Index: /inundation/pymetis/Makefile
===================================================================
--- /inundation/pymetis/Makefile	(revision 2051)
+++ /inundation/pymetis/Makefile	(revision 2051)
@@ -0,0 +1,35 @@
+###
+# PyMetis Makefile
+#
+
+###
+# Config
+#
+
+METIS_DIR = metis-4.0
+
+###
+# Build
+#
+
+pymetis: metis pymetis_module
+
+metis:
+	make -C $(METIS_DIR)
+
+pymetis_module:
+	(cd pymetis; METIS_DIR=$(METIS_DIR) python setup.py build; ./get_module)
+
+###
+# Clean
+#
+
+clean:
+	make -C $(METIS_DIR) clean
+	-(cd pymetis; rm -rf build)
+	-(cd pymetis; rm *~)
+	-rm *~
+
+realclean: clean
+	make -C $(METIS_DIR) realclean
+	-rm metis.so
Index: /inundation/pymetis/metis-4.0/CHANGES
===================================================================
--- /inundation/pymetis/metis-4.0/CHANGES	(revision 2051)
+++ /inundation/pymetis/metis-4.0/CHANGES	(revision 2051)
@@ -0,0 +1,149 @@
+
+METIS 4.0.1, 11/29/98
+------------------------------------------------------------------------------
+This is mostly a bug-fix release
+
+  - Fixed some bugs in the multi-constraint partitioning routines
+  - Fixed some bugs in the volume-minimization routines
+
+
+
+METIS 4.0.0, 9/20/98
+------------------------------------------------------------------------------
+METIS 4.0 contains a number of changes over the previous major release (ver 
+3.0.x). Most of these changes are concentrated on the graph and mesh 
+partitioning routines and they do not affect the sparse matrix re-ordering 
+routines. Here is a list of the major changes:
+
+  Multi-Constraint Partitioning
+  -----------------------------
+  METIS now includes partitioning routines that can be used to a partition
+  a graph in the presence of multiple balancing constraints.
+
+  Minimizing the Total Communication Volume
+  -----------------------------------------
+  METIS now includes partitioning routines whose objective is to minimize
+  the total communication volume (as opposed to minimizing the edge-cut).
+
+  Minimizing the Maximum Connectivity of the Subdomains
+  -----------------------------------------------------
+  The k-way partitioning routines in METIS can now directly minimize the number
+  of adjacent subdomains. For most graphs corresponding to finite element 
+  meshes, METIS is able to significantly reduce the maximum (and total) number of 
+  adjacent subdomains.
+
+
+
+
+METIS 3.0.6, 1/28/98
+-------------------------------------------------------------------------------
+  - Fixed some problems when too many partitions were asked, and each partition
+    end up having 0 vertices
+  - Fixed some bugs in the I/O routines
+  - Added support for the g77 compiler under Linux
+
+
+METIS 3.0.5, 12/22/97
+-------------------------------------------------------------------------------
+  - Fixed problems on 64-bit architectures (eg., -64 option on SGIs).
+  - Added some options in Makefile.in
+
+
+METIS 3.0.4, 12/1/97
+-------------------------------------------------------------------------------
+  Fixed a memory leak in the ordering code.
+
+
+METIS 3.0.3, 11/5/97
+-------------------------------------------------------------------------------
+  This is mostly a bug-fix release with just a few additions
+
+  Added functionality
+    - Added support for quadrilateral elements.
+    - Added a routine METIS_EstimateMemory that estimates the amount of
+      memory that will be allocated by METIS. This is useful in determining
+      if a problem can run on your system.
+    - Added hooks to allow PARMETIS to use the orderings produced by METIS.
+      This is hidden from the user but it will be used in the next release
+      of PARMETIS.
+
+  Bug-fixes
+    - Fixed a bug related to memory allocation. This should somewhat reduce the 
+      overall memory used by METIS.
+    - Fixed some bugs in the 'graphchk' program in the case of weighted graphs.
+    - Removed some code corresponding to unused options.
+    - Fixed some minor bugs in the node-refinement code
+      
+
+
+-------------------------------------------------------------------------------
+METIS 3.0 contains a number of changes over METIS 2.0.
+The major changes are the following:
+
+  General Changes
+  ---------------
+    1.  Added code to directly partition finite element meshes.
+
+    2.  Added code to convert finite element meshes into graphs so they
+        can be used by METIS.
+
+    1.  The names, calling sequences, and options  of the routines in 
+        METISlib have been changed.
+
+    2.  Better support has been added for Fortran programs.
+
+    3.  Eliminated the 'metis' program. The only way to tune METIS's
+        behavior is to use METISlib.
+
+    4.  Improved memory management. METIS should now only abort if truly
+        there is no more memory left in the system.
+
+
+  Graph Partitioning
+  ------------------
+    1.  Added partitioning routines that can be used to compute a partition 
+        with prescribed partition weights. For example, they can be used to 
+        compute a 3-way partition such that partition 1 has 50% of the weight, 
+        partition 2 has 20% of the way, and partition 3 has 30% of the weight. 
+
+    2.  Improved the speed of the k-way partitioning algorithm (kmetis). The
+        new code has better cache locality which dramatically improves the 
+        speed for large graphs. A factor of 4 speedup can be obtained for
+        certain graphs. METIS can now partition a 4 million node graph
+        in well under a minute on a MIPS R10000.
+
+    3.  Eliminated some of the options that were seldom used. 
+  
+
+  Fill-Reducing Orderings
+  ----------------------
+    1.  Added a node based ordering code `onmetis' that greatly improves 
+        ordering quality.
+
+    2.  Improved the quality of the orderings produced by the original
+        edge-based ordering code (it is now called 'oemetis').
+
+    3.  METIS can now analyze the graph and try to compress together 
+        nodes with identical sparsity pattern. For some problems, this 
+        significantly reduces ordering time 
+
+    4.  METIS can now prune dense columns prior to ordering. This can be
+        helpful for LP matrices.
+        
+
+  Mesh Partitioning
+  -----------------
+    1.  METIS can now directly partition the element node array of finite
+        element meshes. It produces two partitioning vectors. One for the
+        elements and one for the nodes. METIS supports the following 
+        elements: triangles, tetrahedra, hexahedra
+
+
+  Mesh-To-Graph Conversion Routines
+  ---------------------------------
+    1.  METIS now includes a number of mesh conversion functions that can 
+        be used to create the dual and nodal graphs directly from the 
+        element connectivity arrays. These are highly optimized routines. 
+
+
+
Index: /inundation/pymetis/metis-4.0/FILES
===================================================================
--- /inundation/pymetis/metis-4.0/FILES	(revision 2051)
+++ /inundation/pymetis/metis-4.0/FILES	(revision 2051)
@@ -0,0 +1,16 @@
+
+The distribution of METIS 4.0 consists of a number of files arranged
+in five directories. The files contained in each directory are as follows:
+
+Doc/		Contains METIS's user manual
+
+Graphs/		Contains some small sample graphs and meshes
+		that can be used with METIS.
+
+Lib/		Contains the code for METIS's library
+
+Programs/	Contains the code for METIS's stand-alone programs
+
+Test/		Contains a comprehensive tester for METIS's partitioning
+                routines.
+
Index: /inundation/pymetis/metis-4.0/Graphs/0README
===================================================================
--- /inundation/pymetis/metis-4.0/Graphs/0README	(revision 2051)
+++ /inundation/pymetis/metis-4.0/Graphs/0README	(revision 2051)
@@ -0,0 +1,81 @@
+
+This file contains two test problems
+
+4elt.graph
+	This is a small graph corresponding to a 2D finite element mesh
+
+test.mgraph
+	This is a very small graph with two vertex weights (multi-constraint)
+
+metis.mesh
+	This is a small 2D mesh (It is a triangulation of 'METIS')
+
+
+You can use them to test the various partitioning, and ordering routines.
+For example try something like
+
+	../kmetis 4elt.graph 40
+	../onmetis 4elt.graph
+	../pmetis test.mgraph 2
+	../kmetis test.mgraph 2
+	../kmetis test.mgraph 5
+	../partnmesh metis.mesh 10
+	../partdmesh metis.mesh 10
+	../mesh2dual metis.mesh
+	../kmetis metis.mesh.dgraph 10
+
+and so on...
+
+
+You can also use the 'mtest' program that tests the various partitioning 
+routines. Here is how the correct output of 'mtest 4elt.graph' should 
+look like.
+
+prompt%: mtest 4elt.graph
+**********************************************************************
+  METIS 4.0   Copyright 1998, Regents of the University of Minnesota
+
+Graph Information ---------------------------------------------------
+  Name: 4elt.graph, #Vertices: 15606, #Edges: 45878
+
+Testing METIS_PartGraphRecursive ------------------------------------
+  [1:ok][2:ok][3:ok][4:ok][5:ok][6:ok]
+
+Testing METIS_WPartGraphRecursive -----------------------------------
+  [1:ok][2:ok][3:ok][4:ok][5:ok][6:ok]
+
+Testing METIS_PartGraphKway -----------------------------------------
+  [1:ok][2:ok][3:ok][4:ok][5:ok][6:ok][7:ok][8:ok]
+
+Testing METIS_WPartGraphKway ----------------------------------------
+  [1:ok][2:ok][3:ok][4:ok][5:ok][6:ok][7:ok][8:ok]
+
+Testing METIS_PartGraphVKway ----------------------------------------
+  [1:ok][2:ok][3:ok][4:ok][5:ok][6:ok][7:ok]
+
+Testing METIS_WPartGraphVKway ---------------------------------------
+  [1:ok][2:ok][3:ok][4:ok][5:ok][6:ok][7:ok]
+
+Testing METIS_mCPartGraphRecursive ----------------------------------
+  [1:ok][2:ok][3:ok][4:ok][5:ok][6:ok][7:ok][8:ok][9:ok][10:ok]
+  [11:ok][12:ok]
+
+Testing METIS_mCPartGraphKway ---------------------------------------
+  [1:ok][2:ok][3:ok][4:ok][5:ok][6:ok][7:ok][8:ok][9:ok][10:ok]
+  [11:ok][12:ok][13:ok][14:ok]
+
+Testing METIS_EdgeND ------------------------------------------------
+  [1:ok][2:ok][3:ok]
+
+Testing METIS_NodeND ------------------------------------------------
+  [1:ok][2:ok][3:ok][4:ok][5:ok][6:ok][7:ok][8:ok][9:ok][10:ok]
+  [11:ok][12:ok][13:ok]
+
+Testing METIS_NodeWND -----------------------------------------------
+  [1:ok][2:ok][3:ok][4:ok][5:ok][6:ok]
+
+---------------------------------------------------------------------
+ Testing completed.
+**********************************************************************
+
+
Index: /inundation/pymetis/metis-4.0/Graphs/4elt.graph
===================================================================
--- /inundation/pymetis/metis-4.0/Graphs/4elt.graph	(revision 2051)
+++ /inundation/pymetis/metis-4.0/Graphs/4elt.graph	(revision 2051)
@@ -0,0 +1,15607 @@
+15606 45878
+ 2 3 6 7 
+ 1 4 6 9 
+ 1 5 7 11 
+ 2 9 12 14 
+ 3 8 11 15 
+ 1 2 7 9 13 
+ 1 3 6 11 13 17 
+ 5 10 15 18 
+ 2 4 6 13 14 19 
+ 8 16 18 21 
+ 3 5 7 15 17 23 24 
+ 4 14 20 26 33 
+ 6 7 9 17 19 22 
+ 4 9 12 19 26 27 
+ 5 8 11 18 24 28 
+ 10 21 25 32 
+ 7 11 13 22 23 31 
+ 8 10 15 21 28 30 
+ 9 13 14 22 27 29 
+ 12 33 45 
+ 10 16 18 30 32 40 
+ 13 17 19 29 31 34 
+ 11 17 24 31 35 36 
+ 11 15 23 28 35 38 
+ 16 32 61 62 
+ 12 14 27 33 39 47 
+ 14 19 26 29 37 39 
+ 15 18 24 30 38 42 
+ 19 22 27 34 37 41 
+ 18 21 28 40 42 51 
+ 17 22 23 34 36 43 44 
+ 16 21 25 40 62 70 
+ 12 20 26 45 47 69 
+ 22 29 31 41 44 46 
+ 23 24 36 38 48 50 
+ 23 31 35 43 48 54 
+ 27 29 39 41 52 53 
+ 24 28 35 42 50 56 
+ 26 27 37 47 53 66 
+ 21 30 32 51 70 76 
+ 29 34 37 46 49 52 
+ 28 30 38 51 56 60 
+ 31 36 44 54 55 63 
+ 31 34 43 46 55 57 
+ 20 33 69 120 
+ 34 41 44 49 57 58 
+ 26 33 39 66 69 91 
+ 35 36 50 54 64 65 
+ 41 46 52 58 59 
+ 35 38 48 56 65 75 
+ 30 40 42 60 76 85 
+ 37 41 49 53 59 67 
+ 37 39 52 66 67 87 
+ 36 43 48 63 64 72 
+ 43 44 57 63 68 73 
+ 38 42 50 60 75 83 
+ 44 46 55 58 68 71 
+ 46 49 57 59 71 74 
+ 49 52 58 67 74 80 
+ 42 51 56 83 85 105 
+ 25 62 150 176 
+ 25 32 61 70 133 150 
+ 43 54 55 72 73 79 84 
+ 48 54 65 72 81 82 
+ 48 50 64 75 81 99 
+ 39 47 53 87 91 113 
+ 52 53 59 80 87 104 
+ 55 57 71 73 77 78 
+ 33 45 47 91 120 168 
+ 32 40 62 76 123 133 
+ 57 58 68 74 77 86 
+ 54 63 64 79 82 88 
+ 55 63 68 78 84 89 
+ 58 59 71 80 86 93 
+ 50 56 65 83 99 108 
+ 40 51 70 85 116 123 
+ 68 71 78 86 90 
+ 68 73 77 89 90 92 
+ 63 72 84 88 94 96 
+ 59 67 74 93 104 125 
+ 64 65 82 99 101 110 
+ 64 72 81 88 97 101 
+ 56 60 75 105 108 132 
+ 63 73 79 89 94 98 
+ 51 60 76 105 116 148 
+ 71 74 77 90 93 100 
+ 53 66 67 104 113 135 
+ 72 79 82 96 97 102 
+ 73 78 84 92 95 98 
+ 77 78 86 92 100 107 
+ 47 66 69 113 168 211 
+ 78 89 90 95 103 107 
+ 74 80 86 100 124 125 
+ 79 84 96 98 109 111 
+ 89 92 98 103 106 
+ 79 88 94 102 111 112 
+ 82 88 101 102 114 
+ 84 89 94 95 106 109 
+ 65 75 81 108 110 131 141 
+ 86 90 93 107 124 127 
+ 81 82 97 110 114 122 
+ 88 96 97 112 114 118 
+ 92 95 106 107 115 121 
+ 67 80 87 125 135 173 
+ 60 83 85 132 148 200 
+ 95 98 103 109 115 117 
+ 90 92 100 103 121 127 130 
+ 75 83 99 132 141 167 
+ 94 98 106 111 117 119 
+ 81 99 101 122 131 137 
+ 94 96 109 112 119 126 
+ 96 102 111 118 126 128 
+ 66 87 91 135 211 270 
+ 97 101 102 118 122 136 
+ 103 106 117 121 129 
+ 76 85 123 148 223 
+ 106 109 115 119 129 134 
+ 102 112 114 128 136 138 
+ 109 111 117 126 134 139 
+ 45 69 168 15200 
+ 103 107 115 129 130 140 
+ 101 110 114 136 137 146 
+ 70 76 116 133 223 5176 
+ 93 100 125 127 175 203 
+ 80 93 104 124 173 203 1438 
+ 111 112 119 128 139 142 143 
+ 100 107 124 130 154 175 
+ 112 118 126 138 142 145 
+ 115 117 121 134 140 144 
+ 107 121 127 140 152 154 
+ 99 110 137 141 161 199 
+ 83 105 108 167 200 410 
+ 62 70 123 150 5176 15053 
+ 117 119 129 139 144 147 
+ 87 104 113 173 252 270 
+ 114 118 122 138 146 149 158 
+ 110 122 131 146 161 165 
+ 118 128 136 145 149 151 
+ 119 126 134 143 147 155 
+ 121 129 130 144 152 159 
+ 99 108 131 167 199 239 
+ 126 128 143 145 156 157 
+ 126 139 142 155 156 160 
+ 129 134 140 147 159 164 
+ 128 138 142 151 153 157 
+ 122 136 137 158 165 174 
+ 134 139 144 155 164 169 
+ 85 105 116 200 223 5408 
+ 136 138 151 158 163 171 
+ 61 62 133 176 15053 15123 
+ 138 145 149 153 162 163 
+ 130 140 154 159 182 190 
+ 145 151 157 162 166 
+ 127 130 152 175 190 226 
+ 139 143 147 160 169 180 
+ 142 143 157 160 170 172 
+ 142 145 153 156 166 170 
+ 136 146 149 171 174 185 
+ 140 144 152 164 182 186 
+ 143 155 156 172 180 181 
+ 131 137 165 199 201 253 
+ 151 153 163 166 177 178 
+ 149 151 162 171 178 184 
+ 144 147 159 169 186 187 
+ 137 146 161 174 201 204 
+ 153 157 162 170 177 179 
+ 108 132 141 239 410 5091 
+ 69 91 120 211 15165 15200 
+ 147 155 164 180 187 193 
+ 156 157 166 172 179 183 
+ 149 158 163 184 185 195 
+ 156 160 170 181 183 188 
+ 104 125 135 252 1438 6142 
+ 146 158 165 185 204 208 
+ 124 127 154 203 226 275 
+ 61 150 15123 
+ 162 166 178 179 189 191 
+ 162 163 177 184 191 194 
+ 166 170 177 183 189 192 
+ 155 160 169 181 193 196 210 
+ 160 172 180 188 196 198 
+ 152 159 186 190 225 244 
+ 170 172 179 188 192 197 
+ 163 171 178 194 195 209 
+ 158 171 174 195 208 216 
+ 159 164 182 187 215 225 
+ 164 169 186 193 215 219 
+ 172 181 183 197 198 207 
+ 177 179 191 192 202 205 
+ 152 154 182 226 244 361 
+ 177 178 189 194 202 206 
+ 179 183 189 197 205 213 
+ 169 180 187 210 219 233 
+ 178 184 191 206 209 214 
+ 171 184 185 209 216 229 
+ 180 181 198 210 221 231 
+ 183 188 192 207 213 218 
+ 181 188 196 207 220 221 
+ 131 141 161 239 253 4560 4672 
+ 105 132 148 410 5408 7666 
+ 161 165 204 253 295 460 
+ 189 191 205 206 212 217 
+ 124 125 175 275 1438 4201 
+ 165 174 201 208 293 295 
+ 189 192 202 212 213 222 
+ 191 194 202 214 217 224 
+ 188 197 198 218 220 230 
+ 174 185 204 216 268 293 
+ 184 194 195 214 229 235 246 
+ 180 193 196 231 233 249 
+ 91 113 168 270 15098 15165 
+ 202 205 217 222 227 
+ 192 197 205 218 222 234 243 
+ 194 206 209 224 232 235 
+ 186 187 219 225 245 264 
+ 185 195 208 229 263 268 
+ 202 206 212 224 227 228 
+ 197 207 213 230 234 238 
+ 187 193 215 233 245 262 
+ 198 207 221 230 237 240 
+ 196 198 220 231 240 247 
+ 205 212 213 227 242 243 
+ 116 123 148 5176 5408 15071 
+ 206 214 217 228 232 236 
+ 182 186 215 244 264 312 
+ 154 175 190 275 361 2535 
+ 212 217 222 228 241 242 
+ 217 224 227 236 241 
+ 195 209 216 246 263 277 
+ 207 218 220 237 238 248 
+ 196 210 221 247 249 267 
+ 214 224 235 236 250 255 
+ 193 210 219 249 262 284 
+ 213 218 238 243 254 256 
+ 209 214 232 246 255 265 
+ 224 228 232 241 250 251 
+ 220 230 240 248 259 
+ 218 230 234 248 256 261 
+ 141 167 199 4560 5091 6408 
+ 220 221 237 247 259 266 
+ 227 228 236 242 251 257 
+ 222 227 241 243 257 258 
+ 213 222 234 242 254 258 260 
+ 182 190 225 312 361 4557 
+ 215 219 262 264 302 
+ 209 229 235 265 277 296 
+ 221 231 240 266 267 287 
+ 230 237 238 259 261 279 
+ 210 231 233 267 284 301 
+ 232 236 251 255 272 280 
+ 236 241 250 257 269 272 
+ 135 173 270 6142 12330 
+ 161 199 201 460 4672 4995 
+ 234 243 256 260 271 274 
+ 232 235 250 265 280 290 
+ 234 238 254 261 271 273 
+ 241 242 251 258 269 276 
+ 242 243 257 260 276 278 
+ 237 240 248 266 279 282 
+ 243 254 258 274 278 289 
+ 238 248 256 273 279 283 
+ 219 233 245 284 302 446 
+ 216 229 268 277 307 372 
+ 215 225 245 302 312 894 
+ 235 246 255 290 296 316 
+ 240 247 259 282 287 313 
+ 231 247 249 287 301 338 
+ 208 216 263 293 372 1146 
+ 251 257 272 276 286 291 
+ 113 135 211 252 12330 15098 
+ 254 256 273 274 281 285 
+ 250 251 269 280 286 297 
+ 256 261 271 281 283 288 
+ 254 260 271 285 289 298 
+ 175 203 226 2535 4201 5293 
+ 257 258 269 278 291 292 
+ 229 246 263 296 307 348 
+ 258 260 276 289 292 304 
+ 248 259 261 282 283 311 314 
+ 250 255 272 290 297 324 
+ 271 273 285 288 294 
+ 259 266 279 313 314 346 
+ 261 273 279 288 306 310 311 
+ 233 249 262 301 446 1168 
+ 271 274 281 294 298 299 
+ 269 272 291 297 317 
+ 247 266 267 313 338 396 
+ 273 281 283 294 300 305 306 308 
+ 260 274 278 298 304 323 329 
+ 255 265 280 316 324 544 
+ 269 276 286 292 317 328 
+ 276 278 291 304 327 328 
+ 204 208 268 295 1146 2565 3697 
+ 281 285 288 299 300 303 
+ 201 204 293 460 2565 3878 
+ 246 265 277 316 348 527 
+ 272 280 286 317 324 370 
+ 274 285 289 299 319 323 337 
+ 285 294 298 303 315 319 
+ 288 294 303 305 309 
+ 249 267 284 338 882 1168 
+ 245 262 264 446 894 1987 
+ 294 299 300 309 315 318 
+ 278 289 292 327 329 344 
+ 288 300 308 309 320 
+ 283 288 308 310 321 331 
+ 263 277 348 372 612 
+ 288 305 306 320 321 
+ 300 303 305 318 320 322 
+ 283 306 311 331 342 
+ 279 283 310 314 342 353 
+ 225 244 264 894 4557 4780 
+ 266 282 287 346 396 621 
+ 279 282 311 346 353 435 
+ 299 303 318 319 325 
+ 265 290 296 527 544 813 
+ 286 291 297 328 370 428 
+ 303 309 315 322 325 326 
+ 298 299 315 325 333 337 341 
+ 305 308 309 321 322 330 332 
+ 306 308 320 331 332 336 
+ 309 318 320 326 330 334 
+ 289 298 329 337 355 356 375 
+ 280 290 297 370 544 797 
+ 315 318 319 326 333 335 
+ 318 322 325 334 335 339 
+ 292 304 328 344 397 520 
+ 291 292 317 327 428 520 
+ 289 304 323 344 355 367 
+ 320 322 332 334 340 343 
+ 306 310 321 336 342 358 368 
+ 320 321 330 336 340 350 
+ 319 325 335 341 349 351 
+ 322 326 330 339 343 347 
+ 325 326 333 339 345 349 
+ 321 331 332 350 358 363 
+ 298 319 323 341 356 366 374 
+ 267 287 301 396 882 1028 
+ 326 334 335 345 347 352 
+ 330 332 343 350 357 
+ 319 333 337 351 364 366 
+ 310 311 331 353 368 458 466 
+ 330 334 340 347 357 362 
+ 304 327 329 367 397 418 
+ 335 339 349 352 354 
+ 282 313 314 435 621 956 
+ 334 339 343 352 359 362 
+ 277 296 307 527 612 1264 
+ 333 335 345 351 354 360 
+ 332 336 340 357 363 371 
+ 333 341 349 360 364 369 
+ 339 345 347 354 359 365 
+ 311 314 342 435 458 656 
+ 345 349 352 360 365 373 
+ 323 329 367 375 409 
+ 323 337 374 375 390 405 411 
+ 340 343 350 362 371 381 382 
+ 331 336 363 368 392 393 
+ 347 352 362 365 377 378 
+ 349 351 354 369 373 376 
+ 190 226 244 2535 4557 5550 
+ 343 347 357 359 377 380 381 
+ 336 350 358 371 387 393 
+ 341 351 366 369 385 386 
+ 352 354 359 373 378 379 
+ 337 341 364 374 386 404 408 413 
+ 329 344 355 409 418 450 
+ 331 342 358 392 453 466 
+ 351 360 364 376 383 385 
+ 297 317 324 428 797 809 
+ 350 357 363 382 387 389 
+ 263 268 307 612 1146 2062 
+ 354 360 365 376 379 384 
+ 337 356 366 404 411 414 
+ 323 355 356 390 409 419 
+ 360 369 373 383 384 388 
+ 359 362 378 380 391 400 
+ 359 365 377 379 394 400 
+ 365 373 378 384 394 398 
+ 362 377 381 391 395 
+ 357 362 380 382 395 401 
+ 357 371 381 389 401 406 
+ 369 376 385 388 399 403 
+ 373 376 379 388 398 402 
+ 364 369 383 386 403 421 
+ 364 366 385 413 421 424 
+ 363 371 389 393 412 416 
+ 376 383 384 399 402 
+ 371 382 387 406 416 427 
+ 356 375 405 419 451 
+ 377 380 395 400 407 417 
+ 358 368 393 437 453 470 
+ 358 363 387 392 412 429 437 
+ 378 379 398 400 415 423 
+ 380 381 391 401 407 422 
+ 287 313 338 621 1028 1249 
+ 327 344 418 520 680 721 
+ 379 384 394 402 415 420 
+ 383 388 402 403 425 426 
+ 377 378 391 394 417 423 432 
+ 381 382 395 406 422 430 
+ 384 388 398 399 420 425 
+ 383 385 399 421 426 433 
+ 366 374 408 414 436 439 
+ 356 390 411 447 451 
+ 382 389 401 427 430 445 
+ 391 395 417 422 434 
+ 366 404 413 431 436 
+ 355 367 375 419 450 494 507 
+ 132 167 200 5091 7666 13608 
+ 356 374 405 414 447 457 
+ 387 393 416 429 444 
+ 366 386 408 424 431 438 
+ 374 404 411 439 457 464 
+ 394 398 420 423 440 441 
+ 387 389 412 427 444 459 
+ 391 400 407 432 434 448 
+ 344 367 397 450 598 680 
+ 375 390 409 451 478 494 
+ 398 402 415 425 441 442 
+ 385 386 403 424 433 454 456 
+ 395 401 407 430 434 452 
+ 394 400 415 432 440 449 
+ 386 413 421 438 454 463 
+ 399 402 420 426 442 443 
+ 399 403 425 433 443 455 
+ 389 406 416 445 459 474 
+ 317 328 370 520 809 870 
+ 393 412 437 444 479 
+ 401 406 422 445 452 473 
+ 408 413 436 438 461 
+ 400 417 423 448 449 462 
+ 403 421 426 455 456 472 
+ 407 417 422 448 452 465 
+ 314 346 353 656 908 956 
+ 404 408 431 439 461 477 
+ 392 393 429 470 479 508 
+ 413 424 431 461 463 476 
+ 404 414 436 464 477 487 
+ 415 423 441 449 468 471 
+ 415 420 440 442 467 468 
+ 420 425 441 443 467 469 
+ 425 426 442 455 469 475 
+ 412 416 429 459 479 490 
+ 406 427 430 473 474 496 
+ 262 284 302 1168 1987 3287 
+ 405 411 451 457 501 505 
+ 417 432 434 462 465 481 
+ 423 432 440 462 471 480 
+ 367 409 418 507 588 598 
+ 390 405 419 447 478 505 517 
+ 422 430 434 465 473 483 
+ 368 392 466 470 545 553 
+ 421 424 456 463 482 484 
+ 426 433 443 472 475 485 
+ 421 433 454 472 482 492 
+ 411 414 447 464 500 501 
+ 342 353 466 550 607 656 690 
+ 416 427 444 474 490 506 
+ 201 253 295 3878 4995 5317 
+ 431 436 438 476 477 486 
+ 432 448 449 480 481 495 
+ 424 438 454 476 484 493 
+ 414 439 457 487 500 518 
+ 434 448 452 481 483 499 
+ 342 368 453 458 550 553 
+ 441 442 468 469 488 489 
+ 440 441 467 471 489 491 
+ 442 443 467 475 488 497 
+ 392 437 453 508 545 559 
+ 440 449 468 480 491 498 
+ 433 455 456 485 492 504 
+ 430 445 452 483 496 525 
+ 427 445 459 496 506 526 
+ 443 455 469 485 497 503 
+ 438 461 463 486 493 502 
+ 436 439 461 486 487 511 
+ 419 451 494 517 557 
+ 429 437 444 490 508 536 
+ 449 462 471 495 498 509 
+ 448 462 465 495 499 510 
+ 454 456 484 492 515 522 
+ 452 465 473 499 525 532 
+ 454 463 482 493 515 519 
+ 455 472 475 503 504 523 
+ 461 476 477 502 511 528 
+ 439 464 477 511 518 533 
+ 467 469 489 497 512 516 
+ 467 468 488 491 512 513 
+ 444 459 479 506 536 542 
+ 468 471 489 498 513 521 
+ 456 472 482 504 522 530 
+ 463 476 484 502 514 519 
+ 409 419 478 507 557 587 
+ 462 480 481 509 510 529 
+ 445 473 474 525 526 547 
+ 469 475 488 503 516 524 
+ 471 480 491 509 521 531 
+ 465 481 483 510 532 538 
+ 457 464 501 518 552 554 
+ 447 457 500 505 548 552 
+ 476 486 493 514 528 535 
+ 475 485 497 523 524 534 
+ 472 485 492 523 530 537 
+ 447 451 501 517 548 561 
+ 459 474 490 526 542 560 
+ 409 450 494 587 588 641 
+ 437 470 479 536 559 578 
+ 480 495 498 529 531 539 
+ 481 495 499 529 538 546 
+ 477 486 487 528 533 555 565 
+ 488 489 513 516 
+ 489 491 512 521 
+ 493 502 519 535 540 
+ 482 484 519 522 541 543 
+ 488 497 512 524 
+ 451 478 505 557 561 590 
+ 464 487 500 533 554 564 
+ 484 493 514 515 540 541 
+ 327 328 397 428 721 870 920 
+ 491 498 513 531 
+ 482 492 515 530 543 551 
+ 485 503 504 534 537 549 
+ 497 503 516 534 
+ 473 483 496 532 547 563 574 
+ 474 496 506 547 560 576 
+ 296 316 348 813 1264 15299 
+ 486 502 511 535 555 15286 
+ 495 509 510 539 546 556 
+ 492 504 522 537 551 558 
+ 498 509 521 539 
+ 483 499 525 538 563 566 
+ 487 511 518 564 565 570 
+ 503 523 524 549 
+ 502 514 528 540 562 15286 
+ 479 490 508 542 578 591 
+ 504 523 530 549 558 567 
+ 499 510 532 546 566 569 
+ 509 529 531 556 
+ 514 519 535 541 562 568 
+ 515 519 540 543 568 571 
+ 490 506 536 560 581 591 
+ 515 522 541 551 571 572 
+ 290 316 324 797 813 1495 1656 
+ 453 470 553 559 633 635 
+ 510 529 538 556 569 573 
+ 496 525 526 574 576 599 
+ 501 505 552 561 583 597 
+ 523 534 537 567 
+ 458 466 553 607 642 
+ 522 530 543 558 572 575 
+ 500 501 548 554 577 583 
+ 453 466 545 550 635 642 
+ 500 518 552 564 577 585 600 
+ 511 528 565 580 584 15286 
+ 529 539 546 573 
+ 478 494 517 587 590 650 
+ 530 537 551 567 575 579 
+ 470 508 545 578 633 645 
+ 506 526 542 576 581 604 
+ 505 517 548 590 597 623 
+ 535 540 568 582 586 15286 
+ 525 532 566 574 594 605 
+ 518 533 554 570 585 602 
+ 511 533 555 570 584 592 
+ 532 538 563 569 593 594 
+ 537 549 558 579 
+ 540 541 562 571 586 589 
+ 538 546 566 573 593 596 
+ 533 564 565 592 602 
+ 541 543 568 572 589 595 
+ 543 551 571 575 595 601 
+ 546 556 569 596 
+ 525 547 563 599 605 622 
+ 551 558 572 579 601 603 
+ 526 547 560 599 604 615 
+ 552 554 583 600 606 
+ 508 536 559 591 644 645 
+ 558 567 575 603 
+ 555 582 584 608 610 15286 
+ 542 560 591 604 629 
+ 562 580 586 608 611 15286 
+ 548 552 577 597 606 618 
+ 555 565 580 592 610 614 
+ 554 564 600 602 626 627 
+ 562 568 582 589 611 613 
+ 494 507 557 641 650 672 
+ 450 507 598 641 674 696 
+ 568 571 586 595 613 616 
+ 517 557 561 623 650 673 
+ 536 542 578 581 629 644 
+ 565 570 584 602 609 614 
+ 566 569 594 596 617 619 
+ 563 566 593 605 619 628 
+ 571 572 589 601 616 620 
+ 569 573 593 617 
+ 548 561 583 618 623 634 
+ 418 450 588 680 696 753 
+ 547 574 576 615 622 625 
+ 554 577 585 606 627 631 
+ 572 575 595 603 620 624 
+ 564 570 585 592 609 626 632 
+ 575 579 601 624 
+ 560 576 581 615 629 653 
+ 563 574 594 622 628 648 
+ 577 583 600 618 630 631 
+ 458 550 642 690 714 
+ 580 582 610 611 636 638 
+ 592 602 614 632 637 
+ 580 584 608 614 638 640 
+ 582 586 608 613 636 639 
+ 307 348 372 1264 2062 2078 
+ 586 589 611 616 639 643 
+ 584 592 609 610 637 640 
+ 576 599 604 625 653 654 
+ 589 595 613 620 643 646 
+ 593 596 619 647 
+ 583 597 606 630 634 651 
+ 593 594 617 628 647 652 
+ 595 601 616 624 646 649 
+ 313 346 396 956 1249 1576 
+ 574 599 605 625 648 655 
+ 561 590 597 634 667 673 
+ 601 603 620 649 
+ 599 615 622 654 655 
+ 585 602 627 632 658 669 
+ 585 600 626 631 659 669 
+ 594 605 619 648 652 665 
+ 581 591 604 644 653 679 
+ 606 618 631 651 657 
+ 600 606 627 630 657 659 
+ 602 609 626 637 658 660 
+ 545 559 635 645 713 715 
+ 597 618 623 651 667 668 
+ 545 553 633 642 713 717 
+ 608 611 638 639 661 662 
+ 609 614 632 640 660 15287 
+ 608 610 636 640 662 664 
+ 611 613 636 643 661 663 
+ 610 614 637 638 664 15287 
+ 507 587 588 672 674 700 
+ 550 553 607 635 714 717 
+ 613 616 639 646 663 666 
+ 578 591 629 645 679 724 
+ 559 578 633 644 715 724 
+ 616 620 643 649 666 670 
+ 617 619 652 671 
+ 605 622 628 655 665 676 
+ 620 624 646 670 
+ 557 587 590 672 673 719 728 
+ 618 630 634 657 668 675 
+ 619 628 647 665 671 677 
+ 604 615 629 654 679 699 
+ 615 625 653 655 685 699 
+ 622 625 648 654 676 685 
+ 353 435 458 690 848 908 1013 
+ 630 631 651 659 675 678 
+ 626 632 660 669 681 691 
+ 627 631 657 669 678 688 
+ 632 637 658 681 682 15287 
+ 636 639 662 663 683 15288 
+ 636 638 661 664 687 15288 
+ 639 643 661 666 683 684 
+ 638 640 662 686 687 15287 
+ 628 648 652 676 677 693 
+ 643 646 663 670 684 689 
+ 623 634 668 673 695 720 
+ 634 651 667 675 695 15289 
+ 626 627 658 659 688 691 697 
+ 646 649 666 689 
+ 647 652 677 692 
+ 587 641 650 700 728 748 
+ 590 623 650 667 719 720 739 
+ 588 641 696 700 743 
+ 651 657 668 678 694 15289 
+ 648 655 665 685 693 704 
+ 652 665 671 692 693 701 
+ 657 659 675 688 694 698 
+ 629 644 653 699 724 752 
+ 397 418 598 721 753 837 949 
+ 658 660 682 691 708 712 
+ 660 681 686 707 708 15287 
+ 661 663 684 702 703 15288 
+ 663 666 683 689 702 705 
+ 654 655 676 699 704 730 
+ 664 682 687 707 709 15287 
+ 662 664 686 706 709 15288 
+ 659 669 678 697 698 710 
+ 666 670 684 705 
+ 458 607 656 714 802 848 
+ 658 669 681 697 712 718 
+ 671 677 701 15290 
+ 665 676 677 701 704 723 
+ 675 678 698 711 716 15289 
+ 667 668 711 720 726 15289 
+ 588 598 674 743 753 783 
+ 669 688 691 710 718 725 
+ 678 688 694 710 716 722 
+ 653 654 679 685 730 752 771 
+ 641 672 674 743 748 759 
+ 677 692 693 723 736 15290 
+ 683 684 703 705 729 731 
+ 683 702 706 729 732 15288 
+ 676 685 693 723 730 747 
+ 684 689 702 731 
+ 687 703 709 732 733 15288 
+ 682 686 708 709 734 735 
+ 681 682 707 712 735 738 
+ 686 687 706 707 733 734 
+ 688 697 698 722 725 727 
+ 694 695 716 726 737 15289 
+ 681 691 708 718 738 741 
+ 633 635 715 717 788 795 
+ 607 642 690 717 796 802 
+ 633 645 713 724 795 815 
+ 694 698 711 722 737 740 
+ 635 642 713 714 788 796 
+ 691 697 712 725 741 745 
+ 650 673 728 739 774 777 
+ 667 673 695 726 739 761 769 
+ 397 520 680 920 949 1104 
+ 698 710 716 727 740 742 
+ 693 701 704 736 747 757 
+ 644 645 679 715 752 815 860 
+ 697 710 718 727 745 746 
+ 695 711 720 737 749 761 
+ 710 722 725 742 746 
+ 650 672 719 748 777 794 
+ 702 703 731 732 750 751 
+ 685 699 704 747 771 780 
+ 702 705 729 750 
+ 703 706 729 733 751 754 
+ 706 709 732 734 754 755 
+ 707 709 733 735 755 758 
+ 707 708 734 738 758 760 
+ 701 723 744 757 764 15290 
+ 711 716 726 740 749 756 
+ 708 712 735 741 760 763 
+ 673 719 720 769 774 790 
+ 716 722 737 742 756 762 
+ 712 718 738 745 763 766 
+ 722 727 740 746 762 765 
+ 674 696 700 759 783 805 
+ 736 764 768 15290 
+ 718 725 741 746 766 767 
+ 725 727 742 745 765 767 
+ 704 723 730 757 780 789 
+ 672 700 728 759 794 804 
+ 726 737 756 761 770 
+ 729 731 751 772 
+ 729 732 750 754 772 773 
+ 679 699 724 771 845 860 
+ 598 680 696 783 837 864 
+ 732 733 751 755 773 775 
+ 733 734 754 758 775 776 
+ 737 740 749 762 770 779 
+ 723 736 747 764 789 792 
+ 734 735 755 760 776 778 
+ 700 743 748 804 805 
+ 735 738 758 763 778 781 
+ 720 726 749 769 770 784 
+ 740 742 756 765 779 782 
+ 738 741 760 766 781 786 
+ 736 744 757 768 792 793 
+ 742 746 762 767 782 785 
+ 741 745 763 767 786 787 
+ 745 746 765 766 785 787 
+ 744 764 791 793 
+ 720 739 761 784 790 817 
+ 749 756 761 779 784 801 
+ 699 730 752 780 839 845 
+ 750 751 773 798 
+ 751 754 772 775 798 799 
+ 719 739 777 790 820 824 
+ 754 755 773 776 799 800 
+ 755 758 775 778 800 803 
+ 719 728 774 794 820 829 
+ 758 760 776 781 803 806 
+ 756 762 770 782 801 807 
+ 730 747 771 789 831 839 
+ 760 763 778 786 806 808 
+ 762 765 779 785 807 810 
+ 696 743 753 805 864 867 
+ 761 769 770 801 817 822 
+ 765 767 782 787 810 811 
+ 763 766 781 787 808 812 
+ 766 767 785 786 811 812 
+ 713 717 795 796 840 869 
+ 747 757 780 792 825 831 
+ 739 769 774 817 824 828 
+ 768 793 814 816 
+ 757 764 789 793 818 825 
+ 764 768 791 792 816 818 
+ 728 748 777 804 829 841 
+ 713 715 788 815 840 876 
+ 714 717 788 802 869 916 
+ 324 370 544 809 1495 1882 15297 
+ 772 773 799 819 
+ 773 775 798 800 819 821 
+ 775 776 799 803 821 823 
+ 770 779 784 807 822 832 
+ 690 714 796 848 916 987 
+ 776 778 800 806 823 826 
+ 748 759 794 805 841 862 
+ 743 759 783 804 862 867 
+ 778 781 803 808 826 830 
+ 779 782 801 810 832 836 
+ 781 786 806 812 830 833 
+ 370 428 797 870 1443 15297 
+ 782 785 807 811 835 836 
+ 785 787 810 812 834 835 
+ 786 787 808 811 833 834 
+ 316 527 544 1656 2019 15299 
+ 791 816 827 838 
+ 715 724 795 860 876 923 
+ 791 793 814 818 838 843 
+ 769 784 790 822 828 854 15291 
+ 792 793 816 825 843 851 
+ 798 799 821 844 
+ 774 777 824 829 859 865 
+ 799 800 819 823 844 846 
+ 784 801 817 832 854 855 
+ 800 803 821 826 846 847 
+ 774 790 820 828 859 863 
+ 789 792 818 831 851 866 
+ 803 806 823 830 847 849 
+ 814 838 842 853 
+ 790 817 824 863 15291 
+ 777 794 820 841 865 877 
+ 806 808 826 833 849 850 
+ 780 789 825 839 866 883 
+ 801 807 822 836 855 858 
+ 808 812 830 834 850 852 
+ 811 812 833 835 852 856 
+ 810 811 834 836 856 857 
+ 807 810 832 835 857 858 
+ 680 753 864 949 994 
+ 814 816 827 843 853 868 
+ 771 780 831 845 883 909 
+ 788 795 869 876 922 
+ 794 804 829 862 877 891 
+ 827 853 861 873 
+ 816 818 838 851 868 879 
+ 819 821 846 871 
+ 752 771 839 860 909 954 
+ 821 823 844 847 871 872 
+ 823 826 846 849 872 874 
+ 656 690 802 987 1013 1149 
+ 826 830 847 850 874 878 
+ 830 833 849 852 878 880 
+ 818 825 843 866 879 892 
+ 833 834 850 856 880 881 
+ 827 838 842 868 873 887 
+ 817 822 855 888 901 15291 
+ 822 832 854 858 886 888 
+ 834 835 852 857 881 884 
+ 835 836 856 858 884 885 
+ 832 836 855 857 885 886 
+ 820 824 863 865 897 898 
+ 724 752 815 845 923 954 1043 
+ 842 873 875 889 
+ 804 805 841 867 891 948 
+ 824 828 859 897 902 15291 
+ 753 783 837 867 994 15292 
+ 820 829 859 877 895 898 
+ 825 831 851 883 892 913 
+ 783 805 862 864 948 15292 
+ 838 843 853 879 887 899 
+ 788 796 840 916 922 974 
+ 428 520 809 920 1408 1443 
+ 844 846 872 893 
+ 846 847 871 874 893 896 
+ 842 853 861 887 889 903 
+ 847 849 872 878 896 900 
+ 861 889 890 906 
+ 795 815 840 922 923 975 
+ 829 841 865 891 895 928 
+ 849 850 874 880 900 904 
+ 843 851 868 892 899 914 
+ 850 852 878 881 904 907 
+ 852 856 880 884 907 910 
+ 301 338 1028 1168 2171 2700 
+ 831 839 866 909 913 945 
+ 856 857 881 885 910 911 
+ 857 858 884 886 911 912 
+ 855 858 885 888 912 915 
+ 853 868 873 899 903 917 
+ 854 855 886 901 915 927 
+ 861 873 875 903 906 919 
+ 875 905 906 921 
+ 841 862 877 928 948 965 
+ 851 866 879 913 914 935 
+ 871 872 896 924 
+ 264 302 312 1987 4780 4973 
+ 865 877 898 928 934 
+ 872 874 893 900 924 925 
+ 859 863 898 902 939 941 
+ 859 865 895 897 934 941 
+ 868 879 887 914 917 932 
+ 874 878 896 904 925 929 
+ 854 888 926 927 944 15291 
+ 863 897 926 933 939 15291 
+ 873 887 889 917 919 937 
+ 878 880 900 907 929 930 
+ 890 918 921 938 
+ 875 889 890 919 921 940 
+ 880 881 904 910 930 936 
+ 435 656 956 1013 1439 1544 
+ 839 845 883 945 954 1000 
+ 881 884 907 911 936 942 
+ 884 885 910 912 942 943 
+ 885 886 911 915 943 946 
+ 866 883 892 935 945 964 
+ 879 892 899 932 935 950 
+ 886 888 912 927 946 955 
+ 796 802 869 974 987 1067 
+ 887 899 903 932 937 951 
+ 905 931 938 952 
+ 889 903 906 937 940 957 
+ 520 721 870 1104 1375 1408 
+ 890 905 906 938 940 958 
+ 840 869 876 974 975 993 
+ 815 860 876 975 1043 1053 
+ 893 896 925 953 
+ 896 900 924 929 953 959 
+ 901 902 933 944 960 15291 
+ 888 901 915 944 955 966 
+ 877 891 895 934 965 979 
+ 900 904 925 930 959 961 
+ 904 907 929 936 961 963 
+ 918 947 952 968 
+ 899 914 917 950 951 967 
+ 902 926 939 960 976 
+ 895 898 928 941 978 979 
+ 892 913 914 950 964 970 
+ 907 910 930 942 963 969 
+ 903 917 919 951 957 972 
+ 905 918 921 952 958 973 
+ 897 902 933 941 976 981 
+ 906 919 921 957 958 977 
+ 897 898 934 939 978 981 
+ 910 911 936 943 969 971 
+ 911 912 942 946 971 980 
+ 901 926 927 960 966 982 
+ 883 909 913 964 1000 1011 
+ 912 915 943 955 980 985 
+ 931 962 968 986 
+ 862 867 891 965 1034 1072 15292 
+ 680 721 837 994 1104 1143 1275 
+ 914 932 935 967 970 983 
+ 917 932 937 967 972 990 
+ 918 931 938 968 973 992 
+ 924 925 959 988 
+ 845 860 909 1000 1043 1088 
+ 915 927 946 966 985 995 
+ 346 435 621 908 1544 1576 1895 
+ 919 937 940 972 977 998 
+ 921 938 940 973 977 997 
+ 925 929 953 961 988 989 
+ 926 933 944 976 982 991 
+ 929 930 959 963 989 996 
+ 947 984 986 1001 
+ 930 936 961 969 996 999 
+ 913 935 945 970 1008 1011 
+ 891 928 948 979 1027 1034 
+ 927 944 955 982 995 1004 
+ 932 950 951 983 990 1003 
+ 931 947 952 986 992 1007 
+ 936 942 963 971 999 1005 
+ 935 950 964 983 1008 1009 
+ 942 943 969 980 1005 1010 
+ 937 951 957 990 998 1017 
+ 938 952 958 992 997 1012 
+ 869 916 922 993 1067 1074 
+ 876 922 923 993 1053 1071 
+ 933 939 960 981 991 1021 1025 
+ 940 957 958 997 998 1022 
+ 934 941 979 981 1018 1020 
+ 928 934 965 978 1020 1027 
+ 943 946 971 985 1010 1014 
+ 939 941 976 978 1018 1025 
+ 944 960 966 991 1004 1006 
+ 950 967 970 1003 1009 
+ 962 1001 1002 1015 
+ 946 955 980 995 1014 1023 
+ 947 962 968 1001 1007 1016 
+ 802 848 916 1067 1149 1200 
+ 953 959 989 1019 
+ 959 961 988 996 1019 1026 
+ 951 967 972 1003 1017 1038 
+ 960 976 982 1006 1021 1030 
+ 952 968 973 1007 1012 1029 
+ 922 974 975 1071 1074 
+ 837 864 949 1143 1170 15292 
+ 955 966 985 1004 1023 1032 
+ 961 963 989 999 1026 1031 
+ 958 973 977 1012 1022 1041 
+ 957 972 977 1017 1022 1048 
+ 963 969 996 1005 1031 1035 
+ 909 945 954 1011 1073 1088 
+ 962 984 986 1015 1016 1036 
+ 984 1015 1024 1039 
+ 967 983 990 1009 1038 1040 
+ 966 982 995 1006 1032 1033 
+ 969 971 999 1010 1035 1042 
+ 982 991 1004 1030 1033 
+ 968 986 992 1016 1029 1037 
+ 964 970 1009 1011 1044 1054 
+ 970 983 1003 1008 1040 1044 
+ 971 980 1005 1014 1042 1045 
+ 945 964 1000 1008 1054 1073 
+ 973 992 997 1029 1041 1047 
+ 656 848 908 1149 1433 1439 
+ 980 985 1010 1023 1045 1051 
+ 984 1001 1002 1036 1039 1052 
+ 986 1001 1007 1036 1037 1050 
+ 972 990 998 1038 1048 1086 
+ 978 981 1020 1025 1049 1060 
+ 988 989 1026 1055 
+ 978 979 1018 1027 1049 1078 
+ 976 991 1025 1030 1061 1075 
+ 977 997 998 1041 1048 1069 
+ 985 995 1014 1032 1051 1057 
+ 1002 1039 1046 1059 
+ 976 981 1018 1021 1060 1075 
+ 989 996 1019 1031 1055 1058 
+ 965 979 1020 1034 1078 1121 
+ 338 396 882 1249 2073 2171 
+ 992 1007 1012 1037 1047 1056 
+ 991 1006 1021 1033 1061 1062 
+ 996 999 1026 1035 1058 1064 
+ 995 1004 1023 1033 1057 1063 
+ 1004 1006 1030 1032 1062 1063 
+ 948 965 1027 1072 1121 1165 
+ 999 1005 1031 1042 1064 15293 
+ 1001 1015 1016 1050 1052 1065 
+ 1007 1016 1029 1050 1056 1066 
+ 990 1003 1017 1040 1086 1090 
+ 1002 1015 1024 1052 1059 1070 
+ 1003 1009 1038 1044 1080 1090 
+ 997 1012 1022 1047 1069 1077 
+ 1005 1010 1035 1045 1076 15293 
+ 860 923 954 1053 1088 1159 1204 
+ 1008 1009 1040 1054 1080 1085 
+ 1010 1014 1042 1051 1076 1082 
+ 1024 1059 1068 1083 
+ 1012 1029 1041 1056 1077 1079 
+ 998 1017 1022 1069 1086 1114 
+ 1018 1020 1060 1078 1100 
+ 1016 1036 1037 1065 1066 1081 
+ 1014 1023 1045 1057 1082 1089 
+ 1015 1036 1039 1065 1070 1087 
+ 923 975 1043 1071 1159 1179 
+ 1008 1011 1044 1073 1085 1112 
+ 1019 1026 1058 1091 
+ 1029 1037 1047 1066 1079 1084 
+ 1023 1032 1051 1063 1089 1092 
+ 1026 1031 1055 1064 1091 1094 
+ 1024 1039 1046 1070 1083 1095 
+ 1018 1025 1049 1075 1100 1110 
+ 1021 1030 1062 1075 1098 1108 
+ 1030 1033 1061 1063 1096 1098 
+ 1032 1033 1057 1062 1092 1096 
+ 1031 1035 1058 1094 1101 15293 
+ 1036 1050 1052 1081 1087 1099 
+ 1037 1050 1056 1081 1084 1093 
+ 916 974 987 1074 1200 1240 
+ 1046 1083 1097 1109 
+ 1022 1041 1048 1077 1114 1115 
+ 1039 1052 1059 1087 1095 1107 
+ 975 993 1053 1074 1162 1179 
+ 948 1034 1165 1170 1236 15292 
+ 1000 1011 1054 1088 1112 1183 
+ 974 993 1067 1071 1162 1240 
+ 1021 1025 1060 1061 1108 1110 1129 
+ 1042 1045 1082 1106 1113 15293 
+ 1041 1047 1069 1079 1103 1115 
+ 1020 1027 1049 1100 1121 1135 
+ 1047 1056 1077 1084 1102 1103 
+ 1040 1044 1085 1090 1117 1130 
+ 1050 1065 1066 1093 1099 1111 
+ 1045 1051 1076 1089 1113 1119 
+ 1046 1059 1068 1095 1109 1120 
+ 1056 1066 1079 1093 1102 1105 
+ 1044 1054 1080 1112 1117 
+ 1017 1038 1048 1090 1114 1137 1147 
+ 1052 1065 1070 1099 1107 1116 
+ 954 1000 1043 1073 1183 1204 1226 
+ 1051 1057 1082 1092 1119 1123 
+ 1038 1040 1080 1086 1130 1137 
+ 1055 1058 1094 1124 
+ 1057 1063 1089 1096 1123 1127 
+ 1066 1081 1084 1105 1111 1118 
+ 1058 1064 1091 1101 1124 1132 
+ 1059 1070 1083 1107 1120 1131 
+ 1062 1063 1092 1098 1127 1133 
+ 1068 1109 1122 1136 
+ 1061 1062 1096 1108 1133 1141 
+ 1065 1081 1087 1111 1116 1128 
+ 1049 1060 1078 1110 1134 1135 
+ 1064 1094 1106 1132 1139 15293 
+ 1079 1084 1103 1105 1125 1126 
+ 1077 1079 1102 1115 1125 1138 
+ 721 920 949 1275 1375 1471 
+ 1084 1093 1102 1118 1126 
+ 1076 1101 1113 1139 1144 15293 
+ 1070 1087 1095 1116 1131 1142 
+ 1061 1075 1098 1129 1141 1154 
+ 1068 1083 1097 1120 1136 1145 
+ 1060 1075 1100 1129 1134 1155 
+ 1081 1093 1099 1118 1128 1140 
+ 1054 1073 1085 1117 1160 1183 
+ 1076 1082 1106 1119 1144 1151 
+ 1048 1069 1086 1115 1147 1169 1176 
+ 1069 1077 1103 1114 1138 1169 
+ 1087 1099 1107 1128 1142 1153 
+ 1080 1085 1112 1130 1160 1174 
+ 1093 1105 1111 1126 1140 1148 
+ 1082 1089 1113 1123 1151 1158 
+ 1083 1095 1109 1131 1145 1157 
+ 1027 1034 1078 1135 1165 1186 1234 
+ 1097 1136 1152 1164 
+ 1089 1092 1119 1127 1158 1161 
+ 1091 1094 1132 1166 
+ 1102 1103 1126 1138 1150 1156 
+ 1102 1105 1118 1125 1148 1150 
+ 1092 1096 1123 1133 1161 1171 
+ 1099 1111 1116 1140 1153 1163 
+ 1075 1108 1110 1154 1155 1178 
+ 1080 1090 1117 1137 1174 1188 
+ 1095 1107 1120 1142 1157 1172 
+ 1094 1101 1124 1139 1166 1173 
+ 1096 1098 1127 1141 1171 1177 
+ 1100 1110 1135 1155 1167 
+ 1078 1100 1121 1134 1167 1186 
+ 1097 1109 1122 1145 1164 1180 
+ 1086 1090 1130 1147 1188 1189 
+ 1103 1115 1125 1156 1169 1187 
+ 1101 1106 1132 1144 1173 1182 
+ 1111 1118 1128 1148 1163 1175 
+ 1098 1108 1133 1154 1177 1190 
+ 1107 1116 1131 1153 1172 1184 
+ 949 994 1170 1275 1354 1412 
+ 1106 1113 1139 1151 1182 1193 
+ 1109 1120 1136 1157 1180 1192 
+ 268 293 372 2062 3697 4176 
+ 1086 1114 1137 1176 1189 1201 
+ 1118 1126 1140 1150 1175 1181 
+ 848 987 1013 1200 1433 1493 
+ 1125 1126 1148 1156 1181 1185 
+ 1113 1119 1144 1158 1193 1197 
+ 1122 1164 1191 1198 
+ 1116 1128 1142 1163 1184 1195 
+ 1108 1129 1141 1178 1190 1194 
+ 1110 1129 1134 1167 1178 1196 
+ 1125 1138 1150 1185 1187 
+ 1120 1131 1145 1172 1192 1199 
+ 1119 1123 1151 1161 1197 1203 
+ 1043 1053 1179 1204 1285 1314 
+ 1112 1117 1174 1183 1224 1242 
+ 1123 1127 1158 1171 1203 1205 
+ 1071 1074 1179 1240 1253 1297 
+ 1128 1140 1153 1175 1195 1202 
+ 1122 1136 1152 1180 1198 1206 
+ 1034 1072 1121 1234 1236 1291 
+ 1124 1132 1173 1207 
+ 1134 1135 1155 1186 1196 1222 
+ 284 301 446 882 2700 3287 4501 
+ 1114 1115 1138 1176 1187 1214 1216 
+ 994 1072 1143 1236 1349 1354 15292 
+ 1127 1133 1161 1177 1205 1211 
+ 1131 1142 1157 1184 1199 1209 
+ 1132 1139 1166 1182 1207 1212 
+ 1117 1130 1160 1188 1224 1230 
+ 1140 1148 1163 1181 1202 1208 
+ 1114 1147 1169 1201 1214 1228 
+ 1133 1141 1171 1190 1211 1221 
+ 1129 1154 1155 1194 1196 1217 
+ 1053 1071 1159 1162 1253 1285 
+ 1136 1145 1164 1192 1206 1215 
+ 1148 1150 1175 1185 1208 1210 
+ 1139 1144 1173 1193 1212 1223 
+ 1073 1088 1112 1160 1226 1242 1263 
+ 1142 1153 1172 1195 1209 1218 
+ 1150 1156 1181 1187 1210 1213 
+ 1121 1135 1167 1222 1234 1273 
+ 1138 1156 1169 1185 1213 1216 
+ 1130 1137 1174 1189 1220 1230 
+ 1137 1147 1188 1201 1220 1225 
+ 1141 1154 1177 1194 1221 1227 
+ 1152 1198 1219 1233 
+ 1145 1157 1180 1199 1215 1231 
+ 1144 1151 1182 1197 1223 1232 
+ 1154 1178 1190 1217 1227 
+ 1153 1163 1184 1202 1218 1229 
+ 1155 1167 1178 1217 1222 1252 
+ 1151 1158 1193 1203 1232 1237 
+ 1152 1164 1191 1206 1233 1239 
+ 1157 1172 1192 1209 1231 1238 
+ 987 1067 1149 1240 1382 1493 
+ 1147 1176 1189 1225 1228 1241 
+ 1163 1175 1195 1208 1229 1235 
+ 1158 1161 1197 1205 1237 1243 
+ 1043 1088 1159 1226 1314 1329 1369 
+ 1161 1171 1203 1211 1243 1250 
+ 1164 1180 1198 1215 1239 1248 
+ 1166 1173 1212 1251 
+ 1175 1181 1202 1210 1235 1244 
+ 1172 1184 1199 1218 1238 1247 
+ 1181 1185 1208 1213 1244 1245 
+ 1171 1177 1205 1221 1250 1258 
+ 1173 1182 1207 1223 1251 1257 
+ 1185 1187 1210 1216 1245 1255 
+ 1169 1176 1216 1228 1261 1265 
+ 1180 1192 1206 1231 1248 1262 
+ 1169 1187 1213 1214 1255 1261 
+ 1178 1194 1196 1227 1252 1266 
+ 1184 1195 1209 1229 1247 1260 
+ 1191 1233 1254 1268 
+ 1188 1189 1225 1230 1246 1259 
+ 1177 1190 1211 1227 1258 1267 
+ 1167 1186 1196 1252 1273 1311 
+ 1182 1193 1212 1232 1257 1270 
+ 1160 1174 1230 1242 1279 1294 
+ 1189 1201 1220 1241 1246 1256 
+ 1088 1183 1204 1263 1319 1329 
+ 1190 1194 1217 1221 1266 1267 
+ 1176 1201 1214 1241 1265 1271 
+ 1195 1202 1218 1235 1260 1269 
+ 1174 1188 1220 1224 1259 1279 
+ 1192 1199 1215 1238 1262 1272 
+ 1193 1197 1223 1237 1270 1276 
+ 1191 1198 1219 1239 1268 1274 
+ 1121 1165 1186 1273 1291 1345 
+ 1202 1208 1229 1244 1269 1277 
+ 1072 1165 1170 1291 1349 1356 
+ 1197 1203 1232 1243 1276 1283 
+ 1199 1209 1231 1247 1272 1281 
+ 1198 1206 1233 1248 1274 1282 
+ 1067 1074 1162 1200 1297 1382 1383 
+ 1201 1225 1228 1256 1271 1278 
+ 1160 1183 1224 1263 1294 1306 
+ 1203 1205 1237 1250 1283 1287 
+ 1208 1210 1235 1245 1277 1286 
+ 1210 1213 1244 1255 1286 1288 
+ 1220 1225 1256 1259 1280 1284 
+ 1209 1218 1238 1260 1281 1292 
+ 1206 1215 1239 1262 1282 1290 
+ 396 621 1028 1576 2073 2193 
+ 1205 1211 1243 1258 1287 1296 
+ 1207 1212 1257 1293 
+ 1196 1217 1222 1266 1308 1311 
+ 1162 1179 1285 1297 1357 
+ 1219 1268 1289 1299 
+ 1213 1216 1245 1261 1288 1295 
+ 1225 1241 1246 1278 1284 
+ 1212 1223 1251 1270 1293 1301 
+ 1211 1221 1250 1267 1296 1304 
+ 1220 1230 1246 1279 1280 1303 
+ 1218 1229 1247 1269 1292 1298 
+ 1214 1216 1255 1265 1295 1300 
+ 1215 1231 1248 1272 1290 1302 
+ 1183 1226 1242 1306 1319 
+ 348 527 612 2078 2587 15299 
+ 1214 1228 1261 1271 1300 1307 
+ 1217 1227 1252 1267 1308 1309 
+ 1221 1227 1258 1266 1304 1309 
+ 1219 1233 1254 1274 1299 1310 
+ 1229 1235 1260 1277 1298 1305 
+ 1223 1232 1257 1276 1301 15294 
+ 1228 1241 1265 1278 1307 1312 
+ 1231 1238 1262 1281 1302 1315 
+ 1186 1222 1234 1311 1345 1363 
+ 1233 1239 1268 1282 1310 1317 
+ 949 1104 1143 1412 1471 1551 
+ 1232 1237 1270 1283 1318 15294 
+ 1235 1244 1269 1286 1305 15295 
+ 1241 1256 1271 1284 1312 1316 
+ 1224 1230 1259 1294 1303 1325 
+ 1246 1259 1284 1303 1313 
+ 1238 1247 1272 1292 1315 1324 
+ 1239 1248 1274 1290 1317 1320 
+ 1237 1243 1276 1287 1318 1322 
+ 1246 1256 1278 1280 1313 1316 
+ 1159 1179 1253 1314 1357 1381 
+ 1244 1245 1277 1288 1321 15295 
+ 1243 1250 1283 1296 1322 1327 
+ 1245 1255 1286 1295 1321 1330 
+ 1254 1299 1323 1328 
+ 1248 1262 1282 1302 1320 1326 
+ 1165 1234 1236 1345 1356 1387 
+ 1247 1260 1281 1298 1324 1332 
+ 1251 1257 1301 1331 
+ 1224 1242 1279 1306 1325 1361 1368 
+ 1255 1261 1288 1300 1330 1339 
+ 1250 1258 1287 1304 1327 1336 
+ 1162 1240 1253 1357 1383 1418 
+ 1260 1269 1292 1305 1332 1334 
+ 1254 1268 1289 1310 1328 1337 
+ 1261 1265 1295 1307 1339 1343 
+ 1257 1270 1293 1331 1340 15294 
+ 1262 1272 1290 1315 1326 1338 
+ 1259 1279 1280 1313 1325 1333 
+ 1258 1267 1296 1309 1336 1341 
+ 1269 1277 1298 1334 1335 15295 
+ 1242 1263 1294 1319 1361 1374 
+ 1265 1271 1300 1312 1343 1347 
+ 1252 1266 1309 1311 1346 1355 
+ 1266 1267 1304 1308 1341 1346 
+ 1268 1274 1299 1317 1337 1342 
+ 1222 1252 1273 1308 1355 1363 1385 
+ 1271 1278 1307 1316 1347 1353 
+ 1280 1284 1303 1316 1333 1344 
+ 1159 1204 1285 1369 1381 1423 
+ 1272 1281 1302 1324 1338 1352 
+ 1278 1284 1312 1313 1344 1353 
+ 1274 1282 1310 1320 1342 1351 
+ 1276 1283 1322 1350 1359 15294 
+ 1226 1263 1306 1329 1374 1398 
+ 1282 1290 1317 1326 1351 1358 
+ 1286 1288 1330 1348 1366 15295 
+ 1283 1287 1318 1327 1359 1365 
+ 1289 1328 1360 1364 
+ 1281 1292 1315 1332 1352 1372 
+ 1279 1294 1303 1333 1367 1368 
+ 1290 1302 1320 1338 1358 1362 
+ 1287 1296 1322 1336 1365 1373 
+ 1289 1299 1323 1337 1364 1371 
+ 1204 1226 1319 1369 1398 1425 
+ 1288 1295 1321 1339 1366 1379 
+ 1293 1301 1340 1378 
+ 1292 1298 1324 1334 1372 1391 
+ 1303 1313 1325 1344 1367 1380 
+ 1298 1305 1332 1335 1377 1391 
+ 1305 1334 1348 1377 15295 
+ 1296 1304 1327 1341 1373 1384 
+ 1299 1310 1328 1342 1371 1376 
+ 1302 1315 1326 1352 1362 1370 
+ 1295 1300 1330 1343 1379 1390 
+ 1301 1331 1350 1378 1389 15294 
+ 1304 1309 1336 1346 1384 1394 
+ 1310 1317 1337 1351 1376 1386 
+ 1300 1307 1339 1347 1390 1392 
+ 1313 1316 1333 1353 1380 1395 
+ 1234 1273 1291 1363 1387 1414 1444 
+ 1308 1309 1341 1355 1394 1401 
+ 1307 1312 1343 1353 1388 1392 
+ 1321 1335 1366 1377 1403 15295 
+ 1170 1236 1354 1356 1475 1510 
+ 1318 1340 1359 1389 1397 15294 
+ 1317 1320 1342 1358 1386 1393 
+ 1315 1324 1338 1370 1372 1400 
+ 1312 1316 1344 1347 1388 1395 
+ 1143 1170 1349 1412 1510 1563 
+ 1308 1311 1346 1385 1401 1416 
+ 1236 1291 1349 1387 1475 1479 
+ 1253 1285 1297 1381 1418 1446 
+ 1320 1326 1351 1362 1393 1396 
+ 1318 1322 1350 1365 1397 1404 
+ 1323 1364 1402 1405 
+ 1294 1306 1368 1374 1410 1440 
+ 1326 1338 1358 1370 1396 1399 
+ 1273 1311 1345 1385 1414 1430 
+ 1323 1328 1360 1371 1405 1406 
+ 1322 1327 1359 1373 1404 1409 
+ 1321 1330 1348 1379 1403 1419 
+ 1325 1333 1368 1380 1413 1415 
+ 1294 1325 1361 1367 1410 1413 
+ 1204 1314 1329 1423 1425 1474 
+ 1338 1352 1362 1399 1400 1407 
+ 1328 1337 1364 1376 1406 1411 
+ 1324 1332 1352 1391 1400 1435 
+ 1327 1336 1365 1384 1409 1421 
+ 1306 1319 1361 1398 1440 1459 
+ 920 1104 1408 1471 1710 1766 
+ 1337 1342 1371 1386 1411 1417 
+ 1334 1335 1348 1391 1403 1432 
+ 1331 1340 1389 1424 
+ 1330 1339 1366 1390 1419 1428 
+ 1333 1344 1367 1395 1415 1437 
+ 1285 1314 1357 1423 1446 1481 
+ 1200 1240 1383 1493 1534 1595 
+ 1240 1297 1382 1418 1485 1534 
+ 1336 1341 1373 1394 1421 1431 
+ 1311 1355 1363 1416 1430 1450 
+ 1342 1351 1376 1393 1417 1422 
+ 1291 1345 1356 1444 1473 1479 
+ 1347 1353 1392 1395 1420 1447 
+ 1340 1350 1378 1397 1424 1436 
+ 1339 1343 1379 1392 1428 1429 
+ 1332 1334 1372 1377 1432 1435 1467 
+ 1343 1347 1388 1390 1420 1429 
+ 1351 1358 1386 1396 1422 1426 
+ 1341 1346 1384 1401 1431 15296 
+ 1344 1353 1380 1388 1437 1447 
+ 1358 1362 1393 1399 1426 1427 
+ 1350 1359 1389 1404 1436 1442 
+ 1319 1329 1374 1425 1459 1489 
+ 1362 1370 1396 1407 1427 1434 
+ 1352 1370 1372 1407 1435 1448 
+ 1346 1355 1394 1416 1453 15296 
+ 1360 1405 1441 1445 
+ 1348 1366 1377 1419 1432 1462 
+ 1359 1365 1397 1409 1442 1451 
+ 1360 1364 1402 1406 1445 1449 
+ 1364 1371 1405 1411 1449 1452 
+ 1370 1399 1400 1434 1448 
+ 870 920 1375 1443 1766 1962 
+ 1365 1373 1404 1421 1451 1458 
+ 1361 1368 1413 1440 1465 
+ 1371 1376 1406 1417 1452 1455 
+ 1143 1275 1354 1551 1563 1664 
+ 1367 1368 1410 1415 1454 1465 
+ 1345 1363 1430 1444 1472 1497 
+ 1367 1380 1413 1437 1454 1463 
+ 1355 1385 1401 1450 1453 1476 
+ 1376 1386 1411 1422 1455 1457 
+ 1297 1357 1383 1446 1485 1540 
+ 1366 1379 1403 1428 1462 1482 
+ 1388 1392 1429 1447 1469 
+ 1373 1384 1409 1431 1458 1466 
+ 1386 1393 1417 1426 1457 1460 
+ 1314 1369 1381 1474 1481 1513 
+ 1378 1389 1436 1468 
+ 1329 1369 1398 1474 1489 1509 
+ 1393 1396 1422 1427 1460 1461 
+ 1396 1399 1426 1434 1456 1461 
+ 1379 1390 1419 1429 1482 1484 
+ 1390 1392 1420 1428 1469 1484 
+ 1363 1385 1414 1450 1470 1472 
+ 1384 1394 1421 1466 1477 15296 
+ 1377 1391 1403 1462 1467 1527 
+ 1013 1149 1439 1493 1751 1812 
+ 1399 1407 1427 1448 1456 1464 
+ 1372 1391 1400 1448 1467 1480 1504 
+ 1389 1397 1424 1442 1468 1478 
+ 1380 1395 1415 1447 1463 1490 
+ 125 173 203 4201 6142 7847 14856 
+ 908 1013 1433 1544 1812 1903 
+ 1361 1374 1410 1459 1465 1502 
+ 1402 1445 1483 15298 
+ 1397 1404 1436 1451 1478 1486 
+ 809 870 1408 1962 1984 15297 
+ 1345 1387 1414 1473 1497 1516 
+ 1402 1405 1441 1449 1487 15298 
+ 1357 1381 1418 1481 1540 1562 
+ 1388 1395 1420 1437 1469 1490 1518 
+ 1400 1407 1434 1435 1464 1480 
+ 1405 1406 1445 1452 1487 1491 
+ 1385 1416 1430 1470 1476 1496 
+ 1404 1409 1442 1458 1486 1498 
+ 1406 1411 1449 1455 1491 1494 
+ 1401 1416 1476 1488 1503 15296 
+ 1413 1415 1463 1465 1492 
+ 1411 1417 1452 1457 1494 1499 
+ 1427 1434 1461 1464 1500 
+ 1417 1422 1455 1460 1499 1501 
+ 1409 1421 1451 1466 1498 1507 
+ 1374 1398 1440 1489 1502 1549 
+ 1422 1426 1457 1461 1501 1505 
+ 1426 1427 1456 1460 1500 1505 
+ 1403 1419 1432 1482 1527 1533 
+ 1415 1437 1454 1490 1492 1517 
+ 1434 1448 1456 1480 1500 1508 
+ 1410 1413 1440 1454 1492 1502 1530 
+ 1421 1431 1458 1477 1507 1511 
+ 1391 1432 1435 1504 1527 1542 
+ 1424 1436 1478 1512 
+ 1420 1429 1447 1484 1518 1536 
+ 1430 1450 1472 1496 1506 
+ 1104 1275 1375 1551 1701 1710 
+ 1414 1430 1470 1497 1506 1522 
+ 1387 1444 1479 1516 1524 
+ 1369 1423 1425 1509 1513 1539 
+ 1349 1356 1479 1510 1552 1615 
+ 1416 1450 1453 1496 1503 1514 
+ 1431 1466 1488 1511 1521 15296 
+ 1436 1442 1468 1486 1512 1519 
+ 1356 1387 1473 1475 1524 1552 
+ 1435 1448 1464 1504 1508 
+ 1381 1423 1446 1513 1562 1580 
+ 1419 1428 1462 1484 1533 1538 
+ 1441 1515 1520 15298 
+ 1428 1429 1469 1482 1536 1538 
+ 1383 1418 1534 1540 1567 
+ 1442 1451 1478 1498 1519 1529 
+ 1445 1449 1491 1523 1525 15298 
+ 1453 1477 1503 1521 1532 15296 
+ 1398 1425 1459 1509 1549 1573 
+ 1437 1447 1463 1517 1518 1564 
+ 1449 1452 1487 1494 1525 1528 
+ 1454 1463 1465 1517 1530 
+ 1149 1200 1382 1433 1595 1725 1751 
+ 1452 1455 1491 1499 1528 1531 
+ 544 797 1656 1882 2219 2312 
+ 1450 1470 1476 1506 1514 1526 
+ 1414 1444 1472 1516 1522 1557 
+ 1451 1458 1486 1507 1529 1537 
+ 1455 1457 1494 1501 1531 1535 
+ 1456 1461 1464 1505 1508 1546 15300 
+ 1457 1460 1499 1505 1535 1541 
+ 1440 1459 1465 1530 1549 1607 
+ 1453 1476 1488 1514 1532 1543 
+ 1435 1467 1480 1508 1542 1550 
+ 1460 1461 1500 1501 1541 15300 
+ 1470 1472 1496 1522 1526 1548 
+ 1458 1466 1498 1511 1537 1547 
+ 1464 1480 1500 1504 1546 1550 
+ 1425 1474 1489 1539 1573 1583 
+ 1349 1354 1475 1563 1615 1669 
+ 1466 1477 1507 1521 1547 1555 
+ 1468 1478 1519 1554 
+ 1423 1474 1481 1539 1580 1596 
+ 1476 1496 1503 1526 1543 1545 
+ 1483 1520 1553 1556 
+ 1444 1473 1497 1524 1557 1577 
+ 1463 1490 1492 1530 1564 1601 
+ 1447 1469 1490 1536 1564 1604 
+ 1478 1486 1512 1529 1554 1560 
+ 1483 1515 1523 1556 1558 15298 
+ 1477 1488 1511 1532 1555 1565 
+ 1472 1497 1506 1548 1557 1598 
+ 1487 1520 1525 1558 1559 15298 
+ 1473 1479 1516 1552 1577 1582 
+ 1487 1491 1523 1528 1559 1561 
+ 1496 1506 1514 1545 1548 1569 
+ 1432 1462 1467 1533 1542 1578 1587 
+ 1491 1494 1525 1531 1561 1566 
+ 1486 1498 1519 1537 1560 1570 
+ 1465 1492 1502 1517 1601 1607 
+ 1494 1499 1528 1535 1566 1568 
+ 1488 1503 1521 1543 1565 1571 
+ 1462 1482 1527 1538 1578 1592 
+ 1382 1383 1485 1567 1595 1639 
+ 1499 1501 1531 1541 1568 1572 
+ 1469 1484 1518 1538 1604 1606 
+ 1498 1507 1529 1547 1570 1575 
+ 1482 1484 1533 1536 1592 1606 
+ 1474 1509 1513 1583 1596 
+ 1418 1446 1485 1562 1567 1618 1643 
+ 1501 1505 1535 1572 1579 15300 
+ 1467 1504 1527 1550 1587 1605 
+ 1503 1514 1532 1545 1571 1574 
+ 908 956 1439 1895 1903 2125 
+ 1514 1526 1543 1569 1574 
+ 1500 1508 1550 1591 1611 15300 
+ 1507 1511 1537 1555 1575 1581 
+ 1506 1522 1526 1569 1598 1599 
+ 1459 1489 1502 1573 1607 1634 
+ 1504 1508 1542 1546 1605 1611 
+ 1275 1412 1471 1664 1701 1707 
+ 1475 1479 1524 1582 1615 1627 
+ 1515 1556 1584 1585 
+ 1512 1519 1560 1589 
+ 1511 1521 1547 1565 1581 1593 
+ 1515 1520 1553 1558 1585 1586 
+ 1497 1516 1522 1577 1598 1614 
+ 1520 1523 1556 1559 1586 1588 
+ 1523 1525 1558 1561 1588 1590 
+ 1519 1529 1554 1570 1589 1600 
+ 1525 1528 1559 1566 1590 1594 
+ 1446 1481 1540 1580 1618 1644 
+ 1354 1412 1510 1664 1669 1760 
+ 1490 1517 1518 1601 1604 1665 
+ 1521 1532 1555 1571 1593 1603 
+ 1528 1531 1561 1568 1594 1597 
+ 1485 1534 1540 1639 1643 
+ 1531 1535 1566 1572 1597 1602 
+ 1526 1545 1548 1574 1599 1608 
+ 1529 1537 1560 1575 1600 1610 
+ 1532 1543 1565 1574 1603 1609 
+ 1535 1541 1568 1579 1602 1612 
+ 1489 1509 1549 1583 1634 1661 
+ 1543 1545 1569 1571 1608 1609 
+ 1537 1547 1570 1581 1610 1613 
+ 621 956 1249 1895 2193 2805 
+ 1516 1524 1557 1582 1614 1631 
+ 1527 1533 1587 1592 1629 1648 
+ 1541 1572 1591 1612 1616 15300 
+ 1481 1513 1562 1596 1644 1670 
+ 1547 1555 1575 1593 1613 1622 
+ 1524 1552 1577 1627 1631 
+ 1509 1539 1573 1596 1661 1672 
+ 1553 1585 1617 1621 
+ 1553 1556 1584 1586 1621 15301 
+ 1556 1558 1585 1588 1619 15301 
+ 1527 1542 1578 1605 1629 1642 
+ 1558 1559 1586 1590 1619 1620 
+ 1554 1560 1600 1626 
+ 1559 1561 1588 1594 1620 1623 
+ 1546 1579 1611 1616 1635 15300 
+ 1533 1538 1578 1606 1648 1667 
+ 1555 1565 1581 1603 1622 1628 
+ 1561 1566 1590 1597 1623 1624 
+ 1382 1493 1534 1639 1725 1730 
+ 1513 1539 1580 1583 1670 1672 
+ 1566 1568 1594 1602 1624 1625 
+ 1522 1548 1557 1599 1614 1640 1662 
+ 1548 1569 1598 1608 1637 1640 
+ 1560 1570 1589 1610 1626 1632 
+ 1517 1530 1564 1607 1665 1694 
+ 1568 1572 1597 1612 1625 1630 
+ 1565 1571 1593 1609 1628 1633 
+ 1518 1536 1564 1606 1665 1676 
+ 1542 1550 1587 1611 1642 1645 
+ 1536 1538 1592 1604 1667 1676 
+ 1502 1530 1549 1601 1634 1694 1708 
+ 1569 1574 1599 1609 1637 1638 
+ 1571 1574 1603 1608 1633 1638 
+ 1570 1575 1600 1613 1632 1641 
+ 1546 1550 1591 1605 1635 1645 1659 
+ 1572 1579 1602 1616 1630 1636 
+ 1575 1581 1610 1622 1641 1647 
+ 1557 1577 1598 1631 1662 1677 
+ 1475 1510 1552 1627 1669 1698 1752 
+ 1579 1591 1612 1635 1636 1658 
+ 1584 1621 1654 1657 
+ 1540 1562 1643 1644 1688 
+ 1586 1588 1620 1652 1653 15301 
+ 1588 1590 1619 1623 1651 1652 
+ 1584 1585 1617 1655 1657 15301 
+ 1581 1593 1613 1628 1647 1663 
+ 1590 1594 1620 1624 1649 1651 
+ 1594 1597 1623 1625 1646 1649 
+ 1597 1602 1624 1630 1646 1650 
+ 1589 1600 1632 1666 
+ 1552 1582 1615 1631 1685 1698 
+ 1593 1603 1622 1633 1663 1668 
+ 1578 1587 1642 1648 1681 
+ 1602 1612 1625 1636 1650 1660 
+ 1577 1582 1614 1627 1677 1685 
+ 1600 1610 1626 1641 1666 1673 
+ 1603 1609 1628 1638 1668 1671 
+ 1549 1573 1607 1661 1708 1729 
+ 1591 1611 1616 1658 1659 1683 
+ 1612 1616 1630 1658 1660 
+ 1599 1608 1638 1640 1674 1679 
+ 1608 1609 1633 1637 1671 1674 
+ 1534 1567 1595 1643 1720 1730 
+ 1598 1599 1637 1662 1679 1695 
+ 1610 1613 1632 1647 1673 1680 
+ 1587 1605 1629 1645 1681 1697 
+ 1540 1567 1618 1639 1688 1720 
+ 1562 1580 1618 1670 1688 1739 
+ 1605 1611 1642 1659 1697 1703 
+ 1624 1625 1649 1650 1675 1678 
+ 1613 1622 1641 1663 1680 1689 
+ 1578 1592 1629 1667 1681 1705 
+ 1623 1624 1646 1651 1678 1682 
+ 1625 1630 1646 1660 1675 1693 
+ 1620 1623 1649 1652 1682 1684 
+ 1619 1620 1651 1653 1684 1686 
+ 1619 1652 1655 1686 1687 15301 
+ 1617 1657 1691 1692 
+ 1621 1653 1657 1687 1690 15301 
+ 544 813 1495 2019 2219 2790 
+ 1617 1621 1654 1655 1690 1692 
+ 1616 1635 1636 1660 1683 1712 
+ 1611 1635 1645 1683 1703 
+ 1630 1636 1650 1658 1693 1712 
+ 1573 1583 1634 1672 1729 1755 
+ 1598 1614 1640 1677 1695 1709 
+ 1622 1628 1647 1668 1689 1696 
+ 1412 1551 1563 1707 1760 1802 
+ 1564 1601 1604 1676 1694 1756 1761 
+ 1626 1632 1673 1700 
+ 1592 1606 1648 1676 1705 1735 
+ 1628 1633 1663 1671 1696 1699 
+ 1510 1563 1615 1752 1760 1833 
+ 1580 1596 1644 1672 1739 1758 
+ 1633 1638 1668 1674 1699 1704 
+ 1583 1596 1661 1670 1755 1758 
+ 1632 1641 1666 1680 1700 1706 
+ 1637 1638 1671 1679 1704 1711 
+ 1646 1650 1678 1693 1702 
+ 1604 1606 1665 1667 1735 1756 
+ 1614 1631 1662 1685 1709 1726 
+ 1646 1649 1675 1682 1702 1713 
+ 1637 1640 1674 1695 1711 1724 
+ 1641 1647 1673 1689 1706 1715 
+ 1629 1642 1648 1697 1705 1733 
+ 1649 1651 1678 1684 1713 1714 
+ 1635 1658 1659 1703 1712 1740 
+ 1651 1652 1682 1686 1714 1716 
+ 1627 1631 1677 1698 1726 1741 
+ 1652 1653 1684 1687 1716 1717 
+ 1653 1655 1686 1690 1717 1718 
+ 1618 1643 1644 1720 1739 1788 
+ 1647 1663 1680 1696 1715 1723 
+ 1655 1657 1687 1692 1718 1719 
+ 1654 1692 1721 1722 
+ 1654 1657 1690 1691 1719 1721 
+ 1650 1660 1675 1702 1712 1728 
+ 1601 1607 1665 1708 1761 1768 
+ 1640 1662 1679 1709 1724 1734 
+ 1663 1668 1689 1699 1723 1727 
+ 1642 1645 1681 1703 1733 1747 
+ 1615 1627 1685 1741 1752 1791 
+ 1668 1671 1696 1704 1727 1731 
+ 1666 1673 1706 1732 
+ 1471 1551 1707 1710 1832 1890 
+ 1675 1678 1693 1713 1728 1736 
+ 1645 1659 1683 1697 1740 1747 
+ 1671 1674 1699 1711 1731 1737 
+ 1648 1667 1681 1733 1735 1794 
+ 1673 1680 1700 1715 1732 1738 
+ 1551 1664 1701 1802 1832 
+ 1607 1634 1694 1729 1768 1787 
+ 1662 1677 1695 1726 1734 1759 
+ 1375 1471 1701 1766 1890 1919 
+ 1674 1679 1704 1724 1737 1749 
+ 1658 1660 1683 1693 1728 1740 1784 
+ 1678 1682 1702 1714 1736 1744 
+ 1682 1684 1713 1716 1742 1744 
+ 1680 1689 1706 1723 1738 1746 
+ 1684 1686 1714 1717 1742 1743 
+ 1686 1687 1716 1718 1743 1745 
+ 1687 1690 1717 1719 1745 1748 
+ 1690 1692 1718 1721 1748 1750 
+ 1639 1643 1688 1730 1788 1858 
+ 1691 1692 1719 1722 1750 1753 
+ 1691 1721 1753 1754 
+ 1689 1696 1715 1727 1746 1757 
+ 1679 1695 1711 1734 1749 1762 
+ 1493 1595 1730 1751 1924 1972 
+ 1677 1685 1709 1741 1759 1776 
+ 1696 1699 1723 1731 1757 1763 
+ 1693 1702 1712 1736 1782 1784 1789 
+ 1634 1661 1708 1755 1787 1815 
+ 1595 1639 1720 1725 1858 1924 
+ 1699 1704 1727 1737 1763 1765 
+ 1700 1706 1738 1764 
+ 1681 1697 1705 1747 1794 1805 
+ 1695 1709 1724 1759 1762 1771 
+ 1667 1676 1705 1756 1794 1822 
+ 1702 1713 1728 1744 1778 1782 
+ 1704 1711 1731 1749 1765 1769 
+ 1706 1715 1732 1746 1764 1767 
+ 1644 1670 1688 1758 1788 1819 
+ 1683 1703 1712 1747 1784 1806 1813 
+ 1685 1698 1726 1776 1791 1823 
+ 1714 1716 1743 1744 1772 1775 
+ 1716 1717 1742 1745 1770 1772 
+ 1713 1714 1736 1742 1775 1778 
+ 1717 1718 1743 1748 1770 1773 
+ 1715 1723 1738 1757 1767 1779 
+ 1697 1703 1733 1740 1805 1806 
+ 1718 1719 1745 1750 1773 1774 
+ 1711 1724 1737 1762 1769 1783 
+ 1719 1721 1748 1753 1774 1777 
+ 1433 1493 1725 1812 1972 2060 
+ 1615 1669 1698 1791 1833 1864 
+ 1721 1722 1750 1754 1777 1780 
+ 1722 1753 1780 1781 
+ 1661 1672 1729 1758 1815 1828 
+ 1665 1676 1735 1761 1818 1822 
+ 1723 1727 1746 1763 1779 1785 
+ 1670 1672 1739 1755 1819 1828 
+ 1709 1726 1734 1771 1776 1801 
+ 1563 1664 1669 1802 1833 1900 
+ 1665 1694 1756 1768 1818 1825 
+ 1724 1734 1749 1771 1783 1786 
+ 1727 1731 1757 1765 1785 1790 
+ 1732 1738 1767 1792 
+ 1731 1737 1763 1769 1790 1793 
+ 1375 1408 1710 1919 1962 2147 
+ 1738 1746 1764 1779 1792 1799 
+ 1694 1708 1761 1787 1825 1830 
+ 1737 1749 1765 1783 1793 1804 
+ 1743 1745 1772 1773 1795 1797 
+ 1734 1759 1762 1786 1801 1808 
+ 1742 1743 1770 1775 1795 1796 
+ 1745 1748 1770 1774 1797 1798 
+ 1748 1750 1773 1777 1798 1800 
+ 1742 1744 1772 1778 1796 1809 
+ 1726 1741 1759 1801 1823 1835 
+ 1750 1753 1774 1780 1800 1803 
+ 1736 1744 1775 1782 1809 1816 
+ 1746 1757 1767 1785 1799 1811 
+ 1753 1754 1777 1781 1803 1807 
+ 1754 1780 1807 1810 
+ 1728 1736 1778 1789 1816 1821 
+ 1749 1762 1769 1786 1804 1814 
+ 1712 1728 1740 1789 1813 1820 
+ 1757 1763 1779 1790 1811 1817 
+ 1762 1771 1783 1808 1814 
+ 1708 1729 1768 1815 1830 1892 
+ 1688 1720 1739 1819 1858 1914 
+ 1728 1782 1784 1820 1821 
+ 1763 1765 1785 1793 1817 1824 
+ 1698 1741 1752 1823 1864 15302 
+ 1764 1767 1799 1831 
+ 1765 1769 1790 1804 1824 1837 
+ 1705 1733 1735 1805 1822 1907 1922 
+ 1770 1772 1796 1797 1826 1827 
+ 1772 1775 1795 1809 1826 1836 
+ 1770 1773 1795 1798 1827 1829 
+ 1773 1774 1797 1800 1829 1834 
+ 1767 1779 1792 1811 1831 1840 
+ 1774 1777 1798 1803 1834 1838 
+ 1759 1771 1776 1808 1835 1845 1861 
+ 1664 1707 1760 1832 1900 1950 
+ 1777 1780 1800 1807 1838 1841 
+ 1769 1783 1793 1814 1837 1842 
+ 1733 1747 1794 1806 1897 1922 
+ 1740 1747 1805 1813 1873 1897 
+ 1780 1781 1803 1810 1841 1843 
+ 1771 1786 1801 1814 1844 1845 
+ 1775 1778 1796 1816 1836 1839 
+ 1781 1807 1843 1846 
+ 1779 1785 1799 1817 1840 1847 
+ 1433 1439 1751 1903 2060 2263 
+ 1740 1784 1806 1820 1856 1873 
+ 1783 1786 1804 1808 1842 1844 
+ 1729 1755 1787 1828 1892 1927 
+ 1778 1782 1809 1821 1839 1848 1850 
+ 1785 1790 1811 1824 1847 1849 
+ 1756 1761 1822 1825 1876 1891 
+ 1739 1758 1788 1828 1914 1937 
+ 1784 1789 1813 1821 1851 1856 
+ 1782 1789 1816 1820 1848 1851 
+ 1735 1756 1794 1818 1876 1907 
+ 1741 1776 1791 1835 1889 15302 
+ 1790 1793 1817 1837 1849 1860 
+ 1761 1768 1818 1830 1891 1893 
+ 1795 1796 1827 1836 1853 1854 
+ 1795 1797 1826 1829 1854 1855 
+ 1755 1758 1815 1819 1927 1937 
+ 1797 1798 1827 1834 1855 1857 
+ 1768 1787 1825 1892 1893 
+ 1792 1799 1840 1863 
+ 1701 1707 1802 1890 1950 2018 
+ 1669 1752 1760 1864 1900 1981 
+ 1798 1800 1829 1838 1857 1859 
+ 1776 1801 1823 1861 1880 1889 
+ 1796 1809 1826 1839 1852 1853 
+ 1793 1804 1824 1842 1860 1865 
+ 1800 1803 1834 1841 1859 1862 
+ 1809 1816 1836 1850 1852 
+ 1799 1811 1831 1847 1863 1867 
+ 1803 1807 1838 1843 1862 1866 
+ 1804 1814 1837 1844 1865 1869 
+ 1807 1810 1841 1846 1866 1870 
+ 1808 1814 1842 1845 1869 1871 
+ 1801 1808 1844 1861 1871 1887 
+ 1810 1843 1870 1872 
+ 1811 1817 1840 1849 1867 1874 
+ 1816 1821 1850 1851 1868 1877 
+ 1817 1824 1847 1860 1874 1883 
+ 1816 1839 1848 1852 1868 1875 
+ 1820 1821 1848 1856 1877 1886 
+ 1836 1839 1850 1853 1875 1878 
+ 1826 1836 1852 1854 1878 1879 
+ 1826 1827 1853 1855 1879 1881 
+ 1827 1829 1854 1857 1881 1884 
+ 1813 1820 1851 1873 1886 1921 
+ 1829 1834 1855 1859 1884 1885 
+ 1720 1730 1788 1914 1924 1997 
+ 1834 1838 1857 1862 1885 1888 
+ 1824 1837 1849 1865 1883 1896 
+ 1801 1835 1845 1880 1887 1909 
+ 1838 1841 1859 1866 1888 1894 
+ 1831 1840 1867 1899 
+ 1752 1791 1833 1980 1981 15302 
+ 1837 1842 1860 1869 1896 1902 
+ 1841 1843 1862 1870 1894 1901 
+ 1840 1847 1863 1874 1899 1905 
+ 1848 1850 1875 1877 1898 
+ 1842 1844 1865 1871 1902 1906 
+ 1843 1846 1866 1872 1901 1904 
+ 1844 1845 1869 1887 1906 1918 
+ 1846 1870 1904 1908 
+ 1806 1813 1856 1897 1921 1948 
+ 1847 1849 1867 1883 1905 1913 
+ 1850 1852 1868 1878 1898 1911 
+ 1818 1822 1891 1907 1961 
+ 1848 1851 1868 1886 1898 1916 
+ 1852 1853 1875 1879 1911 1912 
+ 1853 1854 1878 1881 1912 1915 
+ 1835 1861 1889 1909 1920 
+ 1854 1855 1879 1884 1910 1915 
+ 797 1495 2261 2312 3001 15297 
+ 1849 1860 1874 1896 1913 1925 
+ 1855 1857 1881 1885 1910 1917 
+ 1857 1859 1884 1888 1917 1923 
+ 1851 1856 1877 1916 1921 1951 
+ 1845 1861 1871 1909 1918 1931 
+ 1859 1862 1885 1894 1923 1926 
+ 1823 1835 1880 1920 1933 15302 
+ 1701 1710 1832 1919 2018 2083 
+ 1818 1825 1876 1893 1961 1986 
+ 1787 1815 1830 1893 1927 2012 2034 
+ 1825 1830 1891 1892 1986 2012 
+ 1862 1866 1888 1901 1926 1928 
+ 956 1544 1576 2125 2805 2889 
+ 1860 1865 1883 1902 1925 1930 
+ 1805 1806 1873 1922 1948 1978 
+ 1868 1875 1877 1911 1916 1929 
+ 1863 1867 1905 1934 
+ 1760 1802 1833 1950 1981 2026 
+ 1866 1870 1894 1904 1928 1932 
+ 1865 1869 1896 1906 1930 1938 
+ 1439 1544 1812 2125 2263 2489 
+ 1870 1872 1901 1908 1932 1939 
+ 1867 1874 1899 1913 1934 1941 
+ 1869 1871 1902 1918 1938 1946 
+ 1794 1822 1876 1922 1961 1991 
+ 1872 1904 1939 1944 
+ 1861 1880 1887 1920 1931 1942 
+ 1881 1884 1915 1917 1935 1936 
+ 1875 1878 1898 1912 1929 1945 
+ 1878 1879 1911 1915 1940 1945 
+ 1874 1883 1905 1925 1941 1949 
+ 1788 1819 1858 1937 1997 2037 
+ 1879 1881 1910 1912 1936 1940 
+ 1877 1886 1898 1929 1951 1963 
+ 1884 1885 1910 1923 1935 1943 
+ 1871 1887 1906 1931 1946 1954 
+ 1710 1766 1890 2083 2147 
+ 1880 1889 1909 1933 1942 1958 
+ 1856 1873 1886 1948 1951 1967 
+ 1794 1805 1897 1907 1978 1991 2027 
+ 1885 1888 1917 1926 1943 1947 
+ 1725 1730 1858 1972 1997 2063 
+ 1883 1896 1913 1930 1949 1953 
+ 1888 1894 1923 1928 1947 1952 
+ 1815 1828 1892 1937 2034 2056 
+ 1894 1901 1926 1932 1952 1957 
+ 1898 1911 1916 1945 1963 1973 
+ 1896 1902 1925 1938 1953 1959 
+ 1887 1909 1918 1942 1954 1955 
+ 1901 1904 1928 1939 1957 1960 
+ 1889 1920 1958 1980 1993 15302 
+ 1899 1905 1941 15303 
+ 1910 1917 1936 1943 1956 1968 
+ 1910 1915 1935 1940 1956 
+ 1819 1828 1914 1927 2037 2056 
+ 1902 1906 1930 1946 1959 1966 
+ 1904 1908 1932 1944 1960 1965 
+ 1912 1915 1936 1945 1956 1979 
+ 1905 1913 1934 1949 1969 15303 
+ 1909 1920 1931 1955 1958 1974 
+ 1917 1923 1935 1947 1968 1970 
+ 1908 1939 1965 1971 
+ 1911 1912 1929 1940 1973 1979 1995 
+ 1906 1918 1938 1954 1966 1977 
+ 1923 1926 1943 1952 1964 1970 
+ 1873 1897 1921 1967 1978 2007 
+ 1913 1925 1941 1953 1969 1976 
+ 1802 1832 1900 2018 2026 2116 
+ 1886 1916 1921 1963 1967 1983 
+ 1926 1928 1947 1957 1964 1975 
+ 1925 1930 1949 1959 1976 15304 
+ 1918 1931 1946 1955 1977 1982 
+ 1931 1942 1954 1974 1982 
+ 1935 1936 1940 1968 1979 2004 
+ 1928 1932 1952 1960 1975 1985 
+ 1920 1933 1942 1974 1993 2000 
+ 1930 1938 1953 1966 1990 15304 
+ 1932 1939 1957 1965 1985 1989 
+ 1876 1891 1907 1986 1991 2066 2079 
+ 1408 1443 1766 1984 2147 2685 2755 
+ 1916 1929 1951 1973 1983 1999 
+ 1947 1952 1970 1975 1988 
+ 1939 1944 1960 1971 1989 1994 
+ 1938 1946 1959 1977 1990 1998 
+ 1921 1948 1951 1983 2007 2009 
+ 1935 1943 1956 1970 2004 2006 
+ 1941 1949 1976 1992 1996 15303 
+ 1943 1947 1964 1968 1988 2006 
+ 1944 1965 1994 15305 
+ 1725 1751 1924 2060 2063 2195 
+ 1929 1945 1963 1995 1999 2008 
+ 1942 1955 1958 1982 2000 2003 
+ 1952 1957 1964 1985 1988 15306 
+ 1949 1953 1969 1996 2001 15304 
+ 1946 1954 1966 1982 1998 2002 
+ 1897 1922 1948 2007 2027 2058 
+ 1940 1945 1956 1995 2004 2011 
+ 1864 1933 1981 1993 2046 2085 15302 
+ 1833 1864 1900 1980 2026 2085 2117 
+ 1954 1955 1974 1977 2002 2003 
+ 1951 1963 1967 1999 2009 2014 
+ 1443 1962 2261 2755 3305 15297 
+ 1957 1960 1975 1989 2005 15306 
+ 1891 1893 1961 2012 2079 2082 
+ 302 446 894 3287 4973 5181 
+ 1964 1970 1975 2006 2020 15306 
+ 1960 1965 1985 1994 2005 2013 
+ 1959 1966 1998 2010 2016 15304 
+ 1907 1922 1961 2027 2066 2086 
+ 1969 1996 2015 15303 
+ 1933 1958 1980 2000 2040 2046 
+ 1965 1971 1989 2013 2017 15305 
+ 1945 1973 1979 2008 2011 2021 
+ 1969 1976 1992 2001 2015 2024 
+ 1858 1914 1924 2037 2063 2131 
+ 1966 1977 1990 2002 2016 2025 
+ 1963 1973 1983 2008 2014 2022 
+ 1958 1974 1993 2003 2035 2040 
+ 1976 1996 2010 2024 2030 15304 
+ 1977 1982 1998 2003 2025 2029 
+ 1974 1982 2000 2002 2029 2035 
+ 1956 1968 1979 2006 2011 2042 2052 
+ 1985 1989 2013 2028 2033 15306 
+ 1968 1970 1988 2004 2020 2052 2057 
+ 1948 1967 1978 2009 2053 2058 
+ 1973 1995 1999 2021 2022 2031 
+ 1967 1983 2007 2014 2048 2053 
+ 1990 2001 2016 2030 2036 15304 
+ 1979 1995 2004 2021 2032 2042 
+ 1892 1893 1986 2034 2082 2095 
+ 1989 1994 2005 2017 2033 2038 
+ 1983 1999 2009 2022 2041 2048 
+ 1992 1996 2024 2043 
+ 1990 1998 2010 2025 2036 2044 
+ 1994 2013 2023 2038 2045 15305 
+ 1832 1890 1950 2083 2116 2207 
+ 813 1656 2447 2790 3675 15299 
+ 1988 2006 2028 2057 2065 15306 
+ 1995 2008 2011 2031 2032 2047 
+ 1999 2008 2014 2031 2039 2041 
+ 2017 2045 2049 15305 
+ 1996 2001 2015 2030 2043 2050 
+ 1998 2002 2016 2029 2044 2051 
+ 1900 1950 1981 2116 2117 2214 
+ 1922 1978 1991 2058 2086 2114 
+ 2005 2020 2033 2065 2068 15306 
+ 2002 2003 2025 2035 2051 2067 
+ 2001 2010 2024 2036 2050 2055 
+ 2008 2021 2022 2039 2047 2054 
+ 2011 2021 2042 2047 2061 
+ 2005 2013 2028 2038 2068 2070 
+ 1892 1927 2012 2056 2095 2128 
+ 2000 2003 2029 2040 2067 2084 
+ 2010 2016 2030 2044 2055 2064 
+ 1914 1937 1997 2056 2131 2155 
+ 2013 2017 2033 2045 2070 2071 
+ 2022 2031 2041 2054 2059 
+ 1993 2000 2035 2046 2084 2099 
+ 2014 2022 2039 2048 2059 2072 
+ 2004 2011 2032 2052 2061 2074 
+ 2015 2024 2050 2075 
+ 2016 2025 2036 2051 2064 2069 
+ 2017 2023 2038 2049 2071 2077 
+ 1980 1993 2040 2085 2099 2133 
+ 2021 2031 2032 2054 2061 2076 
+ 2009 2014 2041 2053 2072 2096 
+ 2023 2045 2077 2080 
+ 2024 2030 2043 2055 2075 2081 
+ 2025 2029 2044 2067 2069 2088 
+ 2004 2006 2042 2057 2074 2093 2098 
+ 2007 2009 2048 2058 2096 2102 
+ 2031 2039 2047 2059 2076 2089 
+ 2030 2036 2050 2064 2081 2087 
+ 1927 1937 2034 2037 2128 2155 2190 
+ 2006 2020 2052 2065 2093 2094 
+ 1978 2007 2027 2053 2102 2114 2141 
+ 2039 2041 2054 2072 2089 2090 
+ 1751 1812 1972 2195 2263 2540 
+ 2032 2042 2047 2074 2076 2092 
+ 372 612 1146 2078 4176 4383 15374 
+ 1924 1972 1997 2131 2195 2326 
+ 2036 2044 2055 2069 2087 2091 
+ 2020 2028 2057 2068 2094 2100 
+ 1961 1991 2079 2086 2150 2174 
+ 2029 2035 2051 2084 2088 2109 
+ 2028 2033 2065 2070 2097 2100 
+ 2044 2051 2064 2088 2091 
+ 2033 2038 2068 2071 2097 2101 
+ 2038 2045 2070 2077 2101 2103 
+ 2041 2048 2059 2090 2096 2107 
+ 1028 1249 2171 2193 3690 3813 
+ 2042 2052 2061 2092 2098 2106 
+ 2043 2050 2081 2105 
+ 2047 2054 2061 2089 2092 2110 
+ 2045 2049 2071 2080 2103 2104 
+ 612 1264 2062 2587 4169 4383 
+ 1961 1986 2066 2082 2154 2174 
+ 2049 2077 2104 2108 
+ 2050 2055 2075 2087 2105 2112 
+ 1986 2012 2079 2095 2154 2163 
+ 1890 1919 2018 2147 2207 2364 
+ 2035 2040 2067 2099 2109 2134 
+ 1980 1981 2046 2117 2133 2203 
+ 1991 2027 2066 2114 2150 2165 
+ 2055 2064 2081 2091 2112 2120 
+ 2051 2067 2069 2091 2109 2121 
+ 2054 2059 2076 2090 2110 2115 
+ 2059 2072 2089 2107 2115 
+ 2064 2069 2087 2088 2120 2121 
+ 2061 2074 2076 2106 2110 2122 
+ 2052 2057 2094 2098 2111 2113 
+ 2057 2065 2093 2100 2113 2123 
+ 2012 2034 2082 2128 2160 2163 
+ 2048 2053 2072 2102 2107 2132 2142 
+ 2068 2070 2100 2101 2118 2130 
+ 2052 2074 2093 2106 2111 2119 2126 
+ 2040 2046 2084 2133 2134 2177 
+ 2065 2068 2094 2097 2123 2130 2146 
+ 2070 2071 2097 2103 2118 2124 2136 
+ 2053 2058 2096 2141 2142 2166 
+ 2071 2077 2101 2104 2124 2129 
+ 2077 2080 2103 2108 2129 2135 
+ 2075 2081 2112 2137 
+ 2074 2092 2098 2122 2126 2138 
+ 2072 2090 2096 2115 2132 2140 
+ 2080 2104 2135 2137 
+ 2067 2084 2088 2121 2134 2162 
+ 2076 2089 2092 2115 2122 2144 2148 
+ 2093 2098 2113 2119 2127 
+ 2081 2087 2105 2120 2137 2159 
+ 2093 2094 2111 2123 2127 2139 
+ 2027 2058 2086 2141 2165 2181 
+ 2089 2090 2107 2110 2140 2148 
+ 1950 2018 2026 2207 2214 2356 
+ 1981 2026 2085 2203 2214 2333 
+ 2097 2101 2130 2136 2145 
+ 2098 2111 2126 2127 15307 
+ 2087 2091 2112 2121 2159 2178 
+ 2088 2091 2109 2120 2162 2178 
+ 2092 2106 2110 2138 2144 2157 
+ 2094 2100 2113 2139 2146 2149 2152 
+ 2101 2103 2129 2136 2143 
+ 1544 1895 1903 2489 2889 2990 
+ 2098 2106 2119 2138 2156 15307 
+ 2111 2113 2119 2139 2151 15307 
+ 2034 2056 2095 2160 2190 2223 
+ 2103 2104 2124 2135 2143 2153 
+ 2097 2100 2118 2145 2146 2176 
+ 1997 2037 2063 2155 2326 2553 
+ 2096 2107 2140 2142 2167 2185 
+ 2046 2085 2099 2177 2203 2244 
+ 2084 2099 2109 2162 2177 2206 
+ 2104 2108 2129 2137 2153 2161 
+ 2101 2118 2124 2143 2145 2158 
+ 2105 2108 2112 2135 2159 2161 2189 
+ 2106 2122 2126 2156 2157 2169 
+ 2113 2123 2127 2149 2151 2164 
+ 2107 2115 2132 2148 2167 2175 
+ 2058 2102 2114 2166 2181 2201 2224 
+ 2096 2102 2132 2166 2185 2188 
+ 2124 2129 2136 2153 2158 2168 
+ 2110 2122 2148 2157 2172 2180 
+ 2118 2130 2136 2158 2176 2182 
+ 2100 2123 2130 2152 2173 2176 
+ 1766 1919 1962 2083 2364 2685 3003 
+ 2110 2115 2140 2144 2175 2180 
+ 2123 2139 2152 2164 2170 
+ 2066 2086 2165 2174 2213 2239 
+ 2127 2139 2164 2179 2183 15307 
+ 2123 2146 2149 2170 2173 
+ 2129 2135 2143 2161 2168 2184 
+ 2079 2082 2163 2174 2251 2255 
+ 2037 2056 2131 2190 2367 2553 
+ 2126 2138 2169 2179 2187 15307 
+ 2122 2138 2144 2169 2172 2186 
+ 2136 2143 2145 2168 2182 2192 
+ 2112 2120 2137 2178 2189 2217 
+ 2095 2128 2163 2223 2241 
+ 2135 2137 2153 2184 2189 
+ 2109 2121 2134 2178 2206 2230 
+ 2082 2095 2154 2160 2241 2255 
+ 2139 2149 2151 2170 2183 2191 
+ 2086 2114 2150 2181 2213 2242 
+ 2102 2141 2142 2188 2201 2210 
+ 2132 2140 2175 2185 2199 2211 
+ 2143 2153 2158 2184 2192 2202 
+ 2138 2156 2157 2186 2187 2197 
+ 2149 2152 2164 2173 2191 2196 
+ 882 1028 2073 2700 3813 4525 
+ 2144 2157 2180 2186 2194 
+ 2146 2152 2170 2176 2196 2198 
+ 2066 2079 2150 2154 2239 2251 2294 
+ 2140 2148 2167 2180 2199 2204 
+ 2130 2145 2146 2173 2182 2198 2205 
+ 2099 2133 2134 2206 2244 2284 
+ 2120 2121 2159 2162 2217 2230 2272 
+ 2151 2156 2183 2187 2200 2208 15307 
+ 2144 2148 2172 2175 2194 2204 
+ 2114 2141 2165 2224 2242 2286 
+ 2145 2158 2176 2192 2205 2218 
+ 2151 2164 2179 2191 2200 2212 
+ 2153 2161 2168 2189 2202 2226 
+ 2132 2142 2167 2188 2211 2216 2227 
+ 2157 2169 2172 2194 2197 2209 
+ 2156 2169 2179 2197 2208 2215 
+ 2142 2166 2185 2210 2216 2221 
+ 2137 2159 2161 2184 2217 2226 2254 
+ 2056 2128 2155 2223 2345 2367 
+ 2164 2170 2183 2196 2212 2220 
+ 2158 2168 2182 2202 2218 2229 
+ 1249 1576 2073 2805 3690 3839 
+ 2172 2180 2186 2204 2209 2228 
+ 1972 2060 2063 2326 2540 2724 
+ 2170 2173 2191 2198 2220 2225 
+ 2169 2186 2187 2209 2215 2222 
+ 2173 2176 2196 2205 2225 2232 
+ 2167 2175 2204 2211 2238 2247 
+ 2179 2183 2208 2212 2233 2234 
+ 2141 2166 2210 2224 2240 2260 
+ 2168 2184 2192 2226 2229 2253 
+ 2085 2117 2133 2244 2333 2373 
+ 2175 2180 2194 2199 2228 2247 15308 
+ 2176 2182 2198 2218 2232 2245 
+ 2134 2162 2177 2230 2284 2319 
+ 2018 2083 2116 2356 2364 2650 
+ 2179 2187 2200 2215 2233 2235 
+ 2186 2194 2197 2222 2228 2237 
+ 2166 2188 2201 2221 2236 2240 
+ 2167 2185 2199 2227 2238 2248 
+ 2183 2191 2200 2220 2234 2243 
+ 2150 2165 2239 2242 2285 
+ 2026 2116 2117 2333 2356 2557 
+ 2187 2197 2208 2222 2231 2235 
+ 2185 2188 2221 2227 2246 2249 
+ 2159 2178 2189 2254 2272 2306 
+ 2182 2192 2205 2229 2245 2256 
+ 1495 1656 2312 2790 3581 3809 
+ 2191 2196 2212 2225 2243 2252 
+ 2188 2210 2216 2236 2246 
+ 2197 2209 2215 2231 2237 2250 
+ 2128 2160 2190 2241 2345 2350 
+ 2141 2181 2201 2260 2286 2297 
+ 2196 2198 2220 2232 2252 2262 
+ 2184 2189 2202 2253 2254 2277 
+ 2185 2211 2216 2248 2249 2259 
+ 2194 2204 2209 2237 2267 2278 15308 
+ 2192 2202 2218 2253 2256 2275 
+ 2162 2178 2206 2272 2319 2346 
+ 2215 2222 2235 2250 2257 
+ 2198 2205 2225 2245 2262 2271 
+ 2200 2208 2234 2235 2264 2265 
+ 2200 2212 2233 2243 2265 2268 
+ 2208 2215 2231 2233 2257 2264 
+ 2210 2221 2240 2246 2270 2276 
+ 2209 2222 2228 2250 2267 2269 
+ 2199 2211 2247 2248 2273 2274 
+ 2150 2174 2213 2285 2294 2327 
+ 2201 2210 2236 2260 2276 2290 
+ 2160 2163 2223 2255 2350 2377 
+ 2165 2181 2213 2285 2286 2352 
+ 2212 2220 2234 2252 2268 2282 
+ 2133 2177 2203 2284 2373 15309 
+ 2205 2218 2232 2256 2271 2288 
+ 2216 2221 2236 2249 2258 2270 
+ 2199 2204 2238 2273 2287 15308 
+ 2211 2227 2238 2259 2274 2283 
+ 2216 2227 2246 2258 2259 2266 
+ 2222 2231 2237 2257 2269 2279 
+ 2154 2174 2255 2294 2414 2418 
+ 2220 2225 2243 2262 2282 2289 
+ 2202 2226 2229 2275 2277 2295 
+ 2189 2217 2226 2277 2306 2314 2329 
+ 2154 2163 2241 2251 2377 2414 
+ 2218 2229 2245 2275 2288 2302 
+ 2231 2235 2250 2264 2279 2291 
+ 2246 2249 2266 2270 2281 
+ 2227 2248 2249 2266 2280 2283 
+ 2201 2224 2240 2290 2297 2323 
+ 1882 1984 3001 3305 15297 15355 
+ 2225 2232 2252 2271 2289 2299 
+ 1812 1903 2060 2489 2540 3033 3271 
+ 2233 2235 2257 2265 2291 2296 
+ 2233 2234 2264 2268 2296 2301 
+ 2249 2258 2259 2280 2281 2292 
+ 2228 2237 2269 2278 2293 2303 
+ 2234 2243 2265 2282 2301 2311 
+ 2237 2250 2267 2279 2293 2305 
+ 2236 2246 2258 2276 2281 2308 2310 
+ 2232 2245 2262 2288 2299 2317 
+ 2178 2217 2230 2306 2346 2371 
+ 2238 2247 2274 2287 2307 2309 
+ 2238 2248 2273 2283 2304 2309 
+ 2229 2253 2256 2295 2302 2325 
+ 2236 2240 2270 2290 2310 2320 
+ 2226 2253 2254 2295 2314 2321 
+ 2228 2267 2300 2303 2316 15308 
+ 2250 2257 2269 2291 2305 2315 
+ 2259 2266 2283 2292 2298 
+ 2258 2266 2270 2292 2308 2313 
+ 2243 2252 2268 2289 2311 2324 
+ 2248 2259 2274 2280 2298 2304 
+ 2177 2206 2244 2319 2449 15309 
+ 2213 2239 2242 2327 2352 2393 
+ 2181 2224 2242 2297 2352 2376 2429 
+ 2247 2273 2300 2307 2318 15308 
+ 2245 2256 2271 2302 2317 2336 
+ 2252 2262 2282 2299 2324 2335 
+ 2240 2260 2276 2320 2323 2344 
+ 2257 2264 2279 2296 2315 2332 
+ 2266 2280 2281 2298 2313 2322 
+ 2267 2269 2303 2305 2330 
+ 2174 2239 2251 2327 2418 2443 
+ 2253 2275 2277 2321 2325 2347 
+ 2264 2265 2291 2301 2332 2338 
+ 2224 2260 2286 2323 2376 2379 
+ 2280 2283 2292 2304 2322 2328 
+ 2262 2271 2289 2317 2335 2357 
+ 2278 2287 2316 2318 2334 2341 15308 
+ 2265 2268 2296 2311 2338 2351 
+ 2256 2275 2288 2325 2336 2363 
+ 2267 2278 2293 2316 2330 2349 
+ 2274 2283 2298 2309 2328 2331 
+ 2269 2279 2293 2315 2330 2362 
+ 2217 2254 2272 2329 2371 2398 
+ 2273 2287 2309 2318 2339 2340 
+ 2270 2281 2310 2313 2342 2343 
+ 2273 2274 2304 2307 2331 2340 2353 
+ 2270 2276 2308 2320 2343 2355 
+ 2268 2282 2301 2324 2351 2360 
+ 1495 1882 2219 3001 3581 15350 
+ 2281 2292 2308 2322 2342 2348 
+ 2254 2277 2321 2329 2375 2400 
+ 2279 2291 2305 2332 2362 2372 
+ 2278 2300 2303 2341 2349 2361 
+ 2271 2288 2299 2336 2357 2383 
+ 2287 2300 2307 2334 2337 2339 
+ 2206 2230 2284 2346 2449 2507 
+ 2276 2290 2310 2344 2355 2374 
+ 2277 2295 2314 2347 2375 
+ 2292 2298 2313 2328 2348 2354 
+ 2260 2290 2297 2344 2379 2388 
+ 2282 2289 2311 2335 2360 2378 
+ 2275 2295 2302 2347 2363 2392 
+ 2063 2131 2195 2553 2724 2909 
+ 2239 2285 2294 2393 2443 2499 
+ 2298 2304 2322 2331 2354 2359 
+ 2254 2306 2314 2398 2400 
+ 2293 2303 2305 2349 2362 2387 
+ 2304 2309 2328 2353 2359 2369 
+ 2291 2296 2315 2338 2372 2386 
+ 2117 2203 2214 2373 2557 2638 2776 
+ 2300 2318 2337 2341 2365 2368 
+ 2289 2299 2324 2357 2378 2401 
+ 2288 2302 2317 2363 2383 2408 
+ 2318 2334 2339 2358 2365 
+ 2296 2301 2332 2351 2386 2394 
+ 2307 2318 2337 2340 2358 2366 
+ 2307 2309 2339 2353 2366 2370 
+ 2300 2316 2334 2361 2368 2384 
+ 2308 2313 2343 2348 2380 2381 
+ 2308 2310 2342 2355 2381 2390 
+ 2290 2320 2323 2374 2388 2403 
+ 2190 2223 2350 2367 2590 2742 
+ 2230 2272 2319 2371 2505 2507 
+ 2295 2321 2325 2375 2392 2417 
+ 2313 2322 2342 2354 2380 2385 
+ 2303 2316 2330 2361 2387 2397 
+ 2223 2241 2345 2377 2495 2590 
+ 2301 2311 2338 2360 2394 2405 
+ 2242 2285 2286 2393 2429 2480 2518 
+ 2309 2331 2340 2369 2370 2389 
+ 2322 2328 2348 2359 2385 2391 
+ 2310 2320 2343 2374 2390 2402 
+ 2116 2207 2214 2557 2650 2852 
+ 2299 2317 2335 2383 2401 2427 
+ 2337 2339 2365 2366 2382 
+ 2328 2331 2354 2369 2391 2399 
+ 2311 2324 2351 2378 2405 2421 
+ 2316 2341 2349 2384 2397 2407 
+ 2305 2315 2330 2372 2387 2415 2422 
+ 2302 2325 2336 2392 2408 2436 
+ 2083 2147 2207 2650 3003 3250 
+ 2334 2337 2358 2368 2382 2395 
+ 2339 2340 2358 2370 2382 2396 
+ 2155 2190 2345 2553 2742 2945 
+ 2334 2341 2365 2384 2395 2404 
+ 2331 2353 2359 2389 2399 2409 
+ 2340 2353 2366 2389 2396 2406 
+ 2272 2306 2346 2398 2505 2517 
+ 2315 2332 2362 2386 2415 2428 
+ 2203 2244 2333 2596 2638 15309 
+ 2320 2344 2355 2402 2403 2426 
+ 2314 2321 2347 2400 2417 2446 
+ 2286 2297 2379 2429 2454 2469 
+ 2241 2255 2350 2414 2495 2577 
+ 2324 2335 2360 2401 2421 2441 
+ 2297 2323 2376 2388 2434 2454 
+ 2342 2348 2381 2385 2411 2412 
+ 2342 2343 2380 2390 2411 2416 
+ 2358 2365 2366 2395 2396 2410 
+ 2317 2336 2357 2408 2427 2455 
+ 2341 2361 2368 2404 2407 2419 
+ 2348 2354 2380 2391 2412 2413 
+ 2332 2338 2372 2394 2428 2433 
+ 2330 2349 2362 2397 2422 2432 
+ 2323 2344 2379 2403 2434 2451 
+ 2353 2369 2370 2406 2409 2423 
+ 2343 2355 2381 2402 2416 2430 
+ 2354 2359 2385 2399 2413 2420 
+ 2325 2347 2363 2417 2436 15310 
+ 2285 2327 2352 2480 2499 2543 
+ 2338 2351 2386 2405 2433 2453 
+ 2365 2368 2382 2404 2410 2424 
+ 2366 2370 2382 2406 2410 2425 
+ 2349 2361 2387 2407 2432 2435 
+ 2306 2329 2371 2400 2477 2517 
+ 2359 2369 2391 2409 2420 2431 
+ 2314 2329 2375 2398 2446 2477 
+ 2335 2357 2378 2427 2441 2467 
+ 2355 2374 2390 2426 2430 2450 
+ 2344 2374 2388 2426 2451 2460 
+ 2368 2384 2395 2419 2424 2437 
+ 2351 2360 2394 2421 2453 2465 
+ 2370 2389 2396 2423 2425 2438 
+ 2361 2384 2397 2419 2435 2445 
+ 2336 2363 2383 2436 2455 2482 
+ 2369 2389 2399 2423 2431 2442 
+ 2382 2395 2396 2424 2425 2439 
+ 2380 2381 2412 2416 2440 2448 
+ 2380 2385 2411 2413 2440 2444 
+ 2385 2391 2412 2420 2444 2452 
+ 2251 2255 2377 2418 2577 2578 2608 
+ 2362 2372 2422 2428 2464 2468 
+ 2381 2390 2411 2430 2448 2456 
+ 2347 2375 2392 2446 2503 15310 
+ 2251 2294 2414 2443 2578 2614 
+ 2384 2404 2407 2437 2445 2462 
+ 2391 2399 2413 2431 2452 2457 
+ 2360 2378 2405 2441 2465 2481 
+ 2362 2387 2415 2432 2464 2485 
+ 2389 2406 2409 2438 2442 2461 
+ 2395 2404 2410 2437 2439 2459 
+ 2396 2406 2410 2438 2439 2458 
+ 2374 2402 2403 2450 2460 2472 
+ 2357 2383 2401 2455 2467 2492 
+ 2372 2386 2415 2433 2468 2479 
+ 2286 2352 2376 2469 2518 2522 
+ 2390 2402 2416 2450 2456 2466 
+ 2399 2409 2420 2442 2457 2463 
+ 2387 2397 2422 2435 2470 2485 
+ 2386 2394 2428 2453 2479 2488 
+ 2379 2388 2451 2454 2490 2494 
+ 2397 2407 2432 2445 2470 2475 
+ 2363 2392 2408 2482 2515 15310 
+ 2404 2419 2424 2459 2462 2474 
+ 2406 2423 2425 2458 2461 2473 
+ 2410 2424 2425 2458 2459 2471 
+ 2411 2412 2444 2448 
+ 2378 2401 2421 2467 2481 2504 
+ 2409 2423 2431 2461 2463 2476 
+ 2294 2327 2418 2499 2611 2614 
+ 2412 2413 2440 2452 
+ 2407 2419 2435 2462 2475 2478 
+ 2375 2400 2417 2477 2503 2534 
+ 2019 2587 3675 15299 15364 
+ 2411 2416 2440 2456 
+ 2284 2319 2507 2606 2641 15309 
+ 2402 2426 2430 2466 2472 2484 
+ 2388 2403 2434 2460 2490 2491 
+ 2413 2420 2444 2457 
+ 2394 2405 2433 2465 2488 2500 
+ 2376 2379 2434 2469 2494 2509 
+ 2383 2408 2427 2482 2492 2521 
+ 2416 2430 2448 2466 
+ 2420 2431 2452 2463 
+ 2425 2438 2439 2471 2473 15311 
+ 2424 2437 2439 2471 2474 2483 
+ 2403 2426 2451 2472 2491 2498 
+ 2423 2438 2442 2473 2476 2486 
+ 2419 2437 2445 2474 2478 2487 
+ 2431 2442 2457 2476 
+ 2415 2422 2468 2485 2508 2513 
+ 2405 2421 2453 2481 2500 2519 
+ 2430 2450 2456 2484 
+ 2401 2427 2441 2492 2504 2526 
+ 2415 2428 2464 2479 2508 2516 
+ 2376 2429 2454 2509 2522 2537 
+ 2432 2435 2475 2485 2502 2510 
+ 2439 2458 2459 2483 15311 15312 
+ 2426 2450 2460 2484 2498 2506 
+ 2438 2458 2461 2486 2497 15311 
+ 2437 2459 2462 2483 2487 2496 
+ 2435 2445 2470 2478 2493 2502 
+ 2442 2461 2463 2486 
+ 2398 2400 2446 2517 2534 2571 
+ 2445 2462 2475 2487 2493 2501 
+ 2428 2433 2468 2488 2516 2523 
+ 2352 2393 2518 2543 2551 2581 
+ 2421 2441 2465 2504 2519 2539 
+ 2408 2436 2455 2515 2521 2548 
+ 2459 2471 2474 2496 2511 15312 
+ 2450 2466 2472 2506 
+ 2422 2432 2464 2470 2510 2513 2532 
+ 2461 2473 2476 2497 
+ 2462 2474 2478 2496 2501 2514 
+ 2433 2453 2479 2500 2523 2536 
+ 1903 2125 2263 2990 3033 3393 
+ 2434 2451 2491 2494 2527 2530 
+ 2451 2460 2490 2498 2527 2529 
+ 2427 2455 2467 2521 2526 2554 
+ 2475 2478 2501 2502 2520 
+ 2434 2454 2490 2509 2530 2541 
+ 2350 2377 2577 2590 2692 
+ 2474 2483 2487 2511 2514 2525 
+ 2473 2486 2512 15311 
+ 2460 2472 2491 2506 2529 2531 
+ 2327 2393 2443 2543 2611 2612 
+ 2453 2465 2488 2519 2536 2550 
+ 2478 2487 2493 2514 2520 2528 
+ 2470 2475 2493 2510 2520 2533 
+ 2417 2446 2534 2546 2591 15310 
+ 2441 2467 2481 2526 2539 2561 
+ 2346 2371 2507 2517 2639 2674 
+ 2472 2484 2498 2531 
+ 2319 2346 2449 2505 2641 2674 2713 
+ 2464 2468 2513 2516 2545 2547 
+ 2454 2469 2494 2537 2541 2558 
+ 2470 2485 2502 2532 2533 2549 
+ 2483 2496 2524 2525 2538 15312 
+ 2497 2524 15311 15312 
+ 2464 2485 2508 2532 2545 2559 
+ 2487 2496 2501 2525 2528 2542 
+ 2436 2482 2546 2548 2585 15310 
+ 2468 2479 2508 2523 2547 2556 
+ 2371 2398 2477 2505 2571 2639 2669 
+ 2352 2429 2480 2522 2551 2576 2593 
+ 2465 2481 2500 2539 2550 2572 
+ 2493 2501 2502 2528 2533 2544 
+ 2455 2482 2492 2548 2554 2583 
+ 2429 2469 2518 2537 2575 2576 
+ 2479 2488 2516 2536 2556 2567 
+ 2511 2512 2538 15312 
+ 2496 2511 2514 2538 2542 2552 
+ 2467 2492 2504 2554 2561 15313 
+ 2490 2491 2529 2530 2563 2564 
+ 2501 2514 2520 2542 2544 2555 
+ 2491 2498 2527 2531 2562 2563 
+ 2490 2494 2527 2541 2564 2573 
+ 2498 2506 2529 2562 
+ 2485 2510 2513 2549 2559 2568 2569 
+ 2502 2510 2520 2544 2549 2560 
+ 2446 2477 2503 2571 2591 2637 
+ 226 275 361 5293 5550 6549 
+ 2488 2500 2523 2550 2567 2582 
+ 2469 2509 2522 2558 2575 2586 
+ 2511 2524 2525 2552 
+ 2481 2504 2519 2561 2572 2595 
+ 2060 2195 2263 2724 3271 3518 
+ 2494 2509 2530 2558 2573 2580 
+ 2514 2525 2528 2552 2555 2566 
+ 2393 2480 2499 2581 2612 2658 
+ 2520 2528 2533 2555 2560 2570 
+ 2508 2513 2547 2559 2584 2588 
+ 2503 2515 2585 2591 2630 15310 
+ 2508 2516 2545 2556 2584 2592 
+ 2482 2515 2521 2583 2585 2625 
+ 2510 2532 2533 2560 2569 2574 
+ 2500 2519 2536 2572 2582 2603 
+ 2480 2518 2581 2593 2618 
+ 2525 2538 2542 2566 
+ 2131 2155 2326 2367 2909 2945 3134 
+ 2492 2521 2526 2583 2621 15313 
+ 2528 2542 2544 2566 2570 2579 
+ 2516 2523 2547 2567 2592 2602 
+ 2214 2333 2356 2776 2852 3019 
+ 2509 2537 2541 2580 2586 2599 
+ 2513 2532 2545 2568 2588 15314 
+ 2533 2544 2549 2570 2574 2589 
+ 2504 2526 2539 2595 2623 15313 
+ 2529 2531 2563 2598 
+ 2527 2529 2562 2564 2598 2601 
+ 2527 2530 2563 2573 2601 2605 
+ 293 295 3697 3878 4830 4888 
+ 2542 2552 2555 2579 
+ 2523 2536 2556 2582 2602 2615 
+ 2532 2559 2569 2597 15314 
+ 2532 2549 2568 2574 2594 2597 
+ 2544 2555 2560 2579 2589 2600 
+ 2477 2517 2534 2637 2669 2695 
+ 2519 2539 2550 2595 2603 2629 
+ 2530 2541 2564 2580 2605 2609 
+ 2549 2560 2569 2589 2594 2604 
+ 2522 2537 2576 2586 2607 2610 
+ 2518 2522 2575 2593 2607 2624 
+ 2377 2414 2495 2608 2692 2759 
+ 2414 2418 2608 2614 2680 2687 
+ 2555 2566 2570 2600 
+ 2541 2558 2573 2599 2609 2628 
+ 2480 2543 2551 2618 2658 2666 
+ 2536 2550 2567 2603 2615 2635 
+ 2521 2548 2554 2621 2625 15315 
+ 2545 2547 2588 2592 2620 2626 
+ 2515 2546 2548 2625 2630 2665 
+ 2537 2558 2575 2599 2610 2622 
+ 1264 2078 2447 4169 15299 15364 
+ 2545 2559 2584 2619 2620 15314 
+ 2560 2570 2574 2600 2604 2613 
+ 2345 2350 2495 2692 2742 2811 
+ 2503 2534 2546 2630 2637 2671 
+ 2547 2556 2584 2602 2626 2632 
+ 2518 2551 2576 2618 2624 2645 
+ 2569 2574 2597 2604 2616 2627 
+ 2539 2561 2572 2623 2629 2651 
+ 2373 2606 2638 2753 2834 15309 
+ 2568 2569 2594 2616 2617 15314 
+ 2562 2563 2601 2634 
+ 2558 2580 2586 2622 2628 2631 
+ 2570 2579 2589 2613 
+ 2563 2564 2598 2605 2634 2642 
+ 2556 2567 2592 2615 2632 2648 
+ 2550 2572 2582 2629 2635 2659 
+ 2574 2589 2594 2613 2627 2633 
+ 2564 2573 2601 2609 2642 2647 
+ 2449 2596 2641 2752 2753 15309 
+ 2575 2576 2610 2624 2636 2657 
+ 2414 2577 2578 2680 2754 2759 
+ 2573 2580 2605 2628 2647 2652 
+ 2575 2586 2607 2622 2636 2646 
+ 2443 2499 2612 2614 2715 2716 
+ 2499 2543 2611 2658 2697 2715 
+ 2589 2600 2604 2633 
+ 2418 2443 2578 2611 2687 2716 2740 
+ 2567 2582 2602 2635 2648 2664 
+ 2594 2597 2617 2627 2640 2644 
+ 2597 2616 2619 2640 2643 15314 
+ 2551 2581 2593 2645 2666 2690 
+ 2588 2617 2620 2643 2649 15314 
+ 2584 2588 2619 2626 2649 2656 
+ 2554 2583 2653 2688 15313 15315 
+ 2586 2599 2610 2631 2646 2655 
+ 2561 2595 2651 2653 2676 15313 
+ 2576 2593 2607 2645 2657 2673 
+ 2548 2583 2585 2665 2703 15315 
+ 2584 2592 2620 2632 2656 2662 
+ 2594 2604 2616 2633 2644 2654 
+ 2580 2599 2609 2631 2652 2661 
+ 2572 2595 2603 2651 2659 2679 
+ 2546 2585 2591 2665 2671 2701 
+ 2599 2622 2628 2655 2661 
+ 2592 2602 2626 2648 2662 2675 
+ 2604 2613 2627 2654 
+ 2598 2601 2642 2672 
+ 2582 2603 2615 2659 2664 2684 
+ 2607 2610 2646 2657 2670 
+ 2534 2571 2591 2671 2695 2712 
+ 2333 2373 2596 2776 2834 2923 
+ 2505 2517 2669 2674 2761 2768 
+ 2616 2617 2643 2644 2660 2663 
+ 2449 2507 2606 2713 2752 2809 
+ 2601 2605 2634 2647 2672 2678 
+ 2617 2619 2640 2649 2660 2667 
+ 2616 2627 2640 2654 2663 2668 
+ 2593 2618 2624 2673 2690 2711 
+ 2610 2622 2636 2655 2670 2677 
+ 2605 2609 2642 2652 2678 2683 
+ 2602 2615 2632 2664 2675 2694 
+ 2619 2620 2643 2656 2667 2681 
+ 2207 2356 2364 2852 3250 3316 
+ 2595 2623 2629 2676 2679 2699 
+ 2609 2628 2647 2661 2683 2686 
+ 2621 2623 2676 2688 2705 15313 
+ 2627 2633 2644 2668 
+ 2622 2631 2646 2661 2677 2691 
+ 2620 2626 2649 2662 2681 2693 
+ 2607 2624 2636 2670 2673 2702 
+ 2543 2581 2612 2666 2697 2726 2736 
+ 2603 2629 2635 2679 2684 2706 
+ 2640 2643 2663 2667 2682 
+ 2628 2631 2652 2655 2686 2691 
+ 2626 2632 2656 2675 2693 2698 
+ 2640 2644 2660 2668 2682 2689 
+ 2615 2635 2648 2684 2694 2707 
+ 2585 2625 2630 2701 2703 2738 
+ 2581 2618 2658 2690 2726 2729 
+ 2643 2649 2660 2681 2682 2696 
+ 2644 2654 2663 2689 
+ 2517 2571 2639 2695 2764 2768 
+ 2636 2646 2657 2677 2702 2710 
+ 2591 2630 2637 2701 2712 2732 
+ 2634 2642 2678 2708 
+ 2624 2645 2657 2702 2711 2746 
+ 2505 2507 2639 2713 2761 2774 
+ 2632 2648 2662 2694 2698 15316 
+ 2623 2651 2653 2699 2705 2721 
+ 2646 2655 2670 2691 2710 2717 
+ 2642 2647 2672 2683 2708 2714 
+ 2629 2651 2659 2699 2706 2725 
+ 2578 2608 2687 2750 2754 
+ 2649 2656 2667 2693 2696 2709 2722 
+ 2660 2663 2667 2689 2696 2704 
+ 2647 2652 2678 2686 2714 2719 
+ 2635 2659 2664 2706 2707 2735 
+ 1962 2147 2755 3003 3755 3759 
+ 2652 2661 2683 2691 2718 2719 
+ 2578 2614 2680 2740 2750 2757 
+ 2621 2653 2705 2727 2734 15315 
+ 2663 2668 2682 2704 
+ 2618 2645 2666 2711 2729 2733 
+ 2655 2661 2677 2686 2717 2718 
+ 2495 2577 2590 2759 2811 2870 
+ 2656 2662 2681 2698 2709 2720 
+ 2648 2664 2675 2707 2728 15316 
+ 2571 2637 2669 2712 2762 2764 
+ 2667 2681 2682 2704 2722 2723 
+ 2612 2658 2715 2736 2766 
+ 2662 2675 2693 2720 2731 15316 
+ 2651 2676 2679 2721 2725 2741 
+ 882 1168 2171 4501 4525 4893 
+ 2630 2665 2671 2732 2738 2778 
+ 2657 2670 2673 2710 2746 2747 
+ 2625 2665 2727 2738 2787 2801 15315 
+ 2682 2689 2696 2723 
+ 2653 2676 2688 2721 2734 2739 
+ 2659 2679 2684 2725 2735 2749 
+ 2664 2684 2694 2728 2735 2760 
+ 2672 2678 2714 2743 
+ 2681 2693 2720 2722 2730 2737 
+ 2670 2677 2702 2717 2747 15318 
+ 2645 2673 2690 2733 2746 2758 
+ 2637 2671 2695 2732 2762 2771 
+ 2507 2641 2674 2774 2809 2828 2868 
+ 2678 2683 2708 2719 2743 2745 
+ 2611 2612 2697 2716 2766 2784 2817 
+ 2611 2614 2715 2740 2784 2788 
+ 2677 2691 2710 2718 2748 15318 
+ 2686 2691 2717 2719 2748 15320 
+ 2683 2686 2714 2718 2745 15320 
+ 2693 2698 2709 2731 2737 15319 
+ 2676 2699 2705 2739 2741 2756 
+ 2681 2696 2709 2723 2730 15317 
+ 2696 2704 2722 15317 
+ 2195 2326 2540 2909 3336 3518 
+ 2679 2699 2706 2741 2749 2779 
+ 2658 2666 2729 2736 2765 2772 
+ 2688 2703 2734 2783 2787 15315 
+ 2694 2707 2744 2760 2773 15316 
+ 2666 2690 2726 2733 2765 2767 
+ 2709 2722 2737 2751 15317 
+ 2698 2720 2744 2763 15316 15319 
+ 2671 2701 2712 2771 2778 2807 
+ 2690 2711 2729 2758 2767 2769 
+ 2688 2705 2727 2739 2775 2783 
+ 2684 2706 2707 2749 2760 2785 2789 
+ 2658 2697 2726 2766 2772 2798 
+ 2709 2720 2730 2751 2770 15319 
+ 2665 2701 2703 2778 2801 15322 
+ 2705 2721 2734 2756 2775 
+ 2614 2687 2716 2757 2788 2819 
+ 2699 2721 2725 2756 2779 2795 
+ 2345 2367 2590 2811 2945 3067 3137 
+ 2708 2714 2745 2782 
+ 2728 2731 2763 2773 2781 15316 
+ 2714 2719 2743 2782 2786 15320 
+ 2673 2702 2711 2747 2758 2799 2804 
+ 2702 2710 2746 2794 2799 15318 
+ 2717 2718 2791 2793 15318 15320 
+ 2706 2725 2735 2779 2785 2816 
+ 2680 2687 2754 2757 2831 2856 
+ 2730 2737 2770 2777 15317 
+ 2606 2641 2753 2809 2854 2901 
+ 2596 2606 2752 2834 2901 2960 
+ 2608 2680 2750 2759 2856 2905 
+ 1962 1984 2685 3305 3759 3960 
+ 2721 2739 2741 2775 2795 2813 
+ 2687 2740 2750 2819 2831 
+ 2711 2733 2746 2769 2804 2808 
+ 2577 2608 2692 2754 2870 2905 2973 
+ 2707 2728 2735 2773 2789 2792 
+ 2639 2674 2768 2774 2857 2863 
+ 2695 2712 2764 2771 2829 2847 
+ 2731 2744 2780 2781 15319 15321 
+ 2669 2695 2762 2768 2847 15323 
+ 2726 2729 2767 2772 2797 2803 
+ 2697 2715 2736 2798 2817 2823 
+ 2729 2733 2765 2769 2803 2806 
+ 2639 2669 2761 2764 2863 15323 
+ 2733 2758 2767 2806 2808 
+ 2737 2751 2777 2780 2796 15319 
+ 2712 2732 2762 2807 2829 
+ 2726 2736 2765 2797 2798 2824 
+ 2728 2744 2760 2781 2792 2802 
+ 2674 2713 2761 2828 2857 
+ 2734 2739 2756 2783 2813 2821 
+ 2333 2557 2638 2923 3019 3122 
+ 2751 2770 2796 
+ 2701 2732 2738 2807 2850 15322 
+ 2725 2741 2749 2795 2816 2841 
+ 2763 2770 2796 2800 15319 15321 
+ 2744 2763 2773 2802 2810 15321 
+ 2743 2745 2786 2822 
+ 2727 2734 2775 2787 2821 2826 
+ 2715 2716 2788 2817 2849 2862 
+ 2735 2749 2789 2812 2816 2839 
+ 2745 2782 2791 2822 2827 15320 
+ 2703 2727 2783 2801 2826 2837 
+ 2716 2740 2784 2819 2849 2861 
+ 2735 2760 2785 2792 2812 2815 
+ 1656 2019 2219 3675 3809 4157 
+ 2748 2786 2793 2827 2832 15320 
+ 2760 2773 2789 2802 2815 2820 
+ 2748 2791 2794 2832 2835 15318 
+ 2747 2793 2799 2835 2840 15318 
+ 2741 2756 2779 2813 2841 2858 
+ 2770 2777 2780 2800 2818 
+ 2765 2772 2803 2824 2833 
+ 2736 2766 2772 2823 2824 2866 
+ 2746 2747 2794 2804 2840 2842 
+ 2780 2796 2814 2818 15321 
+ 2703 2738 2787 2837 2855 15322 
+ 2773 2781 2792 2810 2820 2825 
+ 2765 2767 2797 2806 2833 2838 
+ 2746 2758 2799 2808 2842 2846 
+ 1576 1895 2193 2889 3839 3931 4130 
+ 2767 2769 2803 2808 2838 2845 
+ 2732 2771 2778 2829 2850 2882 
+ 2758 2769 2804 2806 2845 2846 
+ 2641 2713 2752 2854 2868 2916 
+ 2781 2802 2814 2825 2830 15321 
+ 2590 2692 2742 2870 3008 3067 
+ 2785 2789 2815 2839 2843 
+ 2756 2775 2795 2821 2858 2860 
+ 2800 2810 2818 2830 2836 15321 
+ 2789 2792 2812 2820 2843 2844 
+ 2749 2779 2785 2839 2841 2867 2879 
+ 2715 2766 2784 2823 2862 2880 2900 
+ 2796 2800 2814 2836 
+ 2740 2757 2788 2831 2861 2898 
+ 2792 2802 2815 2825 2844 2848 
+ 2775 2783 2813 2826 2860 2869 
+ 2782 2786 2827 2859 
+ 2766 2798 2817 2866 2880 
+ 2772 2797 2798 2833 2866 2877 
+ 2802 2810 2820 2830 2848 2851 
+ 2783 2787 2821 2837 2869 2875 
+ 2786 2791 2822 2832 2859 2872 
+ 2713 2774 2857 2868 15326 
+ 2762 2771 2807 2847 2882 15325 
+ 2810 2814 2825 2836 2851 2853 
+ 2750 2757 2819 2856 2898 2944 
+ 2791 2793 2827 2835 2872 2874 
+ 2797 2803 2824 2838 2877 2881 
+ 2596 2638 2753 2923 2960 3057 
+ 2793 2794 2832 2840 2874 2878 
+ 2814 2818 2830 2853 
+ 2787 2801 2826 2855 2875 2885 
+ 2803 2806 2833 2845 2881 2886 
+ 2785 2812 2816 2843 2864 2867 
+ 2794 2799 2835 2842 2878 2883 
+ 2779 2795 2816 2858 2879 2887 
+ 2799 2804 2840 2846 2883 2884 
+ 2812 2815 2839 2844 2864 2865 
+ 2815 2820 2843 2848 2865 2871 
+ 2806 2808 2838 2846 2886 2888 
+ 2804 2808 2842 2845 2884 2888 
+ 2762 2764 2829 2957 15323 15325 
+ 2820 2825 2844 2851 2871 2873 
+ 2784 2788 2861 2862 2902 2939 
+ 2778 2807 2882 2896 2925 15322 
+ 2825 2830 2848 2853 2873 2876 
+ 2356 2557 2650 3019 3316 3404 
+ 2830 2836 2851 2876 
+ 2752 2809 2901 2916 15329 
+ 2801 2837 2885 2893 2899 15322 
+ 2750 2754 2831 2905 2944 2998 
+ 2761 2774 2828 2863 2952 15326 
+ 2795 2813 2841 2860 2887 2906 2907 2935 
+ 2822 2827 2872 2903 
+ 2813 2821 2858 2869 2907 2918 
+ 2788 2819 2849 2898 2939 2965 
+ 2784 2817 2849 2900 2902 2936 
+ 2761 2768 2857 2952 3005 15323 
+ 2839 2843 2865 2867 2890 2891 
+ 2843 2844 2864 2871 2890 2892 
+ 2798 2823 2824 2877 2880 2929 2930 
+ 2816 2839 2864 2879 2891 2895 
+ 2713 2809 2828 2916 3002 15326 
+ 2821 2826 2860 2875 2912 2918 
+ 2692 2759 2811 2973 3008 3066 
+ 2844 2848 2865 2873 2892 2894 
+ 2827 2832 2859 2874 2903 2908 
+ 2848 2851 2871 2876 2894 2897 
+ 2832 2835 2872 2878 2908 2920 
+ 2826 2837 2869 2885 2912 2915 
+ 2851 2853 2873 2897 
+ 2824 2833 2866 2881 2930 2932 
+ 2835 2840 2874 2883 2920 2924 
+ 2816 2841 2867 2887 2895 2904 15324 
+ 2817 2823 2866 2900 2929 2941 
+ 2833 2838 2877 2886 2931 2932 
+ 2807 2829 2850 2925 2971 15325 
+ 2840 2842 2878 2884 2924 2926 
+ 2842 2846 2883 2888 2926 2928 
+ 2837 2855 2875 2899 2915 2922 
+ 2838 2845 2881 2888 2931 2934 
+ 2841 2858 2879 2906 2921 15324 
+ 2845 2846 2884 2886 2928 2934 
+ 1895 2125 2805 2990 3748 3931 
+ 2864 2865 2891 2892 2910 2913 
+ 2864 2867 2890 2895 2910 2911 
+ 2865 2871 2890 2894 2913 2917 
+ 2855 2896 2899 2933 2938 15322 
+ 2871 2873 2892 2897 2917 2919 
+ 2867 2879 2891 2904 2911 2914 
+ 2850 2893 2925 2938 2968 15322 
+ 2873 2876 2894 2919 
+ 2819 2831 2861 2944 2965 3011 
+ 2855 2885 2893 2922 2933 
+ 2817 2862 2880 2936 2941 2955 
+ 2752 2753 2854 2960 3125 15329 
+ 2849 2862 2936 2939 2967 
+ 2859 2872 2908 2954 
+ 2879 2895 2914 2927 2937 15324 
+ 2754 2759 2856 2973 2998 3060 
+ 2858 2887 2921 2935 2943 
+ 2858 2860 2918 2935 2951 2959 
+ 2872 2874 2903 2920 2954 2963 
+ 2326 2553 2724 3134 3336 3496 
+ 2890 2891 2911 2913 2942 15327 
+ 2891 2895 2910 2914 2940 2942 
+ 2869 2875 2915 2918 2949 2956 15328 
+ 2890 2892 2910 2917 2946 15327 
+ 2895 2904 2911 2937 2940 
+ 2875 2885 2912 2922 2953 2956 
+ 2809 2854 2868 3002 3083 15329 
+ 2892 2894 2913 2919 2946 2947 
+ 2860 2869 2907 2912 2949 2951 2974 
+ 2894 2897 2917 2947 
+ 2874 2878 2908 2924 2963 2972 
+ 2887 2906 2927 2943 2948 15324 
+ 2885 2899 2915 2933 2953 2962 
+ 2638 2776 2834 3057 3122 3206 
+ 2878 2883 2920 2926 2972 2975 
+ 2850 2882 2896 2968 2971 3010 
+ 2883 2884 2924 2928 2975 2977 
+ 2904 2921 2937 2948 2950 15324 
+ 2884 2888 2926 2934 2977 2979 
+ 2866 2880 2930 2941 2986 2989 
+ 2866 2877 2929 2932 2982 2986 
+ 2881 2886 2932 2934 2984 2985 
+ 2877 2881 2930 2931 2982 2985 
+ 2893 2899 2922 2938 2962 2970 
+ 2886 2888 2928 2931 2979 2984 
+ 2858 2906 2907 2943 2959 2981 
+ 2862 2900 2902 2955 2967 2999 
+ 2904 2914 2927 2940 2950 2958 
+ 2893 2896 2933 2968 2970 2992 
+ 2849 2861 2902 2965 2967 3007 
+ 2911 2914 2937 2942 2958 2961 
+ 2880 2900 2929 2955 2978 2989 
+ 2910 2911 2940 2961 2964 15327 
+ 2906 2921 2935 2948 2976 2981 
+ 2831 2856 2898 2998 3011 3068 
+ 2367 2553 2742 3134 3137 3311 3483 
+ 2913 2917 2947 2966 2969 15327 
+ 2917 2919 2946 2969 
+ 2921 2927 2943 2950 2976 2983 
+ 2912 2918 2974 2987 15328 
+ 2927 2937 2948 2958 2983 2988 
+ 2907 2918 2959 2974 2980 15330 
+ 2857 2863 3005 3044 3077 15326 
+ 2915 2922 2956 2962 3000 3014 
+ 2903 2908 2963 3009 
+ 2900 2936 2941 2978 2999 3024 
+ 2912 2915 2953 2994 3000 15328 
+ 2847 3015 3030 15323 15325 15331 
+ 2937 2940 2950 2961 2988 2991 
+ 2907 2935 2951 2980 2981 2996 
+ 2753 2834 2901 3057 3125 3169 
+ 2940 2942 2958 2964 2991 2993 
+ 2922 2933 2953 2970 3014 3029 
+ 2908 2920 2954 2972 3009 3018 
+ 2942 2961 2966 2993 2995 15327 
+ 2861 2898 2939 3007 3011 3062 
+ 2946 2964 2969 2995 2997 15327 
+ 2902 2936 2939 2999 3007 3046 
+ 2896 2925 2938 2992 3010 3031 
+ 2946 2947 2966 2997 
+ 2933 2938 2962 2992 3027 3029 
+ 2882 2925 3010 3015 3042 15325 
+ 2920 2924 2963 2975 3018 3028 
+ 2759 2870 2905 3060 3066 3140 
+ 2918 2949 2951 2987 3004 15330 
+ 2924 2926 2972 2977 3028 3032 
+ 2943 2948 2981 2983 3012 3013 
+ 2926 2928 2975 2979 3032 3035 
+ 2941 2955 2989 3024 3040 
+ 2928 2934 2977 2984 3035 3039 
+ 2951 2959 2996 3006 15330 
+ 2935 2943 2959 2976 2996 3012 3020 
+ 2930 2932 2985 2986 3037 3043 
+ 2948 2950 2976 2988 3013 3016 
+ 2931 2934 2979 2985 3039 3045 
+ 2931 2932 2982 2984 3043 3045 
+ 2929 2930 2982 2989 3037 3038 
+ 2949 2974 2994 3004 3034 15328 
+ 2950 2958 2983 2991 3016 3017 
+ 2929 2941 2978 2986 3038 3040 
+ 2125 2489 2889 3393 3716 3748 
+ 2958 2961 2988 2993 3017 3021 
+ 2938 2968 2970 3027 3031 
+ 2961 2964 2991 2995 3021 3023 
+ 2956 2987 3000 3034 3036 15328 
+ 2964 2966 2993 2997 3023 3026 
+ 2959 2980 2981 3006 3020 3022 
+ 2966 2969 2995 3026 
+ 2856 2905 2944 3060 3068 3141 
+ 2936 2955 2967 3024 3046 3065 
+ 2953 2956 2994 3014 3036 3056 
+ 1882 2261 2312 3994 15350 15355 
+ 2868 2916 3044 3083 3136 15326 
+ 2147 2364 2685 3250 3755 3760 
+ 2974 2987 3025 3034 3055 15330 
+ 2863 2952 3030 3077 3127 15323 15334 
+ 2980 2996 3022 3025 3041 15330 
+ 2939 2965 2967 3046 3062 3100 
+ 2811 2870 3066 3067 3159 3193 
+ 2954 2963 3018 3064 
+ 2925 2968 2971 3031 3042 3069 3082 
+ 2898 2944 2965 3062 3068 3120 
+ 2976 2981 3013 3020 3047 3051 
+ 2976 2983 3012 3016 3047 3048 
+ 2953 2962 3000 3029 3056 3059 
+ 2957 2971 3042 3073 3089 15325 15331 
+ 2983 2988 3013 3017 3048 3049 
+ 2988 2991 3016 3021 3049 3052 
+ 2963 2972 3009 3028 3064 3072 
+ 2557 2776 2852 3122 3404 3407 
+ 2981 2996 3012 3022 3050 3051 
+ 2991 2993 3017 3023 3052 3053 
+ 2996 3006 3020 3041 3050 
+ 2993 2995 3021 3026 3053 3054 
+ 2955 2978 2999 3040 3065 3087 
+ 3004 3006 3041 3055 3058 15330 
+ 2995 2997 3023 3054 
+ 2970 2992 3029 3031 3061 3063 
+ 2972 2975 3018 3032 3072 3081 
+ 2962 2970 3014 3027 3059 3061 3070 
+ 2957 3005 3112 15323 15331 15334 
+ 2968 2992 3010 3027 3063 3082 
+ 2975 2977 3028 3035 3081 3085 
+ 2263 2489 3271 3393 3596 3667 
+ 2987 2994 3004 3036 3055 3080 3084 
+ 2977 2979 3032 3039 3085 3092 
+ 2994 3000 3034 3056 3080 3086 
+ 2982 2986 3038 3043 3093 3097 
+ 2986 2989 3037 3040 3090 3093 
+ 2979 2984 3035 3045 3092 3095 
+ 2978 2989 3024 3038 3087 3090 
+ 3006 3022 3025 3050 3058 15332 
+ 2971 3010 3015 3069 3089 3110 
+ 2982 2985 3037 3045 3097 3099 
+ 2952 3002 3077 3136 3192 15326 
+ 2984 2985 3039 3043 3095 3099 
+ 2967 2999 3007 3065 3100 3118 
+ 3012 3013 3048 3051 3071 15333 
+ 3013 3016 3047 3049 3074 15333 
+ 3016 3017 3048 3052 3074 3076 
+ 3020 3022 3041 3051 3075 15332 
+ 3012 3020 3047 3050 3071 3075 
+ 3017 3021 3049 3053 3076 3078 
+ 3021 3023 3052 3054 3078 3079 
+ 3023 3026 3053 3079 
+ 3004 3025 3034 3058 3084 3088 
+ 3000 3014 3036 3059 3086 3094 
+ 2834 2923 2960 3169 3206 3268 3304 
+ 3025 3041 3055 3088 3096 15332 
+ 3014 3029 3056 3070 3094 3098 
+ 2905 2973 2998 3140 3141 3202 
+ 3027 3029 3063 3070 3091 
+ 2965 3007 3011 3100 3120 3168 
+ 3027 3031 3061 3082 3091 3104 
+ 3009 3018 3072 3117 
+ 2999 3024 3046 3087 3118 3144 
+ 2870 2973 3008 3140 3159 3226 
+ 2742 2811 3008 3137 3193 3196 
+ 2944 2998 3011 3120 3141 3225 
+ 3010 3042 3082 3110 3119 
+ 3029 3059 3061 3091 3098 3109 
+ 3047 3051 3075 3102 3103 15333 
+ 3018 3028 3064 3081 3117 3129 
+ 3015 3089 3114 3146 15331 
+ 3048 3049 3076 3105 3106 15333 
+ 3050 3051 3071 3101 3102 15332 
+ 3049 3052 3074 3078 3106 3107 
+ 2952 3005 3044 3127 3192 3204 
+ 3052 3053 3076 3079 3107 3108 
+ 3053 3054 3078 3108 
+ 3034 3036 3084 3086 3113 3116 
+ 3028 3032 3072 3085 3129 3139 
+ 3010 3031 3063 3069 3104 3119 3135 
+ 2916 3002 3136 3158 3210 15329 
+ 3034 3055 3080 3088 3113 3115 
+ 3032 3035 3081 3092 3139 3142 
+ 3036 3056 3080 3094 3116 3123 
+ 3024 3040 3065 3090 3144 3147 
+ 3055 3058 3084 3096 3115 3121 
+ 3015 3042 3073 3110 3114 3143 
+ 3038 3040 3087 3093 3147 3151 
+ 3061 3063 3070 3104 3109 3111 
+ 3035 3039 3085 3095 3142 3149 
+ 3037 3038 3090 3097 3151 3152 
+ 3056 3059 3086 3098 3123 3126 
+ 3039 3045 3092 3099 3149 3150 
+ 3058 3088 3101 3121 3124 15332 
+ 3037 3043 3093 3099 3152 3153 
+ 3059 3070 3094 3109 3126 3138 
+ 3043 3045 3095 3097 3150 3153 
+ 3007 3046 3062 3118 3168 3191 
+ 3075 3096 3102 3124 3128 15332 
+ 3071 3075 3101 3103 3128 3130 
+ 3071 3102 3105 3130 3131 15333 
+ 3063 3082 3091 3111 3135 3148 
+ 3074 3103 3106 3131 15333 15335 
+ 3074 3076 3105 3107 3133 15335 
+ 3076 3078 3106 3108 3132 3133 
+ 3078 3079 3107 3132 
+ 3070 3091 3098 3111 3138 3145 
+ 3042 3069 3089 3119 3143 3167 
+ 3091 3104 3109 3145 3148 
+ 3030 3146 3176 15331 15334 15337 
+ 3080 3084 3115 3116 3154 15336 
+ 3073 3089 3143 3146 3171 
+ 3084 3088 3113 3121 3154 3155 
+ 3080 3086 3113 3123 3156 15336 
+ 3064 3072 3129 3172 
+ 3046 3065 3100 3144 3191 3198 
+ 3069 3082 3110 3135 3167 3173 
+ 3011 3062 3068 3168 3225 3247 
+ 3088 3096 3115 3124 3155 3157 
+ 2776 2923 3019 3206 3407 3413 
+ 3086 3094 3116 3126 3156 3161 
+ 3096 3101 3121 3128 3157 3160 
+ 2901 2960 3158 3169 3254 3267 15329 
+ 3094 3098 3123 3138 3161 3170 
+ 3005 3077 3174 3204 3223 15334 
+ 3101 3102 3124 3130 3160 3163 
+ 3072 3081 3117 3139 3172 3180 
+ 3102 3103 3128 3131 3163 3165 
+ 3103 3105 3130 3165 3166 15335 
+ 3107 3108 3133 3162 
+ 3106 3107 3132 3162 3164 15335 
+ 2553 2909 2945 3483 3496 3574 
+ 3082 3104 3119 3148 3173 3188 
+ 3002 3044 3083 3192 3210 3251 
+ 2742 2945 3067 3196 3311 3323 
+ 3098 3109 3126 3145 3170 3175 
+ 3081 3085 3129 3142 3180 3190 
+ 2973 3060 3066 3202 3226 3284 
+ 2998 3060 3068 3202 3225 3262 
+ 3085 3092 3139 3149 3190 3195 
+ 3089 3110 3114 3167 3171 3197 
+ 3065 3087 3118 3147 3198 3200 
+ 3109 3111 3138 3148 3175 3189 
+ 3073 3112 3114 3171 3176 3217 15331 
+ 3087 3090 3144 3151 3200 3203 
+ 3104 3111 3135 3145 3188 3189 
+ 3092 3095 3142 3150 3195 3199 
+ 3095 3099 3149 3153 3199 3201 
+ 3090 3093 3147 3152 3203 3208 
+ 3093 3097 3151 3153 3208 3209 
+ 3097 3099 3150 3152 3201 3209 
+ 3113 3115 3155 3178 3179 15336 
+ 3115 3121 3154 3157 3179 3182 
+ 3116 3123 3161 3177 3181 15336 
+ 3121 3124 3155 3160 3182 15338 
+ 3083 3125 3210 3267 3303 15329 
+ 3008 3066 3193 3226 3263 
+ 3124 3128 3157 3163 3186 15338 
+ 3123 3126 3156 3170 3181 3194 
+ 3132 3133 3164 3183 
+ 3128 3130 3160 3165 3186 3187 
+ 3133 3162 3166 3183 3184 15335 
+ 3130 3131 3163 3166 3185 3187 
+ 3131 3164 3165 3184 3185 15335 
+ 3110 3119 3143 3173 3197 3224 
+ 3062 3100 3120 3191 3247 3282 
+ 2960 3057 3125 3254 3268 3320 
+ 3126 3138 3161 3175 3194 3205 
+ 3114 3143 3146 3197 3217 3234 
+ 3117 3129 3180 3227 
+ 3119 3135 3167 3188 3224 3228 
+ 3127 3207 3223 3233 15334 15337 
+ 3138 3145 3170 3189 3205 3229 
+ 3112 3146 3207 3217 3245 15337 
+ 3156 3178 3181 3212 3213 15336 
+ 3154 3177 3179 3213 3215 15336 
+ 3154 3155 3178 3182 3215 3219 
+ 3129 3139 3172 3190 3227 3235 
+ 3156 3161 3177 3194 3211 3212 
+ 3155 3157 3179 3219 3221 15338 
+ 3162 3164 3184 3214 
+ 3164 3166 3183 3185 3214 3216 
+ 3165 3166 3184 3187 3216 3218 
+ 3160 3163 3187 3220 3222 15338 
+ 3163 3165 3185 3186 3218 3220 
+ 3135 3148 3173 3189 3228 3231 
+ 3145 3148 3175 3188 3229 3231 
+ 3139 3142 3180 3195 3235 3246 
+ 3100 3118 3168 3198 3261 3282 
+ 3044 3077 3136 3204 3251 3313 15340 
+ 3008 3067 3159 3196 3263 3298 
+ 3161 3170 3181 3205 3211 3230 
+ 3142 3149 3190 3199 3246 3248 
+ 3067 3137 3193 3298 3323 
+ 3143 3167 3171 3224 3234 3257 
+ 3118 3144 3191 3200 3260 3261 
+ 3149 3150 3195 3201 3248 3252 
+ 3144 3147 3198 3203 3256 3260 
+ 3150 3153 3199 3209 3252 3253 
+ 3060 3140 3141 3262 3284 3334 
+ 3147 3151 3200 3208 3256 3259 
+ 3077 3127 3192 3223 3288 15340 
+ 3170 3175 3194 3229 3230 3249 
+ 2923 3057 3122 3304 3387 3413 
+ 3174 3176 3233 3245 3264 15337 
+ 3151 3152 3203 3209 3258 3259 
+ 3152 3153 3201 3208 3253 3258 
+ 3083 3136 3158 3251 3303 15343 
+ 3181 3194 3212 3230 3232 
+ 3177 3181 3211 3213 3232 3237 
+ 3177 3178 3212 3215 3237 3240 
+ 3183 3184 3216 3236 
+ 3178 3179 3213 3219 3240 3244 
+ 3184 3185 3214 3218 3236 3238 
+ 3146 3171 3176 3234 3245 3270 
+ 3185 3187 3216 3220 3238 3239 
+ 3179 3182 3215 3221 3243 3244 
+ 3186 3187 3218 3222 3239 3241 
+ 3182 3219 3222 3242 3243 15338 
+ 3186 3220 3221 3241 3242 15338 
+ 3127 3174 3204 3233 3288 15339 
+ 3167 3173 3197 3228 3257 3283 
+ 3068 3120 3141 3247 3262 3327 3329 
+ 3066 3140 3159 3263 3284 3333 
+ 3172 3180 3235 3280 
+ 3173 3188 3224 3231 3281 3283 
+ 3175 3189 3205 3231 3249 3278 3279 
+ 3194 3205 3211 3232 3249 3255 
+ 3188 3189 3228 3229 3279 3281 
+ 3211 3212 3230 3237 3255 3265 
+ 3174 3207 3223 3264 15339 
+ 3171 3197 3217 3257 3270 3293 
+ 3180 3190 3227 3246 3280 3286 
+ 3214 3216 3238 3266 
+ 3212 3213 3232 3240 3265 3273 
+ 3216 3218 3236 3239 3266 3269 
+ 3218 3220 3238 3241 3269 3272 
+ 3213 3215 3237 3244 3273 3277 
+ 3220 3222 3239 3242 3272 3274 
+ 3221 3222 3241 3243 3274 3275 
+ 3219 3221 3242 3244 3275 3276 
+ 3215 3219 3240 3243 3276 3277 
+ 3176 3207 3217 3264 3270 3308 
+ 3190 3195 3235 3248 3286 3294 
+ 3120 3168 3225 3282 3329 3339 
+ 3195 3199 3246 3252 3294 3301 
+ 3205 3229 3230 3255 3278 3285 
+ 2364 2650 3003 3316 3760 3777 
+ 3136 3192 3210 3313 3335 15343 
+ 3199 3201 3248 3253 3301 3302 
+ 3201 3209 3252 3258 3302 3306 
+ 3125 3169 3267 3320 3363 
+ 3230 3232 3249 3265 3285 3289 
+ 3200 3203 3259 3260 3310 3312 
+ 3197 3224 3234 3283 3293 15341 
+ 3208 3209 3253 3259 3306 3309 
+ 3203 3208 3256 3258 3309 3310 
+ 3198 3200 3256 3261 3312 3321 
+ 3191 3198 3260 3282 3321 3332 
+ 3141 3202 3225 3327 3334 3378 
+ 3159 3193 3226 3298 3333 3370 
+ 3207 3233 3245 3308 3331 15339 
+ 3232 3237 3255 3273 3289 3295 
+ 3236 3238 3269 3290 
+ 3125 3158 3254 3303 3363 3405 
+ 3057 3169 3304 3320 15345 
+ 3238 3239 3266 3272 3290 3291 
+ 3217 3234 3245 3293 3307 3308 
+ 2263 2540 3033 3518 3667 3869 
+ 3239 3241 3269 3274 3291 3292 
+ 3237 3240 3265 3277 3295 3300 
+ 3241 3242 3272 3275 3292 3296 
+ 3242 3243 3274 3276 3296 3297 
+ 3243 3244 3275 3277 3297 3299 
+ 3240 3244 3273 3276 3299 3300 
+ 3229 3249 3279 3285 3314 3317 
+ 3229 3231 3278 3281 3314 3330 
+ 3227 3235 3286 15344 
+ 3228 3231 3279 3283 3330 3338 
+ 3168 3191 3247 3261 3332 3339 3356 
+ 3224 3228 3257 3281 3338 3361 15341 
+ 3140 3202 3226 3333 3334 3390 
+ 3249 3255 3278 3289 3317 3318 
+ 3235 3246 3280 3294 3337 15344 
+ 446 1168 1987 4501 5174 5181 
+ 3204 3223 3341 3354 15339 15340 
+ 3255 3265 3285 3295 3318 15342 
+ 3266 3269 3291 3315 
+ 3269 3272 3290 3292 3315 3319 
+ 3272 3274 3291 3296 3319 3322 
+ 3234 3257 3270 3307 3342 15341 
+ 3246 3248 3286 3301 3337 3343 
+ 3265 3273 3289 3300 3328 15342 
+ 3274 3275 3292 3297 3322 3324 
+ 3275 3276 3296 3299 3324 3325 
+ 3193 3196 3263 3323 3370 3432 
+ 3276 3277 3297 3300 3325 3326 
+ 3273 3277 3295 3299 3326 3328 
+ 3248 3252 3294 3302 3343 3347 
+ 3252 3253 3301 3306 3347 3355 
+ 3158 3210 3267 3405 3458 15343 
+ 3057 3206 3268 3387 3424 15345 
+ 1984 2261 2755 3960 4172 15355 
+ 3253 3258 3302 3309 3355 3359 
+ 3270 3293 3308 3342 3358 
+ 3245 3264 3270 3307 3331 3358 3386 
+ 3258 3259 3306 3310 3359 3360 
+ 3256 3259 3309 3312 3360 3362 
+ 2945 3137 3323 3483 3501 3606 
+ 3256 3260 3310 3321 3362 3366 
+ 3192 3251 3335 3365 3383 15340 
+ 3278 3279 3317 3330 3353 3357 
+ 3290 3291 3319 3340 
+ 2650 2852 3250 3404 3777 3788 
+ 3278 3285 3314 3318 3348 3353 
+ 3285 3289 3317 3348 3349 15342 
+ 3291 3292 3315 3322 3340 3344 
+ 3169 3254 3268 3363 3438 15345 
+ 3260 3261 3312 3332 3366 3374 
+ 3292 3296 3319 3324 3344 3345 
+ 3137 3196 3298 3311 3432 3501 
+ 3296 3297 3322 3325 3345 3346 
+ 3297 3299 3324 3326 3346 3350 
+ 3299 3300 3325 3328 3350 3351 
+ 3225 3262 3329 3372 3378 3423 
+ 3295 3300 3326 3351 3352 15342 
+ 3225 3247 3327 3339 3372 3385 
+ 3279 3281 3314 3338 3357 3364 
+ 3264 3308 3341 3386 3397 15339 
+ 3261 3282 3321 3356 3374 3389 
+ 3226 3263 3284 3370 3390 3461 
+ 3202 3262 3284 3378 3390 3440 
+ 3251 3313 3383 3398 15343 
+ 2724 2909 3496 3518 3767 3782 
+ 3286 3294 3343 3376 3388 15344 
+ 3281 3283 3330 3361 3364 3382 
+ 3247 3282 3329 3356 3385 3401 
+ 3315 3319 3344 3367 
+ 3288 3331 3354 3397 3410 15339 
+ 3293 3307 3358 3369 3392 15341 
+ 3294 3301 3337 3347 3388 3395 
+ 3319 3322 3340 3345 3367 3368 
+ 3322 3324 3344 3346 3368 3371 
+ 3324 3325 3345 3350 3371 3373 
+ 3301 3302 3343 3355 3395 3400 
+ 3317 3318 3349 3353 3380 3381 
+ 3318 3348 3352 3379 3380 15342 
+ 3325 3326 3346 3351 3373 3375 
+ 3326 3328 3350 3352 3375 3377 
+ 3328 3349 3351 3377 3379 15342 
+ 3314 3317 3348 3357 3381 3384 
+ 3288 3341 3365 3410 3417 15340 
+ 3302 3306 3347 3359 3400 3408 
+ 3282 3332 3339 3389 3401 3418 
+ 3314 3330 3353 3364 3384 3391 
+ 3307 3308 3342 3386 3392 3460 
+ 3306 3309 3355 3360 3408 3414 
+ 3309 3310 3359 3362 3414 3421 
+ 3283 3338 3369 3382 3403 15341 15346 
+ 3310 3312 3360 3366 3421 3426 
+ 3254 3267 3320 3405 3438 3484 
+ 3330 3338 3357 3382 3391 3394 
+ 3313 3354 3383 3417 3420 15340 
+ 3312 3321 3362 3374 3425 3426 
+ 3340 3344 3368 3396 
+ 3344 3345 3367 3371 3396 3399 
+ 3342 3361 3392 3403 3428 15341 
+ 3263 3298 3333 3432 3461 3529 
+ 3345 3346 3368 3373 3399 3402 
+ 3327 3329 3385 3423 3436 
+ 3346 3350 3371 3375 3402 3406 
+ 3321 3332 3366 3389 3425 3427 
+ 3350 3351 3373 3377 3406 3409 
+ 3337 3388 3437 15344 
+ 3351 3352 3375 3379 3409 3412 
+ 3262 3327 3334 3423 3440 3477 
+ 3349 3352 3377 3380 3412 3415 
+ 3348 3349 3379 3381 3415 3416 
+ 3348 3353 3380 3384 3416 3419 
+ 3338 3361 3364 3394 3411 15346 
+ 3313 3335 3365 3398 3420 3463 
+ 3353 3357 3381 3391 3419 3422 
+ 3329 3339 3372 3401 3436 3448 
+ 3308 3331 3358 3397 3460 3469 
+ 3206 3304 3413 3424 3548 
+ 3337 3343 3376 3395 3437 3446 
+ 3332 3356 3374 3418 3427 3453 
+ 3284 3333 3334 3440 3461 3505 
+ 3357 3364 3384 3394 3422 3429 
+ 3342 3358 3369 3428 3460 3462 
+ 2489 2990 3033 3596 3716 3817 
+ 3364 3382 3391 3411 3429 3430 
+ 3343 3347 3388 3400 3446 3459 
+ 3367 3368 3399 3433 
+ 3331 3341 3386 3410 3469 15347 
+ 3335 3383 3458 3463 3514 15343 
+ 3368 3371 3396 3402 3433 3434 
+ 3347 3355 3395 3408 3459 3464 
+ 3339 3356 3385 3418 3448 3456 
+ 3371 3373 3399 3406 3434 3439 
+ 3361 3369 3428 3431 3444 15346 
+ 2852 3019 3316 3407 3788 3802 
+ 3267 3303 3363 3458 3484 3525 
+ 3373 3375 3402 3409 3439 3441 
+ 3019 3122 3404 3413 3623 3802 
+ 3355 3359 3400 3414 3464 3470 
+ 3375 3377 3406 3412 3441 3442 
+ 3341 3354 3397 3417 3486 15347 
+ 3382 3394 3430 3435 15346 
+ 3377 3379 3409 3415 3442 3445 
+ 3122 3206 3387 3407 3548 3623 
+ 3359 3360 3408 3421 3470 3472 
+ 3379 3380 3412 3416 3445 3447 
+ 3380 3381 3415 3419 3447 3450 
+ 3354 3365 3410 3420 3479 3486 
+ 3356 3389 3401 3453 3456 3485 
+ 3381 3384 3416 3422 3450 3451 
+ 3365 3383 3417 3463 3479 
+ 3360 3362 3414 3426 3472 3480 
+ 3384 3391 3419 3429 3451 3452 
+ 3327 3372 3378 3436 3477 15349 
+ 3304 3387 3548 3556 15345 15348 
+ 3366 3374 3426 3427 3466 3481 
+ 3362 3366 3421 3425 3480 3481 
+ 3374 3389 3425 3453 3466 
+ 3369 3392 3403 3444 3462 3473 
+ 3391 3394 3422 3430 3452 3457 
+ 3394 3411 3429 3435 3454 3457 
+ 3403 3443 3444 3449 15346 
+ 3298 3323 3370 3501 3529 3538 
+ 3396 3399 3434 3465 
+ 3399 3402 3433 3439 3465 3467 
+ 3411 3430 3443 3454 3455 15346 
+ 3372 3385 3423 3448 3517 15349 
+ 3376 3388 3446 3494 
+ 3320 3363 3484 3541 15345 15348 
+ 3402 3406 3434 3441 3467 3471 
+ 3334 3378 3390 3477 3505 3532 
+ 3406 3409 3439 3442 3471 3474 
+ 3409 3412 3441 3445 3474 3478 
+ 3431 3435 3449 3455 3468 15346 
+ 3403 3428 3431 3449 3473 3475 
+ 3412 3415 3442 3447 3478 3482 
+ 3388 3395 3437 3459 3494 3498 
+ 3415 3416 3445 3450 3482 3487 
+ 3385 3401 3436 3456 3513 3517 
+ 3431 3443 3444 3468 3475 
+ 3416 3419 3447 3451 3487 3488 
+ 3419 3422 3450 3452 3488 3490 
+ 3422 3429 3451 3457 3489 3490 
+ 3389 3418 3427 3466 3485 3500 
+ 3430 3435 3455 3457 3476 3491 
+ 3435 3443 3454 3468 3476 
+ 3401 3418 3448 3485 3513 
+ 3429 3430 3452 3454 3489 3491 
+ 3303 3398 3405 3514 3525 3591 15343 
+ 3395 3400 3446 3464 3498 3508 
+ 3358 3386 3392 3462 3469 3515 3524 
+ 3333 3370 3390 3505 3529 3611 
+ 3392 3428 3460 3473 3504 3515 
+ 3383 3398 3420 3479 3514 3540 
+ 3400 3408 3459 3470 3508 3516 
+ 3433 3434 3467 3493 
+ 3425 3427 3453 3481 3500 3523 
+ 3434 3439 3465 3471 3493 3495 
+ 3443 3449 3455 3475 3476 3492 
+ 3386 3397 3460 3524 3537 15347 
+ 3408 3414 3464 3472 3516 3520 
+ 3439 3441 3467 3474 3495 3497 
+ 3414 3421 3470 3480 3520 3522 
+ 3428 3444 3462 3475 3504 3512 
+ 3441 3442 3471 3478 3497 3499 
+ 3444 3449 3468 3473 3492 3512 
+ 3454 3455 3468 3491 3492 3503 
+ 3378 3423 3440 3532 3555 15349 
+ 3442 3445 3474 3482 3499 3502 
+ 3417 3420 3463 3486 3540 3551 
+ 3421 3426 3472 3481 3522 3527 
+ 3425 3426 3466 3480 3523 3527 
+ 3445 3447 3478 3487 3502 3507 
+ 2945 3134 3311 3574 3606 3714 3771 
+ 3363 3405 3438 3525 3541 3584 
+ 3418 3453 3456 3500 3513 3559 
+ 3410 3417 3479 3543 3551 15347 
+ 3447 3450 3482 3488 3507 3509 
+ 3450 3451 3487 3490 3509 3511 
+ 3452 3457 3490 3491 3506 3510 
+ 3451 3452 3488 3489 3510 3511 
+ 3454 3457 3476 3489 3503 3506 
+ 3468 3475 3476 3503 3512 15351 
+ 3465 3467 3495 3519 
+ 3437 3446 3498 3539 
+ 3467 3471 3493 3497 3519 3521 
+ 2909 3134 3336 3574 3773 3782 
+ 3471 3474 3495 3499 3521 3526 
+ 3446 3459 3494 3508 3539 3545 
+ 3474 3478 3497 3502 3526 3528 
+ 3453 3466 3485 3523 3559 3566 
+ 3311 3323 3432 3538 3606 3630 
+ 3478 3482 3499 3507 3528 3531 
+ 3476 3491 3492 3506 3530 15351 
+ 3462 3473 3512 3515 3544 3550 
+ 3390 3440 3461 3532 3611 3616 
+ 3489 3491 3503 3510 3530 3534 
+ 3482 3487 3502 3509 3531 3533 
+ 3459 3464 3498 3516 3545 3554 
+ 3487 3488 3507 3511 3533 3535 
+ 3489 3490 3506 3511 3534 3536 
+ 3488 3490 3509 3510 3535 3536 
+ 3473 3475 3492 3504 3544 3547 15351 
+ 3448 3456 3485 3517 3559 3573 
+ 3398 3458 3463 3540 3591 3604 
+ 3460 3462 3504 3524 3550 3564 
+ 3464 3470 3508 3520 3554 3560 
+ 3436 3448 3513 3569 3573 15349 
+ 2540 2724 3271 3336 3767 3869 3898 
+ 3493 3495 3521 3542 
+ 3470 3472 3516 3522 3560 3565 
+ 3495 3497 3519 3526 3542 3546 
+ 3472 3480 3520 3527 3565 3567 
+ 3466 3481 3500 3527 3566 3570 
+ 3460 3469 3515 3537 3564 3577 
+ 3405 3458 3484 3584 3591 3627 
+ 3497 3499 3521 3528 3546 3549 
+ 3480 3481 3522 3523 3567 3570 
+ 3499 3502 3526 3531 3549 3553 
+ 3370 3432 3461 3538 3611 3632 
+ 3503 3506 3534 3552 3558 15351 
+ 3502 3507 3528 3533 3553 3557 
+ 3440 3477 3505 3555 3613 3616 
+ 3507 3509 3531 3535 3557 3561 
+ 3506 3510 3530 3536 3558 3562 
+ 3509 3511 3533 3536 3561 3563 
+ 3510 3511 3534 3535 3562 3563 
+ 3469 3524 3543 3577 3594 15347 
+ 3432 3501 3529 3630 3632 
+ 3494 3498 3545 3582 
+ 3463 3479 3514 3551 3604 3617 
+ 3438 3484 3556 3584 3624 15348 
+ 3519 3521 3546 3568 
+ 3486 3537 3551 3594 3622 15347 
+ 3504 3512 3547 3550 3576 3580 
+ 3498 3508 3539 3554 3582 3588 
+ 3521 3526 3542 3549 3568 3571 
+ 3512 3544 3552 3576 3578 15351 
+ 3387 3413 3424 3556 3623 3648 3749 
+ 3526 3528 3546 3553 3571 3572 
+ 3504 3515 3544 3564 3580 3589 
+ 3479 3486 3540 3543 3617 3622 
+ 3530 3547 3558 3578 3583 15351 
+ 3528 3531 3549 3557 3572 3575 
+ 3508 3516 3545 3560 3588 3593 
+ 3477 3532 3569 3598 3613 15349 
+ 3424 3541 3548 3624 3648 15348 
+ 3531 3533 3553 3561 3575 3579 
+ 3530 3534 3552 3562 3583 3586 
+ 3485 3500 3513 3566 3573 3614 3633 
+ 3516 3520 3554 3565 3593 3597 
+ 3533 3535 3557 3563 3579 3585 
+ 3534 3536 3558 3563 3586 3587 
+ 3535 3536 3561 3562 3585 3587 
+ 3515 3524 3550 3577 3589 3600 
+ 3520 3522 3560 3567 3597 3602 
+ 3500 3523 3559 3570 3612 3614 
+ 3522 3527 3565 3570 3602 3609 
+ 3542 3546 3571 3590 
+ 3517 3555 3573 3598 3619 15349 
+ 3523 3527 3566 3567 3609 3612 
+ 3546 3549 3568 3572 3590 3592 
+ 3549 3553 3571 3575 3592 3595 
+ 3513 3517 3559 3569 3619 3633 
+ 3134 3483 3496 3771 3773 3829 
+ 3553 3557 3572 3579 3595 3599 
+ 3544 3547 3578 3580 3608 15352 
+ 3524 3537 3564 3594 3600 3641 
+ 3547 3552 3576 3583 3607 15352 
+ 3557 3561 3575 3585 3599 3601 
+ 3544 3550 3576 3589 3603 3608 
+ 2219 2312 3809 4134 4251 15350 
+ 3539 3545 3588 3620 
+ 3552 3558 3578 3586 3607 3610 
+ 3484 3525 3541 3624 3627 3663 
+ 3561 3563 3579 3587 3601 3605 
+ 3558 3562 3583 3587 3610 15353 
+ 3562 3563 3585 3586 3605 15353 
+ 3545 3554 3582 3593 3620 3629 
+ 3550 3564 3580 3600 3603 3626 
+ 3568 3571 3592 3615 
+ 3458 3514 3525 3604 3627 3671 3680 
+ 3571 3572 3590 3595 3615 3618 
+ 3554 3560 3588 3597 3629 3639 
+ 3537 3543 3577 3622 3641 3657 
+ 3572 3575 3592 3599 3618 3621 
+ 3033 3393 3667 3817 3889 
+ 3560 3565 3593 3602 3639 3642 
+ 3555 3569 3613 3619 3659 
+ 3575 3579 3595 3601 3621 3625 
+ 3564 3577 3589 3626 3641 3646 
+ 3579 3585 3599 3605 3625 3628 
+ 3565 3567 3597 3609 3642 3645 
+ 3580 3589 3608 3626 3638 
+ 3514 3540 3591 3617 3671 15354 
+ 3585 3587 3601 3628 3631 15353 
+ 3311 3483 3501 3630 3714 3769 
+ 3578 3583 3610 3636 3637 15352 
+ 3576 3580 3603 3635 3638 15352 
+ 3567 3570 3602 3612 3645 3649 
+ 3583 3586 3607 3634 3636 15353 
+ 3461 3505 3529 3616 3632 3705 3722 
+ 3566 3570 3609 3614 3649 3651 
+ 3532 3555 3598 3616 3659 3673 
+ 3559 3566 3612 3633 3651 3666 
+ 3590 3592 3618 3640 
+ 3505 3532 3611 3613 3673 3705 
+ 3540 3551 3604 3622 3686 15354 
+ 3592 3595 3615 3621 3640 3643 
+ 3569 3573 3598 3633 3659 3684 
+ 3582 3588 3629 3661 
+ 3595 3599 3618 3625 3643 3644 
+ 3543 3551 3594 3617 3657 3686 3699 
+ 3407 3413 3548 3749 3802 3867 
+ 3541 3556 3584 3648 3663 3693 
+ 3599 3601 3621 3628 3644 3647 
+ 3589 3600 3603 3638 3646 3655 
+ 3525 3584 3591 3663 3680 3708 
+ 3601 3605 3625 3631 3647 3650 
+ 3588 3593 3620 3639 3661 3664 
+ 3501 3538 3606 3632 3720 3769 
+ 3605 3628 3634 3650 3652 15353 
+ 3529 3538 3611 3630 3720 3722 
+ 3559 3573 3614 3619 3666 3684 3700 
+ 3610 3631 3636 3652 3653 15353 
+ 3608 3637 3638 3654 3658 15352 
+ 3607 3610 3634 3637 3653 3656 
+ 3607 3635 3636 3656 3658 15352 
+ 3603 3608 3626 3635 3654 3655 
+ 3593 3597 3629 3642 3664 3669 
+ 3615 3618 3643 3660 
+ 3577 3594 3600 3646 3657 3676 3691 
+ 3597 3602 3639 3645 3669 3674 
+ 3618 3621 3640 3644 3660 3662 
+ 3621 3625 3643 3647 3662 3665 
+ 3602 3609 3642 3649 3674 3685 
+ 3600 3626 3641 3655 3676 3679 
+ 3625 3628 3644 3650 3665 3668 
+ 3548 3556 3624 3693 3749 3779 
+ 3609 3612 3645 3651 3685 3689 
+ 3628 3631 3647 3652 3668 3670 
+ 3612 3614 3649 3666 3689 3696 
+ 3631 3634 3650 3653 3670 3672 
+ 3634 3636 3652 3656 3672 3677 
+ 3635 3638 3655 3658 3681 3683 
+ 3626 3638 3646 3654 3679 3681 
+ 3636 3637 3653 3658 3677 3682 
+ 3594 3622 3641 3691 3699 3719 
+ 3635 3637 3654 3656 3682 3683 
+ 3598 3613 3619 3673 3684 3725 
+ 3640 3643 3662 3678 
+ 3620 3629 3664 3694 
+ 3643 3644 3660 3665 3678 3687 
+ 3584 3624 3627 3693 3708 3718 
+ 3629 3639 3661 3669 3694 3702 
+ 3644 3647 3662 3668 3687 3688 
+ 3614 3633 3651 3696 3700 3709 
+ 3033 3271 3596 3869 3889 3979 
+ 3647 3650 3665 3670 3688 3692 
+ 3639 3642 3664 3674 3702 3711 
+ 3650 3652 3668 3672 3692 3695 
+ 3591 3604 3680 3729 3734 15354 
+ 3652 3653 3670 3677 3695 3698 
+ 3613 3616 3659 3705 3725 3795 
+ 3642 3645 3669 3685 3711 3715 
+ 2019 2447 2790 4157 4463 15364 
+ 3641 3646 3679 3691 3712 3724 
+ 3653 3656 3672 3682 3698 3703 
+ 3660 3662 3687 3701 
+ 3646 3655 3676 3681 3710 3712 
+ 3591 3627 3671 3708 3734 3750 
+ 3654 3655 3679 3683 3706 3710 
+ 3656 3658 3677 3683 3703 3704 
+ 3654 3658 3681 3682 3704 3706 
+ 3619 3633 3659 3700 3725 3754 
+ 3645 3649 3674 3689 3715 3723 
+ 3617 3622 3699 3732 3738 15354 
+ 3662 3665 3678 3688 3701 3707 
+ 3665 3668 3687 3692 3707 3713 
+ 3649 3651 3685 3696 3723 3730 
+ 2073 2193 3813 3839 4440 4509 
+ 3641 3657 3676 3719 3724 3741 
+ 3668 3670 3688 3695 3713 3717 
+ 3624 3648 3663 3718 3779 3783 
+ 3661 3664 3702 3735 
+ 3670 3672 3692 3698 3717 3721 
+ 3651 3666 3689 3709 3730 3739 
+ 293 1146 2565 4176 4830 5050 
+ 3672 3677 3695 3703 3721 3726 
+ 3622 3657 3686 3719 3738 3746 
+ 3633 3666 3684 3709 3744 3754 
+ 3678 3687 3707 3727 
+ 3664 3669 3694 3711 3735 3743 
+ 3677 3682 3698 3704 3726 3728 
+ 3682 3683 3703 3706 3728 3733 
+ 3611 3616 3673 3722 3795 3798 
+ 3681 3683 3704 3710 3733 3736 
+ 3687 3688 3701 3713 3727 3731 
+ 3627 3663 3680 3718 3750 3766 
+ 3666 3696 3700 3739 3744 
+ 3679 3681 3706 3712 3736 3740 
+ 3669 3674 3702 3715 3743 3751 
+ 3676 3679 3710 3724 3740 3747 
+ 3688 3692 3707 3717 3731 3737 
+ 3483 3606 3769 3771 3856 3885 
+ 3674 3685 3711 3723 3751 3756 
+ 2990 3393 3748 3817 4044 4097 
+ 3692 3695 3713 3721 3737 3742 
+ 3663 3693 3708 3766 3783 
+ 3657 3691 3699 3741 3746 3765 
+ 3630 3632 3722 3769 3811 3862 
+ 3695 3698 3717 3726 3742 3745 
+ 3611 3632 3705 3720 3798 3811 
+ 3685 3689 3715 3730 3756 3762 
+ 3676 3691 3712 3741 3747 3764 
+ 3659 3673 3684 3754 3795 3807 
+ 3698 3703 3721 3728 3745 3753 
+ 3701 3707 3731 3752 
+ 3703 3704 3726 3733 3753 3758 
+ 3671 3732 3734 3781 15354 15356 
+ 3689 3696 3723 3739 3762 3768 
+ 3707 3713 3727 3737 3752 3757 
+ 3686 3729 3738 15354 15356 15357 
+ 3704 3706 3728 3736 3758 3761 
+ 3671 3680 3729 3750 3781 3791 
+ 3694 3702 3743 3778 
+ 3706 3710 3733 3740 3761 3770 
+ 3713 3717 3731 3742 3757 3763 
+ 3686 3699 3732 3746 3789 15357 
+ 3696 3709 3730 3744 3768 3774 
+ 3710 3712 3736 3747 3770 3776 
+ 3691 3719 3724 3764 3765 3786 
+ 3717 3721 3737 3745 3763 3772 
+ 3702 3711 3735 3751 3778 3790 
+ 3700 3709 3739 3754 3774 3799 
+ 3721 3726 3742 3753 3772 3775 
+ 3699 3719 3738 3765 3784 3789 
+ 3712 3724 3740 3764 3776 3792 
+ 2889 2990 3716 3931 4097 4203 
+ 3548 3623 3648 3779 3867 3924 
+ 3680 3708 3734 3766 3791 3804 
+ 3711 3715 3743 3756 3790 3797 
+ 3727 3731 3757 3780 
+ 3726 3728 3745 3758 3775 3785 
+ 3684 3700 3725 3744 3799 3807 3841 
+ 2685 3003 3759 3760 4129 4193 
+ 3715 3723 3751 3762 3797 3801 
+ 3731 3737 3752 3763 3780 3787 
+ 3728 3733 3753 3761 3785 3793 
+ 2685 2755 3755 3960 4193 4294 
+ 3003 3250 3755 3777 4065 4129 
+ 3733 3736 3758 3770 3793 3796 
+ 3723 3730 3756 3768 3801 3810 
+ 3737 3742 3757 3772 3787 3794 
+ 3724 3741 3747 3786 3792 3806 
+ 3719 3741 3746 3784 3786 3808 
+ 3708 3718 3750 3783 3804 3837 
+ 3336 3518 3782 3898 3916 4002 
+ 3730 3739 3762 3774 3800 3810 
+ 3606 3630 3714 3720 3862 3885 3921 
+ 3736 3740 3761 3776 3796 3805 
+ 3483 3574 3714 3829 3856 3928 
+ 3742 3745 3763 3775 3794 3803 
+ 3496 3574 3782 3829 3958 3964 
+ 3739 3744 3768 3799 3800 3825 
+ 3745 3753 3772 3785 3803 3812 
+ 3740 3747 3770 3792 3805 3815 
+ 3250 3316 3760 3788 4065 4072 
+ 3735 3743 3790 3824 
+ 3648 3693 3749 3783 3870 3924 
+ 3752 3757 3787 3814 
+ 3729 3734 3791 3827 3831 15356 
+ 3336 3496 3767 3773 3916 3958 
+ 3693 3718 3766 3779 3837 3870 
+ 3746 3765 3789 3808 3819 
+ 3753 3758 3775 3793 3812 3816 
+ 3741 3764 3765 3806 3808 3822 
+ 3757 3763 3780 3794 3814 3818 
+ 3316 3404 3777 3802 4036 4072 
+ 3738 3746 3784 3819 3848 15357 
+ 3743 3751 3778 3797 3824 3830 
+ 3734 3750 3781 3804 3827 3838 
+ 3747 3764 3776 3806 3815 3820 
+ 3758 3761 3785 3796 3816 3821 
+ 3763 3772 3787 3803 3818 3823 
+ 3673 3705 3725 3798 3807 3880 3891 
+ 3761 3770 3793 3805 3821 3826 
+ 3751 3756 3790 3801 3830 3842 
+ 3705 3722 3795 3811 3865 3891 
+ 3744 3754 3774 3825 3841 3857 
+ 3768 3774 3810 3825 3844 
+ 3756 3762 3797 3810 3842 3843 
+ 3404 3407 3623 3788 3867 4014 4036 
+ 3772 3775 3794 3812 3823 3828 
+ 3750 3766 3791 3837 3838 
+ 3770 3776 3796 3815 3826 3832 
+ 3764 3786 3792 3820 3822 3834 
+ 3725 3754 3795 3841 3880 3892 
+ 3765 3784 3786 3819 3822 3840 
+ 2219 2790 3581 4157 4251 4365 
+ 3762 3768 3800 3801 3843 3844 
+ 3720 3722 3798 3862 3865 
+ 3775 3785 3803 3816 3828 3836 
+ 2073 2171 3690 4509 4525 4706 
+ 3780 3787 3818 3833 
+ 3776 3792 3805 3820 3832 3835 
+ 3785 3793 3812 3821 3836 3847 
+ 3393 3596 3716 3889 3996 4044 
+ 3787 3794 3814 3823 3833 3845 
+ 3784 3789 3808 3840 3848 3863 
+ 3792 3806 3815 3834 3835 3846 
+ 3793 3796 3816 3826 3847 3849 
+ 3786 3806 3808 3834 3840 3851 
+ 3794 3803 3818 3828 3845 3850 
+ 3778 3790 3830 3861 
+ 3774 3799 3800 3844 3857 3871 
+ 3796 3805 3821 3832 3849 3852 
+ 3781 3791 3831 3838 3864 3886 
+ 3803 3812 3823 3836 3850 3853 
+ 3574 3771 3773 3928 3964 3987 
+ 3790 3797 3824 3842 3861 3868 
+ 3781 3827 3864 3874 15356 15358 
+ 3805 3815 3826 3835 3852 3854 
+ 3814 3818 3845 3858 
+ 3806 3820 3822 3846 3851 3859 
+ 3815 3820 3832 3846 3854 3855 
+ 3812 3816 3828 3847 3853 3860 
+ 3766 3783 3804 3838 3870 3912 
+ 3791 3804 3827 3837 3886 3912 
+ 2193 2805 3690 4130 4440 4467 
+ 3808 3819 3822 3851 3863 3872 
+ 3754 3799 3807 3857 3892 3899 
+ 3797 3801 3830 3843 3868 3877 
+ 3801 3810 3842 3844 3876 3877 
+ 3800 3810 3825 3843 3871 3876 
+ 3818 3823 3833 3850 3858 15359 
+ 3820 3834 3835 3855 3859 
+ 3816 3821 3836 3849 3860 3866 
+ 3789 3819 3863 3910 15357 15358 15360 
+ 3821 3826 3847 3852 3866 3875 
+ 3823 3828 3845 3853 3873 15359 
+ 3822 3834 3840 3859 3872 3883 
+ 3826 3832 3849 3854 3875 3879 
+ 3828 3836 3850 3860 3873 3881 
+ 3832 3835 3852 3855 3879 3882 
+ 3835 3846 3854 3859 3882 3884 
+ 3714 3771 3885 3928 3973 
+ 3799 3825 3841 3871 3899 3907 
+ 3833 3845 3887 15359 
+ 3834 3846 3851 3855 3883 3884 
+ 3836 3847 3853 3866 3881 3888 
+ 3824 3830 3868 3896 
+ 3720 3769 3811 3865 3921 3953 
+ 3819 3840 3848 3872 3908 3910 
+ 3827 3831 3874 3886 3897 
+ 3798 3811 3862 3891 3948 3953 
+ 3847 3849 3860 3875 3888 3893 
+ 3623 3749 3802 3924 4014 4026 
+ 3830 3842 3861 3877 3896 3906 
+ 3271 3518 3667 3898 3979 4093 4133 
+ 3779 3783 3837 3912 3924 3962 
+ 3825 3844 3857 3876 3907 3911 
+ 3840 3851 3863 3883 3904 3908 
+ 3850 3853 3881 3890 3894 15359 
+ 3831 3864 3897 3915 15358 15360 
+ 3849 3852 3866 3879 3893 3895 
+ 3843 3844 3871 3877 3911 3913 
+ 3842 3843 3868 3876 3906 3913 
+ 295 460 2565 4888 5317 5611 
+ 3852 3854 3875 3882 3895 3900 
+ 3795 3807 3891 3892 3940 3944 
+ 3853 3860 3873 3888 3894 3902 
+ 3854 3855 3879 3884 3900 3901 
+ 3851 3859 3872 3884 3903 3904 
+ 3855 3859 3882 3883 3901 3903 
+ 3714 3769 3856 3921 3973 4003 
+ 3827 3838 3864 3897 3912 3930 
+ 3858 3890 3905 15359 
+ 3860 3866 3881 3893 3902 3909 
+ 3596 3667 3817 3979 3996 4108 
+ 3873 3887 3894 3905 3914 15359 
+ 3795 3798 3865 3880 3944 3948 
+ 3807 3841 3880 3899 3940 3941 
+ 3866 3875 3888 3895 3909 3917 
+ 3873 3881 3890 3902 3914 3918 
+ 3875 3879 3893 3900 3917 3919 
+ 3861 3868 3906 3934 
+ 3864 3874 3886 3915 3930 3935 
+ 3518 3767 3869 4002 4093 4118 
+ 3841 3857 3892 3907 3941 3942 
+ 3879 3882 3895 3901 3919 3920 
+ 3882 3884 3900 3903 3920 3923 
+ 3881 3888 3894 3909 3918 3922 
+ 3883 3884 3901 3904 3923 3926 
+ 3872 3883 3903 3908 3926 3932 
+ 3887 3890 3914 3925 
+ 3868 3877 3896 3913 3934 3938 
+ 3857 3871 3899 3911 3942 3946 
+ 3863 3872 3904 3910 3932 15361 
+ 3888 3893 3902 3917 3922 3929 
+ 3848 3863 3908 3927 3957 15360 15361 
+ 3871 3876 3907 3913 3945 3946 
+ 3837 3838 3870 3886 3930 3962 4004 
+ 3876 3877 3906 3911 3938 3945 
+ 3890 3894 3905 3918 3925 3933 
+ 3874 3897 3927 3935 3951 15360 
+ 3767 3782 3958 4002 4064 
+ 3893 3895 3909 3919 3929 3936 
+ 3894 3902 3914 3922 3933 3937 
+ 3895 3900 3917 3920 3936 3939 
+ 3900 3901 3919 3923 3939 3943 
+ 3769 3862 3885 3953 4003 4058 
+ 3902 3909 3918 3929 3937 3947 
+ 3901 3903 3920 3926 3943 3950 
+ 3749 3779 3867 3870 3962 4026 4052 
+ 3905 3914 3933 3949 
+ 3903 3904 3923 3932 3950 3954 
+ 3910 3915 3951 3957 3967 15360 
+ 3771 3829 3856 3973 3987 4048 
+ 3909 3917 3922 3936 3947 3952 
+ 3886 3897 3912 3935 4004 15362 
+ 2805 2889 3748 4130 4203 4357 
+ 3904 3908 3926 3954 3959 15361 
+ 3914 3918 3925 3937 3949 3955 
+ 3896 3906 3938 3969 
+ 3897 3915 3930 3951 15362 
+ 3917 3919 3929 3939 3952 3956 
+ 3918 3922 3933 3947 3955 3961 
+ 3906 3913 3934 3945 3969 3975 
+ 3919 3920 3936 3943 3956 3963 
+ 3880 3892 3941 3944 3985 3988 
+ 3892 3899 3940 3942 3984 3985 
+ 3899 3907 3941 3946 3982 3984 
+ 3920 3923 3939 3950 3963 3965 
+ 3880 3891 3940 3948 3988 3997 
+ 3911 3913 3938 3946 3975 3978 
+ 3907 3911 3942 3945 3978 3982 
+ 3922 3929 3937 3952 3961 3966 
+ 3865 3891 3944 3953 3997 4006 
+ 3925 3933 3955 3968 
+ 3923 3926 3943 3954 3965 3971 
+ 3915 3927 3935 3967 3981 15362 
+ 3929 3936 3947 3956 3966 3972 
+ 3862 3865 3921 3948 4006 4050 4058 
+ 3926 3932 3950 3959 3971 3976 
+ 3933 3937 3949 3961 3968 3974 
+ 3936 3939 3952 3963 3972 3977 
+ 3910 3927 3967 3970 3990 3993 15361 
+ 3773 3782 3916 3964 4064 4099 
+ 3932 3954 3970 3976 3986 15361 
+ 2755 3305 3759 4172 4294 4436 
+ 3937 3947 3955 3966 3974 3980 
+ 3870 3912 3924 4004 4052 4066 
+ 3939 3943 3956 3965 3977 3983 
+ 3773 3829 3958 3987 4099 4100 
+ 3943 3950 3963 3971 3983 3992 
+ 3947 3952 3961 3972 3980 3989 
+ 3927 3951 3957 3981 3993 3998 
+ 3949 3955 3974 3991 
+ 3934 3938 3975 4009 
+ 3957 3959 3986 3990 3995 15361 
+ 3950 3954 3965 3976 3992 4000 
+ 3952 3956 3966 3977 3989 3999 
+ 3856 3885 3928 4003 4048 4083 
+ 3955 3961 3968 3980 3991 4001 
+ 3938 3945 3969 3978 4009 4020 
+ 3954 3959 3971 3986 4000 4005 
+ 3956 3963 3972 3983 3999 15363 
+ 3945 3946 3975 3982 4020 4024 
+ 3667 3869 3889 4108 4133 4220 
+ 3961 3966 3974 3989 4001 4008 
+ 3951 3967 3998 4007 4018 15362 
+ 3942 3946 3978 3984 4024 4028 
+ 3963 3965 3977 3992 4012 15363 
+ 3941 3942 3982 3985 4028 4034 
+ 3940 3941 3984 3988 4031 4034 
+ 3959 3970 3976 3995 4005 4011 
+ 3829 3928 3964 4048 4100 4109 
+ 3940 3944 3985 3997 4031 4035 
+ 3966 3972 3980 3999 4008 4015 
+ 3957 3970 3993 3995 4010 4013 
+ 3968 3974 4001 4016 
+ 3965 3971 3983 4000 4012 4019 
+ 3957 3967 3990 3998 4013 4017 
+ 3001 4134 4323 4485 15350 15355 
+ 3970 3986 3990 4010 4011 
+ 3817 3889 4044 4108 4190 
+ 3944 3948 3988 4006 4035 4037 
+ 3967 3981 3993 4017 4018 
+ 3972 3977 3989 4015 4021 15363 
+ 3971 3976 3992 4005 4019 4022 
+ 3974 3980 3991 4008 4016 4023 
+ 3767 3898 3916 4064 4118 4178 
+ 3885 3921 3973 4058 4083 4115 
+ 3912 3930 3962 4007 4057 4066 4084 15362 
+ 3976 3986 4000 4011 4022 4025 
+ 3948 3953 3997 4037 4050 4069 
+ 3981 4004 4018 4042 4057 15362 
+ 3980 3989 4001 4015 4023 4032 
+ 3969 3975 4020 4054 
+ 3990 3995 4011 4013 4027 4033 
+ 3986 3995 4005 4010 4025 4033 
+ 3983 3992 4019 4030 4038 15363 
+ 3990 3993 4010 4017 4027 4029 
+ 3802 3867 4026 4036 4150 4179 
+ 3989 3999 4008 4021 4032 4040 
+ 3991 4001 4023 4039 
+ 3993 3998 4013 4018 4029 4047 
+ 3981 3998 4007 4017 4042 4047 
+ 3992 4000 4012 4022 4038 4041 
+ 3975 3978 4009 4024 4054 4060 
+ 3999 4015 4030 4040 4045 15363 
+ 4000 4005 4019 4025 4041 4043 
+ 4001 4008 4016 4032 4039 4046 
+ 3978 3982 4020 4028 4060 4067 
+ 4005 4011 4022 4033 4043 4049 
+ 3867 3924 4014 4052 4145 4150 
+ 4010 4013 4029 4033 4051 4053 
+ 3982 3984 4024 4034 4067 4073 
+ 4013 4017 4027 4047 4051 
+ 4012 4021 4038 4045 4055 15363 
+ 3985 3988 4034 4035 4076 4078 
+ 4008 4015 4023 4040 4046 4056 
+ 4010 4011 4025 4027 4049 4053 
+ 3984 3985 4028 4031 4073 4078 
+ 3988 3997 4031 4037 4075 4076 
+ 3788 3802 4014 4072 4179 4248 
+ 3997 4006 4035 4069 4075 
+ 4012 4019 4030 4041 4055 4059 
+ 4016 4023 4046 4061 
+ 4015 4021 4032 4045 4056 4062 
+ 4019 4022 4038 4043 4059 4063 
+ 4007 4018 4047 4057 4081 4088 
+ 4022 4025 4041 4049 4063 4068 
+ 3716 3817 3996 4097 4190 4296 
+ 4021 4030 4040 4055 4062 4070 
+ 4023 4032 4039 4056 4061 4071 
+ 4017 4018 4029 4042 4051 4080 4081 
+ 3928 3973 3987 4083 4109 4138 
+ 4025 4033 4043 4053 4068 4074 
+ 3953 4006 4058 4069 4113 4125 
+ 4027 4029 4047 4053 4077 4080 
+ 3924 3962 4026 4066 4141 4145 
+ 4027 4033 4049 4051 4074 4077 
+ 4009 4020 4060 4094 
+ 4030 4038 4045 4059 4070 4079 
+ 4032 4040 4046 4062 4071 4082 
+ 4004 4007 4042 4084 4088 4105 
+ 3921 3953 4003 4050 4115 4125 4162 
+ 4038 4041 4055 4063 4079 4085 
+ 4020 4024 4054 4067 4094 4101 
+ 4039 4046 4071 4086 
+ 4040 4045 4056 4070 4082 4087 
+ 4041 4043 4059 4068 4085 4089 
+ 3916 3958 4002 4099 4178 4202 
+ 3760 3777 4072 4129 4253 4353 
+ 3962 4004 4052 4084 4141 4142 
+ 4024 4028 4060 4073 4101 4107 
+ 4043 4049 4063 4074 4089 4090 
+ 4006 4037 4050 4075 4113 4120 
+ 4045 4055 4062 4079 4087 4092 
+ 4046 4056 4061 4082 4086 4091 
+ 3777 3788 4036 4065 4248 4253 
+ 4028 4034 4067 4078 4107 4112 
+ 4049 4053 4068 4077 4090 4095 
+ 4035 4037 4069 4076 4120 15366 
+ 4031 4035 4075 4078 4119 15366 
+ 4051 4053 4074 4080 4095 15365 
+ 4031 4034 4073 4076 4112 4119 
+ 4055 4059 4070 4085 4092 4096 
+ 4047 4051 4077 4081 4102 15365 
+ 4042 4047 4080 4088 4102 4110 
+ 4056 4062 4071 4087 4091 4098 
+ 3973 4003 4048 4115 4138 4166 
+ 4004 4057 4066 4105 4137 4142 
+ 4059 4063 4079 4089 4096 4103 
+ 4061 4071 4091 4104 
+ 4062 4070 4082 4092 4098 4106 
+ 4042 4057 4081 4105 4110 4121 
+ 4063 4068 4085 4090 4103 4111 
+ 4068 4074 4089 4095 4111 4117 
+ 4071 4082 4086 4098 4104 4114 
+ 4070 4079 4087 4096 4106 4116 
+ 3869 3898 4118 4133 4264 4276 
+ 4054 4060 4101 4135 
+ 4074 4077 4090 4117 4122 15365 
+ 4079 4085 4092 4103 4116 4123 
+ 3716 3748 4044 4203 4296 4387 
+ 4082 4087 4091 4106 4114 4124 
+ 3958 3964 4064 4100 4202 4227 
+ 3964 3987 4099 4109 4206 4227 
+ 4060 4067 4094 4107 4135 4146 
+ 4080 4081 4110 4126 4132 15365 
+ 4085 4089 4096 4111 4123 4128 
+ 4086 4091 4114 4127 
+ 4057 4084 4088 4121 4137 4151 
+ 4087 4092 4098 4116 4124 4131 
+ 4067 4073 4101 4112 4146 4153 
+ 3889 3979 3996 4190 4220 4278 
+ 3987 4048 4100 4138 4206 4210 
+ 4081 4088 4102 4121 4132 4143 
+ 4089 4090 4103 4117 4128 4136 
+ 4073 4078 4107 4119 4153 4159 
+ 4050 4069 4120 4125 4171 4175 
+ 4091 4098 4104 4124 4127 4139 
+ 4003 4058 4083 4162 4166 4207 
+ 4092 4096 4106 4123 4131 4140 
+ 4090 4095 4111 4122 4136 4144 
+ 3898 4002 4093 4178 4264 4286 
+ 4076 4078 4112 4159 4164 15366 
+ 4069 4075 4113 4168 4171 15366 
+ 4088 4105 4110 4143 4151 
+ 4095 4117 4126 4144 4148 15365 
+ 4096 4103 4116 4128 4140 4149 
+ 4098 4106 4114 4131 4139 4147 
+ 4050 4058 4113 4162 4175 4196 
+ 4102 4122 4132 4148 4154 15365 
+ 4104 4114 4139 4152 
+ 4103 4111 4123 4136 4149 4155 
+ 3755 3760 4065 4193 4353 4428 
+ 2805 3839 3931 4357 4467 4528 
+ 4106 4116 4124 4140 4147 4156 
+ 4102 4110 4126 4143 4154 4158 
+ 3869 3979 4093 4220 4276 4287 
+ 3581 3994 4251 4485 4522 15350 
+ 4094 4101 4146 4181 
+ 4111 4117 4128 4144 4155 4160 
+ 4084 4105 4142 4151 4180 4191 
+ 4048 4083 4109 4166 4199 4210 
+ 4114 4124 4127 4147 4152 4161 
+ 4116 4123 4131 4149 4156 4165 
+ 4052 4066 4142 4145 4218 4255 
+ 4066 4084 4137 4141 4191 4218 
+ 4110 4121 4132 4151 4158 4163 
+ 4117 4122 4136 4148 4160 4167 
+ 4026 4052 4141 4150 4255 4263 
+ 4101 4107 4135 4153 4181 4189 
+ 4124 4131 4139 4156 4161 4170 
+ 4122 4126 4144 4154 4167 4174 
+ 4123 4128 4140 4155 4165 4173 
+ 4014 4026 4145 4179 4263 4269 
+ 4105 4121 4137 4143 4163 4180 4185 
+ 4127 4139 4161 4177 
+ 4107 4112 4146 4159 4189 4198 
+ 4126 4132 4148 4158 4174 4184 
+ 4128 4136 4149 4160 4173 15367 
+ 4131 4140 4147 4165 4170 4183 
+ 2790 3675 3809 4365 4463 4600 
+ 4132 4143 4154 4163 4182 4184 
+ 4112 4119 4153 4164 4198 4205 
+ 4136 4144 4155 4167 4187 15367 
+ 4139 4147 4152 4170 4177 4186 
+ 4058 4115 4125 4196 4207 4238 
+ 4143 4151 4158 4182 4185 
+ 4119 4159 4168 4205 4213 15366 
+ 4140 4149 4156 4173 4183 4188 
+ 4083 4115 4138 4199 4207 4237 
+ 4144 4148 4160 4174 4187 4192 
+ 4120 4164 4171 4213 4219 15366 
+ 2078 2587 4383 4762 4894 15364 
+ 4147 4156 4161 4183 4186 4194 
+ 4113 4120 4168 4175 4219 4226 
+ 3305 3960 4323 4436 4535 15355 
+ 4149 4155 4165 4188 4195 15367 
+ 4148 4154 4167 4184 4192 4197 
+ 4113 4125 4171 4196 4226 4233 
+ 1146 2062 3697 5050 5180 15374 
+ 4152 4161 4186 4200 
+ 4002 4064 4118 4202 4286 4343 
+ 4014 4036 4150 4248 4269 4346 
+ 4137 4151 4185 4191 4216 4217 
+ 4135 4146 4189 4225 
+ 4158 4163 4184 4185 4209 4212 
+ 4156 4165 4170 4188 4194 4204 
+ 4154 4158 4174 4182 4197 4209 
+ 4151 4163 4180 4182 4212 4216 
+ 4161 4170 4177 4194 4200 4211 
+ 4160 4167 4192 4208 4214 15367 
+ 4165 4173 4183 4195 4204 4215 
+ 4146 4153 4181 4198 4225 4234 
+ 3996 4044 4108 4278 4296 4433 
+ 4137 4142 4180 4217 4218 4240 
+ 4167 4174 4187 4197 4214 4221 
+ 3755 3759 4129 4294 4428 4526 
+ 4170 4183 4186 4204 4211 4222 
+ 4173 4188 4208 4215 4223 15367 
+ 4125 4162 4175 4233 4238 4243 
+ 4174 4184 4192 4209 4221 4228 
+ 4153 4159 4189 4205 4234 4241 
+ 4138 4166 4210 4237 4262 
+ 4177 4186 4211 4224 
+ 203 275 1438 5293 7003 7847 
+ 4064 4099 4178 4227 4316 4343 
+ 3748 3931 4097 4357 4387 4503 
+ 4183 4188 4194 4215 4222 4229 
+ 4159 4164 4198 4213 4241 4249 
+ 4100 4109 4210 4227 4277 4330 
+ 4115 4162 4166 4237 4238 4265 
+ 4187 4195 4214 4223 4230 15367 
+ 4182 4184 4197 4212 4228 4232 
+ 4109 4138 4199 4206 4262 4277 
+ 4186 4194 4200 4222 4224 4231 
+ 4182 4185 4209 4216 4232 4247 
+ 4164 4168 4205 4219 4249 4257 
+ 4187 4192 4208 4221 4230 4235 
+ 4188 4195 4204 4223 4229 4236 
+ 4180 4185 4212 4217 4246 4247 
+ 4180 4191 4216 4240 4246 
+ 4141 4142 4191 4240 4255 4267 4293 
+ 4168 4171 4213 4226 4257 4260 
+ 3979 4108 4133 4278 4287 4373 
+ 4192 4197 4214 4228 4235 4242 
+ 4194 4204 4211 4229 4231 4239 
+ 4195 4208 4215 4230 4236 4244 
+ 4200 4211 4231 4245 
+ 4181 4189 4234 4268 
+ 4171 4175 4219 4233 4260 4270 
+ 4099 4100 4202 4206 4316 4330 
+ 4197 4209 4221 4232 4242 4252 
+ 4204 4215 4222 4236 4239 4250 
+ 4208 4214 4223 4235 4244 4254 
+ 4211 4222 4224 4239 4245 4256 
+ 4209 4212 4228 4247 4252 4261 
+ 4175 4196 4226 4243 4270 4283 
+ 4189 4198 4225 4241 4268 4280 
+ 4214 4221 4230 4242 4254 4259 
+ 4215 4223 4229 4244 4250 4258 
+ 4166 4199 4207 4262 4265 4324 
+ 4162 4196 4207 4243 4265 4274 4301 
+ 4222 4229 4231 4250 4256 4266 
+ 4191 4217 4218 4246 4267 4279 
+ 4198 4205 4234 4249 4280 4292 
+ 4221 4228 4235 4252 4259 4273 
+ 4196 4233 4238 4274 4283 
+ 4223 4230 4236 4254 4258 4272 
+ 4224 4231 4256 4271 
+ 4216 4217 4240 4247 4279 4282 
+ 4212 4216 4232 4246 4261 4282 4289 
+ 4036 4072 4179 4253 4346 4441 4451 
+ 4205 4213 4241 4257 4292 4298 
+ 4229 4236 4239 4258 4266 4275 
+ 3581 3809 4134 4365 4522 4577 
+ 4228 4232 4242 4261 4273 4281 
+ 4065 4072 4248 4353 4451 
+ 4230 4235 4244 4259 4272 4284 
+ 4141 4145 4218 4263 4293 4335 4358 
+ 4231 4239 4245 4266 4271 4285 
+ 4213 4219 4249 4260 4298 4304 
+ 4236 4244 4250 4272 4275 4288 
+ 4235 4242 4254 4273 4284 4291 
+ 4219 4226 4257 4270 4304 4307 
+ 4232 4247 4252 4281 4289 4290 
+ 4199 4210 4237 4277 4324 4332 
+ 4145 4150 4255 4269 4358 15368 
+ 4093 4118 4276 4286 4397 4399 
+ 4207 4237 4238 4301 4324 4333 
+ 4239 4250 4256 4275 4285 4295 
+ 4218 4240 4279 4293 4311 
+ 4225 4234 4280 4314 
+ 4150 4179 4263 4346 15368 
+ 4226 4233 4260 4283 4307 4313 
+ 4245 4256 4285 4297 
+ 4244 4254 4258 4284 4288 4299 
+ 4242 4252 4259 4281 4291 4300 
+ 4238 4243 4283 4301 4318 
+ 4250 4258 4266 4288 4295 4302 
+ 4093 4133 4264 4287 4399 4402 
+ 4206 4210 4262 4330 4332 4372 
+ 4108 4190 4220 4373 4433 4457 
+ 4240 4246 4267 4282 4310 4311 
+ 4234 4241 4268 4292 4314 4322 
+ 4252 4261 4273 4290 4300 4303 
+ 4246 4247 4279 4289 4308 4310 
+ 4233 4243 4270 4274 4313 4318 
+ 4254 4259 4272 4291 4299 4306 
+ 4256 4266 4271 4295 4297 4305 
+ 4118 4178 4264 4343 4397 4416 
+ 4133 4220 4276 4373 4402 
+ 4258 4272 4275 4299 4302 4312 
+ 4247 4261 4282 4290 4308 4309 
+ 4261 4281 4289 4303 4309 
+ 4259 4273 4284 4300 4306 4315 
+ 4241 4249 4280 4298 4322 4331 
+ 4218 4255 4267 4311 4335 4340 
+ 3759 3960 4193 4436 4526 4589 
+ 4266 4275 4285 4302 4305 4317 
+ 4044 4097 4190 4387 4433 4511 
+ 4271 4285 4305 4319 
+ 4249 4257 4292 4304 4331 4339 
+ 4272 4284 4288 4306 4312 4321 
+ 4273 4281 4291 4303 4315 4320 
+ 4238 4265 4274 4318 4333 4350 
+ 4275 4288 4295 4312 4317 4325 
+ 4281 4290 4300 4309 4320 4326 
+ 4257 4260 4298 4307 4339 4347 
+ 4285 4295 4297 4317 4319 4327 
+ 4284 4291 4299 4315 4321 4328 
+ 4260 4270 4304 4313 4347 4348 
+ 4282 4289 4309 4310 4329 4336 
+ 4289 4290 4303 4308 4326 4329 
+ 4279 4282 4308 4311 4336 4341 
+ 4267 4279 4293 4310 4340 4341 
+ 4288 4299 4302 4321 4325 4334 
+ 4270 4283 4307 4318 4348 4351 
+ 4268 4280 4322 4356 
+ 4291 4300 4306 4320 4328 4337 
+ 4202 4227 4330 4343 4400 4417 
+ 4295 4302 4305 4325 4327 4338 
+ 4274 4283 4301 4313 4350 4351 
+ 4297 4305 4327 4342 
+ 4300 4303 4315 4326 4337 4344 
+ 4299 4306 4312 4328 4334 4345 
+ 4280 4292 4314 4331 4356 4367 
+ 3994 4172 4485 4535 4661 15355 
+ 4237 4262 4265 4332 4333 4381 4391 
+ 4302 4312 4317 4334 4338 4349 
+ 4303 4309 4320 4329 4344 4355 
+ 4305 4317 4319 4338 4342 4352 
+ 4306 4315 4321 4337 4345 4354 
+ 4308 4309 4326 4336 4355 4363 
+ 4206 4227 4277 4316 4372 4400 4420 
+ 4292 4298 4322 4339 4367 4374 
+ 4262 4277 4324 4372 4391 4409 
+ 4265 4301 4324 4350 4381 4386 
+ 4312 4321 4325 4345 4349 4359 
+ 4255 4293 4340 4358 4385 4411 
+ 4308 4310 4329 4341 4363 4364 
+ 4315 4320 4328 4344 4354 4360 
+ 4317 4325 4327 4349 4352 4361 
+ 4298 4304 4331 4347 4374 4376 
+ 4293 4311 4335 4341 4366 4385 
+ 4310 4311 4336 4340 4364 4366 
+ 4319 4327 4352 4362 
+ 4178 4202 4286 4316 4416 4417 4468 
+ 4320 4326 4337 4355 4360 4369 
+ 4321 4328 4334 4354 4359 4368 
+ 4179 4248 4269 4441 4458 15368 
+ 4304 4307 4339 4348 4376 4384 
+ 4307 4313 4347 4351 4384 4388 
+ 4325 4334 4338 4359 4361 4370 
+ 4301 4318 4333 4351 4386 4390 
+ 4313 4318 4348 4350 4388 4390 
+ 4327 4338 4342 4361 4362 4371 
+ 4065 4129 4253 4428 4451 4537 
+ 4328 4337 4345 4360 4368 4375 
+ 4326 4329 4344 4363 4369 4378 
+ 4314 4322 4367 4396 
+ 3931 4130 4203 4503 4528 4573 
+ 4255 4263 4335 4411 4446 15368 
+ 4334 4345 4349 4368 4370 4377 
+ 4337 4344 4354 4369 4375 4380 
+ 4338 4349 4352 4370 4371 4379 
+ 4342 4352 4371 4382 
+ 4329 4336 4355 4364 4378 4392 
+ 4336 4341 4363 4366 4392 15369 
+ 3809 4157 4251 4577 4600 
+ 4340 4341 4364 4385 15369 
+ 4322 4331 4356 4374 4396 4405 
+ 4345 4354 4359 4375 4377 4389 
+ 4344 4355 4360 4378 4380 4395 
+ 4349 4359 4361 4377 4379 4393 
+ 4352 4361 4362 4379 4382 4394 
+ 4277 4330 4332 4409 4420 4439 
+ 4220 4278 4287 4402 4457 4489 
+ 4331 4339 4367 4376 4405 4412 
+ 4354 4360 4368 4380 4389 4398 
+ 4339 4347 4374 4384 4412 4418 
+ 4359 4368 4370 4389 4393 4403 
+ 4355 4363 4369 4392 4395 4401 
+ 4361 4370 4371 4393 4394 4404 
+ 4360 4369 4375 4395 4398 4407 
+ 4324 4333 4386 4391 4430 4438 
+ 4362 4371 4394 4406 
+ 2062 2078 4169 4894 5221 15374 
+ 4347 4348 4376 4388 4418 4423 
+ 4335 4340 4366 4411 4448 15369 
+ 4333 4350 4381 4390 4429 4430 
+ 4097 4203 4296 4503 4511 4583 
+ 4348 4351 4384 4390 4423 4426 
+ 4368 4375 4377 4398 4403 4410 
+ 4350 4351 4386 4388 4426 4429 
+ 4324 4332 4381 4409 4438 4450 
+ 4363 4364 4378 4401 4408 15369 
+ 4370 4377 4379 4403 4404 4413 
+ 4371 4379 4382 4404 4406 4414 
+ 4369 4378 4380 4401 4407 4415 
+ 4356 4367 4405 4434 
+ 4264 4286 4399 4416 4488 4493 
+ 4375 4380 4389 4407 4410 4419 
+ 4264 4276 4397 4402 4493 4502 
+ 4316 4330 4417 4420 4453 4475 
+ 4378 4392 4395 4408 4415 4421 
+ 4276 4287 4373 4399 4489 4502 
+ 4377 4389 4393 4410 4413 4422 
+ 4379 4393 4394 4413 4414 4424 
+ 4367 4374 4396 4412 4434 4444 
+ 4382 4394 4414 4425 
+ 4380 4395 4398 4415 4419 4427 
+ 4392 4401 4421 4445 15369 
+ 4332 4372 4391 4439 4450 4465 
+ 4389 4398 4403 4419 4422 4431 
+ 4335 4358 4385 4446 4448 4492 
+ 4374 4376 4405 4418 4444 4456 
+ 4393 4403 4404 4422 4424 4435 
+ 4394 4404 4406 4424 4425 4437 
+ 4395 4401 4407 4421 4427 4432 
+ 4286 4343 4397 4468 4488 4514 
+ 4316 4343 4400 4468 4475 4513 
+ 4376 4384 4412 4423 4456 4461 
+ 4398 4407 4410 4427 4431 4442 
+ 4330 4372 4400 4439 4453 4476 
+ 4401 4408 4415 4432 4445 4454 
+ 4403 4410 4413 4431 4435 4443 
+ 4384 4388 4418 4426 4461 4466 
+ 4404 4413 4414 4435 4437 4447 
+ 4406 4414 4437 4449 
+ 4388 4390 4423 4429 4466 4471 
+ 4407 4415 4419 4432 4442 4452 
+ 4129 4193 4353 4526 4537 4647 
+ 4386 4390 4426 4430 4471 4477 
+ 4381 4386 4429 4438 4477 4480 
+ 4410 4419 4422 4442 4443 4455 
+ 4415 4421 4427 4452 4454 
+ 4190 4278 4296 4457 4511 4554 4603 
+ 4396 4405 4444 4474 
+ 4413 4422 4424 4443 4447 4459 
+ 3960 4172 4294 4535 4589 4664 
+ 4414 4424 4425 4447 4449 4460 
+ 4381 4391 4430 4450 4480 4487 
+ 4372 4409 4420 4465 4476 4479 
+ 3690 3839 4467 4509 4685 4715 
+ 4248 4346 4451 4458 4551 4567 
+ 4419 4427 4431 4452 4455 4462 
+ 4422 4431 4435 4455 4459 4464 
+ 4405 4412 4434 4456 4474 4486 
+ 4408 4421 4448 4454 4481 4495 15369 
+ 4358 4411 4458 4492 4517 15368 
+ 4424 4435 4437 4459 4460 4469 
+ 4385 4411 4445 4492 4495 4523 15369 
+ 4425 4437 4460 4472 
+ 4391 4409 4438 4465 4487 4496 
+ 4248 4253 4353 4441 4537 4567 4628 
+ 4427 4432 4442 4454 4462 4473 
+ 4400 4420 4475 4476 4497 
+ 4421 4432 4445 4452 4473 4481 
+ 4431 4442 4443 4462 4464 4470 
+ 4412 4418 4444 4461 4486 4491 
+ 4278 4373 4433 4489 4554 4563 
+ 4346 4441 4446 4517 4551 15368 
+ 4435 4443 4447 4464 4469 4478 
+ 4437 4447 4449 4469 4472 4483 
+ 4418 4423 4456 4466 4491 4499 
+ 4442 4452 4455 4470 4473 4484 
+ 3675 4157 4600 4762 4851 15364 
+ 4443 4455 4459 4470 4478 4482 
+ 4409 4439 4450 4479 4496 4507 
+ 4423 4426 4461 4471 4499 4506 
+ 3839 4130 4440 4528 4679 4685 
+ 4343 4416 4417 4513 4514 4538 
+ 4447 4459 4460 4478 4483 4490 
+ 4455 4462 4464 4482 4484 
+ 4426 4429 4466 4477 4506 4510 
+ 4449 4460 4483 4494 
+ 4452 4454 4462 4481 4484 4498 
+ 4434 4444 4486 4512 
+ 4400 4417 4453 4497 4513 4545 
+ 4420 4439 4453 4479 4497 4505 4521 
+ 4429 4430 4471 4480 4510 4515 
+ 4459 4464 4469 4482 4490 4500 
+ 4439 4465 4476 4505 4507 
+ 4430 4438 4477 4487 4515 4520 
+ 4445 4454 4473 4495 4498 4531 
+ 4464 4470 4478 4484 4500 4504 
+ 4460 4469 4472 4490 4494 4508 
+ 4462 4470 4473 4482 4498 4504 
+ 3994 4134 4323 4522 4661 4745 
+ 4444 4456 4474 4491 4512 4518 
+ 4438 4450 4480 4496 4520 4530 
+ 4397 4416 4493 4514 4544 4562 
+ 4373 4402 4457 4502 4563 4578 
+ 4469 4478 4483 4500 4508 4516 
+ 4456 4461 4486 4499 4518 4529 
+ 4411 4446 4448 4517 4523 4559 
+ 4397 4399 4488 4502 4562 4566 
+ 4472 4483 4508 4519 
+ 4445 4448 4481 4523 4531 4543 
+ 4450 4465 4487 4507 4530 4534 
+ 4453 4475 4476 4521 4545 4546 
+ 4473 4481 4484 4504 4527 4531 
+ 4461 4466 4491 4506 4529 15370 
+ 4478 4482 4490 4504 4516 4524 
+ 1168 2700 3287 4893 5174 5290 
+ 4399 4402 4489 4493 4566 4578 
+ 4203 4357 4387 4573 4583 4667 
+ 4482 4484 4498 4500 4524 4527 
+ 4476 4479 4507 4521 4532 
+ 4466 4471 4499 4510 4536 15370 
+ 4465 4479 4496 4505 4532 4534 
+ 4483 4490 4494 4516 4519 4533 
+ 3690 3813 4440 4706 4715 4827 
+ 4471 4477 4506 4515 4536 4541 
+ 4296 4387 4433 4583 4603 4644 
+ 4474 4486 4518 4540 
+ 4417 4468 4475 4538 4545 4565 
+ 4416 4468 4488 4538 4544 4571 
+ 4477 4480 4510 4520 4541 4547 
+ 4490 4500 4508 4524 4533 4539 
+ 4446 4458 4492 4551 4559 4579 4594 
+ 4486 4491 4512 4529 4540 4549 
+ 4494 4508 4533 4542 
+ 4480 4487 4515 4530 4547 4550 
+ 4476 4497 4505 4532 4546 4552 
+ 4134 4251 4485 4577 4745 4796 
+ 4448 4492 4495 4543 4559 4576 
+ 4500 4504 4516 4527 4539 4548 
+ 2171 2700 3813 4706 4893 4958 
+ 4193 4294 4428 4589 4647 4690 
+ 4498 4504 4524 4531 4548 4553 
+ 4130 4357 4467 4573 4675 4679 
+ 4491 4499 4518 4549 4556 15370 
+ 4487 4496 4520 4534 4550 4558 
+ 4481 4495 4498 4527 4543 4553 4570 
+ 4505 4507 4521 4534 4552 4561 
+ 4508 4516 4519 4539 4542 4555 
+ 4496 4507 4530 4532 4558 4561 
+ 4172 4323 4436 4661 4664 4776 
+ 4506 4510 4541 4564 4569 15370 
+ 4353 4428 4451 4628 4647 4701 
+ 4468 4513 4514 4565 4571 4596 
+ 4516 4524 4533 4548 4555 4568 
+ 4512 4518 4549 4574 
+ 4510 4515 4536 4547 4569 4575 
+ 4519 4533 4555 4572 
+ 4495 4523 4531 4570 4576 4591 
+ 4488 4514 4562 4571 4595 
+ 4475 4497 4513 4546 4565 4586 4601 
+ 4497 4521 4545 4552 4585 4586 
+ 4515 4520 4541 4550 4575 4580 
+ 4524 4527 4539 4553 4568 4581 
+ 4518 4529 4540 4556 4574 4582 
+ 4520 4530 4547 4558 4580 15371 
+ 4441 4458 4517 4567 4594 4632 4654 
+ 4521 4532 4546 4561 4585 4587 
+ 4527 4531 4548 4570 4581 4593 
+ 4433 4457 4563 4603 4641 4646 
+ 4533 4539 4542 4568 4572 4584 
+ 4529 4549 4564 4582 4588 15370 
+ 244 312 361 4780 5550 6345 6996 
+ 4530 4534 4550 4561 4590 15371 
+ 4492 4517 4523 4576 4579 4592 
+ 199 239 4672 6408 6740 7295 
+ 4532 4534 4552 4558 4587 4590 
+ 4488 4493 4544 4566 4595 4615 
+ 4457 4489 4554 4578 4641 4652 
+ 4536 4556 4569 4588 4597 15370 
+ 4513 4538 4545 4596 4601 4614 
+ 4493 4502 4562 4578 4615 4649 
+ 4441 4451 4551 4628 4654 4695 
+ 4539 4548 4555 4581 4584 4599 
+ 4536 4541 4564 4575 4597 4602 
+ 4531 4543 4553 4591 4593 4607 
+ 4514 4538 4544 4595 4596 4617 
+ 4542 4555 4584 4598 
+ 4357 4503 4528 4667 4675 4730 
+ 4540 4549 4582 4604 
+ 4541 4547 4569 4580 4602 4606 
+ 4523 4543 4559 4591 4592 4605 
+ 4251 4365 4522 4600 4796 4869 
+ 4489 4502 4563 4566 4649 4652 
+ 4517 4559 4592 4594 4608 
+ 4547 4550 4575 4606 4609 15371 
+ 4548 4553 4568 4593 4599 4611 
+ 4549 4556 4574 4588 4604 4610 
+ 4387 4503 4511 4644 4667 4731 
+ 4555 4568 4572 4598 4599 4612 
+ 4546 4552 4586 4587 4618 4621 
+ 4545 4546 4585 4601 4621 4629 
+ 4552 4561 4585 4590 4616 4618 
+ 4556 4564 4582 4597 4610 4619 
+ 4294 4436 4526 4664 4690 4751 
+ 4558 4561 4587 4613 4616 15371 
+ 4543 4570 4576 4605 4607 4622 
+ 4559 4576 4579 4605 4608 4620 
+ 4553 4570 4581 4607 4611 4626 
+ 4517 4551 4579 4608 4632 4643 
+ 4544 4562 4571 4615 4617 4642 
+ 4538 4565 4571 4614 4617 4634 
+ 4564 4569 4588 4602 4619 4623 
+ 4572 4584 4612 4624 
+ 4568 4581 4584 4611 4612 4627 
+ 4157 4365 4463 4577 4851 4869 
+ 4545 4565 4586 4614 4629 4635 
+ 4569 4575 4597 4606 4623 4630 
+ 4433 4511 4554 4644 4646 4709 
+ 4574 4582 4610 4631 
+ 4576 4591 4592 4620 4622 4625 
+ 4575 4580 4602 4609 4630 4633 
+ 4570 4591 4593 4622 4626 4636 
+ 4579 4592 4594 4620 4643 4655 
+ 4580 4606 4613 4633 4638 15371 
+ 4582 4588 4604 4619 4631 4637 
+ 4581 4593 4599 4626 4627 4640 
+ 4584 4598 4599 4624 4627 4639 
+ 4590 4609 4616 4638 4645 15371 
+ 4565 4596 4601 4634 4635 4659 
+ 4562 4566 4595 4642 4649 4702 
+ 4587 4590 4613 4618 4645 4650 
+ 4571 4595 4596 4634 4642 4669 
+ 4585 4587 4616 4621 4650 4656 
+ 4588 4597 4610 4623 4637 4651 
+ 4592 4605 4608 4625 4653 4655 
+ 4585 4586 4618 4629 4656 4660 
+ 4591 4605 4607 4625 4636 4648 
+ 4597 4602 4619 4630 4651 4658 
+ 4598 4612 4639 4657 
+ 4605 4620 4622 4648 4653 
+ 4593 4607 4611 4636 4640 4663 
+ 4599 4611 4612 4639 4640 4662 
+ 4451 4537 4567 4695 4701 4744 
+ 4586 4601 4621 4635 4660 4668 
+ 4602 4606 4623 4633 4658 4665 
+ 4604 4610 4637 4666 
+ 4551 4594 4643 4654 4703 4711 
+ 4606 4609 4630 4638 4665 4671 
+ 4596 4614 4617 4659 4669 4682 
+ 4601 4614 4629 4659 4668 4670 
+ 4607 4622 4626 4648 4663 4673 
+ 4610 4619 4631 4651 4666 4674 
+ 4609 4613 4633 4645 4671 4676 
+ 4612 4624 4627 4657 4662 4677 
+ 4611 4626 4627 4662 4663 4678 
+ 4554 4563 4646 4652 4733 4742 
+ 4595 4615 4617 4669 4702 4712 
+ 4594 4608 4632 4655 4697 4703 
+ 4511 4583 4603 4709 4731 4768 
+ 4613 4616 4638 4650 4676 4681 
+ 4554 4603 4641 4709 4742 
+ 4428 4526 4537 4690 4701 4794 4799 
+ 4622 4625 4636 4653 4673 4680 
+ 4566 4578 4615 4652 4702 4737 
+ 4616 4618 4645 4656 4681 4684 
+ 4619 4623 4637 4658 4674 4683 
+ 4563 4578 4641 4649 4733 4737 
+ 4620 4625 4648 4655 4680 4686 
+ 4551 4567 4632 4695 4711 4739 
+ 4608 4620 4643 4653 4686 4697 
+ 4618 4621 4650 4660 4684 4689 
+ 4624 4639 4677 4687 
+ 4623 4630 4651 4665 4683 4688 
+ 4614 4634 4635 4670 4682 4693 
+ 4621 4629 4656 4668 4689 4694 
+ 4323 4485 4535 4745 4776 4892 
+ 4627 4639 4640 4677 4678 4692 
+ 4626 4636 4640 4673 4678 4691 
+ 4436 4535 4589 4751 4776 4844 
+ 4630 4633 4658 4671 4688 4696 
+ 4631 4637 4674 4698 
+ 4503 4573 4583 4730 4731 4795 
+ 4629 4635 4660 4670 4694 4699 
+ 4617 4634 4642 4682 4712 4718 
+ 4635 4659 4668 4693 4699 
+ 4633 4638 4665 4676 4696 4700 
+ 199 253 4560 4995 6562 6740 
+ 4636 4648 4663 4680 4691 4704 
+ 4637 4651 4666 4683 4698 4705 
+ 4528 4573 4679 4730 4804 
+ 4638 4645 4671 4681 4700 4707 
+ 4639 4657 4662 4687 4692 4708 
+ 4640 4662 4663 4691 4692 4710 
+ 4467 4528 4675 4685 4804 4821 
+ 4648 4653 4673 4686 4704 4716 
+ 4645 4650 4676 4684 4707 4713 
+ 4634 4659 4669 4693 4718 4721 
+ 4651 4658 4674 4688 4705 4714 
+ 4650 4656 4681 4689 4713 4717 
+ 4440 4467 4679 4715 4821 4823 
+ 4653 4655 4680 4697 4716 4728 
+ 4657 4677 4708 4720 
+ 4658 4665 4683 4696 4714 4719 
+ 4656 4660 4684 4694 4717 4722 
+ 4526 4589 4647 4751 4794 4835 
+ 4663 4673 4678 4704 4710 4724 
+ 4662 4677 4678 4708 4710 4726 
+ 4659 4670 4682 4699 4721 4723 
+ 4660 4668 4689 4699 4722 4725 
+ 4567 4628 4654 4739 4744 4777 
+ 4665 4671 4688 4700 4719 4727 
+ 4643 4655 4686 4703 4728 4738 
+ 4666 4674 4705 4729 
+ 4668 4670 4693 4694 4723 4725 
+ 4671 4676 4696 4707 4727 4732 
+ 4537 4628 4647 4744 4799 4824 
+ 4615 4642 4649 4712 4737 4766 4779 
+ 4632 4643 4697 4711 4738 4755 
+ 4673 4680 4691 4716 4724 4736 
+ 4674 4683 4698 4714 4729 4734 
+ 3813 4509 4525 4827 4958 5028 
+ 4676 4681 4700 4713 4732 4735 
+ 4677 4687 4692 4720 4726 15372 
+ 4603 4644 4646 4742 4768 4808 
+ 4678 4691 4692 4724 4726 4740 
+ 4632 4654 4703 4739 4755 4773 
+ 4642 4669 4702 4718 4761 4766 
+ 4681 4684 4707 4717 4735 4743 
+ 4683 4688 4705 4719 4734 4741 
+ 4440 4509 4685 4823 4827 4947 
+ 4680 4686 4704 4728 4736 4749 
+ 4684 4689 4713 4722 4743 4746 
+ 4669 4682 4712 4721 4754 4761 
+ 4688 4696 4714 4727 4741 4747 
+ 4687 4708 4748 15372 
+ 4682 4693 4718 4723 4753 4754 
+ 4689 4694 4717 4725 4746 4750 
+ 4693 4699 4721 4725 4752 4753 
+ 4691 4704 4710 4736 4740 4759 
+ 4694 4699 4722 4723 4750 4752 
+ 4692 4708 4710 4740 4758 15372 
+ 4696 4700 4719 4732 4747 4756 
+ 4686 4697 4716 4738 4749 4764 
+ 4698 4705 4734 4757 
+ 4573 4667 4675 4795 4804 4913 
+ 4583 4644 4667 4768 4795 4877 
+ 4700 4707 4727 4735 4756 4760 
+ 4641 4652 4737 4742 4816 4836 
+ 4705 4714 4729 4741 4757 4763 
+ 4707 4713 4732 4743 4760 4765 
+ 4704 4716 4724 4749 4759 4770 
+ 4649 4652 4702 4733 4779 4812 4816 
+ 4697 4703 4728 4755 4764 4783 
+ 4654 4695 4711 4773 4777 4806 
+ 4710 4724 4726 4758 4759 4772 
+ 4714 4719 4734 4747 4763 4769 
+ 4641 4646 4709 4733 4808 4836 
+ 4713 4717 4735 4746 4765 4771 
+ 4628 4695 4701 4777 4824 4840 
+ 4485 4522 4661 4796 4892 4976 
+ 4717 4722 4743 4750 4771 4774 
+ 4719 4727 4741 4756 4769 4775 
+ 4720 4767 4782 15372 
+ 4716 4728 4736 4764 4770 4787 
+ 4722 4725 4746 4752 4774 4778 
+ 4589 4664 4690 4835 4844 4898 
+ 4723 4725 4750 4753 4778 4781 
+ 4721 4723 4752 4754 4781 4786 
+ 4718 4721 4753 4761 4786 4790 
+ 4703 4711 4738 4773 4783 4800 
+ 4727 4732 4747 4760 4775 4785 
+ 4729 4734 4763 4784 
+ 4726 4740 4767 4772 4788 15372 
+ 4724 4736 4740 4770 4772 4791 
+ 4732 4735 4756 4765 4785 4789 
+ 4712 4718 4754 4766 4790 4802 
+ 4169 4463 4851 4894 5272 5282 15364 
+ 4734 4741 4757 4769 4784 4792 
+ 4728 4738 4749 4783 4787 4803 
+ 4735 4743 4760 4771 4789 4793 
+ 4702 4712 4761 4779 4802 4819 
+ 4748 4758 4782 4788 4801 15372 
+ 4644 4709 4731 4808 4877 4883 
+ 4741 4747 4763 4775 4792 4797 
+ 4736 4749 4759 4787 4791 4809 
+ 4743 4746 4765 4774 4793 4798 
+ 4740 4758 4759 4788 4791 4807 
+ 4711 4739 4755 4800 4806 4833 
+ 4746 4750 4771 4778 4798 4805 
+ 4747 4756 4769 4785 4797 15373 
+ 4535 4661 4664 4844 4892 5012 
+ 4695 4739 4744 4806 4840 4857 
+ 4750 4752 4774 4781 4805 4810 
+ 4702 4737 4766 4812 4819 4853 
+ 312 894 4557 4973 6102 6345 
+ 4752 4753 4778 4786 4810 4814 
+ 4748 4767 4801 4815 
+ 4738 4755 4764 4800 4803 4828 
+ 4757 4763 4792 4811 
+ 4756 4760 4775 4789 4813 15373 
+ 4753 4754 4781 4790 4814 4818 
+ 4749 4764 4770 4803 4809 4826 
+ 4758 4767 4772 4801 4807 4822 
+ 4760 4765 4785 4793 4813 4817 
+ 4754 4761 4786 4802 4818 4831 
+ 4759 4770 4772 4807 4809 4829 
+ 4763 4769 4784 4797 4811 4820 
+ 4765 4771 4789 4798 4817 4825 
+ 4647 4690 4799 4835 4884 15375 
+ 4667 4730 4731 4877 4913 4966 
+ 4522 4577 4745 4869 4976 5213 
+ 4769 4775 4792 4820 4832 15373 
+ 4771 4774 4793 4805 4825 4834 
+ 4647 4701 4794 4824 4884 4902 
+ 4755 4773 4783 4828 4833 4855 
+ 4767 4782 4788 4815 4822 4838 
+ 4761 4766 4790 4819 4831 4841 
+ 4764 4783 4787 4826 4828 4848 
+ 4675 4679 4730 4821 4913 4941 
+ 4774 4778 4798 4810 4834 4839 
+ 4739 4773 4777 4833 4857 4870 
+ 4772 4788 4791 4822 4829 4845 
+ 4709 4742 4768 4836 4883 4911 
+ 4770 4787 4791 4826 4829 4847 
+ 4778 4781 4805 4814 4839 4842 
+ 4784 4792 4820 4843 
+ 4737 4779 4816 4853 4865 
+ 4785 4789 4817 4837 4846 15373 
+ 4781 4786 4810 4818 4842 4849 
+ 4782 4801 4838 4850 
+ 4733 4737 4812 4836 4865 4921 
+ 4789 4793 4813 4825 4846 4852 
+ 4786 4790 4814 4831 4849 4856 
+ 4766 4779 4802 4841 4853 4858 
+ 4792 4797 4811 4832 4843 4854 
+ 4679 4685 4804 4823 4941 4953 
+ 4788 4801 4807 4838 4845 4860 
+ 4685 4715 4821 4947 4953 
+ 4701 4744 4799 4840 4902 4933 
+ 4793 4798 4817 4834 4852 4859 
+ 4787 4803 4809 4847 4848 4866 
+ 4509 4706 4715 4947 5028 5107 
+ 4783 4800 4803 4848 4855 4872 
+ 4791 4807 4809 4845 4847 4863 
+ 2565 3697 4888 5050 5372 5652 
+ 4790 4802 4818 4841 4856 4864 
+ 4797 4820 4837 4854 4861 15373 
+ 4773 4800 4806 4855 4870 4882 
+ 4798 4805 4825 4839 4859 4862 
+ 4690 4751 4794 4898 4954 15375 
+ 4733 4742 4808 4816 4911 4921 
+ 4813 4832 4846 4861 4867 15373 
+ 4801 4815 4822 4850 4860 4873 
+ 4805 4810 4834 4842 4862 4868 
+ 4744 4777 4824 4857 4926 4933 
+ 4802 4819 4831 4858 4864 4871 
+ 4810 4814 4839 4849 4868 4875 
+ 4811 4820 4854 4874 
+ 4664 4751 4776 4898 5010 5012 
+ 4807 4822 4829 4860 4863 4878 
+ 4813 4817 4837 4852 4867 4876 
+ 4809 4826 4829 4863 4866 4887 
+ 4803 4826 4828 4866 4872 4889 
+ 4814 4818 4842 4856 4875 4880 
+ 4815 4838 4873 4886 
+ 4463 4600 4762 4869 5255 5272 
+ 4817 4825 4846 4859 4876 4879 
+ 4779 4812 4819 4858 4865 4885 4904 
+ 4820 4832 4843 4861 4874 4881 
+ 4800 4828 4833 4872 4882 4901 
+ 4818 4831 4849 4864 4880 4891 
+ 4777 4806 4840 4870 4924 4926 
+ 4819 4841 4853 4871 4885 
+ 4825 4834 4852 4862 4879 4890 
+ 4822 4838 4845 4873 4878 4896 
+ 4832 4837 4854 4867 4881 4895 
+ 4834 4839 4859 4868 4890 4899 
+ 4829 4845 4847 4878 4887 4905 
+ 4831 4841 4856 4871 4891 4897 
+ 4812 4816 4853 4904 4921 4943 
+ 4826 4847 4848 4887 4889 4907 
+ 4837 4846 4861 4876 4895 4900 
+ 4839 4842 4862 4875 4899 4903 
+ 4577 4600 4796 4851 5213 5255 
+ 4806 4833 4857 4882 4924 4927 
+ 4841 4858 4864 4885 4897 4909 
+ 4828 4848 4855 4889 4901 4914 
+ 4838 4850 4860 4886 4896 4912 
+ 4843 4854 4881 4906 
+ 4842 4849 4868 4880 4903 4910 
+ 4846 4852 4867 4879 4900 4908 
+ 4731 4768 4795 4883 4966 5026 
+ 4845 4860 4863 4896 4905 4918 
+ 4852 4859 4876 4890 4908 4915 
+ 4849 4856 4875 4891 4910 4917 
+ 4854 4861 4874 4895 4906 4916 
+ 4833 4855 4870 4901 4927 4932 
+ 4768 4808 4877 4911 4991 5026 
+ 4794 4799 4902 4940 4960 15375 
+ 4853 4858 4871 4904 4909 4931 
+ 4850 4873 4912 4922 
+ 4847 4863 4866 4905 4907 4925 
+ 2565 3878 4830 5611 5652 
+ 4848 4866 4872 4907 4914 4928 
+ 4859 4862 4879 4899 4915 15376 
+ 4856 4864 4880 4897 4917 4919 
+ 4661 4745 4776 4976 5012 5096 
+ 2700 4501 4525 4958 5290 5355 5486 
+ 4169 4383 4762 5221 5282 5498 
+ 4861 4867 4881 4900 4916 4923 
+ 4860 4873 4878 4912 4918 4934 
+ 4864 4871 4891 4909 4919 4920 
+ 4751 4835 4844 4954 5010 5018 
+ 4862 4868 4890 4903 4929 15376 
+ 4867 4876 4895 4908 4923 4930 
+ 4855 4872 4882 4914 4932 4937 
+ 4799 4824 4884 4933 4940 4978 
+ 4868 4875 4899 4910 4929 4935 
+ 4853 4865 4885 4931 4943 4982 
+ 4863 4878 4887 4918 4925 4942 
+ 4874 4881 4916 4936 
+ 4866 4887 4889 4925 4928 4946 
+ 4876 4879 4900 4915 4930 4938 
+ 4871 4885 4897 4920 4931 4944 
+ 4875 4880 4903 4917 4935 4939 
+ 4808 4836 4883 4921 4991 5003 
+ 4873 4886 4896 4922 4934 4951 
+ 4730 4795 4804 4941 4966 5080 5105 
+ 4872 4889 4901 4928 4937 4945 
+ 4879 4890 4908 4938 4948 15376 
+ 4881 4895 4906 4923 4936 4949 
+ 4880 4891 4910 4919 4939 4950 
+ 4878 4896 4905 4934 4942 4957 
+ 4891 4897 4917 4920 4950 4952 
+ 4897 4909 4919 4944 4952 
+ 4816 4836 4865 4911 4943 5000 5003 
+ 4886 4912 4951 4959 
+ 4895 4900 4916 4930 4949 4956 
+ 4857 4870 4926 4927 4975 4985 
+ 4887 4905 4907 4942 4946 4963 
+ 4840 4857 4924 4933 4985 4992 
+ 4870 4882 4924 4932 4970 4975 
+ 4889 4907 4914 4945 4946 4964 
+ 4899 4903 4935 4955 4961 15376 
+ 4900 4908 4923 4938 4956 4962 
+ 4885 4904 4909 4944 4977 4982 
+ 4882 4901 4927 4937 4965 4970 
+ 4824 4840 4902 4926 4978 4992 15377 
+ 4896 4912 4918 4951 4957 4972 
+ 4903 4910 4929 4939 4961 4968 
+ 4906 4916 4949 4969 
+ 4901 4914 4932 4945 4965 4967 
+ 4908 4915 4930 4948 4962 4971 
+ 4910 4917 4935 4950 4968 4974 
+ 4884 4902 4960 4978 5013 
+ 4804 4821 4913 4953 5105 5131 
+ 4905 4918 4925 4957 4963 4986 
+ 4865 4904 4921 4982 5000 5027 
+ 4909 4920 4931 4952 4977 4983 
+ 4914 4928 4937 4964 4967 4984 
+ 4907 4925 4928 4963 4964 4987 
+ 4715 4823 4827 4953 5107 5173 
+ 4915 4938 4955 4971 4980 15376 
+ 4916 4923 4936 4956 4969 4979 
+ 4917 4919 4939 4952 4974 4981 
+ 4912 4922 4934 4959 4972 4988 
+ 4919 4920 4944 4950 4981 4983 
+ 4821 4823 4941 4947 5131 5173 
+ 4835 4898 4993 5018 5033 15375 
+ 4929 4948 4961 4980 4989 15376 
+ 4923 4930 4949 4962 4979 4990 
+ 4918 4934 4942 4972 4986 4998 
+ 4525 4706 4893 5028 5190 5355 
+ 4922 4951 4988 4999 
+ 4884 4940 4993 5013 5044 15375 
+ 4929 4935 4955 4968 4989 4994 
+ 4930 4938 4956 4971 4990 4996 
+ 4925 4942 4946 4986 4987 5005 
+ 4928 4945 4946 4984 4987 5004 
+ 4932 4937 4967 4970 4997 5007 
+ 4795 4877 4913 5026 5080 5112 
+ 4937 4945 4965 4984 4997 
+ 4935 4939 4961 4974 4994 5002 
+ 4936 4949 4979 5001 
+ 4927 4932 4965 4975 5007 5017 
+ 4938 4948 4962 4980 4996 5006 
+ 4934 4951 4957 4988 4998 5015 
+ 894 1987 4780 5181 6066 6102 
+ 4939 4950 4968 4981 5002 5008 
+ 4924 4927 4970 4985 5017 5023 
+ 4745 4796 4892 5096 5213 5309 
+ 4931 4944 4982 4983 5016 5020 
+ 4902 4933 4940 5013 5066 15377 
+ 4949 4956 4969 4990 5001 5011 
+ 4948 4955 4971 4989 5006 5014 
+ 4950 4952 4974 4983 5008 5009 
+ 4904 4931 4943 4977 5020 5027 5041 
+ 4944 4952 4977 4981 5009 5016 
+ 4945 4964 4967 4997 5004 5019 
+ 4924 4926 4975 4992 5023 5032 
+ 4942 4957 4963 4998 5005 5024 
+ 4946 4963 4964 5004 5005 5025 
+ 4951 4959 4972 4999 5015 5029 
+ 4955 4961 4980 4994 5014 5021 
+ 4956 4962 4979 4996 5011 5022 
+ 4883 4911 5003 5026 5068 5093 
+ 4926 4933 4985 5032 5038 15377 
+ 4954 4960 5033 5044 5069 15375 
+ 4961 4968 4989 5002 5021 5031 
+ 253 460 4672 5317 6494 6562 
+ 4962 4971 4990 5006 5022 5030 
+ 4965 4967 4984 5007 5019 5034 
+ 4957 4972 4986 5015 5024 5037 
+ 4959 4988 5029 5040 
+ 4921 4943 5003 5027 5060 5082 
+ 4969 4979 5011 5035 
+ 4968 4974 4994 5008 5031 5036 
+ 4911 4921 4991 5000 5068 5082 
+ 4964 4984 4987 5019 5025 5043 
+ 4963 4986 4987 5024 5025 5045 
+ 4971 4980 4996 5014 5030 5039 
+ 4965 4970 4997 5017 5034 5049 
+ 4974 4981 5002 5009 5036 5042 
+ 4981 4983 5008 5016 5042 5048 
+ 4844 4898 5012 5018 5123 5160 
+ 4979 4990 5001 5022 5035 5046 
+ 4776 4844 4892 5010 5096 5160 5223 
+ 4940 4960 4978 5044 5066 5100 
+ 4980 4989 5006 5021 5039 5047 
+ 4972 4988 4998 5029 5037 5052 
+ 4977 4983 5009 5020 5048 5051 
+ 4970 4975 5007 5023 5049 5055 
+ 4898 4954 5010 5033 5101 5123 
+ 4984 4997 5004 5034 5043 5057 
+ 4977 4982 5016 5041 5051 5062 
+ 4989 4994 5014 5031 5047 5054 
+ 4990 4996 5011 5030 5046 5053 
+ 4975 4985 5017 5032 5055 5064 
+ 4986 4998 5005 5037 5045 15378 
+ 4987 5004 5005 5043 5045 5059 
+ 4877 4883 4966 4991 5093 5112 5149 
+ 4943 4982 5000 5041 5060 5070 
+ 4706 4827 4958 5107 5190 5256 
+ 4988 4999 5015 5040 5052 5061 
+ 4996 5006 5022 5039 5053 5056 
+ 4994 5002 5021 5036 5054 5058 
+ 4985 4992 5023 5038 5064 5072 
+ 4954 4993 5018 5069 5101 
+ 4997 5007 5019 5049 5057 5076 
+ 5001 5011 5046 5063 
+ 5002 5008 5031 5042 5058 5065 
+ 4998 5015 5024 5052 5074 15378 
+ 4992 5032 5072 5078 15377 
+ 5006 5014 5030 5047 5056 5067 
+ 4999 5029 5061 5077 
+ 4982 5020 5027 5062 5070 5086 
+ 5008 5009 5036 5048 5065 5071 
+ 5004 5019 5025 5057 5059 5083 
+ 4960 4993 5013 5069 5100 5134 
+ 5005 5024 5025 5059 5081 15378 
+ 5011 5022 5035 5053 5063 5073 
+ 5014 5021 5039 5054 5067 5075 
+ 5009 5016 5042 5051 5071 5079 
+ 5007 5017 5034 5055 5076 5092 
+ 3697 4176 4830 5180 5372 5667 
+ 5016 5020 5048 5062 5079 5087 
+ 5015 5029 5037 5061 5074 5088 
+ 5022 5030 5046 5056 5073 5084 
+ 5021 5031 5047 5058 5075 5085 
+ 5017 5023 5049 5064 5092 5113 
+ 5030 5039 5053 5067 5084 5089 
+ 5019 5034 5043 5076 5083 5104 
+ 5031 5036 5054 5065 5085 5090 
+ 5025 5043 5045 5081 5083 5102 
+ 5000 5027 5070 5082 5094 5114 
+ 5029 5040 5052 5077 5088 5103 
+ 5020 5041 5051 5086 5087 5106 
+ 5035 5046 5073 5095 
+ 5023 5032 5055 5072 5113 5130 
+ 5036 5042 5058 5071 5090 5097 
+ 4978 5013 5078 5100 5151 5164 15377 
+ 5039 5047 5056 5075 5089 5099 
+ 4991 5003 5082 5093 5136 5155 
+ 4993 5033 5044 5101 5134 5170 
+ 5027 5041 5060 5086 5094 5109 
+ 5042 5048 5065 5079 5097 5110 
+ 5032 5038 5064 5078 5130 5143 
+ 5046 5053 5063 5084 5095 5108 
+ 5037 5052 5088 5098 5115 15378 
+ 5047 5054 5067 5085 5099 5111 
+ 5034 5049 5057 5092 5104 5126 
+ 5040 5061 5103 5119 
+ 5038 5066 5072 5143 5151 15377 
+ 5048 5051 5071 5087 5110 5117 
+ 4913 4966 5105 5112 5218 5228 
+ 5045 5059 5098 5102 5121 15378 
+ 5000 5003 5060 5068 5114 5136 5141 
+ 5043 5057 5059 5102 5104 5125 
+ 5053 5056 5073 5089 5108 5116 
+ 5054 5058 5075 5090 5111 5118 
+ 5041 5062 5070 5106 5109 5120 
+ 5051 5062 5079 5106 5117 5127 
+ 5052 5061 5074 5103 5115 5129 
+ 5056 5067 5084 5099 5116 5122 
+ 5058 5065 5085 5097 5118 15379 
+ 167 239 410 6408 13608 14718 
+ 5049 5055 5076 5113 5126 5153 
+ 4991 5026 5068 5149 5155 5191 
+ 5060 5070 5109 5114 5124 
+ 5063 5073 5108 5128 
+ 4892 4976 5012 5223 5309 5375 
+ 5065 5071 5090 5110 5132 15379 
+ 5074 5081 5115 5121 5140 15378 
+ 5067 5075 5089 5111 5122 5133 
+ 5013 5044 5066 5134 5164 5200 
+ 5018 5033 5069 5123 5170 5203 
+ 5059 5081 5083 5121 5125 5146 
+ 5061 5077 5088 5119 5129 5145 
+ 5057 5076 5083 5125 5126 5148 
+ 4913 4941 5080 5131 5228 5300 
+ 5062 5086 5087 5120 5127 5138 
+ 4827 4947 5028 5173 5256 5336 
+ 5073 5084 5095 5116 5128 5137 
+ 5070 5086 5094 5120 5124 5135 
+ 5071 5079 5097 5117 5132 5142 
+ 5075 5085 5099 5118 5133 5139 
+ 4966 5026 5080 5149 5207 5218 5231 
+ 5055 5064 5092 5130 5153 5183 
+ 5060 5082 5094 5124 5141 5154 
+ 5074 5088 5098 5129 5140 5157 
+ 5084 5089 5108 5122 5137 5147 
+ 5079 5087 5110 5127 5142 5152 
+ 5085 5090 5111 5139 5150 15379 
+ 5077 5103 5145 5158 
+ 5086 5106 5109 5135 5138 5144 
+ 5081 5098 5102 5140 5146 5166 
+ 5089 5099 5116 5133 5147 5156 
+ 5010 5018 5101 5160 5203 5241 
+ 5094 5109 5114 5135 5154 5161 
+ 5083 5102 5104 5146 5148 5171 
+ 5076 5092 5104 5148 5153 5178 
+ 5087 5106 5117 5138 5152 5163 
+ 5095 5108 5137 5162 
+ 5088 5103 5115 5145 5157 5175 
+ 5064 5072 5113 5143 5183 5192 
+ 4941 4953 5105 5173 5300 5365 
+ 5097 5110 5142 5159 5169 15379 
+ 5099 5111 5122 5139 5156 5167 
+ 5044 5069 5100 5170 5200 5229 
+ 5109 5120 5124 5144 5161 5165 
+ 5068 5082 5141 5155 5194 5212 
+ 5108 5116 5128 5147 5162 5172 
+ 5106 5120 5127 5144 5163 5168 
+ 5111 5118 5133 5150 5167 5177 
+ 5098 5115 5121 5157 5166 5184 
+ 5082 5114 5136 5154 5194 5201 
+ 5110 5117 5132 5152 5169 5179 
+ 5072 5078 5130 5151 5192 5209 
+ 5120 5135 5138 5165 5168 
+ 5103 5119 5129 5158 5175 5187 
+ 5102 5121 5125 5166 5171 5188 
+ 5116 5122 5137 5156 5172 5182 
+ 5104 5125 5126 5171 5178 5195 
+ 5026 5093 5112 5191 5207 5243 
+ 5118 5139 5159 5177 5185 15379 
+ 5066 5078 5143 5164 5209 5222 
+ 5117 5127 5142 5163 5179 5186 
+ 5092 5113 5126 5178 5183 5210 
+ 5114 5124 5141 5161 5201 5202 
+ 5068 5093 5136 5191 5212 5238 
+ 5122 5133 5147 5167 5182 5189 
+ 5115 5129 5140 5175 5184 5205 
+ 5119 5145 5187 5204 
+ 5132 5150 5169 5185 5197 15379 
+ 5010 5012 5123 5223 5241 5334 
+ 5124 5135 5154 5165 5196 5202 
+ 5128 5137 5172 5199 
+ 5127 5138 5152 5168 5186 5193 
+ 5066 5100 5151 5200 5222 5266 
+ 5135 5144 5161 5168 5196 5198 
+ 5121 5140 5146 5184 5188 5215 
+ 5133 5139 5156 5177 5189 5206 
+ 5138 5144 5163 5165 5193 5198 
+ 5132 5142 5159 5179 5197 5208 
+ 5069 5101 5134 5203 5229 5262 
+ 5125 5146 5148 5188 5195 5217 
+ 5137 5147 5162 5182 5199 5211 
+ 4947 4953 5107 5131 5336 5365 5416 
+ 3287 4501 5181 5290 5828 5952 
+ 5129 5145 5157 5187 5205 5219 
+ 123 133 223 15053 15071 15220 
+ 5139 5150 5167 5185 5206 5214 
+ 5126 5148 5153 5195 5210 5226 
+ 5142 5152 5169 5186 5208 5216 
+ 4176 5050 5528 5667 5905 15374 
+ 1987 3287 4973 5174 5952 6066 6276 
+ 5147 5156 5172 5189 5211 5220 
+ 5113 5130 5153 5192 5210 5239 5249 
+ 5140 5157 5166 5205 5215 5233 
+ 5150 5159 5177 5197 5214 5225 
+ 5152 5163 5179 5193 5216 5224 
+ 5145 5158 5175 5204 5219 5236 
+ 5146 5166 5171 5215 5217 5242 
+ 5156 5167 5182 5206 5220 5230 
+ 4958 5028 5256 5355 5387 
+ 5093 5149 5155 5238 5243 5278 
+ 5130 5143 5183 5209 5239 5248 
+ 5163 5168 5186 5198 5224 5227 
+ 5136 5141 5201 5212 5250 5260 
+ 5148 5171 5178 5217 5226 5246 
+ 5161 5165 5198 5202 5232 5237 
+ 5159 5169 5185 5208 5225 5235 
+ 5165 5168 5193 5196 5227 5232 
+ 5162 5172 5211 5234 
+ 5100 5134 5164 5229 5266 5274 
+ 5141 5154 5194 5202 5244 5250 
+ 5154 5161 5196 5201 5237 5244 
+ 5101 5123 5170 5241 5262 5284 
+ 5158 5187 5236 5251 
+ 5157 5175 5184 5219 5233 5253 
+ 5167 5177 5189 5214 5230 5240 
+ 5112 5149 5231 5243 5276 
+ 5169 5179 5197 5216 5235 5245 
+ 5143 5151 5192 5222 5248 5257 
+ 5153 5178 5183 5226 5249 5258 
+ 5172 5182 5199 5220 5234 5247 
+ 5136 5155 5194 5238 5260 5277 
+ 4796 4869 4976 5255 5309 5549 5559 
+ 5177 5185 5206 5225 5240 5252 
+ 5166 5184 5188 5233 5242 5264 
+ 5179 5186 5208 5224 5245 5254 
+ 5171 5188 5195 5242 5246 5269 
+ 5080 5112 5228 5231 5301 15380 
+ 5175 5187 5205 5236 5253 5268 
+ 5182 5189 5211 5230 5247 5259 
+ 4383 4894 5498 5528 5763 15374 
+ 5151 5164 5209 5257 5266 5310 
+ 5012 5096 5160 5334 5375 5432 
+ 5186 5193 5216 5227 5254 5261 
+ 5185 5197 5214 5235 5252 5263 
+ 5178 5195 5210 5246 5258 5275 
+ 5193 5198 5224 5232 5261 5265 
+ 5080 5105 5218 5300 5398 15380 
+ 5134 5170 5200 5262 5274 5311 
+ 5189 5206 5220 5240 5259 5267 
+ 5112 5207 5218 5276 5301 
+ 5196 5198 5227 5237 5265 5270 
+ 5184 5205 5215 5253 5264 5283 
+ 5199 5211 5247 5271 
+ 5197 5208 5225 5245 5263 5273 
+ 5187 5204 5219 5251 5268 5285 
+ 5196 5202 5232 5244 5270 5280 
+ 5155 5191 5212 5277 5278 5315 
+ 5183 5192 5248 5249 5295 5302 
+ 5206 5214 5230 5252 5267 5279 
+ 5123 5160 5203 5284 5334 5400 
+ 5188 5215 5217 5264 5269 5292 
+ 5149 5191 5207 5276 5278 5319 
+ 5201 5202 5237 5250 5280 5287 
+ 5208 5216 5235 5254 5273 5281 
+ 5195 5217 5226 5269 5275 5298 
+ 5211 5220 5234 5259 5271 5286 
+ 5192 5209 5239 5257 5302 5307 
+ 5183 5210 5239 5258 5291 5295 
+ 5194 5201 5244 5260 5287 5297 
+ 5204 5236 5285 5299 
+ 5214 5225 5240 5263 5279 5288 
+ 5205 5219 5233 5268 5283 5304 
+ 5216 5224 5245 5261 5281 5289 
+ 4851 4869 5213 5272 5549 5583 
+ 5028 5107 5190 5336 5387 5446 
+ 5209 5222 5248 5307 5310 
+ 5210 5226 5249 5275 5291 5305 
+ 5220 5230 5247 5267 5286 5294 
+ 5194 5212 5250 5277 5297 5318 
+ 5224 5227 5254 5265 5289 5296 
+ 5170 5203 5229 5284 5311 5335 
+ 5225 5235 5252 5273 5288 5303 
+ 5215 5233 5242 5283 5292 5314 
+ 5227 5232 5261 5270 5296 5306 
+ 5164 5200 5222 5274 5310 5339 
+ 5230 5240 5259 5279 5294 5308 
+ 5219 5236 5253 5285 5304 5320 
+ 5217 5242 5246 5292 5298 5323 
+ 5232 5237 5265 5280 5306 5316 
+ 5234 5247 5286 5312 
+ 4762 4851 5255 5282 5583 5609 
+ 5235 5245 5263 5281 5303 5313 
+ 5200 5229 5266 5311 5339 5384 
+ 5226 5246 5258 5298 5305 5328 
+ 5207 5231 5243 5301 5319 5353 
+ 5212 5238 5260 5315 5318 5340 
+ 5191 5238 5243 5315 5319 5343 
+ 5240 5252 5267 5288 5308 5321 
+ 5237 5244 5270 5287 5316 5324 
+ 5245 5254 5273 5289 5313 5322 
+ 4762 4894 5272 5498 5609 5647 
+ 5233 5253 5264 5304 5314 5330 
+ 5203 5241 5262 5335 5400 
+ 5236 5251 5268 5299 5320 5331 
+ 5247 5259 5271 5294 5312 5325 
+ 5244 5250 5280 5297 5324 5333 
+ 5252 5263 5279 5303 5321 5326 
+ 5254 5261 5281 5296 5322 5327 
+ 4501 4893 5174 5486 5828 5831 
+ 5249 5258 5295 5305 5329 
+ 5242 5264 5269 5314 5323 5341 
+ 275 2535 4201 6549 7003 11051 
+ 5259 5267 5286 5308 5325 5332 
+ 5239 5249 5291 5302 5329 5350 
+ 5261 5265 5289 5306 5327 5337 
+ 5250 5260 5287 5318 5333 5348 
+ 5246 5269 5275 5323 5328 5351 
+ 5251 5285 5331 5346 
+ 5105 5131 5228 5365 5398 5423 
+ 5218 5231 5276 5353 5402 15380 
+ 5239 5248 5295 5307 5350 5369 
+ 5263 5273 5288 5313 5326 5338 
+ 5253 5268 5283 5320 5330 5349 
+ 5258 5275 5291 5328 5329 5356 
+ 5265 5270 5296 5316 5337 5344 
+ 5248 5257 5302 5310 5369 5382 
+ 5267 5279 5294 5321 5332 5342 
+ 4976 5096 5213 5375 5559 5568 
+ 5222 5257 5266 5307 5339 5382 5389 
+ 5229 5262 5274 5335 5384 5420 
+ 5271 5286 5325 5345 
+ 5273 5281 5303 5322 5338 5347 
+ 5264 5283 5292 5330 5341 5359 
+ 5238 5277 5278 5340 5343 5364 
+ 5270 5280 5306 5324 5344 5352 
+ 460 3878 4995 5611 6494 6507 
+ 5260 5277 5297 5340 5348 5366 
+ 5243 5276 5278 5343 5353 5385 
+ 5268 5285 5304 5331 5349 5362 
+ 5279 5288 5308 5326 5342 5354 
+ 5281 5289 5313 5327 5347 5357 
+ 5269 5292 5298 5341 5351 5368 
+ 5280 5287 5316 5333 5352 5361 
+ 5286 5294 5312 5332 5345 5358 
+ 5288 5303 5321 5338 5354 5360 
+ 5289 5296 5322 5337 5357 5363 
+ 5275 5298 5305 5351 5356 5378 
+ 5291 5295 5305 5350 5356 5379 
+ 5283 5304 5314 5349 5359 5376 
+ 5285 5299 5320 5346 5362 5373 
+ 5294 5308 5325 5342 5358 5367 
+ 5287 5297 5324 5348 5361 5377 
+ 5160 5223 5241 5400 5432 5492 
+ 5262 5284 5311 5400 5420 
+ 5107 5173 5256 5416 5446 5503 
+ 5296 5306 5327 5344 5363 5370 
+ 5303 5313 5326 5347 5360 5371 
+ 5266 5274 5310 5384 5389 5447 
+ 5277 5315 5318 5364 5366 5393 
+ 5292 5314 5323 5359 5368 5386 
+ 5308 5321 5332 5354 5367 5374 
+ 5278 5315 5319 5364 5385 5403 
+ 5306 5316 5337 5352 5370 5381 
+ 5312 5325 5358 5380 
+ 5299 5331 5373 5391 
+ 5313 5322 5338 5357 5371 5383 
+ 5297 5318 5333 5366 5377 5396 
+ 5304 5320 5330 5362 5376 5395 
+ 5295 5302 5329 5369 5379 5425 
+ 5298 5323 5328 5368 5378 5399 
+ 5316 5324 5344 5361 5381 5390 
+ 5276 5301 5319 5385 5402 5440 
+ 5321 5326 5342 5360 5374 5388 
+ 4893 4958 5190 5387 5486 5625 5679 
+ 5305 5328 5329 5378 5379 5412 
+ 5322 5327 5347 5363 5383 5392 
+ 5325 5332 5345 5367 5380 5394 
+ 5314 5330 5341 5376 5386 5407 
+ 5326 5338 5354 5371 5388 5397 
+ 5324 5333 5352 5377 5390 5405 
+ 5320 5331 5349 5373 5395 5410 
+ 5327 5337 5357 5370 5392 5401 
+ 5315 5340 5343 5393 5403 5406 
+ 5131 5173 5300 5416 5423 5518 5520 
+ 5318 5340 5348 5393 5396 5419 
+ 5332 5342 5358 5374 5394 5404 
+ 5323 5341 5351 5386 5399 15381 
+ 5302 5307 5350 5382 5425 5433 
+ 5337 5344 5363 5381 5401 5411 
+ 5338 5347 5360 5383 5397 5409 
+ 4830 5050 5652 5667 5974 
+ 5331 5346 5362 5391 5410 5421 
+ 5342 5354 5367 5388 5404 5413 
+ 5096 5223 5309 5432 5568 5580 
+ 5330 5349 5359 5395 5407 5424 
+ 5333 5348 5361 5396 5405 5415 
+ 5328 5351 5356 5399 5412 5428 
+ 5329 5350 5356 5412 5425 5445 
+ 5345 5358 5394 5414 
+ 5344 5352 5370 5390 5411 5417 
+ 5307 5310 5369 5389 5433 5441 
+ 5347 5357 5371 5392 5409 5418 
+ 5274 5311 5339 5420 5447 5509 
+ 5319 5343 5353 5403 5440 5464 
+ 5341 5359 5368 5407 5435 15381 
+ 5190 5256 5355 5446 5578 5625 
+ 5354 5360 5374 5397 5413 5422 
+ 5310 5339 5382 5441 5447 5477 
+ 5352 5361 5381 5405 5417 5429 
+ 5346 5373 5421 5437 
+ 5357 5363 5383 5401 5418 5427 
+ 5340 5364 5366 5406 5419 5434 
+ 5358 5367 5380 5404 5414 5426 
+ 5349 5362 5376 5410 5424 5439 
+ 5348 5366 5377 5415 5419 5430 
+ 5360 5371 5388 5409 5422 5431 
+ 5228 5300 5423 5493 5521 15380 
+ 5351 5368 5378 5428 5443 15381 
+ 5241 5284 5334 5335 5420 5492 5553 
+ 5363 5370 5392 5411 5427 5436 
+ 5301 5353 5440 5493 5516 15380 
+ 5343 5364 5385 5406 5449 5464 
+ 5367 5374 5394 5413 5426 5438 
+ 5361 5377 5390 5415 5429 5442 
+ 5364 5393 5403 5434 5449 
+ 5359 5376 5386 5424 5435 5453 
+ 148 200 223 7666 15071 15133 
+ 5371 5383 5397 5418 5431 5444 
+ 5362 5373 5395 5421 5439 5454 
+ 5370 5381 5401 5417 5436 5448 
+ 5356 5378 5379 5428 5445 5462 
+ 5374 5388 5404 5422 5438 5451 
+ 5380 5394 5426 5452 
+ 5377 5396 5405 5430 5442 5450 
+ 5173 5336 5365 5503 5520 5566 
+ 5381 5390 5411 5429 5448 5456 
+ 5383 5392 5409 5427 5444 5455 
+ 5366 5393 5396 5430 5434 5457 5459 
+ 5311 5335 5384 5400 5509 5553 5582 
+ 5373 5391 5410 5437 5454 5467 
+ 5388 5397 5413 5431 5451 5458 
+ 5300 5365 5398 5518 5521 
+ 5376 5395 5407 5439 5453 5468 
+ 5350 5369 5379 5433 5445 5474 5482 
+ 5394 5404 5414 5438 5452 5460 
+ 5392 5401 5418 5436 5455 5463 
+ 5378 5399 5412 5443 5462 5471 
+ 5390 5405 5417 5442 5456 5465 
+ 5396 5415 5419 5450 5459 
+ 5397 5409 5422 5444 5458 5466 
+ 5223 5334 5375 5492 5580 5585 
+ 5369 5382 5425 5441 5474 5480 
+ 5393 5406 5419 5449 5457 5473 
+ 5386 5407 5453 5461 5476 15381 
+ 5401 5411 5427 5448 5463 5469 
+ 5391 5421 5467 5478 
+ 5404 5413 5426 5451 5460 5470 
+ 5395 5410 5424 5454 5468 5484 
+ 5353 5385 5402 5464 5516 5540 
+ 5382 5389 5433 5477 5480 
+ 5405 5415 5429 5450 5465 5472 
+ 5399 5428 5461 5471 5487 15381 
+ 5409 5418 5431 5455 5466 5475 
+ 5379 5412 5425 5462 5482 5497 
+ 5256 5336 5387 5503 5578 5634 
+ 5339 5384 5389 5477 5509 5536 
+ 5411 5417 5436 5456 5469 5479 
+ 5403 5406 5434 5464 5473 5501 
+ 5415 5430 5442 5459 5472 5488 
+ 5413 5422 5438 5458 5470 5481 
+ 5414 5426 5460 5485 
+ 5407 5424 5435 5468 5476 5495 
+ 5410 5421 5439 5467 5484 5499 
+ 5418 5427 5444 5463 5475 5489 
+ 5417 5429 5448 5465 5479 5490 
+ 5419 5434 5459 5473 5483 
+ 5422 5431 5451 5466 5481 5491 
+ 5419 5430 5450 5457 5483 5488 
+ 5426 5438 5452 5470 5485 5494 
+ 5435 5443 5476 5487 5506 15381 
+ 5412 5428 5445 5471 5497 5505 
+ 5427 5436 5455 5469 5489 5496 
+ 5385 5403 5440 5449 5501 5540 5561 
+ 5429 5442 5456 5472 5490 5500 
+ 5431 5444 5458 5475 5491 5504 
+ 5421 5437 5454 5478 5499 5510 
+ 5424 5439 5453 5484 5495 5512 
+ 5436 5448 5463 5479 5496 5508 
+ 5438 5451 5460 5481 5494 5507 
+ 5428 5443 5462 5487 5505 5513 
+ 5442 5450 5465 5488 5500 5502 
+ 5434 5449 5457 5483 5501 5519 
+ 5425 5433 5480 5482 5538 5541 
+ 5444 5455 5466 5489 5504 5511 
+ 5435 5453 5461 5495 5506 5524 
+ 5389 5441 5447 5480 5536 5548 
+ 5437 5467 5510 5527 
+ 5448 5456 5469 5490 5508 5515 
+ 5433 5441 5474 5477 5541 5548 
+ 5451 5458 5470 5491 5507 5514 
+ 5425 5445 5474 5497 5523 5538 
+ 5457 5459 5473 5488 5519 5526 
+ 5439 5454 5468 5499 5512 5530 
+ 5452 5460 5494 5517 
+ 4893 5290 5355 5679 5831 5863 
+ 5443 5461 5471 5506 5513 5534 
+ 5450 5459 5472 5483 5502 5526 5531 
+ 5455 5463 5475 5496 5511 5522 
+ 5456 5465 5479 5500 5515 5525 
+ 5458 5466 5481 5504 5514 5529 
+ 5334 5400 5432 5553 5585 5607 
+ 5398 5402 5516 5521 5621 5629 15380 
+ 5460 5470 5485 5507 5517 5532 
+ 5453 5468 5476 5512 5524 5545 
+ 5463 5469 5489 5508 5522 5535 
+ 5445 5462 5482 5505 5523 5537 
+ 4894 5221 5282 5647 5763 5889 
+ 5454 5467 5484 5510 5530 5546 
+ 5465 5472 5490 5502 5525 5533 
+ 5449 5464 5473 5519 5561 5577 
+ 5472 5488 5500 5531 5533 
+ 5336 5416 5446 5566 5634 5682 
+ 5466 5475 5491 5511 5529 5539 
+ 5462 5471 5497 5513 5537 5544 
+ 5461 5476 5487 5524 5534 5554 
+ 5470 5481 5494 5514 5532 5542 
+ 5469 5479 5496 5515 5535 5543 
+ 5384 5420 5447 5536 5582 5608 
+ 5467 5478 5499 5527 5546 5556 
+ 5475 5489 5504 5522 5539 5547 
+ 5468 5484 5495 5530 5545 5560 
+ 5471 5487 5505 5534 5544 5562 
+ 5481 5491 5507 5529 5542 5551 
+ 5479 5490 5508 5525 5543 5552 
+ 5402 5440 5493 5540 5620 5621 
+ 5485 5494 5532 5555 
+ 5365 5423 5520 5521 5636 5641 
+ 5473 5483 5501 5526 5577 5592 
+ 5365 5416 5518 5566 5641 5672 
+ 5398 5423 5493 5518 5629 5636 
+ 5489 5496 5511 5535 5547 5557 
+ 5482 5497 5537 5538 5574 
+ 5476 5495 5506 5545 5554 5572 
+ 5490 5500 5515 5533 5552 5558 
+ 5483 5488 5519 5531 5570 5592 
+ 5478 5510 5556 5571 
+ 5180 5221 5763 5905 6206 15374 
+ 5491 5504 5514 5539 5551 5563 
+ 5484 5499 5512 5546 5560 5575 
+ 5488 5502 5526 5533 5564 5570 
+ 5494 5507 5517 5542 5555 5565 
+ 5500 5502 5525 5531 5558 5564 
+ 5487 5506 5513 5554 5562 5581 
+ 5496 5508 5522 5543 5557 5567 
+ 5447 5477 5509 5548 5608 5635 
+ 5497 5505 5523 5544 5569 5574 
+ 5474 5482 5523 5541 5574 5595 
+ 5504 5511 5529 5547 5563 5573 
+ 5440 5464 5516 5561 5620 5623 
+ 5474 5480 5538 5548 5595 5650 
+ 5507 5514 5532 5551 5565 5576 
+ 5508 5515 5535 5552 5567 5579 
+ 5505 5513 5537 5562 5569 5587 
+ 5495 5512 5524 5560 5572 5590 
+ 5499 5510 5530 5556 5575 5591 
+ 5511 5522 5539 5557 5573 5584 
+ 5477 5480 5536 5541 5635 5650 
+ 5213 5255 5559 5583 5790 5820 
+ 361 2535 4557 6549 6996 8429 
+ 5514 5529 5542 5563 5576 5586 
+ 5515 5525 5543 5558 5579 5588 
+ 5400 5420 5492 5582 5607 5664 5670 
+ 5506 5524 5534 5572 5581 5598 
+ 5517 5532 5565 5589 
+ 5510 5527 5546 5571 5591 5600 
+ 5522 5535 5547 5567 5584 5593 
+ 5525 5533 5552 5564 5588 5594 
+ 5213 5309 5549 5568 5764 5790 
+ 5512 5530 5545 5575 5590 5602 
+ 5464 5501 5540 5577 5623 5628 
+ 5513 5534 5544 5581 5587 5605 
+ 5529 5539 5551 5573 5586 5596 
+ 5531 5533 5558 5570 5594 5599 
+ 5532 5542 5555 5576 5589 5597 
+ 5416 5503 5520 5672 5682 
+ 5535 5543 5557 5579 5593 5601 
+ 5309 5375 5559 5580 5734 5764 
+ 5537 5544 5574 5587 5604 
+ 5526 5531 5564 5592 5599 5617 
+ 5527 5556 5600 5612 
+ 5524 5545 5554 5590 5598 5613 
+ 5539 5547 5563 5584 5596 5603 
+ 5523 5537 5538 5569 5595 5604 5631 
+ 5530 5546 5560 5591 5602 5616 
+ 5542 5551 5565 5586 5597 5606 
+ 5501 5519 5561 5592 5628 5639 
+ 5387 5446 5625 5634 5742 5761 
+ 5543 5552 5567 5588 5601 5610 
+ 5375 5432 5568 5585 5707 5734 
+ 5534 5554 5562 5598 5605 5622 
+ 5420 5509 5553 5608 5664 5694 
+ 5255 5272 5549 5609 5820 5848 
+ 5547 5557 5573 5593 5603 5614 
+ 5432 5492 5580 5607 5701 5707 
+ 5551 5563 5576 5596 5606 5615 
+ 5544 5562 5569 5604 5605 5637 
+ 5552 5558 5579 5594 5610 5618 
+ 5555 5565 5597 5619 
+ 5545 5560 5572 5602 5613 5633 
+ 5546 5556 5575 5600 5616 5632 
+ 5519 5526 5570 5577 5617 5639 5651 
+ 5557 5567 5584 5601 5614 5624 
+ 5558 5564 5588 5599 5618 5627 
+ 5538 5541 5574 5631 5650 5676 
+ 5563 5573 5586 5603 5615 5626 
+ 5565 5576 5589 5606 5619 5630 
+ 5554 5572 5581 5613 5622 5643 
+ 5564 5570 5594 5617 5627 5644 
+ 5556 5571 5591 5612 5632 5646 
+ 5567 5579 5593 5610 5624 5638 
+ 5560 5575 5590 5616 5633 5648 
+ 5573 5584 5596 5614 5626 5640 
+ 5569 5574 5587 5631 5637 5658 
+ 5562 5581 5587 5622 5637 5656 
+ 5576 5586 5597 5615 5630 5642 
+ 5492 5553 5585 5670 5701 
+ 5509 5536 5582 5635 5688 5694 
+ 5272 5282 5583 5647 5848 5870 
+ 5579 5588 5601 5618 5638 5645 
+ 3878 4888 5317 5652 6391 6507 
+ 5571 5600 5646 5657 
+ 5572 5590 5598 5633 5643 5660 
+ 5584 5593 5603 5624 5640 5649 
+ 5586 5596 5606 5626 5642 5653 
+ 5575 5591 5602 5632 5648 5662 
+ 5570 5592 5599 5644 5651 5666 
+ 5588 5594 5610 5627 5645 5655 
+ 5589 5597 5630 5654 
+ 5516 5540 5621 5623 5691 5699 
+ 5493 5516 5620 5629 5699 5713 
+ 5581 5598 5605 5643 5656 5669 
+ 5540 5561 5620 5628 5686 5691 
+ 5593 5601 5614 5638 5649 5659 
+ 5355 5387 5578 5679 5761 5784 
+ 5596 5603 5615 5640 5653 5661 
+ 5594 5599 5618 5644 5655 5665 
+ 5561 5577 5623 5639 5678 5686 
+ 5493 5521 5621 5636 5713 5726 
+ 5597 5606 5619 5642 5654 5663 
+ 5574 5595 5604 5658 5676 5700 
+ 5591 5600 5616 5646 5662 5674 
+ 5590 5602 5613 5648 5660 5675 
+ 5446 5503 5578 5682 5742 5803 
+ 5536 5548 5608 5650 5688 5711 
+ 5518 5521 5629 5641 5726 5745 
+ 5587 5604 5605 5656 5658 5684 
+ 5601 5610 5624 5645 5659 5668 
+ 5577 5592 5628 5651 5678 5681 
+ 5603 5614 5626 5649 5661 5671 
+ 5518 5520 5636 5672 5745 5825 
+ 5606 5615 5630 5653 5663 5673 
+ 5598 5613 5622 5660 5669 5689 
+ 5599 5617 5627 5665 5666 5685 
+ 5610 5618 5638 5655 5668 5677 
+ 5600 5612 5632 5657 5674 5690 
+ 5282 5498 5609 5870 5889 
+ 5602 5616 5633 5662 5675 5693 
+ 5614 5624 5640 5659 5671 5680 
+ 5541 5548 5595 5635 5676 5711 5728 
+ 5592 5617 5639 5666 5681 5696 
+ 4830 4888 5372 5611 5974 6391 6710 
+ 5615 5626 5642 5661 5673 5683 
+ 5619 5630 5663 5687 
+ 5618 5627 5645 5665 5677 5692 
+ 5605 5622 5637 5669 5684 5703 
+ 5612 5646 5690 5702 
+ 5604 5631 5637 5684 5700 5717 
+ 5624 5638 5649 5668 5680 5695 
+ 5613 5633 5643 5675 5689 5708 
+ 5626 5640 5653 5671 5683 5697 
+ 5616 5632 5648 5674 5693 5710 
+ 5630 5642 5654 5673 5687 5698 
+ 5553 5582 5670 5694 5736 5759 
+ 5627 5644 5655 5685 5692 5705 
+ 5617 5644 5651 5685 5696 5709 
+ 5050 5180 5372 5905 5974 6160 
+ 5638 5645 5659 5677 5695 5704 
+ 5622 5643 5656 5689 5703 5718 
+ 5553 5607 5664 5701 5759 5785 
+ 5640 5649 5661 5680 5697 5706 
+ 5520 5566 5641 5682 5825 5841 
+ 5642 5653 5663 5683 5698 5712 
+ 5632 5646 5662 5690 5710 5722 
+ 5633 5648 5660 5693 5708 5723 
+ 5595 5631 5650 5700 5728 5743 
+ 5645 5655 5668 5692 5704 5715 
+ 5628 5639 5681 5686 5729 5746 
+ 5355 5486 5625 5784 5851 5863 
+ 5649 5659 5671 5695 5706 5716 
+ 5639 5651 5678 5696 5714 5729 
+ 5503 5566 5634 5672 5803 5841 
+ 5653 5661 5673 5697 5712 5719 
+ 5637 5656 5658 5703 5717 5733 
+ 5644 5665 5666 5705 5709 5720 
+ 5623 5628 5678 5691 5746 5757 
+ 5654 5663 5698 5721 
+ 5608 5635 5694 5711 5775 5792 
+ 5643 5660 5669 5708 5718 5735 
+ 5646 5657 5674 5702 5722 5732 
+ 5620 5623 5686 5699 5757 5767 
+ 5655 5665 5677 5705 5715 5724 
+ 5648 5662 5675 5710 5723 5740 
+ 5582 5608 5664 5688 5736 5775 
+ 5659 5668 5680 5704 5716 5727 
+ 5651 5666 5681 5709 5714 5725 
+ 5661 5671 5683 5706 5719 5730 
+ 5663 5673 5687 5712 5721 5731 
+ 5620 5621 5691 5713 5767 5780 
+ 5631 5658 5676 5717 5743 5753 
+ 5585 5607 5670 5707 5785 5810 
+ 5657 5690 5732 5748 
+ 5656 5669 5684 5718 5733 5750 
+ 5668 5677 5695 5715 5727 5738 
+ 5665 5685 5692 5720 5724 5737 
+ 5671 5680 5697 5716 5730 5741 
+ 5580 5585 5701 5734 5810 5888 
+ 5660 5675 5689 5723 5735 5754 
+ 5666 5685 5696 5720 5725 5739 
+ 5662 5674 5693 5722 5740 5756 
+ 5635 5650 5688 5728 5792 5804 
+ 5673 5683 5698 5719 5731 5744 
+ 5621 5629 5699 5726 5780 5809 
+ 5681 5696 5725 5729 5749 
+ 5677 5692 5704 5724 5738 5751 
+ 5680 5695 5706 5727 5741 5752 
+ 5658 5684 5700 5733 5753 5774 
+ 5669 5689 5703 5735 5750 5769 
+ 5683 5697 5712 5730 5744 5755 
+ 5685 5705 5709 5737 5739 5747 
+ 5687 5698 5731 5758 
+ 5674 5690 5710 5732 5756 5770 
+ 5675 5693 5708 5740 5754 5773 
+ 5692 5705 5715 5737 5751 5762 
+ 5696 5709 5714 5739 5749 5760 
+ 5629 5636 5713 5745 5809 5816 
+ 5695 5704 5716 5738 5752 5765 
+ 5650 5676 5711 5743 5804 5808 
+ 5678 5681 5714 5746 5749 5791 
+ 5697 5706 5719 5741 5755 5766 
+ 5698 5712 5721 5744 5758 5768 
+ 5690 5702 5722 5748 5770 5779 
+ 5684 5703 5717 5750 5774 5781 
+ 5568 5580 5707 5764 5888 5934 
+ 5689 5708 5718 5754 5769 5782 
+ 5664 5694 5759 5775 5834 
+ 5705 5720 5724 5747 5762 5772 
+ 5704 5715 5727 5751 5765 5776 
+ 5709 5720 5725 5747 5760 5771 
+ 5693 5710 5723 5756 5773 5786 
+ 5706 5716 5730 5752 5766 5777 
+ 5578 5634 5761 5803 5871 5903 
+ 5676 5700 5728 5753 5807 5808 
+ 5712 5719 5731 5755 5768 5778 
+ 5636 5641 5726 5816 5825 5891 
+ 5678 5686 5729 5757 5791 5813 
+ 5720 5737 5739 5771 5772 
+ 5702 5732 5779 5793 
+ 5714 5725 5729 5760 5791 5796 
+ 5703 5718 5733 5769 5781 5798 
+ 5715 5724 5738 5762 5776 5783 
+ 5716 5727 5741 5765 5777 5787 
+ 5700 5717 5743 5774 5794 5807 
+ 5708 5723 5735 5773 5782 5805 
+ 5719 5730 5744 5766 5778 5788 
+ 5710 5722 5740 5770 5786 5802 
+ 5686 5691 5746 5767 5813 5837 
+ 5721 5731 5768 5789 
+ 5664 5670 5736 5785 5834 5883 
+ 5725 5739 5749 5771 5796 5797 
+ 5578 5625 5742 5784 5871 5892 
+ 5724 5737 5751 5772 5783 5795 
+ 5221 5498 5528 5889 6206 6248 
+ 5559 5568 5734 5790 5934 5995 
+ 5727 5738 5752 5776 5787 5800 
+ 5730 5741 5755 5777 5788 5801 
+ 5691 5699 5757 5780 5837 5860 
+ 5731 5744 5758 5778 5789 5806 
+ 5718 5735 5750 5782 5798 5817 
+ 5722 5732 5756 5779 5802 5815 
+ 5739 5747 5760 5772 5797 5799 
+ 5737 5747 5762 5771 5795 5799 
+ 5723 5740 5754 5786 5805 5819 
+ 5717 5733 5753 5781 5794 5818 
+ 5688 5694 5736 5792 5834 5878 
+ 5738 5751 5765 5783 5800 5811 
+ 5741 5752 5766 5787 5801 5812 
+ 5744 5755 5768 5788 5806 5814 
+ 5732 5748 5770 5793 5815 5827 
+ 5699 5713 5767 5809 5860 5897 
+ 5733 5750 5774 5798 5818 5830 
+ 5735 5754 5769 5805 5817 5832 
+ 5751 5762 5776 5795 5811 5821 
+ 5625 5679 5761 5851 5892 5913 
+ 5670 5701 5759 5810 5883 5933 
+ 5740 5756 5773 5802 5819 5833 
+ 5752 5765 5777 5800 5812 5822 
+ 5755 5766 5778 5801 5814 5823 
+ 5758 5768 5806 5824 
+ 5549 5559 5764 5820 5995 6058 
+ 5729 5746 5749 5796 5813 5850 5858 
+ 5688 5711 5775 5804 5878 5916 
+ 5748 5779 5827 5842 
+ 5753 5774 5807 5818 5840 
+ 5762 5772 5783 5799 5821 5826 
+ 5749 5760 5791 5797 5839 5850 
+ 5760 5771 5796 5799 5829 5839 
+ 5750 5769 5781 5817 5830 5849 
+ 5771 5772 5795 5797 5826 5829 
+ 5765 5776 5787 5811 5822 5835 
+ 5766 5777 5788 5812 5823 5836 
+ 5756 5770 5786 5815 5833 5845 
+ 5634 5682 5742 5841 5903 5969 
+ 5711 5728 5792 5808 5896 5916 
+ 5754 5773 5782 5819 5832 5847 
+ 5768 5778 5789 5814 5824 5838 
+ 5743 5753 5794 5808 5840 5864 
+ 5728 5743 5804 5807 5864 5896 
+ 5713 5726 5780 5816 5895 5897 
+ 5701 5707 5785 5888 5933 
+ 5776 5783 5800 5821 5835 5843 
+ 5777 5787 5801 5822 5836 5844 
+ 5746 5757 5791 5837 5858 5882 
+ 5778 5788 5806 5823 5838 5846 
+ 5770 5779 5802 5827 5845 5856 
+ 5726 5745 5809 5891 5895 
+ 5769 5782 5798 5832 5849 5862 
+ 5774 5781 5794 5830 5840 5859 
+ 5773 5786 5805 5833 5847 5861 
+ 5549 5583 5790 5848 6058 6141 
+ 5783 5795 5811 5826 5843 5852 
+ 5787 5800 5812 5835 5844 5853 
+ 5788 5801 5814 5836 5846 5854 
+ 5789 5806 5838 5855 
+ 5641 5672 5745 5841 5891 5976 6020 
+ 5795 5799 5821 5829 5852 5857 
+ 5779 5793 5815 5842 5856 5869 
+ 5174 5290 5831 5952 6127 6203 
+ 5797 5799 5826 5839 5857 5867 
+ 5781 5798 5818 5849 5859 5877 
+ 5290 5486 5828 5863 6127 6131 
+ 5782 5805 5817 5847 5862 5875 
+ 5786 5802 5819 5845 5861 5873 
+ 5736 5759 5775 5878 5883 5954 
+ 5800 5811 5822 5843 5853 5865 
+ 5801 5812 5823 5844 5854 5866 
+ 5757 5767 5813 5860 5882 5915 
+ 5806 5814 5824 5846 5855 5868 
+ 5796 5797 5829 5850 5867 5879 
+ 5794 5807 5818 5859 5864 5893 
+ 5672 5682 5803 5825 5969 6020 
+ 5793 5827 5869 5880 
+ 5811 5821 5835 5852 5865 5872 
+ 5812 5822 5836 5853 5866 5874 
+ 5802 5815 5833 5856 5873 5887 
+ 5814 5823 5838 5854 5868 5876 
+ 5805 5819 5832 5861 5875 5890 
+ 5583 5609 5820 5870 6141 6180 
+ 5798 5817 5830 5862 5877 5898 
+ 5791 5796 5839 5858 5879 5899 
+ 5679 5784 5863 5913 6055 
+ 5821 5826 5843 5857 5872 5881 
+ 5822 5835 5844 5865 5874 5884 
+ 5823 5836 5846 5866 5876 5885 
+ 5824 5838 5868 5886 
+ 5815 5827 5845 5869 5887 5904 
+ 5826 5829 5852 5867 5881 5894 
+ 5791 5813 5850 5882 5899 5918 
+ 5818 5830 5840 5877 5893 5912 
+ 5767 5780 5837 5897 5915 5949 
+ 5819 5833 5847 5873 5890 5906 
+ 5817 5832 5849 5875 5898 5907 
+ 5486 5679 5831 5851 6055 6131 6201 
+ 5807 5808 5840 5893 5896 5945 
+ 5835 5843 5853 5872 5884 5900 
+ 5836 5844 5854 5874 5885 5901 
+ 5829 5839 5857 5879 5894 5909 
+ 5838 5846 5855 5876 5886 5902 
+ 5827 5842 5856 5880 5904 5914 
+ 5609 5647 5848 5889 6180 6225 
+ 5742 5761 5892 5903 5991 
+ 5843 5852 5865 5881 5900 5908 
+ 5833 5845 5861 5887 5906 5919 
+ 5844 5853 5866 5884 5901 5910 
+ 5832 5847 5862 5890 5907 5923 
+ 5846 5854 5868 5885 5902 5911 
+ 5830 5849 5859 5898 5912 5926 
+ 5775 5792 5834 5916 5954 5992 
+ 5839 5850 5867 5899 5909 5925 
+ 5842 5869 5914 5924 
+ 5852 5857 5872 5894 5908 5917 
+ 5813 5837 5858 5915 5918 5940 
+ 5759 5785 5834 5933 5954 6034 
+ 5853 5865 5874 5900 5910 5920 
+ 5854 5866 5876 5901 5911 5921 
+ 5855 5868 5902 5922 
+ 5845 5856 5873 5904 5919 5931 
+ 5707 5734 5810 5933 5934 6064 
+ 5498 5647 5763 5870 6225 6248 
+ 5847 5861 5875 5906 5923 5932 
+ 5745 5816 5825 5895 5976 5984 
+ 5761 5784 5871 5913 5991 6022 
+ 5840 5859 5864 5912 5945 5953 
+ 5857 5867 5881 5909 5917 5930 
+ 5809 5816 5891 5897 5972 5984 
+ 5804 5808 5864 5916 5945 5982 
+ 5780 5809 5860 5895 5949 5972 5996 
+ 5849 5862 5877 5907 5926 5936 
+ 5850 5858 5879 5918 5925 5941 
+ 5865 5872 5884 5908 5920 5927 
+ 5866 5874 5885 5910 5921 5928 
+ 5868 5876 5886 5911 5922 5929 
+ 5742 5803 5871 5969 5991 6068 
+ 5856 5869 5887 5914 5931 5939 
+ 5180 5528 5667 6160 6206 6522 
+ 5861 5873 5890 5919 5932 5943 
+ 5862 5875 5898 5923 5936 5944 
+ 5872 5881 5900 5917 5927 5937 
+ 5867 5879 5894 5925 5930 5942 
+ 5874 5884 5901 5920 5928 5935 
+ 5876 5885 5902 5921 5929 5938 
+ 5859 5877 5893 5926 5953 5960 
+ 5784 5851 5892 6022 6055 
+ 5869 5880 5904 5924 5939 5951 
+ 5837 5860 5882 5940 5949 5973 
+ 5792 5804 5878 5896 5982 5992 6029 
+ 5881 5894 5908 5930 5937 5950 
+ 5858 5882 5899 5940 5941 5965 
+ 5873 5887 5906 5931 5943 5955 
+ 5884 5900 5910 5927 5935 5948 
+ 5885 5901 5911 5928 5938 5946 
+ 5886 5902 5929 5947 
+ 5875 5890 5907 5932 5944 5959 
+ 5880 5914 5951 5961 
+ 5879 5899 5909 5941 5942 5962 
+ 5877 5898 5912 5936 5960 5970 
+ 5900 5908 5920 5937 5948 5958 
+ 5901 5910 5921 5935 5946 5957 
+ 5902 5911 5922 5938 5947 5956 
+ 5894 5909 5917 5942 5950 5963 
+ 5887 5904 5919 5939 5955 5967 
+ 5890 5906 5923 5943 5959 5971 
+ 5785 5810 5883 5888 6034 6064 6135 
+ 5734 5764 5888 5995 6064 6199 
+ 5910 5920 5928 5948 5957 5964 
+ 5898 5907 5926 5944 5970 5975 
+ 5908 5917 5927 5950 5958 5968 
+ 5911 5921 5929 5946 5956 5966 
+ 5904 5914 5931 5951 5967 5981 
+ 5882 5915 5918 5965 5973 6003 
+ 5899 5918 5925 5962 5965 5990 
+ 5909 5925 5930 5962 5963 5980 
+ 5906 5919 5932 5955 5971 5985 
+ 5907 5923 5936 5959 5975 5986 
+ 5864 5893 5896 5953 5982 6012 6027 
+ 5921 5928 5938 5957 5966 5978 
+ 5922 5929 5956 5977 
+ 5920 5927 5935 5958 5964 5979 
+ 5860 5897 5915 5973 5996 6017 
+ 5917 5930 5937 5963 5968 5983 
+ 5914 5924 5939 5961 5981 5993 
+ 5174 5181 5828 6203 6276 6418 
+ 5893 5912 5945 5960 6005 6012 
+ 5834 5878 5883 5992 6034 6090 
+ 5919 5931 5943 5967 5985 5998 
+ 5929 5938 5947 5966 5977 5987 
+ 5928 5935 5946 5964 5978 5988 
+ 5927 5937 5948 5968 5979 5989 
+ 5923 5932 5944 5971 5986 5999 
+ 5912 5926 5953 5970 6005 6006 
+ 5924 5951 5993 6002 
+ 5925 5941 5942 5980 5990 6004 
+ 5930 5942 5950 5980 5983 5994 
+ 5935 5948 5957 5979 5988 5997 
+ 5918 5940 5941 5990 6003 6025 
+ 5938 5946 5956 5978 5987 6000 
+ 5931 5939 5955 5981 5998 6011 
+ 5937 5950 5958 5983 5989 6001 
+ 5803 5841 5903 6020 6068 6175 
+ 5926 5936 5960 5975 6006 6009 
+ 5932 5943 5959 5985 5999 6014 
+ 5895 5897 5984 5996 6036 6098 
+ 5915 5940 5949 6003 6017 6049 
+ 5372 5652 5667 6160 6710 6724 
+ 5936 5944 5970 5986 6009 6015 
+ 5825 5891 5984 6020 6122 6138 
+ 5947 5956 5987 6007 
+ 5946 5957 5966 5988 6000 6008 
+ 5948 5958 5964 5989 5997 6010 
+ 5942 5962 5963 5994 6004 6016 
+ 5939 5951 5967 5993 6011 6024 
+ 5896 5916 5945 6027 6029 6062 
+ 5950 5963 5968 5994 6001 6013 
+ 5891 5895 5972 5976 6098 6122 
+ 5943 5955 5971 5998 6014 6028 
+ 5944 5959 5975 5999 6015 6026 
+ 5956 5966 5977 6000 6007 6019 
+ 5957 5964 5978 5997 6008 6021 
+ 5958 5968 5979 6001 6010 6023 
+ 5941 5962 5965 6004 6025 6035 
+ 5871 5892 5903 6022 6068 6153 
+ 5878 5916 5954 6029 6090 6107 
+ 5951 5961 5981 6002 6024 6033 
+ 5963 5980 5983 6013 6016 6018 
+ 5764 5790 5934 6058 6199 6302 
+ 5897 5949 5972 6017 6036 6070 
+ 5964 5979 5988 6010 6021 6030 
+ 5955 5967 5985 6011 6028 6040 
+ 5959 5971 5986 6014 6026 6041 
+ 5966 5978 5987 6008 6019 6031 
+ 5968 5983 5989 6013 6023 6032 
+ 5961 5993 6033 6048 
+ 5940 5965 5973 6025 6049 6081 
+ 5962 5980 5990 6016 6035 6039 
+ 5953 5960 6006 6012 6046 6050 
+ 5960 5970 6005 6009 6044 6046 
+ 5977 5987 6019 6037 
+ 5978 5988 6000 6021 6031 6038 
+ 5970 5975 6006 6015 6044 6045 
+ 5979 5989 5997 6023 6030 6043 
+ 5967 5981 5998 6024 6040 6053 
+ 5945 5953 6005 6027 6050 6059 
+ 5983 5994 6001 6018 6032 6042 
+ 5971 5985 5999 6028 6041 6057 
+ 5975 5986 6009 6026 6045 6056 
+ 5980 5994 6004 6018 6039 6047 
+ 5949 5973 5996 6049 6070 6092 
+ 5994 6013 6016 6042 6047 
+ 5987 6000 6007 6031 6037 6051 
+ 5825 5841 5969 5976 6138 6175 6234 
+ 5988 5997 6008 6030 6038 6052 
+ 5892 5913 5991 6055 6153 6237 
+ 5989 6001 6010 6032 6043 6054 
+ 5981 5993 6011 6033 6053 6065 
+ 5965 5990 6003 6035 6079 6081 
+ 5986 5999 6015 6041 6056 6067 
+ 5945 5982 6012 6059 6062 6085 
+ 5985 5998 6014 6040 6057 6069 
+ 5916 5982 5992 6062 6107 6119 
+ 5997 6010 6021 6043 6052 6060 
+ 6000 6008 6019 6038 6051 6061 
+ 6001 6013 6023 6042 6054 6063 
+ 5993 6002 6024 6048 6065 6077 
+ 5883 5933 5954 6090 6135 6190 
+ 5990 6004 6025 6039 6079 6087 
+ 5972 5996 6070 6094 6098 
+ 6007 6019 6051 6072 
+ 6008 6021 6031 6052 6061 6073 
+ 6004 6016 6035 6047 6076 6087 
+ 5998 6011 6028 6053 6069 6088 
+ 5999 6014 6026 6057 6067 6089 
+ 6013 6018 6032 6047 6063 6071 
+ 6010 6023 6030 6054 6060 6075 
+ 6006 6009 6045 6046 6074 6078 
+ 6009 6015 6044 6056 6074 6083 
+ 6005 6006 6044 6050 6078 6080 
+ 6016 6018 6039 6042 6071 6076 
+ 6002 6033 6077 6093 
+ 5973 6003 6017 6081 6092 6120 
+ 6005 6012 6046 6059 6080 6082 
+ 6019 6031 6037 6061 6072 6084 
+ 6021 6030 6038 6060 6073 6086 
+ 6011 6024 6040 6065 6088 6099 
+ 6023 6032 6043 6063 6075 6091 
+ 5851 5863 5913 6022 6201 6237 
+ 6015 6026 6045 6067 6083 6100 
+ 6014 6028 6041 6069 6089 6101 
+ 5790 5820 5995 6141 6302 6447 
+ 6012 6027 6050 6082 6085 6109 
+ 6030 6043 6052 6075 6086 6095 
+ 6031 6038 6051 6073 6084 6097 
+ 5982 6027 6029 6085 6119 6123 
+ 6032 6042 6054 6071 6091 6096 
+ 5888 5933 5934 6135 6199 6318 
+ 6024 6033 6053 6077 6099 6111 
+ 4973 5181 6102 6276 6767 6884 
+ 6026 6041 6056 6089 6100 6113 
+ 5903 5969 5991 6153 6175 6269 
+ 6028 6040 6057 6088 6101 6115 
+ 5996 6017 6036 6092 6094 6132 
+ 6042 6047 6063 6076 6096 6103 
+ 6037 6051 6084 6104 
+ 6038 6052 6061 6086 6097 6105 
+ 6044 6045 6078 6083 6106 
+ 6043 6054 6060 6091 6095 6108 
+ 6039 6047 6071 6087 6103 6114 
+ 6033 6048 6065 6093 6111 6121 
+ 6044 6046 6074 6080 6106 6110 
+ 6025 6035 6081 6087 6143 6148 
+ 6046 6050 6078 6082 6110 6112 
+ 6003 6025 6049 6079 6120 6148 6163 
+ 6050 6059 6080 6109 6112 
+ 6045 6056 6074 6100 6106 6124 
+ 6051 6061 6072 6097 6104 6116 
+ 6027 6059 6062 6109 6123 6144 
+ 6052 6060 6073 6095 6105 6117 
+ 6035 6039 6076 6079 6114 6143 
+ 6040 6053 6069 6099 6115 6129 
+ 6041 6057 6067 6101 6113 6130 
+ 5954 5992 6034 6107 6190 6211 
+ 6054 6063 6075 6096 6108 6118 
+ 6017 6049 6070 6120 6132 6155 
+ 6048 6077 6121 6133 
+ 6036 6070 6098 6132 6154 
+ 6060 6075 6086 6108 6117 6125 
+ 6063 6071 6091 6103 6118 6128 
+ 6061 6073 6084 6105 6116 6126 
+ 5972 5984 6036 6094 6122 6154 6220 
+ 6053 6065 6088 6111 6129 6140 
+ 6056 6067 6083 6113 6124 6145 
+ 6057 6069 6089 6115 6130 6146 
+ 4780 4973 6066 6345 6884 7178 
+ 6071 6076 6096 6114 6128 6139 
+ 6072 6084 6116 6134 
+ 6073 6086 6097 6117 6126 6136 
+ 6074 6078 6083 6110 6124 6147 
+ 5992 6029 6090 6119 6207 6211 
+ 6075 6091 6095 6118 6125 6137 
+ 6059 6082 6085 6112 6144 6172 
+ 6078 6080 6106 6112 6147 6165 
+ 6065 6077 6099 6121 6140 6152 
+ 6080 6082 6109 6110 6165 6172 
+ 6067 6089 6100 6130 6145 6161 
+ 6076 6087 6103 6139 6143 6157 
+ 6069 6088 6101 6129 6146 6156 
+ 6084 6097 6104 6126 6134 6149 
+ 6086 6095 6105 6125 6136 6150 
+ 6091 6096 6108 6128 6137 6151 
+ 6029 6062 6107 6123 6186 6207 
+ 6049 6081 6092 6155 6163 6191 
+ 6077 6093 6111 6133 6152 6164 
+ 5976 5984 6098 6138 6220 6246 
+ 6062 6085 6119 6144 6186 
+ 6083 6100 6106 6145 6147 6170 
+ 6095 6108 6117 6137 6150 6159 
+ 6097 6105 6116 6136 6149 6158 
+ 5828 5831 6131 6203 6335 6360 
+ 6096 6103 6118 6139 6151 6162 
+ 6088 6099 6115 6140 6156 6169 
+ 6089 6101 6113 6146 6161 6173 
+ 5831 5863 6127 6201 6335 6350 
+ 6070 6092 6094 6154 6155 6193 
+ 6093 6121 6164 6171 
+ 6104 6116 6149 6166 
+ 5933 6034 6064 6190 6318 6324 
+ 6105 6117 6126 6150 6158 6167 
+ 6108 6118 6125 6151 6159 6168 
+ 5976 6020 6122 6234 6246 6289 
+ 6103 6114 6128 6157 6162 6174 
+ 6099 6111 6129 6152 6169 6178 
+ 5820 5848 6058 6180 6447 6490 
+ 173 252 1438 12330 14856 15094 
+ 6079 6087 6114 6148 6157 6181 6182 
+ 6085 6109 6123 6172 6186 6244 
+ 6100 6113 6124 6161 6170 6188 
+ 6101 6115 6130 6156 6173 6183 
+ 6106 6110 6124 6165 6170 6195 
+ 6079 6081 6143 6163 6181 6196 
+ 6116 6126 6134 6158 6166 6176 
+ 6117 6125 6136 6159 6167 6177 
+ 6118 6128 6137 6162 6168 6179 
+ 6111 6121 6140 6164 6178 6187 
+ 5991 6022 6068 6237 6269 6346 
+ 6094 6098 6132 6193 6220 6255 
+ 6092 6120 6132 6191 6193 6241 
+ 6115 6129 6146 6169 6183 6198 
+ 6114 6139 6143 6174 6182 6192 
+ 6126 6136 6149 6167 6176 6184 
+ 6125 6137 6150 6168 6177 6185 
+ 5667 5905 5974 6522 6724 
+ 6113 6130 6145 6173 6188 6204 
+ 6128 6139 6151 6174 6179 6189 
+ 6081 6120 6148 6191 6196 6219 
+ 6121 6133 6152 6171 6187 6202 
+ 6110 6112 6147 6172 6195 6238 
+ 6134 6149 6176 6194 
+ 6136 6150 6158 6177 6184 6197 
+ 6137 6151 6159 6179 6185 6200 
+ 6129 6140 6156 6178 6198 6212 
+ 6124 6145 6147 6188 6195 6224 
+ 6133 6164 6202 6213 
+ 6109 6112 6144 6165 6238 6244 
+ 6130 6146 6161 6183 6204 6216 
+ 6139 6157 6162 6189 6192 6208 
+ 5969 6020 6068 6234 6269 6353 6400 
+ 6149 6158 6166 6184 6194 6205 
+ 6150 6159 6167 6185 6197 6210 
+ 6140 6152 6169 6187 6212 6221 
+ 6151 6162 6168 6189 6200 6214 
+ 5848 5870 6141 6225 6490 6630 
+ 6143 6148 6182 6196 6215 6223 
+ 6143 6157 6181 6192 6209 6215 
+ 6146 6156 6173 6198 6216 6230 
+ 6158 6167 6176 6197 6205 6217 
+ 6159 6168 6177 6200 6210 6218 
+ 6119 6123 6144 6207 6244 6287 
+ 6152 6164 6178 6202 6221 6233 
+ 6145 6161 6170 6204 6224 6240 
+ 6162 6174 6179 6208 6214 6226 
+ 6034 6090 6135 6211 6324 6328 
+ 6120 6155 6163 6219 6241 6267 
+ 6157 6174 6182 6208 6209 6222 
+ 6132 6154 6155 6241 6255 6281 
+ 6166 6176 6205 6227 
+ 6147 6165 6170 6224 6238 6260 
+ 6148 6163 6181 6219 6223 6232 
+ 6167 6177 6184 6210 6217 6228 
+ 6156 6169 6183 6212 6230 6242 
+ 5934 5995 6064 6302 6318 6435 
+ 6168 6179 6185 6214 6218 6231 
+ 5863 6055 6131 6237 6350 6390 
+ 6164 6171 6187 6213 6233 6245 
+ 5828 5952 6127 6360 6418 6455 
+ 6161 6173 6188 6216 6240 6252 
+ 6176 6184 6194 6217 6227 6235 
+ 5528 5763 5905 6248 6522 7007 7248 
+ 6107 6119 6186 6211 6287 6316 
+ 6174 6189 6192 6222 6226 6236 
+ 6182 6192 6215 6222 6229 
+ 6177 6185 6197 6218 6228 6239 
+ 6090 6107 6190 6207 6316 6328 
+ 6169 6178 6198 6221 6242 6253 
+ 6171 6202 6245 6254 
+ 6179 6189 6200 6226 6231 6247 
+ 6181 6182 6209 6223 6229 6249 
+ 6173 6183 6204 6230 6252 6262 
+ 6184 6197 6205 6228 6235 6250 
+ 6185 6200 6210 6231 6239 6251 
+ 6163 6191 6196 6232 6266 6267 
+ 6098 6122 6154 6246 6255 6311 6322 
+ 6178 6187 6212 6233 6253 6265 
+ 6192 6208 6209 6229 6236 6243 
+ 6181 6196 6215 6232 6249 6256 
+ 6170 6188 6195 6240 6260 6275 
+ 5870 5889 6180 6248 6630 6811 
+ 6189 6208 6214 6236 6247 6257 
+ 6194 6205 6235 6258 
+ 6197 6210 6217 6239 6250 6259 
+ 6209 6215 6222 6243 6249 6261 
+ 6183 6198 6216 6242 6262 6271 
+ 6200 6214 6218 6247 6251 6263 
+ 6196 6219 6223 6256 6266 
+ 6187 6202 6221 6245 6265 6272 
+ 6020 6138 6175 6289 6353 6382 
+ 6205 6217 6227 6250 6258 6268 
+ 6208 6222 6226 6243 6257 6264 
+ 6022 6055 6153 6201 6346 6390 6471 
+ 6165 6172 6195 6244 6260 6317 6319 
+ 6210 6218 6228 6251 6259 6270 
+ 6188 6204 6224 6252 6275 6285 
+ 6155 6191 6193 6267 6281 6300 
+ 6198 6212 6230 6253 6271 6278 
+ 6222 6229 6236 6261 6264 
+ 6144 6172 6186 6238 6287 6319 
+ 6202 6213 6233 6254 6272 6279 
+ 6122 6138 6220 6289 6311 6340 
+ 6214 6226 6231 6257 6263 6273 
+ 5763 5889 6206 6225 6811 7007 
+ 6215 6223 6229 6256 6261 6283 6294 
+ 6217 6228 6235 6259 6268 6274 
+ 6218 6231 6239 6263 6270 6277 
+ 6204 6216 6240 6262 6285 6291 
+ 6212 6221 6242 6265 6278 6292 
+ 6213 6245 6279 6290 
+ 6154 6193 6220 6281 6322 6341 
+ 6223 6232 6249 6266 6293 6294 
+ 6226 6236 6247 6264 6273 6280 
+ 6227 6235 6268 6282 
+ 6228 6239 6250 6270 6274 6286 
+ 6195 6224 6238 6275 6315 6317 
+ 6229 6243 6249 6264 6283 6284 
+ 6216 6230 6252 6271 6291 6297 
+ 6231 6247 6251 6273 6277 6288 
+ 6236 6243 6257 6261 6280 6284 
+ 6221 6233 6253 6272 6292 6298 
+ 6219 6232 6256 6267 6293 6305 
+ 6191 6219 6241 6266 6300 6305 6321 
+ 6235 6250 6258 6274 6282 6295 
+ 6068 6153 6175 6346 6400 6454 
+ 6239 6251 6259 6277 6286 6296 
+ 6230 6242 6262 6278 6297 6306 
+ 6233 6245 6265 6279 6298 6307 
+ 6247 6257 6263 6280 6288 6299 
+ 6250 6259 6268 6286 6295 6301 
+ 6224 6240 6260 6285 6315 6323 
+ 5181 5952 6066 6418 6767 6815 
+ 6251 6263 6270 6288 6296 6303 
+ 6242 6253 6271 6292 6306 6313 
+ 6245 6254 6272 6290 6307 6314 
+ 6257 6264 6273 6284 6299 6304 
+ 6193 6241 6255 6300 6341 6354 
+ 6258 6268 6295 6308 
+ 6249 6261 6284 6294 6309 6326 
+ 6261 6264 6280 6283 6304 6309 
+ 6240 6252 6275 6291 6323 6325 
+ 6259 6270 6274 6296 6301 6310 
+ 6186 6207 6244 6316 6319 6431 6453 
+ 6263 6273 6277 6299 6303 6312 
+ 6138 6234 6246 6340 6382 6411 
+ 6254 6279 6314 6332 
+ 6252 6262 6285 6297 6325 6331 
+ 6253 6265 6278 6298 6313 6333 
+ 6256 6266 6294 6305 6330 
+ 6249 6256 6283 6293 6326 6330 6359 
+ 6268 6274 6282 6301 6308 6320 
+ 6270 6277 6286 6303 6310 6327 
+ 6262 6271 6291 6306 6331 6338 
+ 6265 6272 6292 6307 6333 6339 
+ 6273 6280 6288 6304 6312 6329 
+ 6241 6267 6281 6321 6354 6366 
+ 6274 6286 6295 6310 6320 6334 
+ 5995 6058 6199 6435 6447 6581 
+ 6277 6288 6296 6312 6327 6336 
+ 6280 6284 6299 6309 6329 6337 
+ 6266 6267 6293 6321 6330 6344 
+ 6271 6278 6297 6313 6338 6348 
+ 6272 6279 6298 6314 6339 6349 
+ 6282 6295 6320 6342 
+ 6283 6284 6304 6326 6337 6351 
+ 6286 6296 6301 6327 6334 6343 
+ 6220 6246 6322 6340 6373 6377 
+ 6288 6299 6303 6329 6336 6347 
+ 6278 6292 6306 6333 6348 6357 
+ 6279 6290 6307 6332 6349 6356 
+ 6260 6275 6317 6323 6371 6381 
+ 6207 6211 6287 6328 6453 6464 
+ 6238 6260 6315 6319 6381 6402 
+ 6064 6135 6199 6324 6435 6517 6558 
+ 6238 6244 6287 6317 6402 6431 
+ 6295 6301 6308 6334 6342 6352 
+ 6267 6300 6305 6344 6366 6379 
+ 6220 6255 6311 6341 6373 6389 
+ 6275 6285 6315 6325 6363 6371 
+ 6135 6190 6318 6328 6484 6517 
+ 6285 6291 6323 6331 6361 6363 
+ 6283 6294 6309 6351 6359 6374 
+ 6296 6303 6310 6336 6343 6355 
+ 6190 6211 6316 6324 6464 6484 
+ 6299 6304 6312 6337 6347 6358 
+ 6293 6294 6305 6344 6359 6369 
+ 6291 6297 6325 6338 6361 6365 
+ 6290 6314 6356 6367 
+ 6292 6298 6313 6339 6357 6368 
+ 6301 6310 6320 6343 6352 6362 
+ 6127 6131 6350 6360 6552 6569 
+ 6303 6312 6327 6347 6355 6364 
+ 6304 6309 6329 6351 6358 6370 
+ 6297 6306 6331 6348 6365 6375 
+ 6298 6307 6333 6349 6368 6378 
+ 6246 6289 6311 6377 6411 6436 
+ 6255 6281 6322 6354 6389 6409 
+ 6308 6320 6352 15382 
+ 6310 6327 6334 6355 6362 6372 
+ 6305 6321 6330 6369 6379 
+ 4557 4780 6102 6996 7178 8355 
+ 6153 6237 6269 6454 6471 6540 
+ 6312 6329 6336 6358 6364 6376 
+ 6306 6313 6338 6357 6375 6384 
+ 6307 6314 6339 6356 6378 6385 
+ 6131 6201 6335 6390 6569 6604 
+ 6309 6326 6337 6370 6374 6386 
+ 6320 6334 6342 6362 6380 15382 
+ 6175 6234 6382 6400 6476 6530 
+ 6281 6300 6341 6366 6409 6422 
+ 6327 6336 6343 6364 6372 6383 
+ 6314 6332 6349 6367 6385 6394 
+ 6313 6333 6348 6368 6384 6395 
+ 6329 6337 6347 6370 6376 6387 
+ 6294 6326 6330 6369 6374 6404 6412 
+ 6127 6203 6335 6455 6552 6573 
+ 6325 6331 6363 6365 6393 6396 
+ 6334 6343 6352 6372 6380 6388 
+ 6323 6325 6361 6371 6393 6403 
+ 6336 6347 6355 6376 6383 6392 
+ 6331 6338 6361 6375 6396 6399 
+ 6300 6321 6354 6379 6422 6432 
+ 6332 6356 6394 6405 
+ 6333 6339 6357 6378 6395 6406 
+ 6330 6344 6359 6379 6412 6428 
+ 6337 6351 6358 6386 6387 6401 
+ 6315 6323 6363 6381 6403 6413 
+ 6343 6355 6362 6383 6388 6398 
+ 6311 6322 6377 6389 6419 6426 
+ 6326 6351 6359 6386 6404 6414 
+ 6338 6348 6365 6384 6399 6416 
+ 6347 6358 6364 6387 6392 6407 
+ 6311 6340 6373 6426 6436 
+ 6339 6349 6368 6385 6406 6417 
+ 6321 6344 6366 6369 6428 6432 
+ 6352 6362 6388 6397 6410 15382 
+ 6315 6317 6371 6402 6413 6445 
+ 6234 6289 6353 6411 6476 6512 
+ 6355 6364 6372 6392 6398 6415 
+ 6348 6357 6375 6395 6416 6424 
+ 6349 6356 6378 6394 6417 6427 
+ 6351 6370 6374 6401 6414 6423 
+ 6358 6370 6376 6401 6407 6421 
+ 6362 6372 6380 6398 6410 6420 
+ 6322 6341 6373 6409 6419 6462 
+ 6201 6237 6350 6471 6604 6643 
+ 5611 5652 6507 6710 7436 7933 
+ 6364 6376 6383 6407 6415 6425 
+ 6361 6363 6396 6403 6429 6433 
+ 6356 6367 6385 6405 6427 6440 
+ 6357 6368 6384 6406 6424 6441 
+ 6361 6365 6393 6399 6429 6438 
+ 6380 6410 6430 15382 
+ 6372 6383 6388 6415 6420 6434 
+ 6365 6375 6396 6416 6438 6448 
+ 6175 6269 6353 6454 6530 6563 
+ 6370 6386 6387 6421 6423 6442 
+ 6317 6319 6381 6431 6445 6496 6514 
+ 6363 6371 6393 6413 6433 6437 
+ 6359 6374 6412 6414 6439 6452 
+ 6367 6394 6440 6450 
+ 6368 6378 6395 6417 6441 6451 
+ 6376 6387 6392 6421 6425 6443 
+ 239 4560 5091 7295 14718 14884 
+ 6341 6354 6389 6422 6462 6488 
+ 6380 6388 6397 6420 6430 6444 
+ 6289 6340 6382 6436 6512 6526 
+ 6359 6369 6404 6428 6452 6473 
+ 6371 6381 6403 6437 6445 6468 
+ 6374 6386 6404 6423 6439 6446 
+ 6383 6392 6398 6425 6434 6449 
+ 6375 6384 6399 6424 6448 6460 
+ 6378 6385 6406 6427 6451 6463 
+ 5952 6203 6276 6455 6685 6815 6912 
+ 6373 6389 6426 6462 6499 
+ 6388 6398 6410 6434 6444 6456 
+ 6387 6401 6407 6442 6443 6458 
+ 6354 6366 6409 6432 6488 6519 
+ 6386 6401 6414 6442 6446 6457 
+ 6384 6395 6416 6441 6460 6472 
+ 6392 6407 6415 6443 6449 6461 
+ 6373 6377 6419 6436 6499 6531 
+ 6385 6394 6417 6440 6463 6474 
+ 6369 6379 6412 6432 6473 6504 
+ 6393 6396 6433 6438 6459 6469 
+ 6397 6410 6444 6465 
+ 6287 6319 6402 6453 6514 6532 
+ 6366 6379 6422 6428 6504 6519 
+ 6393 6403 6429 6437 6459 6466 
+ 6398 6415 6420 6449 6456 6470 
+ 6199 6302 6318 6558 6581 6649 
+ 6340 6377 6411 6426 6526 6531 
+ 6403 6413 6433 6466 6468 
+ 6396 6399 6429 6448 6469 6481 
+ 6404 6414 6446 6452 6467 
+ 6394 6405 6427 6450 6474 6483 
+ 6395 6406 6424 6451 6472 6485 
+ 6401 6421 6423 6457 6458 6475 
+ 6407 6421 6425 6458 6461 6478 
+ 6410 6420 6430 6456 6465 6479 
+ 6381 6402 6413 6468 6496 6508 
+ 6414 6423 6439 6457 6467 6477 
+ 6058 6141 6302 6490 6581 6721 6765 
+ 6399 6416 6438 6460 6481 6493 
+ 6415 6425 6434 6461 6470 6482 
+ 6405 6440 6483 6495 
+ 6406 6417 6441 6463 6485 6497 
+ 6404 6412 6439 6467 6473 6487 
+ 6287 6316 6431 6464 6532 6560 6571 
+ 6269 6346 6400 6540 6563 6619 
+ 6203 6360 6418 6573 6685 
+ 6420 6434 6444 6470 6479 6486 
+ 6423 6442 6446 6475 6477 6480 
+ 6421 6442 6443 6475 6478 6489 
+ 6429 6433 6466 6469 6491 
+ 6416 6424 6448 6472 6493 6505 
+ 6425 6443 6449 6478 6482 6492 
+ 6389 6409 6419 6488 6499 6543 
+ 6417 6427 6451 6474 6497 6506 
+ 6316 6328 6453 6484 6571 6608 
+ 6430 6444 6479 6498 
+ 6433 6437 6459 6468 6491 6510 
+ 6439 6446 6452 6477 6487 6500 
+ 6413 6437 6445 6466 6508 6510 
+ 6429 6438 6459 6481 6491 6513 
+ 6434 6449 6456 6482 6486 6502 
+ 6237 6346 6390 6540 6643 6686 
+ 6424 6441 6460 6485 6505 6518 
+ 6412 6428 6452 6487 6504 6523 
+ 6427 6440 6463 6483 6506 6516 
+ 6442 6457 6458 6480 6489 6501 
+ 6353 6382 6512 6530 6590 
+ 6446 6457 6467 6480 6500 6503 
+ 6443 6458 6461 6489 6492 6509 
+ 6444 6456 6465 6486 6498 6511 
+ 6457 6475 6477 6501 6503 
+ 6438 6448 6469 6493 6513 15383 
+ 6449 6461 6470 6492 6502 6515 
+ 6440 6450 6474 6495 6516 6525 
+ 6324 6328 6464 6517 6608 6647 
+ 6441 6451 6472 6497 6518 6527 
+ 6456 6470 6479 6502 6511 6521 
+ 6452 6467 6473 6500 6523 6541 
+ 6409 6422 6462 6519 6543 6570 
+ 6458 6475 6478 6501 6509 6520 
+ 6141 6180 6447 6630 6721 6882 
+ 6459 6466 6469 6510 6513 6536 
+ 6461 6478 6482 6509 6515 6524 
+ 6448 6460 6481 6505 6539 15383 
+ 4995 5317 6507 6562 8232 11299 
+ 6450 6483 6525 6535 
+ 6402 6445 6508 6514 6578 6580 
+ 6451 6463 6485 6506 6527 6538 
+ 6465 6479 6511 6528 
+ 6419 6426 6462 6531 6543 6613 
+ 6467 6477 6487 6503 6533 6541 
+ 6475 6480 6489 6503 6520 6529 
+ 6470 6482 6486 6515 6521 6534 
+ 6477 6480 6500 6501 6529 6533 
+ 6428 6432 6473 6519 6523 6555 6575 
+ 6460 6472 6493 6518 6539 6546 
+ 6463 6474 6497 6516 6538 6545 
+ 5317 5611 6391 6494 7436 8232 
+ 6445 6468 6496 6510 6576 6580 
+ 6478 6489 6492 6520 6524 6537 
+ 6466 6468 6491 6508 6536 6576 
+ 6479 6486 6498 6521 6528 6542 
+ 6382 6411 6476 6526 6590 6622 
+ 6469 6481 6491 6536 6557 15383 
+ 6402 6431 6496 6532 6572 6578 
+ 6482 6492 6502 6524 6534 6544 
+ 6474 6483 6506 6525 6545 6551 
+ 6318 6324 6484 6558 6647 6699 
+ 6472 6485 6505 6527 6546 6556 
+ 6422 6432 6488 6504 6570 6575 6602 
+ 6489 6501 6509 6529 6537 6547 
+ 6486 6502 6511 6534 6542 6548 
+ 5905 6160 6206 6724 7248 7709 
+ 6473 6487 6504 6541 6555 6568 
+ 6492 6509 6515 6537 6544 6550 
+ 6483 6495 6516 6535 6551 6561 
+ 6411 6436 6512 6531 6622 6632 
+ 6485 6497 6518 6538 6556 6565 
+ 6498 6511 6542 6553 
+ 6501 6503 6520 6533 6547 6554 
+ 6353 6400 6476 6563 6590 6660 
+ 6426 6436 6499 6526 6613 6632 
+ 6431 6453 6514 6560 6572 6589 
+ 6500 6503 6529 6541 6554 6566 
+ 6502 6515 6521 6544 6548 6559 
+ 6495 6525 6561 6579 
+ 6491 6510 6513 6557 6576 6594 
+ 6509 6520 6524 6547 6550 6564 
+ 6497 6506 6527 6545 6565 6582 
+ 6493 6505 6546 6574 6585 15383 
+ 6346 6454 6471 6619 6686 6692 
+ 6487 6500 6523 6533 6566 6568 6595 
+ 6511 6521 6528 6548 6553 6567 
+ 6462 6488 6499 6570 6613 6635 
+ 6515 6524 6534 6550 6559 6577 
+ 6506 6516 6538 6551 6582 6587 
+ 6505 6518 6539 6556 6585 6591 
+ 6520 6529 6537 6554 6564 6583 
+ 6521 6534 6542 6559 6567 6584 
+ 2535 5293 5550 8429 11051 14806 
+ 6524 6537 6544 6564 6577 6586 
+ 6516 6525 6545 6561 6587 6596 
+ 6335 6360 6569 6573 6708 6730 
+ 6528 6542 6567 6588 
+ 6529 6533 6547 6566 6583 6593 
+ 6504 6523 6568 6575 6603 
+ 6518 6527 6546 6565 6591 6598 
+ 6513 6536 6574 6594 6606 15383 
+ 6318 6435 6517 6649 6699 6770 
+ 6534 6544 6548 6577 6584 6592 
+ 6453 6532 6571 6589 6644 6667 
+ 6525 6535 6551 6579 6596 6600 
+ 4672 4995 6494 6740 11299 13260 
+ 6400 6454 6530 6619 6660 6738 
+ 6537 6547 6550 6583 6586 6599 
+ 6527 6538 6556 6582 6598 6605 
+ 6533 6541 6554 6593 6595 6610 
+ 6542 6548 6553 6584 6588 6597 
+ 6523 6541 6555 6595 6603 6631 
+ 6335 6350 6552 6604 6730 6776 
+ 6488 6519 6543 6602 6635 6655 
+ 6453 6464 6560 6608 6644 6676 
+ 6514 6532 6578 6589 6620 6651 
+ 6360 6455 6552 6685 6708 6852 
+ 6539 6557 6585 6606 6614 15383 
+ 6504 6519 6555 6602 6603 6627 
+ 6508 6510 6536 6580 6594 6636 6641 
+ 6544 6550 6559 6586 6592 6601 
+ 6496 6514 6572 6580 6620 6638 
+ 6535 6561 6600 6611 
+ 6496 6508 6576 6578 6636 6638 
+ 6302 6435 6447 6649 6750 6765 
+ 6538 6545 6565 6587 6605 6616 
+ 6547 6554 6564 6593 6599 6609 
+ 6548 6559 6567 6592 6597 6607 
+ 6539 6546 6574 6591 6614 6618 
+ 6550 6564 6577 6599 6601 6615 
+ 6545 6551 6582 6596 6616 6621 
+ 6553 6567 6597 6612 
+ 6532 6560 6572 6651 6667 
+ 6476 6512 6530 6622 6660 6743 
+ 6546 6556 6585 6598 6618 6625 
+ 6559 6577 6584 6601 6607 6617 
+ 6554 6566 6583 6609 6610 6624 
+ 6536 6557 6576 6606 6641 6648 
+ 6541 6566 6568 6610 6631 6637 
+ 6551 6561 6587 6600 6621 6628 
+ 6567 6584 6588 6607 6612 6623 
+ 6556 6565 6591 6605 6625 6633 
+ 6564 6583 6586 6609 6615 6626 
+ 6561 6579 6596 6611 6628 6639 
+ 6577 6586 6592 6615 6617 6629 
+ 6519 6570 6575 6627 6655 6665 
+ 6555 6568 6575 6627 6631 6658 
+ 6350 6390 6569 6643 6776 6810 
+ 6565 6582 6598 6616 6633 6645 
+ 6557 6574 6594 6614 6648 6654 
+ 6584 6592 6597 6617 6623 6634 
+ 6464 6484 6571 6647 6676 6751 
+ 6583 6593 6599 6624 6626 6642 
+ 6566 6593 6595 6624 6637 6653 
+ 6579 6600 6639 6652 
+ 6588 6597 6623 6640 
+ 6499 6531 6543 6632 6635 6747 6757 
+ 6574 6585 6606 6618 6654 6659 
+ 6586 6599 6601 6626 6629 6646 
+ 6582 6587 6605 6621 6645 6657 
+ 6592 6601 6607 6629 6634 6650 
+ 6585 6591 6614 6625 6659 6662 
+ 6454 6540 6563 6692 6738 6791 
+ 6572 6578 6638 6651 6687 
+ 6587 6596 6616 6628 6657 6663 
+ 6512 6526 6590 6632 6743 6762 
+ 6597 6607 6612 6634 6640 6656 
+ 6593 6609 6610 6642 6653 6666 
+ 6591 6598 6618 6633 6662 6669 
+ 6599 6609 6615 6642 6646 6661 
+ 6575 6602 6603 6658 6665 6679 
+ 6596 6600 6621 6639 6663 6670 
+ 6601 6615 6617 6646 6650 6664 
+ 6180 6225 6490 6811 6882 7112 
+ 6568 6595 6603 6637 6658 6680 6690 
+ 6526 6531 6613 6622 6747 6762 
+ 6598 6605 6625 6645 6669 6674 
+ 6607 6617 6623 6650 6656 6668 
+ 6543 6570 6613 6655 6745 6757 
+ 6576 6580 6638 6641 6712 6714 
+ 6595 6610 6631 6653 6671 6680 
+ 6578 6580 6620 6636 6687 6714 
+ 6600 6611 6628 6652 6670 6678 
+ 6612 6623 6656 6672 
+ 6576 6594 6636 6648 6701 6712 
+ 6609 6624 6626 6661 6666 6675 
+ 6390 6471 6604 6686 6809 6810 
+ 6560 6571 6667 6676 6764 
+ 6605 6616 6633 6657 6674 6683 
+ 6615 6626 6629 6661 6664 6673 
+ 6484 6517 6608 6699 6751 6830 
+ 6594 6606 6641 6654 6697 6701 
+ 6435 6558 6581 6750 6770 6825 
+ 6617 6629 6634 6664 6668 6677 
+ 6572 6589 6620 6667 6687 6773 
+ 6611 6639 6678 6684 
+ 6610 6624 6637 6666 6671 6681 
+ 6606 6614 6648 6659 6694 6697 
+ 6570 6602 6635 6665 6734 6745 
+ 6623 6634 6640 6668 6672 6682 
+ 6616 6621 6645 6663 6683 6691 
+ 6603 6627 6631 6679 6690 6716 
+ 6614 6618 6654 6662 6694 6696 
+ 6530 6563 6590 6738 6743 6863 
+ 6626 6642 6646 6673 6675 6688 
+ 6618 6625 6659 6669 6696 6703 
+ 6621 6628 6657 6670 6691 6702 
+ 6629 6646 6650 6673 6677 6689 
+ 6602 6627 6655 6679 6729 6734 
+ 6624 6642 6653 6675 6681 6693 
+ 6560 6589 6644 6651 6764 6773 
+ 6634 6650 6656 6677 6682 6695 
+ 6625 6633 6662 6674 6703 6707 
+ 6628 6639 6663 6678 6702 6709 
+ 6637 6653 6680 6681 6698 
+ 6640 6656 6682 6700 
+ 6646 6661 6664 6688 6689 6704 
+ 6633 6645 6669 6683 6707 6715 
+ 6642 6661 6666 6688 6693 6705 
+ 6571 6608 6644 6751 6764 6854 
+ 6650 6664 6668 6689 6695 6706 
+ 6639 6652 6670 6684 6709 6717 
+ 6627 6658 6665 6716 6729 
+ 6631 6637 6671 6690 6698 6723 
+ 6653 6666 6671 6693 6698 6711 
+ 6656 6668 6672 6695 6700 6713 
+ 6645 6657 6674 6691 6715 6722 
+ 6652 6678 6717 6726 
+ 6418 6455 6573 6852 6912 7030 
+ 6471 6540 6643 6692 6809 6845 
+ 6620 6638 6651 6714 6773 6801 
+ 6661 6673 6675 6704 6705 6718 
+ 6664 6673 6677 6704 6706 6720 
+ 6631 6658 6680 6716 6723 6761 
+ 6657 6663 6683 6702 6722 6728 
+ 6540 6619 6686 6791 6845 
+ 6666 6675 6681 6705 6711 6719 
+ 6654 6659 6696 6697 6732 6739 
+ 6668 6677 6682 6706 6713 6725 
+ 6659 6662 6694 6703 6732 6736 
+ 6648 6654 6694 6701 6739 6744 
+ 6671 6680 6681 6711 6723 6735 
+ 6517 6558 6647 6770 6830 6915 
+ 6672 6682 6713 6727 
+ 6641 6648 6697 6712 6744 6756 
+ 6663 6670 6691 6709 6728 6741 
+ 6662 6669 6696 6707 6736 6742 
+ 6673 6688 6689 6718 6720 6731 
+ 6675 6688 6693 6718 6719 6733 
+ 6677 6689 6695 6720 6725 6737 
+ 6669 6674 6703 6715 6742 6753 
+ 6552 6573 6730 6852 6892 
+ 6670 6678 6702 6717 6741 6752 
+ 5652 5974 6391 6724 7933 8666 
+ 6681 6693 6698 6719 6735 6748 
+ 6636 6641 6701 6714 6756 6794 
+ 6682 6695 6700 6725 6727 6746 
+ 6636 6638 6687 6712 6794 6801 6838 
+ 6674 6683 6707 6722 6753 6759 
+ 6658 6679 6690 6729 6761 6784 
+ 6678 6684 6709 6726 6752 6760 
+ 6688 6704 6705 6731 6733 6754 
+ 6693 6705 6711 6733 6748 6749 
+ 6689 6704 6706 6731 6737 6755 
+ 6447 6490 6765 6882 6987 
+ 6683 6691 6715 6728 6759 6768 
+ 6680 6690 6698 6735 6761 6786 
+ 5974 6160 6522 6710 7709 8666 
+ 6695 6706 6713 6737 6746 6758 
+ 6684 6717 6760 6771 
+ 6700 6713 6746 6763 
+ 6691 6702 6722 6741 6768 15384 
+ 6665 6679 6716 6734 6784 6799 
+ 6552 6569 6708 6776 6892 6941 
+ 6704 6718 6720 6754 6755 6769 
+ 6694 6696 6736 6739 6777 6780 
+ 6705 6718 6719 6749 6754 6766 
+ 6655 6665 6729 6745 6799 6821 
+ 6698 6711 6723 6748 6779 6786 
+ 6696 6703 6732 6742 6777 6781 
+ 6706 6720 6725 6755 6758 6772 
+ 6563 6619 6660 6791 6863 6936 
+ 6694 6697 6732 6744 6778 6780 
+ 4560 4672 6562 7295 13260 14209 
+ 6702 6709 6728 6752 6785 15384 
+ 6703 6707 6736 6753 6781 6788 
+ 6590 6622 6660 6762 6863 6972 
+ 6697 6701 6739 6756 6778 6783 
+ 6635 6655 6734 6757 6821 6851 
+ 6713 6725 6727 6758 6763 6775 
+ 6613 6632 6757 6762 6905 6937 
+ 6711 6719 6735 6749 6774 6779 
+ 6719 6733 6748 6766 6774 
+ 6581 6649 6765 6825 15386 
+ 6608 6647 6676 6830 6854 6970 
+ 6709 6717 6741 6760 6785 6790 
+ 6707 6715 6742 6759 6788 6792 
+ 6718 6731 6733 6766 6769 6782 
+ 6720 6731 6737 6769 6772 6787 
+ 6701 6712 6744 6783 6794 6822 
+ 6613 6635 6745 6747 6851 6905 
+ 6725 6737 6746 6772 6775 6789 
+ 6715 6722 6753 6768 6792 6798 
+ 6717 6726 6752 6771 6790 6797 
+ 6690 6716 6723 6784 6786 6829 6833 
+ 6622 6632 6743 6747 6937 6972 
+ 6727 6746 6775 6793 
+ 6644 6667 6676 6773 6854 6895 
+ 6447 6581 6721 6750 6987 15386 
+ 6733 6749 6754 6774 6782 6795 
+ 6066 6276 6815 6884 7528 7730 
+ 6722 6728 6759 6798 6804 15384 
+ 6731 6754 6755 6782 6787 6796 
+ 6558 6649 6699 6825 6915 7006 
+ 6726 6760 6797 6805 
+ 6737 6755 6758 6787 6789 6800 
+ 6651 6667 6687 6764 6801 6895 6928 
+ 6748 6749 6766 6779 6795 6802 
+ 6746 6758 6763 6789 6793 6803 
+ 6569 6604 6730 6810 6941 6998 
+ 6732 6736 6780 6781 6813 6816 
+ 6739 6744 6780 6783 6806 6807 
+ 6735 6748 6774 6786 6802 6826 
+ 6732 6739 6777 6778 6807 6813 
+ 6736 6742 6777 6788 6816 6818 
+ 6754 6766 6769 6795 6796 6808 
+ 6744 6756 6778 6806 6822 
+ 6716 6729 6761 6799 6833 6848 
+ 6741 6752 6790 6812 6819 15384 
+ 6723 6735 6761 6779 6826 6829 
+ 6755 6769 6772 6796 6800 6814 
+ 6742 6753 6781 6792 6818 6824 
+ 6758 6772 6775 6800 6803 6817 
+ 6752 6760 6785 6797 6819 6827 
+ 6619 6692 6738 6845 6936 6961 
+ 6753 6759 6788 6798 6824 6832 
+ 6763 6775 6803 6820 
+ 6712 6714 6756 6822 6838 6862 
+ 6766 6774 6782 6802 6808 6823 
+ 6769 6782 6787 6808 6814 6828 
+ 6760 6771 6790 6805 6827 6835 
+ 6759 6768 6792 6804 6832 6836 
+ 6729 6734 6784 6821 6848 6871 
+ 6772 6787 6789 6814 6817 6831 
+ 6687 6714 6773 6838 6922 6928 
+ 6774 6779 6795 6823 6826 6840 
+ 6775 6789 6793 6817 6820 6834 
+ 6768 6798 6812 6836 6843 15384 
+ 6771 6797 6835 6842 
+ 6778 6783 6807 6822 6837 6853 
+ 6778 6780 6806 6813 6837 6844 
+ 6782 6795 6796 6823 6828 6839 
+ 6643 6686 6810 6845 7008 7078 
+ 6604 6643 6776 6809 6998 7078 
+ 6225 6248 6630 7007 7112 7455 
+ 6785 6804 6819 6843 6850 15384 
+ 6777 6780 6807 6816 6844 6849 
+ 6787 6796 6800 6828 6831 6841 
+ 6276 6418 6767 6912 7437 7528 
+ 6777 6781 6813 6818 6849 6855 
+ 6789 6800 6803 6831 6834 6846 
+ 6781 6788 6816 6824 6855 6860 
+ 6785 6790 6812 6827 6850 6856 
+ 6793 6803 6834 6847 
+ 6734 6745 6799 6851 6871 6908 
+ 6756 6783 6794 6806 6853 6862 6883 
+ 6795 6802 6808 6839 6840 6857 
+ 6788 6792 6818 6832 6860 6864 
+ 6649 6750 6770 7006 15386 
+ 6779 6786 6802 6829 6840 6869 6875 
+ 6790 6797 6819 6835 6856 6865 
+ 6796 6808 6814 6839 6841 6858 
+ 6761 6786 6826 6833 6869 6876 
+ 6647 6699 6751 6915 6970 7130 
+ 6800 6814 6817 6841 6846 6859 
+ 6792 6798 6824 6836 6864 6866 
+ 6761 6784 6829 6848 6876 6889 
+ 6803 6817 6820 6846 6847 6861 
+ 6797 6805 6827 6842 6865 6867 
+ 6798 6804 6832 6843 6866 6874 
+ 6806 6807 6844 6853 6868 
+ 6714 6794 6801 6862 6922 6927 
+ 6808 6823 6828 6857 6858 6872 
+ 6802 6823 6826 6857 6875 6879 
+ 6814 6828 6831 6858 6859 6870 
+ 6805 6835 6867 6878 
+ 6804 6812 6836 6850 6874 6880 
+ 6807 6813 6837 6849 6868 6881 
+ 6686 6692 6791 6809 6961 7008 
+ 6817 6831 6834 6859 6861 6873 
+ 6820 6834 6861 6877 
+ 6784 6799 6833 6871 6889 6913 
+ 6813 6816 6844 6855 6881 6890 
+ 6812 6819 6843 6856 6880 6887 
+ 6745 6757 6821 6905 6908 6967 
+ 6573 6685 6708 6892 7030 7117 
+ 6806 6822 6837 6868 6883 6902 
+ 6676 6751 6764 6895 6970 7058 
+ 6816 6818 6849 6860 6890 6894 
+ 6819 6827 6850 6865 6887 6893 
+ 6823 6839 6840 6872 6879 6891 
+ 6828 6839 6841 6870 6872 6885 
+ 6831 6841 6846 6870 6873 6886 
+ 6818 6824 6855 6864 6894 6896 
+ 6834 6846 6847 6873 6877 6888 
+ 6794 6822 6838 6883 6927 15385 
+ 6660 6738 6743 6936 6972 7151 
+ 6824 6832 6860 6866 6896 6899 
+ 6827 6835 6856 6867 6893 6897 
+ 6832 6836 6864 6874 6899 6904 
+ 6835 6842 6865 6878 6897 6907 
+ 6837 6844 6853 6881 6902 6910 
+ 6826 6829 6875 6876 6911 6916 
+ 6841 6858 6859 6885 6886 6898 
+ 6799 6821 6848 6908 6913 6945 
+ 6839 6857 6858 6885 6891 6901 
+ 6846 6859 6861 6886 6888 6900 
+ 6836 6843 6866 6880 6904 6914 
+ 6826 6840 6869 6879 6909 6911 
+ 6829 6833 6869 6889 6916 6924 
+ 6847 6861 6888 6903 
+ 6842 6867 6907 6919 
+ 6840 6857 6875 6891 6906 6909 
+ 6843 6850 6874 6887 6914 6921 
+ 6844 6849 6868 6890 6910 6925 
+ 6490 6630 6721 6987 7112 7332 
+ 6822 6853 6862 6902 6946 15385 
+ 6066 6102 6767 7178 7730 7911 
+ 6858 6870 6872 6898 6901 6917 
+ 6859 6870 6873 6898 6900 6918 
+ 6850 6856 6880 6893 6921 6926 
+ 6861 6873 6877 6900 6903 6920 
+ 6833 6848 6876 6913 6924 6943 
+ 6849 6855 6881 6894 6925 6934 
+ 6857 6872 6879 6901 6906 6923 
+ 6708 6730 6852 6941 7117 7177 
+ 6856 6865 6887 6897 6926 6930 
+ 6855 6860 6890 6896 6934 6939 
+ 6764 6773 6854 6928 7058 7081 
+ 6860 6864 6894 6899 6939 6942 
+ 6865 6867 6893 6907 6930 6940 
+ 6870 6885 6886 6917 6918 6931 
+ 6864 6866 6896 6904 6942 6944 
+ 6873 6886 6888 6918 6920 6933 
+ 6872 6885 6891 6917 6923 6932 
+ 6853 6868 6883 6910 6946 6947 
+ 6877 6888 6920 6935 
+ 6866 6874 6899 6914 6944 6951 
+ 6747 6757 6851 6937 6967 7071 7105 
+ 6879 6891 6909 6923 6929 
+ 6867 6878 6897 6919 6940 6948 
+ 6821 6851 6871 6945 6967 6986 
+ 6875 6879 6906 6911 6929 6938 
+ 6868 6881 6902 6925 6947 6957 
+ 6869 6875 6909 6916 6938 6954 
+ 6418 6685 6815 7030 7315 7437 
+ 6848 6871 6889 6943 6945 6968 
+ 6874 6880 6904 6921 6951 6955 
+ 6699 6770 6830 7006 7130 7326 
+ 6869 6876 6911 6924 6954 6960 
+ 6885 6898 6901 6931 6932 6949 
+ 6886 6898 6900 6931 6933 6950 
+ 6878 6907 6948 6956 
+ 6888 6900 6903 6933 6935 6952 
+ 6880 6887 6914 6926 6955 6958 
+ 6801 6838 6927 6928 7016 7039 
+ 6891 6901 6906 6929 6932 6953 
+ 6876 6889 6916 6943 6960 6974 
+ 6881 6890 6910 6934 6957 6971 
+ 6887 6893 6921 6930 6958 6966 
+ 6838 6862 6922 7005 7016 15385 
+ 6773 6801 6895 6922 7039 7081 
+ 6906 6909 6923 6938 6953 6959 
+ 6893 6897 6926 6940 6966 6969 
+ 6898 6917 6918 6949 6950 6962 
+ 6901 6917 6923 6949 6953 6964 
+ 6900 6918 6920 6950 6952 6963 
+ 6890 6894 6925 6939 6971 6977 
+ 6903 6920 6952 6965 
+ 6738 6791 6863 6961 7148 7151 
+ 6747 6762 6905 6972 7105 7195 
+ 6909 6911 6929 6954 6959 6990 
+ 6894 6896 6934 6942 6977 6980 
+ 6897 6907 6930 6948 6969 6973 
+ 6730 6776 6892 6998 7177 7243 
+ 6896 6899 6939 6944 6980 6983 
+ 6889 6913 6924 6968 6974 7001 
+ 6899 6904 6942 6951 6983 6984 
+ 6871 6908 6913 6968 6986 7004 
+ 6883 6902 6947 6981 6994 15385 
+ 6902 6910 6946 6957 6981 6993 
+ 6907 6919 6940 6956 6973 6982 
+ 6917 6931 6932 6962 6964 6979 
+ 6918 6931 6933 6962 6963 6975 
+ 6904 6914 6944 6955 6984 6985 
+ 6920 6933 6935 6963 6965 6976 
+ 6923 6929 6932 6959 6964 6978 
+ 6911 6916 6938 6960 6990 6999 
+ 6914 6921 6951 6958 6985 6988 
+ 6919 6948 6982 6989 
+ 6910 6925 6947 6971 6993 7018 
+ 6921 6926 6955 6966 6988 6997 
+ 6929 6938 6953 6978 6990 7009 
+ 6916 6924 6954 6974 6999 7013 
+ 6791 6845 6936 7008 7148 7196 
+ 6931 6949 6950 6975 6979 6995 
+ 6933 6950 6952 6975 6976 6992 
+ 6932 6949 6953 6978 6979 7000 
+ 6935 6952 6976 6991 
+ 6926 6930 6958 6969 6997 7002 
+ 6851 6905 6908 6986 7049 7071 
+ 6913 6943 6945 7001 7004 7035 
+ 6930 6940 6966 6973 7002 7011 
+ 6751 6830 6854 7058 7130 7280 
+ 6925 6934 6957 6977 7018 7026 
+ 6743 6762 6863 6937 7151 7195 7322 
+ 6940 6948 6969 6982 7011 7015 
+ 6924 6943 6960 7001 7013 7031 
+ 6950 6962 6963 6992 6995 7012 
+ 6952 6963 6965 6991 6992 7010 
+ 6934 6939 6971 6980 7026 7028 
+ 6953 6959 6964 7000 7009 7017 
+ 6949 6962 6964 6995 7000 7014 
+ 6939 6942 6977 6983 7028 7029 
+ 6946 6947 6993 6994 7033 
+ 6948 6956 6973 6989 7015 7019 
+ 6942 6944 6980 6984 7023 7029 
+ 6944 6951 6983 6985 7022 7023 
+ 6951 6955 6984 6988 7022 7024 
+ 6908 6945 6967 7004 7047 7049 
+ 6721 6765 6882 7332 7379 15386 
+ 6955 6958 6985 6997 7024 7034 
+ 6956 6982 7019 7032 
+ 6938 6954 6959 6999 7009 7027 7040 
+ 6965 6976 7010 7020 
+ 6963 6975 6976 7010 7012 7021 
+ 6947 6957 6981 7018 7033 7073 
+ 6946 6981 7005 7033 7052 15385 
+ 6962 6975 6979 7012 7014 7025 
+ 4557 5550 6345 8355 8429 13856 14069 
+ 6958 6966 6988 7002 7034 7038 
+ 6776 6810 6941 7078 7243 7316 
+ 6954 6960 6990 7013 7027 7037 
+ 6964 6978 6979 7014 7017 7036 
+ 6943 6968 6974 7031 7035 7062 
+ 6966 6969 6997 7011 7038 7043 
+ 4201 5293 7847 11051 14945 
+ 6945 6968 6986 7035 7047 7074 
+ 6927 6994 7016 7052 7077 15385 
+ 6770 6825 6915 7326 7346 15386 
+ 6206 6248 6811 7248 7455 8151 
+ 6809 6845 6961 7078 7196 7249 
+ 6959 6978 6990 7017 7040 7048 
+ 6976 6991 6992 7020 7021 7041 
+ 6969 6973 7002 7015 7043 7045 
+ 6975 6992 6995 7021 7025 7042 
+ 6960 6974 6999 7031 7037 7046 
+ 6979 6995 7000 7025 7036 7044 
+ 6973 6982 7011 7019 7045 7050 
+ 6922 6927 7005 7039 7077 7096 
+ 6978 7000 7009 7036 7048 7056 
+ 6957 6971 6993 7026 7073 7100 
+ 6982 6989 7015 7032 7050 7057 
+ 6991 7010 7041 7051 
+ 6992 7010 7012 7041 7042 7053 
+ 6984 6985 7023 7024 7060 7064 
+ 6983 6984 7022 7029 7064 7072 
+ 6985 6988 7022 7034 7060 7063 
+ 6995 7012 7014 7042 7044 7055 
+ 6971 6977 7018 7028 7090 7100 
+ 6990 6999 7037 7040 7054 7061 
+ 6977 6980 7026 7029 7080 7090 
+ 6980 6983 7023 7028 7072 7080 
+ 6685 6852 6912 7117 7269 7315 
+ 6974 7001 7013 7046 7062 7085 
+ 6989 7019 7057 7065 
+ 6981 6993 6994 7052 7073 7104 
+ 6988 6997 7024 7038 7063 7070 
+ 6968 7001 7004 7062 7074 7108 
+ 7000 7014 7017 7044 7056 7059 
+ 6999 7013 7027 7046 7061 7075 
+ 6997 7002 7034 7043 7070 7076 
+ 6922 6928 7016 7081 7096 7186 
+ 6990 7009 7027 7048 7054 7066 
+ 7010 7020 7021 7051 7053 7067 
+ 7012 7021 7025 7053 7055 7069 
+ 7002 7011 7038 7045 7076 7082 
+ 7014 7025 7036 7055 7059 7068 
+ 7011 7015 7043 7050 7082 7086 
+ 7013 7031 7037 7075 7085 
+ 6986 7004 7049 7074 7118 
+ 7009 7017 7040 7056 7066 7079 
+ 6967 6986 7047 7071 7118 7155 
+ 7015 7019 7045 7057 7086 7091 
+ 7020 7041 7067 7084 
+ 6994 7005 7033 7077 7104 7128 
+ 7021 7041 7042 7067 7069 7088 
+ 7027 7040 7061 7066 7092 
+ 7025 7042 7044 7068 7069 7089 
+ 7017 7036 7048 7059 7079 7083 
+ 7019 7032 7050 7065 7091 7093 
+ 6854 6895 6970 7081 7280 7285 
+ 7036 7044 7056 7068 7083 7087 
+ 7022 7024 7063 7064 7094 7097 
+ 7027 7037 7054 7075 7092 7113 
+ 7001 7031 7035 7085 7108 7125 
+ 7024 7034 7060 7070 7094 7102 
+ 7022 7023 7060 7072 7097 7107 
+ 7032 7057 7093 7101 
+ 7040 7048 7054 7079 7092 7103 
+ 7041 7051 7053 7084 7088 7095 
+ 7044 7055 7059 7087 7089 7099 
+ 7042 7053 7055 7088 7089 7098 
+ 7034 7038 7063 7076 7102 7106 
+ 6905 6967 7049 7105 7155 7214 
+ 7023 7029 7064 7080 7107 7121 
+ 6993 7018 7033 7100 7104 7154 
+ 7004 7035 7047 7108 7118 7152 
+ 7037 7046 7061 7085 7113 7131 
+ 7038 7043 7070 7082 7106 7110 
+ 7005 7016 7052 7096 7128 7150 
+ 6809 6810 6998 7008 7249 7316 7438 
+ 7048 7056 7066 7083 7103 7111 
+ 7028 7029 7072 7090 7121 7134 
+ 6895 6928 7039 7058 7186 7285 
+ 7043 7045 7076 7086 7110 7116 
+ 7056 7059 7079 7087 7111 7115 
+ 7051 7067 7095 7109 
+ 7031 7046 7062 7075 7125 7131 
+ 7045 7050 7082 7091 7116 7120 
+ 7059 7068 7083 7099 7115 
+ 7053 7067 7069 7095 7098 7114 
+ 7055 7068 7069 7098 7099 7119 
+ 7026 7028 7080 7100 7134 7159 
+ 7050 7057 7086 7093 7120 7122 
+ 7054 7061 7066 7103 7113 7138 
+ 7057 7065 7091 7101 7122 7124 
+ 7060 7063 7097 7102 7126 7127 
+ 7067 7084 7088 7109 7114 7123 
+ 7016 7039 7077 7150 7186 7211 
+ 7060 7064 7094 7107 7126 7132 
+ 7069 7088 7089 7114 7119 7129 
+ 7068 7087 7089 7115 7119 7137 
+ 7018 7026 7073 7090 7154 7159 7198 
+ 7065 7093 7124 7133 
+ 7063 7070 7094 7106 7127 7136 
+ 7066 7079 7092 7111 7138 7143 
+ 7033 7052 7073 7128 7154 7183 
+ 6905 6937 7071 7195 7214 7334 
+ 7070 7076 7102 7110 7136 7140 
+ 7064 7072 7097 7121 7132 7145 
+ 7035 7062 7074 7125 7152 7167 
+ 7084 7095 7123 7135 
+ 7076 7082 7106 7116 7140 7141 
+ 7079 7083 7103 7115 7142 7143 
+ 6630 6811 6882 7332 7455 8166 
+ 7061 7075 7092 7131 7138 7174 
+ 7088 7095 7098 7123 7129 7139 
+ 7083 7087 7099 7111 7137 7142 
+ 7082 7086 7110 7120 7141 7144 
+ 6852 6892 7030 7177 7269 7376 
+ 7047 7049 7074 7152 7155 7199 
+ 7089 7098 7099 7129 7137 7146 
+ 7086 7091 7116 7122 7144 7147 
+ 7072 7080 7107 7134 7145 7161 
+ 7091 7093 7120 7124 7147 7153 
+ 7095 7109 7114 7135 7139 7149 
+ 7093 7101 7122 7133 7153 7157 
+ 7062 7085 7108 7131 7167 7185 
+ 7094 7097 7127 7132 7156 7158 
+ 7094 7102 7126 7136 7158 7166 
+ 7052 7077 7104 7150 7183 7202 
+ 7098 7114 7119 7139 7146 7162 
+ 6830 6915 6970 7280 7326 7608 
+ 7075 7085 7113 7125 7174 7185 7216 
+ 7097 7107 7126 7145 7156 7164 
+ 7101 7124 7157 7163 
+ 7080 7090 7121 7159 7161 7188 
+ 7109 7123 7149 7160 
+ 7102 7106 7127 7140 7166 7168 
+ 7099 7115 7119 7142 7146 7172 7175 
+ 7092 7103 7113 7143 7174 7191 
+ 7114 7123 7129 7149 7162 7165 
+ 7106 7110 7136 7141 7168 7170 
+ 7110 7116 7140 7144 7170 7171 
+ 7111 7115 7137 7143 7172 7181 
+ 7103 7111 7138 7142 7181 7191 
+ 7116 7120 7141 7147 7171 7176 
+ 7107 7121 7132 7161 7164 7169 
+ 7119 7129 7137 7162 7175 7180 
+ 7120 7122 7144 7153 7176 7179 
+ 6936 6961 7151 7196 7380 7395 
+ 7123 7135 7139 7160 7165 7173 
+ 7077 7096 7128 7202 7211 7239 
+ 6863 6936 6972 7148 7322 7395 7557 
+ 7074 7108 7118 7167 7199 7218 
+ 7122 7124 7147 7157 7179 7182 
+ 7073 7100 7104 7183 7198 7226 
+ 7049 7071 7118 7199 7214 7259 
+ 7126 7132 7158 7164 7184 
+ 7124 7133 7153 7163 7182 7190 
+ 7126 7127 7156 7166 7184 7201 
+ 7090 7100 7134 7188 7198 7222 
+ 7135 7149 7173 7187 
+ 7121 7134 7145 7169 7188 7197 
+ 7129 7139 7146 7165 7180 7189 
+ 7133 7157 7190 7192 
+ 7132 7145 7156 7169 7184 7194 
+ 7139 7149 7162 7173 7189 7193 
+ 7127 7136 7158 7168 7201 7224 
+ 7108 7125 7152 7185 7218 7227 
+ 7136 7140 7166 7170 7215 7224 
+ 7145 7161 7164 7194 7197 
+ 7140 7141 7168 7171 7207 7215 
+ 7141 7144 7170 7176 7204 7207 
+ 7137 7142 7175 7181 7208 7219 
+ 7149 7160 7165 7187 7193 7200 
+ 7113 7131 7138 7191 7216 7231 
+ 7137 7146 7172 7180 7203 7208 
+ 7144 7147 7171 7179 7204 7205 
+ 6892 6941 7117 7243 7376 7460 
+ 6102 6345 6884 7911 8355 10635 
+ 7147 7153 7176 7182 7205 7209 
+ 7146 7162 7175 7189 7203 7206 
+ 7142 7143 7172 7191 7219 7233 
+ 7153 7157 7179 7190 7209 7213 
+ 7104 7128 7154 7202 7226 7251 
+ 7156 7158 7164 7194 7201 7232 
+ 7125 7131 7167 7216 7227 7260 
+ 7039 7081 7096 7211 7285 7381 
+ 7160 7173 7200 7210 
+ 7134 7159 7161 7197 7222 7230 
+ 7162 7165 7180 7193 7206 7212 
+ 7157 7163 7182 7192 7213 7217 
+ 7138 7143 7174 7181 7231 7233 7257 
+ 7163 7190 7217 7221 
+ 7165 7173 7189 7200 7212 7220 
+ 7164 7169 7184 7197 7232 7246 
+ 6937 6972 7105 7322 7334 7430 
+ 6961 7008 7148 7249 7380 7451 
+ 7161 7169 7188 7194 7230 7246 
+ 7100 7154 7159 7222 7226 7275 7300 
+ 7118 7152 7155 7218 7259 7267 
+ 7173 7187 7193 7210 7220 7225 
+ 7158 7166 7184 7224 7232 7279 
+ 7128 7150 7183 7239 7251 7276 
+ 7175 7180 7206 7208 7223 7228 
+ 7171 7176 7205 7207 7234 7242 
+ 7176 7179 7204 7209 7234 7235 
+ 7180 7189 7203 7212 7223 7229 
+ 7170 7171 7204 7215 7242 7250 
+ 7172 7175 7203 7219 7228 7240 
+ 7179 7182 7205 7213 7235 7238 
+ 7187 7200 7225 7236 
+ 7096 7150 7186 7239 7349 7381 
+ 7189 7193 7206 7220 7229 7237 
+ 7182 7190 7209 7217 7238 7241 
+ 7071 7105 7155 7259 7334 7357 
+ 7168 7170 7207 7224 7250 7286 
+ 7131 7174 7185 7231 7260 7287 
+ 7190 7192 7213 7221 7241 7245 
+ 7152 7167 7199 7227 7267 7281 
+ 7172 7181 7208 7233 7240 7253 
+ 7193 7200 7212 7225 7237 7247 
+ 7192 7217 7245 7252 
+ 7159 7188 7198 7230 7275 7278 
+ 7203 7206 7228 7229 7244 
+ 7166 7168 7201 7215 7279 7286 
+ 7200 7210 7220 7236 7247 7254 
+ 7154 7183 7198 7251 7300 7324 
+ 7167 7185 7218 7260 7281 7323 
+ 7203 7208 7223 7240 7244 7255 
+ 7206 7212 7223 7237 7244 7256 
+ 7188 7197 7222 7246 7278 7304 
+ 7174 7191 7216 7257 7287 7297 
+ 7184 7194 7201 7246 7279 7311 
+ 7181 7191 7219 7253 7257 7271 
+ 7204 7205 7235 7242 7258 7265 
+ 7205 7209 7234 7238 7258 7262 
+ 7210 7225 7254 7261 
+ 7212 7220 7229 7247 7256 7263 
+ 7209 7213 7235 7241 7262 7264 
+ 7150 7202 7211 7276 7349 
+ 7208 7219 7228 7253 7255 7268 
+ 7213 7217 7238 7245 7264 7266 
+ 7204 7207 7234 7250 7265 7273 
+ 6941 6998 7177 7316 7460 7551 
+ 7223 7228 7229 7255 7256 7270 
+ 7217 7221 7241 7252 7266 7272 
+ 7194 7197 7230 7232 7304 7311 
+ 7220 7225 7237 7254 7263 7274 
+ 6206 6522 7007 7709 8151 10752 
+ 7008 7078 7196 7438 7451 7571 
+ 7207 7215 7242 7273 7286 7299 
+ 7183 7202 7226 7276 7324 7328 
+ 7221 7245 7272 7277 
+ 7219 7233 7240 7268 7271 7290 
+ 7225 7236 7247 7261 7274 7282 
+ 7228 7240 7244 7268 7270 7293 
+ 7229 7237 7244 7263 7270 7283 
+ 7191 7231 7233 7271 7297 7302 
+ 7234 7235 7262 7265 7284 7288 
+ 7155 7199 7214 7267 7329 7357 
+ 7185 7216 7227 7287 7323 7351 
+ 7236 7254 7282 7292 
+ 7235 7238 7258 7264 7288 7291 
+ 7237 7247 7256 7274 7283 7296 
+ 7238 7241 7262 7266 7291 7294 
+ 7234 7242 7258 7273 7284 7289 
+ 7241 7245 7264 7272 7294 7298 
+ 7199 7218 7259 7281 7329 7340 
+ 7240 7253 7255 7290 7293 7314 
+ 7030 7117 7315 7376 7609 
+ 7244 7255 7256 7283 7293 7307 
+ 7233 7253 7257 7290 7302 7310 
+ 7245 7252 7266 7277 7298 7306 
+ 7242 7250 7265 7289 7299 7308 
+ 7247 7254 7263 7282 7296 7305 
+ 7198 7222 7278 7300 7345 
+ 7202 7239 7251 7328 7349 7368 
+ 7252 7272 7306 7312 
+ 7222 7230 7275 7304 7345 7371 
+ 7201 7224 7232 7286 7311 7352 7359 
+ 6970 7058 7130 7285 7592 7608 
+ 7218 7227 7267 7323 7340 7383 
+ 7254 7261 7274 7292 7305 7313 
+ 7256 7263 7270 7296 7307 7317 
+ 7258 7265 7288 7289 7301 7303 
+ 7058 7081 7186 7280 7381 7549 7592 
+ 7215 7224 7250 7279 7299 7339 7352 
+ 7216 7231 7260 7297 7348 7351 
+ 7258 7262 7284 7291 7301 7309 
+ 7265 7273 7284 7303 7308 
+ 7253 7268 7271 7310 7314 7337 
+ 7262 7264 7288 7294 7309 7318 
+ 7261 7282 7313 7319 
+ 7255 7268 7270 7307 7314 7331 
+ 7264 7266 7291 7298 7318 7321 
+ 4560 6408 6740 14209 14884 
+ 7263 7274 7283 7305 7317 7325 
+ 7231 7257 7287 7302 7348 7353 
+ 7266 7272 7294 7306 7321 7327 
+ 7250 7273 7286 7308 7338 7339 
+ 7198 7226 7275 7324 7345 7407 
+ 7284 7288 7303 7309 7320 
+ 7257 7271 7297 7310 7353 7361 
+ 7284 7289 7301 7308 7320 7330 
+ 7230 7246 7278 7311 7371 7384 
+ 7274 7282 7296 7313 7325 7335 
+ 7272 7277 7298 7312 7327 7336 
+ 7270 7283 7293 7317 7331 7341 
+ 7273 7289 7299 7303 7330 7338 
+ 7288 7291 7301 7318 7320 7333 
+ 7271 7290 7302 7337 7361 
+ 7232 7246 7279 7304 7359 7384 
+ 7277 7306 7336 7343 
+ 7282 7292 7305 7319 7335 7342 
+ 7268 7290 7293 7331 7337 7360 
+ 6912 7030 7269 7437 7609 8118 
+ 6998 7078 7243 7438 7551 7660 
+ 7283 7296 7307 7325 7341 7350 
+ 7291 7294 7309 7321 7333 7344 
+ 7292 7313 7342 7347 
+ 7301 7303 7309 7330 7333 7354 
+ 7294 7298 7318 7327 7344 7355 
+ 6972 7151 7195 7430 7557 7645 7669 
+ 7227 7260 7281 7351 7383 7414 
+ 7226 7251 7300 7328 7407 7408 
+ 7296 7305 7317 7335 7350 7356 
+ 6915 7006 7130 7346 7608 8108 
+ 7298 7306 7321 7336 7355 7358 
+ 7251 7276 7324 7368 7408 
+ 7259 7267 7340 7357 7404 7415 
+ 7303 7308 7320 7338 7354 7374 
+ 7293 7307 7314 7341 7360 7365 
+ 6882 6987 7112 7379 8166 10539 
+ 7309 7318 7320 7344 7354 7363 
+ 7105 7195 7214 7357 7430 7505 7523 
+ 7305 7313 7325 7342 7356 7362 
+ 7306 7312 7327 7343 7358 7364 
+ 7290 7310 7314 7360 7361 7390 
+ 7299 7308 7330 7339 7374 7378 
+ 7286 7299 7338 7352 7378 7388 
+ 7267 7281 7329 7383 7404 
+ 7307 7317 7331 7350 7365 7369 
+ 7313 7319 7335 7347 7362 7366 
+ 7312 7336 7364 7367 
+ 7318 7321 7333 7355 7363 7370 
+ 7275 7278 7300 7371 7407 7449 
+ 7006 7326 7379 8108 8722 15386 
+ 7319 7342 7366 7372 
+ 7287 7297 7351 7353 7389 7402 
+ 7211 7239 7276 7368 7381 7425 
+ 7317 7325 7341 7356 7369 7373 
+ 7260 7287 7323 7348 7402 7414 
+ 7279 7286 7339 7359 7388 7400 
+ 7297 7302 7348 7361 7389 7397 
+ 7320 7330 7333 7363 7374 7385 
+ 7321 7327 7344 7358 7370 7375 
+ 7325 7335 7350 7362 7373 7377 
+ 7214 7259 7329 7334 7415 7505 
+ 7327 7336 7355 7364 7375 7382 
+ 7279 7311 7352 7384 7400 7434 
+ 7314 7331 7337 7365 7390 7394 
+ 7302 7310 7337 7353 7390 7397 7412 
+ 7335 7342 7356 7366 7377 7386 
+ 7333 7344 7354 7370 7385 7393 
+ 7336 7343 7358 7367 7382 7387 
+ 7331 7341 7360 7369 7392 7394 
+ 7342 7347 7362 7372 7386 7391 
+ 7343 7364 7387 7396 
+ 7276 7328 7349 7408 7425 7487 
+ 7341 7350 7365 7373 7392 7399 
+ 7344 7355 7363 7375 7393 7401 
+ 7278 7304 7345 7384 7449 7486 
+ 7347 7366 7391 7398 
+ 7350 7356 7369 7377 7399 7403 
+ 7330 7338 7354 7378 7385 7417 7423 
+ 7355 7358 7370 7382 7401 7406 
+ 7117 7177 7269 7460 7609 7753 
+ 7356 7362 7373 7386 7403 7405 
+ 7338 7339 7374 7388 7423 7428 
+ 6987 7332 7346 8722 10539 15386 
+ 7148 7196 7395 7451 7591 7639 
+ 7186 7211 7285 7349 7425 7514 7549 
+ 7358 7364 7375 7387 7406 7409 
+ 7281 7323 7340 7404 7414 7506 
+ 7304 7311 7359 7371 7434 7486 
+ 7354 7363 7374 7393 7417 7421 
+ 7362 7366 7377 7391 7405 7410 
+ 7364 7367 7382 7396 7409 7411 
+ 7339 7352 7378 7400 7428 7444 
+ 7348 7353 7397 7402 7427 7433 
+ 7337 7360 7361 7394 7412 7431 7447 
+ 7366 7372 7386 7398 7410 7413 
+ 7365 7369 7394 7399 7416 7418 
+ 7363 7370 7385 7401 7421 7424 
+ 7360 7365 7390 7392 7418 7431 
+ 7148 7151 7380 7557 7591 7670 
+ 7367 7387 7411 7419 
+ 7353 7361 7389 7412 7427 7441 
+ 7372 7391 7413 7420 
+ 7369 7373 7392 7403 7416 7422 
+ 7352 7359 7388 7434 7444 7468 
+ 7370 7375 7393 7406 7424 7429 
+ 7348 7351 7389 7414 7433 7473 
+ 7373 7377 7399 7405 7422 7426 
+ 7329 7340 7383 7415 7506 7525 
+ 7377 7386 7403 7410 7426 7432 
+ 7375 7382 7401 7409 7429 7435 
+ 7300 7324 7345 7408 7449 7545 7603 
+ 7324 7328 7368 7407 7487 7545 
+ 7382 7387 7406 7411 7435 7440 
+ 7386 7391 7405 7413 7432 7439 
+ 7387 7396 7409 7419 7440 7443 
+ 7361 7390 7397 7441 7447 7463 
+ 7391 7398 7410 7420 7439 7442 
+ 7323 7351 7383 7402 7473 7506 7563 
+ 7329 7357 7404 7505 7525 7579 
+ 7392 7399 7418 7422 7445 7446 
+ 7374 7385 7421 7423 7453 7459 
+ 7392 7394 7416 7431 7445 7456 
+ 7396 7411 7443 7450 
+ 7398 7413 7442 7448 
+ 7385 7393 7417 7424 7453 7454 
+ 7399 7403 7416 7426 7446 7452 
+ 7374 7378 7417 7428 7459 7476 
+ 7393 7401 7421 7429 7454 7458 
+ 7349 7368 7381 7487 7514 7570 
+ 7403 7405 7422 7432 7452 7457 
+ 7389 7397 7433 7441 7464 7469 
+ 7378 7388 7423 7444 7476 7500 
+ 7401 7406 7424 7435 7458 7462 
+ 7195 7322 7334 7523 7640 7645 
+ 7390 7394 7418 7447 7456 7466 
+ 7405 7410 7426 7439 7457 7461 
+ 7389 7402 7427 7464 7473 
+ 7359 7384 7400 7468 7486 7550 
+ 7406 7409 7429 7440 7462 7465 
+ 6391 6507 7933 8232 13750 
+ 6815 6912 7315 7528 8118 8472 
+ 7078 7249 7316 7571 7660 7808 
+ 7410 7413 7432 7442 7461 7467 
+ 7409 7411 7435 7443 7465 7470 
+ 7397 7412 7427 7463 7469 7485 
+ 7413 7420 7439 7448 7467 7471 
+ 7411 7419 7440 7450 7470 7474 
+ 7388 7400 7428 7468 7500 7521 
+ 7416 7418 7446 7456 7472 7477 
+ 7416 7422 7445 7452 7472 7475 
+ 7390 7412 7431 7463 7466 7495 7498 
+ 7420 7442 7471 7479 
+ 7345 7371 7407 7486 7603 7607 
+ 7419 7443 7474 7483 
+ 7196 7249 7380 7571 7639 7703 
+ 7422 7426 7446 7457 7475 7482 
+ 7417 7421 7454 7459 7480 7481 
+ 7421 7424 7453 7458 7481 7484 
+ 6811 7007 7112 8151 8166 10767 
+ 7418 7431 7445 7466 7477 7478 
+ 7426 7432 7452 7461 7482 7488 
+ 7424 7429 7454 7462 7484 7489 
+ 7417 7423 7453 7476 7480 7508 
+ 7177 7243 7376 7551 7753 7852 
+ 7432 7439 7457 7467 7488 7490 
+ 7429 7435 7458 7465 7489 7491 
+ 7412 7441 7447 7485 7495 7509 
+ 7427 7433 7469 7473 7493 7517 
+ 7435 7440 7462 7470 7491 7496 
+ 7431 7447 7456 7478 7494 7498 
+ 7439 7442 7461 7471 7490 7497 
+ 7400 7434 7444 7521 7550 
+ 7427 7441 7464 7485 7493 7507 
+ 7440 7443 7465 7474 7496 7501 
+ 7442 7448 7467 7479 7497 7502 
+ 7445 7446 7475 7477 7499 7503 
+ 7402 7414 7433 7464 7517 7563 7583 
+ 7443 7450 7470 7483 7501 7512 
+ 7446 7452 7472 7482 7503 7510 
+ 7423 7428 7459 7500 7508 7526 
+ 7445 7456 7472 7478 7492 7499 
+ 7456 7466 7477 7492 7494 
+ 7448 7471 7502 7511 
+ 7453 7459 7481 7504 7508 
+ 7453 7454 7480 7484 7504 7513 
+ 7452 7457 7475 7488 7510 7515 
+ 7450 7474 7512 7519 
+ 7454 7458 7481 7489 7513 7516 
+ 7441 7463 7469 7507 7509 7534 
+ 7371 7384 7434 7449 7550 7607 7634 
+ 7368 7408 7425 7545 7570 7679 
+ 7457 7461 7482 7490 7515 7522 
+ 7458 7462 7484 7491 7516 7524 
+ 7461 7467 7488 7497 7522 7527 
+ 7462 7465 7489 7496 7524 7529 
+ 7477 7478 7494 7499 7518 7520 
+ 7464 7469 7507 7517 7560 
+ 7466 7478 7492 7498 7518 7530 
+ 7447 7463 7498 7509 7536 7540 
+ 7465 7470 7491 7501 7529 7533 
+ 7467 7471 7490 7502 7527 7532 
+ 7447 7466 7494 7495 7530 7536 
+ 7472 7477 7492 7503 7520 7531 
+ 7428 7444 7476 7521 7526 7562 7573 
+ 7470 7474 7496 7512 7533 7538 
+ 7471 7479 7497 7511 7532 7535 
+ 7472 7475 7499 7510 7531 7539 
+ 7480 7481 7508 7513 7541 7544 
+ 7334 7357 7415 7523 7579 7672 7696 
+ 7383 7404 7414 7525 7563 7654 7684 
+ 7469 7485 7493 7534 7560 
+ 7459 7476 7480 7504 7526 7542 7544 
+ 7463 7485 7495 7534 7540 7574 
+ 7475 7482 7503 7515 7539 7547 
+ 7479 7502 7535 7543 
+ 7474 7483 7501 7519 7538 7546 
+ 7481 7484 7504 7516 7541 7548 
+ 7381 7425 7549 7570 7729 
+ 7482 7488 7510 7522 7547 7553 
+ 7484 7489 7513 7524 7548 7554 
+ 7464 7473 7493 7560 7583 7596 
+ 7492 7494 7520 7530 7537 
+ 7483 7512 7546 7555 
+ 7492 7499 7518 7531 7537 7552 
+ 7444 7468 7500 7550 7573 7616 
+ 7488 7490 7515 7527 7553 7556 
+ 7334 7430 7505 7640 7672 7713 
+ 7489 7491 7516 7529 7554 7558 
+ 7404 7415 7506 7579 7681 7684 
+ 7476 7500 7508 7542 7562 7565 
+ 7490 7497 7522 7532 7556 7559 
+ 6767 6815 7437 7730 8472 8881 
+ 7491 7496 7524 7533 7558 7561 
+ 7494 7498 7518 7536 7537 7566 7576 
+ 7499 7503 7520 7539 7552 7567 
+ 7497 7502 7527 7535 7559 7564 
+ 7496 7501 7529 7538 7561 7569 
+ 7485 7507 7509 7560 7574 7621 
+ 7502 7511 7532 7543 7564 7572 
+ 7495 7498 7530 7540 7576 7580 
+ 7518 7520 7530 7552 7566 
+ 7501 7512 7533 7546 7569 7575 
+ 7503 7510 7531 7547 7567 7581 
+ 7495 7509 7536 7574 7580 
+ 7504 7513 7544 7548 7578 7584 
+ 7508 7526 7544 7565 7568 
+ 7511 7535 7572 7577 
+ 7504 7508 7541 7542 7568 7578 
+ 7407 7408 7487 7603 7679 7772 
+ 7512 7519 7538 7555 7575 7582 
+ 7510 7515 7539 7553 7581 7585 
+ 7513 7516 7541 7554 7584 7586 
+ 7285 7381 7514 7592 7729 7963 
+ 7434 7468 7486 7521 7616 7634 7674 
+ 7243 7316 7460 7660 7852 7966 
+ 7520 7531 7537 7566 7567 7595 
+ 7515 7522 7547 7556 7585 7587 
+ 7516 7524 7548 7558 7586 7589 
+ 7519 7546 7582 7588 
+ 7522 7527 7553 7559 7587 7590 
+ 7151 7322 7395 7669 7670 7884 
+ 7524 7529 7554 7561 7589 7594 
+ 7527 7532 7556 7564 7590 7593 
+ 7493 7507 7517 7534 7596 7621 7628 
+ 7529 7533 7558 7569 7594 7598 
+ 7500 7526 7565 7573 7602 7612 
+ 7414 7473 7506 7583 7638 7654 
+ 7532 7535 7559 7572 7593 7597 
+ 7526 7542 7562 7568 7600 7602 
+ 7530 7537 7552 7576 7595 7614 
+ 7531 7539 7552 7581 7595 7606 
+ 7542 7544 7565 7578 7600 7610 
+ 7533 7538 7561 7575 7598 7601 
+ 7425 7487 7514 7679 7729 7794 
+ 7249 7438 7451 7703 7808 7832 
+ 7535 7543 7564 7577 7597 7599 
+ 7500 7521 7562 7612 7616 7644 
+ 7509 7534 7540 7580 7621 7631 
+ 7538 7546 7569 7582 7601 7605 
+ 7530 7536 7566 7580 7614 7629 
+ 7543 7572 7599 7604 
+ 7541 7544 7568 7584 7610 7613 
+ 7415 7505 7525 7681 7696 
+ 7536 7540 7574 7576 7629 7631 
+ 7539 7547 7567 7585 7606 7615 
+ 7546 7555 7575 7588 7605 7611 
+ 7473 7517 7563 7596 7630 7638 
+ 7541 7548 7578 7586 7613 7617 
+ 7547 7553 7581 7587 7615 7623 
+ 7548 7554 7584 7589 7617 7620 
+ 7553 7556 7585 7590 7619 7623 
+ 7555 7582 7611 7618 
+ 7554 7558 7586 7594 7620 7625 
+ 7556 7559 7587 7593 7619 7622 
+ 7380 7395 7639 7670 7873 7874 
+ 7280 7285 7549 7608 7963 8358 
+ 7559 7564 7590 7597 7622 7624 
+ 7558 7561 7589 7598 7625 7627 
+ 7552 7566 7567 7606 7614 7652 
+ 7517 7560 7583 7628 7630 7661 
+ 7564 7572 7593 7599 7624 7626 
+ 7561 7569 7594 7601 7627 7633 
+ 7572 7577 7597 7604 7626 7632 
+ 7565 7568 7602 7610 7637 7646 
+ 7569 7575 7598 7605 7633 7635 
+ 7562 7565 7600 7612 7637 7642 
+ 7407 7449 7545 7607 7772 7778 
+ 7577 7599 7632 7636 
+ 7575 7582 7601 7611 7635 7641 
+ 7567 7581 7595 7615 7652 7655 
+ 7449 7486 7603 7634 7771 7778 
+ 7130 7280 7326 7592 8108 8358 9530 
+ 7269 7315 7376 7753 8118 8739 
+ 7568 7578 7600 7613 7646 7665 
+ 7582 7588 7605 7618 7641 7643 
+ 7562 7573 7602 7642 7644 7667 
+ 7578 7584 7610 7617 7657 7665 
+ 7566 7576 7595 7629 7652 7685 
+ 7581 7585 7606 7623 7655 7662 
+ 7521 7550 7573 7644 7674 7683 
+ 7584 7586 7613 7620 7651 7657 
+ 7588 7611 7643 7650 
+ 7587 7590 7622 7623 7647 7656 
+ 7586 7589 7617 7625 7651 7653 
+ 7534 7560 7574 7628 7631 7694 7724 
+ 7590 7593 7619 7624 7647 7648 
+ 7585 7587 7615 7619 7656 7662 
+ 7593 7597 7622 7626 7648 7649 
+ 7589 7594 7620 7627 7653 7659 
+ 7597 7599 7624 7632 7649 7658 
+ 7594 7598 7625 7633 7659 7663 
+ 7560 7596 7621 7661 7694 
+ 7576 7580 7614 7631 7685 7706 
+ 7583 7596 7638 7661 7690 
+ 7574 7580 7621 7629 7706 7724 
+ 7599 7604 7626 7636 7658 7664 
+ 7598 7601 7627 7635 7663 7668 
+ 7486 7550 7607 7674 7761 7771 
+ 7601 7605 7633 7641 7668 7673 
+ 7604 7632 7664 7671 
+ 7600 7602 7642 7646 7698 
+ 7563 7583 7630 7654 7690 7718 
+ 7380 7451 7591 7703 7874 7905 
+ 7430 7523 7645 7713 7814 7858 
+ 7605 7611 7635 7643 7673 7675 
+ 7602 7612 7637 7667 7698 
+ 7611 7618 7641 7650 7675 7677 
+ 7573 7612 7616 7667 7683 7710 
+ 7322 7430 7640 7669 7858 7872 
+ 7600 7610 7637 7665 7698 7715 
+ 7619 7622 7648 7656 7676 7682 
+ 7622 7624 7647 7649 7676 7678 
+ 7624 7626 7648 7658 7678 7680 
+ 7618 7643 7677 7687 
+ 7617 7620 7653 7657 7686 7692 
+ 7595 7606 7614 7655 7685 7727 7745 
+ 7620 7625 7651 7659 7686 7689 
+ 7506 7563 7638 7684 7718 7754 
+ 7606 7615 7652 7662 7712 7727 
+ 7619 7623 7647 7662 7682 7699 
+ 7613 7617 7651 7665 7692 7695 
+ 7626 7632 7649 7664 7680 7688 
+ 7625 7627 7653 7663 7689 7691 
+ 7316 7438 7551 7808 7966 8100 
+ 7596 7628 7630 7690 7694 7736 
+ 7615 7623 7655 7656 7699 7712 
+ 7627 7633 7659 7668 7691 7697 
+ 7632 7636 7658 7671 7688 7693 
+ 7610 7613 7646 7657 7695 7715 
+ 200 410 5408 13608 15133 15144 
+ 7612 7642 7644 7698 7710 7747 
+ 7633 7635 7663 7673 7697 7701 
+ 7322 7557 7645 7872 7884 7984 
+ 7395 7557 7591 7873 7884 7995 
+ 7636 7664 7693 7700 
+ 7505 7523 7696 7713 7807 7819 
+ 7635 7641 7668 7675 7701 7704 
+ 7550 7616 7634 7683 7738 7761 
+ 7641 7643 7673 7677 7704 7708 
+ 7647 7648 7678 7682 7702 7705 
+ 7643 7650 7675 7687 7708 7714 
+ 7648 7649 7676 7680 7705 7707 
+ 7487 7545 7570 7772 7794 7937 
+ 7649 7658 7678 7688 7707 7711 
+ 7525 7579 7684 7696 7844 7866 
+ 7647 7656 7676 7699 7702 7717 
+ 7616 7644 7674 7710 7738 7756 
+ 7506 7525 7654 7681 7754 7844 7867 
+ 7614 7629 7652 7706 7745 7770 
+ 7651 7653 7689 7692 7720 7722 
+ 7650 7677 7714 7721 
+ 7658 7664 7680 7693 7711 7716 
+ 7653 7659 7686 7691 7720 7725 
+ 7630 7638 7661 7718 7736 7767 
+ 7659 7663 7689 7697 7725 7728 
+ 7651 7657 7686 7695 7719 7722 
+ 7664 7671 7688 7700 7716 7726 
+ 7621 7628 7661 7724 7736 7777 
+ 7657 7665 7692 7715 7719 7741 
+ 7505 7579 7672 7681 7819 7866 
+ 7663 7668 7691 7701 7728 7732 
+ 7637 7642 7646 7667 7715 7747 7764 
+ 7656 7662 7682 7712 7717 7749 
+ 7671 7693 7726 7733 
+ 7668 7673 7697 7704 7732 7734 
+ 7676 7682 7705 7717 7723 
+ 7451 7571 7639 7832 7905 7934 
+ 7673 7675 7701 7708 7734 7737 
+ 7676 7678 7702 7707 7723 7731 
+ 7629 7631 7685 7724 7770 7800 
+ 7678 7680 7705 7711 7731 7735 
+ 7675 7677 7704 7714 7737 7740 
+ 6522 6724 7248 8666 10752 12141 
+ 7644 7667 7683 7747 7756 7804 
+ 7680 7688 7707 7716 7735 7739 
+ 7655 7662 7699 7727 7749 7765 
+ 7523 7640 7672 7807 7814 7891 
+ 7677 7687 7708 7721 7740 7743 
+ 7646 7665 7695 7698 7741 7764 7779 
+ 7688 7693 7711 7726 7739 7744 
+ 7682 7699 7702 7723 7742 7749 
+ 7638 7654 7690 7754 7767 7799 
+ 7692 7695 7722 7741 7746 
+ 7686 7689 7722 7725 7751 7755 
+ 7687 7714 7743 7750 
+ 7686 7692 7719 7720 7746 7751 
+ 7702 7705 7717 7731 7742 7748 
+ 7621 7631 7694 7706 7777 7800 7841 
+ 7689 7691 7720 7728 7755 7758 
+ 7693 7700 7716 7733 7744 7752 
+ 7652 7655 7712 7745 7765 7785 
+ 7691 7697 7725 7732 7758 7759 
+ 7514 7549 7570 7794 7963 8177 
+ 6767 6884 7528 7911 8881 10857 11227 
+ 7705 7707 7723 7735 7748 7757 
+ 7697 7701 7728 7734 7759 7762 
+ 7700 7726 7752 7760 
+ 7701 7704 7732 7737 7762 7766 
+ 7707 7711 7731 7739 7757 7763 
+ 7661 7690 7694 7767 7777 7805 
+ 7704 7708 7734 7740 7766 7769 
+ 7674 7683 7756 7761 7834 7835 
+ 7711 7716 7735 7744 7763 7768 
+ 7708 7714 7737 7743 7769 7774 
+ 7695 7715 7719 7746 7779 7784 
+ 7717 7723 7748 7749 7773 7780 
+ 7714 7721 7740 7750 7774 7776 
+ 7716 7726 7739 7752 7768 7775 
+ 7652 7685 7727 7770 7785 7811 
+ 7719 7722 7741 7751 7784 7787 
+ 7667 7698 7710 7764 7804 7824 
+ 7723 7731 7742 7757 7773 7783 
+ 7699 7712 7717 7742 7765 7780 7795 
+ 7721 7743 7776 7782 
+ 7720 7722 7746 7755 7787 7788 
+ 7726 7733 7744 7760 7775 7781 
+ 7376 7460 7609 7852 8739 8918 
+ 7654 7684 7718 7799 7842 7867 
+ 7720 7725 7751 7758 7788 7790 
+ 7683 7710 7738 7804 7835 
+ 7731 7735 7748 7763 7783 7786 
+ 7725 7728 7755 7759 7790 7791 
+ 7728 7732 7758 7762 7791 7793 
+ 7733 7752 7781 7789 
+ 7634 7674 7738 7771 7834 7897 
+ 7732 7734 7759 7766 7793 7796 
+ 7735 7739 7757 7768 7786 7792 
+ 7698 7715 7747 7779 7824 7828 
+ 7712 7727 7749 7785 7795 7813 
+ 7734 7737 7762 7769 7796 7798 
+ 7690 7718 7736 7799 7805 7838 
+ 7739 7744 7763 7775 7792 7797 
+ 7737 7740 7766 7774 7798 7801 
+ 7685 7706 7745 7800 7811 7856 
+ 7607 7634 7761 7778 7897 7924 
+ 7545 7603 7679 7778 7937 8045 8145 
+ 7742 7748 7780 7783 7810 
+ 7740 7743 7769 7776 7801 7802 
+ 7744 7752 7768 7781 7797 7803 
+ 7743 7750 7774 7782 7802 7806 
+ 7694 7724 7736 7805 7841 7859 
+ 7603 7607 7771 7772 7924 8045 
+ 7715 7741 7764 7784 7828 7830 
+ 7742 7749 7773 7795 7810 7836 
+ 7752 7760 7775 7789 7803 7809 
+ 7750 7776 7806 7812 
+ 7748 7757 7773 7786 7810 7817 
+ 7741 7746 7779 7787 7827 7830 
+ 7727 7745 7765 7811 7813 7846 
+ 7757 7763 7783 7792 7816 7817 
+ 7746 7751 7784 7788 7827 7831 
+ 7751 7755 7787 7790 7826 7831 
+ 7760 7781 7809 7815 
+ 7755 7758 7788 7791 7820 7826 
+ 7758 7759 7790 7793 7820 7821 
+ 7763 7768 7786 7797 7816 7818 
+ 7759 7762 7791 7796 7821 7823 
+ 7570 7679 7729 7937 8177 8194 
+ 7749 7765 7780 7813 7836 7855 
+ 7762 7766 7793 7798 7823 7825 
+ 7768 7775 7792 7803 7818 7822 
+ 7766 7769 7796 7801 7825 7829 
+ 7718 7754 7767 7838 7842 7869 
+ 7706 7724 7770 7841 7856 7908 
+ 7769 7774 7798 7802 7829 15387 
+ 7774 7776 7801 7806 7837 15387 
+ 7775 7781 7797 7809 7822 7833 
+ 7710 7747 7756 7824 7835 7926 7955 
+ 7736 7767 7777 7838 7859 7886 
+ 7776 7782 7802 7812 7837 7840 
+ 7672 7713 7819 7891 7936 8028 
+ 7438 7571 7660 7832 8100 8337 8426 
+ 7781 7789 7803 7815 7833 7839 
+ 7773 7780 7783 7817 7836 7854 7878 
+ 7745 7770 7785 7846 7856 7929 
+ 7782 7806 7840 7843 
+ 7765 7785 7795 7846 7855 7890 
+ 7640 7713 7858 7891 8049 
+ 7789 7809 7839 7848 
+ 7786 7792 7817 7818 7845 7850 
+ 7783 7786 7810 7816 7850 7854 
+ 7792 7797 7816 7822 7845 7849 
+ 7672 7696 7807 7866 7936 8007 
+ 7790 7791 7821 7826 7853 7862 
+ 7791 7793 7820 7823 7853 7857 
+ 7797 7803 7818 7833 7849 7851 
+ 7793 7796 7821 7825 7857 7860 
+ 7747 7764 7804 7828 7913 7926 
+ 7796 7798 7823 7829 7860 7863 
+ 7788 7790 7820 7831 7862 7870 
+ 7784 7787 7830 7831 7882 7887 
+ 7764 7779 7824 7830 7895 7913 
+ 7798 7801 7825 7863 7864 15387 
+ 7779 7784 7827 7828 7887 7895 
+ 7787 7788 7826 7827 7870 7882 
+ 7571 7703 7808 7934 8307 8337 
+ 7803 7809 7822 7839 7851 7861 
+ 7738 7761 7835 7897 7942 
+ 7738 7756 7804 7834 7942 7955 
+ 7780 7795 7810 7855 7878 7888 
+ 7802 7806 7840 7865 7868 15387 
+ 7767 7799 7805 7869 7886 7923 
+ 7809 7815 7833 7848 7861 7871 
+ 7806 7812 7837 7843 7868 7875 
+ 7724 7777 7800 7859 7908 7961 7987 
+ 7754 7799 7867 7869 7916 7969 
+ 7812 7840 7875 7881 
+ 7681 7684 7866 7867 8018 8037 
+ 7816 7818 7849 7850 7876 7877 
+ 7785 7811 7813 7890 7929 7952 
+ 1438 4201 7003 14856 14945 15069 
+ 7815 7839 7871 7883 
+ 7818 7822 7845 7851 7877 7879 
+ 7816 7817 7845 7854 7876 7880 
+ 7822 7833 7849 7861 7879 7885 
+ 7460 7551 7753 7966 8918 9066 
+ 7820 7821 7857 7862 7893 7896 
+ 7810 7817 7850 7878 7880 7889 
+ 7795 7813 7836 7888 7890 7914 
+ 7770 7800 7811 7908 7929 7965 
+ 7821 7823 7853 7860 7896 7900 
+ 7640 7645 7814 7872 8049 8140 8176 
+ 7777 7805 7841 7886 7961 7967 
+ 7823 7825 7857 7863 7900 7901 
+ 7833 7839 7851 7871 7885 7892 
+ 7820 7826 7853 7870 7893 7925 
+ 7825 7829 7860 7864 7901 7902 
+ 7829 7863 7865 7902 7903 15387 
+ 7837 7864 7868 7903 7904 15387 
+ 7681 7696 7819 7844 8007 8037 8152 8198 
+ 7684 7754 7842 7844 7969 8009 8018 
+ 7837 7840 7865 7875 7904 7907 
+ 7799 7838 7842 7916 7923 7939 
+ 7826 7831 7862 7882 7925 7931 
+ 7839 7848 7861 7883 7892 7906 
+ 7645 7669 7858 7984 8139 8140 
+ 7591 7670 7874 7995 8189 8246 
+ 7591 7639 7873 7905 8189 8219 
+ 7840 7843 7868 7881 7907 7912 
+ 7845 7850 7877 7880 7894 7898 
+ 7845 7849 7876 7879 7894 7899 
+ 7810 7836 7854 7888 7889 7915 7917 
+ 7849 7851 7877 7885 7899 7910 
+ 7850 7854 7876 7889 7898 7909 
+ 7843 7875 7912 7920 
+ 7827 7831 7870 7887 7931 7953 
+ 7848 7871 7906 7919 
+ 7557 7669 7670 7984 7995 8311 8350 
+ 7851 7861 7879 7892 7910 7918 
+ 7805 7838 7859 7923 7967 8001 
+ 7827 7830 7882 7895 7953 7973 
+ 7836 7855 7878 7914 7915 7935 7940 
+ 7854 7878 7880 7909 7917 7922 
+ 7813 7846 7855 7914 7952 7970 
+ 7713 7807 7814 8028 8049 8155 
+ 7861 7871 7885 7906 7918 7930 
+ 7853 7862 7896 7925 7945 
+ 7876 7877 7898 7899 7921 7927 
+ 7828 7830 7887 7913 7973 7994 
+ 7853 7857 7893 7900 7945 7964 
+ 7761 7771 7834 7924 7942 8109 8117 
+ 7876 7880 7894 7909 7927 7932 
+ 7877 7879 7894 7910 7921 7928 
+ 7857 7860 7896 7901 7958 7964 
+ 7860 7863 7900 7902 7951 7958 
+ 7863 7864 7901 7903 7947 7951 
+ 7864 7865 7902 7904 7943 7947 
+ 7865 7868 7903 7907 7943 7944 
+ 7639 7703 7874 7934 8219 8224 
+ 7871 7883 7892 7919 7930 7941 
+ 7868 7875 7904 7912 7944 7949 
+ 7800 7841 7856 7965 7987 8000 
+ 7880 7889 7898 7922 7932 7938 
+ 7879 7885 7899 7918 7928 15388 
+ 6884 7178 7730 10635 10857 11933 
+ 7875 7881 7907 7920 7949 7954 
+ 7824 7828 7895 7926 7994 8034 
+ 7855 7888 7890 7935 7970 7974 
+ 7878 7888 7917 7940 7948 
+ 7842 7869 7939 7969 8006 
+ 7878 7889 7915 7922 7948 7950 
+ 7885 7892 7910 7930 7956 15388 
+ 7883 7906 7941 7960 
+ 7881 7912 7954 7959 
+ 7894 7899 7927 7928 7946 
+ 7889 7909 7917 7938 7950 
+ 7838 7869 7886 7939 7996 8001 
+ 7771 7778 7897 8045 8109 8212 
+ 7862 7870 7893 7931 7945 8003 
+ 7804 7824 7913 7955 8034 8095 
+ 7894 7898 7921 7932 7946 7957 
+ 7899 7910 7921 7946 7962 15388 
+ 7811 7846 7856 7952 7965 8027 8046 
+ 7892 7906 7918 7941 7956 7972 
+ 7870 7882 7925 7953 8003 8016 
+ 7898 7909 7927 7938 7957 7968 
+ 6391 6710 7436 8666 13750 14308 
+ 7703 7832 7905 8224 8307 
+ 7888 7914 7940 7971 7974 
+ 7807 7819 8007 8028 8110 
+ 7679 7772 7794 8145 8194 8306 
+ 7909 7922 7932 7950 7968 7975 
+ 7869 7916 7923 7996 8006 
+ 7888 7915 7935 7948 7971 7976 
+ 7906 7919 7930 7960 7972 7980 
+ 7834 7835 7897 7955 8117 8119 
+ 7903 7904 7944 7947 7982 7985 
+ 7904 7907 7943 7949 7981 7982 
+ 7893 7896 7925 7964 8003 8015 
+ 7921 7927 7928 7957 7962 7979 
+ 7902 7903 7943 7951 7985 7989 
+ 7915 7917 7940 7950 7976 7977 
+ 7907 7912 7944 7954 7981 7983 
+ 7917 7922 7938 7948 7975 7977 
+ 7901 7902 7947 7958 7989 7999 
+ 7846 7890 7929 7970 8033 8046 
+ 7882 7887 7931 7973 8016 8026 
+ 7912 7920 7949 7959 7983 7986 
+ 7804 7835 7926 7942 8095 8119 
+ 7918 7930 7972 7978 7988 15388 
+ 7927 7932 7946 7968 7979 7991 
+ 7900 7901 7951 7964 7999 8021 
+ 7920 7954 7986 7990 
+ 7919 7941 7980 7993 
+ 7841 7859 7967 7987 8030 8047 
+ 7928 7946 7978 7979 7992 15388 
+ 7549 7592 7729 8177 8358 9305 
+ 7896 7900 7945 7958 8015 8021 
+ 7856 7908 7929 8000 8027 8044 
+ 7551 7660 7852 8100 8935 9066 
+ 7859 7886 7961 8001 8030 8083 
+ 7932 7938 7957 7975 7991 8004 
+ 7842 7867 7916 8006 8009 8075 8081 
+ 7890 7914 7952 7974 7998 8025 8033 
+ 7935 7940 7974 7976 8002 15389 
+ 7930 7941 7956 7980 7988 7997 
+ 7887 7895 7953 7994 8026 8054 
+ 7914 7935 7970 7971 7998 15389 
+ 7938 7950 7968 7977 8004 8013 
+ 7940 7948 7971 7977 8002 8019 
+ 7948 7950 7975 7976 8013 8019 
+ 7956 7962 7988 7992 8005 15388 
+ 7946 7957 7962 7991 7992 15390 
+ 7941 7960 7972 7993 7997 8012 
+ 7944 7949 7982 7983 8008 8010 
+ 7943 7944 7981 7985 8010 8014 
+ 7949 7954 7981 7986 8008 8011 
+ 7669 7872 7884 8139 8350 8432 
+ 7943 7947 7982 7989 8014 8022 
+ 7954 7959 7983 7990 8011 8017 
+ 7841 7908 7961 8000 8047 8064 
+ 7956 7972 7978 7997 8005 8020 
+ 7947 7951 7985 7999 8022 8038 
+ 7959 7986 8017 8023 
+ 7957 7968 7979 8004 8039 15390 
+ 7962 7978 7979 8005 8024 15390 
+ 7960 7980 8012 8029 
+ 7895 7913 7973 8034 8054 8106 
+ 7670 7873 7884 8246 8311 8439 
+ 7923 7939 8001 8006 8089 8093 
+ 7972 7980 7988 8012 8020 8035 
+ 7970 7974 8025 8031 15389 
+ 7951 7958 7989 8021 8038 8057 
+ 7908 7965 7987 8044 8064 8074 
+ 7886 7923 7967 7996 8083 8093 8162 
+ 7971 7976 8019 8032 8036 15389 
+ 7925 7931 7945 8015 8016 8088 8091 
+ 7968 7975 7991 8013 8039 8051 
+ 7978 7988 7992 8020 8024 8041 
+ 7916 7939 7969 7996 8081 8089 
+ 7819 7866 7936 8110 8198 8243 
+ 7981 7983 8010 8011 8042 8043 
+ 7867 7969 8018 8075 8136 8142 
+ 7981 7982 8008 8014 8040 8043 
+ 7983 7986 8008 8017 8042 8048 
+ 7980 7993 7997 8029 8035 8052 
+ 7975 7977 8004 8019 8051 8058 
+ 7982 7985 8010 8022 8040 8050 
+ 7945 7964 8003 8021 8088 8099 
+ 7931 7953 8003 8026 8091 8097 
+ 7986 7990 8011 8023 8048 8055 
+ 7844 7867 8009 8037 8128 8136 
+ 7976 7977 8002 8013 8036 8058 8069 
+ 7988 7997 8005 8035 8041 8056 
+ 7958 7964 7999 8015 8057 8099 
+ 7985 7989 8014 8038 8050 8059 
+ 7990 8017 8055 8060 
+ 7992 8005 8041 8053 8063 15390 
+ 7970 7998 8031 8033 8061 8076 
+ 7953 7973 8016 8054 8097 8113 
+ 7929 7965 8044 8046 8124 8132 
+ 7807 7891 7936 8110 8155 8236 
+ 7993 8012 8052 8065 
+ 7961 7967 8047 8083 8114 
+ 7998 8025 8032 8061 8066 15389 
+ 8002 8031 8036 8066 8067 15389 
+ 7952 7970 8025 8046 8076 8120 
+ 7913 7926 7994 8095 8106 8171 
+ 7997 8012 8020 8052 8056 8071 
+ 8002 8019 8032 8067 8069 
+ 7844 7866 8018 8128 8152 8223 
+ 7989 7999 8022 8057 8059 8072 
+ 7991 8004 8051 8053 8078 8082 15390 
+ 8010 8014 8043 8050 8062 8070 
+ 8005 8020 8024 8056 8063 8077 
+ 8008 8011 8043 8048 8068 8073 
+ 8008 8010 8040 8042 8062 8068 
+ 7965 8000 8027 8074 8124 8129 
+ 7772 7778 7924 8145 8212 8417 
+ 7929 7952 8027 8033 8120 8132 8168 
+ 7961 7987 8030 8064 8114 8143 
+ 8011 8017 8042 8055 8073 8080 
+ 7814 7858 7891 8155 8176 8305 8333 
+ 8014 8022 8040 8059 8070 8079 
+ 8004 8013 8039 8058 8078 8084 
+ 8012 8029 8035 8065 8071 8086 
+ 8024 8039 8063 8082 8090 15390 
+ 7973 7994 8026 8106 8113 8157 
+ 8017 8023 8048 8060 8080 8087 
+ 8020 8035 8041 8071 8077 8094 
+ 7999 8021 8038 8072 8099 8102 8141 
+ 8013 8019 8051 8069 8084 8096 
+ 8022 8038 8050 8072 8079 8092 
+ 8023 8055 8087 8098 
+ 8025 8031 8066 8076 8112 
+ 8040 8043 8068 8070 8085 
+ 8024 8041 8053 8077 8090 8103 
+ 7987 8000 8047 8074 8143 8160 
+ 8029 8052 8086 8107 
+ 8031 8032 8061 8067 8104 8112 
+ 8032 8036 8066 8069 8104 8111 
+ 8042 8043 8062 8073 8085 8101 
+ 8019 8036 8058 8067 8096 8111 
+ 8040 8050 8062 8079 8085 8105 
+ 8035 8052 8056 8086 8094 8116 
+ 8038 8057 8059 8092 8102 
+ 8042 8048 8068 8080 8101 8115 
+ 8000 8044 8064 8129 8160 
+ 7969 8009 8081 8138 8142 8182 
+ 8025 8033 8061 8112 8120 8170 
+ 8041 8056 8063 8094 8103 8123 
+ 8039 8051 8082 8084 8122 8125 
+ 8050 8059 8070 8092 8105 8127 
+ 8048 8055 8073 8087 8115 8126 
+ 7969 8006 8075 8089 8138 8161 
+ 8039 8053 8078 8090 8121 8122 
+ 7967 8001 8030 8114 8162 8216 
+ 8051 8058 8078 8096 8125 8134 
+ 8062 8068 8070 8101 8105 8130 
+ 8052 8065 8071 8107 8116 8133 
+ 8055 8060 8080 8098 8126 8135 
+ 8003 8015 8091 8099 8179 8187 
+ 7996 8006 8081 8093 8161 8190 
+ 8053 8063 8082 8103 8121 8131 
+ 8003 8016 8088 8097 8179 8184 
+ 8059 8072 8079 8102 8127 8147 
+ 7996 8001 8089 8162 8190 8213 
+ 8056 8071 8077 8116 8123 8137 
+ 7926 7955 8034 8119 8171 8291 15393 
+ 8058 8069 8084 8111 8134 8146 
+ 8016 8026 8091 8113 8184 8186 
+ 8060 8087 8135 8144 
+ 8015 8021 8057 8088 8141 8187 8206 
+ 7660 7808 7966 8426 8742 8935 
+ 8068 8073 8085 8115 8130 8149 
+ 8057 8072 8092 8141 8147 
+ 8063 8077 8090 8123 8131 8148 
+ 8066 8067 8111 8112 8154 8183 
+ 8070 8079 8085 8127 8130 8167 
+ 7994 8034 8054 8157 8171 8188 
+ 8065 8086 8133 8153 
+ 7326 7346 7608 8722 9530 11037 
+ 7897 7924 8117 8212 8401 8405 
+ 7936 8007 8028 8236 8243 8364 
+ 8067 8069 8096 8104 8146 8154 
+ 8061 8066 8076 8104 8170 8183 
+ 8026 8054 8097 8157 8186 8202 
+ 8030 8047 8083 8143 8216 8252 
+ 8073 8080 8101 8126 8149 8159 
+ 8071 8086 8094 8133 8137 8158 
+ 7897 7942 8109 8119 8344 8401 
+ 7315 7437 7609 8472 8739 11028 11079 
+ 7942 7955 8095 8117 8344 15393 
+ 8033 8046 8076 8168 8170 8204 
+ 8082 8090 8122 8131 8150 8156 
+ 8078 8082 8121 8125 8156 8164 
+ 8077 8094 8103 8137 8148 8163 
+ 8027 8044 8129 8132 8193 8200 
+ 8078 8084 8122 8134 8164 8172 
+ 8080 8087 8115 8135 8159 8169 
+ 8079 8092 8105 8147 8167 8201 
+ 8018 8037 8136 8223 8229 
+ 8044 8074 8124 8160 8193 8276 
+ 8085 8101 8105 8149 8167 8181 
+ 8090 8103 8121 8148 8150 8165 
+ 8027 8046 8124 8168 8200 8220 
+ 8086 8107 8116 8153 8158 8174 
+ 8084 8096 8125 8146 8172 8191 
+ 8087 8098 8126 8144 8169 8175 
+ 8009 8018 8128 8142 8229 8233 
+ 8094 8116 8123 8158 8163 8178 
+ 8075 8081 8161 8182 8209 
+ 7872 7984 8140 8420 8432 
+ 7858 7872 8139 8176 8420 8452 
+ 8057 8099 8102 8147 8206 8214 
+ 8009 8075 8136 8182 8233 8244 
+ 8047 8064 8114 8160 8252 8285 
+ 8098 8135 8175 8185 
+ 7772 7937 8045 8306 8417 8519 
+ 8096 8111 8134 8154 8191 8203 
+ 8092 8102 8127 8141 8201 8214 
+ 8103 8123 8131 8163 8165 8180 
+ 8101 8115 8130 8159 8181 15391 
+ 8121 8131 8156 8165 8173 
+ 7007 7248 7455 10752 10767 12039 
+ 7866 8037 8198 8223 8296 
+ 8107 8133 8174 8196 
+ 8104 8111 8146 8183 8203 8215 
+ 7891 8028 8049 8236 8333 8393 
+ 8121 8122 8150 8164 8173 8192 
+ 8054 8106 8113 8188 8202 8208 
+ 8116 8133 8137 8174 8178 8197 
+ 8115 8126 8149 8169 8205 15391 
+ 8064 8074 8129 8143 8276 8285 
+ 8081 8089 8138 8190 8209 8247 
+ 8001 8083 8093 8213 8216 8293 
+ 8123 8137 8148 8178 8180 8199 
+ 8122 8125 8156 8172 8192 8207 
+ 8131 8148 8150 8173 8180 8195 
+ 7112 7332 7455 10539 10767 15544 
+ 8105 8127 8130 8181 8201 8226 
+ 8046 8120 8132 8204 8220 8249 
+ 8126 8135 8159 8175 8205 8210 
+ 8076 8112 8120 8183 8204 8234 8241 
+ 8034 8095 8106 8188 8262 8291 
+ 8125 8134 8164 8191 8207 8227 
+ 8150 8156 8165 8192 8195 8211 
+ 8133 8153 8158 8196 8197 8221 
+ 8135 8144 8169 8185 8210 8222 
+ 7858 8049 8140 8305 8410 8452 
+ 7729 7794 7963 8194 9305 15422 
+ 8137 8158 8163 8197 8199 8218 
+ 8088 8091 8184 8187 8264 8290 
+ 8148 8163 8165 8195 8199 8217 
+ 8130 8149 8167 8226 8228 15391 
+ 8075 8138 8142 8209 8244 8269 
+ 8104 8112 8154 8170 8215 8241 8242 
+ 8091 8097 8179 8186 8261 8264 
+ 8144 8175 8222 8225 
+ 8097 8113 8184 8202 8260 8261 
+ 8088 8099 8179 8206 8290 8308 
+ 8106 8157 8171 8208 8257 8262 
+ 7873 7874 8219 8246 8458 8517 
+ 8089 8093 8161 8213 8247 8284 
+ 8134 8146 8172 8203 8227 8237 
+ 8156 8164 8173 8207 8211 8230 
+ 8124 8129 8200 8276 15392 
+ 7794 7937 8177 8306 15422 
+ 8165 8173 8180 8211 8217 8231 
+ 8153 8174 8221 8240 
+ 8158 8174 8178 8218 8221 8238 
+ 7866 8007 8152 8243 8296 8373 
+ 8163 8178 8180 8217 8218 8235 
+ 8124 8132 8193 8220 8273 15392 
+ 8127 8147 8167 8214 8226 8275 8279 
+ 8113 8157 8186 8208 8255 8260 
+ 8146 8154 8191 8215 8237 8248 
+ 8120 8168 8170 8234 8249 8268 
+ 8159 8169 8210 8239 8245 15391 
+ 8099 8141 8187 8214 8297 8308 
+ 8164 8172 8192 8227 8230 8254 
+ 8157 8188 8202 8255 8257 
+ 8138 8161 8182 8247 8269 8327 
+ 8169 8175 8205 8222 8245 8250 
+ 8173 8192 8195 8230 8231 8251 
+ 7924 8045 8109 8405 8417 8521 
+ 8093 8162 8190 8284 8293 8335 
+ 8141 8147 8201 8206 8275 8297 
+ 8154 8183 8203 8242 8248 8263 
+ 8083 8114 8162 8252 8293 8346 
+ 8180 8195 8199 8231 8235 8253 
+ 8178 8197 8199 8235 8238 8256 
+ 7874 7905 8189 8224 8517 8534 
+ 8132 8168 8200 8249 8273 8274 
+ 8174 8196 8197 8238 8240 8259 
+ 8175 8185 8210 8225 8250 8258 
+ 8037 8128 8152 8229 8296 8381 
+ 7905 7934 8219 8307 8534 8645 
+ 8185 8222 8258 8265 
+ 8167 8181 8201 8228 8270 8279 
+ 8172 8191 8207 8237 8254 8272 8289 
+ 8181 8226 8239 8270 8277 15391 
+ 8128 8136 8223 8233 8377 8381 
+ 8192 8207 8211 8251 8254 8266 
+ 8195 8211 8217 8251 8253 8271 
+ 6494 6507 7436 11299 13750 14955 
+ 8136 8142 8229 8244 8367 8377 
+ 8170 8204 8241 8268 8280 8316 
+ 8199 8217 8218 8253 8256 8278 
+ 8028 8110 8155 8364 8393 8441 
+ 8191 8203 8227 8248 8267 8272 
+ 8197 8218 8221 8256 8259 8283 
+ 8205 8228 8245 8277 8287 15391 
+ 8196 8221 8259 8286 
+ 8170 8183 8234 8242 8280 8281 
+ 8183 8215 8241 8263 8281 8282 
+ 8007 8110 8198 8364 8373 8535 
+ 8142 8182 8233 8269 8367 
+ 8205 8210 8239 8250 8287 8292 
+ 7873 7995 8189 8439 8458 8630 
+ 8161 8190 8209 8284 8327 8370 
+ 8203 8215 8237 8263 8267 8288 
+ 8168 8204 8220 8268 8274 8321 
+ 8210 8222 8245 8258 8292 8298 
+ 8211 8230 8231 8266 8271 8294 
+ 8114 8143 8216 8285 8346 8380 
+ 8217 8231 8235 8271 8278 8299 
+ 8207 8227 8230 8266 8289 8295 
+ 8202 8208 8257 8260 8322 8336 
+ 8218 8235 8238 8278 8283 8300 
+ 8188 8208 8255 8262 8322 8328 
+ 8222 8225 8250 8265 8298 8302 
+ 8221 8238 8240 8283 8286 8303 
+ 8186 8202 8255 8261 8329 8336 
+ 8184 8186 8260 8264 8329 8349 
+ 8171 8188 8257 8291 8328 8374 
+ 8215 8242 8248 8282 8288 8313 
+ 8179 8184 8261 8290 8349 8388 
+ 8225 8258 8302 8309 
+ 8230 8251 8254 8294 8295 8304 
+ 8237 8248 8272 8288 8301 8319 
+ 8204 8234 8249 8316 8321 8357 
+ 8182 8209 8244 8327 8367 8479 
+ 8226 8228 8277 8279 8312 8330 
+ 8231 8251 8253 8294 8299 8314 
+ 8227 8237 8267 8289 8301 8310 
+ 8200 8220 8274 8343 8371 15392 
+ 8220 8249 8273 8321 8343 
+ 8201 8214 8279 8297 8348 8362 
+ 8129 8160 8193 8285 8391 8418 15392 
+ 8228 8239 8270 8287 8312 8317 
+ 8235 8253 8256 8299 8300 8318 
+ 8201 8226 8270 8275 8330 8348 
+ 8234 8241 8281 8316 8334 
+ 8241 8242 8280 8282 8323 8334 
+ 8242 8263 8281 8313 8323 
+ 8238 8256 8259 8300 8303 8324 
+ 8190 8213 8247 8335 8370 
+ 8143 8160 8252 8276 8380 8418 
+ 8240 8259 8303 8326 
+ 8239 8245 8277 8292 8317 8325 
+ 8248 8263 8267 8313 8319 
+ 8227 8254 8272 8295 8310 8315 
+ 8179 8187 8264 8308 8388 8416 
+ 8095 8171 8262 8374 8450 15393 
+ 8245 8250 8287 8298 8325 8332 
+ 8162 8213 8216 8335 8346 8444 
+ 8251 8266 8271 8304 8314 8331 
+ 8254 8266 8289 8304 8315 8320 
+ 8152 8198 8223 8373 8381 8470 
+ 8206 8214 8275 8308 8362 8400 
+ 8250 8258 8292 8302 8332 8338 
+ 8253 8271 8278 8314 8318 8339 
+ 8256 8278 8283 8318 8324 8342 
+ 8267 8272 8310 8319 8340 
+ 8258 8265 8298 8309 8338 8345 
+ 8259 8283 8286 8324 8326 8347 
+ 8266 8294 8295 8320 8331 8341 
+ 8049 8176 8333 8410 8456 8461 
+ 7937 8145 8194 8519 15422 
+ 7832 7934 8224 8337 8643 8645 
+ 8187 8206 8290 8297 8400 8416 
+ 8265 8302 8345 8354 
+ 8272 8289 8301 8315 8340 8351 
+ 7884 7995 8350 8439 8586 8601 
+ 8270 8277 8317 8330 8352 8359 
+ 8263 8282 8288 8319 8323 8361 
+ 8271 8294 8299 8331 8339 8356 
+ 8289 8295 8310 8320 8351 8353 
+ 8234 8268 8280 8334 8357 8384 
+ 8277 8287 8312 8325 8352 8360 
+ 8278 8299 8300 8339 8342 8363 
+ 8267 8288 8301 8313 8340 8361 8386 
+ 8295 8304 8315 8341 8353 
+ 8249 8268 8274 8343 8357 8397 
+ 8255 8257 8328 8336 8390 8404 
+ 8281 8282 8313 8334 8361 8395 
+ 8283 8300 8303 8342 8347 8365 
+ 8287 8292 8317 8332 8360 8366 
+ 8286 8303 8347 8369 
+ 8209 8247 8269 8370 8462 8479 
+ 8257 8262 8322 8374 8390 
+ 8260 8261 8336 8349 8407 
+ 8270 8279 8312 8348 8359 8387 
+ 8294 8304 8314 8341 8356 8368 
+ 8292 8298 8325 8338 8366 8372 
+ 8049 8155 8305 8393 8461 8495 
+ 8280 8281 8316 8323 8384 8395 
+ 8213 8284 8293 8370 8444 8453 
+ 8255 8260 8322 8329 8404 8407 
+ 7808 7832 8307 8426 8643 8701 
+ 8298 8302 8332 8345 8372 8376 
+ 8299 8314 8318 8356 8363 8375 
+ 8301 8310 8319 8351 8386 8399 
+ 8304 8320 8331 8353 8368 8379 
+ 8300 8318 8324 8363 8365 8378 
+ 8273 8274 8321 8371 8397 8436 
+ 8117 8119 8401 8516 8624 15393 
+ 8302 8309 8338 8354 8376 8382 
+ 8216 8252 8293 8380 8444 8464 
+ 8303 8324 8326 8365 8369 8385 
+ 8275 8279 8330 8362 8387 8413 
+ 8261 8264 8329 8388 8407 8477 
+ 7884 7984 8311 8432 8601 8688 
+ 8310 8315 8340 8353 8394 8399 
+ 8312 8317 8359 8360 8383 8389 
+ 8315 8320 8341 8351 8379 8394 
+ 8309 8345 8382 8392 
+ 6345 6996 7178 10635 13535 13856 
+ 8314 8331 8339 8368 8375 15394 
+ 8268 8316 8321 8384 8397 8433 
+ 7592 7608 7963 9305 9530 10946 
+ 8312 8330 8352 8383 8387 
+ 8317 8325 8352 8366 8389 8396 
+ 8313 8319 8323 8386 8395 8423 
+ 8275 8297 8348 8400 8413 8455 
+ 8318 8339 8342 8375 8378 8398 
+ 8110 8236 8243 8441 8535 8573 
+ 8324 8342 8347 8378 8385 8402 
+ 8325 8332 8360 8372 8396 8403 
+ 8233 8244 8269 8377 8479 8507 
+ 8331 8341 8356 8379 8408 15394 
+ 8326 8347 8385 8406 
+ 8247 8284 8327 8335 8453 8462 
+ 8273 8343 8391 8436 15392 15395 
+ 8332 8338 8366 8376 8403 8409 
+ 8198 8243 8296 8470 8535 8613 
+ 8262 8291 8328 8390 8450 8460 
+ 8339 8356 8363 8398 8411 15394 
+ 8338 8345 8372 8382 8409 8412 
+ 8229 8233 8367 8381 8507 8529 
+ 8342 8363 8365 8398 8402 8414 
+ 8341 8353 8368 8394 8408 8427 
+ 8252 8285 8346 8418 8464 8498 
+ 8223 8229 8296 8377 8470 8529 8556 
+ 8345 8354 8376 8392 8412 8419 
+ 8352 8359 8387 8389 8415 8421 
+ 8316 8334 8357 8395 8433 8469 
+ 8347 8365 8369 8402 8406 8422 
+ 8319 8340 8361 8399 8423 8442 
+ 8330 8348 8359 8383 8413 8421 8435 
+ 8264 8290 8349 8416 8477 8536 
+ 8352 8360 8383 8396 8415 8425 
+ 8322 8328 8374 8404 8460 8474 
+ 8276 8371 8418 8499 15392 15395 
+ 8354 8382 8419 8424 
+ 8155 8236 8333 8441 8495 8539 
+ 8351 8353 8379 8399 8427 8447 
+ 8323 8334 8361 8384 8423 8469 8486 
+ 8360 8366 8389 8403 8425 8430 
+ 8321 8343 8357 8433 8436 8491 
+ 8363 8375 8378 8411 8414 8431 
+ 8340 8351 8386 8394 8442 8447 
+ 8297 8308 8362 8416 8455 8511 
+ 8109 8117 8344 8405 8624 8690 
+ 8365 8378 8385 8414 8422 8434 
+ 8366 8372 8396 8409 8430 8437 
+ 8322 8336 8390 8407 8474 8490 
+ 8109 8212 8401 8521 8690 
+ 8369 8385 8422 8438 
+ 8329 8336 8349 8404 8477 8490 
+ 8368 8379 8427 8428 8448 15394 
+ 8372 8376 8403 8412 8437 8440 
+ 8176 8305 8452 8456 8676 
+ 8375 8398 8428 8431 8445 15394 
+ 8376 8382 8409 8419 8440 8443 
+ 8348 8362 8387 8435 8455 8465 
+ 8378 8398 8402 8431 8434 8449 
+ 8383 8389 8421 8425 8446 8457 
+ 8290 8308 8388 8400 8511 8536 
+ 8045 8145 8212 8519 8521 8816 
+ 8276 8285 8380 8391 8498 8499 8564 
+ 8382 8392 8412 8424 8443 8451 
+ 8139 8140 8432 8452 8728 8856 
+ 8383 8387 8415 8435 8446 
+ 8385 8402 8406 8434 8438 8454 
+ 8361 8386 8395 8442 8486 8492 
+ 8392 8419 8451 8459 
+ 8389 8396 8415 8430 8457 8463 
+ 7808 8100 8337 8701 8742 9359 
+ 8379 8394 8408 8447 8448 8480 
+ 8408 8411 8445 8448 8467 15394 
+ 5550 6549 6996 14069 14806 14963 
+ 8396 8403 8425 8437 8463 8468 
+ 8398 8411 8414 8445 8449 8466 
+ 7984 8139 8350 8420 8688 8856 
+ 8357 8384 8397 8469 8491 8548 
+ 8402 8414 8422 8449 8454 8471 
+ 8387 8413 8421 8446 8465 8476 
+ 8343 8371 8397 8491 8532 15395 
+ 8403 8409 8430 8440 8468 8473 
+ 8406 8422 8454 8475 
+ 7995 8246 8311 8586 8630 8835 
+ 8409 8412 8437 8443 8473 8478 
+ 8236 8364 8393 8539 8573 8589 
+ 8386 8399 8423 8447 8492 8501 
+ 8412 8419 8440 8451 8478 8481 
+ 8293 8335 8346 8453 8464 8585 8587 
+ 8411 8428 8431 8466 8467 8482 
+ 8415 8421 8435 8457 8476 8485 
+ 8394 8399 8427 8442 8480 8501 8510 
+ 8408 8427 8428 8467 8480 8489 
+ 8414 8431 8434 8466 8471 8483 
+ 8291 8374 8460 8516 8649 15393 15397 
+ 8419 8424 8443 8459 8481 8484 
+ 8140 8176 8410 8420 8676 8728 
+ 8335 8370 8444 8462 8585 8598 
+ 8422 8434 8438 8471 8475 8487 
+ 8362 8400 8413 8465 8504 8511 15396 
+ 8305 8410 8461 8544 8676 
+ 8415 8425 8446 8463 8485 8493 
+ 8189 8246 8517 8630 8778 
+ 8424 8451 8484 8488 
+ 8374 8390 8450 8474 8542 15397 
+ 8305 8333 8456 8495 8544 8608 
+ 8327 8370 8453 8479 8598 8615 
+ 8425 8430 8457 8468 8493 8494 
+ 8346 8380 8444 8498 8587 8617 
+ 8413 8435 8455 8476 8504 8508 
+ 8431 8445 8449 8482 8483 8496 
+ 8428 8445 8448 8482 8489 8502 
+ 8430 8437 8463 8473 8494 8497 
+ 8384 8395 8433 8486 8543 8548 
+ 8296 8373 8381 8556 8613 8699 
+ 8434 8449 8454 8483 8487 8500 
+ 7437 7528 8118 8881 11028 11137 
+ 8437 8440 8468 8478 8497 8503 
+ 8390 8404 8460 8490 8542 8568 
+ 8438 8454 8487 8505 
+ 8435 8446 8465 8485 8508 8523 
+ 8349 8388 8407 8490 8536 8580 8626 
+ 8440 8443 8473 8481 8503 8506 
+ 8269 8327 8367 8462 8507 8615 8629 
+ 8427 8447 8448 8489 8510 8520 
+ 8443 8451 8478 8484 8506 8509 
+ 8445 8466 8467 8496 8502 8514 
+ 8449 8466 8471 8496 8500 8512 
+ 8451 8459 8481 8488 8509 8513 
+ 8446 8457 8476 8493 8523 8524 
+ 8395 8423 8469 8492 8543 8569 
+ 8454 8471 8475 8500 8505 8515 
+ 8459 8484 8513 8518 
+ 8448 8467 8480 8502 8520 8522 
+ 8404 8407 8474 8477 8568 8580 
+ 8397 8433 8436 8532 8548 8592 
+ 8423 8442 8486 8501 8555 8569 
+ 8457 8463 8485 8494 8524 8526 
+ 8463 8468 8493 8497 8525 8526 
+ 8333 8393 8461 8539 8608 8693 
+ 8466 8482 8483 8512 8514 8527 
+ 8468 8473 8494 8503 8525 8528 
+ 8380 8418 8464 8564 8617 8656 
+ 8391 8418 8564 8574 8662 15395 
+ 8471 8483 8487 8512 8515 8530 
+ 8442 8447 8492 8510 8554 8555 
+ 8467 8482 8489 8514 8522 8531 
+ 8473 8478 8497 8506 8528 8533 
+ 8455 8465 8508 8540 15396 
+ 8475 8487 8515 8537 
+ 8478 8481 8503 8509 8533 8538 
+ 8367 8377 8479 8529 8629 8655 
+ 8465 8476 8504 8523 8540 8551 
+ 8481 8484 8506 8513 8538 8541 
+ 8447 8480 8501 8520 8554 8560 
+ 8400 8416 8455 8536 8611 8642 15396 
+ 8483 8496 8500 8527 8530 8545 
+ 8484 8488 8509 8518 8541 8546 
+ 8482 8496 8502 8527 8531 8547 
+ 8487 8500 8505 8530 8537 8549 
+ 8344 8450 8624 8649 8779 15393 
+ 8189 8219 8458 8534 8778 8942 
+ 8488 8513 8546 8550 
+ 8145 8306 8417 8816 10106 15422 
+ 8480 8489 8510 8522 8553 8560 
+ 8212 8405 8417 8690 8816 9209 
+ 8489 8502 8520 8531 8552 8553 
+ 8476 8485 8508 8524 8551 8571 8583 
+ 8485 8493 8523 8526 8566 8571 
+ 8494 8497 8526 8528 8558 8559 
+ 8493 8494 8524 8525 8559 8566 
+ 8496 8512 8514 8545 8547 8557 
+ 8497 8503 8525 8533 8558 8562 
+ 8377 8381 8507 8556 8655 8670 
+ 8500 8512 8515 8545 8549 8561 
+ 8502 8514 8522 8547 8552 8563 
+ 8436 8491 8574 8592 8652 15395 
+ 8503 8506 8528 8538 8562 8565 
+ 8219 8224 8517 8645 8942 9424 
+ 8243 8364 8373 8573 8613 8842 8861 
+ 8388 8416 8477 8511 8626 8642 8695 
+ 8505 8515 8549 8567 
+ 8506 8509 8533 8541 8565 8570 
+ 8393 8441 8495 8589 8693 8755 
+ 8504 8508 8551 8579 15396 
+ 8509 8513 8538 8546 8570 8572 
+ 8460 8474 8568 8658 8663 15397 
+ 8469 8486 8548 8569 8610 8634 
+ 8456 8461 8608 8676 8703 
+ 8512 8527 8530 8557 8561 8575 
+ 8513 8518 8541 8550 8572 8577 
+ 8514 8527 8531 8557 8563 8576 
+ 8433 8469 8491 8543 8592 8634 8661 
+ 8515 8530 8537 8561 8567 8581 
+ 8518 8546 8577 8582 
+ 8508 8523 8540 8579 8583 15398 
+ 8522 8531 8553 8563 8578 8584 
+ 8520 8522 8552 8560 8584 8588 
+ 8501 8510 8555 8560 8597 8622 
+ 8492 8501 8554 8569 8622 8633 
+ 8381 8470 8529 8670 8699 8774 
+ 8527 8545 8547 8575 8576 8591 
+ 8525 8528 8559 8562 8594 8595 
+ 8525 8526 8558 8566 8595 8602 
+ 8510 8520 8553 8554 8588 8597 8612 
+ 8530 8545 8549 8575 8581 8593 
+ 8528 8533 8558 8565 8594 8596 
+ 8531 8547 8552 8576 8578 8590 
+ 8418 8498 8499 8656 8662 8733 
+ 8533 8538 8562 8570 8596 8600 
+ 8524 8526 8559 8571 8602 8606 
+ 8537 8549 8581 8603 
+ 8474 8490 8542 8580 8663 8691 
+ 8486 8492 8543 8555 8610 8633 8668 
+ 8538 8541 8565 8572 8600 8604 
+ 8523 8524 8566 8583 8606 8618 
+ 8541 8546 8570 8577 8604 8607 
+ 8364 8441 8535 8589 8818 8842 
+ 8499 8532 8652 8662 8780 15395 
+ 8545 8557 8561 8591 8593 8614 
+ 8547 8557 8563 8590 8591 8609 
+ 8546 8550 8572 8582 8607 8616 
+ 8552 8563 8584 8590 8599 
+ 8540 8551 8625 15396 15398 15400 
+ 8477 8490 8568 8626 8691 8738 
+ 8549 8561 8567 8593 8603 8620 
+ 8550 8577 8616 8621 
+ 8523 8551 8571 8618 8628 15398 
+ 8552 8553 8578 8588 8599 8605 
+ 8444 8453 8587 8598 8758 8772 
+ 8311 8439 8601 8835 8927 
+ 8444 8464 8585 8617 8758 8762 
+ 8553 8560 8584 8605 8612 8619 
+ 8441 8539 8573 8755 8818 
+ 8563 8576 8578 8599 8609 8623 
+ 8557 8575 8576 8609 8614 8627 
+ 8491 8532 8548 8652 8661 8718 
+ 8561 8575 8581 8614 8620 8632 
+ 8558 8562 8595 8596 8635 8636 
+ 8558 8559 8594 8602 8636 8639 
+ 8562 8565 8594 8600 8635 8637 
+ 8554 8560 8612 8622 8665 15401 
+ 8453 8462 8585 8615 8772 8800 
+ 8578 8584 8590 8605 8623 8631 
+ 8565 8570 8596 8604 8637 8640 
+ 8311 8350 8586 8688 8927 9139 
+ 8559 8566 8595 8606 8639 15399 
+ 8567 8581 8620 8644 
+ 8570 8572 8600 8607 8640 8646 
+ 8584 8588 8599 8619 8631 8638 
+ 8566 8571 8602 8618 8647 15399 
+ 8572 8577 8604 8616 8646 8648 
+ 8461 8495 8544 8693 8703 8841 
+ 8576 8590 8591 8623 8627 8641 
+ 8543 8569 8634 8668 8698 
+ 8511 8625 8642 8705 8726 15396 
+ 8560 8588 8597 8619 8653 15401 
+ 8373 8470 8535 8699 8861 8911 
+ 8575 8591 8593 8627 8632 8650 
+ 8462 8479 8598 8629 8800 8821 
+ 8577 8582 8607 8621 8648 8654 
+ 8464 8498 8587 8656 8762 8777 
+ 8571 8583 8606 8628 8647 8651 
+ 8588 8605 8612 8638 8653 
+ 8581 8593 8603 8632 8644 8659 
+ 8582 8616 8654 8660 
+ 8554 8555 8597 8633 8665 8679 
+ 8590 8599 8609 8631 8641 8657 
+ 8344 8401 8516 8690 8779 9129 9162 
+ 8579 8611 8700 8705 15396 15400 
+ 8477 8536 8580 8695 8738 8802 
+ 8591 8609 8614 8641 8650 8667 
+ 8583 8618 8651 8664 8672 15398 
+ 8479 8507 8615 8655 8793 8821 
+ 8246 8439 8458 8778 8835 9382 
+ 8599 8605 8623 8638 8657 8669 
+ 8593 8614 8620 8650 8659 8671 
+ 8555 8569 8622 8668 8679 8709 
+ 8543 8548 8610 8661 8698 8734 
+ 8594 8596 8636 8637 8674 8677 
+ 8594 8595 8635 8639 8677 8682 
+ 8596 8600 8635 8640 8674 8675 
+ 8605 8619 8631 8653 8669 8689 
+ 8595 8602 8636 8682 8684 15399 
+ 8600 8604 8637 8646 8675 8678 
+ 8609 8623 8627 8657 8667 8673 
+ 8511 8536 8611 8695 8726 8768 
+ 8307 8337 8645 8701 9296 9719 
+ 8603 8620 8659 8680 
+ 8224 8307 8534 8643 9424 9719 
+ 8604 8607 8640 8648 8678 8681 
+ 8606 8618 8651 8683 8685 15399 
+ 8607 8616 8646 8654 8681 8687 
+ 8450 8516 8730 8779 8846 15397 
+ 8614 8627 8632 8667 8671 8686 
+ 8618 8628 8647 8672 8683 
+ 8532 8574 8592 8718 8780 8837 
+ 8612 8619 8638 8689 8704 15401 
+ 8616 8621 8648 8660 8687 8692 
+ 8507 8529 8629 8670 8793 8799 
+ 8498 8564 8617 8733 8777 8792 
+ 8623 8631 8641 8669 8673 8694 
+ 8542 8663 8730 8756 15397 
+ 8620 8632 8644 8671 8680 8697 
+ 8621 8654 8692 8696 
+ 8548 8592 8634 8718 8734 8798 
+ 8499 8564 8574 8733 8780 8838 
+ 8542 8568 8658 8691 8756 8789 
+ 8628 8672 8706 8711 15398 15400 
+ 8597 8622 8679 8707 8737 15401 
+ 6710 6724 7709 7933 12141 14308 
+ 8627 8641 8650 8673 8686 8702 
+ 8569 8610 8633 8698 8709 8749 
+ 8631 8638 8657 8689 8694 8710 
+ 8529 8556 8655 8774 8799 
+ 8632 8650 8659 8686 8697 8708 
+ 8628 8651 8664 8683 8711 8723 
+ 8641 8657 8667 8694 8702 8712 
+ 8635 8637 8675 8677 8714 8721 
+ 8637 8640 8674 8678 8713 8714 
+ 8410 8452 8456 8544 8703 8728 8990 9658 
+ 8635 8636 8674 8682 8721 8725 
+ 8640 8646 8675 8681 8713 8715 
+ 8622 8633 8665 8709 8737 8759 
+ 8644 8659 8697 8716 
+ 8646 8648 8678 8687 8715 8717 
+ 8636 8639 8677 8684 8725 8727 
+ 8647 8651 8672 8685 8723 8735 
+ 8639 8682 8685 8727 8731 15399 
+ 8647 8683 8684 8731 8735 15399 
+ 8650 8667 8671 8702 8708 8719 
+ 8648 8654 8681 8692 8717 8720 
+ 8350 8432 8601 8856 9139 9604 
+ 8638 8653 8669 8704 8710 8740 
+ 8401 8405 8521 8624 9162 9209 
+ 8568 8580 8663 8738 8789 8867 
+ 8654 8660 8687 8696 8720 8724 
+ 8495 8539 8608 8755 8841 8999 
+ 8657 8669 8673 8710 8712 8732 
+ 8536 8626 8642 8768 8802 8847 
+ 8660 8692 8724 15402 
+ 8659 8671 8680 8708 8716 8729 
+ 8610 8634 8668 8734 8749 8781 
+ 8470 8556 8613 8774 8911 8998 
+ 8625 8705 8706 8743 8765 15400 
+ 8337 8426 8643 9296 9359 
+ 8667 8673 8686 8712 8719 8736 
+ 8544 8608 8676 8841 8990 
+ 8653 8689 8707 8740 8767 15401 
+ 8611 8625 8700 8726 8765 8808 
+ 8664 8700 8711 8743 8745 15400 
+ 8665 8704 8737 8767 8773 15401 
+ 8671 8686 8697 8719 8729 8741 
+ 8633 8668 8679 8749 8759 8803 
+ 8669 8689 8694 8732 8740 8751 
+ 8664 8672 8706 8723 8745 8766 
+ 8673 8694 8702 8732 8736 8744 
+ 8675 8678 8714 8715 8748 8752 
+ 8674 8675 8713 8721 8752 8760 
+ 8678 8681 8713 8717 8748 8750 
+ 8680 8697 8729 8746 
+ 8681 8687 8715 8720 8747 8750 
+ 8592 8652 8661 8798 8837 8898 
+ 8686 8702 8708 8736 8741 8754 
+ 8687 8692 8717 8724 8747 8753 
+ 8674 8677 8714 8725 8760 8764 
+ 7346 7379 8108 10539 11037 11903 
+ 8672 8683 8711 8735 8766 8786 
+ 8692 8696 8720 8753 8757 15402 
+ 8677 8682 8721 8727 8764 8769 
+ 8611 8642 8705 8768 8808 8851 
+ 8682 8684 8725 8731 8769 8776 
+ 8420 8452 8676 8856 9658 9840 
+ 8697 8708 8716 8741 8746 8763 
+ 8649 8658 8756 8846 8853 15397 
+ 8684 8685 8727 8735 8776 8782 
+ 8694 8710 8712 8744 8751 8771 
+ 8564 8656 8662 8792 8838 8922 
+ 8634 8661 8698 8781 8798 8868 
+ 8683 8685 8723 8731 8782 8786 
+ 8702 8712 8719 8744 8754 8770 
+ 8665 8679 8707 8759 8773 8796 
+ 8580 8626 8691 8802 8867 8969 
+ 7609 7753 8118 8918 11034 11079 
+ 8689 8704 8710 8751 8767 8783 
+ 8708 8719 8729 8754 8763 8775 
+ 8100 8426 8935 9359 10199 
+ 8700 8706 8745 8765 8804 8810 
+ 8712 8732 8736 8770 8771 8791 
+ 8706 8711 8743 8766 8804 8820 
+ 8716 8729 8763 8785 
+ 8717 8720 8750 8753 8784 8788 
+ 8713 8715 8750 8752 8790 8797 
+ 8668 8698 8709 8781 8803 8872 8877 
+ 8715 8717 8747 8748 8788 8790 
+ 8710 8732 8740 8771 8783 8806 
+ 8713 8714 8748 8760 8797 8805 
+ 8720 8724 8747 8757 8784 8787 
+ 8719 8736 8741 8770 8775 8794 
+ 8539 8589 8693 8818 8999 9246 
+ 8658 8663 8730 8789 8853 8895 
+ 8724 8753 8761 8787 8795 15402 
+ 8585 8587 8762 8772 8976 9031 
+ 8679 8709 8737 8796 8803 8828 
+ 8714 8721 8752 8764 8805 8809 
+ 8757 8795 8801 15402 
+ 8587 8617 8758 8777 8939 8976 
+ 8729 8741 8746 8775 8785 8807 
+ 8721 8725 8760 8769 8809 8813 
+ 8700 8705 8743 8808 8810 8850 
+ 8711 8723 8745 8786 8820 8862 
+ 8704 8707 8740 8773 8783 8814 8834 
+ 8642 8695 8726 8847 8851 8912 
+ 8725 8727 8764 8776 8813 8819 
+ 8736 8744 8754 8791 8794 8811 
+ 8732 8744 8751 8791 8806 8815 
+ 8585 8598 8758 8800 9031 9078 
+ 8707 8737 8767 8796 8814 8817 
+ 8556 8670 8699 8799 8998 9101 
+ 8741 8754 8763 8794 8807 8812 
+ 8727 8731 8769 8782 8819 8832 
+ 8617 8656 8762 8792 8939 8949 
+ 8458 8517 8630 8942 9382 9994 
+ 8516 8624 8649 8846 9049 9129 
+ 8574 8652 8662 8837 8838 9039 9041 
+ 8698 8734 8749 8868 8872 8905 
+ 8731 8735 8776 8786 8832 8858 
+ 8740 8751 8767 8806 8830 8834 
+ 8747 8753 8787 8788 8824 15403 
+ 8746 8763 8807 8823 
+ 8723 8735 8766 8782 8858 8862 
+ 8753 8757 8784 8795 8822 15403 
+ 8747 8750 8784 8790 8824 8827 
+ 8663 8691 8756 8867 8895 9074 
+ 8748 8750 8788 8797 8827 8833 
+ 8744 8770 8771 8811 8815 8829 
+ 8656 8733 8777 8922 8949 
+ 8629 8655 8799 8821 9133 9170 
+ 8754 8770 8775 8811 8812 8826 
+ 8757 8761 8787 8801 8822 8825 
+ 8737 8759 8773 8817 8828 8848 
+ 8748 8752 8790 8805 8833 8839 
+ 8661 8718 8734 8868 8898 8982 
+ 8655 8670 8774 8793 9101 9133 
+ 8598 8615 8772 8821 9078 9090 
+ 8761 8795 8825 8831 
+ 8626 8695 8738 8847 8969 9008 
+ 8709 8749 8759 8828 8877 8886 
+ 8743 8745 8810 8820 8852 
+ 8752 8760 8797 8809 8839 8844 
+ 8751 8771 8783 8815 8830 8840 
+ 8763 8775 8785 8812 8823 8836 
+ 8705 8726 8765 8850 8851 8919 
+ 8760 8764 8805 8813 8844 8854 
+ 8743 8765 8804 8850 8852 8883 
+ 8770 8791 8794 8826 8829 8843 
+ 8775 8794 8807 8826 8836 8845 
+ 8764 8769 8809 8819 8854 8870 
+ 8767 8773 8817 8834 8849 8869 
+ 8771 8791 8806 8829 8840 8860 
+ 8417 8519 8521 9209 10106 10288 
+ 8773 8796 8814 8848 8849 8880 
+ 8573 8589 8755 8842 9246 9308 
+ 8769 8776 8813 8832 8870 8875 
+ 8745 8766 8804 8852 8862 8915 
+ 8615 8629 8793 8800 9090 9170 
+ 8787 8795 8825 8855 8857 15403 
+ 8785 8807 8836 15404 
+ 8784 8788 8827 8863 8871 15403 
+ 8795 8801 8822 8831 8855 8859 
+ 8794 8811 8812 8843 8845 8864 
+ 8788 8790 8824 8833 8871 8876 
+ 8759 8796 8803 8848 8886 8893 
+ 8791 8811 8815 8843 8860 8873 
+ 8783 8806 8834 8840 8866 8878 
+ 8801 8825 8859 8865 
+ 8776 8782 8819 8858 8875 8903 
+ 8790 8797 8827 8839 8876 8882 
+ 8767 8783 8814 8830 8869 8878 8887 
+ 8439 8586 8630 8927 9382 9947 
+ 8807 8812 8823 8845 8874 15404 
+ 8652 8718 8780 8898 9041 9098 
+ 8662 8733 8780 8922 9039 9163 
+ 8797 8805 8833 8844 8882 8889 
+ 8806 8815 8830 8860 8866 8879 
+ 8608 8693 8703 8990 8999 9437 
+ 8535 8573 8818 8861 9308 9364 
+ 8811 8826 8829 8864 8873 8884 
+ 8805 8809 8839 8854 8889 8904 
+ 8812 8826 8836 8864 8874 8885 
+ 8649 8730 8779 8853 9028 9049 9117 
+ 8695 8768 8802 8912 9008 9017 
+ 8796 8817 8828 8880 8893 8909 
+ 8814 8817 8869 8880 8891 
+ 8765 8808 8810 8883 8919 8962 
+ 8726 8768 8808 8912 8919 8984 
+ 8804 8810 8820 8883 8915 8943 
+ 8730 8756 8846 8895 9028 
+ 8809 8813 8844 8870 8904 8916 
+ 8822 8825 8857 8859 8890 8894 
+ 8420 8432 8688 8728 9604 9840 10227 
+ 8822 8855 8863 8894 8900 15403 
+ 8782 8786 8832 8862 8903 8975 
+ 8825 8831 8855 8865 8890 8892 
+ 8815 8829 8840 8873 8879 8901 15405 
+ 8535 8613 8842 8911 9364 9423 
+ 8766 8786 8820 8858 8915 8975 9012 
+ 8824 8857 8871 8900 8906 15403 
+ 8826 8843 8845 8884 8885 8902 
+ 8831 8859 8892 8897 
+ 8830 8840 8878 8879 8888 8899 
+ 8691 8738 8789 8969 9074 15437 
+ 8734 8781 8798 8905 8977 8982 
+ 8814 8834 8849 8887 8891 8917 
+ 8813 8819 8854 8875 8916 8930 
+ 8824 8827 8863 8876 8906 8910 
+ 8749 8781 8877 8905 8934 8967 8986 
+ 8829 8843 8860 8884 8907 15405 
+ 8836 8845 8885 8896 15404 15406 
+ 8819 8832 8870 8903 8930 8945 
+ 8827 8833 8871 8882 8910 8925 
+ 8749 8803 8872 8886 8934 8948 
+ 8830 8834 8866 8887 8899 8914 
+ 8840 8860 8866 8888 8901 8908 
+ 8817 8848 8849 8891 8909 8926 
+ 7528 7730 8472 11137 11227 
+ 8833 8839 8876 8889 8925 8946 
+ 8810 8850 8852 8943 8962 
+ 8843 8864 8873 8902 8907 8920 
+ 8845 8864 8874 8902 8921 15406 
+ 8803 8828 8877 8893 8948 8979 
+ 8834 8869 8878 8914 8917 8947 
+ 8866 8879 8899 8908 8913 
+ 8839 8844 8882 8904 8946 15408 
+ 8855 8859 8892 8894 8929 15407 
+ 8849 8869 8880 8917 8926 8953 
+ 8859 8865 8890 8897 8928 8929 
+ 8828 8848 8886 8909 8979 8988 
+ 8855 8857 8890 8900 8940 15407 
+ 8756 8789 8853 9028 9074 9274 
+ 8874 8937 15404 15406 
+ 8865 8892 8928 8933 
+ 8718 8798 8837 8982 9098 9167 
+ 8866 8878 8888 8913 8914 8931 
+ 8857 8863 8894 8906 8940 8951 
+ 8860 8879 8908 8923 8924 15405 
+ 8864 8884 8885 8920 8921 8938 
+ 8832 8858 8875 8945 8975 9011 
+ 8844 8854 8889 8916 8985 15408 
+ 8781 8868 8872 8967 8977 9021 
+ 8863 8871 8900 8910 8951 8957 
+ 8873 8884 8920 8932 8944 15405 
+ 8879 8888 8901 8913 8924 8936 
+ 8848 8880 8893 8926 8988 8989 
+ 8871 8876 8906 8925 8957 15410 
+ 8613 8699 8861 8998 9423 9524 
+ 8768 8847 8851 8984 9017 9068 
+ 8888 8899 8908 8931 8936 8954 
+ 8878 8887 8899 8931 8947 8955 
+ 8820 8852 8862 8943 9012 9050 
+ 8854 8870 8904 8930 8985 9019 
+ 8869 8887 8891 8947 8953 8972 
+ 7753 7852 8739 9066 10971 11034 
+ 8808 8850 8851 8962 8984 9146 15421 
+ 8884 8902 8907 8938 8944 8959 
+ 8885 8902 8938 8950 8960 15406 
+ 8733 8792 8838 8949 9163 9247 
+ 8901 8924 8932 8941 8952 15405 
+ 8901 8908 8923 8936 8941 8956 
+ 8876 8882 8910 8946 8997 15410 
+ 8880 8891 8909 8953 8989 9000 
+ 8586 8601 8835 9139 9947 10103 
+ 8892 8897 8929 8933 8963 8964 
+ 8890 8892 8928 8964 8970 15407 
+ 8870 8875 8916 8945 9010 9019 
+ 8899 8913 8914 8954 8955 8965 
+ 8907 8923 8944 8952 8958 15405 
+ 8897 8928 8963 8966 
+ 8872 8877 8948 8986 9003 
+ 7966 8100 8742 9066 10199 10889 
+ 8908 8913 8924 8954 8956 8968 
+ 8896 8950 8974 15406 
+ 8902 8920 8921 8959 8960 15409 
+ 8762 8777 8949 8976 9262 9458 
+ 8894 8900 8951 8978 8987 15407 
+ 8923 8924 8952 8956 8961 
+ 8517 8534 8778 9424 9994 10403 
+ 8852 8883 8915 8962 9050 15418 
+ 8907 8920 8932 8958 8959 8971 
+ 8875 8903 8930 9010 9011 
+ 8882 8889 8925 8997 9026 15408 
+ 8887 8914 8917 8955 8972 8983 9007 
+ 8877 8886 8934 8979 9003 9024 
+ 8777 8792 8922 8939 9247 9262 
+ 8921 8937 8960 8974 8981 15406 
+ 8900 8906 8940 8957 8987 9001 
+ 8923 8932 8941 8958 8961 8973 
+ 8891 8917 8926 8972 9000 9018 
+ 8913 8931 8936 8965 8968 8992 
+ 8914 8931 8947 8965 8983 
+ 8924 8936 8941 8961 8968 8980 
+ 8906 8910 8951 9001 9023 15410 
+ 8932 8944 8952 8971 8973 15411 
+ 8920 8938 8944 8971 8991 15409 
+ 8921 8938 8950 8981 15409 15412 
+ 8941 8952 8956 8973 8980 8993 
+ 8850 8883 8919 8943 15418 15421 
+ 8928 8933 8964 8966 8994 8996 
+ 8928 8929 8963 8970 8996 9004 
+ 8931 8954 8955 8983 8992 9016 
+ 8933 8963 8994 8995 
+ 8872 8905 8986 9021 9035 9079 
+ 8936 8954 8956 8980 8992 9005 
+ 8738 8802 8867 9008 9325 15437 
+ 8929 8964 8978 9004 9014 15407 
+ 8944 8958 8959 8991 9002 15411 
+ 8917 8947 8953 9007 9018 9047 
+ 8952 8958 8961 8993 9006 15411 
+ 8937 8950 8981 9009 
+ 8858 8862 8903 9011 9012 9137 15424 
+ 8758 8762 8939 9031 9458 9584 
+ 8868 8905 8982 9021 9057 9124 
+ 8940 8970 8987 9014 9034 15407 
+ 8886 8893 8948 8988 9024 9054 9084 
+ 8956 8961 8968 8993 9005 9015 
+ 8950 8960 8974 9009 9022 15412 
+ 8798 8868 8898 8977 9124 9167 9188 
+ 8947 8955 8965 9007 9016 9043 
+ 8851 8912 8919 9068 9146 9226 
+ 8904 8916 9019 9063 9123 15408 
+ 8872 8934 8967 9003 9035 9065 
+ 8940 8951 8978 9001 9034 9048 
+ 8893 8909 8979 8989 9038 9044 9054 
+ 8909 8926 8988 9000 9038 15413 
+ 8676 8703 8841 9437 9658 9934 
+ 8959 8971 9002 9013 9033 15409 
+ 8954 8965 8968 9005 9016 9040 
+ 8961 8973 8980 9006 9015 9029 
+ 8963 8966 8995 8996 9025 9030 
+ 8966 8994 9025 9027 
+ 8963 8964 8994 9004 9030 9036 
+ 8925 8946 9026 9081 15410 15414 
+ 8699 8774 8911 9101 9524 9748 
+ 8693 8755 8841 9246 9437 9979 
+ 8926 8953 8989 9018 9061 15413 
+ 8951 8957 8987 9023 9048 9073 
+ 8971 8991 9020 9032 9033 15411 
+ 8934 8948 8986 9024 9065 9119 
+ 8964 8970 8996 9014 9036 9052 
+ 8968 8980 8992 9015 9040 9042 
+ 8973 8993 9020 9029 9037 15411 
+ 8947 8972 8983 9043 9047 9088 
+ 8802 8847 8969 9017 9294 9325 
+ 8974 8981 9022 9045 
+ 8930 8945 9011 9019 9134 9158 
+ 8903 8945 8975 9010 9134 15424 
+ 8862 8915 8975 9050 9137 9198 
+ 8991 9033 9053 9058 15409 15412 
+ 8970 8978 9004 9034 9052 9069 
+ 8980 8993 9005 9029 9042 9055 
+ 8965 8983 8992 9040 9043 9067 
+ 8847 8912 9008 9068 9294 9367 
+ 8953 8972 9000 9047 9061 15417 
+ 8916 8930 8985 9010 9123 9158 
+ 9002 9006 9032 9037 9051 15411 
+ 8905 8967 8977 9057 9079 9112 
+ 8981 9009 9045 9059 9072 15412 
+ 8957 9001 9073 9099 15410 15414 
+ 8948 8979 9003 9084 9109 9119 
+ 8994 8995 9027 9030 9046 9056 
+ 8946 8997 9063 9081 15408 15423 
+ 8995 9025 9045 9046 
+ 8846 8853 8895 9117 9274 15451 
+ 8993 9006 9015 9037 9055 9062 
+ 8994 8996 9025 9036 9056 9064 
+ 8758 8772 8976 9078 9543 9584 
+ 9002 9020 9033 9051 9060 
+ 8991 9002 9013 9032 9053 9060 9070 
+ 8978 8987 9014 9048 9069 9096 
+ 8967 8986 9065 9079 9114 
+ 8996 9004 9030 9052 9064 9082 
+ 9006 9020 9029 9051 9062 9071 
+ 8988 8989 9044 9075 9077 15413 
+ 8780 8838 9041 9163 9255 9389 9472 
+ 8992 9005 9016 9042 9067 9083 9087 
+ 8780 8837 9039 9098 9255 9316 
+ 9005 9015 9040 9055 9083 9085 
+ 8983 9007 9016 9067 9088 9097 
+ 8988 9038 9054 9075 9106 
+ 9009 9022 9027 9046 9072 15415 
+ 9025 9027 9045 9056 9076 15415 
+ 8972 9007 9018 9088 9116 15417 
+ 8987 9001 9034 9073 9096 15425 
+ 8779 8846 9117 9129 9550 9661 
+ 8915 8943 9012 9198 9236 15418 
+ 9020 9032 9037 9060 9071 15416 
+ 9004 9014 9036 9069 9082 15419 
+ 9013 9033 9058 9070 9080 
+ 8979 8988 9044 9084 9106 9155 
+ 9015 9029 9042 9062 9085 9092 
+ 9025 9030 9046 9064 9076 9086 
+ 8977 9021 9112 9124 9130 
+ 9013 9053 9059 9080 9089 15412 
+ 9022 9058 9072 9089 9094 15412 
+ 9032 9033 9051 9070 9091 15416 
+ 9000 9018 9093 9113 15413 15417 
+ 9029 9037 9055 9071 9092 9095 
+ 8985 9026 9123 9182 15408 15423 
+ 9030 9036 9056 9082 9086 9103 
+ 8986 9003 9035 9114 9119 9166 
+ 7852 7966 8918 8935 10889 10971 
+ 9016 9040 9043 9087 9097 9102 
+ 8912 8984 9017 9226 9367 
+ 9014 9034 9052 9096 9141 15419 
+ 9033 9053 9060 9080 9091 9100 
+ 9037 9051 9062 9095 9104 15416 
+ 9022 9045 9059 9094 9105 15415 
+ 9001 9023 9048 9099 9160 15425 
+ 8789 8867 8895 9274 15437 15475 
+ 9038 9044 9077 9106 9132 9136 
+ 9046 9056 9086 9107 9108 15415 
+ 9038 9075 9093 9132 9143 15413 
+ 8772 8800 9031 9090 9543 9649 
+ 8967 9021 9035 9112 9114 9195 
+ 9053 9058 9070 9089 9100 9111 
+ 8997 9026 9128 9156 15414 15423 
+ 9036 9052 9064 9103 9126 15419 
+ 9040 9042 9085 9087 9110 15420 
+ 8979 9024 9054 9109 9155 9179 
+ 9042 9055 9083 9092 9110 9118 
+ 9056 9064 9076 9103 9107 9121 
+ 9040 9067 9083 9102 9120 15420 
+ 9007 9043 9047 9097 9116 9154 9165 
+ 9058 9059 9080 9094 9111 9122 
+ 8800 8821 9078 9170 9649 9731 
+ 9060 9070 9100 9115 9127 15416 
+ 9055 9062 9085 9095 9118 9125 
+ 9061 9077 9113 9143 9161 15413 
+ 9059 9072 9089 9105 9122 9138 
+ 9062 9071 9092 9104 9125 9135 
+ 9034 9048 9069 9141 9184 15425 
+ 9043 9067 9088 9102 9140 9154 
+ 8837 8898 9041 9167 9316 9433 
+ 9023 9073 9128 9160 9190 15414 
+ 9070 9080 9091 9111 9127 9144 
+ 8774 8799 8998 9133 9748 9970 
+ 9067 9087 9097 9120 9140 9147 
+ 9064 9082 9086 9121 9126 9145 
+ 9071 9095 9115 9135 9148 15416 
+ 9072 9094 9108 9138 9151 15415 
+ 9044 9054 9075 9136 9155 9174 
+ 9076 9086 9108 9121 9153 15427 
+ 9076 9105 9107 9151 15415 15427 
+ 9024 9084 9119 9179 9183 
+ 9083 9085 9118 9131 9142 15420 
+ 9080 9089 9100 9122 9144 9152 
+ 9021 9057 9079 9130 9195 9220 
+ 9061 9093 9149 9161 9192 15417 
+ 9035 9065 9079 9166 9195 9228 
+ 9091 9104 9127 9148 9159 15416 
+ 9047 9088 9149 9165 9185 15417 
+ 8846 9028 9049 9550 15451 
+ 9085 9092 9110 9125 9142 9157 
+ 9003 9024 9065 9109 9166 9183 9231 
+ 9087 9102 9147 9150 15420 
+ 9086 9103 9107 9145 9153 
+ 9089 9094 9111 9138 9152 15426 
+ 8985 9019 9063 9158 9182 9269 9273 
+ 8977 8982 9057 9130 9188 9234 9250 
+ 9092 9095 9118 9135 9157 9169 
+ 9082 9103 9145 9164 9172 15419 
+ 9091 9100 9115 9144 9159 9171 
+ 9081 9099 9156 9190 9208 15414 
+ 8624 8779 9049 9162 9661 9964 
+ 9057 9112 9124 9220 9234 
+ 9110 9142 9150 9168 15420 
+ 9075 9077 9136 9143 9187 9191 
+ 8793 8799 9101 9170 9809 9970 
+ 9010 9011 9158 9289 9301 15424 
+ 9095 9104 9125 9148 9169 9175 
+ 9075 9106 9132 9174 9191 
+ 8975 9012 9198 9280 9312 15424 
+ 9094 9105 9122 9151 9176 15426 
+ 8601 8688 8927 9604 10103 10240 
+ 9097 9102 9147 9154 9173 9181 
+ 9069 9096 9164 9184 9221 15419 
+ 9110 9118 9131 9157 9168 9180 
+ 9077 9093 9132 9161 9187 9201 
+ 9100 9111 9127 9152 9171 9178 
+ 9103 9121 9126 9153 9172 9177 
+ 8919 8984 9226 9352 9468 15421 
+ 9102 9120 9140 9150 9173 9189 
+ 9104 9115 9135 9159 9175 9186 
+ 9113 9116 9185 9192 9217 15417 
+ 9120 9131 9147 9168 9189 9200 15420 
+ 9105 9108 9138 9176 9193 15427 
+ 9111 9122 9144 9178 9196 15426 
+ 9107 9121 9145 9177 9194 15427 
+ 9088 9097 9140 9165 9181 9202 
+ 9054 9084 9106 9174 9179 9229 9238 
+ 9081 9128 9208 9213 15423 
+ 9118 9125 9142 9169 9180 9197 
+ 9010 9019 9123 9134 9273 9301 
+ 9115 9127 9148 9171 9186 9199 
+ 9073 9099 9190 9214 9257 15425 
+ 9093 9113 9143 9192 9201 9223 
+ 8624 8690 9129 9209 9964 10325 
+ 8838 8922 9039 9247 9472 9605 
+ 9126 9141 9172 9221 9227 15419 
+ 9088 9116 9154 9185 9202 9225 
+ 9065 9114 9119 9228 9231 9264 
+ 8898 8982 9098 9188 9321 9368 9433 
+ 9131 9142 9150 9180 9200 9207 
+ 9125 9135 9157 9175 9197 9203 
+ 8793 8821 9090 9133 9731 9809 
+ 9127 9144 9159 9178 9199 9206 
+ 9126 9145 9164 9177 9215 9227 
+ 9140 9147 9181 9189 9219 
+ 9106 9136 9155 9191 9229 9232 
+ 9135 9148 9169 9186 9203 9210 
+ 9138 9151 9193 9204 9211 15426 
+ 9145 9153 9172 9194 9212 9215 
+ 9144 9152 9171 9196 9206 9216 
+ 9084 9109 9155 9183 9238 9261 
+ 9142 9157 9168 9197 9207 15428 
+ 9140 9154 9173 9202 9219 9243 
+ 9063 9123 9213 9269 15423 15435 
+ 9109 9119 9179 9231 9261 9275 
+ 9096 9141 9214 9221 9279 15425 
+ 9116 9149 9165 9217 9225 9235 
+ 9148 9159 9175 9199 9210 15429 
+ 9132 9143 9191 9201 9218 9222 
+ 8982 9124 9167 9250 9310 9321 
+ 9147 9150 9173 9200 9219 9239 
+ 9099 9128 9160 9208 9257 9298 
+ 9132 9136 9174 9187 9222 9232 
+ 9113 9149 9161 9217 9223 9260 
+ 9151 9176 9205 9211 15427 15430 
+ 9153 9177 9205 9212 9224 15427 
+ 9079 9112 9114 9220 9228 9346 9347 
+ 9152 9178 9204 9216 15426 15431 
+ 9157 9169 9180 9203 9230 15428 
+ 9012 9050 9137 9236 9312 9366 
+ 9159 9171 9186 9206 9233 15429 
+ 9150 9168 9189 9207 9237 9239 
+ 9143 9161 9187 9218 9223 9242 
+ 9154 9165 9181 9225 9243 9256 
+ 9169 9175 9197 9210 9230 15432 
+ 9176 9196 9211 9240 15426 15431 
+ 9193 9194 9224 9241 15427 15430 
+ 9171 9178 9199 9216 9233 9244 
+ 9168 9180 9200 9237 9245 15428 
+ 9128 9156 9190 9213 9298 15439 
+ 8521 8690 8816 9162 10288 10325 
+ 9175 9186 9203 9249 15429 15432 
+ 9176 9193 9204 9240 9248 15430 
+ 9177 9194 9215 9224 9252 
+ 9156 9182 9208 15423 15435 15439 
+ 9160 9184 9257 9279 9340 15425 
+ 9172 9177 9212 9227 9252 9290 
+ 9178 9196 9206 9244 9253 15431 
+ 9149 9185 9192 9235 9260 9284 
+ 9187 9201 9222 9242 9254 
+ 9173 9181 9189 9239 9243 9266 9268 
+ 9112 9130 9195 9234 9342 9346 
+ 9141 9164 9184 9227 9279 9319 
+ 9187 9191 9218 9232 9254 9265 
+ 9161 9192 9201 9242 9260 9270 
+ 9194 9205 9212 9241 9252 
+ 9165 9185 9202 9235 9256 9277 
+ 8984 9068 9146 9367 9468 9680 
+ 9164 9172 9215 9221 9290 9319 
+ 9114 9166 9195 9264 9333 9347 
+ 9155 9174 9232 9238 9297 9307 
+ 9197 9203 9251 9263 15428 15432 
+ 9119 9166 9183 9264 9275 9309 
+ 9174 9191 9222 9229 9265 9307 
+ 9199 9206 9244 9259 9271 15429 
+ 9124 9130 9220 9250 9339 9342 
+ 9185 9217 9225 9277 9284 
+ 9050 9198 9287 9366 15418 15455 
+ 9200 9207 9239 9245 9267 9272 
+ 9155 9179 9229 9261 9297 9327 
+ 9189 9200 9219 9237 9266 9267 
+ 9204 9211 9248 15431 15433 15434 
+ 9205 9224 9252 9258 9278 15430 
+ 9201 9218 9223 9254 9270 9288 
+ 9181 9202 9219 9256 9268 9295 
+ 9206 9216 9233 9253 9271 9282 
+ 9207 9237 9251 9272 9281 15428 
+ 8755 8818 8999 9308 9979 10207 
+ 8922 8949 9163 9262 9605 9692 
+ 9211 9240 9258 9283 15430 15434 
+ 9210 9259 9276 9286 15429 15432 
+ 9124 9188 9234 9310 9339 9358 
+ 9230 9245 9263 9281 9291 15428 
+ 9212 9215 9224 9241 9278 9290 9311 
+ 9216 9244 9282 9292 15431 15433 
+ 9218 9222 9242 9265 9288 9328 
+ 9039 9041 9316 9389 9517 
+ 9202 9225 9243 9277 9295 15436 
+ 9160 9190 9214 9298 9340 15448 
+ 9241 9248 9278 9283 9293 15430 
+ 9233 9249 9271 9286 9299 15429 
+ 9192 9217 9223 9270 9284 9320 9329 
+ 9179 9183 9238 9275 9327 9365 9374 9377 
+ 8939 8949 9247 9458 9692 9974 
+ 9230 9251 9276 9291 9304 15432 
+ 9166 9228 9231 9309 9333 15441 
+ 9222 9232 9254 9307 9328 9338 
+ 9219 9239 9267 9268 9285 9300 
+ 9237 9239 9266 9272 9300 9303 
+ 9219 9243 9266 9285 9295 9302 
+ 9123 9182 9273 15435 15446 15457 
+ 9223 9242 9260 9288 9313 9320 
+ 9233 9244 9259 9282 9299 9314 
+ 9237 9245 9267 9281 9303 9315 
+ 9123 9158 9269 9301 9411 15446 
+ 8895 9028 9074 9885 15451 15475 
+ 9183 9231 9261 9309 9365 9371 
+ 9249 9263 9286 9304 9317 15432 
+ 9225 9235 9256 9284 9349 15436 
+ 9241 9252 9258 9293 9311 9322 
+ 9184 9214 9221 9319 9340 9387 
+ 9137 9289 9312 9452 9482 15424 
+ 9245 9251 9272 9291 9315 9323 
+ 9244 9253 9271 9292 9314 9324 
+ 9248 9258 9293 9318 15434 15438 
+ 9217 9235 9260 9277 9329 9349 9351 
+ 9266 9268 9300 9302 9326 
+ 9249 9259 9276 9299 9317 9330 
+ 9236 9352 9533 15418 15421 15455 
+ 9242 9254 9270 9313 9328 9335 
+ 9134 9280 9301 9478 9482 15424 
+ 9215 9227 9252 9311 9319 9344 9369 
+ 9251 9263 9281 9304 9323 9332 
+ 9253 9282 9306 9324 9334 15433 
+ 9258 9278 9283 9322 15438 
+ 9008 9017 9325 9367 9640 9698 
+ 9243 9256 9268 9302 9343 9354 15436 
+ 8643 8701 9359 9719 10573 10666 
+ 9229 9238 9307 9327 9362 9375 
+ 9190 9208 9257 9510 15439 15448 
+ 9259 9271 9286 9314 9330 9337 
+ 9266 9267 9285 9303 9326 9331 
+ 9134 9158 9273 9289 9411 9478 
+ 9268 9285 9295 9326 9336 9343 
+ 9267 9272 9300 9315 9331 15440 
+ 9263 9276 9291 9317 9332 9341 
+ 7963 8177 8358 10865 10946 11175 15422 
+ 9292 9318 9334 9348 15433 15434 
+ 9229 9232 9265 9297 9338 9362 15444 
+ 8818 8842 9246 9364 9835 10207 
+ 9231 9264 9275 9370 9371 15441 
+ 9188 9250 9321 9358 9401 
+ 9252 9278 9290 9322 9344 15443 
+ 9137 9198 9280 9366 9452 9538 
+ 9270 9288 9320 9335 9345 
+ 9271 9282 9299 9324 9337 9350 
+ 9272 9281 9303 9323 15440 15442 
+ 9041 9098 9255 9433 9517 9656 
+ 9276 9286 9304 9330 9341 9353 
+ 9283 9306 9348 9355 15434 15438 
+ 9221 9227 9279 9290 9369 9387 15450 
+ 9260 9270 9313 9329 9345 9357 
+ 9167 9188 9310 9368 9401 9408 
+ 9278 9293 9311 9360 15438 15443 
+ 9281 9291 9315 9332 9361 15442 
+ 9282 9292 9314 9334 9350 9363 
+ 8969 9008 9294 9640 9761 15437 
+ 9285 9300 9302 9331 9336 9356 
+ 9238 9261 9297 9374 9375 9395 
+ 9254 9265 9288 9335 9338 9383 9388 
+ 9260 9284 9320 9351 9357 15445 
+ 9286 9299 9317 9337 9353 9373 
+ 9300 9303 9326 9356 9372 15440 
+ 9291 9304 9323 9341 9361 9376 
+ 9228 9264 9347 9404 15441 15452 
+ 9292 9306 9324 9348 9363 9381 
+ 9288 9313 9328 9345 9383 9386 
+ 9302 9326 9343 9356 9380 
+ 9299 9314 9330 9350 9373 9385 
+ 9265 9307 9328 9388 9400 15444 
+ 9234 9250 9342 9358 9457 9466 
+ 9214 9257 9279 9387 9462 15448 
+ 9304 9317 9332 9353 9376 9390 
+ 9220 9234 9339 9346 9457 9487 
+ 9295 9302 9336 9354 9380 9396 
+ 9290 9311 9369 9402 15443 
+ 9313 9320 9335 9357 9379 9386 
+ 9195 9220 9342 9347 9421 9487 9488 
+ 9195 9228 9333 9346 9421 15452 
+ 9306 9318 9334 9355 9381 9394 
+ 9277 9284 9351 9378 9399 9413 15436 
+ 9314 9324 9337 9363 9385 9393 
+ 9284 9329 9349 9399 9405 15445 
+ 9146 9287 9468 9533 15421 15474 
+ 9317 9330 9341 9373 9390 9398 
+ 9295 9343 9378 9396 9416 15436 
+ 9318 9348 9360 9394 9403 15438 
+ 9326 9331 9336 9372 9380 9392 
+ 9320 9329 9345 9379 9397 15445 
+ 9250 9310 9339 9401 9466 9484 
+ 8426 8701 8742 9296 10199 10666 
+ 9322 9355 9403 9409 15438 15443 
+ 9323 9332 9376 9391 15442 15447 
+ 9297 9307 9375 9419 15444 15449 
+ 9324 9334 9350 9381 9393 9406 
+ 8842 8861 9308 9423 9835 9941 
+ 9261 9275 9371 9377 9414 9428 
+ 9198 9236 9312 9538 9612 15455 
+ 9017 9068 9226 9294 9680 9698 9863 
+ 9167 9321 9408 9433 9586 9632 
+ 9290 9319 9344 9402 9465 15450 
+ 9309 9371 9415 9427 15441 
+ 9275 9309 9365 9370 9427 9428 
+ 9331 9356 9384 9392 9407 15440 
+ 9330 9337 9353 9385 9398 9410 
+ 9261 9327 9377 9395 9420 9426 
+ 9297 9327 9362 9395 9419 9431 
+ 9332 9341 9361 9390 9417 15447 
+ 9261 9365 9374 9414 9426 
+ 9349 9354 9413 9416 9436 15436 
+ 9345 9357 9386 9397 9412 
+ 9336 9343 9356 9392 9396 9418 
+ 9334 9348 9363 9394 9406 15454 
+ 8630 8778 8835 9947 9994 10462 
+ 9328 9335 9386 9388 9422 9430 
+ 9372 9391 9407 9425 15440 15442 
+ 9337 9350 9373 9393 9410 9429 
+ 9335 9345 9379 9383 9412 9422 
+ 9279 9319 9340 9462 15450 15462 
+ 9328 9338 9383 9400 9430 9439 
+ 9039 9255 9472 9517 9671 
+ 9341 9353 9376 9398 9417 9432 
+ 9361 9384 9425 9434 15442 15447 
+ 9356 9372 9380 9407 9418 9440 
+ 9350 9363 9385 9406 9429 15456 
+ 9348 9355 9381 9403 9444 15454 
+ 9327 9374 9375 9420 9431 9442 
+ 9343 9354 9380 9416 9418 9453 
+ 9357 9379 9412 9438 15445 15453 
+ 9353 9373 9390 9410 9432 9441 
+ 9349 9351 9405 9413 9445 9450 
+ 9338 9388 9435 9439 9456 15444 
+ 9310 9321 9358 9408 9484 9512 
+ 9344 9369 9409 9465 9469 15443 
+ 9355 9360 9394 9409 9444 9463 
+ 9333 9415 9479 9494 15441 15452 
+ 9351 9399 9445 9449 15445 15453 
+ 9363 9381 9393 15454 15456 15458 
+ 9372 9384 9392 9425 9440 9447 
+ 9321 9368 9401 9512 9586 
+ 9360 9402 9403 9463 9469 15443 
+ 9373 9385 9398 9429 9441 9451 
+ 9273 9301 9478 9534 15446 15473 
+ 9379 9386 9397 9422 9438 9446 
+ 9349 9378 9399 9436 9450 9470 
+ 9365 9377 9426 9428 9454 9501 
+ 9370 9404 9427 9479 9480 15441 
+ 9354 9378 9396 9436 9453 9459 
+ 9376 9390 9432 9443 9455 15447 
+ 9380 9392 9396 9440 9453 9471 
+ 9362 9375 9431 9461 15449 15459 
+ 9374 9395 9426 9442 9448 
+ 9346 9347 9488 9502 15452 
+ 9383 9386 9412 9430 9446 9460 
+ 8861 8911 9364 9524 9941 9988 
+ 8534 8645 8942 9719 10403 10548 
+ 9384 9391 9407 9434 9447 9464 
+ 9374 9377 9414 9420 9448 9454 
+ 9370 9371 9415 9428 9480 9490 
+ 9365 9371 9414 9427 9490 9501 
+ 9385 9393 9410 9451 9475 15456 
+ 9383 9388 9422 9439 9460 9477 
+ 9375 9395 9419 9442 9476 15459 
+ 9390 9398 9417 9441 9455 9473 
+ 9098 9167 9316 9368 9632 9656 9815 
+ 9391 9425 9443 9464 9481 15447 
+ 9400 9456 9474 9492 15444 15449 
+ 9378 9413 9416 9459 9470 9493 
+ 8841 8990 8999 9934 9979 10343 
+ 9397 9412 9446 9467 9483 15453 
+ 9388 9400 9430 9456 9477 9495 
+ 9392 9407 9418 9447 9471 9489 
+ 9398 9410 9432 9451 9473 9485 
+ 9395 9420 9431 9448 9476 9486 
+ 9417 9434 9455 9481 15447 15461 
+ 9394 9403 9463 15454 15460 15464 
+ 9399 9405 9449 9450 9496 9500 
+ 9412 9422 9438 9460 9483 9498 
+ 9407 9425 9440 9464 9489 9503 
+ 9420 9426 9442 9454 9486 9499 
+ 9405 9445 9467 9496 9504 15453 
+ 9399 9413 9445 9470 9500 9509 
+ 9410 9429 9441 9475 9485 9507 
+ 9280 9312 9482 9538 9645 
+ 9396 9416 9418 9459 9471 9511 9518 
+ 9414 9426 9448 9499 9501 9525 
+ 9417 9432 9443 9473 9506 15461 
+ 9400 9435 9439 9492 9495 9520 
+ 9339 9342 9466 9487 9595 9615 
+ 8939 8976 9262 9584 9917 9974 
+ 9416 9436 9453 9493 9518 9521 
+ 9422 9430 9446 9477 9498 15463 
+ 9419 9474 9505 9515 15449 15459 
+ 9340 9387 9581 9597 15448 15462 
+ 9403 9409 9444 9469 9545 15464 
+ 9425 9434 9447 9481 9503 9516 
+ 9369 9402 9469 9568 9569 15450 
+ 9339 9358 9457 9484 9595 9600 
+ 9438 9449 9483 9504 9514 15453 
+ 9146 9226 9352 9680 15474 15480 
+ 9402 9409 9463 9465 9545 9569 
+ 9413 9436 9450 9493 9509 9523 
+ 9418 9440 9453 9489 9511 9522 
+ 9039 9163 9389 9605 9671 9824 
+ 9432 9441 9455 9485 9506 9513 
+ 9435 9461 9492 9515 9531 15449 
+ 9429 9451 9491 9507 9532 15456 
+ 9431 9442 9486 9497 9519 15459 
+ 9430 9439 9460 9495 9528 15463 
+ 9289 9301 9411 9482 9676 15473 
+ 9404 9415 9480 9494 9553 9572 
+ 9415 9427 9479 9490 9548 9553 
+ 9434 9443 9464 9516 9526 15461 
+ 9280 9289 9452 9478 9645 9676 9742 
+ 9438 9446 9467 9498 9514 9527 
+ 9358 9401 9466 9512 9600 9623 
+ 9441 9451 9473 9507 9513 9529 
+ 9442 9448 9476 9499 9519 9536 
+ 9342 9346 9457 9488 9614 9615 9663 
+ 9346 9421 9487 9502 9582 9614 
+ 9440 9447 9471 9503 9522 9535 
+ 9427 9428 9480 9501 9548 9559 
+ 9475 9508 9532 9546 15456 15458 
+ 9435 9456 9474 9520 9531 9554 
+ 9436 9459 9470 9521 9523 9547 
+ 9404 9479 9502 9572 9587 15452 
+ 9439 9456 9477 9520 9528 9551 
+ 9445 9449 9500 9504 9537 9540 
+ 9476 9505 9519 9539 15459 
+ 9446 9460 9483 9527 9542 15463 
+ 9448 9454 9486 9525 9536 9565 
+ 9445 9450 9496 9509 9537 9541 
+ 9414 9428 9454 9490 9525 9559 9575 
+ 9421 9488 9494 9582 9587 15452 
+ 9447 9464 9489 9516 9535 9556 
+ 9449 9467 9496 9514 9540 9549 
+ 9461 9497 9515 9539 9557 15459 
+ 9455 9473 9513 9544 9561 15461 
+ 9451 9475 9485 9529 9532 9566 
+ 9491 9546 9570 15458 15460 15465 
+ 9450 9470 9500 9523 9541 9558 
+ 9298 9552 9581 9697 9714 15439 15448 
+ 9453 9471 9518 9522 9555 9562 
+ 9401 9408 9484 9586 9623 9666 
+ 9473 9485 9506 9529 9560 9561 
+ 9467 9483 9504 9527 9549 9563 
+ 9461 9474 9505 9531 9557 9573 
+ 9464 9481 9503 9526 9556 9567 
+ 9255 9316 9389 9656 9671 9822 
+ 9453 9459 9511 9521 9555 9574 
+ 9476 9486 9497 9536 9539 9571 
+ 9456 9492 9495 9551 9554 9579 
+ 9459 9493 9518 9547 9574 9580 
+ 9471 9489 9511 9535 9562 9576 
+ 9470 9493 9509 9547 9558 9578 
+ 8911 8998 9423 9748 9988 9999 
+ 9454 9499 9501 9565 9575 9593 
+ 9481 9516 9544 9567 15461 15468 
+ 9483 9498 9514 9542 9563 9577 
+ 9477 9495 9551 9564 9583 15463 
+ 9485 9507 9513 9560 9566 15466 
+ 7608 8108 8358 10946 11037 11492 
+ 9474 9492 9515 9554 9573 9588 
+ 9475 9491 9507 9546 9566 9585 
+ 9287 9352 9744 15455 15474 15478 
+ 9411 9727 15446 15457 15473 15476 
+ 9489 9503 9522 9556 9576 15467 
+ 9486 9499 9519 9565 9571 9592 
+ 9496 9500 9540 9541 
+ 9312 9366 9452 9612 9645 9702 
+ 9497 9505 9519 9557 9571 9589 
+ 9496 9504 9537 9549 
+ 9500 9509 9537 9558 
+ 9498 9527 9564 9577 9591 15463 
+ 9031 9078 9584 9649 9922 10049 
+ 9506 9526 9561 9619 15461 15468 
+ 9463 9469 9569 9599 9637 9659 15464 
+ 9491 9508 9532 9570 9585 9603 
+ 9493 9521 9523 9578 9580 9596 
+ 9480 9490 9553 9559 9610 9611 
+ 9504 9514 9540 9563 
+ 9049 9117 9661 10042 10046 15451 
+ 9495 9520 9528 9579 9583 9601 
+ 9510 9714 9755 15435 15439 15457 15476 
+ 9479 9480 9548 9572 9611 9622 
+ 9492 9520 9531 9579 9588 15469 
+ 9511 9518 9562 9574 9590 9594 
+ 9503 9516 9535 9567 9607 15467 
+ 9505 9515 9539 9573 9589 9602 
+ 9509 9523 9541 9578 
+ 9490 9501 9548 9575 9610 9617 
+ 9513 9529 9561 9613 15466 
+ 9506 9513 9544 9560 9613 9619 
+ 9511 9522 9555 9576 9594 9608 
+ 9514 9527 9549 9577 
+ 9528 9542 9583 9591 9606 15463 
+ 9499 9525 9536 9592 9593 9620 
+ 9507 9529 9532 9585 9598 15466 
+ 9516 9526 9556 9607 15468 
+ 9465 9569 9644 9650 15450 15462 15472 
+ 9465 9469 9545 9568 9637 9650 
+ 9508 9546 9603 15465 15470 
+ 9519 9536 9539 9589 9592 9616 
+ 9479 9494 9553 9587 9622 9652 
+ 9515 9531 9557 9588 9602 9618 
+ 9518 9521 9555 9580 9590 9609 
+ 9501 9525 9559 9593 9617 9627 
+ 9522 9535 9562 9608 9621 15467 
+ 9527 9542 9563 9591 
+ 9523 9547 9558 9596 
+ 9520 9551 9554 9601 9625 15469 
+ 9521 9547 9574 9596 9609 15471 
+ 9462 9510 9597 9684 9697 15448 
+ 9488 9502 9587 9614 9646 9667 
+ 9528 9551 9564 9601 9606 9624 
+ 8976 9031 9458 9543 9917 9922 10108 
+ 9532 9546 9566 9598 9603 9628 
+ 9368 9408 9512 9632 9666 9715 
+ 9494 9502 9572 9582 9646 9652 
+ 9531 9554 9573 9618 9631 15469 
+ 9539 9557 9571 9602 9616 9630 
+ 9555 9574 9594 9609 9626 
+ 9542 9564 9577 9606 
+ 9536 9565 9571 9616 9620 9636 
+ 9525 9565 9575 9620 9627 9641 
+ 9555 9562 9590 9608 9626 9633 
+ 9457 9466 9600 9615 9678 9688 
+ 9547 9578 9580 15471 
+ 9462 9581 9684 9686 15462 15472 
+ 9566 9585 9628 9629 15466 
+ 9545 9659 15464 15465 15470 15477 
+ 9466 9484 9595 9623 9678 9696 
+ 9551 9579 9583 9624 9625 9638 
+ 9557 9573 9589 9618 9630 9639 
+ 9546 9570 9585 9628 9654 15470 
+ 8688 8856 9139 10227 10240 10518 
+ 9163 9247 9472 9692 9824 9951 
+ 9564 9583 9591 9624 
+ 9556 9567 9647 9651 9675 15467 15468 
+ 9562 9576 9594 9621 9633 9643 
+ 9574 9580 9590 9626 9635 15471 
+ 9548 9559 9611 9617 9634 9648 
+ 9548 9553 9610 9622 9634 9657 
+ 9366 9538 9702 9771 15455 15478 
+ 9560 9561 9619 9629 9668 15466 
+ 9487 9488 9582 9663 9667 9703 
+ 9457 9487 9595 9663 9688 9712 
+ 9571 9589 9592 9630 9636 9653 
+ 9559 9575 9610 9627 9648 9664 
+ 9573 9588 9602 9631 9639 9655 
+ 9544 9561 9613 9651 9668 9707 15468 
+ 9565 9592 9593 9636 9641 9665 
+ 9576 9608 9643 9647 9672 15467 
+ 9553 9572 9611 9652 9657 9681 
+ 9484 9512 9600 9666 9696 9721 
+ 9583 9601 9606 9638 
+ 9579 9601 9638 9642 9660 15469 
+ 9590 9594 9609 9633 9635 9662 
+ 9575 9593 9617 9641 9664 9674 
+ 9585 9598 9603 9629 9654 9689 9701 
+ 9598 9613 9628 9668 9689 15466 
+ 9589 9602 9616 9639 9653 9669 
+ 9588 9618 9642 9655 9670 15469 
+ 9368 9433 9586 9715 9784 9815 
+ 9594 9608 9626 9643 9662 9673 
+ 9610 9611 9648 9657 9679 
+ 9609 9626 9662 15471 
+ 9592 9616 9620 9653 9665 9677 
+ 9545 9569 9650 9659 9711 9726 
+ 9601 9624 9625 9660 
+ 9602 9618 9630 9655 9669 9682 
+ 9294 9325 9698 9761 9948 
+ 9593 9620 9627 9665 9674 9690 
+ 9625 9631 9660 9670 9683 15469 
+ 9608 9621 9633 9672 9673 9685 
+ 9568 9650 9699 9700 15472 
+ 9452 9482 9538 9702 9742 9808 
+ 9582 9587 9652 9667 9713 9722 
+ 9607 9621 9672 9675 9691 15467 
+ 9610 9617 9634 9664 9679 9695 
+ 9078 9090 9543 9731 10049 10141 
+ 9568 9569 9637 9644 9699 9711 
+ 9607 9619 9675 9707 9718 15468 
+ 9572 9587 9622 9646 9681 9713 9720 
+ 9616 9630 9636 9669 9677 9694 
+ 9603 9628 9701 9716 15470 15477 
+ 9618 9631 9639 9670 9682 9693 
+ 9316 9433 9517 9815 9822 9923 
+ 9611 9622 9634 9679 9681 9710 
+ 8676 8728 8990 9840 9934 10471 10478 
+ 9545 9599 9637 9726 9734 15477 
+ 9625 9638 9642 9683 
+ 9049 9129 9550 9964 10042 10184 
+ 9626 9633 9635 9673 9687 
+ 9487 9614 9615 9703 9712 9739 
+ 9617 9627 9648 9674 9695 9708 
+ 9620 9636 9641 9677 9690 9706 
+ 9512 9586 9623 9715 9721 9766 
+ 9582 9614 9646 9703 9722 9740 
+ 9613 9619 9629 9689 9707 9730 
+ 9630 9639 9653 9682 9694 9709 
+ 9631 9642 9655 9683 9693 9705 
+ 9389 9472 9517 9822 9824 9992 
+ 9621 9643 9647 9685 9691 9704 
+ 9633 9643 9662 9685 9687 
+ 9627 9641 9664 9690 9708 9725 
+ 9607 9647 9651 9691 9718 9728 
+ 9478 9482 9742 9829 15473 15483 
+ 9636 9653 9665 9694 9706 9724 
+ 9595 9600 9688 9696 9750 9764 
+ 9634 9648 9657 9695 9710 9729 
+ 9226 9367 9468 9863 9912 15480 
+ 9622 9652 9657 9710 9720 9737 
+ 9639 9655 9669 9693 9709 9723 
+ 9642 9660 9670 9705 
+ 9581 9597 9686 9697 9747 9782 
+ 9643 9672 9673 9687 9704 9717 
+ 9597 9684 9700 9747 9749 15472 
+ 9662 9673 9685 9717 
+ 9595 9615 9678 9712 9750 9762 
+ 9628 9629 9668 9701 9730 9743 
+ 9641 9665 9674 9706 9725 9735 
+ 9647 9672 9675 9704 9728 9736 
+ 9247 9262 9605 9951 9974 10160 
+ 9655 9670 9682 9705 9723 9732 
+ 9653 9669 9677 9709 9724 9733 
+ 9648 9664 9679 9708 9729 9738 
+ 9600 9623 9678 9721 9753 9764 
+ 9510 9581 9684 9714 9782 9807 
+ 9294 9367 9640 9863 9948 10061 
+ 9644 9650 9700 9711 9760 9773 
+ 9644 9686 9699 9749 9760 15472 
+ 9628 9654 9689 9716 9743 15482 
+ 9538 9612 9645 9771 9808 9865 
+ 9614 9663 9667 9739 9740 9768 
+ 9672 9685 9691 9717 9736 15479 
+ 9670 9683 9693 9732 
+ 9665 9677 9690 9724 9735 9745 
+ 9619 9651 9668 9718 9730 9757 9765 
+ 9664 9674 9695 9725 9738 9746 
+ 9669 9682 9694 9723 9733 9741 
+ 9657 9679 9681 9729 9737 9752 
+ 9637 9650 9699 9726 9773 9783 
+ 9615 9663 9688 9739 9762 9779 
+ 9646 9652 9720 9722 9756 9758 
+ 9510 9552 9697 9755 9807 9860 
+ 9586 9632 9666 9766 9784 9831 
+ 9654 9701 9734 9789 15477 15482 
+ 9685 9687 9704 15479 
+ 9651 9675 9707 9728 9757 9763 
+ 8643 8645 9296 9424 10548 10573 
+ 9652 9681 9713 9737 9756 9769 
+ 9623 9666 9696 9753 9766 9793 
+ 9646 9667 9713 9740 9758 9775 
+ 9682 9693 9709 9732 9741 9751 
+ 9677 9694 9706 9733 9745 9754 
+ 9674 9690 9708 9735 9746 9759 
+ 9637 9659 9711 9734 9783 9804 
+ 9534 9816 9879 15473 15476 15483 
+ 9675 9691 9718 9736 9763 9767 
+ 9679 9695 9710 9738 9752 15481 
+ 9668 9689 9707 9743 9765 9777 
+ 9090 9170 9649 9809 10141 10242 
+ 9693 9705 9723 9751 
+ 9694 9709 9724 9741 9754 9770 
+ 9659 9716 9726 9789 9804 15477 
+ 9690 9706 9725 9745 9759 9774 
+ 9691 9704 9728 9767 9772 15479 
+ 9681 9710 9720 9752 9769 9780 
+ 9695 9708 9729 9746 9778 15481 
+ 9663 9703 9712 9768 9779 9800 
+ 9667 9703 9722 9768 9775 9786 
+ 9709 9723 9733 9751 9770 9776 
+ 9482 9645 9676 9808 9829 9891 
+ 9689 9701 9730 9777 9791 15482 
+ 9533 9802 9839 9900 15474 15478 
+ 9706 9724 9735 9754 9774 9781 
+ 9708 9725 9738 9759 9778 9785 
+ 9684 9686 9749 9782 9811 
+ 8998 9101 9524 9970 9999 10161 
+ 9686 9700 9747 9760 9811 9847 
+ 9678 9688 9762 9764 9817 9820 
+ 9723 9732 9741 9776 
+ 9710 9729 9737 9780 9790 15481 
+ 9696 9721 9764 9793 9818 
+ 9724 9733 9745 9770 9781 9787 
+ 9552 9714 9816 9860 9913 15476 
+ 9713 9720 9758 9769 9797 9801 
+ 9707 9718 9763 9765 9794 9798 
+ 9713 9722 9756 9775 9788 9797 
+ 9725 9735 9746 9774 9785 9796 
+ 9699 9700 9749 9773 9847 9859 
+ 9325 9640 9935 9948 10123 15437 
+ 9688 9712 9750 9779 9820 9833 
+ 9718 9728 9757 9767 9792 9794 
+ 9678 9696 9750 9753 9817 9818 
+ 9707 9730 9757 9777 9798 9806 
+ 9666 9715 9721 9793 9831 9854 
+ 9728 9736 9763 9772 9792 9795 
+ 9703 9739 9740 9786 9800 9821 
+ 9720 9737 9756 9780 9801 9810 
+ 9733 9741 9754 9776 9787 9799 
+ 9612 9702 9839 9865 9977 15478 
+ 9736 9767 9795 15479 
+ 9699 9711 9760 9783 9859 15484 
+ 9735 9745 9759 9781 9796 9805 
+ 9722 9740 9758 9786 9788 9812 
+ 9741 9751 9770 9799 
+ 9730 9743 9765 9791 9806 9819 
+ 9738 9746 9785 9803 9813 15481 
+ 9712 9739 9762 9800 9833 9848 
+ 9737 9752 9769 9790 9810 9825 
+ 9745 9754 9774 9787 9805 9814 
+ 9684 9697 9747 9807 9811 9890 
+ 9711 9726 9773 9804 9853 15484 
+ 9632 9715 9815 9831 9949 15487 
+ 9746 9759 9778 9796 9813 9827 
+ 9740 9768 9775 9812 9821 9843 
+ 9754 9770 9781 9799 9814 9826 
+ 9758 9775 9797 9812 9834 
+ 9716 9734 9804 9823 9846 9855 15482 
+ 9752 9780 9803 9825 9838 15481 
+ 9743 9777 9819 9823 9842 15482 
+ 9763 9767 9794 9795 9828 9830 
+ 9721 9753 9766 9818 9854 9892 
+ 9757 9763 9792 9798 9830 9832 
+ 9767 9772 9792 9828 
+ 9759 9774 9785 9805 9827 9837 
+ 9756 9758 9788 9801 9834 9841 
+ 9757 9765 9794 9806 9832 9836 
+ 9770 9776 9787 9826 
+ 9739 9768 9779 9821 9848 9864 
+ 9756 9769 9797 9810 9841 9850 
+ 9744 9900 9944 15474 15480 
+ 9778 9790 9813 9838 9849 15481 
+ 9726 9734 9783 9789 9853 9855 9870 
+ 9774 9781 9796 9814 9837 9845 
+ 9765 9777 9798 9819 9836 9844 
+ 9697 9714 9782 9860 9890 9942 
+ 9645 9702 9742 9865 9891 9938 
+ 9133 9170 9731 9970 10242 10293 
+ 9769 9780 9801 9825 9850 9857 
+ 9747 9749 9782 9847 9890 9998 
+ 9775 9786 9788 9834 9843 9862 
+ 9778 9785 9803 9827 9849 9856 
+ 9781 9787 9805 9826 9845 9851 
+ 9433 9632 9656 9784 9923 10025 15487 
+ 9727 9755 9879 9913 9968 15476 
+ 9750 9764 9818 9820 9872 9875 
+ 9753 9764 9793 9817 9872 9892 
+ 9777 9791 9806 9842 9844 9852 
+ 9750 9762 9817 9833 9875 9882 
+ 9768 9786 9800 9843 9864 9880 
+ 9517 9656 9671 9923 9992 10068 10072 
+ 9789 9791 9842 9846 9871 15482 15485 
+ 9472 9605 9671 9951 9992 10063 
+ 9780 9790 9810 9838 9857 9869 
+ 9787 9799 9814 9851 
+ 9785 9796 9813 9837 9856 9867 
+ 9792 9795 9830 9858 
+ 9676 9742 9891 9932 9980 15483 
+ 9792 9794 9828 9832 9858 9861 
+ 9715 9766 9784 9854 9949 9956 
+ 9794 9798 9830 9836 9861 9866 
+ 9762 9779 9820 9848 9882 9888 
+ 9788 9797 9812 9841 9862 9877 
+ 9308 9364 9941 10207 10327 
+ 9798 9806 9832 9844 9866 9868 
+ 9796 9805 9827 9845 9867 9876 
+ 9790 9803 9825 9849 9869 9881 
+ 9744 9771 9900 9977 10037 15478 
+ 8728 8856 9658 10227 10471 10568 
+ 9797 9801 9834 9850 9877 9884 
+ 9791 9819 9823 9852 9871 9878 
+ 9786 9812 9821 9862 9880 9894 
+ 9806 9819 9836 9852 9868 9873 
+ 9805 9814 9837 9851 9876 9883 
+ 9789 9823 9855 9887 9889 15485 
+ 9749 9760 9811 9859 9943 9998 
+ 9779 9800 9833 9864 9888 9905 
+ 9803 9813 9838 9856 9881 9886 
+ 9801 9810 9841 9857 9884 9895 
+ 9814 9826 9845 9883 
+ 9819 9842 9844 9873 9878 
+ 9783 9804 9870 9874 9903 15484 
+ 9766 9793 9831 9892 9956 15491 
+ 9789 9804 9846 9870 9889 9899 
+ 9813 9827 9849 9867 9886 9897 
+ 9810 9825 9850 9869 9895 9904 
+ 9828 9830 9861 9893 
+ 9760 9773 9847 9874 9921 9943 15484 
+ 9714 9755 9807 9913 9942 9993 
+ 9830 9832 9858 9866 9893 9898 
+ 9812 9834 9843 9877 9894 9910 
+ 9367 9680 9698 9912 10061 10091 
+ 9800 9821 9848 9880 9905 9914 
+ 9702 9771 9808 9938 9977 10045 
+ 9832 9836 9861 9868 9898 9901 
+ 9827 9837 9856 9876 9897 9907 
+ 9836 9844 9866 9873 9901 9906 
+ 9825 9838 9857 9881 9904 9911 
+ 9804 9853 9855 9899 9903 9916 
+ 9823 9842 9878 9896 9902 15485 
+ 9817 9818 9875 9892 9909 9933 
+ 9844 9852 9868 9878 9906 9908 
+ 9853 9859 9903 9921 15484 
+ 9817 9820 9872 9882 9909 9915 
+ 9837 9845 9867 9883 9907 15486 
+ 9834 9841 9862 9884 9910 9920 
+ 9842 9852 9871 9873 9902 9908 
+ 9727 9816 9932 9968 10019 15483 
+ 9821 9843 9864 9894 9914 9927 
+ 9838 9849 9869 9886 9911 9918 
+ 9820 9833 9875 9888 9915 9926 
+ 9845 9851 9876 15486 
+ 9841 9850 9877 9895 9920 9928 
+ 9274 10046 10139 10326 15451 15475 
+ 9849 9856 9881 9897 9918 9924 
+ 9846 9889 9896 9919 9929 15485 
+ 9833 9848 9882 9905 9926 15488 
+ 9846 9855 9887 9899 9919 
+ 9782 9807 9811 9942 9998 10006 
+ 9742 9808 9829 9938 9980 10020 
+ 9793 9818 9854 9872 9933 9975 15491 
+ 9858 9861 9898 9925 
+ 9843 9862 9880 9910 9927 9945 
+ 9850 9857 9884 9904 9928 9937 
+ 9871 9887 9902 9929 9940 15485 
+ 9856 9867 9886 9907 9924 9931 
+ 9861 9866 9893 9901 9925 9930 
+ 9855 9870 9889 9916 9919 9950 
+ 9744 9802 9839 9944 10037 10087 
+ 9866 9868 9898 9906 9930 9936 
+ 9871 9878 9896 9908 9940 9946 
+ 9853 9870 9874 9916 9921 9966 
+ 9857 9869 9895 9911 9937 15490 
+ 9848 9864 9888 9914 9955 15488 
+ 9868 9873 9901 9908 9936 15489 
+ 9867 9876 9897 9931 9939 15486 
+ 9873 9878 9902 9906 9946 15489 
+ 9872 9875 9915 9933 9953 
+ 9862 9877 9894 9920 9945 9954 
+ 9869 9881 9904 9918 9952 15490 
+ 9680 9863 9944 10091 10111 15480 
+ 9755 9816 9860 9968 9993 10035 
+ 9864 9880 9905 9927 9955 9961 
+ 9875 9882 9909 9926 9953 9962 
+ 9870 9899 9903 9950 9966 
+ 9458 9584 9974 10108 10235 
+ 9881 9886 9911 9924 9952 9957 
+ 9887 9889 9899 9929 9950 9984 
+ 9877 9884 9910 9928 9954 9959 
+ 9859 9874 9903 9943 9966 15493 
+ 9543 9584 10049 10108 10194 
+ 9656 9815 9822 10025 10068 10098 
+ 9886 9897 9918 9931 9957 9960 
+ 9893 9898 9930 9958 
+ 9882 9888 9915 9962 9976 15488 
+ 9880 9894 9914 9945 9961 9971 
+ 9884 9895 9920 9937 9959 9967 
+ 9887 9896 9919 9940 9982 9984 
+ 9898 9901 9925 9936 9958 9963 
+ 9897 9907 9924 9939 9960 9965 
+ 9829 9879 9980 10019 10078 15483 
+ 9872 9892 9909 9953 9975 9990 
+ 8990 9437 9658 10343 10478 10526 
+ 9761 10123 10139 10287 15437 15475 
+ 9901 9906 9930 9963 9969 15489 
+ 9895 9904 9928 9967 9972 15490 
+ 9808 9865 9891 10020 10045 
+ 9907 9931 9965 15486 
+ 9896 9902 9929 9946 9982 15492 
+ 9364 9423 9835 9988 10322 10327 
+ 9807 9860 9890 9993 10006 10041 
+ 9847 9859 9921 9998 10051 15493 
+ 9802 9900 9912 10087 10111 15480 
+ 9894 9910 9927 9954 9971 9981 
+ 9902 9908 9940 9973 15489 15492 
+ 8835 8927 9382 10103 10462 10731 
+ 9640 9698 9761 10061 10123 10220 
+ 9784 9831 9956 10004 10008 15487 
+ 9899 9916 9919 9966 9984 10009 
+ 9605 9692 9824 10063 10160 10239 
+ 9911 9918 9957 9978 9983 15490 
+ 9909 9915 9933 9962 9990 10000 
+ 9910 9920 9945 9959 9981 9989 
+ 9905 9914 9961 9985 9996 15488 
+ 9831 9854 9949 10008 10021 15491 
+ 9918 9924 9952 9960 9983 9986 
+ 9925 9930 9963 9987 
+ 9920 9928 9954 9967 9989 9997 
+ 9924 9931 9957 9965 9986 9991 
+ 9914 9927 9955 9971 9996 10003 
+ 9915 9926 9953 9976 10000 10010 
+ 9930 9936 9958 9969 9987 9995 
+ 9129 9162 9661 10184 10325 10538 
+ 9931 9939 9960 9991 
+ 9903 9916 9921 9950 10009 10029 15493 
+ 9928 9937 9959 9972 9997 10002 
+ 9816 9879 9913 10019 10035 10089 
+ 9936 9963 9973 9995 10001 15489 
+ 9101 9133 9748 9809 10161 10293 10407 
+ 9927 9945 9961 9981 10003 10012 
+ 9937 9967 9978 10002 10005 15490 
+ 9946 9969 10001 10007 15489 15492 
+ 9262 9458 9692 9917 10160 10235 10357 
+ 9892 9933 9990 10027 10032 15491 
+ 9926 9962 9985 10010 10018 15488 
+ 9771 9839 9865 10037 10045 10142 
+ 9952 9972 9983 10005 10011 15490 
+ 8999 9246 9437 10207 10343 10614 
+ 9829 9891 9932 10020 10078 10137 
+ 9945 9954 9971 9989 10012 10017 
+ 9929 9940 9984 10014 10022 15492 
+ 9952 9957 9978 9986 10011 10013 
+ 9919 9929 9950 9982 10009 10022 10034 
+ 9955 9976 9996 10018 10026 15488 
+ 9957 9960 9983 9991 10013 10015 
+ 9958 9963 9995 10016 
+ 9423 9524 9941 9999 10322 10351 
+ 9954 9959 9981 9997 10017 10023 
+ 9933 9953 9975 10000 10032 10038 
+ 9960 9965 9986 10015 
+ 9671 9822 9824 10063 10072 10177 
+ 9860 9913 9942 10035 10041 10088 
+ 8778 8942 9382 10403 10462 10896 
+ 9963 9969 9987 10001 10016 10024 
+ 9955 9961 9985 10003 10026 10033 
+ 9959 9967 9989 10002 10023 10028 
+ 9811 9847 9890 9943 10006 10051 10092 10135 
+ 9524 9748 9988 10161 10351 
+ 9953 9962 9990 10010 10038 10047 
+ 9969 9973 9995 10007 10024 10030 
+ 9967 9972 9997 10005 10028 10031 
+ 9961 9971 9996 10012 10033 10043 
+ 9949 10008 10056 10100 15487 
+ 9972 9978 10002 10011 10031 10036 
+ 9890 9942 9998 10041 10092 
+ 9973 10001 10014 10030 10040 15492 
+ 9949 9956 10004 10021 10056 10069 
+ 9950 9966 9984 10029 10034 10060 
+ 9962 9976 10000 10018 10047 10052 
+ 9978 9983 10005 10013 10036 10039 
+ 9971 9981 10003 10017 10043 10048 
+ 9983 9986 10011 10015 10039 10044 
+ 9982 10007 10022 10040 10050 15492 
+ 9986 9991 10013 10044 
+ 9987 9995 10024 15494 
+ 9981 9989 10012 10023 10048 10053 
+ 9976 9985 10010 10026 10052 10057 
+ 9879 9932 9968 10078 10089 10155 
+ 9891 9938 9980 10045 10137 10190 
+ 9956 10008 10027 10069 10073 15491 
+ 9982 9984 10014 10034 10050 10058 
+ 9989 9997 10017 10028 10053 10055 
+ 9995 10001 10016 10030 10054 15494 
+ 9815 9923 10098 10100 10152 15487 
+ 9985 9996 10018 10033 10057 10065 
+ 9975 10021 10032 10073 10074 15491 
+ 9997 10002 10023 10031 10055 10059 
+ 9966 10009 10060 10085 10114 15493 
+ 10001 10007 10024 10040 10054 10062 
+ 10002 10005 10028 10036 10059 10064 
+ 9975 9990 10027 10038 10074 10079 
+ 9996 10003 10026 10043 10065 10070 
+ 9984 10009 10022 10058 10060 10075 
+ 9913 9968 9993 10088 10089 10136 
+ 10005 10011 10031 10039 10064 10066 
+ 9839 9900 9977 10087 10142 10216 
+ 9990 10000 10032 10047 10079 10082 
+ 10011 10013 10036 10044 10066 10067 
+ 10007 10014 10030 10050 10062 10071 
+ 9942 9993 10006 10088 10092 10133 
+ 9550 9661 10046 10184 10376 10393 
+ 10003 10012 10033 10048 10070 10077 
+ 10013 10015 10039 10067 
+ 9865 9938 9977 10020 10142 10190 
+ 9550 9885 10042 10326 10393 15451 
+ 10000 10010 10038 10052 10082 10086 
+ 10012 10017 10043 10053 10077 10081 
+ 9543 9649 9922 10141 10194 10339 
+ 10014 10022 10040 10058 10071 10080 
+ 9943 9998 10085 10135 10156 15493 
+ 10010 10018 10047 10057 10086 10093 
+ 10017 10023 10048 10055 10081 10084 
+ 10024 10030 10062 10076 10083 15494 
+ 10023 10028 10053 10059 10084 10090 
+ 10004 10008 10069 10100 10128 10167 
+ 10018 10026 10052 10065 10093 10099 
+ 10022 10034 10050 10075 10080 15495 
+ 10028 10031 10055 10064 10090 10094 
+ 10009 10029 10034 10075 10104 10114 
+ 9698 9863 9948 10091 10220 10280 
+ 10030 10040 10054 10071 10083 10095 
+ 9824 9951 9992 10177 10239 10271 
+ 10031 10036 10059 10066 10094 10096 
+ 10026 10033 10057 10070 10099 10102 
+ 10036 10039 10064 10067 10096 10097 
+ 10039 10044 10066 10097 
+ 9822 9923 10072 10098 10210 10212 
+ 10008 10021 10056 10073 10105 10128 
+ 10033 10043 10065 10077 10102 10110 
+ 10040 10050 10062 10080 10095 10101 
+ 9822 9992 10068 10177 10212 
+ 10021 10027 10069 10074 10105 10115 
+ 10027 10032 10073 10079 10115 10116 
+ 10034 10058 10060 10104 10107 15495 
+ 10054 10083 10109 15494 
+ 10043 10048 10070 10081 10110 10113 
+ 9932 9980 10019 10137 10155 10222 
+ 10032 10038 10074 10082 10116 10119 
+ 10050 10058 10071 10101 10112 15495 
+ 10048 10053 10077 10084 10113 10117 
+ 10038 10047 10079 10086 10119 10126 
+ 10054 10062 10076 10095 10109 10118 
+ 10053 10055 10081 10090 10117 10120 
+ 10029 10051 10114 10156 10162 15493 
+ 10047 10052 10082 10093 10126 10129 
+ 9900 9944 10037 10111 10216 10277 
+ 9993 10035 10041 10133 10136 10175 
+ 9968 10019 10035 10136 10155 10188 
+ 10055 10059 10084 10094 10120 10122 
+ 9863 9912 10061 10111 10280 10334 
+ 9998 10006 10041 10133 10135 10174 
+ 10052 10057 10086 10099 10129 10131 
+ 10059 10064 10090 10096 10122 10125 
+ 10062 10071 10083 10101 10118 10127 
+ 10064 10066 10094 10097 10124 10125 
+ 10066 10067 10096 10124 
+ 9923 10025 10068 10152 10208 10210 
+ 10057 10065 10093 10102 10131 10134 
+ 10004 10025 10056 10152 10167 15487 15497 
+ 10071 10080 10095 10112 10127 10132 
+ 10065 10070 10099 10110 10134 10140 
+ 8927 9139 9947 10240 10703 10731 
+ 10060 10075 10107 10114 10130 10146 
+ 10069 10073 10115 10128 10153 
+ 8519 8816 10288 10842 10897 15422 
+ 10075 10104 10121 10130 15495 
+ 9584 9917 9922 10194 10235 10363 
+ 10076 10083 10118 10138 
+ 10070 10077 10102 10113 10140 10144 
+ 9912 9944 10087 10091 10277 10334 
+ 10080 10101 10121 10132 10143 15495 
+ 10077 10081 10110 10117 10144 10147 
+ 10029 10060 10085 10104 10146 10162 10171 
+ 10073 10074 10105 10116 10153 10157 
+ 10074 10079 10115 10119 10157 10158 
+ 10081 10084 10113 10120 10147 10149 
+ 10083 10095 10109 10127 10138 10148 
+ 10079 10082 10116 10126 10158 10159 
+ 10084 10090 10117 10122 10149 10150 
+ 10107 10112 10130 10143 10145 15495 
+ 10090 10094 10120 10125 10150 10154 
+ 9761 9935 9948 10220 10287 10361 
+ 10096 10097 10125 10151 
+ 10094 10096 10122 10124 10151 10154 
+ 10082 10086 10119 10129 10159 10163 
+ 10095 10101 10118 10132 10148 15496 
+ 10056 10069 10105 10153 10167 10196 
+ 10086 10093 10126 10131 10163 10164 
+ 10104 10107 10121 10145 10146 
+ 10093 10099 10129 10134 10164 10166 
+ 10101 10112 10127 10143 10165 15496 
+ 10041 10088 10092 10174 10175 10206 
+ 10099 10102 10131 10140 10166 10169 
+ 9998 10051 10092 10156 10174 10221 10225 
+ 10035 10088 10089 10175 10188 10214 
+ 9980 10020 10078 10190 10222 10299 
+ 10109 10118 10148 10168 
+ 9885 9935 10287 10326 10475 15475 
+ 10102 10110 10134 10144 10169 10172 
+ 9649 9731 10049 10242 10339 10537 
+ 9977 10037 10045 10190 10216 10286 
+ 10112 10121 10132 10145 10165 10170 
+ 10110 10113 10140 10147 10172 10176 
+ 10121 10130 10143 10146 10170 10173 
+ 10104 10114 10130 10145 10171 10173 
+ 10113 10117 10144 10149 10176 10178 
+ 10118 10127 10138 10168 10179 15496 
+ 10117 10120 10147 10150 10178 10181 
+ 10120 10122 10149 10154 10181 10182 
+ 10124 10125 10154 10180 
+ 10025 10098 10100 10208 10217 15497 
+ 10105 10115 10128 10157 10196 10218 
+ 10122 10125 10150 10151 10180 10182 
+ 10019 10078 10089 10188 10222 10257 
+ 10051 10085 10135 10162 10221 10237 
+ 10115 10116 10153 10158 10189 10218 
+ 10116 10119 10157 10159 10186 10189 
+ 10119 10126 10158 10163 10185 10186 
+ 9692 9951 9974 10239 10357 10473 
+ 9748 9970 9999 10351 10407 10414 
+ 10085 10114 10156 10171 10211 10237 
+ 10126 10129 10159 10164 10185 10187 
+ 10129 10131 10163 10166 10187 10191 
+ 10132 10143 10170 10183 10192 15496 
+ 10131 10134 10164 10169 10191 10195 
+ 10056 10100 10128 10196 10263 15497 
+ 10138 10148 10179 10193 
+ 10134 10140 10166 10172 10195 10197 
+ 10143 10145 10165 10173 10192 10200 
+ 10114 10146 10162 10173 10209 10211 
+ 10140 10144 10169 10176 10197 10198 
+ 10145 10146 10170 10171 10200 10209 
+ 10092 10133 10135 10206 10225 10243 
+ 10088 10133 10136 10206 10214 10236 
+ 10144 10147 10172 10178 10198 10202 
+ 9992 10063 10072 10212 10271 10300 
+ 10147 10149 10176 10181 10202 10203 
+ 10148 10168 10183 10193 10205 15496 
+ 10151 10154 10182 10201 
+ 10149 10150 10178 10182 10203 10204 
+ 10150 10154 10180 10181 10201 10204 
+ 10165 10179 10192 10205 10215 15496 
+ 9661 9964 10042 10376 10538 
+ 10159 10163 10186 10187 10213 10219 
+ 10158 10159 10185 10189 10213 10234 
+ 10163 10164 10185 10191 10219 10223 
+ 10089 10136 10155 10214 10257 10262 
+ 10157 10158 10186 10218 10234 10246 
+ 10020 10045 10137 10142 10286 10299 10359 
+ 10164 10166 10187 10195 10223 10226 
+ 10165 10170 10183 10200 10215 10228 
+ 10168 10179 10205 10224 
+ 9922 10049 10108 10339 10363 10488 
+ 10166 10169 10191 10197 10226 10229 
+ 10128 10153 10167 10218 10263 10270 
+ 10169 10172 10195 10198 10229 10231 
+ 10172 10176 10197 10202 10231 10232 
+ 8742 8935 9359 10666 10889 11074 
+ 10170 10173 10192 10209 10228 10241 
+ 10180 10182 10204 10230 
+ 10176 10178 10198 10203 10232 10233 
+ 10178 10181 10202 10204 10233 15498 
+ 10181 10182 10201 10203 10230 15498 
+ 10179 10183 10193 10215 10224 10238 
+ 10133 10174 10175 10236 10243 10258 
+ 9246 9308 9835 9979 10327 10614 10698 
+ 10098 10152 10210 10217 10283 10294 
+ 10171 10173 10200 10211 10241 10249 
+ 10068 10098 10208 10212 10294 10312 
+ 10162 10171 10209 10237 10249 10264 
+ 10068 10072 10177 10210 10300 10312 
+ 10185 10186 10219 10234 10244 
+ 10136 10175 10188 10236 10261 10262 
+ 10183 10192 10205 10228 10238 10245 
+ 10037 10087 10142 10277 10286 10386 
+ 10152 10208 10274 10283 15497 
+ 10153 10157 10189 10196 10246 10270 10278 
+ 10185 10187 10213 10223 10244 10247 
+ 9948 10061 10123 10280 10361 10415 
+ 10135 10156 10225 10237 10265 10268 
+ 10078 10137 10155 10257 10299 10319 
+ 10187 10191 10219 10226 10247 10250 
+ 10193 10205 10238 10248 
+ 10135 10174 10221 10243 10265 10269 
+ 10191 10195 10223 10229 10250 10252 
+ 8856 9604 9840 10518 10568 10710 
+ 10192 10200 10215 10241 10245 10259 
+ 10195 10197 10226 10231 10252 10254 
+ 10201 10204 10251 15498 
+ 10197 10198 10229 10232 10254 10256 
+ 10198 10202 10231 10233 10255 10256 
+ 10202 10203 10232 10253 10255 15498 
+ 10186 10189 10213 10244 10246 10266 
+ 9917 9974 10108 10357 10363 10463 
+ 10175 10206 10214 10258 10261 10267 
+ 10156 10162 10211 10221 10264 10268 10296 
+ 10205 10215 10224 10245 10248 10260 
+ 9951 10063 10160 10271 10439 10473 
+ 9139 9604 10103 10518 10661 10703 
+ 10200 10209 10228 10249 10259 10272 
+ 9731 9809 10141 10293 10537 10570 
+ 10174 10206 10225 10258 10269 10292 10305 
+ 10213 10219 10234 10247 10266 10273 
+ 10215 10228 10238 10259 10260 10275 
+ 10189 10218 10234 10266 10278 10295 
+ 10219 10223 10244 10250 10273 10279 
+ 10224 10238 10260 15499 
+ 10209 10211 10241 10264 10272 10297 
+ 10223 10226 10247 10252 10279 10282 
+ 10230 10253 10276 15498 
+ 10226 10229 10250 10254 10282 10284 
+ 10233 10251 10255 10276 10281 15498 
+ 10229 10231 10252 10256 10284 10285 
+ 10232 10233 10253 10256 10281 15500 
+ 10231 10232 10254 10255 10285 15500 
+ 10155 10188 10222 10262 10309 10319 10323 
+ 10206 10236 10243 10267 10291 10292 
+ 10228 10241 10245 10272 10275 10290 
+ 10238 10245 10248 10275 10289 15499 
+ 10214 10236 10262 10267 10298 10301 
+ 10188 10214 10257 10261 10301 10309 
+ 10167 10196 10270 10274 10340 10353 15497 
+ 10211 10237 10249 10296 10297 15501 
+ 10221 10225 10268 10269 10302 10303 
+ 10234 10244 10246 10273 10295 10304 
+ 10236 10258 10261 10291 10298 10318 
+ 10221 10237 10265 10296 10303 10320 
+ 10225 10243 10265 10302 10305 
+ 10196 10218 10263 10278 10329 10340 
+ 10063 10177 10239 10300 10422 10439 
+ 10241 10249 10259 10290 10297 10314 
+ 10244 10247 10266 10279 10304 10311 
+ 10217 10263 10283 10353 10360 15497 
+ 10245 10259 10260 10289 10290 10308 
+ 10251 10253 10281 10306 
+ 10087 10111 10216 10334 10386 10482 
+ 10218 10246 10270 10295 10329 10330 
+ 10247 10250 10273 10282 10311 10315 
+ 10061 10091 10220 10334 10415 15505 
+ 10253 10255 10276 10306 10310 15500 
+ 10250 10252 10279 10284 10315 10317 
+ 10208 10217 10274 10294 10360 10374 
+ 10252 10254 10282 10285 10316 10317 
+ 10254 10256 10284 10313 10316 15500 
+ 10142 10190 10216 10359 10386 10458 
+ 9935 10123 10139 10361 10475 10496 
+ 8816 9209 10106 10325 10875 10897 
+ 10260 10275 10307 10308 10321 15499 
+ 10259 10272 10275 10308 10314 10324 
+ 10258 10267 10292 10318 10328 
+ 10243 10258 10291 10305 10328 10344 
+ 9809 9970 10242 10407 10570 10621 
+ 10208 10210 10283 10312 10374 10400 
+ 10246 10266 10278 10304 10330 10336 
+ 10237 10264 10268 10320 15501 15502 
+ 10249 10264 10272 10314 10332 15501 
+ 10261 10267 10301 10318 10331 
+ 10137 10190 10222 10319 10359 10409 10426 
+ 10177 10212 10271 10312 10412 10422 
+ 10261 10262 10298 10309 10331 10348 
+ 10265 10269 10303 10305 10354 10355 
+ 10265 10268 10302 10320 10341 10354 
+ 10266 10273 10295 10311 10336 10345 
+ 10243 10269 10292 10302 10344 10355 
+ 10276 10281 10310 10333 
+ 10289 10321 10335 15499 
+ 10275 10289 10290 10321 10324 10337 
+ 10257 10262 10301 10323 10348 10352 
+ 10281 10306 10313 10333 10338 15500 
+ 10273 10279 10304 10315 10345 10350 
+ 10210 10212 10294 10300 10400 10412 
+ 10285 10310 10316 10338 10342 15500 
+ 10272 10290 10297 10324 10332 10346 
+ 10279 10282 10311 10317 10349 10350 
+ 10284 10285 10313 10317 10342 10347 
+ 10282 10284 10315 10316 10347 10349 
+ 10267 10291 10298 10328 10331 10362 
+ 10222 10257 10299 10323 10382 10409 
+ 10268 10296 10303 10341 10364 15502 
+ 10289 10307 10308 10335 10337 10356 
+ 9941 9988 10327 10351 10639 10751 
+ 10257 10309 10319 10352 10382 15503 
+ 10290 10308 10314 10337 10346 10358 
+ 9162 9209 9964 10288 10538 10823 10875 
+ 9885 10046 10139 10393 10475 10644 10677 
+ 9835 9941 10207 10322 10698 10751 
+ 10291 10292 10318 10344 10362 10384 
+ 10270 10278 10330 10340 10383 10395 
+ 10278 10295 10329 10336 10377 10383 
+ 10298 10301 10318 10348 10362 10389 
+ 10297 10314 10346 10365 10367 15501 
+ 10306 10310 10338 10366 
+ 10091 10111 10277 10280 10482 10596 15505 
+ 10307 10321 10356 10368 
+ 10295 10304 10330 10345 10377 10379 
+ 10308 10321 10324 10356 10358 10370 
+ 10310 10313 10333 10342 10366 10372 
+ 10049 10141 10194 10488 10537 10662 
+ 10263 10270 10329 10353 10395 10405 
+ 10303 10320 10354 10364 10381 
+ 10313 10316 10338 10347 10372 10373 
+ 9437 9934 9979 10526 10614 10744 
+ 10292 10305 10328 10355 10384 10397 
+ 10304 10311 10336 10350 10379 10380 
+ 10314 10324 10332 10358 10365 10371 
+ 10316 10317 10342 10349 10373 10375 
+ 10301 10309 10331 10352 10389 10394 
+ 10315 10317 10347 10350 10375 10378 
+ 10311 10315 10345 10349 10378 10380 
+ 9988 9999 10161 10322 10414 10592 10639 
+ 10309 10323 10348 10394 15503 
+ 10263 10274 10340 10360 10405 10424 
+ 10302 10303 10341 10355 10381 10406 
+ 10302 10305 10344 10354 10397 10406 
+ 10321 10335 10337 10368 10370 10388 
+ 9974 10160 10235 10463 10473 10590 
+ 10324 10337 10346 10370 10371 10387 
+ 10190 10286 10299 10426 10458 10494 
+ 10274 10283 10353 10374 10424 10442 
+ 10123 10220 10287 10415 10496 10511 
+ 10318 10328 10331 10384 10389 10435 
+ 10108 10194 10235 10463 10488 10521 
+ 10320 10341 10381 10385 10401 15502 
+ 10332 10346 10367 10371 10390 10391 
+ 10333 10338 10372 10398 
+ 10332 10365 10369 10391 10392 15501 
+ 10335 10356 10388 10402 
+ 10367 10385 10392 10396 15501 15502 
+ 10337 10356 10358 10387 10388 15504 
+ 10346 10358 10365 10387 10390 10399 
+ 10338 10342 10366 10373 10398 10404 
+ 10342 10347 10372 10375 10404 10408 
+ 10283 10294 10360 10400 10442 10468 
+ 10347 10349 10373 10378 10408 10410 
+ 10042 10184 10393 10538 10618 
+ 10330 10336 10379 10383 10418 10425 
+ 10349 10350 10375 10380 10410 10413 
+ 10336 10345 10377 10380 10416 10418 
+ 10345 10350 10378 10379 10413 10416 
+ 10341 10354 10364 10401 10406 10427 
+ 10319 10323 10409 10434 10449 15503 
+ 10329 10330 10377 10395 10425 10430 
+ 10328 10344 10362 10397 10435 10446 
+ 10364 10369 10396 10401 10420 15502 
+ 10216 10277 10286 10458 10482 10559 
+ 10358 10370 10371 10399 10421 15504 
+ 10356 10368 10370 10402 10423 15504 
+ 10331 10348 10362 10394 10435 10451 
+ 10365 10371 10391 10399 10411 
+ 10365 10367 10390 10392 10411 10417 
+ 10367 10369 10391 10396 10417 10419 
+ 10042 10046 10326 10376 10618 10644 
+ 10348 10352 10389 10444 10451 15503 
+ 10329 10340 10383 10405 10430 10452 
+ 10369 10385 10392 10419 10420 
+ 10344 10355 10384 10406 10446 10454 
+ 10366 10372 10404 10429 
+ 10371 10387 10390 10411 10421 10428 
+ 10294 10312 10374 10412 10468 10486 
+ 10364 10381 10385 10420 10427 10440 
+ 10368 10388 10423 10431 
+ 8942 9424 9994 10548 10896 10930 
+ 10372 10373 10398 10408 10429 10433 
+ 10340 10353 10395 10424 10452 10464 
+ 10354 10355 10381 10397 10427 10454 10466 
+ 9970 10161 10293 10414 10621 10625 
+ 10373 10375 10404 10410 10433 10437 
+ 10299 10319 10382 10426 10449 10465 
+ 10375 10378 10408 10413 10437 10438 
+ 10390 10391 10399 10417 10428 10436 
+ 10300 10312 10400 10422 10486 10510 
+ 10378 10380 10410 10416 10438 10443 
+ 10161 10351 10407 10592 10625 
+ 10220 10280 10361 10511 10576 15505 
+ 10379 10380 10413 10418 10443 10447 
+ 10391 10392 10411 10419 10436 10441 
+ 10377 10379 10416 10425 10447 10453 
+ 10392 10396 10417 10420 10441 10445 
+ 10385 10396 10401 10419 10440 10445 
+ 10387 10399 10428 10432 10448 15504 
+ 10271 10300 10412 10439 10510 10555 
+ 10388 10402 10431 10432 10450 15504 
+ 10353 10360 10405 10442 10464 10490 
+ 10377 10383 10418 10430 10453 10457 
+ 10299 10359 10409 10465 10494 10527 
+ 10381 10401 10406 10440 10466 10477 
+ 10399 10411 10421 10436 10448 10456 
+ 10398 10404 10433 10455 
+ 10383 10395 10425 10452 10457 10480 
+ 10402 10423 10450 10459 
+ 10421 10423 10448 10450 10460 15504 
+ 10404 10408 10429 10437 10455 10461 
+ 10382 10444 10449 10493 15503 
+ 10362 10384 10389 10446 10451 10500 10501 
+ 10411 10417 10428 10441 10456 10469 
+ 10408 10410 10433 10438 10461 10467 
+ 10410 10413 10437 10443 10467 10470 
+ 10239 10271 10422 10473 10555 10605 
+ 10401 10420 10427 10445 10477 10485 
+ 10417 10419 10436 10445 10469 10481 
+ 10360 10374 10424 10468 10490 10520 
+ 10413 10416 10438 10447 10470 10472 
+ 10394 10434 10451 10493 10503 15503 
+ 10419 10420 10440 10441 10481 10485 
+ 10384 10397 10435 10454 10500 10504 
+ 10416 10418 10443 10453 10472 10479 
+ 10421 10428 10432 10456 10460 10474 
+ 10382 10409 10434 10465 10493 10515 
+ 10423 10431 10432 10459 10460 10476 
+ 10389 10394 10435 10444 10501 10503 
+ 10395 10405 10430 10464 10480 10497 
+ 10418 10425 10447 10457 10479 10483 
+ 10397 10406 10446 10466 10504 10508 
+ 10429 10433 10461 10484 
+ 10428 10436 10448 10469 10474 10487 
+ 10425 10430 10453 10480 10483 10498 
+ 10286 10359 10386 10494 10559 10579 
+ 10431 10450 10476 10489 
+ 10432 10448 10450 10474 10476 10491 
+ 10433 10437 10455 10467 10484 10492 
+ 9382 9947 9994 10731 10896 10934 
+ 10235 10357 10363 10521 10590 10643 
+ 10405 10424 10452 10490 10497 10550 
+ 10409 10426 10449 10515 10527 
+ 10406 10427 10454 10477 10508 10513 
+ 10437 10438 10461 10470 10492 10495 
+ 10374 10400 10442 10486 10520 10554 
+ 10436 10441 10456 10481 10487 10502 
+ 10438 10443 10467 10472 10495 10499 
+ 9658 9840 10478 10568 10802 10846 
+ 10443 10447 10470 10479 10499 10505 
+ 10160 10239 10357 10439 10590 10605 10727 
+ 10448 10456 10460 10487 10491 10506 
+ 10139 10287 10326 10496 10674 10677 
+ 10450 10459 10460 10489 10491 10507 
+ 10427 10440 10466 10485 10513 10522 
+ 9658 9934 10471 10526 10802 10804 
+ 10447 10453 10472 10483 10505 10509 
+ 10430 10452 10457 10497 10498 10516 
+ 10441 10445 10469 10485 10502 10517 
+ 10277 10334 10386 10559 10596 10671 
+ 10453 10457 10479 10498 10509 10512 
+ 10455 10461 10492 10514 
+ 10440 10445 10477 10481 10517 10522 10532 
+ 10400 10412 10468 10510 10554 10577 
+ 10456 10469 10474 10502 10506 10519 
+ 10194 10339 10363 10521 10662 10664 
+ 10459 10476 10507 10523 
+ 10424 10442 10464 10520 10550 10562 
+ 10460 10474 10476 10506 10507 10524 
+ 10461 10467 10484 10495 10514 10525 
+ 10434 10444 10449 10503 10515 10575 10585 
+ 10359 10426 10458 10527 10579 10609 
+ 10467 10470 10492 10499 10525 10528 
+ 10287 10361 10475 10511 10651 10674 
+ 10452 10464 10480 10516 10550 10552 
+ 10457 10480 10483 10512 10516 10531 
+ 10470 10472 10495 10505 10528 10529 
+ 10435 10446 10501 10504 10540 10543 
+ 10435 10451 10500 10503 10540 10560 
+ 10469 10481 10487 10517 10519 10530 
+ 10444 10451 10493 10501 10560 10575 
+ 10446 10454 10500 10508 10543 10545 
+ 10472 10479 10499 10509 10529 10535 
+ 10474 10487 10491 10519 10524 10533 
+ 10476 10489 10491 10523 10524 10534 
+ 10454 10466 10504 10513 10542 10545 
+ 10479 10483 10505 10512 10535 10536 
+ 10412 10422 10486 10555 10577 10627 
+ 10361 10415 10496 10576 10651 
+ 10483 10498 10509 10531 10536 
+ 10466 10477 10508 10522 10542 10544 
+ 10484 10492 10525 10541 
+ 10449 10465 10493 10527 10585 10602 
+ 10480 10497 10498 10531 10552 10558 
+ 10481 10485 10502 10530 10532 10546 
+ 9604 10227 10240 10661 10710 10854 
+ 10487 10502 10506 10530 10533 10547 
+ 10442 10468 10490 10554 10562 10569 
+ 10363 10463 10488 10643 10664 
+ 10477 10485 10513 10532 10544 10556 
+ 10489 10507 10534 10549 
+ 10491 10506 10507 10533 10534 10551 
+ 10492 10495 10514 10528 10541 10553 
+ 9934 10343 10478 10744 10804 
+ 10426 10465 10494 10515 10602 10609 
+ 10495 10499 10525 10529 10553 10557 
+ 10499 10505 10528 10535 10557 10561 
+ 10502 10517 10519 10546 10547 15506 
+ 10498 10512 10516 10536 10558 10567 
+ 10485 10517 10522 10546 10556 10565 
+ 10506 10519 10524 10547 10551 10563 
+ 10507 10523 10524 10549 10551 10564 
+ 10505 10509 10529 10536 10561 10566 
+ 10509 10512 10531 10535 10566 10567 
+ 10141 10242 10339 10570 10662 10777 10792 
+ 9964 10184 10325 10376 10618 10822 10823 
+ 7332 7379 8166 8722 11903 13752 15544 
+ 10500 10501 10543 10560 10578 10595 
+ 10514 10525 10553 10572 
+ 10508 10513 10544 10545 10586 10593 
+ 10500 10504 10540 10545 10578 10589 
+ 10513 10522 10542 10556 10571 10586 
+ 10504 10508 10542 10543 10589 10593 
+ 10517 10530 10532 10565 10574 15506 
+ 10519 10530 10533 10563 10580 15506 
+ 9424 9719 10403 10573 10930 10975 
+ 10523 10534 10564 10581 
+ 10464 10490 10497 10552 10562 10606 10610 
+ 10524 10533 10534 10563 10564 10582 
+ 10497 10516 10550 10558 10600 10606 
+ 10525 10528 10541 10557 10572 10583 
+ 10468 10486 10520 10569 10577 10608 10638 
+ 10422 10439 10510 10605 10627 10672 
+ 10522 10532 10544 10565 10571 10584 
+ 10528 10529 10553 10561 10583 10587 
+ 10516 10531 10552 10567 10597 10600 
+ 10386 10458 10482 10579 10665 10671 
+ 10501 10503 10540 10575 10595 10617 
+ 10529 10535 10557 10566 10587 10594 
+ 10490 10520 10550 10569 10610 10620 
+ 10533 10547 10551 10580 10582 10601 
+ 10534 10549 10551 10581 10582 10599 
+ 10532 10546 10556 10574 10584 10588 
+ 10535 10536 10561 10567 10594 10598 
+ 10531 10536 10558 10566 10597 10598 
+ 9840 10227 10471 10710 10846 10903 
+ 10520 10554 10562 10608 10620 
+ 10242 10293 10537 10621 10775 10792 
+ 10544 10556 10584 10586 10604 
+ 10541 10553 10583 10607 
+ 9296 9719 10548 10666 10975 11036 
+ 10546 10565 10588 10591 10603 15506 
+ 10493 10503 10560 10585 10617 10637 
+ 10415 10511 10651 10685 10749 15505 
+ 10486 10510 10554 10627 10638 10675 
+ 10540 10543 10589 10595 10622 
+ 10458 10494 10559 10609 10653 10665 
+ 10547 10563 10591 10601 10613 15506 
+ 10549 10564 10599 10612 
+ 10551 10563 10564 10599 10601 10616 
+ 10553 10557 10572 10587 10607 10615 
+ 10556 10565 10571 10588 10604 10611 
+ 10493 10515 10575 10602 10637 10648 
+ 10542 10544 10571 10593 10604 10628 
+ 10557 10561 10583 10594 10615 10619 
+ 10565 10574 10584 10603 10611 
+ 10543 10545 10578 10593 10622 10631 
+ 10357 10463 10473 10643 10727 10747 
+ 10574 10580 10603 10613 10623 15506 
+ 10351 10414 10625 10639 10725 10814 
+ 10542 10545 10586 10589 10628 10631 
+ 10561 10566 10587 10598 10619 10624 
+ 10540 10560 10578 10617 10622 10649 
+ 10334 10482 10671 10685 10738 15505 
+ 10558 10567 10598 10600 10626 10632 
+ 10566 10567 10594 10597 10624 10626 
+ 10564 10581 10582 10612 10616 10629 
+ 10552 10558 10597 10606 10632 10642 
+ 10563 10580 10582 10613 10616 10630 
+ 10515 10527 10585 10609 10648 10660 
+ 10574 10588 10591 10611 10623 10633 
+ 10571 10584 10586 10611 10628 10636 
+ 10439 10473 10555 10672 10727 10739 
+ 10550 10552 10600 10610 10642 10652 
+ 10572 10583 10615 10634 
+ 10554 10569 10620 10638 10669 
+ 10494 10527 10579 10602 10653 10660 10684 
+ 10550 10562 10606 10620 10652 10657 
+ 10584 10588 10603 10604 10633 10636 
+ 10581 10599 10629 10640 
+ 10580 10591 10601 10623 10630 10646 
+ 9979 10207 10343 10698 10744 10917 10939 
+ 10583 10587 10607 10619 10634 10641 
+ 10582 10599 10601 10629 10630 10645 
+ 10560 10575 10595 10637 10649 10676 
+ 10376 10393 10538 10644 10816 10822 
+ 10587 10594 10615 10624 10641 10647 
+ 10562 10569 10608 10610 10657 10669 
+ 10293 10407 10570 10625 10775 10784 
+ 10578 10589 10595 10631 10649 10678 
+ 10591 10603 10613 10633 10646 10656 
+ 10594 10598 10619 10626 10647 10650 
+ 10407 10414 10592 10621 10725 10784 
+ 10597 10598 10624 10632 10650 10655 
+ 10510 10555 10577 10672 10675 10726 
+ 10586 10593 10604 10631 10636 10681 10682 
+ 10599 10612 10616 10640 10645 10654 
+ 10601 10613 10616 10645 10646 10659 
+ 10589 10593 10622 10628 10678 10681 
+ 10597 10600 10626 10642 10655 10668 
+ 10603 10611 10623 10636 10656 10670 
+ 10607 10615 10641 10658 
+ 7178 7911 8355 11933 13535 14090 
+ 10604 10611 10628 10633 10670 10682 
+ 10575 10585 10617 10648 10676 10688 
+ 10554 10577 10608 10669 10675 10704 
+ 10322 10351 10592 10751 10814 10893 
+ 10612 10629 10654 10663 
+ 10615 10619 10634 10647 10658 10667 
+ 10600 10606 10632 10652 10668 10686 
+ 10463 10521 10590 10664 10747 10795 
+ 10326 10393 10618 10677 10816 10859 
+ 10616 10629 10630 10654 10659 15507 
+ 10613 10623 10630 10656 10659 10679 
+ 10619 10624 10641 10650 10667 10673 
+ 10585 10602 10637 10660 10688 10693 
+ 10595 10617 10622 10676 10678 10716 
+ 10624 10626 10647 10655 10673 10680 
+ 10496 10511 10576 10674 10749 10793 
+ 10606 10610 10642 10657 10686 10695 
+ 10579 10609 10665 10684 10709 10713 
+ 10629 10640 10645 10663 10683 15507 
+ 10626 10632 10650 10668 10680 10689 
+ 10623 10633 10646 10670 10679 10694 
+ 10610 10620 10652 10669 10695 10715 
+ 10634 10641 10667 10687 
+ 10630 10645 10646 10679 10691 15507 
+ 10602 10609 10648 10684 10693 10700 
+ 10240 10518 10703 10854 10952 
+ 10339 10488 10537 10664 10761 10777 10844 
+ 10640 10654 10683 10690 
+ 10488 10521 10643 10662 10761 10795 
+ 10559 10579 10653 10671 10709 10743 
+ 9296 9359 10199 10573 11036 11074 11267 
+ 10641 10647 10658 10673 10687 10692 
+ 10632 10642 10655 10686 10689 10699 
+ 10608 10620 10638 10657 10704 10715 
+ 10633 10636 10656 10682 10694 10711 
+ 10482 10559 10596 10665 10738 10743 10788 
+ 10555 10605 10627 10726 10739 10773 
+ 10647 10650 10667 10680 10692 10696 
+ 10475 10496 10651 10677 10793 10843 
+ 10577 10627 10638 10704 10726 10748 
+ 10617 10637 10649 10688 10716 10721 
+ 10326 10475 10644 10674 10843 10859 
+ 10622 10631 10649 10681 10716 10735 
+ 10646 10656 10659 10691 10694 10705 
+ 10650 10655 10673 10689 10696 10701 
+ 10628 10631 10678 10682 10720 10735 
+ 10628 10636 10670 10681 10711 10720 
+ 10654 10663 10690 10697 10702 15507 
+ 10609 10653 10660 10700 10713 10733 
+ 10576 10596 10738 10749 10818 15505 
+ 10642 10652 10668 10695 10699 10717 
+ 10658 10667 10692 10706 
+ 10637 10648 10676 10693 10721 10729 
+ 10655 10668 10680 10699 10701 10707 
+ 10663 10683 10702 10708 
+ 10659 10679 10697 10705 10714 15507 
+ 10667 10673 10687 10696 10706 10712 
+ 10648 10660 10688 10700 10729 10734 
+ 10656 10670 10679 10705 10711 15508 
+ 10652 10657 10686 10715 10717 10740 
+ 10673 10680 10692 10701 10712 10718 
+ 10683 10691 10702 10714 10719 15507 
+ 10207 10327 10614 10751 10939 10958 
+ 10668 10686 10689 10707 10717 10724 
+ 10660 10684 10693 10733 10734 
+ 10680 10689 10696 10707 10718 10723 
+ 10683 10690 10697 10708 10719 10722 
+ 10103 10240 10661 10731 10952 11019 
+ 10638 10669 10675 10715 10748 10764 
+ 10679 10691 10694 10714 10732 15508 
+ 10687 10692 10712 10728 
+ 10689 10699 10701 10723 10724 
+ 10690 10702 10722 10730 
+ 10653 10665 10713 10743 10750 
+ 10227 10518 10568 10854 10903 10984 
+ 10670 10682 10694 10720 10754 10758 15508 
+ 10692 10696 10706 10718 10728 10737 
+ 10653 10684 10709 10733 10750 10768 
+ 10691 10697 10705 10719 10732 10736 
+ 10657 10669 10695 10704 10740 10764 10785 
+ 10649 10676 10678 10721 10735 10769 10781 
+ 10686 10695 10699 10724 10740 10745 10763 
+ 10696 10701 10712 10723 10737 10741 
+ 10697 10702 10714 10722 10736 15509 
+ 10681 10682 10711 10735 10758 10774 
+ 10676 10688 10716 10729 10769 10772 
+ 10702 10708 10719 10730 10746 15509 
+ 10701 10707 10718 10724 10741 10742 
+ 10699 10707 10717 10723 10742 10745 
+ 10592 10625 10784 10814 10907 
+ 10627 10672 10675 10748 10773 10827 
+ 10473 10590 10605 10739 10747 10840 10862 
+ 10706 10712 10737 10753 
+ 10688 10693 10721 10734 10770 10772 
+ 10708 10722 10746 10756 
+ 9947 10103 10462 10703 10934 11019 11072 
+ 10705 10714 10736 10755 10757 15508 
+ 10684 10700 10713 10734 10768 10779 
+ 10693 10700 10729 10733 10770 10779 
+ 10678 10681 10716 10720 10774 10781 10798 
+ 10714 10719 10732 10757 10759 15509 
+ 10712 10718 10728 10741 10753 10760 
+ 10596 10671 10685 10788 10818 15511 
+ 10605 10672 10727 10773 10840 10852 
+ 10695 10715 10717 10763 10785 10796 
+ 10718 10723 10737 10742 10760 10765 
+ 10723 10724 10741 10745 10762 10765 
+ 10665 10671 10709 10750 10788 10820 10853 
+ 10343 10526 10614 10804 10917 10961 
+ 10717 10724 10742 10762 10763 10783 
+ 10722 10730 10756 10766 10771 15509 
+ 10590 10643 10727 10795 10862 10887 
+ 10675 10704 10726 10764 10827 10829 
+ 10576 10651 10685 10793 10818 10908 
+ 10709 10713 10743 10768 10820 
+ 10322 10327 10639 10698 10893 10958 10990 
+ 7248 7709 8151 12039 12141 13965 
+ 10728 10737 10760 10782 
+ 10711 10755 10758 10786 10789 15508 
+ 10732 10754 10757 10776 10786 15508 
+ 10730 10746 10771 10780 
+ 10732 10736 10755 10759 10776 10778 
+ 10711 10720 10754 10774 10789 10799 
+ 10736 10757 10766 10778 10787 15509 
+ 10737 10741 10753 10765 10782 10790 
+ 10662 10664 10795 10844 10921 
+ 10742 10745 10765 10783 10791 
+ 10717 10740 10745 10783 10796 10805 
+ 10704 10715 10748 10785 10829 10832 
+ 10741 10742 10760 10762 10790 10791 
+ 10746 10759 10771 10787 10794 15509 
+ 7455 8151 8166 12039 15544 15579 
+ 10713 10733 10750 10779 10820 10861 
+ 10716 10721 10772 10781 10811 10821 
+ 10729 10734 10772 10779 10847 15510 
+ 10746 10756 10766 10780 10794 10801 
+ 10721 10729 10769 10770 10811 15510 
+ 10672 10726 10739 10827 10852 10870 
+ 10720 10735 10758 10798 10799 10809 
+ 10570 10621 10784 10792 10911 10936 
+ 10755 10757 10778 10786 10797 10800 
+ 10537 10662 10792 10844 10937 10945 
+ 10757 10759 10776 10787 10797 10803 
+ 10733 10734 10768 10770 10847 10861 
+ 10756 10771 10801 10806 
+ 10716 10735 10769 10798 10821 10831 
+ 10753 10760 10790 10808 
+ 10745 10762 10763 10791 10805 10812 
+ 10621 10625 10725 10775 10907 10911 
+ 10715 10740 10764 10796 10832 10834 
+ 10754 10755 10776 10789 10800 10807 
+ 10759 10766 10778 10794 10803 10810 
+ 10671 10738 10743 10853 10883 15511 
+ 10754 10758 10786 10799 10807 10813 
+ 10760 10765 10782 10791 10808 10815 
+ 10762 10765 10783 10790 10812 10815 
+ 10537 10570 10775 10777 10936 10945 
+ 10651 10674 10749 10843 10908 10951 
+ 10766 10771 10787 10801 10810 10819 
+ 10643 10664 10747 10761 10887 10921 10944 
+ 10740 10763 10785 10805 10834 10839 
+ 10776 10778 10800 10803 10817 
+ 10735 10774 10781 10809 10830 10831 
+ 10758 10774 10789 10809 10813 10826 
+ 10776 10786 10797 10807 10817 10824 
+ 10771 10780 10794 10806 10819 10825 
+ 10471 10478 10804 10846 11012 11014 
+ 10778 10787 10797 10810 10817 10828 
+ 10478 10526 10744 10802 10961 11014 
+ 10763 10783 10796 10812 10839 10845 
+ 10780 10801 10825 10833 
+ 10786 10789 10800 10813 10824 10835 
+ 10782 10790 10815 10836 
+ 10774 10798 10799 10826 10830 10838 
+ 10787 10794 10803 10819 10828 10837 
+ 10769 10772 10821 10850 10873 15510 
+ 10783 10791 10805 10815 10845 10848 
+ 10789 10799 10807 10826 10835 10849 
+ 10592 10639 10725 10893 10907 10988 
+ 10790 10791 10808 10812 10836 10848 
+ 10618 10644 10822 10859 10981 11007 
+ 10797 10800 10803 10824 10828 10841 
+ 10685 10738 10749 10908 15511 15514 
+ 10794 10801 10810 10825 10837 10851 
+ 10743 10750 10768 10853 10861 10900 
+ 10769 10781 10811 10831 10850 10864 
+ 10538 10618 10816 10823 10981 11010 
+ 10325 10538 10822 10875 11010 11076 
+ 10800 10807 10817 10835 10841 10855 
+ 10801 10806 10819 10833 10851 10860 
+ 10799 10809 10813 10838 10849 10863 
+ 10726 10748 10773 10829 10870 10891 10904 
+ 10803 10810 10817 10837 10841 10856 
+ 10748 10764 10827 10832 10885 10891 
+ 10798 10809 10831 10838 10858 
+ 10781 10798 10821 10830 10858 10864 10874 
+ 10764 10785 10829 10834 10881 10885 
+ 10806 10825 10860 10866 
+ 10785 10796 10832 10839 10880 10881 
+ 10807 10813 10824 10849 10855 10867 
+ 10808 10815 10848 10872 
+ 10810 10819 10828 10851 10856 10868 
+ 10809 10826 10830 10858 10863 10871 
+ 10796 10805 10834 10845 10879 10880 
+ 10727 10739 10852 10862 10920 10932 
+ 10817 10824 10828 10855 10856 10869 
+ 10106 10865 10897 11294 11322 15422 
+ 10674 10677 10793 10859 10951 10999 
+ 10662 10761 10777 10921 10937 10966 
+ 10805 10812 10839 10848 10877 10879 
+ 10471 10568 10802 10903 11012 11049 
+ 10770 10779 10861 10873 10914 15510 
+ 10812 10815 10836 10845 10872 10877 
+ 10813 10826 10835 10863 10867 10876 
+ 10811 10821 10864 10873 10892 
+ 10819 10825 10837 10860 10868 15512 
+ 10739 10773 10840 10870 10920 15513 
+ 10743 10788 10820 10883 10900 10928 
+ 10518 10661 10710 10952 10984 11070 
+ 10824 10835 10841 10867 10869 10878 
+ 10828 10837 10841 10868 10869 10884 
+ 7730 7911 11227 11933 13414 
+ 10830 10831 10838 10871 10874 10882 
+ 10644 10677 10816 10843 10999 11007 
+ 10825 10833 10851 10866 10888 15512 
+ 10768 10779 10820 10847 10900 10914 10954 
+ 10727 10747 10840 10887 10932 10950 
+ 10826 10838 10849 10871 10876 10890 
+ 10821 10831 10850 10874 10892 10905 
+ 9305 10842 11175 11322 15422 
+ 10833 10860 10888 10895 
+ 10835 10849 10855 10876 10878 10886 
+ 10837 10851 10856 10884 10898 15512 
+ 10841 10855 10856 10878 10884 10894 
+ 10773 10827 10852 10904 10931 15513 
+ 10838 10858 10863 10882 10890 10899 
+ 10836 10848 10877 10906 
+ 10811 10847 10850 10892 10914 10933 15510 
+ 10831 10858 10864 10882 10905 10909 
+ 10288 10325 10823 10897 11076 11198 
+ 10849 10863 10867 10886 10890 10902 
+ 10845 10848 10872 10879 10906 10913 
+ 10855 10867 10869 10886 10894 10901 
+ 10839 10845 10877 10880 10913 10915 
+ 10834 10839 10879 10881 10915 10918 
+ 10832 10834 10880 10885 10918 10922 
+ 10858 10871 10874 10899 10909 
+ 10788 10853 10928 10943 15511 
+ 10856 10868 10869 10894 10898 10912 
+ 10829 10832 10881 10891 10922 10925 
+ 10867 10876 10878 10901 10902 
+ 10747 10795 10862 10944 10950 10979 
+ 10860 10866 10895 10910 10919 15512 
+ 8935 9066 10199 10971 11074 11573 11578 
+ 10863 10871 10876 10899 10902 10916 
+ 10827 10829 10885 10904 10925 10935 
+ 10850 10864 10873 10905 10933 10942 
+ 10639 10751 10814 10988 10990 11048 
+ 10869 10878 10884 10901 10912 10923 
+ 10866 10888 10919 10924 
+ 9994 10403 10462 10930 10934 11179 11182 
+ 10106 10288 10842 10875 11198 11294 
+ 10868 10884 10910 10912 10927 15512 
+ 10871 10882 10890 10909 10916 10929 
+ 10820 10853 10861 10928 10954 10996 
+ 10878 10886 10894 10902 10923 10926 
+ 10876 10886 10890 10901 10916 10926 
+ 10568 10710 10846 10984 11049 11092 
+ 10827 10870 10891 10931 10935 10955 
+ 10864 10874 10892 10909 10940 10942 
+ 10872 10877 10913 10938 
+ 10725 10784 10814 10911 10988 11045 
+ 10749 10793 10818 10951 11025 11029 15514 
+ 10874 10882 10899 10905 10929 10940 
+ 10888 10898 10919 10927 10941 15512 
+ 10775 10784 10907 10936 11035 11045 
+ 10884 10894 10898 10923 10927 10948 
+ 10877 10879 10906 10915 10938 10947 
+ 10847 10861 10873 10933 10954 10983 
+ 10879 10880 10913 10918 10947 10953 
+ 10890 10899 10902 10926 10929 10959 
+ 10614 10744 10939 10961 11091 11097 
+ 10880 10881 10915 10922 10953 10957 
+ 10888 10895 10910 10924 10941 10949 
+ 10840 10852 10932 10969 10985 15513 
+ 10761 10795 10844 10944 10966 11001 
+ 10881 10885 10918 10925 10957 10960 
+ 10894 10901 10912 10926 10948 10963 
+ 10895 10919 10949 10956 
+ 10885 10891 10922 10935 10960 10962 
+ 10901 10902 10916 10923 10959 10963 
+ 10898 10910 10912 10941 10948 10965 
+ 10853 10883 10900 10943 10996 11005 
+ 10899 10909 10916 10940 10959 10970 
+ 10403 10548 10896 10975 11182 11215 
+ 10870 10904 10955 10964 10967 15513 
+ 10840 10862 10920 10950 10985 10997 
+ 10873 10892 10914 10942 10983 10991 
+ 10462 10731 10896 11072 11179 11204 
+ 10891 10904 10925 10955 10962 10968 
+ 10775 10792 10911 10945 11035 11040 
+ 10777 10844 10945 10966 11027 11047 
+ 10906 10913 10947 10972 
+ 10614 10698 10917 10958 11091 11131 
+ 10905 10909 10929 10942 10970 10986 
+ 10910 10919 10927 10949 10965 10973 
+ 10892 10905 10933 10940 10986 10991 
+ 10883 10928 11005 11015 15511 15514 
+ 10795 10887 10921 10979 11001 11026 
+ 10777 10792 10936 10937 11040 11047 
+ 8358 9305 9530 11175 11492 11859 
+ 10913 10915 10938 10953 10972 10977 
+ 10912 10923 10927 10963 10965 10982 
+ 10919 10924 10941 10956 10973 10974 
+ 10862 10887 10932 10979 10997 11020 
+ 10793 10843 10908 10999 11025 11065 
+ 10661 10703 10854 11019 11070 11149 
+ 10915 10918 10947 10957 10977 10980 
+ 10861 10900 10914 10983 10996 11039 
+ 10904 10931 10935 10964 10968 10976 
+ 10924 10949 10974 10978 
+ 10918 10922 10953 10960 10980 10987 
+ 10698 10751 10939 10990 11095 11131 
+ 10916 10926 10929 10963 10970 10995 
+ 10922 10925 10957 10962 10987 10992 
+ 10744 10804 10917 11014 11097 11102 
+ 10925 10935 10960 10968 10989 10992 
+ 10923 10926 10948 10959 10982 10995 11008 
+ 10931 10955 10967 10976 10993 
+ 10927 10941 10948 10973 10982 10998 
+ 10844 10921 10937 11001 11027 11052 
+ 10931 10964 10969 10993 11002 15513 
+ 10935 10955 10962 10976 10989 10994 
+ 10920 10967 10985 11002 11043 15513 
+ 10929 10940 10959 10986 10995 11022 
+ 8918 9066 10889 11034 11578 11733 
+ 10938 10947 10977 11004 
+ 10941 10949 10965 10974 10998 11000 
+ 10949 10956 10973 10978 11000 11006 
+ 10548 10573 10930 11036 11215 11271 
+ 10955 10964 10968 10993 10994 11003 
+ 10947 10953 10972 10980 11004 11013 
+ 10956 10974 11006 11009 
+ 10887 10944 10950 11020 11026 11059 
+ 10953 10957 10977 10987 11013 11016 
+ 10816 10822 11007 11010 11139 11158 
+ 10948 10963 10965 10998 11008 11021 
+ 10914 10933 10954 10991 11039 11042 
+ 10710 10854 10903 11070 11092 11176 
+ 10920 10932 10969 10997 11043 11044 
+ 10940 10942 10970 10991 11022 11030 
+ 10957 10960 10980 10992 11016 11018 
+ 10814 10893 10907 11045 11048 11120 
+ 10962 10968 10992 10994 11011 11017 
+ 10751 10893 10958 11048 11095 11121 
+ 10933 10942 10983 10986 11030 11042 
+ 10960 10962 10987 10989 11017 11018 
+ 10964 10967 10976 11002 11003 11023 
+ 10968 10976 10989 11003 11011 
+ 10959 10963 10970 11008 11022 11033 
+ 10900 10928 10954 11005 11039 11071 11103 
+ 10932 10950 10985 11020 11044 11058 
+ 10965 10973 10982 11000 11021 11024 
+ 10843 10859 10951 11007 11065 11141 
+ 10973 10974 10998 11006 11024 11031 
+ 10921 10944 10966 11026 11052 11062 
+ 10967 10969 10993 11023 11043 11057 
+ 10976 10993 10994 11011 11023 11032 
+ 10972 10977 11013 11046 
+ 10928 10943 10996 11015 11068 11071 
+ 10974 10978 11000 11009 11031 11038 
+ 10816 10859 10981 10999 11141 11158 
+ 10963 10982 10995 11021 11033 11056 
+ 10978 11006 11038 11041 
+ 10822 10823 10981 11076 11139 11180 
+ 10989 10994 11003 11017 11032 11050 
+ 10802 10846 11014 11049 11125 11157 
+ 10977 10980 11004 11016 11046 11053 
+ 10802 10804 10961 11012 11102 11125 11132 
+ 10943 11005 11029 11068 11093 15514 
+ 10980 10987 11013 11018 11053 11055 
+ 10989 10992 11011 11018 11050 11054 
+ 10987 10992 11016 11017 11054 11055 
+ 10703 10731 10952 11072 11149 11239 
+ 10950 10979 10997 11058 11059 11080 
+ 10982 10998 11008 11024 11056 11060 
+ 10970 10986 10995 11030 11033 11075 11078 
+ 10993 11002 11003 11032 11057 11063 
+ 10998 11000 11021 11031 11060 11061 
+ 10908 10951 11029 11065 11122 11136 
+ 10944 10979 11001 11059 11062 11085 
+ 10937 10966 11047 11052 11108 11109 
+ 8118 8472 11079 11137 12969 13265 
+ 10908 11015 11025 11093 11122 15514 
+ 10986 10991 11022 11042 11075 11086 
+ 11000 11006 11024 11038 11061 11064 
+ 11003 11011 11023 11050 11063 11069 
+ 10995 11008 11022 11056 11078 11083 
+ 8739 8918 10971 11079 11733 12178 
+ 10911 10936 11040 11045 11142 11150 
+ 10573 10666 10975 11267 11271 11445 
+ 8108 8722 9530 11492 11903 13212 
+ 11006 11009 11031 11041 11064 11067 
+ 10954 10983 10996 11042 11101 11103 
+ 10936 10945 11035 11047 11115 11150 
+ 11009 11038 11066 11067 
+ 10983 10991 11030 11039 11086 11101 
+ 10969 10985 11002 11044 11057 11084 11090 
+ 10985 10997 11043 11058 11084 11088 
+ 10907 10911 10988 11035 11120 11142 11184 
+ 11004 11013 11053 11073 
+ 10937 10945 11027 11040 11109 11115 
+ 10893 10988 10990 11120 11121 11145 
+ 10846 10903 11012 11092 11157 11206 
+ 11011 11017 11032 11054 11069 11077 
+ 5293 6549 7003 14806 14945 15040 
+ 10966 11001 11027 11062 11106 11108 
+ 11013 11016 11046 11055 11073 11081 
+ 11017 11018 11050 11055 11077 11082 
+ 11016 11018 11053 11054 11081 11082 
+ 11008 11021 11033 11060 11083 11087 
+ 11002 11023 11043 11063 11090 11099 
+ 10997 11020 11044 11080 11088 11107 
+ 10979 11020 11026 11080 11085 11105 
+ 11021 11024 11056 11061 11087 11089 
+ 11024 11031 11060 11064 11089 11094 
+ 11001 11026 11052 11085 11106 11124 
+ 11023 11032 11057 11069 11099 11104 
+ 11031 11038 11061 11067 11094 11098 
+ 10951 10999 11025 11136 11141 11188 
+ 11041 11067 11096 11100 
+ 11038 11041 11064 11066 11098 11100 
+ 11005 11015 11071 11093 11165 
+ 11032 11050 11063 11077 11104 11110 
+ 10854 10952 10984 11149 11176 11304 
+ 10996 11005 11068 11103 11165 11169 
+ 10731 10934 11019 11204 11239 11302 
+ 11046 11053 11081 11112 
+ 10199 10666 10889 11267 11573 11599 
+ 11022 11030 11078 11086 11113 11118 
+ 10823 10875 11010 11180 11198 11337 
+ 11050 11054 11069 11082 11110 11114 
+ 11022 11033 11075 11083 11111 11113 
+ 8118 8739 11028 11034 12178 12969 
+ 11020 11058 11059 11105 11107 11128 
+ 11053 11055 11073 11082 11112 11116 
+ 11054 11055 11077 11081 11114 11116 
+ 11033 11056 11078 11087 11111 11119 
+ 11043 11044 11088 11090 11126 11130 
+ 11026 11059 11062 11105 11124 11144 
+ 11030 11042 11075 11101 11118 11148 
+ 11056 11060 11083 11089 11117 11119 
+ 11044 11058 11084 11107 11123 11126 
+ 11060 11061 11087 11094 11117 11127 
+ 11043 11057 11084 11099 11130 11138 
+ 10917 10939 11097 11131 11216 11238 
+ 10903 10984 11049 11176 11206 11273 
+ 11015 11029 11068 11122 11165 11212 
+ 11061 11064 11089 11098 11127 11133 
+ 10958 10990 11121 11131 11200 11220 
+ 11066 11100 11129 11134 
+ 10917 10961 11091 11102 11216 11222 11249 
+ 11064 11067 11094 11100 11133 11135 
+ 11057 11063 11090 11104 11138 11143 
+ 11066 11067 11096 11098 11134 11135 
+ 11039 11042 11086 11103 11148 11183 
+ 10961 11014 11097 11132 11195 11222 
+ 10996 11039 11071 11101 11169 11183 
+ 11063 11069 11099 11110 11143 11147 
+ 11059 11080 11085 11128 11144 11160 
+ 11052 11062 11108 11124 11185 11186 
+ 11058 11080 11088 11123 11128 11151 
+ 11027 11052 11106 11109 11171 11185 
+ 11027 11047 11108 11115 11171 11178 
+ 11069 11077 11104 11114 11147 11153 
+ 11078 11083 11113 11119 11140 11146 
+ 11073 11081 11116 11155 
+ 11075 11078 11111 11118 11146 11152 
+ 11077 11082 11110 11116 11153 11156 
+ 11040 11047 11109 11150 11178 11190 
+ 11081 11082 11112 11114 11155 11156 
+ 11087 11089 11119 11127 11154 11159 
+ 11075 11086 11113 11148 11152 11172 
+ 11083 11087 11111 11117 11140 11154 
+ 10988 11045 11048 11145 11184 11211 11243 
+ 10990 11048 11095 11145 11200 11218 
+ 11025 11029 11093 11136 11212 11225 
+ 11088 11107 11126 11151 11162 
+ 11062 11085 11106 11144 11186 11191 
+ 11012 11014 11132 11157 11224 11254 
+ 11084 11088 11123 11130 11162 11163 
+ 11089 11094 11117 11133 11159 11166 
+ 11080 11105 11107 11151 11160 11174 
+ 11096 11134 11161 11164 
+ 11084 11090 11126 11138 11163 11168 
+ 10939 10958 11091 11095 11220 11238 11291 
+ 11014 11102 11125 11195 11224 
+ 11094 11098 11127 11135 11166 11170 
+ 11096 11100 11129 11135 11164 11167 
+ 11098 11100 11133 11134 11167 11170 
+ 11025 11065 11122 11188 11225 
+ 8472 8881 11028 11227 13265 13426 
+ 11090 11099 11130 11143 11168 11177 
+ 10981 11010 11158 11180 11310 11348 
+ 11111 11119 11146 11154 11173 
+ 10999 11007 11065 11158 11188 11316 
+ 11035 11045 11150 11184 11240 11261 
+ 11099 11104 11138 11147 11177 11181 
+ 11085 11105 11124 11160 11191 11201 
+ 11048 11120 11121 11211 11218 11234 
+ 11111 11113 11140 11152 11173 11193 
+ 11104 11110 11143 11153 11181 11187 
+ 11086 11101 11118 11172 11183 11213 
+ 10952 11019 11070 11239 11304 11355 
+ 11035 11040 11115 11142 11190 11240 11247 
+ 11107 11123 11128 11162 11174 15515 
+ 11113 11118 11146 11172 11193 11196 
+ 11110 11114 11147 11156 11187 11192 
+ 11117 11119 11140 11159 11173 11189 
+ 11112 11116 11156 15516 
+ 11114 11116 11153 11155 11192 15516 
+ 11012 11049 11125 11206 11254 11314 
+ 10981 11007 11139 11141 11316 11348 
+ 11117 11127 11154 11166 11189 11203 
+ 11105 11128 11144 11174 11201 11209 
+ 11129 11164 11194 11199 
+ 11123 11126 11151 11163 11197 15515 
+ 11126 11130 11162 11168 11197 11205 
+ 11129 11134 11161 11167 11199 11202 
+ 11068 11071 11093 11169 11212 11260 
+ 11127 11133 11159 11170 11203 11208 
+ 11134 11135 11164 11170 11202 11207 
+ 11130 11138 11163 11177 11205 11210 
+ 11071 11103 11165 11183 11260 11264 
+ 11133 11135 11166 11167 11207 11208 
+ 11108 11109 11178 11185 11226 11232 
+ 11118 11148 11152 11196 11213 
+ 11140 11146 11154 11189 11193 11233 
+ 11128 11151 11160 11209 11217 15515 
+ 9305 10865 10946 11322 11859 12320 
+ 10984 11070 11092 11273 11304 11365 
+ 11138 11143 11168 11181 11210 11214 
+ 11109 11115 11171 11190 11219 11232 
+ 10896 10934 11182 11204 11407 11410 
+ 11010 11076 11139 11310 11337 
+ 11143 11147 11177 11187 11214 11221 
+ 10896 10930 11179 11215 11407 11462 
+ 11101 11103 11148 11169 11213 11255 11264 
+ 11045 11120 11142 11243 11261 11289 
+ 11106 11108 11171 11186 11226 11230 11237 
+ 11106 11124 11185 11191 11230 11236 
+ 11147 11153 11181 11192 11221 11228 
+ 11065 11136 11141 11225 11316 11353 
+ 11154 11159 11173 11203 11233 11245 
+ 11115 11150 11178 11219 11247 11263 
+ 11124 11144 11186 11201 11236 11244 
+ 11153 11156 11187 11228 11231 15516 
+ 11146 11152 11173 11196 11233 11246 
+ 11161 11199 11223 11235 
+ 11102 11132 11222 11224 11287 
+ 11152 11172 11193 11213 11246 11256 
+ 11162 11163 11205 11229 11242 15515 
+ 10875 10897 11076 11294 11337 11621 
+ 11161 11164 11194 11202 11235 11241 
+ 11095 11121 11218 11220 11280 11312 
+ 11144 11160 11191 11209 11244 11252 
+ 11164 11167 11199 11207 11241 11248 
+ 11159 11166 11189 11208 11245 11253 
+ 10934 11072 11179 11302 11410 11426 
+ 11163 11168 11197 11210 11242 11251 
+ 11049 11092 11157 11273 11314 11372 
+ 11167 11170 11202 11208 11248 11250 
+ 11166 11170 11203 11207 11250 11253 
+ 11160 11174 11201 11217 11252 11258 
+ 11168 11177 11205 11214 11251 11257 
+ 11120 11145 11234 11243 11295 11297 
+ 11093 11122 11165 11225 11260 11364 11375 
+ 11148 11172 11183 11196 11255 11256 11266 
+ 11177 11181 11210 11221 11257 11265 
+ 10930 10975 11182 11271 11462 11500 
+ 11091 11097 11238 11249 11323 11335 
+ 11174 11209 11229 11258 11269 15515 
+ 11121 11145 11200 11234 11280 11286 
+ 11178 11190 11232 11263 11281 
+ 11095 11131 11200 11291 11312 11354 
+ 11181 11187 11214 11228 11265 11272 
+ 11097 11102 11195 11249 11287 11334 
+ 11194 11235 11259 11270 
+ 11125 11132 11195 11254 11287 11347 
+ 11122 11136 11188 11212 11353 11364 
+ 11171 11185 11232 11237 11274 11282 
+ 7730 8881 10857 11137 13414 13426 
+ 11187 11192 11221 11231 11272 11275 
+ 11197 11217 11242 11269 11278 15515 
+ 11185 11186 11236 11237 11262 11268 
+ 11192 11228 11275 15516 
+ 11171 11178 11219 11226 11281 11282 
+ 11173 11189 11193 11245 11246 11298 11306 
+ 11145 11211 11218 11286 11297 
+ 11194 11199 11223 11241 11270 11277 
+ 11186 11191 11230 11244 11268 11276 
+ 11185 11226 11230 11262 11274 
+ 11091 11131 11216 11291 11335 11373 
+ 11019 11072 11149 11302 11355 11443 
+ 11142 11150 11247 11261 11327 11339 
+ 11199 11202 11235 11248 11277 11279 
+ 11197 11205 11229 11251 11278 11283 
+ 11120 11184 11211 11289 11295 11308 
+ 11191 11201 11236 11252 11276 11285 
+ 11189 11203 11233 11253 11301 11306 
+ 11193 11196 11233 11256 11296 11298 
+ 11150 11190 11240 11263 11325 11327 
+ 11202 11207 11241 11250 11279 11284 
+ 11097 11216 11222 11323 11334 11382 
+ 11207 11208 11248 11253 11284 11290 
+ 11205 11210 11242 11257 11283 11293 
+ 11201 11209 11244 11258 11285 11300 
+ 11203 11208 11245 11250 11290 11301 
+ 11125 11157 11224 11314 11347 11389 
+ 11183 11213 11264 11266 11303 15517 
+ 11196 11213 11246 11266 11288 11296 
+ 11210 11214 11251 11265 11293 11305 
+ 11209 11217 11252 11269 11300 11311 
+ 11223 11270 11292 11307 
+ 11165 11169 11212 11264 11375 11385 
+ 11142 11184 11240 11289 11339 11362 
+ 11230 11237 11268 11274 11309 
+ 11190 11219 11247 11281 11325 11331 
+ 11169 11183 11255 11260 11385 15517 
+ 11214 11221 11257 11272 11305 11313 
+ 11213 11255 11256 11288 11303 11320 
+ 10666 11036 11074 11445 11599 11664 
+ 11230 11236 11262 11276 11309 11318 
+ 11217 11229 11258 11278 11311 11317 
+ 11223 11235 11259 11277 11307 11315 
+ 10975 11036 11215 11445 11500 11630 
+ 11221 11228 11265 11275 11313 11319 
+ 11092 11176 11206 11365 11372 11434 
+ 11226 11237 11262 11282 11309 11338 
+ 11228 11231 11272 11319 
+ 11236 11244 11268 11285 11318 11328 
+ 11235 11241 11270 11279 11315 11321 
+ 11229 11242 11269 11283 11317 11324 
+ 11241 11248 11277 11284 11321 11326 
+ 11200 11218 11286 11312 11358 11381 
+ 11219 11232 11263 11282 11331 11341 
+ 11226 11232 11274 11281 11338 11341 
+ 11242 11251 11278 11293 11324 11333 
+ 11248 11250 11279 11290 11326 11332 
+ 11244 11252 11276 11300 11328 11336 
+ 11218 11234 11280 11297 11346 11358 
+ 11195 11222 11224 11334 11347 11405 
+ 11256 11266 11296 11320 11329 
+ 11184 11243 11261 11308 11362 11367 
+ 11250 11253 11284 11301 11332 11344 
+ 11131 11220 11238 11354 11373 11412 
+ 11259 11307 11330 11340 
+ 11251 11257 11283 11305 11333 11343 
+ 10842 10897 11198 11322 11621 11962 
+ 11211 11243 11297 11308 11351 11359 
+ 11246 11256 11288 11298 11329 11342 
+ 11211 11234 11286 11295 11346 11351 
+ 11233 11246 11296 11306 11342 11360 
+ 6494 6562 8232 13260 14955 15024 
+ 11252 11258 11285 11311 11336 11345 
+ 11245 11253 11290 11306 11344 11357 
+ 11072 11204 11239 11426 11443 11506 
+ 11255 11266 11320 11349 15517 
+ 11070 11149 11176 11355 11365 11491 11514 
+ 11257 11265 11293 11313 11343 11352 
+ 11233 11245 11298 11301 11357 11360 11383 
+ 11259 11270 11292 11315 11340 11350 
+ 11243 11289 11295 11359 11367 
+ 11262 11268 11274 11318 11338 11374 11390 
+ 11139 11180 11337 11348 11556 11680 
+ 11258 11269 11300 11317 11345 11356 
+ 11200 11220 11280 11354 11381 11411 
+ 11265 11272 11305 11319 11352 11361 
+ 11157 11206 11254 11372 11389 11498 
+ 11270 11277 11307 11321 11350 11363 
+ 11141 11158 11188 11348 11353 11520 11534 
+ 11269 11278 11311 11324 11356 11366 
+ 11268 11276 11309 11328 11371 11374 
+ 11272 11275 11313 11361 
+ 11266 11288 11303 11329 11349 11368 
+ 11277 11279 11315 11326 11363 11370 
+ 10842 10865 11175 11294 11962 12320 
+ 11216 11249 11335 11382 11404 
+ 11278 11283 11317 11333 11366 11377 
+ 11247 11263 11327 11331 11397 11408 
+ 11279 11284 11321 11332 11370 11376 
+ 11240 11247 11325 11339 11408 11423 
+ 11276 11285 11318 11336 11371 11379 
+ 11288 11296 11320 11342 11368 11378 
+ 11292 11340 11369 11380 
+ 11263 11281 11325 11341 11396 11397 
+ 11284 11290 11326 11344 11376 11384 
+ 11283 11293 11324 11343 11377 11386 
+ 11222 11249 11287 11382 11405 11437 
+ 11216 11238 11323 11373 11404 11438 
+ 11285 11300 11328 11345 11379 11387 
+ 11076 11180 11198 11310 11621 11680 
+ 11274 11282 11309 11341 11390 11403 11406 
+ 11240 11261 11327 11362 11423 11441 
+ 11292 11307 11330 11350 11380 11391 
+ 11281 11282 11331 11338 11396 11406 
+ 11296 11298 11329 11360 11378 11395 
+ 11293 11305 11333 11352 11386 11394 
+ 11290 11301 11332 11357 11384 11388 
+ 11300 11311 11336 11356 11387 11393 
+ 11286 11297 11351 11358 11392 11421 
+ 11224 11254 11287 11389 11405 11485 
+ 11139 11158 11310 11316 11534 11556 
+ 11303 11320 11368 11398 11427 15517 
+ 11307 11315 11340 11363 11391 11399 
+ 11295 11297 11346 11359 11392 11422 
+ 11305 11313 11343 11361 11394 11401 
+ 11188 11225 11316 11364 11518 11520 
+ 11220 11291 11312 11411 11412 11458 
+ 11149 11239 11304 11443 11491 11545 
+ 11311 11317 11345 11366 11393 11402 
+ 11301 11306 11344 11383 11388 11416 
+ 11280 11286 11346 11381 11421 11447 
+ 11295 11308 11351 11367 11422 11431 
+ 11298 11306 11342 11383 11395 11414 
+ 11313 11319 11352 11401 
+ 11261 11289 11339 11367 11440 11441 
+ 11315 11321 11350 11370 11399 11409 
+ 11212 11225 11353 11375 11518 15519 
+ 11176 11273 11304 11434 11514 11548 
+ 11317 11324 11356 11377 11402 11415 
+ 11289 11308 11359 11362 11431 11440 
+ 11320 11329 11349 11378 11398 11413 
+ 11330 11380 11400 11417 
+ 11321 11326 11363 11376 11409 11419 
+ 11318 11328 11374 11379 11418 11420 
+ 11206 11273 11314 11434 11498 11531 
+ 11238 11291 11335 11412 11438 11472 
+ 11309 11318 11371 11390 11418 11430 
+ 11212 11260 11364 11385 11508 15519 
+ 11326 11332 11370 11384 11419 11425 
+ 11324 11333 11366 11386 11415 11429 
+ 11329 11342 11368 11395 11413 11432 
+ 11328 11336 11371 11387 11420 11428 
+ 11330 11340 11369 11391 11417 11433 
+ 11280 11312 11358 11411 11447 11489 
+ 11249 11323 11334 11404 11437 11473 
+ 11306 11357 11360 11414 11416 15518 
+ 11332 11344 11376 11388 11424 11425 
+ 11260 11264 11375 11427 11508 11513 15517 
+ 11333 11343 11377 11394 11429 11436 
+ 11336 11345 11379 11393 11428 11435 
+ 11344 11357 11384 11416 11424 
+ 11254 11314 11347 11485 11498 11538 
+ 11309 11338 11374 11403 11430 11442 
+ 11340 11350 11380 11399 11433 11444 
+ 11346 11351 11421 11422 11455 
+ 11345 11356 11387 11402 11435 11448 
+ 11343 11352 11386 11401 11436 11449 
+ 11342 11360 11378 11414 11432 11446 
+ 11331 11341 11397 11406 11456 11466 
+ 11325 11331 11396 11408 11466 11481 
+ 11349 11368 11413 11427 11451 
+ 11350 11363 11391 11409 11444 11453 
+ 11369 11417 11439 11452 
+ 11352 11361 11394 11449 
+ 11356 11366 11393 11415 11448 11454 
+ 11338 11390 11406 11442 11450 
+ 11323 11335 11382 11438 11473 11510 
+ 11287 11334 11347 11437 11485 11551 
+ 11338 11341 11396 11403 11450 11456 
+ 11179 11182 11410 11462 11583 11730 
+ 11325 11327 11397 11423 11481 11490 
+ 11363 11370 11399 11419 11453 11461 
+ 11179 11204 11407 11426 11583 11591 
+ 11312 11354 11381 11458 11486 11489 
+ 11291 11354 11373 11458 11472 11501 
+ 11368 11378 11398 11432 11451 11468 
+ 11360 11383 11395 11446 11470 15518 
+ 11366 11377 11402 11429 11454 11463 
+ 11357 11383 11388 11424 11457 15518 
+ 11369 11380 11400 11433 11452 11469 
+ 11371 11374 11420 11430 11459 11460 
+ 11370 11376 11409 11425 11461 11467 
+ 11371 11379 11418 11428 11459 11464 
+ 11346 11358 11392 11447 11455 11478 
+ 11351 11359 11392 11431 11455 11482 11484 
+ 11327 11339 11408 11441 11490 11532 
+ 11384 11388 11416 11425 11457 11465 
+ 11376 11384 11419 11424 11465 11467 
+ 11204 11302 11410 11506 11591 11603 
+ 11349 11385 11398 11451 11495 11513 15517 
+ 11379 11387 11420 11435 11464 11475 
+ 11377 11386 11415 11436 11463 11476 
+ 11374 11390 11418 11442 11460 11471 
+ 11359 11367 11422 11440 11484 11523 
+ 11378 11395 11413 11446 11468 11483 
+ 11380 11391 11417 11444 11469 11479 
+ 11273 11365 11372 11531 11548 11549 
+ 11387 11393 11428 11448 11475 11480 
+ 11386 11394 11429 11449 11476 11487 
+ 11334 11382 11405 11473 11551 11567 
+ 11335 11373 11404 11472 11510 11542 
+ 11400 11452 11474 11488 
+ 11362 11367 11431 11441 11519 11523 
+ 11339 11362 11423 11440 11519 11532 
+ 11390 11403 11430 11450 11471 11477 
+ 11239 11302 11355 11506 11545 11618 
+ 11391 11399 11433 11453 11479 11496 
+ 11036 11267 11271 11630 11664 11868 
+ 11395 11414 11432 11470 11483 
+ 11358 11381 11421 11478 11489 11553 
+ 11393 11402 11435 11454 11480 11493 
+ 11394 11401 11436 11487 
+ 11403 11406 11442 11456 11477 11497 
+ 11398 11413 11427 11468 11495 11502 
+ 11400 11417 11439 11469 11488 11503 
+ 11399 11409 11444 11461 11496 11509 
+ 11402 11415 11448 11463 11493 11504 
+ 11392 11421 11422 11478 11482 11525 
+ 11396 11406 11450 11466 11497 11517 
+ 11416 11424 11465 11522 11528 15518 
+ 11354 11411 11412 11486 11501 11544 
+ 11418 11420 11460 11464 11499 11505 
+ 11418 11430 11459 11471 11494 11499 
+ 11409 11419 11453 11467 11509 11515 
+ 11182 11215 11407 11500 11730 11738 
+ 11415 11429 11454 11476 11504 11516 
+ 11420 11428 11459 11475 11505 11511 
+ 11424 11425 11457 11467 11526 11528 
+ 11396 11397 11456 11481 11517 11563 
+ 11419 11425 11461 11465 11515 11526 
+ 11413 11432 11451 11483 11502 11529 
+ 11417 11433 11452 11479 11503 11521 
+ 11414 11446 11483 11522 11547 15518 
+ 11430 11442 11460 11477 11494 11512 
+ 11373 11412 11438 11501 11542 11574 
+ 11382 11404 11437 11510 11567 11597 
+ 11439 11488 11507 11527 
+ 11428 11435 11464 11480 11511 11524 
+ 11429 11436 11463 11487 11516 11530 
+ 11442 11450 11471 11497 11512 11535 
+ 11421 11447 11455 11525 11553 11558 
+ 11433 11444 11469 11496 11521 11536 
+ 11435 11448 11475 11493 11524 11533 
+ 11397 11408 11466 11490 11555 11563 
+ 11422 11455 11484 11525 11550 
+ 11432 11446 11468 11470 11529 11547 
+ 11422 11431 11482 11523 11550 11560 
+ 11347 11389 11405 11538 11551 11584 
+ 11411 11458 11489 11544 11577 
+ 11436 11449 11476 11530 
+ 11439 11452 11474 11503 11527 11540 
+ 11381 11411 11447 11486 11553 11577 11588 
+ 11408 11423 11481 11532 11555 11575 
+ 11304 11355 11514 11545 11633 11674 
+ 9530 10946 11037 11859 13212 13588 
+ 11448 11454 11480 11504 11533 11543 
+ 11460 11471 11499 11512 11537 
+ 11427 11451 11502 11513 11546 
+ 11444 11453 11479 11509 11536 11554 
+ 11450 11456 11477 11517 11535 11568 
+ 11314 11372 11389 11531 11538 11634 11644 
+ 11459 11460 11494 11505 11537 11541 
+ 11215 11271 11462 11630 11738 11896 
+ 11412 11458 11472 11544 11574 11595 
+ 11451 11468 11495 11529 11546 11569 
+ 11452 11469 11488 11521 11540 11559 
+ 11454 11463 11493 11516 11543 11557 
+ 11459 11464 11499 11511 11541 11552 
+ 11302 11426 11443 11603 11618 11690 
+ 11474 11527 11539 11561 
+ 11375 11385 11513 11607 11648 15519 
+ 11453 11461 11496 11515 11554 11565 
+ 11404 11438 11473 11542 11597 11655 
+ 11464 11475 11505 11524 11552 11562 
+ 11471 11477 11494 11535 11537 11564 
+ 11385 11427 11495 11508 11546 11607 11611 
+ 11304 11365 11491 11548 11633 11651 
+ 11461 11467 11509 11526 11565 11581 
+ 11463 11476 11504 11530 11557 11566 
+ 11456 11466 11497 11563 11568 11594 
+ 11353 11364 11520 11763 11951 15519 
+ 11440 11441 11523 11532 11587 11608 
+ 11316 11353 11518 11534 11951 
+ 11469 11479 11503 11536 11559 11570 
+ 11457 11470 11528 11547 11620 11643 15518 
+ 11431 11440 11484 11519 11560 11587 11605 
+ 11475 11480 11511 11533 11562 15520 
+ 11455 11478 11482 11550 11558 11579 
+ 11465 11467 11515 11528 11581 11598 
+ 11474 11488 11507 11540 11561 11576 
+ 11457 11465 11522 11526 11598 11620 
+ 11468 11483 11502 11547 11569 11616 
+ 11476 11487 11516 11566 
+ 11372 11434 11498 11549 11644 11656 
+ 11423 11441 11490 11519 11575 11608 11624 
+ 11480 11493 11524 11543 11580 15520 
+ 11316 11348 11520 11556 11951 12643 
+ 11477 11497 11512 11564 11568 11589 
+ 11479 11496 11521 11554 11570 11585 
+ 11494 11499 11512 11541 11564 11572 
+ 11389 11485 11498 11584 11634 11645 
+ 11507 11561 11571 11586 
+ 11488 11503 11527 11559 11576 11592 
+ 11499 11505 11537 11552 11572 11582 
+ 11438 11472 11510 11574 11647 11655 
+ 11493 11504 11533 11557 11580 11590 
+ 11458 11486 11501 11577 11595 11619 
+ 11355 11443 11491 11618 11674 11744 
+ 11495 11502 11513 11569 11611 11614 
+ 11470 11483 11522 11529 11616 11643 
+ 11365 11434 11514 11549 11651 11660 
+ 11434 11531 11548 11656 11660 
+ 11482 11484 11525 11560 11579 11596 
+ 11405 11437 11485 11567 11584 11669 11699 
+ 11505 11511 11541 11562 11582 11593 
+ 11447 11478 11489 11558 11588 11617 11640 
+ 11496 11509 11536 11565 11585 11606 
+ 11481 11490 11563 11575 11622 11627 
+ 11310 11348 11534 11680 12643 
+ 11504 11516 11543 11566 11590 11602 
+ 11478 11525 11553 11579 11612 11617 
+ 11503 11521 11540 11570 11592 11610 
+ 11484 11523 11550 11596 11605 15521 
+ 11507 11527 11539 11576 11586 11609 
+ 11511 11524 11552 11593 11601 15520 
+ 11466 11481 11517 11555 11594 11622 11636 
+ 11512 11535 11537 11572 11589 11604 
+ 11509 11515 11554 11581 11606 11626 
+ 11516 11530 11557 11602 
+ 11437 11473 11551 11597 11669 11675 
+ 11497 11517 11535 11589 11594 11650 
+ 11502 11529 11546 11614 11616 15522 
+ 11521 11536 11559 11585 11610 11625 
+ 11539 11586 11600 11623 
+ 11537 11541 11564 11582 11604 11615 
+ 10889 11074 11578 11599 12469 12876 
+ 11472 11501 11542 11595 11647 11701 
+ 11490 11532 11555 11624 11627 11653 
+ 11527 11540 11561 11592 11609 11632 
+ 11486 11489 11544 11588 11619 11639 
+ 10889 10971 11573 11733 12876 13315 
+ 11525 11550 11558 11596 11612 11628 
+ 11533 11543 11590 11613 11629 15520 
+ 11515 11526 11565 11598 11626 11652 
+ 11541 11552 11572 11593 11615 11631 
+ 11407 11410 11591 11730 11809 11880 
+ 11485 11538 11551 11645 11677 11699 
+ 11536 11554 11570 11606 11625 11646 
+ 11539 11561 11571 11609 11623 11642 
+ 11519 11523 11605 11608 11658 11661 
+ 11489 11553 11577 11639 11640 11685 
+ 11535 11564 11568 11604 11650 15523 
+ 11543 11557 11580 11602 11629 11641 
+ 11410 11426 11583 11603 11728 11809 
+ 11540 11559 11576 11610 11632 11649 
+ 11552 11562 11582 11601 11631 11638 
+ 11517 11563 11568 11636 11650 11671 
+ 11501 11544 11574 11619 11684 11701 
+ 11550 11560 11579 11628 11637 15521 
+ 11473 11510 11567 11655 11675 11711 
+ 11526 11528 11581 11620 11652 11682 
+ 11074 11267 11573 11664 12331 12469 
+ 11571 11623 11635 11657 
+ 11562 11593 11613 11638 11654 15520 
+ 11557 11566 11590 11641 
+ 11426 11506 11591 11690 11728 11804 
+ 11564 11572 11589 11615 11659 15523 
+ 11523 11560 11587 11661 11673 15521 
+ 11554 11565 11585 11626 11646 11662 
+ 11508 11513 11611 11648 11689 11710 
+ 11519 11532 11587 11624 11658 11678 11702 
+ 11561 11576 11586 11632 11642 15524 
+ 11559 11570 11592 11625 11649 11667 
+ 11513 11546 11607 11614 11681 11689 
+ 11558 11579 11617 11628 11666 11672 
+ 11580 11601 11629 11654 11663 15520 
+ 11546 11569 11611 11681 15522 
+ 11572 11582 11604 11631 11659 11665 
+ 11529 11547 11569 11643 11722 15522 
+ 11553 11558 11612 11640 11672 11692 
+ 11443 11506 11545 11690 11744 11829 
+ 11544 11577 11595 11639 11684 11694 
+ 11522 11528 11598 11643 11682 11717 
+ 11198 11294 11337 11680 11962 13075 
+ 11555 11563 11627 11636 11687 11691 
+ 11571 11586 11600 11642 11657 11683 
+ 11532 11575 11608 11653 11678 11688 
+ 11570 11585 11610 11646 11667 11693 
+ 11565 11581 11606 11652 11662 15525 
+ 11555 11575 11622 11653 11687 11695 
+ 11579 11596 11612 11637 11666 11670 
+ 11580 11590 11613 11641 11663 11686 
+ 11271 11445 11500 11868 11896 12269 
+ 11582 11593 11615 11638 11665 11679 
+ 11576 11592 11609 11649 11698 15524 
+ 11491 11514 11651 11674 11805 11843 
+ 11498 11538 11644 11645 11754 11779 
+ 11600 11657 11668 11700 
+ 11563 11594 11622 11671 11691 11707 
+ 11596 11628 11670 11676 15521 
+ 11593 11601 11631 11654 11679 11697 
+ 11577 11588 11619 11685 11694 11696 
+ 11553 11588 11617 11685 11692 11712 
+ 11590 11602 11629 11686 
+ 11586 11609 11623 11683 11704 15524 
+ 11522 11547 11616 11620 11717 11722 11815 
+ 11498 11531 11634 11656 11779 11788 
+ 11538 11584 11634 11677 11754 11759 
+ 11585 11606 11625 11662 11693 11705 
+ 11542 11574 11655 11701 11760 11773 
+ 11508 11607 11710 11763 11835 15519 
+ 11592 11610 11632 11667 11698 11713 
+ 11568 11589 11594 11671 11731 11739 15523 
+ 11514 11548 11633 11660 11805 11861 
+ 11581 11598 11626 11682 11721 15525 
+ 11575 11624 11627 11688 11695 11709 
+ 11601 11613 11638 11663 11697 11706 
+ 11510 11542 11597 11647 11711 11760 11794 
+ 11531 11549 11644 11660 11788 11813 
+ 11600 11623 11635 11683 11700 11716 
+ 11587 11608 11661 11702 11725 11729 
+ 11604 11615 11665 11708 11714 15523 
+ 11548 11549 11651 11656 11813 11861 
+ 11587 11605 11658 11673 11729 11736 
+ 11606 11626 11646 11705 11715 15525 
+ 11613 11629 11654 11686 11706 11726 
+ 11267 11445 11599 11868 12164 12331 
+ 11615 11631 11659 11679 11708 11718 
+ 11612 11628 11670 11672 11720 11732 
+ 11610 11625 11649 11693 11713 11742 
+ 11635 11700 11703 11734 
+ 11551 11567 11675 11699 11758 11768 
+ 11628 11637 11666 11676 11720 11723 
+ 11594 11636 11650 11707 11739 11756 
+ 11612 11617 11666 11692 11732 11745 
+ 11605 11661 11676 11735 11736 15521 
+ 11491 11545 11633 11744 11843 11918 
+ 11567 11597 11669 11711 11758 11791 
+ 11637 11670 11673 11723 11735 15521 
+ 11584 11645 11699 11759 11782 
+ 11608 11624 11688 11702 11719 11727 
+ 11631 11638 11665 11697 11718 11737 
+ 11310 11337 11556 11621 12643 13075 
+ 11611 11614 11689 11786 11803 15522 
+ 11598 11620 11652 11717 11721 11771 
+ 11623 11642 11657 11704 11716 11746 
+ 11595 11619 11694 11701 11780 11795 
+ 11588 11639 11640 11696 11712 11749 
+ 11629 11641 11663 11726 
+ 11622 11627 11691 11695 11740 11743 
+ 11624 11653 11678 11709 11719 11724 
+ 11607 11611 11681 11710 11786 11789 
+ 11506 11603 11618 11804 11829 11984 
+ 11622 11636 11687 11707 11743 11752 
+ 11617 11640 11672 11712 11745 11764 
+ 11625 11646 11667 11705 11742 11762 
+ 11619 11639 11684 11696 11765 11780 
+ 11627 11653 11687 11709 11740 11748 
+ 11639 11685 11694 11749 11765 
+ 11638 11654 11679 11706 11737 11747 
+ 11632 11649 11713 11741 11769 15524 
+ 11551 11584 11669 11677 11768 11782 11814 
+ 11635 11657 11668 11716 11734 11761 
+ 11574 11595 11647 11684 11773 11795 11830 
+ 11608 11658 11678 11725 11727 11755 11757 
+ 11668 11734 11772 15526 
+ 11642 11683 11741 11746 11785 15524 
+ 11646 11662 11693 11715 11762 11778 
+ 11654 11663 11697 11726 11747 11770 
+ 11636 11671 11691 11752 11756 11790 
+ 11659 11665 11714 11718 11766 11767 
+ 11653 11688 11695 11724 11748 11753 
+ 11607 11648 11689 11789 11835 
+ 11597 11655 11675 11791 11794 11842 
+ 11640 11685 11692 11749 11764 11811 
+ 11649 11667 11698 11742 11769 11806 
+ 11659 11708 11731 11766 11775 15523 
+ 11662 11705 11778 11787 15525 
+ 11657 11683 11700 11746 11761 11797 
+ 11620 11643 11682 11771 11815 11885 
+ 11665 11679 11708 11737 11767 11776 
+ 11678 11688 11724 11727 11750 11751 
+ 11666 11670 11723 11732 11777 11784 
+ 11652 11682 11771 11787 11860 15525 
+ 11616 11643 11803 11815 11956 15522 
+ 11670 11676 11720 11735 11777 11781 
+ 11688 11709 11719 11751 11753 
+ 11658 11702 11729 11757 11774 
+ 11663 11686 11706 11770 
+ 11678 11702 11719 11750 11755 
+ 11591 11603 11804 11809 12010 
+ 11658 11661 11725 11736 11774 11810 
+ 11407 11462 11583 11738 11880 12208 12232 
+ 11650 11714 11739 11775 11796 11816 15523 
+ 11666 11672 11720 11745 11784 11808 
+ 10971 11034 11578 12178 13315 13654 
+ 11668 11700 11703 11761 11772 11812 
+ 11673 11676 11723 11736 11781 11818 
+ 11661 11673 11729 11735 11810 11818 
+ 11679 11697 11718 11747 11776 11799 
+ 11462 11500 11730 11896 12232 12409 
+ 11650 11671 11731 11756 11796 11802 11849 
+ 11687 11695 11743 11748 11792 11798 
+ 11698 11704 11769 11785 11826 15524 
+ 11667 11693 11713 11762 11806 11841 
+ 11687 11691 11740 11752 11792 15528 
+ 11545 11618 11674 11829 11918 12045 
+ 11672 11692 11732 11764 11808 11867 
+ 11683 11704 11716 11785 11797 11836 
+ 11697 11706 11737 11770 11799 11820 
+ 11695 11709 11740 11753 11798 11801 
+ 11685 11696 11712 11765 11811 11857 
+ 11719 11727 11751 11755 11793 11800 
+ 11719 11724 11750 11753 11793 11807 
+ 11691 11707 11743 11790 11851 15528 
+ 11709 11724 11748 11751 11801 11807 
+ 11634 11645 11759 11779 11895 12004 
+ 11702 11727 11750 11757 11800 15527 
+ 11671 11707 11739 11790 11802 11827 
+ 11702 11725 11755 11774 11824 15527 
+ 11669 11675 11768 11791 11834 11852 
+ 11645 11677 11754 11782 11881 11895 
+ 11647 11655 11773 11794 11892 11893 
+ 11700 11716 11734 11797 11812 11848 
+ 11693 11705 11742 11778 11841 11887 
+ 11518 11648 11835 11951 12361 15519 
+ 11692 11712 11745 11811 11867 11878 
+ 11694 11696 11749 11780 11857 11858 
+ 11708 11714 11767 11775 11819 11821 
+ 11708 11718 11766 11776 11819 11833 
+ 11669 11699 11758 11814 11834 11844 
+ 11698 11713 11741 11806 11826 11876 
+ 11706 11726 11747 11820 
+ 11682 11717 11721 11860 11885 11942 
+ 11703 11734 11812 11817 11853 15526 
+ 11647 11701 11760 11830 11892 11922 
+ 11725 11729 11757 11810 11824 11840 
+ 11714 11731 11766 11816 11821 11825 
+ 11718 11737 11767 11799 11833 11846 
+ 11720 11723 11781 11784 11832 11850 
+ 11705 11715 11762 11787 11887 11941 
+ 11634 11644 11754 11788 11971 12004 
+ 11684 11694 11765 11795 11858 11901 
+ 11723 11735 11777 11818 11850 11865 
+ 11677 11699 11759 11814 11881 11906 
+ 11817 11831 11866 15526 
+ 11720 11732 11777 11808 11832 11855 
+ 11704 11741 11746 11826 11836 11884 
+ 11681 11689 11789 11803 11974 
+ 11715 11721 11778 11860 11941 15525 
+ 11644 11656 11779 11813 11971 12014 
+ 11689 11710 11786 11835 11974 12230 
+ 11707 11752 11756 11827 11851 15529 
+ 11675 11711 11758 11842 11852 11902 
+ 11740 11743 11798 11828 11845 15528 
+ 11750 11751 11800 11807 11823 11838 
+ 11655 11711 11760 11842 11893 11923 
+ 11684 11701 11780 11830 11901 11929 
+ 11731 11739 11816 11839 11849 11872 
+ 11716 11746 11761 11836 11848 11894 
+ 11740 11748 11792 11801 11828 11847 
+ 11737 11747 11776 11820 11846 15530 
+ 11750 11755 11793 11822 11823 11837 15527 
+ 11748 11753 11798 11807 11847 11854 
+ 11739 11756 11827 11849 11862 11873 
+ 11681 11722 11786 11956 11974 12095 15522 
+ 11603 11690 11728 11984 12010 12239 
+ 11633 11651 11843 11861 12106 12119 
+ 11713 11742 11769 11841 11876 11939 
+ 11751 11753 11793 11801 11838 11854 11863 
+ 11732 11745 11784 11855 11867 11897 
+ 11583 11591 11728 11880 12010 12191 
+ 11729 11736 11774 11818 11840 11889 11891 
+ 11712 11749 11764 11857 11878 11927 
+ 11734 11761 11772 11848 11853 11905 
+ 11656 11660 11788 11861 12014 12074 
+ 11699 11768 11782 11844 11906 11945 
+ 11643 11717 11722 11885 11956 12006 
+ 11731 11775 11796 11825 11839 11856 
+ 11772 11783 11853 11866 11910 15526 
+ 11735 11736 11781 11810 11865 11889 11917 
+ 11766 11767 11821 11833 11874 11883 
+ 11747 11770 11799 15530 
+ 11766 11775 11819 11825 11869 11874 
+ 11800 11824 11837 11871 11879 15527 
+ 11793 11800 11837 11838 11864 
+ 11757 11774 11822 11840 11879 11908 15527 
+ 11775 11816 11821 11856 11869 
+ 11741 11769 11785 11876 11884 11946 
+ 11756 11790 11802 11870 11873 15529 
+ 11792 11798 11845 11847 11890 
+ 11618 11690 11744 11984 12045 12248 
+ 11701 11773 11795 11922 11929 11992 
+ 11783 11866 11877 11919 
+ 11777 11784 11850 11855 11900 
+ 11767 11776 11819 11846 11883 11899 
+ 11758 11768 11844 11852 11914 11940 
+ 11648 11710 11763 11789 12230 12361 
+ 11746 11785 11797 11884 11894 11948 
+ 11800 11822 11823 11864 11871 11875 
+ 11793 11807 11823 11863 11864 11886 
+ 11796 11816 11856 11872 11888 
+ 11774 11810 11824 11891 11908 11931 
+ 11742 11762 11806 11887 11939 12013 
+ 11711 11791 11794 11902 11923 11965 
+ 11633 11674 11805 11918 12106 12138 
+ 11768 11814 11834 11940 11945 
+ 11792 11828 11882 11890 11920 15528 
+ 11776 11799 11833 11899 11932 15530 
+ 11798 11801 11828 11854 11890 11909 
+ 11761 11797 11812 11894 11905 11960 
+ 11739 11796 11802 11862 11872 11911 11921 
+ 11777 11781 11832 11865 11900 11944 
+ 11752 11790 11882 11926 11972 15528 15529 
+ 11758 11791 11834 11902 11914 11982 
+ 11772 11812 11817 11905 11910 11968 
+ 11801 11807 11847 11863 11909 11924 
+ 11784 11808 11832 11897 11900 11947 
+ 11816 11825 11839 11869 11888 11907 
+ 11749 11765 11811 11858 11927 11959 11967 
+ 11765 11780 11857 11901 11967 11991 
+ 10946 11175 11492 12320 13588 13730 
+ 11721 11771 11787 11941 11942 12067 
+ 11651 11660 11805 11813 12074 12119 12279 
+ 11802 11849 11873 11911 11913 
+ 11807 11838 11854 11886 11924 11934 
+ 11823 11837 11838 11875 11886 11898 
+ 11781 11818 11850 11917 11944 11969 
+ 11783 11817 11831 11910 11919 11973 
+ 11745 11764 11808 11878 11897 11983 12020 
+ 11445 11630 11664 12164 12269 12600 
+ 11821 11825 11856 11874 11907 11928 
+ 11827 11873 11912 11916 15529 
+ 11822 11837 11875 11879 11904 11915 
+ 11796 11839 11849 11888 11921 11935 
+ 11802 11827 11862 11870 11912 11913 
+ 11819 11821 11869 11883 11928 11943 
+ 11837 11864 11871 11898 11904 
+ 11769 11806 11826 11939 11946 12015 
+ 11831 11919 11930 11979 
+ 11764 11811 11867 11927 11983 11990 
+ 11822 11824 11871 11908 11915 11938 
+ 11583 11730 11809 12191 12208 12366 
+ 11759 11782 11895 11906 11994 12054 
+ 11845 11851 11920 11952 11972 15528 
+ 11819 11833 11874 11899 11943 11955 
+ 11785 11826 11836 11946 11948 12016 
+ 11717 11771 11815 11942 12006 12041 
+ 11838 11863 11864 11898 11925 11934 
+ 11762 11778 11841 11941 12013 12140 
+ 11839 11856 11872 11907 11935 11949 
+ 11810 11818 11891 11917 11957 11975 
+ 11828 11845 11847 11909 11920 11954 11978 
+ 11810 11840 11889 11931 11957 11970 
+ 11760 11773 11893 11922 12035 12064 
+ 11760 11794 11892 11923 12035 12047 
+ 11797 11836 11848 11948 11960 12023 
+ 11754 11759 11881 12004 12054 12149 
+ 11500 11630 11738 12269 12409 12725 
+ 11808 11855 11867 11947 12003 12020 
+ 11864 11875 11886 11904 11925 11937 
+ 11833 11846 11883 11932 11955 11989 
+ 11832 11850 11855 11944 11947 11986 
+ 11780 11795 11858 11929 11991 12076 
+ 11791 11842 11852 11965 11982 12053 
+ 8722 10539 11037 13212 13752 14084 
+ 11871 11875 11898 11915 11936 11937 
+ 11812 11848 11853 11960 11968 12032 
+ 11782 11814 11881 11945 11994 12058 
+ 11856 11869 11888 11928 11949 11976 
+ 11824 11840 11879 11931 11938 11993 12007 
+ 11847 11854 11890 11924 11978 11985 
+ 11817 11853 11866 11968 11973 12033 
+ 11849 11862 11913 11921 11958 11963 
+ 11870 11873 11913 11916 11953 11964 
+ 11862 11873 11911 11912 11953 11958 
+ 11834 11852 11940 11982 12040 
+ 11871 11879 11904 11936 11938 11950 
+ 11870 11912 11926 11964 11988 15529 
+ 11818 11865 11889 11969 11975 12009 
+ 11674 11744 11843 12045 12138 12282 
+ 11831 11866 11877 11973 11979 12031 
+ 11845 11882 11890 11952 11954 12002 
+ 11849 11872 11911 11935 11963 11981 
+ 11773 11830 11892 11992 12064 12086 
+ 11794 11842 11893 11965 12028 12047 
+ 11854 11863 11909 11934 11980 11985 
+ 11886 11898 11934 11937 11966 11977 
+ 11851 11916 11972 11988 12027 15529 
+ 11811 11857 11878 11959 11990 12030 
+ 11869 11874 11907 11943 11976 11998 
+ 11795 11830 11901 11992 12076 12077 
+ 11877 11979 11987 12037 
+ 11840 11891 11908 11970 11993 12008 
+ 11846 11899 11989 15530 
+ 7911 10635 10857 13414 14090 14593 
+ 11863 11886 11924 11925 11977 11980 15531 
+ 11872 11888 11921 11949 11981 12000 
+ 11904 11915 11937 11950 11961 
+ 11898 11904 11925 11936 11961 11966 
+ 11879 11908 11915 11950 12001 12007 
+ 11806 11841 11876 12013 12015 12109 
+ 11834 11844 11914 11945 12040 12113 
+ 11778 11787 11860 11887 12067 12140 12231 
+ 11771 11860 11885 12041 12067 12152 
+ 11874 11883 11928 11955 11998 12012 
+ 11850 11865 11900 11969 11986 12034 12036 
+ 11814 11844 11906 11940 12058 12113 
+ 11826 11876 11884 12015 12016 12085 
+ 11855 11897 11900 11986 12003 12022 
+ 11836 11884 11894 12016 12023 12090 
+ 11888 11907 11935 11976 12000 12018 
+ 11915 11936 11938 11961 11995 12001 
+ 11518 11520 11534 11763 12361 12643 13136 
+ 11882 11920 11972 12002 12052 
+ 11912 11913 11958 11964 11997 12011 
+ 11890 11920 11978 12002 12019 
+ 11883 11899 11943 11989 12012 12048 
+ 11722 11803 11815 12006 12095 12300 
+ 11889 11891 11970 11975 12021 12024 
+ 11911 11913 11953 11963 11997 12005 
+ 11857 11927 11967 12030 12079 
+ 11848 11894 11905 12023 12032 12108 
+ 11936 11937 11950 11966 11995 11999 
+ 11294 11322 11621 12320 13075 13578 
+ 11911 11921 11958 11981 12005 15532 
+ 11912 11916 11953 11988 12011 12046 
+ 11842 11902 11923 12028 12053 12116 
+ 11925 11937 11961 11977 11996 11999 
+ 11857 11858 11959 11991 12079 12111 
+ 11853 11905 11910 12032 12033 12110 
+ 11865 11917 11944 12009 12036 12059 
+ 11891 11931 11957 12008 12021 12038 
+ 11779 11788 12004 12014 12244 12285 
+ 11851 11882 11926 11952 12027 12052 12120 
+ 11866 11910 11919 12031 12033 12105 
+ 11786 11789 11803 12095 12230 12329 
+ 11889 11917 11957 12009 12024 12051 
+ 11907 11928 11949 11998 12018 12049 
+ 11925 11934 11966 11996 12017 15531 
+ 11890 11909 11954 11985 12019 12056 
+ 11877 11919 11930 12031 12037 12097 
+ 11924 11934 11985 12043 12055 15531 
+ 11921 11935 11963 12000 12050 15532 
+ 11852 11902 11914 12040 12053 12136 
+ 11867 11878 11990 12020 12092 12103 
+ 11690 11804 11829 12239 12248 12502 
+ 11909 11924 11978 11980 12043 12056 
+ 11900 11944 11947 12022 12034 12062 
+ 11930 12037 12044 12096 
+ 11916 11926 11964 12027 12046 12081 
+ 11899 11932 11955 12048 
+ 11878 11927 11983 12030 12092 12130 
+ 11858 11901 11967 12076 12111 12153 
+ 11830 11922 11929 12077 12086 12159 
+ 11908 11931 12007 12008 12060 12066 
+ 11881 11906 12054 12058 12160 
+ 11950 11961 11999 12001 12026 12029 
+ 11966 11977 11999 12017 12025 
+ 11953 11958 12005 12011 12042 
+ 11928 11943 11976 12012 12049 12071 
+ 11961 11966 11995 11996 12025 12029 
+ 11935 11949 11981 12018 12050 12068 
+ 11938 11950 11995 12007 12026 12057 
+ 11920 11952 11954 12019 12052 12080 
+ 11897 11947 12020 12022 12082 12101 
+ 11754 11779 11895 11971 12149 12244 12303 
+ 11958 11963 11997 12042 12069 15532 
+ 11815 11885 11956 12041 12300 12317 
+ 11908 11938 11993 12001 12057 12066 12089 
+ 11931 11970 11993 12038 12060 12070 
+ 11917 11969 11975 12051 12059 12084 
+ 11728 11804 11809 12191 12239 12413 
+ 11953 11964 11997 12042 12046 12075 
+ 11943 11955 11998 12048 12071 12104 
+ 11841 11887 11939 12109 12140 12225 
+ 11788 11813 11971 12074 12285 12315 
+ 11876 11939 11946 12085 12109 12168 
+ 11884 11946 11948 12085 12090 12169 
+ 11977 11996 12025 12065 12073 15531 
+ 11949 11976 12000 12049 12068 12094 
+ 11954 11978 12002 12056 12080 12112 
+ 11867 11897 11983 12003 12101 12103 12157 
+ 11957 11970 12024 12038 12072 12078 
+ 11947 11986 12003 12062 12082 15533 
+ 11894 11948 11960 12090 12108 12183 
+ 11957 11975 12021 12051 12072 12083 
+ 11996 11999 12017 12029 12061 12065 
+ 11995 12001 12029 12057 12063 
+ 11926 11972 11988 12081 12120 12133 
+ 11923 11965 12047 12116 12174 
+ 11995 11999 12025 12026 12061 12063 
+ 11927 11959 11990 12079 12130 12167 
+ 11919 11973 11979 12097 12105 12171 
+ 11905 11960 11968 12108 12110 12188 
+ 11910 11968 11973 12105 12110 12180 
+ 11944 11986 12036 12062 12091 12100 
+ 11892 11893 12047 12064 12195 12206 
+ 11944 11969 12034 12059 12091 12107 
+ 11930 11979 11987 12096 12097 12166 
+ 11970 12008 12021 12070 12078 12088 
+ 8151 10752 10767 13965 14823 15579 
+ 11914 11940 11982 12113 12136 12223 
+ 11885 11942 12006 12152 12317 
+ 11997 12005 12011 12069 12075 12114 
+ 11980 11985 12055 12056 12099 12129 
+ 11987 12096 12102 15534 
+ 11744 11829 11918 12248 12282 12511 
+ 11964 11988 12011 12075 12081 12124 
+ 11893 11923 12028 12035 12174 12195 
+ 11955 11989 12012 12104 
+ 11976 11998 12018 12071 12094 12131 
+ 11981 12000 12068 12093 12126 15532 
+ 11975 12009 12024 12083 12084 12118 
+ 11952 11972 12002 12080 12120 12147 12162 
+ 11902 11965 11982 12116 12136 12219 
+ 11881 11895 11994 12149 12160 12280 
+ 11980 12043 12073 12099 12125 15531 
+ 11978 11985 12019 12043 12112 12129 12143 
+ 12001 12007 12026 12063 12089 12115 12117 
+ 11906 11945 11994 12113 12160 12256 
+ 11969 12009 12036 12084 12107 12132 
+ 11993 12008 12066 12070 12121 12127 
+ 12025 12029 12063 12065 12087 12098 
+ 11986 12022 12034 12100 12123 15533 
+ 12026 12029 12057 12061 12098 12115 
+ 11892 11922 12035 12086 12206 12277 
+ 12017 12025 12061 12073 12087 12122 
+ 11993 12007 12060 12089 12127 12142 
+ 11860 11941 11942 12152 12231 12295 
+ 12000 12018 12050 12094 12126 12150 
+ 12005 12042 12093 12114 12146 15532 
+ 12008 12038 12060 12088 12121 12128 
+ 11998 12012 12049 12104 12131 12155 
+ 12021 12024 12078 12083 
+ 12017 12055 12065 12122 12125 12137 15531 
+ 11813 11861 12014 12279 12315 12462 
+ 12011 12042 12046 12114 12124 12156 
+ 11901 11929 11991 12077 12153 12210 12237 
+ 11929 11992 12076 12159 12196 12210 
+ 12021 12038 12072 12088 
+ 11959 11967 12030 12111 12167 12193 
+ 12002 12019 12052 12112 12145 12162 
+ 11988 12027 12046 12124 12133 12173 
+ 12003 12022 12101 12135 12165 15533 
+ 12024 12051 12072 12118 
+ 12009 12051 12059 12118 12132 12151 
+ 11946 12015 12016 12168 12169 12226 
+ 11922 11992 12064 12159 12242 12277 
+ 12061 12065 12098 12122 12139 
+ 12038 12070 12078 12128 
+ 12007 12057 12066 12117 12142 12158 
+ 11948 12016 12023 12169 12183 12253 
+ 12034 12036 12100 12107 12134 12148 
+ 11983 11990 12103 12130 12185 12215 
+ 12050 12069 12126 12146 12176 15532 
+ 12018 12049 12068 12131 12150 12181 
+ 11803 11956 11974 12300 12329 12482 
+ 11987 12037 12044 12166 12222 15534 
+ 11979 12031 12037 12166 12171 12234 
+ 12061 12063 12087 12115 12139 12144 
+ 12043 12055 12125 12129 15535 
+ 12034 12062 12091 12123 12134 12161 
+ 12003 12020 12082 12157 12165 12209 
+ 12044 12163 12213 15534 
+ 11983 12020 12092 12157 12185 12218 
+ 12012 12048 12071 12155 
+ 11973 12031 12033 12171 12180 12245 
+ 11805 11843 12119 12138 12338 12425 
+ 12036 12059 12091 12132 12148 12172 
+ 11960 12023 12032 12183 12188 12274 
+ 11939 12013 12015 12168 12225 12240 
+ 11968 12032 12033 12180 12188 12261 
+ 11967 11991 12079 12153 12193 12241 
+ 12019 12056 12080 12143 12145 12199 
+ 11940 11945 12040 12058 12223 12256 12412 
+ 12042 12069 12075 12146 12156 12186 
+ 12057 12063 12098 12117 12144 12154 
+ 11965 12028 12053 12174 12219 12286 
+ 12057 12089 12115 12154 12158 
+ 12051 12083 12084 12151 
+ 11805 11861 12106 12279 12425 12496 
+ 11972 12027 12052 12133 12147 12207 12220 
+ 12060 12070 12127 12128 12170 12175 
+ 12065 12073 12087 12137 12139 12177 
+ 12062 12100 12135 12161 12179 15533 
+ 12046 12075 12081 12156 12173 12202 
+ 12055 12073 12099 12137 12184 15535 
+ 12050 12068 12093 12150 12176 12198 
+ 12060 12066 12121 12142 12175 12187 
+ 12070 12088 12121 12170 
+ 12043 12056 12099 12143 12192 12197 15535 
+ 11990 12030 12092 12167 12215 12243 
+ 12049 12071 12094 12155 12181 12211 
+ 12059 12084 12107 12151 12172 12189 
+ 12027 12081 12120 12173 12207 12233 
+ 12091 12100 12148 12161 12182 
+ 12082 12123 12165 12179 12212 15533 
+ 11982 12040 12053 12219 12223 12322 
+ 12073 12122 12125 12177 12184 12200 
+ 11843 11918 12106 12282 12338 12456 
+ 12087 12098 12122 12144 12177 12190 
+ 11887 11941 12013 12225 12231 12389 15542 
+ 7709 8666 10752 13965 14308 14913 
+ 12066 12089 12127 12158 12187 12201 
+ 12056 12112 12129 12197 12199 12228 
+ 12098 12115 12139 12154 12190 12194 
+ 12080 12112 12162 12199 12204 
+ 12069 12093 12114 12176 12186 12221 
+ 12052 12120 12162 12217 12220 
+ 12091 12107 12134 12172 12182 12205 
+ 11895 12004 12054 12280 12303 12420 
+ 12068 12094 12126 12181 12198 12229 
+ 12084 12118 12132 12189 
+ 11942 12041 12067 12295 12317 15543 
+ 11991 12076 12111 12237 12241 12314 
+ 12115 12117 12144 12158 12194 12203 
+ 12071 12104 12131 12211 
+ 12075 12114 12124 12186 12202 12236 
+ 12020 12101 12103 12209 12218 12258 
+ 12089 12117 12142 12154 12201 12203 
+ 11992 12077 12086 12196 12242 12272 
+ 11994 12054 12058 12256 12280 12393 
+ 12100 12123 12134 12179 12182 15536 
+ 12052 12080 12145 12147 12204 12217 
+ 12102 12213 12214 12265 
+ 11664 11868 12331 12600 12906 
+ 12082 12101 12135 12209 12212 12252 
+ 12037 12096 12097 12222 12234 12291 
+ 12030 12079 12130 12193 12243 12278 
+ 12015 12085 12109 12226 12240 12284 
+ 12016 12085 12090 12226 12253 12325 
+ 12121 12128 12175 12216 
+ 12031 12097 12105 12234 12245 12304 
+ 12107 12132 12148 12189 12205 12235 
+ 12081 12124 12133 12202 12233 12255 
+ 12028 12047 12116 12195 12286 12334 
+ 12121 12127 12170 12187 12216 12224 
+ 12093 12126 12146 12198 12221 12250 
+ 12122 12137 12139 12190 12200 12238 
+ 11034 11079 11733 12969 13654 14023 
+ 12123 12135 12161 12212 12251 15536 
+ 12033 12105 12110 12245 12261 12333 
+ 12094 12131 12150 12211 12229 12259 
+ 12134 12148 12161 12205 12247 15536 
+ 12023 12090 12108 12253 12274 15539 
+ 12125 12137 12200 12227 12266 15535 
+ 12092 12103 12215 12218 12262 12293 
+ 12114 12146 12156 12221 12236 12268 
+ 12127 12142 12175 12201 12224 12246 
+ 12032 12108 12110 12261 12274 12351 
+ 12132 12151 12172 12235 
+ 12139 12144 12177 12194 12238 12249 
+ 11809 11880 12010 12366 12413 12581 
+ 12129 12197 12227 12257 15535 
+ 12079 12111 12167 12241 12278 12327 
+ 12144 12154 12190 12203 12249 12254 
+ 12035 12047 12174 12206 12334 12352 
+ 12077 12159 12210 12272 12308 
+ 12129 12143 12192 12228 12257 12260 
+ 12126 12150 12176 12229 12250 12283 
+ 12112 12143 12145 12204 12228 12264 12292 
+ 12137 12177 12184 12238 12266 12273 
+ 12142 12158 12187 12203 12246 12271 
+ 12124 12156 12173 12236 12255 12288 
+ 12154 12158 12194 12201 12254 12271 
+ 12145 12162 12199 12217 12264 12270 
+ 12148 12172 12182 12235 12247 12275 
+ 12035 12064 12195 12277 12352 12383 
+ 12120 12133 12220 12233 12302 12305 
+ 11730 11880 12232 12366 12700 12759 
+ 12101 12157 12165 12252 12258 12299 
+ 12076 12077 12196 12237 12308 12339 
+ 12131 12155 12181 12259 
+ 12135 12165 12179 12251 12252 12296 
+ 12102 12163 12265 12276 12323 15534 
+ 12163 12263 12265 12310 
+ 12092 12130 12185 12243 12293 12318 
+ 12170 12175 12224 12267 
+ 12147 12162 12204 12220 12270 12281 
+ 12103 12157 12185 12258 12262 12301 
+ 12053 12116 12136 12286 12322 12460 
+ 12120 12147 12207 12217 12281 12302 
+ 12146 12176 12186 12250 12268 12297 
+ 12096 12166 12276 12291 12348 15534 
+ 12040 12113 12136 12322 12412 12487 
+ 12175 12187 12216 12246 12267 12287 
+ 12013 12109 12140 12240 12354 12389 
+ 12085 12168 12169 12284 12325 15541 
+ 12184 12192 12257 12266 12294 15535 
+ 12143 12197 12199 12260 12292 12306 
+ 12150 12181 12198 12259 12283 15537 
+ 11789 11835 11974 12329 12361 12887 13168 
+ 11941 12067 12140 12295 12476 15542 
+ 11730 11738 12208 12409 12759 12888 
+ 12133 12173 12207 12255 12305 12312 
+ 12097 12166 12171 12291 12304 12364 
+ 12172 12189 12205 12275 
+ 12156 12186 12202 12268 12288 12311 
+ 12076 12153 12210 12314 12339 12394 
+ 12177 12190 12200 12249 12273 12298 
+ 11804 11984 12010 12413 12502 12675 
+ 12109 12168 12225 12284 12354 12397 
+ 12111 12153 12193 12314 12327 12387 
+ 12086 12159 12272 12277 12390 12404 
+ 12130 12167 12215 12278 12318 12350 
+ 11971 12004 12285 12303 12513 12528 
+ 12105 12171 12180 12304 12333 12388 
+ 12187 12201 12224 12271 12287 12290 
+ 12182 12205 12275 12289 12316 15536 
+ 11829 11984 12045 12502 12511 12792 
+ 12190 12194 12238 12254 12298 12307 
+ 12176 12198 12221 12283 12297 12332 
+ 12179 12212 12289 12296 12335 15536 
+ 12165 12209 12212 12296 12299 12343 
+ 12090 12169 12183 12325 12441 15539 
+ 12194 12203 12249 12271 12307 12342 
+ 12173 12202 12233 12288 12312 12341 
+ 12058 12113 12160 12393 12412 12512 
+ 12192 12197 12227 12260 12294 12321 
+ 12157 12209 12218 12299 12301 12349 
+ 12181 12211 12229 15537 
+ 12197 12228 12257 12306 12321 12324 
+ 12110 12180 12188 12333 12351 12424 
+ 12185 12218 12293 12301 12344 
+ 12214 12309 12310 12353 
+ 12199 12204 12270 12292 12337 12340 
+ 12163 12213 12214 12310 12323 12367 
+ 12184 12200 12227 12273 12294 12326 12346 
+ 12216 12224 12287 12319 
+ 12186 12221 12236 12297 12311 12347 
+ 11630 11868 11896 12600 12725 13015 
+ 12204 12217 12264 12281 12313 12340 
+ 12201 12203 12246 12254 12290 12342 15538 
+ 12159 12196 12242 12308 12368 12390 
+ 12200 12238 12266 12298 12326 12328 
+ 12108 12183 12188 12351 12450 15539 
+ 12205 12235 12247 12316 
+ 12213 12222 12323 12348 12391 15534 
+ 12064 12086 12206 12242 12383 12404 12453 
+ 12167 12193 12243 12327 12350 12400 
+ 11861 12074 12119 12462 12496 12638 
+ 12054 12149 12160 12393 12420 12546 
+ 12217 12220 12270 12302 12313 12345 
+ 11918 12045 12138 12456 12511 12668 
+ 12198 12229 12250 12332 12358 15537 
+ 12168 12226 12240 12397 15541 
+ 11971 12014 12244 12315 12513 12542 
+ 12116 12174 12219 12334 12440 12460 
+ 12224 12246 12267 12290 12319 12336 
+ 12202 12236 12255 12311 12341 12359 
+ 12247 12251 12316 12335 12360 15536 
+ 12246 12271 12287 12336 15538 
+ 12166 12222 12234 12348 12364 12415 
+ 12199 12228 12264 12306 12337 12370 
+ 12185 12215 12262 12318 12344 12377 
+ 12227 12257 12266 12321 12346 12357 
+ 12067 12152 12231 12476 12549 15543 
+ 12212 12251 12252 12335 12343 12373 
+ 12221 12250 12268 12332 12347 12371 
+ 12238 12249 12273 12307 12328 12356 
+ 12209 12252 12258 12343 12349 12382 
+ 11956 12006 12095 12317 12482 13041 
+ 12218 12258 12262 12344 12349 12384 
+ 12207 12220 12281 12305 12345 12376 12381 
+ 12004 12149 12244 12420 12519 12528 
+ 12171 12234 12245 12364 12388 12445 
+ 12207 12233 12302 12312 12374 12376 
+ 12228 12260 12292 12324 12362 12370 
+ 12249 12254 12298 12342 12356 15540 
+ 12196 12210 12272 12339 12368 12416 
+ 12263 12353 12355 12399 
+ 12214 12263 12265 12353 12367 12406 
+ 12236 12268 12288 12347 12359 12385 
+ 12233 12255 12305 12341 12374 12386 
+ 12270 12281 12340 12345 12365 
+ 12153 12237 12241 12387 12394 12455 
+ 12014 12074 12285 12462 12542 12652 
+ 12247 12275 12289 12360 
+ 12006 12041 12152 12300 13041 15543 
+ 12215 12243 12293 12350 12377 12418 
+ 12267 12287 12336 12369 
+ 11175 11322 11859 11962 13578 13730 
+ 12257 12260 12294 12324 12357 12363 
+ 12136 12219 12223 12460 12487 12555 
+ 12213 12265 12276 12367 12391 12433 
+ 12260 12306 12321 12362 12363 
+ 12169 12226 12253 12441 12532 15541 
+ 12266 12273 12328 12346 12375 12379 
+ 12193 12241 12278 12387 12400 12459 
+ 12273 12298 12326 12356 12372 12375 
+ 11974 12095 12230 12482 12887 
+ 252 270 6142 15094 15098 15170 
+ 11599 11664 12164 12469 12906 13213 
+ 12250 12283 12297 12358 12371 12403 
+ 12180 12245 12261 12388 12424 12486 
+ 12174 12195 12286 12352 12440 12463 
+ 12251 12289 12296 12360 12373 12408 
+ 12287 12290 12319 12369 12378 15538 
+ 12264 12292 12340 12370 12395 12401 
+ 12106 12138 12425 12456 12650 
+ 12210 12237 12308 12394 12416 12471 
+ 12264 12270 12313 12337 12365 12380 12395 
+ 12255 12288 12312 12359 12386 12410 
+ 12254 12271 12307 12392 12422 15538 15540 
+ 12252 12296 12299 12373 12382 12421 
+ 12262 12293 12301 12377 12384 12432 
+ 12281 12302 12313 12365 12381 12396 
+ 12266 12294 12326 12357 12379 12398 
+ 12268 12297 12311 12371 12385 12414 
+ 12222 12276 12291 12391 12415 12466 
+ 12258 12299 12301 12382 12384 12431 
+ 12243 12278 12318 12400 12418 12473 
+ 12188 12261 12274 12424 12450 12521 
+ 12195 12206 12334 12383 12463 12501 
+ 12263 12309 12310 12399 12406 12446 
+ 12225 12240 12389 12397 12523 
+ 12309 12399 12402 12443 
+ 12298 12307 12328 12372 12407 15540 
+ 12294 12321 12346 12363 12398 12411 
+ 12283 12332 12403 15537 
+ 12288 12311 12341 12385 12410 12434 
+ 12289 12316 12335 12408 
+ 11763 11835 11951 12230 13136 13168 
+ 12306 12324 12363 12370 12419 12428 
+ 12321 12324 12357 12362 12411 12419 
+ 12234 12291 12304 12415 12445 12499 
+ 12313 12340 12345 12380 12396 12405 
+ 11880 12191 12208 12581 12700 12889 
+ 12265 12310 12323 12406 12433 12467 
+ 12272 12308 12390 12416 12481 
+ 12319 12336 12378 12427 
+ 12292 12306 12337 12362 12401 12428 12439 
+ 12297 12332 12347 12403 12414 12449 
+ 12328 12356 12375 12407 12423 
+ 12296 12335 12343 12408 12421 12454 
+ 12305 12312 12376 12386 12437 12442 
+ 12326 12328 12372 12379 12423 12429 
+ 12302 12305 12374 12381 12430 12437 
+ 12293 12318 12344 12418 12432 12479 
+ 12336 12369 12392 12427 12451 15538 
+ 12326 12346 12375 12398 12429 12436 
+ 12340 12365 12395 12405 12417 
+ 12302 12345 12376 12396 12430 12435 
+ 12299 12343 12349 12421 12431 12474 
+ 12206 12277 12352 12453 12501 12547 
+ 12301 12344 12349 12431 12432 12480 
+ 12311 12347 12359 12414 12434 12461 
+ 12312 12341 12374 12410 12442 12458 
+ 12241 12314 12327 12455 12459 12525 
+ 12245 12304 12333 12445 12486 12539 
+ 12140 12225 12354 12523 12628 15542 
+ 12242 12272 12368 12404 12481 12520 
+ 12276 12323 12348 12433 12466 12506 
+ 12342 12378 12422 12451 12475 15538 
+ 12160 12256 12280 12512 12546 12609 
+ 12237 12314 12339 12455 12471 12530 
+ 12337 12340 12380 12401 12417 12438 
+ 12345 12365 12381 12405 12426 12435 
+ 12240 12284 12354 12523 12605 15541 
+ 12346 12357 12379 12411 12436 12452 
+ 12309 12353 12355 12443 12446 12489 
+ 12278 12327 12350 12459 12473 12527 
+ 12337 12370 12395 12438 12439 12465 
+ 12355 12443 12447 12491 
+ 12332 12358 12371 12449 
+ 12242 12277 12390 12453 12520 12563 
+ 12365 12380 12396 12417 12426 12448 
+ 12310 12353 12367 12446 12467 15545 
+ 12356 12372 12423 12444 12457 15540 
+ 12335 12360 12373 12454 
+ 11738 11896 12232 12725 12888 13094 
+ 12341 12359 12386 12434 12458 12483 
+ 12357 12363 12398 12419 12452 12464 
+ 12113 12223 12256 12487 12512 12606 12633 
+ 12010 12191 12239 12581 12675 12818 
+ 12347 12371 12385 12449 12461 12493 
+ 12291 12348 12364 12466 12499 12554 
+ 12308 12339 12368 12471 12481 12540 
+ 12380 12395 12405 12438 12448 12468 
+ 12318 12350 12377 12473 12479 12533 
+ 12362 12363 12411 12428 12464 12478 
+ 12149 12280 12303 12519 12546 12676 
+ 12343 12373 12382 12454 12474 12508 
+ 12342 12392 12444 12475 12488 15540 
+ 12372 12375 12407 12429 12457 12472 
+ 12261 12333 12351 12486 12521 12577 
+ 12106 12119 12338 12496 12650 12804 
+ 12396 12405 12435 12448 12470 
+ 12369 12378 12451 12485 
+ 12362 12370 12419 12439 12478 12490 
+ 12375 12379 12423 12436 12472 12484 
+ 12376 12381 12435 12437 12477 12492 
+ 12349 12382 12384 12474 12480 12524 
+ 12344 12377 12384 12479 12480 15546 
+ 12323 12367 12391 12467 12506 12544 
+ 12359 12385 12410 12461 12483 12505 
+ 12381 12396 12426 12430 12470 12477 
+ 12379 12398 12429 12452 12484 12497 
+ 12374 12376 12430 12442 12492 12504 
+ 12395 12401 12417 12465 12468 12495 
+ 12370 12401 12428 12465 12490 12503 
+ 12286 12334 12460 12463 12601 12621 
+ 12253 12325 12532 12561 12686 15539 
+ 12374 12386 12437 12458 12504 12509 
+ 12355 12399 12402 12489 12491 12531 
+ 12407 12422 12457 12488 12500 15540 
+ 12304 12364 12388 12499 12539 12583 
+ 12353 12399 12406 12489 12538 15545 
+ 12402 12491 12494 12534 
+ 12405 12417 12426 12468 12470 12498 
+ 12371 12403 12414 12493 
+ 12274 12351 12521 12561 12636 15539 
+ 12378 12392 12427 12475 12485 12514 12517 
+ 12398 12411 12436 12464 12497 12507 
+ 12277 12383 12404 12547 12563 12620 
+ 12373 12408 12421 12508 
+ 12314 12387 12394 12525 12530 12594 
+ 12138 12282 12338 12650 12668 12762 
+ 12407 12423 12444 12472 12500 12510 
+ 12386 12410 12442 12483 12509 12529 
+ 12327 12387 12400 12525 12527 12588 
+ 12219 12286 12322 12440 12555 12621 12665 
+ 12385 12414 12434 12493 12505 12537 
+ 12074 12279 12315 12638 12652 12803 
+ 12334 12352 12440 12501 12571 12601 
+ 12411 12419 12452 12478 12507 12518 
+ 12401 12438 12439 12495 12503 12522 
+ 12348 12391 12415 12506 12554 12595 
+ 12367 12406 12433 12544 12568 15545 
+ 12417 12438 12448 12495 12498 12515 
+ 11573 11599 12331 12876 13213 13437 
+ 12426 12435 12448 12477 12498 12516 
+ 12339 12394 12416 12530 12540 12598 
+ 12423 12429 12457 12484 12510 12526 
+ 12350 12400 12418 12527 12533 12586 
+ 12382 12421 12431 12508 12524 12565 
+ 12392 12422 12451 12488 12517 12536 
+ 12231 12295 12549 12733 12736 15542 
+ 12430 12435 12470 12492 12516 12552 
+ 12419 12428 12464 12490 12518 12535 
+ 12377 12418 12432 12533 12584 15546 
+ 12384 12431 12432 12524 12578 15546 
+ 12368 12390 12416 12520 12540 12590 
+ 12095 12300 12329 12887 13041 
+ 12410 12434 12458 12505 12529 12553 
+ 12429 12436 12472 12497 12526 12543 
+ 12427 12451 12514 12545 
+ 12333 12388 12424 12539 12577 12622 
+ 12223 12322 12412 12555 12633 12673 
+ 12422 12444 12475 12500 12536 12548 
+ 12399 12443 12446 12531 12538 12570 
+ 12428 12439 12478 12503 12535 15547 
+ 12402 12443 12447 12531 12534 12573 
+ 12430 12437 12477 12504 12552 12557 
+ 12414 12449 12461 12537 
+ 12447 12534 12541 12574 
+ 12438 12465 12468 12515 12522 12550 
+ 12119 12279 12425 12638 12731 12804 
+ 12436 12452 12484 12507 12543 12556 
+ 12448 12468 12470 12515 12516 12551 
+ 12364 12415 12445 12554 12583 12632 
+ 12444 12457 12488 12510 12548 12560 
+ 12352 12383 12463 12547 12571 12630 
+ 11984 12239 12248 12675 12792 12971 
+ 12439 12465 12490 12522 12564 15547 
+ 12437 12442 12492 12509 12557 12562 
+ 12434 12461 12483 12537 12553 12576 
+ 12391 12433 12466 12544 12595 12623 
+ 12452 12464 12497 12518 12556 12566 
+ 12421 12454 12474 12565 
+ 12442 12458 12504 12529 12562 12572 
+ 12457 12472 12500 12526 12560 12569 
+ 12045 12248 12282 12668 12792 13011 
+ 12256 12393 12412 12606 12609 12710 
+ 12244 12285 12528 12542 12702 12739 
+ 12451 12485 12517 12545 12558 12567 
+ 12468 12495 12498 12550 12551 12559 
+ 12470 12477 12498 12551 12552 12585 
+ 12451 12475 12514 12536 12567 12579 
+ 12464 12478 12507 12535 12566 12575 
+ 12303 12420 12528 12676 12701 
+ 12390 12404 12481 12563 12590 12644 
+ 12351 12424 12450 12577 12636 12678 
+ 12465 12495 12503 12550 12564 12580 
+ 12354 12389 12397 12605 12628 12781 
+ 12431 12474 12480 12565 12578 12619 
+ 12387 12455 12459 12588 12594 12654 
+ 12472 12484 12510 12543 12569 12582 
+ 12400 12459 12473 12586 12588 12647 
+ 12244 12303 12513 12519 12701 12702 
+ 12458 12483 12509 12553 12572 12596 
+ 12394 12455 12471 12594 12598 12661 
+ 12443 12489 12491 12570 12573 12610 
+ 12325 12441 12605 12686 12850 15541 
+ 12418 12473 12479 12584 12586 12641 
+ 12447 12491 12494 12573 12574 12612 
+ 12478 12490 12518 12575 12587 15547 
+ 12475 12488 12517 12548 12579 12591 
+ 12461 12493 12505 12576 
+ 12446 12489 12570 12589 12613 15545 
+ 12388 12445 12486 12583 12622 12666 
+ 12416 12471 12481 12590 12598 12659 
+ 12494 12574 15548 15550 
+ 12285 12315 12513 12652 12739 12832 
+ 12484 12497 12526 12556 12582 12597 
+ 12433 12467 12506 12568 12623 12642 
+ 12485 12514 12558 12599 
+ 12280 12393 12420 12609 12676 12828 
+ 12383 12453 12501 12620 12630 12697 
+ 12488 12500 12536 12560 12591 12603 
+ 12295 12476 12733 12913 15543 
+ 12495 12515 12522 12559 12580 12593 
+ 12498 12515 12516 12559 12585 12592 
+ 12477 12492 12516 12557 12585 12615 15549 
+ 12483 12505 12529 12576 12596 12617 
+ 12415 12466 12499 12595 12632 12680 
+ 12322 12460 12487 12665 12673 12753 
+ 12497 12507 12543 12566 12597 12607 
+ 12492 12504 12552 12562 12604 15549 
+ 12514 12545 12567 12599 12608 
+ 12515 12550 12551 12592 12593 
+ 12500 12510 12548 12569 12603 12614 
+ 12441 12450 12636 12686 12777 15539 
+ 12504 12509 12557 12572 12604 12616 
+ 12404 12453 12520 12620 12644 12707 
+ 12503 12522 12580 12602 12618 15547 
+ 12474 12508 12524 12619 
+ 12507 12518 12556 12575 12607 15551 
+ 12514 12517 12558 12579 12608 12624 
+ 12467 12544 12589 12642 12660 15545 
+ 12510 12526 12560 12582 12614 12625 
+ 12489 12531 12538 12610 12613 12646 
+ 12463 12501 12601 12630 12703 
+ 12509 12529 12562 12596 12616 12629 
+ 12491 12531 12534 12610 12612 15553 
+ 12494 12534 12541 12612 12655 15550 
+ 12518 12535 12566 12587 12627 15551 
+ 12505 12537 12553 12617 
+ 12424 12486 12521 12622 12678 12708 
+ 12480 12524 12619 12631 12677 15546 
+ 12517 12536 12567 12591 12624 12634 
+ 12522 12550 12564 12593 12618 12626 
+ 12191 12366 12413 12818 12889 13057 
+ 12526 12543 12569 12597 12625 12637 
+ 12445 12499 12539 12632 12666 12723 
+ 12479 12533 12631 12641 12693 15546 
+ 12516 12551 12552 12592 12615 12635 12648 
+ 12473 12527 12533 12641 12647 12705 
+ 12535 12575 12602 12627 12640 15547 
+ 12459 12525 12527 12647 12654 12713 
+ 12538 12568 12613 12660 15545 15555 
+ 12481 12520 12540 12644 12659 12719 
+ 12536 12548 12579 12603 12634 12645 
+ 12551 12559 12585 12593 12635 15552 
+ 12550 12559 12580 12592 12626 15552 
+ 12455 12525 12530 12654 12661 12720 
+ 12466 12506 12554 12623 12680 12714 
+ 12529 12553 12572 12617 12629 12656 
+ 12543 12556 12582 12607 12637 12651 
+ 12471 12530 12540 12659 12661 12724 
+ 12545 12558 12608 12662 15554 
+ 11868 12164 12269 12906 13015 13210 
+ 12440 12463 12571 12621 12703 12752 
+ 12564 12587 12618 12640 12657 15547 
+ 12548 12560 12591 12614 12645 12663 
+ 12557 12562 12616 12639 12658 15549 
+ 12397 12523 12532 12781 12850 12907 15541 
+ 12412 12512 12633 12710 12746 12811 
+ 12556 12566 12597 12651 12664 15551 
+ 12558 12567 12599 12624 12669 15554 
+ 12393 12512 12546 12710 12821 12828 
+ 12531 12570 12573 12646 12689 15553 
+ 12649 12653 12687 15548 
+ 12534 12573 12574 12655 15553 15556 
+ 12538 12570 12589 12646 12685 15555 
+ 12560 12569 12603 12625 12663 12670 
+ 12552 12585 12639 12648 12671 15549 
+ 12562 12572 12604 12629 12658 12672 
+ 12553 12576 12596 12656 
+ 12564 12580 12602 12626 12657 12667 
+ 12524 12565 12578 12677 
+ 12453 12547 12563 12697 12707 12780 
+ 12440 12460 12601 12665 12752 12797 
+ 12486 12539 12577 12666 12708 12750 
+ 12506 12544 12595 12642 12714 12737 
+ 12567 12579 12608 12634 12669 12681 
+ 12569 12582 12614 12637 12670 12682 
+ 12580 12593 12618 12667 12679 15552 
+ 12575 12587 12640 12674 12684 15551 
+ 12389 12523 12736 12781 12927 15542 
+ 12572 12596 12616 12656 12672 12692 
+ 12501 12547 12571 12697 12703 12778 
+ 12578 12584 12677 12693 12742 15546 
+ 12499 12554 12583 12680 12723 12779 
+ 12412 12487 12606 12673 12746 12791 
+ 12579 12591 12624 12645 12681 12691 
+ 12585 12592 12648 12688 12696 15552 
+ 12450 12521 12561 12678 12777 12795 
+ 12582 12597 12625 12651 12682 12695 
+ 12279 12462 12496 12731 12803 12892 
+ 12604 12615 12658 12671 12694 15549 
+ 12587 12602 12627 12657 12684 12699 
+ 12533 12584 12586 12693 12705 12760 
+ 12544 12568 12623 12660 12737 12745 
+ 11534 11556 11680 11951 13075 13136 13616 
+ 12520 12563 12590 12707 12719 12788 
+ 12591 12603 12634 12663 12691 12704 
+ 12570 12610 12613 12685 12689 15557 
+ 12527 12586 12588 12705 12713 12770 
+ 12585 12615 12635 12671 12696 12709 
+ 12611 12683 12687 12722 
+ 12338 12425 12456 12762 12804 12952 
+ 12597 12607 12637 12664 12695 12706 
+ 12315 12462 12542 12803 12832 12949 
+ 12611 12687 12690 12727 15548 15550 
+ 12525 12588 12594 12713 12720 12782 
+ 12574 12612 12690 12734 15550 15556 
+ 12596 12617 12629 12692 
+ 12602 12618 12640 12667 12699 12711 
+ 12604 12616 12639 12672 12694 12712 
+ 12540 12590 12598 12719 12724 12793 
+ 12568 12589 12642 12743 12745 15555 
+ 12530 12594 12598 12720 12724 12790 
+ 12599 12698 12718 15554 
+ 12603 12614 12645 12670 12704 12716 
+ 12607 12651 12674 12706 12717 15551 
+ 12460 12555 12621 12753 12797 12860 
+ 12539 12583 12622 12723 12750 12817 
+ 12618 12626 12657 12679 12711 12721 
+ 12282 12456 12511 12762 12999 13011 
+ 12608 12624 12681 12698 12735 15554 
+ 12614 12625 12663 12682 12716 12726 
+ 12615 12639 12648 12694 12709 12728 
+ 12616 12629 12658 12692 12712 12730 
+ 12487 12555 12633 12753 12791 12857 
+ 12627 12664 12684 12717 12729 15551 
+ 12239 12413 12502 12818 12971 13059 
+ 12420 12519 12546 12701 12828 12933 
+ 12578 12619 12631 12742 
+ 12521 12577 12636 12708 12794 12795 
+ 12626 12667 12688 12721 12732 15552 
+ 12554 12595 12632 12714 12779 12825 
+ 12624 12634 12669 12691 12735 12757 
+ 12625 12637 12670 12695 12726 12741 
+ 12649 12715 12722 12756 
+ 12627 12640 12674 12699 12729 12744 
+ 12613 12646 12738 15555 15557 
+ 12441 12532 12561 12777 12850 12958 
+ 12611 12649 12653 12722 12727 12765 
+ 12635 12679 12696 12732 12747 15552 
+ 12610 12646 12740 12769 15553 15557 
+ 12653 12655 12727 12734 12771 15550 
+ 12634 12645 12681 12704 12757 12758 
+ 12629 12656 12672 12730 
+ 12584 12631 12641 12742 12760 12807 
+ 12639 12658 12671 12712 12728 12749 
+ 12637 12651 12682 12706 12741 12751 
+ 12635 12648 12688 12709 12747 12755 
+ 12547 12620 12630 12778 12780 12858 
+ 12662 12669 12718 12735 12761 15554 
+ 12640 12657 12684 12711 12744 12754 
+ 12208 12366 12759 12889 13046 13109 
+ 12519 12528 12676 12702 12910 12933 
+ 12513 12528 12701 12739 12910 12919 
+ 12571 12601 12630 12752 12778 12849 
+ 12645 12663 12691 12716 12758 12763 
+ 12586 12641 12647 12760 12770 12829 
+ 12651 12664 12695 12717 12751 12764 
+ 12563 12620 12644 12780 12788 12862 
+ 12577 12622 12678 12750 12794 12824 
+ 12648 12671 12696 12728 12755 12768 
+ 12512 12606 12609 12811 12821 12836 
+ 12657 12667 12699 12721 12754 12766 
+ 12658 12672 12694 12730 12749 12767 
+ 12588 12647 12654 12770 12782 12842 
+ 12595 12623 12680 12737 12825 12840 
+ 12683 12748 12756 12786 
+ 12663 12670 12704 12726 12763 12772 
+ 12664 12674 12706 12729 12764 12773 
+ 12662 12698 12761 12776 
+ 12590 12644 12659 12788 12793 12863 
+ 12594 12654 12661 12782 12790 12851 
+ 12667 12679 12711 12732 12766 12774 
+ 12649 12683 12687 12756 12765 12796 
+ 12583 12632 12666 12779 12817 12884 
+ 12598 12659 12661 12790 12793 12861 
+ 11896 12269 12409 13015 13094 13233 
+ 12670 12682 12716 12741 12772 12785 
+ 12653 12687 12690 12765 12771 12808 
+ 12671 12694 12709 12749 12768 12784 
+ 12674 12684 12717 12744 12773 12787 
+ 12672 12692 12712 12767 
+ 12496 12638 12804 12892 12986 
+ 12679 12688 12721 12747 12774 12789 
+ 12476 12549 12736 12913 12975 
+ 12655 12690 12771 12783 12819 15556 
+ 12669 12681 12698 12757 12761 12805 
+ 12476 12628 12733 12927 12975 13032 15542 
+ 12623 12642 12714 12745 12838 12840 
+ 12685 12743 12801 12815 15555 15557 
+ 12513 12542 12702 12832 12919 12923 
+ 12689 12769 12783 12831 15553 15556 
+ 12682 12695 12726 12751 12785 12799 
+ 12631 12677 12693 12807 
+ 12660 12738 12745 12815 12820 15555 
+ 12684 12699 12729 12754 12787 12798 
+ 12642 12660 12737 12743 12820 12838 
+ 12606 12633 12791 12811 12879 
+ 12688 12696 12732 12755 12789 12800 
+ 12715 12775 12786 12816 
+ 12694 12712 12728 12767 12784 12802 
+ 12622 12666 12708 12817 12824 12895 
+ 12695 12706 12741 12764 12799 12810 
+ 12601 12621 12703 12797 12849 12905 
+ 12555 12665 12673 12857 12860 12937 
+ 12699 12711 12744 12766 12798 12809 
+ 12696 12709 12747 12768 12800 12812 
+ 12683 12715 12722 12786 12796 12830 
+ 12681 12691 12735 12758 12805 12833 12866 
+ 12691 12704 12757 12763 12813 12833 
+ 12208 12232 12700 12888 13109 13166 
+ 12641 12693 12705 12807 12829 12873 
+ 12698 12718 12735 12776 12805 12827 
+ 12456 12650 12668 12952 12999 
+ 12704 12716 12758 12772 12813 12814 
+ 12706 12717 12751 12773 12810 12822 
+ 12687 12722 12727 12796 12808 12841 
+ 12711 12721 12754 12774 12809 15558 
+ 12712 12730 12749 12802 
+ 12709 12728 12755 12784 12812 12823 
+ 12689 12740 12801 12831 12859 15557 
+ 12647 12705 12713 12829 12842 12891 
+ 12690 12727 12734 12808 12819 12853 
+ 12716 12726 12763 12785 12814 12826 
+ 12717 12729 12764 12787 12822 12834 
+ 12721 12732 12766 12789 12835 15558 
+ 12748 12806 12816 12845 
+ 12718 12761 12827 12839 
+ 12561 12636 12686 12795 12926 12958 
+ 12630 12697 12703 12849 12858 12922 
+ 12632 12680 12723 12825 12884 12946 
+ 12620 12697 12707 12858 12862 12929 
+ 12523 12605 12628 12907 12927 13031 
+ 12654 12713 12720 12842 12851 12904 
+ 12734 12740 12819 12831 12871 15556 
+ 12728 12749 12768 12802 12823 12837 
+ 12726 12741 12772 12799 12826 12844 
+ 12715 12748 12756 12816 12830 12854 
+ 12729 12744 12773 12798 12834 12843 
+ 12644 12707 12719 12862 12863 12930 
+ 12732 12747 12774 12800 12835 12846 
+ 12661 12720 12724 12851 12861 12917 
+ 12633 12673 12746 12857 12879 12954 
+ 12248 12502 12511 12971 13011 13200 
+ 12659 12719 12724 12861 12863 12925 
+ 12678 12708 12795 12824 12909 12959 
+ 12636 12678 12777 12794 12909 12926 
+ 12722 12756 12765 12830 12841 12870 
+ 12621 12665 12752 12860 12905 12968 
+ 12744 12754 12787 12809 12843 12852 
+ 12741 12751 12785 12810 12844 12856 
+ 12747 12755 12789 12812 12846 12848 
+ 12738 12769 12815 12859 15557 15559 
+ 12749 12767 12784 12837 
+ 12462 12638 12652 12892 12949 13029 
+ 12425 12496 12650 12731 12952 12986 13120 
+ 12735 12757 12761 12827 12866 12874 
+ 12775 12837 12845 12869 
+ 12693 12742 12760 12873 
+ 12727 12765 12771 12841 12853 12882 
+ 12754 12766 12798 12852 12865 15558 
+ 12751 12764 12799 12822 12856 12868 
+ 12606 12710 12746 12836 12879 12948 
+ 12755 12768 12800 12823 12848 12855 
+ 12758 12763 12814 12833 12847 
+ 12763 12772 12813 12826 12847 12864 
+ 12738 12743 12801 12820 12896 15559 
+ 12748 12775 12786 12845 12854 12878 
+ 12666 12723 12750 12884 12895 13001 
+ 12413 12581 12675 13057 13059 13172 
+ 12734 12771 12783 12853 12871 12900 
+ 12743 12745 12815 12838 12896 12903 
+ 12609 12710 12828 12836 12990 13013 
+ 12764 12773 12810 12834 12868 12875 
+ 12768 12784 12812 12837 12855 12867 
+ 12708 12750 12794 12895 12959 
+ 12680 12714 12779 12840 12946 12960 
+ 12772 12785 12814 12844 12864 12880 
+ 12761 12776 12805 12839 12874 12883 
+ 12546 12609 12676 12821 12933 13013 13053 
+ 12705 12760 12770 12873 12891 12943 
+ 12756 12786 12796 12854 12870 15561 
+ 12740 12769 12783 12859 12871 12915 
+ 12542 12652 12739 12923 12949 13045 
+ 12757 12758 12813 12847 12866 12877 
+ 12773 12787 12822 12843 12875 15560 
+ 12774 12789 12846 12872 12881 15558 
+ 12710 12811 12821 12948 12990 
+ 12784 12802 12806 12823 12867 12869 12886 
+ 12737 12745 12820 12840 12903 12931 
+ 12776 12827 12883 12885 
+ 12714 12737 12825 12838 12931 12960 
+ 12765 12796 12808 12870 12882 12911 
+ 12713 12770 12782 12891 12904 12965 
+ 12787 12798 12834 12852 12893 15560 
+ 12785 12799 12826 12856 12880 12899 
+ 12775 12806 12816 12869 12878 12901 
+ 12789 12800 12835 12848 12881 12894 
+ 12813 12814 12833 12864 12877 12890 
+ 12800 12812 12846 12855 12894 12897 
+ 12703 12752 12778 12905 12922 12985 
+ 12532 12605 12686 12907 12958 13085 13126 
+ 12720 12782 12790 12904 12917 12974 
+ 12798 12809 12843 12865 12893 12902 
+ 12771 12808 12819 12882 12900 12928 
+ 12786 12816 12830 12878 12914 15561 
+ 12812 12823 12848 12867 12897 12898 
+ 12799 12810 12844 12868 12899 12908 
+ 12673 12753 12791 12937 12954 13012 
+ 12697 12778 12780 12922 12929 12997 
+ 12769 12801 12831 12915 12955 15559 
+ 12665 12753 12797 12937 12968 13018 
+ 12724 12790 12793 12917 12925 12987 
+ 12707 12780 12788 12929 12930 13000 
+ 12719 12788 12793 12925 12930 12994 
+ 12814 12826 12847 12880 12890 12920 
+ 12809 12852 12872 12902 12912 15558 
+ 12757 12805 12833 12874 12877 12940 12947 
+ 12823 12837 12855 12886 12898 15562 
+ 12810 12822 12856 12875 12908 12916 
+ 12806 12837 12845 12886 12901 12918 
+ 12796 12830 12841 12911 15561 15563 
+ 12783 12819 12831 12900 12915 12967 
+ 12835 12865 12881 12912 12921 15558 
+ 12760 12807 12829 12943 
+ 12805 12827 12866 12883 12934 12940 
+ 12822 12834 12868 12916 12924 15560 
+ 11573 11578 12469 13315 13437 13684 
+ 12833 12847 12866 12890 12941 12947 
+ 12816 12845 12854 12901 12914 12942 
+ 12746 12791 12811 12948 12954 13016 
+ 12826 12844 12864 12899 12920 12953 
+ 12835 12846 12872 12894 12921 12935 
+ 12808 12841 12853 12911 12928 12963 
+ 12827 12839 12874 12885 12934 12938 
+ 12723 12779 12817 12946 13001 13063 
+ 12839 12883 12938 12944 
+ 12837 12867 12869 12918 12936 15562 
+ 12230 12329 12482 13041 13168 13498 
+ 12232 12409 12759 13094 13166 13267 
+ 12366 12581 12700 13046 13057 13154 
+ 12847 12864 12877 12920 12941 
+ 12770 12829 12842 12943 12965 13008 
+ 12638 12731 12803 12986 13029 13099 
+ 12843 12852 12902 12932 12945 15560 
+ 12846 12848 12881 12897 12935 12951 
+ 12750 12817 12824 12959 13001 13078 
+ 12815 12820 12903 12972 12982 15559 
+ 12848 12855 12894 12898 12950 12951 
+ 12855 12867 12897 12939 12950 15562 
+ 12844 12856 12880 12908 12953 12961 
+ 12819 12853 12871 12928 12967 12983 
+ 12845 12869 12878 12918 12942 12957 
+ 12852 12865 12893 12912 12945 12956 
+ 12820 12838 12896 12931 12982 12998 
+ 12782 12842 12851 12965 12974 13017 
+ 12752 12797 12849 12968 12985 13030 
+ 12164 12331 12600 13210 13213 13401 
+ 12605 12781 12850 13031 13085 
+ 12856 12868 12899 12916 12961 12962 
+ 12794 12795 12926 12959 13061 
+ 12701 12702 12919 12933 13098 13110 
+ 12841 12870 12882 12963 12981 15563 
+ 12865 12872 12902 12921 12956 12970 
+ 12549 12733 12975 13041 13371 15543 
+ 12854 12878 12942 12964 12976 15561 
+ 12831 12859 12871 12955 12967 13009 
+ 12868 12875 12908 12924 12962 12966 
+ 12790 12851 12861 12974 12987 13028 
+ 12869 12886 12901 12936 12957 12973 
+ 12702 12739 12910 12923 13060 13110 
+ 12864 12880 12890 12941 12953 12995 
+ 12872 12881 12912 12935 12970 12980 
+ 12778 12849 12858 12985 12997 13040 
+ 12739 12832 12919 13045 13060 
+ 12875 12916 12932 12966 12977 15560 
+ 12793 12861 12863 12987 12994 13035 
+ 12777 12795 12909 12958 13061 13096 
+ 12628 12736 12781 13031 13032 13128 
+ 12853 12882 12900 12963 12983 13002 
+ 12780 12858 12862 12997 13000 13044 
+ 12788 12862 12863 12994 13000 13042 
+ 12838 12840 12903 12960 12998 13025 
+ 12893 12924 12945 12977 15560 15564 
+ 12676 12701 12828 12910 13053 13098 13123 
+ 12874 12883 12938 12940 12988 12996 
+ 12881 12894 12921 12951 12980 12991 
+ 12886 12918 12939 12973 12993 15562 
+ 12753 12857 12860 13012 13018 13076 
+ 12883 12885 12934 12944 12988 12989 
+ 12898 12936 12950 12978 12993 15562 
+ 12866 12874 12934 12947 12996 13005 
+ 12877 12890 12920 12947 12995 13006 
+ 12878 12901 12914 12957 12976 12979 
+ 12829 12873 12891 13008 
+ 12885 12938 12989 12992 
+ 12893 12902 12932 12956 15564 
+ 12779 12825 12884 12960 13063 13067 
+ 12866 12877 12940 12941 13005 13006 
+ 12811 12836 12879 12990 13016 13071 
+ 12652 12803 12832 13029 13045 13143 
+ 12897 12898 12939 12951 12978 12984 
+ 12894 12897 12935 12950 12984 12991 
+ 12650 12762 12804 12999 13120 13158 
+ 12880 12899 12920 12961 12995 13036 
+ 12791 12857 12879 13012 13016 13077 
+ 12859 12915 12972 13009 13033 15559 
+ 12902 12912 12945 12970 13097 15564 
+ 12901 12918 12942 12973 12979 13003 
+ 12686 12777 12850 12926 13096 13126 
+ 12794 12824 12895 12909 13061 13078 
+ 12825 12840 12931 12946 13025 13067 
+ 12899 12908 12953 12962 13022 13036 
+ 12908 12916 12961 12966 13007 13022 
+ 12882 12911 12928 12981 13002 15565 
+ 12914 12976 13004 13010 15561 15563 
+ 12842 12891 12904 13008 13017 13055 
+ 12916 12924 12962 12977 13007 
+ 12871 12900 12915 12983 13009 13038 
+ 12797 12860 12905 13018 13030 13081 
+ 11028 11079 12178 13265 14023 14169 
+ 12912 12921 12956 12980 13097 
+ 12502 12675 12792 13059 13200 13230 
+ 12896 12955 12982 13033 13049 15559 
+ 12918 12936 12957 12993 13003 13021 
+ 12851 12904 12917 13017 13028 13073 
+ 12733 12736 12913 13032 13371 
+ 12914 12942 12964 12979 13010 13014 
+ 12924 12932 12966 13007 13023 15564 
+ 12939 12950 12984 12993 13019 13039 
+ 12942 12957 12976 13003 13014 
+ 12921 12935 12970 12991 13058 13097 
+ 12911 12963 13004 13034 15563 15565 
+ 12896 12903 12972 12998 13049 13051 
+ 12900 12928 12967 13002 13038 13047 
+ 12950 12951 12978 12991 13019 
+ 12849 12905 12922 13030 13040 13088 
+ 12731 12804 12892 13099 13120 13186 
+ 12861 12917 12925 13028 13035 13080 
+ 12934 12938 12989 12996 13020 13026 
+ 12938 12944 12988 12992 13020 13024 
+ 12821 12836 12948 13013 13071 13107 
+ 12935 12951 12980 12984 13019 13058 
+ 12944 12989 13024 13027 
+ 12936 12939 12973 12978 13021 13039 
+ 12863 12925 12930 13035 13042 13086 
+ 12920 12941 12953 13006 13036 13056 
+ 12934 12940 12988 13005 13026 13037 
+ 12858 12922 12929 13040 13044 13092 
+ 12903 12931 12982 13025 13051 13069 
+ 12668 12762 12952 13011 13158 13183 
+ 12862 12929 12930 13042 13044 13091 
+ 12817 12884 12895 13063 13078 13146 
+ 12928 12963 12983 13047 13050 15565 
+ 12957 12973 12979 13014 13021 13052 
+ 12964 12981 13010 13034 13048 15563 
+ 12940 12947 12996 13006 13037 13054 
+ 12941 12947 12995 13005 13054 13056 
+ 12962 12966 12977 13022 13023 13043 
+ 12891 12943 12965 13055 
+ 12915 12955 12967 13033 13038 13089 
+ 12964 12976 13004 13014 13048 13074 
+ 12511 12668 12792 12999 13183 13200 13295 
+ 12857 12937 12954 13076 13077 13125 
+ 12821 12828 12990 13053 13107 13141 
+ 12976 12979 13003 13010 13052 13074 
+ 12269 12600 12725 13210 13233 13367 
+ 12879 12948 12954 13071 13077 13121 
+ 12904 12965 12974 13055 13073 13104 
+ 12860 12937 12968 13076 13081 13130 
+ 12978 12984 12991 13039 13058 15567 
+ 12988 12989 13024 13026 13062 13065 
+ 12973 12993 13003 13039 13052 13083 
+ 12961 12962 13007 13036 13043 13064 
+ 12977 13007 13043 13079 15564 
+ 12989 12992 13020 13027 13065 13068 
+ 12931 12960 12998 13067 13069 13112 
+ 12988 12996 13020 13037 13062 13070 
+ 12992 13024 13068 13072 
+ 12917 12974 12987 13073 13080 13113 
+ 12803 12892 12949 13099 13143 13196 
+ 12905 12968 12985 13081 13088 13134 
+ 12781 12907 12927 13085 13128 13194 
+ 12736 12927 12975 13128 13371 
+ 12955 12972 13009 13049 13089 13114 
+ 12981 13004 13048 13066 13082 15565 
+ 12925 12987 12994 13080 13086 13127 
+ 12953 12961 12995 13022 13056 13064 13105 13106 
+ 12996 13005 13026 13054 13070 13084 
+ 12967 12983 13009 13047 13089 13115 
+ 12978 12993 13019 13021 13083 15567 
+ 12922 12985 12997 13088 13092 13139 
+ 12300 12317 12482 12887 12913 13371 13498 15543 
+ 12930 12994 13000 13086 13091 13133 
+ 13007 13022 13023 13064 13079 13100 
+ 12929 12997 13000 13091 13092 15568 
+ 12832 12923 12949 13060 13143 13203 
+ 12700 12889 13109 13154 13225 
+ 12983 13002 13038 13050 13108 13115 
+ 13004 13010 13034 13074 13082 13142 
+ 12972 12982 13033 13051 13114 13118 
+ 13002 13047 13066 13108 15565 
+ 12982 12998 13049 13069 13111 13118 
+ 13003 13014 13021 13074 13083 13124 
+ 12828 12933 13013 13123 13141 13180 
+ 13005 13006 13037 13056 13084 13093 13102 
+ 12965 13008 13017 13104 
+ 12995 13006 13036 13054 13093 13105 
+ 12581 12818 12889 13154 13172 13239 
+ 12980 12991 13019 13097 13156 15567 
+ 12675 12818 12971 13172 13230 13279 
+ 12919 12923 13045 13110 13185 13203 
+ 12909 12926 12959 13078 13096 13224 
+ 13020 13026 13065 13070 13087 13090 
+ 12884 12946 13001 13067 13146 13153 
+ 13022 13036 13043 13100 13106 
+ 13020 13024 13062 13068 13090 13095 
+ 13034 13050 13082 13108 13119 15565 
+ 12946 12960 13025 13063 13112 13153 13159 
+ 13024 13027 13065 13072 13095 13101 
+ 12998 13025 13051 13111 13112 
+ 13026 13037 13062 13084 13087 15566 
+ 12948 12990 13016 13107 13121 13160 
+ 13027 13068 13101 13103 
+ 12974 13017 13028 13104 13113 13144 
+ 13010 13014 13048 13052 13124 13142 
+ 11621 11680 11962 12643 13578 13616 13931 
+ 12937 13012 13018 13125 13130 13170 
+ 12954 13012 13016 13121 13125 13167 
+ 12895 12959 13001 13061 13146 13224 13247 
+ 13023 13043 13097 13100 13152 15564 
+ 12987 13028 13035 13113 13127 13155 
+ 12968 13018 13030 13130 13134 13175 
+ 13034 13048 13066 13119 13142 
+ 13021 13039 13052 13124 13151 15567 
+ 13037 13054 13070 13102 13116 15566 
+ 12850 12907 13031 13126 13194 13235 
+ 12994 13035 13042 13127 13133 13164 
+ 13062 13070 13090 13117 15566 
+ 12985 13030 13040 13134 13139 13178 
+ 13009 13033 13038 13114 13115 13176 
+ 13062 13065 13087 13095 13117 13129 
+ 13000 13042 13044 13133 13173 15568 
+ 12997 13040 13044 13139 13177 15568 
+ 13054 13056 13102 13105 13122 13131 
+ 12409 12725 12888 13233 13267 13370 
+ 13065 13068 13090 13101 13129 13132 
+ 12926 12958 13061 13126 13224 13261 
+ 12956 12970 12980 13058 13079 13152 13156 13214 15564 
+ 12910 12933 13110 13123 13202 13218 
+ 12892 12986 13029 13186 13196 13238 
+ 13043 13064 13079 13106 13149 13152 
+ 13068 13072 13095 13103 13132 13137 
+ 13054 13084 13093 13116 13122 13135 
+ 13072 13101 13137 13138 
+ 13017 13055 13073 13144 
+ 13036 13056 13093 13106 13131 13148 
+ 13036 13064 13100 13105 13148 13149 
+ 12990 13013 13071 13141 13160 13195 
+ 13047 13050 13066 13115 13119 13171 13187 
+ 12700 12759 13046 13166 13225 13297 
+ 12910 12919 13060 13098 13185 13218 
+ 13051 13069 13112 13118 13165 13181 
+ 13025 13067 13069 13111 13159 13165 
+ 13028 13073 13080 13144 13155 13182 
+ 13033 13049 13089 13118 13176 13189 
+ 13038 13047 13089 13108 13176 13187 
+ 13084 13102 13135 13140 13150 15566 
+ 13087 13090 13129 13140 13147 15566 
+ 13049 13051 13111 13114 13181 13189 
+ 13066 13082 13108 13142 13171 
+ 12804 12952 12986 13158 13186 13282 13292 
+ 13016 13071 13077 13160 13167 13204 
+ 13093 13102 13131 13135 13145 
+ 12933 13053 13098 13180 13202 13222 
+ 13052 13074 13083 13142 13151 13198 
+ 13012 13076 13077 13167 13170 13206 
+ 12850 12958 13085 13096 13235 13261 
+ 13035 13080 13086 13155 13164 13192 
+ 12927 13031 13032 13194 13371 13387 
+ 13090 13095 13117 13132 13147 13157 
+ 13018 13076 13081 13170 13175 13207 
+ 13093 13105 13122 13145 13148 13174 
+ 13095 13101 13129 13137 13157 13161 
+ 13042 13086 13091 13164 13173 13201 
+ 13030 13081 13088 13175 13178 13209 
+ 13102 13116 13122 13145 13150 13169 
+ 11951 12361 12643 13168 13616 13680 
+ 13101 13103 13132 13138 13161 13163 
+ 13103 13137 13162 13163 
+ 13040 13088 13092 13177 13178 13208 
+ 13116 13117 13147 13150 13179 15566 
+ 13013 13053 13107 13180 13195 13231 
+ 13048 13074 13082 13119 13124 13171 13198 13249 
+ 12949 13029 13045 13196 13203 13288 
+ 13073 13104 13113 13182 
+ 13122 13131 13135 13169 13174 
+ 13001 13063 13078 13153 13247 13259 
+ 13117 13129 13140 13157 13179 13184 
+ 13105 13106 13131 13149 13174 13199 
+ 13100 13106 13148 13152 13199 13215 
+ 13116 13135 13140 13169 13179 13197 
+ 13083 13124 13156 13198 13236 15567 
+ 13079 13097 13100 13149 13214 13215 
+ 13063 13067 13146 13159 13259 15569 
+ 12889 13046 13057 13225 13239 13291 
+ 13080 13113 13127 13182 13192 13219 
+ 13058 13097 13151 13214 13236 15567 
+ 13129 13132 13147 13161 13184 13188 
+ 12952 12999 13120 13183 13266 13292 
+ 13067 13112 13153 13165 13227 15569 
+ 13071 13107 13121 13195 13204 13240 
+ 13132 13137 13157 13163 13188 13190 
+ 13138 13163 13191 13193 
+ 13137 13138 13161 13162 13190 13193 
+ 13086 13127 13133 13192 13201 13229 
+ 13111 13112 13159 13181 13216 13227 
+ 12759 12888 13109 13267 13297 13390 
+ 13077 13121 13125 13204 13206 13243 
+ 12230 12361 12887 13136 13498 13680 
+ 13135 13145 13150 13174 13197 13228 
+ 13076 13125 13130 13206 13207 13245 
+ 13108 13119 13142 13187 13249 13251 
+ 12818 13057 13059 13239 13279 13323 
+ 13091 13133 13201 13205 13234 15568 
+ 13131 13145 13148 13169 13199 13228 
+ 13081 13130 13134 13207 13209 13246 
+ 13089 13114 13115 13187 13189 13237 13258 
+ 13092 13139 13205 13208 13241 15568 
+ 13088 13134 13139 13208 13209 13244 
+ 13140 13147 13150 13184 13197 13211 
+ 13053 13123 13141 13222 13231 13264 
+ 13111 13118 13165 13189 13216 13232 
+ 13113 13144 13155 13219 
+ 12999 13011 13158 13266 13295 13334 
+ 13147 13157 13179 13188 13211 13217 
+ 13060 13110 13203 13218 13290 13294 
+ 12986 13099 13120 13238 13282 13293 
+ 13108 13115 13171 13176 13251 13258 
+ 13157 13161 13184 13190 13217 13220 
+ 13114 13118 13176 13181 13232 13237 
+ 13161 13163 13188 13193 13220 13223 
+ 13162 13193 13221 13226 
+ 13127 13155 13164 13219 13229 13256 
+ 13162 13163 13190 13191 13223 13226 
+ 13031 13085 13128 13235 13352 13387 
+ 13107 13141 13160 13231 13240 13271 
+ 13029 13099 13143 13238 13288 13301 
+ 13150 13169 13179 13211 13228 13242 
+ 13124 13142 13151 13236 13249 13325 
+ 13148 13149 13174 13215 13228 13262 
+ 12792 12971 13011 13230 13295 13418 13433 
+ 13133 13164 13173 13229 13234 13263 
+ 13098 13123 13218 13222 13257 13270 
+ 13045 13060 13143 13185 13288 13294 13321 
+ 13121 13160 13167 13240 13243 13275 
+ 13173 13177 13234 13241 13268 15568 
+ 13125 13167 13170 13243 13245 13277 
+ 13130 13170 13175 13245 13246 13276 
+ 13139 13177 13178 13241 13244 13272 
+ 13134 13175 13178 13244 13246 13274 
+ 12600 12906 13015 13367 13401 13523 
+ 13179 13184 13197 13217 13242 13248 
+ 11037 11492 11903 13588 14084 14344 
+ 12331 12469 12906 13401 13437 13629 
+ 13097 13152 13156 13215 13236 13298 13350 
+ 13149 13152 13199 13214 13262 13298 
+ 13165 13181 13227 13232 13269 
+ 13184 13188 13211 13220 13248 13250 
+ 13098 13110 13185 13202 13257 13286 13290 
+ 13155 13182 13192 13256 
+ 13188 13190 13217 13223 13250 13252 
+ 13191 13226 13253 13255 
+ 13123 13180 13202 13264 13270 13300 
+ 13190 13193 13220 13226 13252 13254 
+ 13061 13078 13096 13247 13261 13356 13382 
+ 13046 13109 13154 13291 13297 13420 
+ 13191 13193 13221 13223 13254 13255 
+ 13159 13165 13216 13269 13310 15569 
+ 13169 13174 13197 13199 13242 13262 13287 
+ 13164 13192 13201 13256 13263 13289 
+ 12971 13059 13200 13279 13384 13433 
+ 13141 13180 13195 13264 13271 13305 
+ 13181 13189 13216 13237 13269 13285 
+ 12725 13015 13094 13367 13370 13484 
+ 13173 13201 13205 13263 13268 13296 
+ 13085 13126 13194 13261 13352 13358 
+ 13151 13156 13198 13214 13325 13350 
+ 13176 13189 13232 13258 13285 13299 
+ 13099 13186 13196 13293 13301 13345 
+ 13057 13154 13172 13291 13323 13330 
+ 13160 13195 13204 13271 13275 13309 
+ 13177 13205 13208 13268 13272 13302 
+ 13197 13211 13228 13248 13278 13287 
+ 13167 13204 13206 13275 13277 13313 
+ 13178 13208 13209 13272 13274 13306 
+ 13170 13206 13207 13276 13277 13312 
+ 13175 13207 13209 13274 13276 13308 
+ 13078 13146 13224 13259 13351 13356 
+ 13211 13217 13242 13250 13273 13278 
+ 13142 13171 13198 13251 13325 13346 
+ 13217 13220 13248 13252 13273 15570 
+ 13171 13187 13249 13258 13328 13346 
+ 13220 13223 13250 13254 13280 15570 
+ 13221 13255 13281 13284 
+ 13223 13226 13252 13255 13280 13283 
+ 13221 13226 13253 13254 13283 13284 
+ 13192 13219 13229 13289 
+ 13202 13218 13270 13286 13318 
+ 13176 13187 13237 13251 13299 13328 
+ 13146 13153 13247 13342 13351 15569 
+ 6562 6740 11299 14209 15024 15057 
+ 13096 13126 13224 13235 13358 13382 
+ 13199 13215 13228 13287 13298 15571 
+ 13201 13229 13234 13289 13296 13320 
+ 13180 13222 13231 13300 13305 13332 
+ 11028 11137 12969 13426 14169 14468 
+ 13158 13183 13292 13334 13378 
+ 12888 13094 13166 13370 13390 13475 
+ 13205 13234 13241 13296 13302 13324 
+ 13216 13227 13232 13285 13310 13357 
+ 13202 13222 13257 13300 13318 13338 
+ 13195 13231 13240 13305 13309 13337 
+ 13208 13241 13244 13302 13306 13329 
+ 13248 13250 13278 13303 13304 15570 
+ 13209 13244 13246 13306 13308 13331 
+ 13204 13240 13243 13309 13313 13340 
+ 13207 13245 13246 13308 13312 13336 
+ 13206 13243 13245 13312 13313 13339 
+ 13242 13248 13273 13287 13304 13319 
+ 13059 13172 13230 13323 13384 13424 
+ 13252 13254 13283 13307 13314 15570 
+ 13253 13284 13311 13316 
+ 13120 13186 13292 13293 13363 13386 
+ 13254 13255 13280 13284 13314 13317 
+ 13253 13255 13281 13283 13316 13317 
+ 13232 13237 13269 13299 13348 13357 
+ 13218 13257 13290 13318 13347 
+ 13228 13242 13262 13278 13319 13349 15571 
+ 13143 13196 13203 13301 13321 13385 13391 
+ 13229 13256 13263 13320 
+ 13185 13218 13286 13294 13347 13361 
+ 13154 13225 13239 13330 13420 13435 
+ 13120 13158 13266 13282 13378 13386 
+ 13186 13238 13282 13345 13360 13363 
+ 13185 13203 13290 13321 13361 13389 
+ 13011 13183 13200 13334 13418 13487 
+ 13234 13263 13268 13320 13324 13353 
+ 13109 13166 13225 13390 13420 13479 
+ 13214 13215 13262 13350 13393 15571 
+ 13237 13258 13285 13328 13348 13365 
+ 13222 13264 13270 13332 13338 13373 
+ 13196 13238 13288 13345 13385 13399 
+ 13241 13268 13272 13324 13329 13359 
+ 13273 13304 13307 13322 13326 15570 
+ 13273 13278 13303 13319 13322 13327 
+ 13231 13264 13271 13332 13337 13375 
+ 13244 13272 13274 13329 13331 13366 
+ 13280 13303 13314 13326 13333 15570 
+ 13246 13274 13276 13331 13336 13368 
+ 13240 13271 13275 13337 13340 13377 
+ 13227 13269 13342 13357 13445 15569 
+ 13281 13316 13335 13343 
+ 13245 13276 13277 13336 13339 13374 
+ 13243 13275 13277 13339 13340 13376 
+ 13280 13283 13307 13317 13333 13341 
+ 11578 11733 12876 13654 13684 14021 
+ 13281 13284 13311 13317 13343 13344 
+ 13283 13284 13314 13316 13341 13344 
+ 13257 13270 13286 13338 13347 13383 
+ 13278 13287 13304 13327 13349 13354 
+ 13263 13289 13296 13353 
+ 13203 13288 13294 13389 13391 13419 
+ 13303 13304 13326 13327 13355 
+ 13172 13239 13279 13330 13424 13432 
+ 13268 13296 13302 13353 13359 13392 
+ 13198 13236 13249 13346 13350 13423 13494 
+ 13303 13307 13322 13333 13355 13362 
+ 13304 13319 13322 13354 13355 13364 
+ 13251 13258 13299 13346 13365 13388 
+ 13272 13302 13306 13359 13366 13395 
+ 13239 13291 13323 13432 13435 
+ 13274 13306 13308 13366 13368 13396 
+ 13264 13300 13305 13373 13375 13406 
+ 13307 13314 13326 13341 13362 13372 
+ 13183 13266 13295 13378 13453 13487 
+ 13311 13343 13369 13379 
+ 13276 13308 13312 13368 13374 13400 
+ 13271 13305 13309 13375 13377 13407 
+ 13270 13300 13318 13373 13383 13410 
+ 13277 13312 13313 13374 13376 13404 
+ 13275 13309 13313 13376 13377 13405 
+ 13314 13317 13333 13344 13372 13380 
+ 13259 13310 13351 13445 13461 15569 
+ 13311 13316 13335 13344 13379 13381 
+ 13316 13317 13341 13343 13380 13381 
+ 13238 13293 13301 13360 13399 13417 
+ 13249 13251 13325 13328 13388 13423 
+ 13286 13290 13318 13361 13383 13411 
+ 13285 13299 13357 13365 13403 
+ 13287 13319 13354 13397 13408 15571 
+ 13214 13236 13298 13325 13393 13474 13494 
+ 13247 13259 13342 13356 13461 
+ 13194 13235 13358 13387 13610 
+ 13296 13320 13324 13392 
+ 13319 13327 13349 13364 13397 
+ 13322 13326 13327 13362 13364 13394 
+ 13224 13247 13351 13382 13461 13532 
+ 13269 13285 13310 13348 13403 13445 13459 
+ 13235 13261 13352 13382 13610 
+ 13302 13324 13329 13392 13395 13421 
+ 13293 13345 13363 13417 13422 
+ 13290 13294 13347 13389 13411 13430 
+ 13326 13333 13355 13372 13394 13398 
+ 13282 13293 13360 13386 13422 13444 
+ 13327 13354 13355 13394 13397 13413 
+ 13299 13328 13348 13388 13403 13428 
+ 13306 13329 13331 13395 13396 13425 
+ 13015 13210 13233 13484 13523 13604 
+ 13308 13331 13336 13396 13400 13429 
+ 13335 13379 13402 13412 
+ 13094 13233 13267 13475 13484 13557 
+ 12913 12975 13032 13041 13128 13387 13498 13811 
+ 13333 13341 13362 13380 13398 13409 
+ 13300 13332 13338 13406 13410 13441 
+ 13312 13336 13339 13400 13404 13431 
+ 13305 13332 13337 13406 13407 13439 
+ 13313 13339 13340 13404 13405 13436 
+ 13309 13337 13340 13405 13407 13438 
+ 13266 13292 13334 13386 13453 13456 
+ 13335 13343 13369 13381 13412 13416 
+ 13341 13344 13372 13381 13409 13415 
+ 13343 13344 13379 13380 13415 13416 
+ 13224 13261 13356 13358 13532 13610 
+ 13318 13338 13347 13410 13411 13443 
+ 13230 13279 13424 13433 13509 
+ 13288 13301 13391 13399 13446 13452 
+ 13282 13292 13363 13378 13444 13456 
+ 13128 13194 13352 13371 13610 13811 
+ 13328 13346 13365 13423 13428 
+ 13294 13321 13361 13419 13430 13455 
+ 13166 13267 13297 13475 13479 13537 
+ 13288 13321 13385 13419 13446 13457 
+ 13324 13353 13359 13421 
+ 13298 13350 13408 13466 13474 15571 
+ 13355 13362 13364 13398 13413 13427 
+ 13329 13359 13366 13421 13425 13451 
+ 13331 13366 13368 13425 13429 13454 
+ 13349 13354 13364 13408 13413 13450 13462 
+ 13362 13372 13394 13409 13427 13440 
+ 13301 13345 13385 13417 13452 13458 
+ 13336 13368 13374 13429 13431 13460 
+ 12906 13210 13213 13523 13629 13681 
+ 13369 13412 13434 13442 
+ 13348 13357 13365 13428 13459 13502 
+ 13339 13374 13376 13431 13436 13463 
+ 13340 13376 13377 13436 13438 13465 
+ 13332 13373 13375 13439 13441 13468 
+ 13337 13375 13377 13438 13439 13467 
+ 13349 13393 13397 13462 13466 15571 
+ 13372 13380 13398 13415 13440 13447 
+ 13338 13373 13383 13441 13443 13472 
+ 13347 13361 13383 13430 13443 13471 
+ 13369 13379 13402 13416 13442 13448 
+ 13364 13394 13397 13427 13450 
+ 10857 11227 11933 13426 14593 14738 
+ 13380 13381 13409 13416 13447 13449 
+ 13379 13381 13412 13415 13448 13449 
+ 13345 13360 13399 13422 13458 13470 
+ 13200 13295 13433 13487 13555 13558 
+ 13321 13389 13391 13455 13457 13485 
+ 13225 13291 13297 13435 13479 13561 13581 
+ 13359 13392 13395 13451 
+ 13360 13363 13417 13444 13470 13489 
+ 13325 13346 13388 13428 13494 13525 
+ 13279 13323 13384 13432 13509 13520 
+ 13366 13395 13396 13451 13454 13478 
+ 11137 11227 13265 13414 14468 14738 
+ 13394 13398 13413 13440 13450 13469 
+ 13365 13388 13403 13423 13502 13525 
+ 13368 13396 13400 13454 13460 13483 
+ 13361 13389 13411 13455 13471 13491 
+ 13374 13400 13404 13460 13463 13486 
+ 13323 13330 13424 13435 13520 13540 
+ 13200 13230 13384 13418 13509 13555 13583 
+ 13402 13442 13464 13473 
+ 13291 13330 13420 13432 13540 13581 
+ 13376 13404 13405 13463 13465 13488 
+ 12469 12876 13213 13629 13684 13854 
+ 13377 13405 13407 13465 13467 13490 
+ 13375 13406 13407 13467 13468 13493 
+ 13398 13409 13427 13447 13469 13476 
+ 13373 13406 13410 13468 13472 13495 
+ 13402 13412 13434 13448 13473 13477 
+ 13383 13410 13411 13471 13472 13496 
+ 13363 13386 13422 13456 13489 13506 
+ 13310 13342 13357 13459 13461 13552 13575 
+ 13385 13391 13452 13457 13482 13497 
+ 13409 13415 13440 13449 13476 13481 
+ 13412 13416 13442 13449 13477 13480 
+ 13415 13416 13447 13448 13480 13481 
+ 13397 13413 13427 13462 13469 13501 
+ 13395 13421 13425 13478 
+ 13385 13399 13446 13458 13482 13499 
+ 13334 13378 13456 13487 13524 13571 
+ 13396 13425 13429 13478 13483 13503 
+ 13389 13419 13430 13485 13491 13516 
+ 13378 13386 13444 13453 13506 13524 
+ 13391 13419 13446 13485 13497 13515 
+ 13399 13417 13452 13470 13499 13512 
+ 13357 13403 13445 13502 13552 
+ 13400 13429 13431 13483 13486 13507 
+ 13342 13351 13356 13445 13532 13575 
+ 13397 13408 13450 13466 13501 13550 
+ 13404 13431 13436 13486 13488 13513 
+ 13434 13473 13492 13500 
+ 13405 13436 13438 13488 13490 13514 
+ 13393 13408 13462 13474 13550 13607 
+ 13407 13438 13439 13490 13493 13517 
+ 13406 13439 13441 13493 13495 13519 
+ 13427 13440 13450 13476 13501 13505 
+ 13417 13422 13458 13489 13512 13527 
+ 13411 13430 13443 13491 13496 13518 
+ 13410 13441 13443 13495 13496 13522 
+ 13434 13442 13464 13477 13500 13504 
+ 13350 13393 13466 13494 13607 
+ 13267 13370 13390 13537 13557 13602 
+ 13440 13447 13469 13481 13505 13510 
+ 13442 13448 13473 13480 13504 13508 
+ 13425 13451 13454 13503 
+ 13297 13390 13420 13537 13561 13582 
+ 13448 13449 13477 13481 13508 13511 
+ 13447 13449 13476 13480 13510 13511 
+ 13446 13452 13497 13499 13526 
+ 13429 13454 13460 13503 13507 13529 
+ 13233 13367 13370 13557 13604 13674 
+ 13419 13455 13457 13515 13516 13538 
+ 13431 13460 13463 13507 13513 13530 
+ 13295 13334 13418 13453 13558 13571 13617 
+ 13436 13463 13465 13513 13514 13533 
+ 13422 13444 13470 13506 13527 13551 
+ 13438 13465 13467 13514 13517 13536 
+ 13430 13455 13471 13516 13518 13542 
+ 13464 13500 13521 13528 
+ 13439 13467 13468 13517 13519 13541 
+ 13325 13350 13423 13474 13525 13607 13699 
+ 13441 13468 13472 13519 13522 13545 
+ 13443 13471 13472 13518 13522 13546 
+ 13446 13457 13482 13515 13526 13548 
+ 12887 13041 13168 13371 13680 13811 14098 
+ 13452 13458 13482 13512 13526 13549 
+ 13464 13473 13492 13504 13528 13531 
+ 13450 13462 13469 13505 13550 13564 
+ 13403 13428 13459 13525 13552 13635 
+ 13454 13478 13483 13529 
+ 13473 13477 13500 13508 13531 13534 
+ 13469 13476 13501 13510 13543 13564 
+ 13444 13456 13489 13524 13551 13580 
+ 13460 13483 13486 13529 13530 13553 
+ 13477 13480 13504 13511 13534 13539 
+ 13384 13424 13433 13520 13583 13600 13605 
+ 13476 13481 13505 13511 13543 13544 
+ 13480 13481 13508 13510 13539 13544 
+ 13458 13470 13499 13527 13549 13562 
+ 13463 13486 13488 13530 13533 13556 
+ 13465 13488 13490 13533 13536 13560 
+ 13457 13485 13497 13538 13548 13570 
+ 13455 13485 13491 13538 13542 13566 
+ 13467 13490 13493 13536 13541 13563 
+ 13471 13491 13496 13542 13546 13568 
+ 13468 13493 13495 13541 13545 13565 
+ 13424 13432 13509 13540 13587 13600 
+ 13492 13528 13547 13554 
+ 13472 13495 13496 13545 13546 13569 
+ 13210 13367 13401 13604 13681 13731 
+ 13453 13456 13506 13571 13580 13614 
+ 13423 13428 13494 13502 13635 13699 
+ 13482 13497 13499 13548 13549 13574 
+ 13470 13489 13512 13551 13562 13586 
+ 13492 13500 13521 13531 13554 13559 
+ 13483 13503 13507 13553 
+ 13486 13507 13513 13553 13556 13579 
+ 13500 13504 13528 13534 13559 13567 
+ 13356 13382 13461 13575 13610 13709 
+ 13488 13513 13514 13556 13560 13585 
+ 13504 13508 13531 13539 13567 13572 
+ 8355 10635 13856 14090 14887 14914 
+ 13490 13514 13517 13560 13563 13589 
+ 13390 13475 13479 13582 13602 13657 
+ 13485 13515 13516 13566 13570 13595 
+ 13508 13511 13534 13544 13572 13576 
+ 13432 13435 13520 13581 13587 13641 
+ 13493 13517 13519 13563 13565 13590 
+ 13491 13516 13518 13566 13568 13594 
+ 13505 13510 13544 13564 13577 
+ 13510 13511 13539 13543 13576 13577 
+ 13495 13519 13522 13565 13569 13592 
+ 13496 13518 13522 13568 13569 13593 
+ 13521 13554 13573 13584 
+ 13497 13515 13526 13570 13574 13597 
+ 13499 13512 13526 13562 13574 13596 
+ 13462 13466 13501 13564 13607 13663 
+ 13489 13506 13527 13580 13586 13611 
+ 13445 13459 13502 13575 13635 13706 
+ 13507 13529 13530 13579 
+ 13521 13528 13547 13559 13584 13591 
+ 13418 13433 13558 13583 13648 13651 
+ 13513 13530 13533 13579 13585 13603 
+ 13370 13475 13484 13602 13674 13748 
+ 13418 13487 13555 13617 13648 13683 
+ 13528 13531 13554 13567 13591 13598 
+ 13514 13533 13536 13585 13589 13609 
+ 13420 13479 13581 13582 13676 13687 
+ 13512 13527 13549 13586 13596 13619 
+ 13517 13536 13541 13589 13590 13615 
+ 13501 13505 13543 13550 13577 13663 
+ 13519 13541 13545 13590 13592 13618 
+ 13516 13538 13542 13594 13595 13622 
+ 13531 13534 13559 13572 13598 13601 
+ 13518 13542 13546 13593 13594 13621 
+ 13522 13545 13546 13592 13593 13620 
+ 13515 13538 13548 13595 13597 13623 
+ 13453 13487 13524 13614 13617 13647 13653 
+ 13534 13539 13567 13576 13601 13606 
+ 13547 13584 13599 13613 
+ 13526 13548 13549 13596 13597 13625 
+ 13445 13461 13532 13552 13706 13709 
+ 13539 13544 13572 13577 13606 13612 
+ 13543 13544 13564 13576 13612 13663 
+ 11962 12320 13075 13730 13931 14292 
+ 13530 13553 13556 13603 
+ 13506 13524 13551 13611 13614 13637 
+ 13420 13435 13540 13561 13641 13676 13696 
+ 13479 13537 13561 13657 13687 
+ 13433 13509 13555 13605 13651 13666 
+ 13547 13554 13573 13591 13613 13624 
+ 13533 13556 13560 13603 13609 13628 
+ 13527 13551 13562 13611 13619 13636 
+ 13520 13540 13600 13641 13655 
+ 11492 11859 13212 13730 14344 14483 
+ 13536 13560 13563 13609 13615 13631 
+ 13541 13563 13565 13615 13618 13632 
+ 13554 13559 13584 13598 13624 13627 
+ 13545 13565 13569 13618 13620 13638 
+ 13546 13568 13569 13620 13621 13640 
+ 13542 13566 13568 13621 13622 13642 
+ 13538 13566 13570 13622 13623 13643 
+ 13549 13562 13574 13619 13625 13644 
+ 13548 13570 13574 13623 13625 13645 
+ 13559 13567 13591 13601 13627 13630 
+ 13573 13613 13626 13634 
+ 13509 13520 13587 13605 13655 13660 
+ 13567 13572 13598 13606 13630 13633 
+ 13475 13537 13557 13657 13732 13748 
+ 13556 13579 13585 13628 
+ 13367 13484 13523 13674 13731 13776 
+ 13509 13583 13600 13660 13666 
+ 13572 13576 13601 13612 13633 13639 
+ 13466 13474 13494 13550 13663 13699 13791 
+ 410 5091 7666 14718 15121 15144 
+ 13560 13585 13589 13628 13631 13650 
+ 13352 13358 13382 13387 13532 13709 13811 13885 
+ 13551 13580 13586 13636 13637 13659 
+ 13576 13577 13606 13639 13663 13677 
+ 13573 13584 13599 13624 13634 13646 
+ 13524 13571 13580 13637 13647 13671 
+ 13563 13589 13590 13631 13632 13656 
+ 12643 13075 13136 13680 13931 14161 
+ 13487 13558 13571 13653 13683 13700 
+ 13565 13590 13592 13632 13638 13658 
+ 13562 13586 13596 13636 13644 13667 
+ 13569 13592 13593 13638 13640 13661 
+ 13568 13593 13594 13640 13642 13665 
+ 13566 13594 13595 13642 13643 13668 
+ 13570 13595 13597 13643 13645 13669 
+ 13584 13591 13613 13627 13646 13652 
+ 13574 13596 13597 13644 13645 13670 
+ 13599 13634 13649 13664 
+ 13591 13598 13624 13630 13652 13662 
+ 13585 13603 13609 13650 
+ 13213 13401 13437 13681 13854 13876 
+ 13598 13601 13627 13633 13662 13672 
+ 13589 13609 13615 13650 13656 13679 
+ 13590 13615 13618 13656 13658 13682 
+ 13601 13606 13630 13639 13672 13673 
+ 13599 13613 13626 13646 13664 13675 
+ 13502 13525 13552 13699 13706 13832 
+ 13586 13611 13619 13659 13667 13690 
+ 13580 13611 13614 13659 13671 13689 
+ 13592 13618 13620 13658 13661 13685 
+ 13606 13612 13633 13673 13677 
+ 13593 13620 13621 13661 13665 13688 
+ 13540 13581 13587 13655 13696 13744 
+ 13594 13621 13622 13665 13668 13691 
+ 13595 13622 13623 13668 13669 13693 
+ 13596 13619 13625 13667 13670 13692 
+ 13597 13623 13625 13669 13670 13694 
+ 13613 13624 13634 13652 13675 13686 
+ 13571 13614 13653 13671 13697 13708 
+ 13555 13558 13651 13683 13723 13740 
+ 13626 13664 13678 13695 
+ 13609 13628 13631 13679 
+ 13555 13583 13648 13666 13723 13726 
+ 13624 13627 13646 13662 13686 13698 
+ 13571 13617 13647 13700 13708 13725 
+ 11733 12178 13315 14021 14023 14374 
+ 13587 13600 13641 13660 13722 13744 
+ 13615 13631 13632 13679 13682 13702 
+ 13537 13582 13602 13687 13732 13759 
+ 13618 13632 13638 13682 13685 13707 
+ 13611 13636 13637 13689 13690 13712 
+ 13600 13605 13655 13666 13720 13722 
+ 13620 13638 13640 13685 13688 13710 
+ 13627 13630 13652 13672 13698 13701 
+ 13550 13564 13577 13607 13612 13677 13766 13791 
+ 13626 13634 13649 13675 13695 13703 
+ 13621 13640 13642 13688 13691 13711 
+ 13583 13605 13651 13660 13720 13726 
+ 13619 13636 13644 13690 13692 13714 
+ 13622 13642 13643 13691 13693 13713 
+ 13623 13643 13645 13693 13694 13715 
+ 13625 13644 13645 13692 13694 13716 
+ 13614 13637 13647 13689 13697 13718 
+ 13630 13633 13662 13673 13701 13705 
+ 13633 13639 13672 13677 13705 13736 
+ 13484 13557 13604 13748 13776 13823 
+ 13634 13646 13664 13686 13703 13717 
+ 13561 13581 13687 13696 13773 13777 
+ 13612 13639 13663 13673 13736 13766 
+ 13649 13695 13704 13719 
+ 13631 13650 13656 13702 
+ 13136 13168 13498 13616 14098 14161 
+ 13401 13523 13629 13731 13876 13897 
+ 13632 13656 13658 13702 13707 13724 
+ 13558 13617 13648 13700 13740 13770 
+ 12876 13315 13437 13854 14021 14159 
+ 13638 13658 13661 13707 13710 13728 
+ 13646 13652 13675 13698 13717 13721 
+ 13561 13582 13657 13676 13759 13777 
+ 13640 13661 13665 13710 13711 13733 
+ 13637 13659 13671 13712 13718 13737 
+ 13636 13659 13667 13712 13714 13738 
+ 13642 13665 13668 13711 13713 13735 
+ 13644 13667 13670 13714 13716 13741 
+ 13643 13668 13669 13713 13715 13739 
+ 13645 13669 13670 13715 13716 13742 
+ 13649 13664 13678 13703 13719 13729 
+ 13581 13641 13676 13744 13773 13793 
+ 13647 13671 13708 13718 13743 
+ 13652 13662 13686 13701 13721 13734 
+ 13494 13525 13607 13635 13791 13832 13945 
+ 13617 13653 13683 13725 13767 13770 
+ 13662 13672 13698 13705 13734 13745 
+ 13656 13679 13682 13724 
+ 13664 13675 13695 13717 13729 13746 
+ 13678 13719 13727 13747 
+ 13672 13673 13701 13736 13745 
+ 13552 13575 13635 13709 13832 13902 
+ 13658 13682 13685 13724 13728 13749 
+ 13647 13653 13697 13725 13743 13758 
+ 13532 13575 13610 13706 13885 13902 
+ 13661 13685 13688 13728 13733 13753 
+ 13665 13688 13691 13733 13735 13755 
+ 13659 13689 13690 13737 13738 13760 
+ 13668 13691 13693 13735 13739 13757 
+ 13667 13690 13692 13738 13741 13762 
+ 13669 13693 13694 13739 13742 13761 
+ 13670 13692 13694 13741 13742 13763 
+ 13675 13686 13703 13721 13746 13751 
+ 13671 13689 13697 13737 13743 13764 
+ 13678 13695 13704 13729 13747 13756 
+ 13660 13666 13722 13726 13779 13788 
+ 13686 13698 13717 13734 13751 13765 
+ 13655 13660 13720 13744 13774 13788 
+ 13648 13651 13726 13740 13794 13798 
+ 13682 13702 13707 13749 
+ 13653 13700 13708 13758 13767 13778 
+ 13651 13666 13720 13723 13779 13794 
+ 13704 13747 13754 13769 
+ 13685 13707 13710 13749 13753 13772 
+ 13695 13703 13719 13746 13756 13768 
+ 11859 12320 13578 13588 14292 14483 
+ 13523 13604 13681 13776 13897 13917 
+ 13602 13657 13748 13759 13829 13850 
+ 13688 13710 13711 13753 13755 13775 
+ 13698 13701 13721 13745 13765 13771 
+ 13691 13711 13713 13755 13757 13780 
+ 13673 13677 13705 13745 13766 13862 
+ 13689 13712 13718 13760 13764 13784 
+ 13690 13712 13714 13760 13762 13785 
+ 13693 13713 13715 13757 13761 13782 
+ 13648 13683 13723 13770 13798 13808 
+ 13692 13714 13716 13762 13763 13787 
+ 13694 13715 13716 13761 13763 13786 
+ 13697 13708 13718 13758 13764 13789 
+ 13641 13655 13696 13722 13774 13793 13812 
+ 13701 13705 13734 13736 13771 13862 
+ 13703 13717 13729 13751 13768 13783 
+ 13704 13719 13727 13756 13769 13790 
+ 13557 13602 13674 13732 13823 13850 13894 
+ 13707 13724 13728 13772 
+ 7436 7933 8232 14308 14955 15001 
+ 13717 13721 13746 13765 13783 13792 
+ 10539 11903 14084 14768 15544 15601 
+ 13710 13728 13733 13772 13775 13797 
+ 13727 13769 13781 13795 
+ 13711 13733 13735 13775 13780 13799 
+ 13719 13729 13747 13768 13790 13796 
+ 13713 13735 13739 13780 13782 13801 
+ 13708 13725 13743 13778 13789 13807 
+ 13657 13687 13732 13777 13829 13840 
+ 13712 13737 13738 13784 13785 13803 
+ 13715 13739 13742 13782 13786 13802 
+ 13714 13738 13741 13785 13787 13804 
+ 13716 13741 13742 13786 13787 15572 
+ 13718 13737 13743 13784 13789 13805 
+ 13721 13734 13751 13771 13792 13800 
+ 13663 13677 13736 13791 13862 14018 
+ 13700 13725 13770 13778 13818 13826 
+ 13729 13746 13756 13783 13796 13809 
+ 13727 13747 13754 13790 13795 13810 
+ 13683 13700 13740 13767 13808 13826 13836 
+ 13734 13745 13765 13800 13862 
+ 13728 13749 13753 13797 
+ 13676 13696 13777 13793 13857 13858 
+ 13722 13744 13788 13812 13837 
+ 13733 13753 13755 13797 13799 13816 
+ 13604 13674 13731 13823 13917 13928 
+ 13676 13687 13759 13773 13840 13858 
+ 13725 13758 13767 13807 13813 13818 
+ 13720 13726 13788 13794 13830 13833 
+ 13735 13755 13757 13799 13801 13817 
+ 13754 13795 13806 13815 
+ 13739 13757 13761 13801 13802 13820 
+ 13746 13751 13768 13792 13809 13814 
+ 13737 13760 13764 13803 13805 13822 
+ 13738 13760 13762 13803 13804 13824 
+ 13742 13761 13763 13802 15572 15573 
+ 13741 13762 13763 13804 13825 15572 
+ 13720 13722 13774 13779 13833 13837 
+ 13743 13758 13764 13805 13807 13821 
+ 13747 13756 13769 13796 13810 13819 
+ 13607 13663 13699 13766 13945 14018 
+ 13751 13765 13783 13800 13814 13828 
+ 13696 13744 13773 13812 13857 13889 
+ 13723 13726 13779 13798 13830 13835 13859 
+ 13754 13769 13781 13810 13815 13831 
+ 13756 13768 13790 13809 13819 13834 
+ 13753 13772 13775 13816 
+ 13723 13740 13794 13808 13835 13849 
+ 13755 13775 13780 13816 13817 13839 
+ 13765 13771 13792 13828 13862 
+ 13757 13780 13782 13817 13820 13842 
+ 13761 13782 13786 13820 13844 15573 
+ 13760 13784 13785 13822 13824 13845 
+ 13762 13785 13787 13824 13825 13847 
+ 13764 13784 13789 13821 13822 13843 
+ 13781 13815 13827 13841 
+ 13758 13778 13789 13813 13821 13838 
+ 13740 13770 13798 13836 13849 13866 
+ 13768 13783 13796 13814 13834 13848 
+ 13769 13790 13795 13819 13831 13851 
+ 13371 13387 13498 13610 13885 14098 14198 
+ 13744 13774 13793 13837 13882 13889 
+ 13778 13807 13818 13838 13853 
+ 13783 13792 13809 13828 13848 13855 
+ 13781 13795 13806 13831 13841 13860 
+ 13775 13797 13799 13839 
+ 13780 13799 13801 13839 13842 13865 
+ 13767 13778 13813 13826 13853 13861 
+ 13790 13796 13810 13834 13851 13864 
+ 13782 13801 13802 13842 13844 13867 
+ 13789 13805 13807 13838 13843 13863 
+ 13784 13803 13805 13843 13845 13868 
+ 13674 13748 13776 13894 13928 13954 
+ 13785 13803 13804 13845 13847 13870 
+ 13787 13804 13846 13847 13871 15572 
+ 13767 13770 13818 13836 13861 13877 
+ 13806 13841 13852 13872 
+ 13792 13800 13814 13855 13862 13881 
+ 13732 13759 13840 13850 13916 13939 
+ 13779 13794 13833 13859 13873 13883 
+ 13795 13810 13815 13851 13860 13875 
+ 13635 13699 13706 13902 13945 14079 
+ 13779 13788 13830 13837 13883 13899 
+ 13796 13809 13819 13848 13864 13878 
+ 13794 13798 13849 13859 13880 
+ 13770 13808 13826 13866 13877 13904 
+ 13774 13788 13812 13833 13882 13899 
+ 13807 13813 13821 13853 13863 13879 
+ 13799 13816 13817 13865 
+ 13759 13777 13829 13858 13916 13922 
+ 13806 13815 13827 13860 13872 13884 
+ 13801 13817 13820 13865 13867 13888 
+ 13805 13821 13822 13863 13868 13886 
+ 13802 13820 13867 13869 13890 15573 
+ 13803 13822 13824 13868 13870 13891 
+ 13825 13869 13871 13892 15572 15573 
+ 13804 13824 13825 13870 13871 13893 
+ 13809 13814 13834 13855 13878 13887 
+ 13798 13808 13835 13866 13880 13903 
+ 13732 13748 13829 13894 13939 13960 
+ 13810 13819 13831 13864 13875 13895 
+ 13827 13872 13874 13898 
+ 13813 13818 13838 13861 13879 13896 
+ 13437 13629 13684 13876 14103 14159 
+ 13814 13828 13848 13881 13887 13900 
+ 6996 8355 13535 14069 14909 14914 
+ 13773 13793 13858 13889 13933 13943 
+ 13773 13777 13840 13857 13922 13933 
+ 13794 13830 13835 13873 13880 13905 
+ 13815 13831 13841 13875 13884 13906 
+ 13818 13826 13853 13877 13896 13910 
+ 13736 13745 13766 13771 13800 13828 13881 13993 14018 
+ 13821 13838 13843 13879 13886 13907 
+ 13819 13834 13851 13878 13895 13908 
+ 13817 13839 13842 13888 
+ 13808 13836 13849 13903 13904 13927 
+ 13820 13842 13844 13888 13890 13911 
+ 13822 13843 13845 13886 13891 13909 
+ 13844 13846 13890 13892 13913 15573 
+ 13824 13845 13847 13891 13893 13914 
+ 13825 13846 13847 13892 13893 13915 
+ 13827 13841 13852 13884 13898 13912 
+ 13830 13859 13883 13905 13921 
+ 13852 13898 13901 13918 
+ 13831 13851 13860 13895 13906 13919 
+ 13629 13681 13854 13897 14024 14103 
+ 13826 13836 13861 13904 13910 13932 
+ 13834 13848 13864 13887 13908 13920 
+ 13838 13853 13863 13896 13907 13923 
+ 13835 13849 13859 13903 13905 13925 
+ 13828 13855 13862 13900 13993 
+ 13812 13837 13889 13899 13951 13952 
+ 13830 13833 13873 13899 13921 13940 
+ 13841 13860 13872 13906 13912 13929 
+ 13610 13709 13811 13902 14162 14198 
+ 13843 13863 13868 13907 13909 13930 
+ 13848 13855 13878 13900 13920 13926 
+ 13842 13865 13867 13911 
+ 13793 13812 13857 13882 13943 13952 13970 
+ 13844 13867 13869 13911 13913 13934 
+ 13845 13868 13870 13909 13914 13935 
+ 13846 13869 13871 13913 13915 13936 
+ 13847 13870 13871 13914 13915 13937 
+ 13748 13823 13850 13954 13960 13999 
+ 13851 13864 13875 13908 13919 13938 
+ 13853 13861 13879 13910 13923 13942 
+ 13681 13731 13876 13917 14024 14036 
+ 13852 13872 13874 13912 13918 13941 
+ 13833 13837 13882 13883 13940 13947 13951 
+ 13855 13881 13887 13926 13993 
+ 13874 13918 13924 13944 
+ 13706 13709 13832 13885 14079 14162 
+ 13849 13866 13880 13925 13927 13949 
+ 13836 13866 13877 13927 13932 13955 
+ 13859 13873 13880 13921 13925 13946 
+ 13860 13875 13884 13919 13929 15575 
+ 13863 13879 13886 13923 13930 13948 
+ 13864 13878 13895 13920 13938 13950 
+ 13868 13886 13891 13930 13935 13953 
+ 13861 13877 13896 13932 13942 13962 
+ 13867 13888 13890 13934 
+ 13872 13884 13898 13929 13941 13956 
+ 13869 13890 13892 13934 13936 13957 
+ 13870 13891 13893 13935 13937 13958 
+ 13871 13892 13893 13936 13937 13959 
+ 13829 13840 13922 13939 13981 14013 
+ 13731 13776 13897 13928 14036 14058 
+ 13874 13898 13901 13941 13944 13963 
+ 13875 13895 13906 13938 13964 15575 
+ 13878 13887 13908 13926 13950 13961 
+ 13873 13883 13905 13940 13946 13966 
+ 13840 13858 13916 13933 13981 13983 
+ 13879 13896 13907 13942 13948 13968 
+ 13901 13944 13967 15574 
+ 13880 13903 13905 13946 13949 13971 
+ 13887 13900 13920 13961 13993 
+ 13866 13903 13904 13949 13955 13974 
+ 13776 13823 13917 13954 14043 14058 
+ 13884 13906 13912 13956 13972 15575 
+ 13886 13907 13909 13948 13953 13973 
+ 13075 13578 13616 14161 14292 14569 
+ 13877 13904 13910 13955 13962 13982 
+ 13857 13858 13922 13943 13983 13992 
+ 13890 13911 13913 13957 
+ 13891 13909 13914 13953 13958 13975 
+ 13892 13913 13915 13957 13959 13976 
+ 13893 13914 13915 13958 13959 13977 
+ 13895 13908 13919 13950 13964 13978 
+ 13829 13850 13916 13960 14013 14015 
+ 13883 13899 13921 13947 13966 13979 
+ 13898 13912 13918 13956 13963 13980 
+ 13896 13910 13923 13962 13968 13985 
+ 13857 13889 13933 13970 13992 14003 
+ 13901 13918 13924 13963 13967 13984 
+ 13699 13791 13832 14018 14079 14220 
+ 13905 13921 13925 13966 13971 13988 
+ 13899 13940 13951 13979 13990 
+ 13907 13923 13930 13968 13973 13991 
+ 13903 13925 13927 13971 13974 13994 
+ 13908 13920 13938 13961 13978 14132 
+ 13882 13899 13947 13952 13990 14000 
+ 13882 13889 13951 13970 14000 14011 
+ 13909 13930 13935 13973 13975 13996 
+ 13823 13894 13928 13999 14028 14043 
+ 13904 13927 13932 13974 13982 13998 
+ 13912 13929 13941 13972 13980 13995 
+ 13913 13934 13936 13976 
+ 13914 13935 13937 13975 13977 13997 
+ 13915 13936 13937 13976 13977 15576 
+ 13850 13894 13939 13999 14015 14051 
+ 13920 13926 13950 13993 14132 
+ 13910 13932 13942 13982 13985 14005 
+ 13918 13941 13944 13980 13984 14001 
+ 13919 13938 13978 13986 14002 15575 
+ 10752 12039 12141 14823 14913 14968 
+ 13921 13940 13946 13979 13988 14004 
+ 13924 13944 13984 13987 14006 15574 
+ 13923 13942 13948 13985 13991 14009 
+ 13987 13989 14008 15574 
+ 13889 13943 13952 14003 14011 14032 
+ 13925 13946 13949 13988 13994 14012 
+ 13929 13956 13986 13995 14010 15575 
+ 13930 13948 13953 13991 13996 14014 
+ 13927 13949 13955 13994 13998 14020 
+ 13935 13953 13958 13996 13997 14016 
+ 13936 13957 13959 15576 
+ 13937 13958 13959 13997 14017 15576 
+ 13938 13950 13964 14002 14132 
+ 13940 13947 13966 13990 14004 14022 
+ 13941 13956 13963 13995 14001 14019 
+ 13916 13922 13983 14013 14054 15577 
+ 13932 13955 13962 13998 14005 14026 
+ 13922 13933 13981 13992 14031 15577 
+ 13944 13963 13967 14001 14006 14025 
+ 13942 13962 13968 14005 14009 14034 
+ 13964 13972 14002 14010 14027 15575 
+ 13967 13969 14006 14008 14030 15574 
+ 13946 13966 13971 14004 14012 14035 
+ 13969 14007 14008 14033 
+ 13947 13951 13979 14000 14022 15578 
+ 13948 13968 13973 14009 14014 14037 
+ 13933 13943 13983 14003 14031 14042 
+ 13862 13881 13900 13926 13961 14018 14132 14288 
+ 13949 13971 13974 14012 14020 14041 
+ 13956 13972 13980 14010 14019 14038 
+ 13953 13973 13975 14014 14016 14039 
+ 13958 13975 13977 14016 14017 14040 
+ 13955 13974 13982 14020 14026 14045 
+ 13894 13954 13960 14028 14051 14076 
+ 13951 13952 13990 14011 14047 15578 
+ 13963 13980 13984 14019 14025 14044 
+ 13964 13978 13986 14027 14132 
+ 13943 13970 13992 14032 14042 14057 
+ 13966 13979 13988 14022 14035 14049 
+ 13962 13982 13985 14026 14034 14050 
+ 13967 13984 13987 14025 14030 14048 
+ 13989 14029 14033 14052 
+ 13969 13987 13989 14030 14033 14053 
+ 13968 13985 13991 14034 14037 14056 
+ 13972 13986 13995 14027 14038 14055 
+ 13952 13970 14000 14032 14047 14064 
+ 13971 13988 13994 14035 14041 14060 
+ 13916 13939 13981 14015 14054 14072 14092 
+ 13973 13991 13996 14037 14039 14059 
+ 13939 13960 14013 14051 14072 14106 
+ 13975 13996 13997 14039 14040 14061 
+ 13977 13997 14040 15576 
+ 13766 13791 13862 13945 13993 14220 14288 
+ 13980 13995 14001 14038 14044 14062 
+ 13974 13994 13998 14041 14045 14065 
+ 13315 13654 13684 14159 14374 14433 
+ 13979 13990 14004 14049 14063 15578 
+ 12178 12969 13654 14169 14374 14725 14744 
+ 13876 13897 14036 14103 14150 14202 
+ 13984 14001 14006 14044 14048 14068 
+ 13982 13998 14005 14045 14050 14071 
+ 13986 14002 14010 14055 14132 
+ 13954 13999 14043 14076 14095 
+ 14007 14046 14052 14070 
+ 13987 14006 14008 14048 14053 14073 
+ 13983 13992 14042 14067 14075 15577 
+ 13970 14003 14011 14057 14064 14091 
+ 13989 14007 14008 14052 14053 14074 
+ 13985 14005 14009 14050 14056 14077 
+ 13988 14004 14012 14049 14060 14078 
+ 13897 13917 14024 14058 14150 14158 
+ 13991 14009 14014 14056 14059 14081 
+ 13995 14010 14019 14055 14062 14080 
+ 13996 14014 14016 14059 14061 14083 
+ 13997 14016 14017 14061 
+ 13994 14012 14020 14060 14065 14087 
+ 13992 14003 14031 14057 14067 14088 
+ 13928 13954 14028 14058 14095 14140 
+ 14001 14019 14025 14062 14068 14089 
+ 13998 14020 14026 14065 14071 14094 
+ 14029 14066 14070 14093 
+ 14000 14011 14064 14082 14102 15578 
+ 14006 14025 14030 14068 14073 14096 
+ 14004 14022 14035 14063 14078 14097 
+ 14005 14026 14034 14071 14077 14101 
+ 13960 13999 14015 14076 14106 14128 
+ 14007 14029 14033 14070 14074 14099 
+ 14008 14030 14033 14073 14074 14100 
+ 13981 14013 14085 14092 14108 15577 
+ 14010 14027 14038 14080 14132 14143 
+ 14009 14034 14037 14077 14081 14104 
+ 14003 14032 14042 14088 14091 14116 
+ 13917 13928 14036 14043 14140 14158 14189 
+ 14014 14037 14039 14081 14083 14107 
+ 14012 14035 14041 14078 14087 14110 
+ 14016 14039 14040 14083 
+ 14019 14038 14044 14080 14089 14109 
+ 14022 14049 14082 14097 14114 15578 
+ 14011 14032 14047 14091 14102 14123 
+ 14020 14041 14045 14087 14094 14115 
+ 14046 14086 14093 14112 
+ 14031 14042 14075 14088 14111 
+ 14025 14044 14048 14089 14096 14113 
+ 6996 8429 13856 14909 14963 14979 
+ 14029 14046 14052 14093 14099 14117 
+ 14026 14045 14050 14094 14101 14120 
+ 14013 14015 14092 14106 14119 14137 
+ 14030 14048 14053 14096 14100 14118 
+ 14033 14052 14053 14099 14100 14122 
+ 14031 14067 14085 14111 14124 15577 
+ 13999 14028 14051 14095 14128 14145 
+ 14034 14050 14056 14101 14104 14125 
+ 14035 14049 14060 14097 14110 14126 
+ 13832 13902 13945 14162 14220 14360 
+ 14038 14055 14062 14109 14143 
+ 14037 14056 14059 14104 14107 14127 
+ 14047 14063 14102 14114 14131 15578 
+ 14039 14059 14061 14107 
+ 11903 13212 13752 14344 14768 14883 
+ 14054 14075 14108 14124 14135 15577 
+ 14066 14105 14112 14129 
+ 14041 14060 14065 14110 14115 14134 
+ 14042 14057 14067 14111 14116 14136 
+ 14044 14062 14068 14109 14113 14130 
+ 10635 11933 13535 14593 14887 14951 
+ 14032 14057 14064 14116 14123 14146 
+ 14013 14054 14072 14108 14119 14133 
+ 14046 14066 14070 14112 14117 14138 
+ 14045 14065 14071 14115 14120 14142 
+ 14028 14043 14076 14140 14145 14179 
+ 14048 14068 14073 14113 14118 14141 
+ 14049 14063 14078 14114 14126 14147 
+ 13498 13680 13811 14161 14198 14599 14674 
+ 14052 14070 14074 14117 14122 14144 
+ 14053 14073 14074 14118 14122 15580 
+ 14050 14071 14077 14120 14125 14148 
+ 14047 14064 14082 14123 14131 14154 
+ 13854 13876 14024 14159 14202 14376 
+ 14056 14077 14081 14125 14127 14151 
+ 14086 14121 14129 14149 
+ 14015 14051 14072 14128 14137 14176 
+ 14059 14081 14083 14127 
+ 14054 14085 14092 14133 14135 14153 
+ 14062 14080 14089 14130 14143 14221 
+ 14060 14078 14087 14126 14134 14156 
+ 14067 14075 14088 14124 14136 14152 
+ 14066 14086 14093 14129 14138 14157 
+ 14068 14089 14096 14130 14141 14160 
+ 14063 14082 14097 14131 14147 14165 
+ 14065 14087 14094 14134 14142 14163 
+ 14057 14088 14091 14136 14146 14164 
+ 14070 14093 14099 14138 14144 15581 
+ 14073 14096 14100 14141 14166 15580 
+ 14072 14092 14133 14137 14167 
+ 14071 14094 14101 14142 14148 14170 
+ 14105 14139 14149 15582 
+ 14074 14099 14100 14144 14171 15580 
+ 14064 14091 14102 14146 14154 14174 
+ 14075 14085 14111 14135 14152 14168 
+ 14077 14101 14104 14148 14151 14173 
+ 14078 14097 14110 14147 14156 14175 
+ 14081 14104 14107 14151 
+ 14051 14076 14106 14145 14176 14193 
+ 14086 14105 14112 14149 14157 15584 
+ 14089 14109 14113 14160 14221 
+ 14082 14102 14114 14154 14165 14183 
+ 13950 13961 13978 13993 14002 14027 14055 14143 14288 14415 
+ 14092 14108 14119 14153 14167 14172 
+ 14087 14110 14115 14156 14163 14180 
+ 14085 14108 14124 14153 14168 14182 
+ 14088 14111 14116 14152 14164 14177 
+ 14072 14106 14119 14167 14176 14187 
+ 14093 14112 14117 14157 14181 15581 
+ 14121 14155 14178 15582 
+ 14043 14058 14095 14179 14189 14216 
+ 14096 14113 14118 14160 14166 14184 
+ 14094 14115 14120 14163 14170 14186 
+ 14055 14080 14109 14132 14221 14415 
+ 14099 14117 14122 14171 15581 15585 
+ 14076 14095 14128 14179 14193 14223 
+ 14091 14116 14123 14164 14174 14192 
+ 14097 14114 14126 14165 14175 14194 
+ 14101 14120 14125 14170 14173 14191 
+ 14105 14121 14129 14190 15582 15584 
+ 14024 14036 14158 14202 14284 14287 
+ 14104 14125 14127 14173 
+ 14111 14124 14136 14168 14177 14195 
+ 14108 14133 14135 14172 14182 14196 
+ 14102 14123 14131 14174 14183 14204 
+ 14139 14178 14197 15583 
+ 14110 14126 14134 14175 14180 14203 
+ 14112 14129 14138 14181 14200 15584 
+ 14036 14058 14150 14189 14271 14287 
+ 13684 13854 14021 14103 14376 14433 14530 
+ 14113 14130 14141 14184 14221 
+ 13616 13680 13931 14098 14569 14674 
+ 13885 13902 14079 14198 14360 14498 
+ 14115 14134 14142 14180 14186 14206 
+ 14116 14136 14146 14177 14192 14208 
+ 14114 14131 14147 14183 14194 14211 
+ 14118 14141 14184 14188 15580 15586 
+ 14119 14133 14137 14172 14187 14199 
+ 14124 14135 14152 14182 14195 14210 
+ 12969 13265 14023 14468 14725 14902 
+ 14120 14142 14148 14186 14191 14213 
+ 14122 14144 14188 14214 15580 15585 
+ 14133 14153 14167 14196 14199 
+ 14125 14148 14151 14191 
+ 14123 14146 14154 14192 14204 14219 
+ 14126 14147 14156 14194 14203 14218 
+ 14106 14128 14137 14187 14193 14234 14244 
+ 14136 14152 14164 14195 14208 14224 
+ 14139 14155 14197 14205 14222 15582 
+ 14095 14140 14145 14216 14223 14248 
+ 14134 14156 14163 14203 14206 14228 
+ 14138 14157 14200 14207 14225 15581 
+ 14135 14153 14168 14196 14210 14226 
+ 14131 14154 14165 14204 14211 14230 
+ 14141 14160 14166 14221 15586 
+ 14201 14212 14227 15583 
+ 14142 14163 14170 14206 14213 15587 
+ 14137 14167 14176 14199 14231 14234 
+ 14166 14171 14214 14235 15580 15586 
+ 14058 14140 14158 14216 14259 14271 
+ 14149 14205 14217 14233 15582 15584 
+ 14148 14170 14173 14213 
+ 14146 14164 14174 14208 14219 14237 
+ 14128 14145 14176 14223 14244 14264 
+ 14147 14165 14175 14211 14218 14239 
+ 14152 14168 14177 14210 14224 14241 
+ 14153 14172 14182 14199 14226 14232 
+ 14155 14178 14212 14222 14238 15583 
+ 13811 13885 14098 14162 14498 14599 
+ 14167 14172 14187 14196 14231 14232 
+ 14157 14181 14217 14225 14242 15584 
+ 14185 14215 14227 14240 
+ 14024 14103 14150 14284 14376 
+ 14156 14175 14180 14218 14228 14245 
+ 14154 14174 14183 14219 14230 14247 
+ 14178 14190 14222 14233 14246 15582 
+ 14163 14180 14186 14228 14249 15587 
+ 14181 14225 14236 14251 15581 15585 
+ 14164 14177 14192 14224 14237 14252 
+ 6740 7295 13260 14884 15057 15086 
+ 14168 14182 14195 14226 14241 14254 
+ 14165 14183 14194 14230 14239 14257 
+ 14185 14197 14227 14238 14250 15583 
+ 14170 14186 14191 15587 
+ 14171 14188 14235 14236 14258 15585 
+ 14201 14229 14240 14253 
+ 14140 14179 14189 14248 14259 14270 
+ 14190 14200 14233 14242 14256 15584 
+ 14175 14194 14203 14239 14245 14261 
+ 14174 14192 14204 14237 14247 14262 
+ 13945 14018 14079 14288 14360 14475 
+ 14109 14130 14143 14160 14184 14415 15586 15588 
+ 14178 14197 14205 14238 14246 15589 
+ 14145 14179 14193 14248 14264 14285 
+ 14177 14195 14208 14241 14252 14267 
+ 14181 14200 14207 14242 14251 14265 
+ 14182 14196 14210 14232 14254 14260 
+ 14185 14201 14212 14240 14250 14263 
+ 14180 14203 14206 14245 14249 14272 
+ 14215 14243 14253 14266 
+ 14183 14204 14211 14247 14257 14274 
+ 14187 14199 14232 14234 14269 14275 
+ 14196 14199 14226 14231 14260 14269 
+ 14190 14205 14217 14246 14256 14273 
+ 14176 14187 14231 14244 14275 14289 
+ 14188 14214 14258 14277 15586 15588 
+ 14207 14214 14251 14258 15585 15590 
+ 14192 14208 14219 14252 14262 14280 
+ 14197 14212 14222 14250 14276 15589 
+ 14194 14211 14218 14257 14261 14282 
+ 14201 14215 14227 14253 14263 14278 
+ 14195 14210 14224 14254 14267 14283 
+ 14200 14217 14225 14256 14265 14279 
+ 14229 14255 14266 14281 
+ 14176 14193 14234 14264 14289 14305 
+ 14203 14218 14228 14261 14272 14290 
+ 14205 14222 14233 14273 14286 15589 
+ 14204 14219 14230 14262 14274 14293 
+ 14179 14216 14223 14270 14285 14304 
+ 14206 14228 14272 15587 
+ 14212 14227 14238 14263 14276 14291 
+ 14207 14225 14236 14265 14298 15590 
+ 14208 14224 14237 14267 14280 14300 
+ 14215 14229 14240 14266 14278 14294 
+ 14210 14226 14241 14260 14283 14295 
+ 14243 14268 14281 14297 
+ 14217 14233 14242 14273 14279 14296 
+ 14211 14230 14239 14274 14282 14301 
+ 14214 14235 14236 14277 14306 15590 
+ 14189 14216 14270 14271 14326 14347 
+ 14226 14232 14254 14269 14295 14303 
+ 14218 14239 14245 14282 14290 14310 
+ 14219 14237 14247 14280 14293 14311 
+ 14227 14240 14250 14278 14291 15592 
+ 14193 14223 14244 14285 14305 14321 
+ 14225 14242 14251 14279 14298 14309 
+ 14229 14243 14253 14281 14294 14307 
+ 14224 14241 14252 14283 14300 14315 
+ 14255 14297 14312 15591 
+ 14231 14232 14260 14275 14303 14316 
+ 14216 14248 14259 14304 14326 
+ 14158 14189 14259 14287 14347 14380 
+ 14228 14245 14249 14290 
+ 14233 14246 14256 14286 14296 14314 
+ 14230 14247 14257 14293 14301 14319 
+ 14231 14234 14269 14289 14316 14327 
+ 14238 14250 14291 14302 14317 15589 
+ 14235 14258 14306 14407 14415 15588 
+ 14240 14253 14263 14294 14318 15592 
+ 14242 14256 14265 14296 14309 15593 
+ 14237 14252 14262 14300 14311 14325 
+ 14243 14255 14266 14297 14307 14320 
+ 14239 14257 14261 14301 14310 14328 
+ 14241 14254 14267 14295 14315 14324 
+ 14150 14202 14287 14376 14388 
+ 14223 14248 14264 14304 14321 14338 
+ 14246 14273 14302 14314 15589 15594 
+ 14150 14158 14271 14284 14380 14388 14443 
+ 13993 14018 14132 14220 14415 14475 14694 
+ 14234 14244 14275 14305 14327 14341 
+ 14245 14261 14272 14310 
+ 14250 14263 14276 14317 14329 15592 
+ 13578 13730 13931 14483 14569 14858 
+ 14247 14262 14274 14311 14319 14333 
+ 14253 14266 14278 14307 14318 14331 
+ 14254 14260 14283 14303 14324 14335 
+ 14256 14273 14279 14314 14332 15593 
+ 14255 14268 14281 14312 14320 14334 
+ 14251 14265 14309 14330 14342 15590 
+ 14313 14322 14336 15591 
+ 14252 14267 14280 14315 14325 14340 
+ 14257 14274 14282 14319 14328 14345 
+ 14276 14286 14317 14339 15589 15594 
+ 14260 14269 14295 14316 14335 14349 
+ 14248 14270 14285 14326 14338 14361 
+ 14244 14264 14289 14321 14341 14359 
+ 14258 14277 14330 14407 15590 
+ 14266 14281 14294 14320 14331 14346 
+ 7933 8666 12141 13750 14913 15001 15008 
+ 14265 14279 14298 14342 14348 15593 
+ 14261 14282 14290 14328 
+ 14262 14280 14293 14325 14333 14354 
+ 14268 14297 14322 14334 14351 15591 
+ 14299 14323 14336 14353 
+ 14273 14286 14296 14332 14350 15594 
+ 14267 14283 14300 14324 14340 14357 
+ 14269 14275 14303 14327 14349 14362 
+ 14276 14291 14302 14329 14339 14355 
+ 14278 14294 14331 14343 14358 15592 
+ 14274 14293 14301 14333 14345 14364 
+ 14281 14297 14307 14334 14346 14363 
+ 14264 14285 14305 14338 14359 14375 
+ 14299 14312 14336 14351 14365 15591 
+ 14313 14337 14353 14368 
+ 14283 14295 14315 14335 14357 14370 
+ 14280 14300 14311 14340 14354 14372 
+ 14259 14270 14304 14347 14361 14390 
+ 14275 14289 14316 14341 14362 14377 
+ 14282 14301 14310 14345 
+ 14291 14317 14343 14355 14369 15592 
+ 14298 14306 14342 14407 15590 15596 
+ 14294 14307 14318 14346 14358 14373 
+ 14296 14314 14350 14356 14371 15593 
+ 14293 14311 14319 14354 14364 14384 
+ 14297 14312 14320 14351 14363 14378 
+ 14295 14303 14324 14349 14370 14385 
+ 14299 14313 14322 14353 14365 14381 
+ 14323 14352 14368 14386 
+ 14285 14304 14321 14361 14375 14398 
+ 14302 14317 14355 14366 14379 15594 
+ 14300 14315 14325 14357 14372 14389 
+ 14289 14305 14327 14359 14377 14393 
+ 14298 14309 14330 14348 14395 15596 
+ 14318 14329 14358 14369 14382 15592 
+ 13212 13588 14084 14483 14883 14923 
+ 14301 14319 14328 14364 
+ 14307 14320 14331 14363 14373 14391 
+ 14259 14271 14326 14380 14390 14419 
+ 14309 14342 14356 14387 14395 15593 
+ 14303 14316 14335 14362 14385 14400 
+ 14314 14332 14366 14371 14392 15594 
+ 14312 14322 14334 14365 14378 14394 
+ 14337 14367 14386 14401 
+ 14313 14323 14336 14368 14381 15595 
+ 14311 14325 14333 14372 14384 14402 
+ 14317 14329 14339 14369 14379 14396 
+ 14332 14348 14371 14387 15593 
+ 14315 14324 14340 14370 14389 14403 
+ 14318 14331 14343 14373 14382 14397 
+ 14305 14321 14341 14375 14393 14409 
+ 14079 14162 14220 14475 14498 14667 
+ 14304 14326 14338 14390 14398 14418 
+ 14316 14327 14349 14377 14400 14412 
+ 14320 14334 14346 14378 14391 14405 
+ 14319 14333 14345 14384 
+ 14322 14336 14351 14381 14394 14408 
+ 14339 14350 14379 14392 14404 15594 
+ 14352 14383 14401 14414 
+ 14323 14337 14353 14386 14413 15595 
+ 14329 14343 14355 14382 14396 14406 
+ 14324 14335 14357 14385 14403 14416 
+ 14332 14350 14356 14387 14392 14423 
+ 14325 14340 14354 14389 14402 14417 
+ 14331 14346 14358 14391 14397 14410 
+ 13654 14021 14023 14433 14697 14744 
+ 14321 14338 14359 14398 14409 14430 
+ 14103 14159 14202 14284 14388 14530 14562 14658 
+ 14327 14341 14362 14393 14412 14426 
+ 14334 14351 14363 14394 14405 14421 
+ 14339 14355 14366 14396 14404 14422 
+ 14271 14287 14347 14419 14443 14463 
+ 14336 14353 14365 14408 14424 15595 
+ 14343 14358 14369 14397 14406 14420 
+ 14367 14399 14414 14427 
+ 14333 14354 14364 14402 
+ 14335 14349 14370 14400 14416 14431 
+ 14337 14352 14368 14401 14413 15597 
+ 14348 14356 14371 14395 14423 14462 
+ 14284 14287 14376 14443 14562 
+ 14340 14357 14372 14403 14417 14432 
+ 14326 14347 14361 14418 14419 14439 
+ 14346 14363 14373 14405 14410 14428 
+ 14350 14366 14371 14404 14423 14429 
+ 14341 14359 14377 14409 14426 14444 
+ 14351 14365 14378 14408 14421 14436 
+ 14342 14348 14387 14462 15596 
+ 14355 14369 14379 14406 14422 14435 
+ 14358 14373 14382 14410 14420 14434 
+ 14338 14361 14375 14418 14430 14450 
+ 14383 14411 14427 14441 
+ 14349 14362 14385 14412 14431 14445 
+ 14352 14367 14386 14414 14442 15597 
+ 14354 14372 14384 14417 
+ 14357 14370 14389 14416 14432 14448 
+ 14366 14379 14392 14422 14429 14440 
+ 14363 14378 14391 14421 14428 14446 
+ 14369 14382 14396 14420 14435 14447 
+ 14277 14306 14330 14415 14536 14634 15596 
+ 14365 14381 14394 14424 14436 14451 
+ 14359 14375 14393 14430 14444 14460 
+ 14373 14391 14397 14428 14434 14449 
+ 14399 14425 14441 14455 
+ 14362 14377 14400 14426 14445 14457 
+ 14368 14386 14437 14453 15595 15597 
+ 14367 14383 14401 14427 14442 14456 
+ 14132 14143 14221 14277 14288 14407 14634 14694 15588 
+ 14370 14385 14403 14431 14448 14459 
+ 14372 14389 14402 14432 
+ 14361 14390 14398 14439 14450 14470 
+ 14347 14380 14390 14439 14463 14473 
+ 14382 14397 14406 14434 14447 14454 
+ 14378 14394 14405 14436 14446 14461 
+ 14379 14396 14404 14435 14440 14458 
+ 14371 14387 14392 14429 14462 14477 
+ 14381 14408 14437 14451 14465 15595 
+ 14411 14438 14455 14472 
+ 14377 14393 14412 14444 14457 14478 
+ 14383 14399 14414 14441 14456 14474 
+ 14391 14405 14410 14446 14449 14464 
+ 14392 14404 14423 14440 14469 14477 
+ 14375 14398 14409 14450 14460 14482 
+ 14385 14400 14416 14445 14459 14479 
+ 14389 14403 14417 14448 
+ 14021 14159 14374 14530 14697 14723 
+ 14397 14410 14420 14449 14454 14466 
+ 14396 14406 14422 14447 14458 14476 
+ 14394 14408 14421 14451 14461 14481 
+ 14413 14424 14453 14465 15595 15598 
+ 14425 14452 14472 14488 
+ 14390 14418 14419 14470 14473 14492 
+ 14404 14422 14429 14458 14469 14480 
+ 14399 14411 14427 14455 14474 14489 
+ 14401 14414 14456 14471 14487 15597 
+ 14287 14380 14388 14463 14533 14562 
+ 14393 14409 14426 14460 14478 14493 
+ 14400 14412 14431 14457 14479 14491 
+ 14405 14421 14428 14461 14464 14490 
+ 14406 14420 14435 14454 14476 14485 
+ 14403 14416 14432 14459 
+ 14410 14428 14434 14464 14466 14486 
+ 14398 14418 14430 14470 14482 14499 
+ 14408 14424 14436 14465 14481 14494 
+ 14438 14467 14488 14500 
+ 14413 14437 14471 14497 15597 15598 
+ 14420 14434 14447 14466 14485 15599 
+ 14411 14425 14441 14472 14489 14503 
+ 14414 14427 14442 14474 14487 14502 
+ 14412 14426 14445 14478 14491 14506 
+ 14422 14435 14440 14476 14480 14495 
+ 14416 14431 14448 14479 
+ 14409 14430 14444 14482 14493 14508 
+ 14421 14436 14446 14481 14490 14504 
+ 14387 14395 14423 14477 14536 14538 15596 
+ 14380 14419 14443 14473 14509 14533 
+ 14428 14446 14449 14486 14490 14505 
+ 14424 14437 14451 14494 14507 15598 
+ 14434 14449 14454 14486 14501 15599 
+ 14452 14484 14500 14512 
+ 13265 13426 14169 14738 14902 14965 
+ 14429 14440 14477 14480 14520 
+ 14418 14439 14450 14492 14499 14517 
+ 14442 14453 14487 14497 14511 15597 
+ 14425 14438 14455 14488 14503 14515 
+ 14419 14439 14463 14492 14509 14514 
+ 14427 14441 14456 14489 14502 14513 
+ 14220 14288 14360 14667 14694 
+ 14435 14447 14458 14485 14495 14531 
+ 14423 14429 14462 14469 14520 14538 
+ 14426 14444 14457 14493 14506 14519 
+ 14431 14445 14459 14491 
+ 14440 14458 14469 14495 14520 
+ 14436 14451 14461 14494 14504 14518 
+ 14430 14450 14460 14499 14508 14525 
+ 13588 13730 14292 14344 14858 14923 
+ 14467 14496 14512 14524 
+ 14447 14454 14476 14531 15599 
+ 14449 14464 14466 14501 14505 14516 
+ 14442 14456 14471 14502 14511 14527 
+ 14438 14452 14472 14500 14515 14529 
+ 14441 14455 14474 14503 14513 14528 
+ 14446 14461 14464 14504 14505 14526 
+ 14445 14457 14479 14506 
+ 14439 14470 14473 14514 14517 14534 
+ 14444 14460 14478 14508 14519 15600 
+ 14451 14465 14481 14507 14518 14532 
+ 14458 14476 14480 14520 14531 14613 
+ 14484 14510 14524 14539 
+ 14453 14471 14511 14521 14537 15598 
+ 14162 14198 14360 14599 14667 14842 
+ 14450 14470 14482 14517 14525 14545 
+ 14452 14467 14488 14512 14529 14543 
+ 14466 14486 14516 14523 15599 
+ 14456 14474 14487 14513 14527 14542 
+ 14455 14472 14489 14515 14528 14544 
+ 14461 14481 14490 14518 14526 14546 
+ 14464 14486 14490 14516 14526 14540 
+ 14457 14478 14491 14519 
+ 14465 14494 14521 14532 14547 15598 
+ 14460 14482 14493 14525 14551 15600 
+ 14463 14473 14514 14533 14541 
+ 14496 14522 14539 14552 
+ 14471 14487 14497 14527 14537 14550 
+ 14467 14484 14500 14524 14543 14554 
+ 14474 14489 14502 14528 14542 14553 
+ 14473 14492 14509 14534 14541 14556 
+ 14472 14488 14503 14529 14544 14555 
+ 14486 14501 14505 14523 14540 14549 
+ 14470 14492 14499 14534 14545 14561 
+ 14481 14494 14504 14532 14546 14557 
+ 14478 14493 14506 15600 
+ 14469 14477 14480 14495 14538 14613 
+ 14497 14507 14537 14547 14560 15598 
+ 14510 14535 14552 14563 
+ 14501 14516 14531 14549 14558 15599 
+ 14484 14496 14512 14539 14554 14566 
+ 14482 14499 14508 14545 14551 14568 
+ 14490 14504 14505 14540 14546 14565 
+ 14487 14502 14511 14542 14550 14564 
+ 14489 14503 14513 14544 14553 14567 
+ 14488 14500 14515 14543 14555 14570 
+ 14159 14376 14433 14658 14723 14799 
+ 14476 14485 14495 14523 14558 14613 15599 
+ 14494 14507 14518 14547 14557 14571 
+ 14443 14463 14509 14541 14562 14573 14659 
+ 14492 14514 14517 14556 14561 14577 
+ 14522 14548 14563 14576 
+ 14407 14462 14538 14634 14731 15596 
+ 14497 14511 14521 14550 14560 14574 
+ 14462 14477 14520 14536 14613 14731 
+ 14496 14510 14524 14552 14566 14579 
+ 14505 14516 14526 14549 14565 14575 
+ 14509 14514 14533 14556 14573 
+ 14502 14513 14527 14553 14564 14578 
+ 14500 14512 14529 14554 14570 14583 
+ 14503 14515 14528 14555 14567 14581 
+ 14499 14517 14525 14561 14568 14585 
+ 14504 14518 14526 14557 14565 14586 
+ 14507 14521 14532 14560 14571 14582 
+ 14535 14559 14576 14589 
+ 14516 14523 14540 14558 14575 14584 
+ 14511 14527 14537 14564 14574 14588 
+ 14508 14525 14568 15600 
+ 14510 14522 14539 14563 14579 14591 
+ 14513 14528 14542 14567 14578 14590 
+ 14512 14524 14543 14566 14583 14592 
+ 14515 14529 14544 14570 14581 14594 
+ 14514 14534 14541 14573 14577 14597 
+ 14518 14532 14546 14571 14586 14598 
+ 14523 14531 14549 14584 14613 14624 
+ 14548 14572 14589 14600 
+ 14521 14537 14547 14574 14582 14595 
+ 14517 14534 14545 14577 14585 14601 
+ 14376 14388 14443 14533 14658 14659 14715 
+ 14522 14535 14552 14576 14591 14606 
+ 14527 14542 14550 14578 14588 14603 
+ 14526 14540 14546 14575 14586 14608 
+ 14524 14539 14554 14579 14592 14607 
+ 14528 14544 14553 14581 14590 14604 
+ 14525 14545 14551 14585 
+ 13931 14161 14292 14674 14858 14922 
+ 14529 14543 14555 14583 14594 14609 
+ 14532 14547 14557 14582 14598 14605 
+ 14559 14580 14600 14611 
+ 14533 14541 14556 14597 14651 14659 
+ 14537 14550 14560 14588 14595 14612 
+ 14540 14549 14565 14584 14608 14621 
+ 14535 14548 14563 14589 14606 14617 
+ 14534 14556 14561 14597 14601 14620 
+ 14542 14553 14564 14590 14603 14616 
+ 14539 14552 14566 14591 14607 14618 
+ 14572 14587 14611 14622 
+ 14544 14555 14567 14594 14604 14619 
+ 14547 14560 14571 14595 14605 14615 
+ 14543 14554 14570 14592 14609 14623 
+ 14549 14558 14575 14621 14624 
+ 14545 14561 14568 14601 
+ 14546 14557 14565 14598 14608 14633 
+ 14580 14596 14622 14626 
+ 14550 14564 14574 14603 14612 14625 
+ 14548 14559 14576 14600 14617 14629 
+ 14553 14567 14578 14604 14616 14627 
+ 14552 14563 14579 14606 14618 14630 
+ 14554 14566 14583 14607 14623 14631 
+ 11933 13414 14090 14738 14951 14974 
+ 14555 14570 14581 14609 14619 14632 
+ 14560 14574 14582 14612 14615 14628 
+ 14587 14602 14626 14635 
+ 14556 14573 14577 14620 14651 
+ 14557 14571 14586 14605 14633 15602 
+ 14098 14198 14498 14674 14842 14921 
+ 14559 14572 14589 14611 14629 14637 
+ 14561 14577 14585 14620 
+ 14596 14610 14635 14640 
+ 14564 14578 14588 14616 14625 14636 
+ 14567 14581 14590 14619 14627 14639 
+ 14571 14582 14598 14615 14638 15602 
+ 14563 14576 14591 14617 14630 14643 
+ 14566 14579 14592 14618 14631 14641 
+ 14565 14575 14586 14621 14633 14647 
+ 14570 14583 14594 14623 14632 14644 
+ 14602 14614 14640 14646 
+ 14572 14580 14600 14622 14637 14648 
+ 14574 14588 14595 14625 14628 14645 
+ 14495 14520 14531 14538 14558 14624 14704 14731 
+ 14610 14620 14646 14650 
+ 14582 14595 14605 14628 14638 14642 
+ 14578 14590 14603 14627 14636 14649 
+ 14576 14589 14606 14629 14643 14654 
+ 14579 14591 14607 14630 14641 14653 
+ 14581 14594 14604 14632 14639 14652 
+ 14577 14597 14601 14614 14650 14651 14668 
+ 14575 14584 14608 14624 14647 14671 
+ 14580 14587 14611 14626 14648 14657 
+ 14583 14592 14609 14631 14644 14656 
+ 14558 14584 14613 14621 14671 14704 
+ 14588 14603 14612 14636 14645 14660 
+ 14587 14596 14622 14635 14657 14662 
+ 14590 14604 14616 14639 14649 14661 
+ 14595 14612 14615 14642 14645 14655 
+ 14589 14600 14617 14637 14654 14664 
+ 14591 14606 14618 14643 14653 14663 
+ 14592 14607 14623 14641 14656 14665 
+ 14594 14609 14619 14644 14652 14666 
+ 14586 14598 14608 14647 14679 15602 
+ 14407 14415 14536 14694 14731 14868 
+ 14596 14602 14626 14640 14662 14669 
+ 14603 14616 14625 14649 14660 14673 
+ 14600 14611 14629 14648 14664 14678 
+ 14605 14615 14642 14670 14686 15602 
+ 14604 14619 14627 14652 14661 14672 
+ 14602 14610 14635 14646 14669 14675 
+ 14607 14618 14631 14653 14665 14676 
+ 14615 14628 14638 14655 14670 
+ 14606 14617 14630 14654 14663 14680 
+ 14609 14623 14632 14656 14666 14681 
+ 14612 14625 14628 14655 14660 14677 
+ 14610 14614 14640 14650 14675 14682 
+ 14608 14621 14633 14671 14679 14696 
+ 14611 14622 14637 14657 14678 14685 
+ 14616 14627 14636 14661 14673 14683 
+ 14614 14620 14646 14668 14682 14689 
+ 14573 14597 14620 14659 14668 14713 
+ 14619 14632 14639 14666 14672 14687 
+ 14618 14630 14641 14663 14676 14688 
+ 14617 14629 14643 14664 14680 14691 
+ 14628 14642 14645 14670 14677 14684 
+ 14623 14631 14644 14665 14681 14690 
+ 14622 14626 14648 14662 14685 14693 
+ 14376 14530 14562 14715 14799 14809 
+ 14533 14562 14573 14651 14713 14715 14739 
+ 14625 14636 14645 14673 14677 14695 
+ 14627 14639 14649 14672 14683 14692 
+ 14626 14635 14657 14669 14693 14698 
+ 14630 14643 14653 14680 14688 14700 
+ 14629 14637 14654 14678 14691 14703 
+ 14631 14641 14656 14676 14690 14699 
+ 14632 14644 14652 14681 14687 14701 
+ 14360 14475 14498 14694 14842 14911 
+ 14620 14650 14651 14689 14713 14721 
+ 14635 14640 14662 14675 14698 14706 
+ 14638 14642 14655 14684 14686 14702 
+ 14621 14624 14647 14696 14704 14728 
+ 14639 14652 14661 14687 14692 14705 
+ 14636 14649 14660 14683 14695 14709 
+ 14098 14161 14569 14599 14921 14922 
+ 14640 14646 14669 14682 14706 14710 
+ 14641 14653 14665 14688 14699 14707 
+ 14645 14655 14660 14684 14695 14708 
+ 14637 14648 14664 14685 14703 14712 
+ 14633 14647 14686 14696 14732 15602 
+ 14643 14654 14663 14691 14700 14717 
+ 14644 14656 14666 14690 14701 14716 
+ 14646 14650 14675 14689 14710 14711 
+ 14649 14661 14673 14692 14709 14719 
+ 14655 14670 14677 14702 14708 14714 
+ 14648 14657 14678 14693 14712 14724 
+ 14638 14670 14679 14702 14732 14740 15602 
+ 14652 14666 14672 14701 14705 14720 
+ 14653 14663 14676 14700 14707 14722 
+ 14650 14668 14682 14711 14721 
+ 14656 14665 14681 14699 14716 14727 
+ 14654 14664 14680 14703 14717 14729 
+ 14661 14672 14683 14705 14719 14726 
+ 14657 14662 14685 14698 14724 14730 
+ 14288 14415 14475 14634 14667 14868 14911 
+ 14660 14673 14677 14708 14709 14736 
+ 14647 14671 14679 14728 14732 14753 
+ 14374 14433 14723 14744 14874 14890 
+ 14662 14669 14693 14706 14730 14737 
+ 14665 14676 14690 14707 14727 14733 
+ 14663 14680 14688 14717 14722 14735 
+ 14666 14681 14687 14716 14720 15603 
+ 14670 14684 14686 14714 14740 
+ 14664 14678 14691 14712 14729 14743 
+ 14613 14624 14671 14728 14731 14782 
+ 14672 14687 14692 14720 14726 14734 
+ 14669 14675 14698 14710 14737 14742 
+ 14676 14688 14699 14722 14733 14741 
+ 14677 14684 14695 14714 14736 15604 
+ 14673 14683 14695 14719 14736 14747 
+ 14675 14682 14706 14711 14742 14745 
+ 14682 14689 14710 14721 14745 14746 
+ 14678 14685 14703 14724 14743 14752 
+ 14651 14659 14668 14721 14739 14757 14763 
+ 14684 14702 14708 14740 14756 15604 
+ 14562 14658 14659 14739 14790 14809 
+ 14681 14690 14701 14727 14754 15603 
+ 14680 14691 14700 14729 14735 14755 
+ 5091 6408 13608 14884 15106 15121 
+ 14683 14692 14709 14726 14747 14749 
+ 14687 14701 14705 14734 14750 15603 
+ 14668 14689 14711 14713 14746 14757 
+ 14688 14700 14707 14735 14741 14748 
+ 14433 14530 14697 14799 14874 14906 
+ 14685 14693 14712 14730 14752 14759 
+ 14023 14169 14744 14886 14902 14933 
+ 14692 14705 14719 14734 14749 14751 
+ 14690 14699 14716 14733 14754 14760 
+ 14671 14696 14704 14753 14782 14788 
+ 14691 14703 14717 14743 14755 14765 
+ 14693 14698 14724 14737 14759 14764 
+ 14536 14538 14613 14634 14704 14782 14868 14870 
+ 14679 14686 14696 14740 14753 14776 14785 
+ 14699 14707 14727 14741 14760 14761 
+ 14705 14720 14726 14750 14751 14758 
+ 14700 14717 14722 14748 14755 15605 
+ 14695 14708 14709 14747 14775 14778 15604 
+ 14698 14706 14730 14742 14764 14766 
+ 13414 13426 14468 14593 14965 14974 15017 
+ 14659 14713 14715 14763 14787 14790 
+ 14686 14702 14714 14732 14756 14776 
+ 14707 14722 14733 14748 14761 14762 
+ 14706 14710 14737 14745 14766 14769 
+ 14703 14712 14729 14752 14765 14774 
+ 14023 14374 14697 14725 14886 14890 
+ 14710 14711 14742 14746 14769 14771 
+ 14711 14721 14745 14757 14771 14777 
+ 14709 14719 14736 14749 14778 14779 
+ 14722 14735 14741 14762 14770 15605 
+ 14719 14726 14747 14751 14772 14779 
+ 14720 14734 14758 14767 14773 15603 
+ 14726 14734 14749 14758 14772 
+ 14712 14724 14743 14759 14774 14783 
+ 14696 14728 14732 14785 14788 
+ 14716 14727 14760 14767 14786 15603 
+ 14717 14729 14735 14765 14784 15605 
+ 14714 14740 14775 14776 14805 15604 
+ 14713 14721 14746 14763 14777 14780 
+ 14734 14750 14751 14772 14773 14781 
+ 14724 14730 14752 14764 14783 14791 
+ 14727 14733 14754 14761 14786 14793 
+ 14733 14741 14760 14762 14789 14793 
+ 14741 14748 14761 14770 14789 
+ 14713 14739 14757 14780 14787 14794 
+ 14730 14737 14759 14766 14791 14795 
+ 14729 14743 14755 14774 14784 14804 
+ 14737 14742 14764 14769 14795 14798 
+ 14750 14754 14773 14786 14802 15603 
+ 13752 14084 14883 14964 14993 15601 
+ 14742 14745 14766 14771 14798 14800 
+ 14748 14762 14789 14792 14797 15605 
+ 14745 14746 14769 14777 14800 14801 
+ 14749 14751 14758 14779 14781 14808 
+ 14750 14758 14767 14781 14802 14803 
+ 14743 14752 14765 14783 14804 14810 
+ 14736 14756 14778 14805 14816 15604 
+ 14732 14740 14756 14785 14805 14814 
+ 14746 14757 14771 14780 14796 14801 
+ 14736 14747 14775 14779 14815 14816 
+ 14747 14749 14772 14778 14808 14815 
+ 14757 14763 14777 14794 14796 14807 
+ 14758 14772 14773 14803 14808 
+ 14704 14728 14731 14788 14850 14870 
+ 14752 14759 14774 14791 14810 14813 
+ 14755 14765 14792 14804 14819 15605 
+ 14732 14753 14776 14788 14814 14830 
+ 14754 14760 14767 14793 14802 14825 
+ 14739 14763 14790 14794 14811 14820 
+ 14728 14753 14782 14785 14830 14850 
+ 14761 14762 14770 14793 14797 14812 
+ 14715 14739 14787 14809 14820 14849 
+ 14759 14764 14783 14795 14813 14822 
+ 14770 14784 14797 14817 14819 15605 
+ 14760 14761 14786 14789 14812 14825 14829 
+ 14763 14780 14787 14807 14811 14821 
+ 14764 14766 14791 14798 14822 14827 
+ 14777 14780 14801 14807 14818 
+ 14770 14789 14792 14812 14817 
+ 14766 14769 14795 14800 14827 14828 
+ 14530 14658 14723 14809 14895 14906 
+ 14769 14771 14798 14801 14824 14828 
+ 14771 14777 14796 14800 14818 14824 
+ 14767 14773 14786 14803 14825 14826 
+ 14773 14781 14802 14808 14826 14832 
+ 14765 14774 14784 14810 14819 14834 
+ 14756 14775 14776 14814 14816 14837 
+ 6549 8429 11051 14963 15040 15073 
+ 14780 14794 14796 14818 14821 14833 
+ 14772 14779 14781 14803 14815 14832 14845 
+ 14658 14715 14790 14799 14849 14895 
+ 14774 14783 14804 14813 14834 14839 
+ 14787 14794 14820 14821 14831 
+ 14789 14793 14797 14817 14829 14835 
+ 14783 14791 14810 14822 14838 14839 
+ 14776 14785 14805 14830 14837 14851 
+ 14778 14779 14808 14816 14845 14852 
+ 14775 14778 14805 14815 14837 14852 
+ 14792 14797 14812 14819 14835 14836 
+ 14796 14801 14807 14824 14833 14840 
+ 14784 14792 14804 14817 14834 14836 14847 
+ 14787 14790 14811 14831 14849 14855 
+ 14794 14807 14811 14831 14833 14846 
+ 14791 14795 14813 14827 14838 14841 
+ 12039 13965 14938 14968 15016 15579 
+ 14800 14801 14818 14828 14840 14843 
+ 14786 14793 14802 14826 14829 14848 14853 
+ 14802 14803 14825 14832 14848 
+ 14795 14798 14822 14828 14841 14844 
+ 14798 14800 14824 14827 14843 14844 
+ 14793 14812 14825 14835 14853 14854 
+ 14785 14788 14814 14850 14851 14867 
+ 14811 14820 14821 14846 14855 
+ 14803 14808 14826 14845 14848 14861 
+ 14807 14818 14821 14840 14846 14859 
+ 14804 14810 14819 14839 14847 14864 
+ 14812 14817 14829 14836 14854 14857 
+ 14817 14819 14835 14847 14857 14862 
+ 14805 14814 14816 14851 14852 14876 
+ 14813 14822 14839 14841 14865 14869 
+ 14810 14813 14834 14838 14864 14869 
+ 14818 14824 14833 14843 14859 14866 
+ 14822 14827 14838 14844 14860 14865 
+ 14498 14599 14667 14911 14921 14985 
+ 14824 14828 14840 14844 14863 14866 
+ 14827 14828 14841 14843 14860 14863 
+ 14808 14815 14832 14852 14861 14877 
+ 14821 14831 14833 14855 14859 14873 
+ 14819 14834 14836 14862 14864 14871 
+ 14825 14826 14832 14853 14861 14875 
+ 14790 14809 14820 14855 14895 14904 
+ 14782 14788 14830 14867 14870 14896 
+ 14814 14830 14837 14867 14876 14882 
+ 14815 14816 14837 14845 14876 14877 14892 
+ 14825 14829 14848 14854 14875 14878 
+ 14829 14835 14853 14857 14872 14878 
+ 14820 14831 14846 14849 14873 14904 
+ 1438 6142 7847 15069 15094 15125 
+ 14835 14836 14854 14862 14872 15606 
+ 14292 14483 14569 14922 14923 14991 
+ 14833 14840 14846 14866 14873 14885 
+ 14841 14844 14863 14865 14879 
+ 14832 14845 14848 14875 14877 14894 
+ 14836 14847 14857 14871 14880 15606 
+ 14843 14844 14860 14866 14879 14881 
+ 14834 14839 14847 14869 14871 14889 
+ 14838 14841 14860 14869 14879 14888 
+ 14840 14843 14859 14863 14881 14885 
+ 14830 14850 14851 14882 14896 
+ 14634 14694 14731 14870 14911 14944 14973 
+ 14838 14839 14864 14865 14888 14889 14901 
+ 14731 14782 14850 14868 14896 14944 
+ 14847 14862 14864 14880 14889 14893 
+ 14854 14857 14878 14891 14898 15606 
+ 14846 14855 14859 14885 14904 14907 
+ 14697 14723 14890 14906 14943 14956 
+ 14848 14853 14861 14878 14894 14900 
+ 14837 14851 14852 14882 14892 14903 
+ 14845 14852 14861 14892 14894 14905 
+ 14853 14854 14872 14875 14898 14900 
+ 14860 14863 14865 14881 14888 14897 
+ 14862 14871 14891 14893 15606 
+ 14863 14866 14879 14885 14897 14899 
+ 14851 14867 14876 14896 14903 14912 
+ 14084 14344 14768 14923 14993 15018 
+ 6408 7295 14209 14718 15086 15106 
+ 14859 14866 14873 14881 14899 14907 
+ 14725 14744 14890 14933 14939 
+ 13535 14090 14914 14951 15006 15014 
+ 14865 14869 14879 14897 14901 14918 
+ 14864 14869 14871 14893 14901 14910 
+ 14697 14744 14874 14886 14939 14943 
+ 14872 14880 14893 14898 14908 15606 
+ 14852 14876 14877 14903 14905 14917 
+ 14871 14880 14889 14891 14908 14910 
+ 14861 14875 14877 14900 14905 14915 
+ 14799 14809 14849 14904 14906 14935 14950 
+ 14850 14867 14870 14882 14912 14944 
+ 14879 14881 14888 14899 14916 14918 
+ 14872 14878 14891 14900 14908 14920 
+ 14881 14885 14897 14907 14916 14919 
+ 14875 14878 14894 14898 14915 14920 14925 
+ 14869 14888 14889 14910 14918 14926 
+ 14169 14468 14725 14933 14965 14975 
+ 14876 14882 14892 14912 14917 14928 
+ 14849 14855 14873 14895 14907 14929 14935 
+ 14877 14892 14894 14915 14917 14924 
+ 14723 14799 14874 14895 14950 14956 
+ 14873 14885 14899 14904 14919 14929 
+ 14891 14893 14898 14910 14920 14927 
+ 13856 14069 14914 14979 14994 15028 
+ 14889 14893 14901 14908 14926 14927 
+ 14667 14694 14842 14868 14973 14985 
+ 14882 14896 14903 14928 14944 14948 
+ 12141 13965 14308 14968 15008 15031 
+ 13535 13856 14887 14909 14994 15006 
+ 14894 14900 14905 14924 14925 14930 
+ 14897 14899 14918 14919 14931 
+ 14892 14903 14905 14924 14928 14932 
+ 14888 14897 14901 14916 14926 14931 14941 
+ 14899 14907 14916 14929 14931 14936 
+ 14898 14900 14908 14925 14927 14934 
+ 14599 14674 14842 14922 14985 15002 
+ 14569 14674 14858 14921 14991 15002 
+ 14344 14483 14858 14883 14991 15018 
+ 14905 14915 14917 14930 14932 14937 
+ 14900 14915 14920 14930 14934 14940 
+ 14901 14910 14918 14927 14941 14942 
+ 14908 14910 14920 14926 14934 14942 
+ 14903 14912 14917 14932 14946 14948 
+ 14904 14907 14919 14935 14936 14952 
+ 14915 14924 14925 14937 14940 14947 
+ 14916 14918 14919 14936 14941 14953 
+ 14917 14924 14928 14937 14946 14949 
+ 14725 14886 14902 14939 14975 14978 
+ 14920 14925 14927 14940 14942 14957 
+ 14895 14904 14929 14950 14952 14961 
+ 14919 14929 14931 14952 14953 14958 
+ 14924 14930 14932 14947 14949 14954 
+ 14823 14964 15016 15034 15579 15601 
+ 14886 14890 14933 14943 14978 14989 
+ 14925 14930 14934 14947 14957 14959 
+ 14918 14926 14931 14942 14953 14962 
+ 14926 14927 14934 14941 14957 14962 14967 
+ 14874 14890 14939 14956 14986 14989 
+ 14868 14870 14896 14912 14948 14973 14981 
+ 7003 7847 11051 15040 15069 15093 
+ 14928 14932 14948 14949 14971 
+ 14930 14937 14940 14954 14959 14960 
+ 14912 14928 14944 14946 14971 14981 
+ 14932 14937 14946 14954 14971 
+ 14895 14906 14935 14956 14961 14976 14983 
+ 14090 14593 14887 14974 15014 15025 
+ 14929 14935 14936 14958 14961 14966 
+ 14931 14936 14941 14958 14962 14969 
+ 14937 14947 14949 14960 14971 
+ 8232 11299 13750 15001 15024 15067 15085 
+ 14874 14906 14943 14950 14983 14986 
+ 14934 14940 14942 14959 14967 14972 
+ 14936 14952 14953 14966 14969 
+ 14940 14947 14957 14960 14970 14972 
+ 14947 14954 14959 14970 14971 
+ 14935 14950 14952 14966 14976 14980 
+ 14941 14942 14953 14967 14969 14977 
+ 8429 14069 14806 14979 15051 15073 
+ 14768 14938 14993 15034 15036 15601 
+ 14468 14738 14902 14975 15017 15022 
+ 14952 14958 14961 14969 14980 14987 
+ 14942 14957 14962 14972 14977 14988 
+ 13965 14823 14913 15016 15031 15046 
+ 14953 14958 14962 14966 14977 14987 
+ 14959 14960 14971 14972 14982 14984 
+ 14946 14948 14949 14954 14960 14970 14981 14982 14990 
+ 14957 14959 14967 14970 14984 14988 
+ 14868 14911 14944 14981 14985 15021 15035 
+ 14593 14738 14951 15017 15025 15041 
+ 14902 14933 14965 14978 15020 15022 
+ 14950 14961 14980 14983 14995 15000 
+ 14962 14967 14969 14987 14988 14997 14998 
+ 14933 14939 14975 14989 15015 15020 
+ 14069 14909 14963 15028 15051 
+ 14961 14966 14976 14987 14995 14999 
+ 14944 14948 14971 14973 14990 15021 
+ 14970 14971 14984 14990 14992 
+ 14950 14956 14976 14986 15000 15003 
+ 14970 14972 14982 14988 14992 14996 
+ 14842 14911 14921 14973 15002 15035 15048 
+ 14943 14956 14983 14989 15003 15004 
+ 14966 14969 14977 14980 14997 14999 
+ 14967 14972 14977 14984 14996 14998 
+ 14939 14943 14978 14986 15004 15015 
+ 14971 14981 14982 14992 15009 15021 
+ 14858 14922 14923 15002 15018 15047 
+ 14982 14984 14990 14996 15005 15009 
+ 14768 14883 14964 15018 15036 15044 
+ 14909 14914 15006 15028 15049 
+ 14976 14980 14999 15000 15012 15013 
+ 14984 14988 14992 14998 15005 15007 
+ 14977 14987 14998 14999 15010 15011 
+ 14977 14988 14996 14997 15007 15010 
+ 14980 14987 14995 14997 15011 15013 
+ 14976 14983 14995 15003 15012 15019 
+ 13750 14308 14955 15008 15059 15067 
+ 14921 14922 14985 14991 15047 15048 
+ 14983 14986 15000 15004 15019 15023 
+ 14986 14989 15003 15015 15023 15032 
+ 14992 14996 15007 15009 15033 
+ 14887 14914 14994 15014 15049 15052 
+ 14996 14998 15005 15010 15033 
+ 14308 14913 15001 15031 15059 15060 
+ 14990 14992 15005 15021 15033 15055 
+ 14997 14998 15007 15011 15030 15033 
+ 14997 14999 15010 15013 15026 15030 
+ 14995 15000 15013 15019 15027 15029 
+ 14995 14999 15011 15012 15026 15027 
+ 14887 14951 15006 15025 15052 15056 
+ 14978 14989 15004 15020 15032 15037 
+ 14823 14938 14968 15034 15046 15061 
+ 14738 14965 14974 15022 15041 15050 15062 
+ 14883 14923 14991 14993 15044 15047 15063 
+ 15000 15003 15012 15023 15029 15038 
+ 14975 14978 15015 15022 15037 15042 
+ 14973 14981 14990 15009 15035 15055 
+ 14965 14975 15017 15020 15042 15050 
+ 15003 15004 15019 15032 15038 
+ 11299 13260 14955 15057 15085 15110 
+ 14951 14974 15014 15041 15056 
+ 15011 15013 15027 15030 15039 15043 
+ 15012 15013 15026 15029 15039 
+ 14909 14979 14994 15049 15051 15075 
+ 15012 15019 15027 15038 15039 
+ 15010 15011 15026 15033 15043 
+ 14913 14968 15008 15046 15060 15068 
+ 15004 15015 15023 15037 15038 15045 
+ 15005 15007 15009 15010 15030 15043 15055 
+ 14938 14964 15016 15036 15061 15066 
+ 14973 14985 15021 15048 15055 15081 
+ 14964 14993 15034 15044 15066 15076 
+ 15015 15020 15032 15042 15045 15054 
+ 15019 15023 15029 15032 15039 15045 15058 
+ 15026 15027 15029 15038 15043 15058 
+ 11051 14806 14945 15073 15093 15129 
+ 14974 15017 15025 15056 15062 15072 
+ 15020 15022 15037 15050 15054 15064 
+ 15026 15030 15033 15039 15055 15058 15077 
+ 14993 15018 15036 15063 15076 
+ 15032 15037 15038 15054 15058 15065 
+ 14968 15016 15031 15061 15068 15078 
+ 14991 15002 15018 15048 15063 15087 
+ 14985 15002 15035 15047 15081 15087 
+ 14994 15006 15028 15052 15075 15089 
+ 15017 15022 15042 15062 15064 15074 
+ 14963 14979 15028 15073 15075 15102 
+ 15006 15014 15049 15056 15084 15089 
+ 133 150 5176 15123 15220 15242 
+ 15037 15042 15045 15064 15065 15070 
+ 15009 15021 15033 15035 15043 15077 15081 
+ 15014 15025 15041 15052 15072 15084 
+ 13260 14209 15024 15086 15110 15141 
+ 15038 15039 15043 15045 15065 15077 15079 
+ 15001 15008 15060 15067 15083 15092 
+ 15008 15031 15059 15068 15083 15088 
+ 15016 15034 15046 15066 15078 15090 
+ 15017 15041 15050 15072 15074 15091 
+ 15018 15044 15047 15076 15087 15105 
+ 15042 15050 15054 15070 15074 15082 
+ 15045 15054 15058 15070 15079 15080 
+ 15034 15036 15061 15076 15090 15103 
+ 14955 15001 15059 15085 15092 15109 
+ 15031 15046 15060 15078 15088 15095 
+ 7847 14856 14945 15093 15125 15135 
+ 15054 15064 15065 15080 15082 
+ 223 5176 5408 15133 15218 15220 
+ 15041 15056 15062 15084 15091 15101 
+ 14806 14963 15040 15051 15102 15129 15146 
+ 15050 15062 15064 15082 15091 15100 
+ 15028 15049 15051 15089 15102 15117 
+ 15036 15044 15063 15066 15103 15105 
+ 15043 15055 15058 15079 15081 15097 15104 
+ 15046 15061 15068 15090 15095 15108 
+ 15058 15065 15077 15080 15096 15097 
+ 15065 15070 15079 15082 15096 15099 
+ 15035 15048 15055 15077 15087 15104 15116 
+ 15064 15070 15074 15080 15099 15100 
+ 15059 15060 15088 15092 15107 
+ 15052 15056 15072 15089 15101 15112 
+ 14955 15024 15067 15109 15110 15131 
+ 14209 14884 15057 15106 15141 15161 
+ 15047 15048 15063 15081 15105 15116 15128 
+ 15060 15068 15083 15095 15107 15111 
+ 15049 15052 15075 15084 15112 15117 
+ 15061 15066 15078 15103 15108 15124 
+ 15062 15072 15074 15100 15101 15113 
+ 15059 15067 15083 15107 15109 15119 
+ 14945 15040 15069 15129 15135 15162 
+ 6142 12330 14856 15125 15170 15186 
+ 15068 15078 15088 15108 15111 15114 
+ 15079 15080 15097 15099 15115 
+ 15077 15079 15096 15104 15115 15118 
+ 211 270 12330 15165 15170 15223 
+ 15080 15082 15096 15100 15115 15120 
+ 15074 15082 15091 15099 15113 15120 
+ 15072 15084 15091 15112 15113 15132 
+ 15051 15073 15075 15117 15146 15147 
+ 15066 15076 15090 15105 15124 15136 
+ 15077 15081 15097 15116 15118 15126 
+ 15063 15076 15087 15103 15128 15136 
+ 14718 14884 15086 15121 15161 15179 
+ 15083 15088 15092 15111 15119 15122 
+ 15078 15090 15095 15114 15124 15130 
+ 15067 15085 15092 15119 15131 15137 
+ 15024 15057 15085 15131 15141 15156 
+ 15088 15095 15107 15114 15122 15127 
+ 15084 15089 15101 15117 15132 15142 
+ 15091 15100 15101 15120 15132 15143 
+ 15095 15108 15111 15127 15130 
+ 15096 15097 15099 15118 15120 15134 15139 
+ 15081 15087 15104 15126 15128 15140 
+ 15075 15089 15102 15112 15142 15147 
+ 15097 15104 15115 15126 15134 
+ 15092 15107 15109 15122 15137 15138 
+ 15099 15100 15113 15115 15139 15143 
+ 13608 14718 15106 15144 15179 15199 
+ 15107 15111 15119 15127 15138 15145 
+ 150 176 15053 15242 
+ 15090 15103 15108 15130 15136 15154 
+ 14856 15069 15094 15135 15185 15186 
+ 15104 15116 15118 15134 15140 15148 
+ 15111 15114 15122 15130 15145 15150 
+ 15087 15105 15116 15136 15140 15153 
+ 15040 15073 15093 15146 15162 15182 
+ 15108 15114 15124 15127 15150 15154 
+ 15085 15109 15110 15137 15152 15156 
+ 15101 15112 15113 15142 15143 15155 
+ 5408 7666 15071 15144 15212 15218 
+ 15115 15118 15126 15139 15148 15151 
+ 15069 15093 15125 15162 15185 
+ 15103 15105 15124 15128 15153 15154 15167 
+ 15109 15119 15131 15138 15149 15152 
+ 15119 15122 15137 15145 15149 
+ 15115 15120 15134 15143 15151 15159 
+ 15116 15126 15128 15148 15153 15157 
+ 15057 15086 15110 15156 15161 15173 
+ 15112 15117 15132 15147 15155 15164 
+ 15113 15120 15132 15139 15155 15159 
+ 7666 13608 15121 15133 15199 15212 
+ 15122 15127 15138 15149 15150 15158 
+ 15073 15102 15129 15147 15175 15182 
+ 15102 15117 15142 15146 15164 15175 
+ 15126 15134 15140 15151 15157 15160 
+ 15137 15138 15145 15152 15158 15163 
+ 15127 15130 15145 15154 15158 15168 
+ 15134 15139 15148 15159 15160 15166 
+ 15131 15137 15149 15156 15163 15172 
+ 15128 15136 15140 15157 15167 15171 
+ 15124 15130 15136 15150 15167 15168 15183 
+ 15132 15142 15143 15159 15164 15176 
+ 15110 15131 15141 15152 15172 15173 15181 
+ 15140 15148 15153 15160 15169 15171 
+ 15145 15149 15150 15163 15168 15174 
+ 15139 15143 15151 15155 15166 15176 15178 
+ 15148 15151 15157 15166 15169 
+ 15086 15106 15141 15173 15179 15192 
+ 15093 15129 15135 15182 15185 15207 
+ 15149 15152 15158 15172 15174 15177 
+ 15142 15147 15155 15175 15176 15191 
+ 168 211 15098 15200 15223 15249 
+ 15151 15159 15160 15169 15178 15180 
+ 15136 15153 15154 15171 15183 15188 
+ 15150 15154 15158 15174 15183 15190 
+ 15157 15160 15166 15171 15180 15184 
+ 12330 15094 15098 15186 15223 15229 
+ 15153 15157 15167 15169 15184 15188 
+ 15152 15156 15163 15177 15181 15187 
+ 15141 15156 15161 15181 15192 15193 
+ 15158 15163 15168 15177 15189 15190 
+ 15146 15147 15164 15182 15191 15202 
+ 15155 15159 15164 15178 15191 15194 
+ 15163 15172 15174 15187 15189 
+ 15159 15166 15176 15180 15194 15196 
+ 15106 15121 15161 15192 15199 15208 
+ 15166 15169 15178 15184 15196 
+ 15156 15172 15173 15187 15193 15195 
+ 15129 15146 15162 15175 15202 15207 
+ 15154 15167 15168 15188 15190 15198 
+ 15169 15171 15180 15188 15196 15203 
+ 15125 15135 15162 15186 15207 15222 
+ 15094 15125 15170 15185 15222 15229 
+ 15172 15177 15181 15189 15195 15197 
+ 15167 15171 15183 15184 15198 15203 
+ 15174 15177 15187 15190 15197 15201 
+ 15168 15174 15183 15189 15198 15201 
+ 15164 15175 15176 15194 15202 15209 
+ 15161 15173 15179 15193 15205 15208 
+ 15173 15181 15192 15195 15204 15205 
+ 15176 15178 15191 15196 15209 15210 
+ 15181 15187 15193 15197 15204 15206 
+ 15178 15180 15184 15194 15203 15210 
+ 15187 15189 15195 15201 15206 15211 
+ 15183 15188 15190 15201 15203 15214 15216 
+ 15121 15144 15179 15208 15212 15230 15237 
+ 120 168 15165 15249 15268 
+ 15189 15190 15197 15198 15211 15214 
+ 15175 15182 15191 15207 15209 15225 
+ 15184 15188 15196 15198 15210 15216 15221 
+ 15193 15195 15205 15206 15213 
+ 15192 15193 15204 15208 15213 15217 
+ 15195 15197 15204 15211 15213 15215 
+ 15162 15182 15185 15202 15222 15225 15238 
+ 15179 15192 15199 15205 15217 15230 
+ 15191 15194 15202 15210 15225 15227 
+ 15194 15196 15203 15209 15221 15227 
+ 15197 15201 15206 15214 15215 15219 
+ 15133 15144 15199 15218 15237 15248 
+ 15204 15205 15206 15215 15217 15224 
+ 15198 15201 15211 15216 15219 15226 
+ 15206 15211 15213 15219 15224 15228 
+ 15198 15203 15214 15221 15226 15231 
+ 15205 15208 15213 15224 15230 15233 
+ 15071 15133 15212 15220 15248 15260 
+ 15211 15214 15215 15226 15228 15232 
+ 5176 15053 15071 15218 15242 15260 15270 
+ 15203 15210 15216 15227 15231 15235 
+ 15185 15186 15207 15229 15238 15246 
+ 15098 15165 15170 15229 15249 15252 
+ 15213 15215 15217 15228 15233 15234 
+ 15202 15207 15209 15227 15238 15240 
+ 15214 15216 15219 15231 15232 15236 
+ 15209 15210 15221 15225 15235 15240 
+ 15215 15219 15224 15232 15234 
+ 15170 15186 15222 15223 15246 15252 
+ 15199 15208 15217 15233 15237 15244 
+ 15216 15221 15226 15235 15236 15239 
+ 15219 15226 15228 15234 15236 15241 
+ 15217 15224 15230 15234 15243 15244 
+ 15224 15228 15232 15233 15241 15243 
+ 15221 15227 15231 15239 15240 15247 
+ 15226 15231 15232 15239 15241 15245 
+ 15199 15212 15230 15244 15248 15256 
+ 15207 15222 15225 15240 15246 15255 15259 
+ 15231 15235 15236 15245 15247 15250 
+ 15225 15227 15235 15238 15247 15255 
+ 15232 15234 15236 15243 15245 15251 
+ 15053 15123 15220 15270 
+ 15233 15234 15241 15244 15251 15254 
+ 15230 15233 15237 15243 15254 15256 
+ 15236 15239 15241 15250 15251 15253 
+ 15222 15229 15238 15252 15259 15265 
+ 15235 15239 15240 15250 15255 15257 
+ 15212 15218 15237 15256 15260 15267 
+ 15165 15200 15223 15252 15268 15269 
+ 15239 15245 15247 15253 15257 
+ 15241 15243 15245 15253 15254 15258 
+ 15223 15229 15246 15249 15265 15269 
+ 15245 15250 15251 15257 15258 15261 
+ 15243 15244 15251 15256 15258 15262 
+ 15238 15240 15247 15257 15259 15263 
+ 15237 15244 15248 15254 15262 15267 
+ 15247 15250 15253 15255 15261 15263 15266 
+ 15251 15253 15254 15261 15262 15264 
+ 15238 15246 15255 15263 15265 15271 
+ 15218 15220 15248 15267 15270 15275 
+ 15253 15257 15258 15264 15266 
+ 15254 15256 15258 15264 15267 15273 
+ 15255 15257 15259 15266 15271 15272 
+ 15258 15261 15262 15266 15273 15274 
+ 15246 15252 15259 15269 15271 15276 
+ 15257 15261 15263 15264 15272 15274 
+ 15248 15256 15260 15262 15273 15275 15277 
+ 15200 15249 15269 15281 
+ 15249 15252 15265 15268 15276 15281 
+ 15220 15242 15260 15275 
+ 15259 15263 15265 15272 15276 15280 
+ 15263 15266 15271 15274 15278 15280 
+ 15262 15264 15267 15274 15277 15279 
+ 15264 15266 15272 15273 15278 15279 
+ 15260 15267 15270 15277 
+ 15265 15269 15271 15280 15281 15285 
+ 15267 15273 15275 15279 15282 
+ 15272 15274 15279 15280 15283 15284 
+ 15273 15274 15277 15278 15282 15283 
+ 15271 15272 15276 15278 15284 15285 
+ 15268 15269 15276 15285 
+ 15277 15279 15283 
+ 15278 15279 15282 15284 
+ 15278 15280 15283 15285 
+ 15276 15280 15281 15284 
+ 528 535 555 562 580 582 
+ 637 640 660 664 682 686 
+ 661 662 683 687 703 706 
+ 668 675 694 695 711 
+ 692 701 736 744 
+ 817 828 854 863 901 902 926 
+ 864 867 948 994 1072 1170 
+ 1035 1042 1064 1076 1101 1106 
+ 1270 1276 1301 1318 1340 1350 
+ 1277 1286 1305 1321 1335 1348 
+ 1394 1401 1431 1453 1477 1488 
+ 797 809 1443 1882 1984 2261 
+ 1441 1445 1483 1487 1520 1523 
+ 527 813 1264 2019 2447 2587 
+ 1500 1505 1541 1546 1579 1591 
+ 1585 1586 1619 1621 1653 1655 
+ 1791 1823 1864 1889 1933 1980 
+ 1934 1941 1969 1992 
+ 1953 1959 1976 1990 2001 2010 
+ 1971 1994 2017 2023 
+ 1975 1985 1988 2005 2020 2028 
+ 2119 2126 2127 2151 2156 2179 
+ 2204 2228 2247 2278 2287 2300 
+ 2244 2284 2373 2449 2596 2606 
+ 2392 2417 2436 2503 2515 2546 
+ 2458 2471 2473 2497 2512 15312 
+ 2471 2483 2511 2512 2524 15311 
+ 2526 2554 2561 2621 2623 2653 
+ 2559 2568 2588 2597 2617 2619 
+ 2583 2621 2625 2688 2703 2727 
+ 2675 2694 2698 2728 2731 2744 
+ 2722 2723 2730 2751 
+ 2710 2717 2747 2748 2793 2794 
+ 2720 2731 2737 2763 2770 2780 
+ 2718 2719 2745 2748 2786 2791 
+ 2763 2780 2781 2800 2810 2814 
+ 2738 2778 2801 2850 2855 2893 2896 
+ 2764 2768 2847 2863 2957 3005 3030 
+ 2879 2887 2904 2921 2927 
+ 2829 2847 2882 2957 2971 3015 
+ 2828 2857 2868 2952 3002 3044 
+ 2910 2913 2942 2946 2964 2966 
+ 2912 2949 2956 2987 2994 
+ 2854 2901 2916 3083 3125 3158 
+ 2951 2974 2980 3004 3006 3025 
+ 2957 3015 3030 3073 3112 3146 
+ 3041 3050 3058 3075 3096 3101 
+ 3047 3048 3071 3074 3103 3105 
+ 3005 3030 3112 3127 3174 15337 
+ 3105 3106 3131 3133 3164 3166 
+ 3113 3116 3154 3156 3177 3178 
+ 3112 3174 3176 3207 15334 
+ 3157 3160 3182 3186 3221 3222 
+ 3223 3233 3264 3288 3331 3341 
+ 3192 3204 3288 3313 3354 3365 
+ 3257 3283 3293 3342 3361 3369 
+ 3289 3295 3318 3328 3349 3352 
+ 3210 3251 3303 3335 3398 3458 
+ 3280 3286 3337 3376 
+ 3268 3304 3320 3424 3438 15348 
+ 3361 3382 3403 3411 3431 3435 3443 
+ 3397 3410 3469 3486 3537 3543 
+ 3424 3438 3541 3556 15345 
+ 3423 3436 3477 3517 3555 3569 
+ 2312 3001 3581 3994 4134 
+ 3492 3503 3512 3530 3547 3552 
+ 3576 3578 3607 3608 3635 3637 
+ 3586 3587 3605 3610 3631 3634 
+ 3604 3617 3671 3686 3729 3732 
+ 2261 3001 3305 3994 4172 4323 
+ 3729 3732 3781 3831 15357 15358 
+ 3732 3738 3789 3848 15356 15358 
+ 3831 3848 3874 15356 15357 15360 
+ 3845 3850 3858 3873 3887 3890 
+ 3848 3874 3910 3915 3927 15358 
+ 3908 3910 3932 3957 3959 3970 
+ 3930 3935 3951 3981 4004 4007 
+ 3977 3983 3999 4012 4021 4030 
+ 2447 2587 3675 4169 4463 4762 
+ 4077 4080 4095 4102 4122 4126 
+ 4075 4076 4119 4120 4164 4168 
+ 4155 4160 4173 4187 4195 4208 
+ 4263 4269 4346 4358 4446 4458 
+ 4364 4366 4385 4392 4408 4445 4448 
+ 4499 4506 4529 4536 4556 4564 
+ 4550 4558 4580 4590 4609 4613 
+ 4708 4720 4726 4748 4758 4767 
+ 4775 4785 4797 4813 4832 4837 
+ 2062 4176 4383 5180 5221 5528 
+ 4794 4835 4884 4954 4960 4993 
+ 4890 4899 4915 4929 4948 4955 
+ 4933 4978 4992 5038 5066 5078 
+ 5024 5037 5045 5074 5081 5098 
+ 5090 5097 5118 5132 5150 5159 
+ 5218 5228 5301 5398 5402 5493 
+ 5368 5386 5399 5435 5443 5461 
+ 6342 6352 6380 6397 
+ 6481 6493 6513 6539 6557 6574 
+ 6728 6741 6768 6785 6804 6812 
+ 6862 6883 6927 6946 6994 7005 
+ 6750 6765 6825 6987 7006 7346 7379 
+ 7801 7802 7829 7837 7864 7865 
+ 7910 7918 7928 7956 7962 7978 
+ 7971 7974 7998 8002 8031 8032 
+ 7979 7991 7992 8024 8039 8053 
+ 8149 8159 8181 8205 8228 8239 
+ 8193 8200 8273 8276 8371 8391 
+ 8095 8119 8291 8344 8450 8516 
+ 8356 8368 8375 8408 8411 8428 
+ 8371 8391 8436 8499 8532 8574 
+ 8455 8504 8511 8540 8579 8611 8625 
+ 8450 8460 8542 8649 8658 8730 
+ 8551 8579 8583 8628 8664 15400 
+ 8602 8606 8639 8647 8684 8685 
+ 8579 8625 8664 8700 8706 15398 
+ 8597 8612 8653 8665 8704 8707 
+ 8696 8724 8757 8761 
+ 8784 8787 8822 8824 8857 8863 
+ 8823 8836 8874 8896 
+ 8860 8873 8901 8907 8923 8932 
+ 8874 8885 8896 8921 8937 8950 
+ 8890 8894 8929 8940 8970 8978 
+ 8889 8904 8946 8985 9026 9063 
+ 8938 8959 8960 8991 9013 15412 
+ 8910 8925 8957 8997 9023 15414 
+ 8958 8971 8973 9002 9006 9020 
+ 8960 8981 9013 9022 9058 9059 15409 
+ 8989 9000 9038 9061 9077 9093 
+ 8997 9023 9081 9099 9128 15410 
+ 9045 9046 9072 9076 9105 9108 
+ 9051 9060 9071 9091 9104 9115 
+ 9018 9047 9061 9113 9116 9149 
+ 8943 8962 9050 9236 9287 15421 
+ 9052 9069 9082 9126 9141 9164 
+ 9083 9087 9110 9120 9131 9150 
+ 8919 8962 9146 9287 9352 15418 
+ 8177 8194 8306 8519 9305 10106 10842 10865 
+ 9026 9063 9081 9156 9182 9213 
+ 8975 9011 9134 9137 9280 9289 
+ 9048 9073 9096 9160 9184 9214 
+ 9122 9138 9152 9176 9196 9204 
+ 9107 9108 9151 9153 9193 9194 9205 
+ 9180 9197 9207 9230 9245 9251 
+ 9186 9199 9210 9233 9249 9259 
+ 9193 9205 9211 9241 9248 9258 
+ 9196 9204 9216 9240 9253 15433 
+ 9203 9210 9230 9249 9263 9276 
+ 9240 9253 9292 9306 15431 15434 
+ 9240 9248 9283 9306 9318 15433 
+ 9182 9213 9269 9552 15439 15457 
+ 9256 9277 9295 9349 9354 9378 
+ 8867 8969 9074 9325 9761 9935 15475 
+ 9283 9293 9318 9322 9355 9360 
+ 9208 9213 9298 9510 9552 15435 
+ 9303 9315 9331 9372 9384 15442 
+ 9264 9309 9333 9370 9404 9415 
+ 9315 9323 9361 9384 9391 15440 
+ 9311 9322 9344 9360 9402 9409 
+ 9307 9338 9362 9400 9435 15449 
+ 9329 9351 9357 9397 9405 15453 
+ 9269 9273 9411 9534 15457 
+ 9361 9376 9391 9417 9434 9443 
+ 9257 9298 9340 9462 9510 9581 
+ 9362 9419 9435 9461 9474 15444 
+ 9319 9369 9387 9465 9568 15462 
+ 9028 9117 9274 9550 9885 10046 
+ 9333 9347 9404 9421 9494 9502 
+ 9397 9405 9438 9449 9467 15445 
+ 9381 9394 9406 9444 15458 15460 
+ 9236 9287 9366 9533 9612 15478 
+ 9393 9406 9429 9475 9491 15458 
+ 9269 9534 9552 15435 15446 15476 
+ 9406 9491 9508 15454 15456 15460 
+ 9419 9431 9461 9476 9497 9505 
+ 9444 9508 15454 15458 15464 15465 
+ 9443 9455 9481 9506 9526 9544 
+ 9387 9462 9568 9597 15450 15472 
+ 9460 9477 9498 9528 9542 9564 
+ 9444 9463 9545 9599 15460 15465 
+ 9508 9570 9599 15460 15464 15470 
+ 9529 9560 9566 9598 9613 9629 
+ 9535 9556 9576 9607 9621 9647 
+ 9526 9544 9567 9607 9619 9651 
+ 9554 9579 9588 9625 9631 9642 
+ 9570 9599 9603 9654 15465 15477 
+ 9580 9596 9609 9635 
+ 9568 9597 9644 9686 9700 15462 
+ 9411 9478 9534 9676 9727 15483 
+ 9352 9468 9533 9744 9802 15480 
+ 9074 9274 9885 9935 10139 15437 
+ 9534 9552 9727 9755 9816 15457 
+ 9599 9654 9659 9716 9734 15470 
+ 9533 9612 9744 9771 9839 15455 
+ 9704 9717 9736 9772 
+ 9468 9680 9802 9912 9944 15474 
+ 9729 9738 9752 9778 9790 9803 
+ 9701 9716 9743 9789 9791 9823 
+ 9676 9727 9829 9879 9932 15473 
+ 9773 9783 9853 9859 9874 
+ 9823 9846 9871 9887 9896 
+ 9876 9883 9907 9939 
+ 9784 9815 9949 10004 10025 10100 
+ 9888 9905 9926 9955 9976 9985 
+ 9906 9908 9936 9946 9969 9973 
+ 9904 9911 9937 9952 9972 9978 
+ 9854 9892 9956 9975 10021 10027 
+ 9940 9946 9973 9982 10007 10014 
+ 9921 9943 9966 10029 10051 10085 
+ 10016 10024 10054 10076 
+ 10058 10075 10080 10107 10112 10121 
+ 10127 10132 10148 10165 10179 10183 
+ 10100 10152 10167 10217 10263 10274 
+ 10203 10204 10230 10233 10251 10253 
+ 10248 10260 10289 10307 
+ 10255 10256 10281 10285 10310 10313 
+ 10264 10296 10297 10332 10367 10369 15502 
+ 10296 10320 10364 10369 10385 15501 
+ 10323 10352 10382 10394 10434 10444 
+ 10370 10387 10388 10421 10423 10432 
+ 10280 10334 10415 10576 10596 10685 
+ 10530 10546 10547 10574 10580 10591 
+ 10645 10654 10659 10683 10691 10697 
+ 10694 10705 10711 10732 10754 10755 
+ 10719 10722 10736 10746 10759 10766 
+ 10770 10772 10811 10847 10873 
+ 10738 10788 10818 10883 10943 15514 
+ 10851 10860 10868 10888 10898 10910 
+ 10852 10870 10920 10931 10967 10969 
+ 10818 10908 10943 11015 11029 15511 
+ 11151 11162 11174 11197 11217 11229 
+ 11155 11156 11192 11231 
+ 11255 11264 11303 11349 11385 11427 
+ 11383 11414 11416 11457 11470 11522 
+ 11364 11375 11508 11518 11648 11763 
+ 11524 11533 11562 11580 11601 11613 
+ 11560 11596 11605 11637 11673 11676 
+ 11569 11614 11616 11681 11722 11803 
+ 11589 11604 11650 11659 11714 11731 
+ 11609 11632 11642 11698 11704 11741 
+ 11626 11652 11662 11715 11721 11787 
+ 11703 11772 11783 11817 
+ 11755 11757 11800 11822 11824 
+ 11743 11752 11792 11845 11851 11882 
+ 11790 11827 11851 11870 11916 11926 
+ 11799 11820 11846 11932 
+ 11934 11977 11980 12017 12055 12073 
+ 11963 11981 12005 12050 12069 12093 
+ 12022 12062 12082 12123 12135 
+ 12044 12096 12102 12213 12222 12276 
+ 12099 12125 12129 12184 12192 12227 
+ 12161 12179 12182 12247 12251 12289 
+ 12229 12259 12283 12358 
+ 12271 12290 12336 12342 12378 12392 
+ 12183 12253 12274 12441 12450 12561 
+ 12307 12342 12356 12407 12422 12444 
+ 12226 12284 12325 12397 12532 12605 
+ 12140 12231 12389 12476 12628 12736 
+ 12152 12295 12317 12549 12913 13041 
+ 8166 10539 10767 13752 15579 15601 
+ 12406 12446 12467 12538 12568 12589 
+ 12432 12479 12480 12578 12584 12631 
+ 12490 12503 12535 12564 12587 12602 
+ 12541 12611 12653 15550 
+ 12552 12557 12604 12615 12639 
+ 12541 12574 12653 12655 12690 15548 
+ 12566 12575 12607 12627 12664 12674 
+ 12592 12593 12626 12635 12679 12688 
+ 12573 12610 12612 12689 12740 15556 
+ 12599 12608 12662 12669 12698 
+ 12589 12613 12660 12685 12738 12743 
+ 12612 12655 12734 12740 12783 15553 
+ 12646 12685 12689 12738 12769 12801 
+ 12766 12774 12809 12835 12865 12872 
+ 12801 12815 12859 12896 12955 12972 
+ 12834 12843 12875 12893 12924 12932 
+ 12830 12854 12870 12914 12964 15563 
+ 12867 12886 12898 12936 12939 
+ 12870 12911 12964 12981 13004 15561 
+ 12932 12945 12956 12977 13023 13079 13097 
+ 12963 12981 13002 13034 13050 13066 
+ 13070 13084 13087 13116 13117 13140 
+ 13019 13039 13058 13083 13151 13156 
+ 13044 13091 13092 13173 13177 13205 
+ 13153 13159 13227 13259 13310 13342 
+ 13250 13252 13273 13280 13303 13307 
+ 13262 13287 13298 13349 13393 13408 
+ 13763 13786 13787 13825 13846 15573 
+ 13786 13802 13844 13846 13869 15572 
+ 13924 13967 13969 13987 
+ 13906 13919 13929 13964 13972 13986 
+ 13959 13976 13977 14017 
+ 13981 13983 14031 14054 14075 14085 
+ 13990 14000 14022 14047 14063 14082 
+ 10767 12039 14823 14938 15544 15601 
+ 14100 14118 14122 14166 14171 14188 
+ 14117 14138 14144 14181 14207 15585 
+ 14121 14139 14149 14178 14190 14205 
+ 14155 14185 14197 14212 
+ 14129 14149 14157 14190 14200 14217 
+ 14144 14171 14207 14214 14236 15581 
+ 14166 14184 14188 14221 14235 15588 
+ 14186 14206 14213 14249 
+ 14221 14235 14277 14415 15586 
+ 14222 14238 14246 14276 14286 14302 
+ 14236 14251 14258 14298 14306 14330 
+ 14268 14299 14312 14322 
+ 14263 14278 14291 14318 14329 14343 
+ 14279 14296 14309 14332 14348 14356 
+ 14286 14302 14314 14339 14350 14366 
+ 14353 14368 14381 14413 14424 14437 
+ 14330 14342 14395 14407 14462 14536 
+ 14386 14401 14413 14442 14453 14471 
+ 14437 14453 14465 14497 14507 14521 
+ 14454 14466 14485 14501 14523 14531 
+ 14493 14508 14519 14551 
+ 13752 14768 14938 14964 15544 15579 
+ 14598 14605 14633 14638 14679 14686 
+ 14701 14716 14720 14750 14754 14767 
+ 14708 14714 14736 14756 14775 
+ 14735 14748 14755 14770 14784 14792 
+ 14857 14862 14872 14880 14891 
Index: /inundation/pymetis/metis-4.0/Graphs/metis.mesh
===================================================================
--- /inundation/pymetis/metis-4.0/Graphs/metis.mesh	(revision 2051)
+++ /inundation/pymetis/metis-4.0/Graphs/metis.mesh	(revision 2051)
@@ -0,0 +1,7435 @@
+7434 1
+ 3708 57 2094
+ 25 308 2956
+ 2411 1300 2468
+ 1246 3012 3401
+ 3765 920 2854
+ 54 613 3240
+ 89 2428 4
+ 544 545 2198
+ 3721 8 1879
+ 826 2760 3239
+ 3047 1564 3916
+ 2086 1466 3119
+ 87 88 3004
+ 1425 1879 3139
+ 957 2775 2199
+ 2033 1418 3718
+ 2243 280 28
+ 962 1638 2942
+ 271 272 2256
+ 1008 1645 3104
+ 3269 246 247
+ 2066 20 256
+ 272 17 1771
+ 103 104 1755
+ 2040 1430 3732
+ 2223 3064 36
+ 1255 2946 2947
+ 254 3509 253
+ 581 582 2059
+ 455 456 3837
+ 274 2070 273
+ 32 3729 3082
+ 33 377 2776
+ 424 425 2879
+ 31 2274 325
+ 3648 467 468
+ 3938 943 2413
+ 1339 2291 3560
+ 2893 430 431
+ 611 612 3197
+ 1309 3652 2716
+ 1088 2230 2833
+ 449 450 2441
+ 3899 40 427
+ 453 2930 452
+ 1054 1775 2407
+ 427 428 2508
+ 575 576 3777
+ 129 130 2086
+ 477 3949 2340
+ 3327 1520 3817
+ 1626 444 445
+ 404 35 2623
+ 554 2927 553
+ 2232 1094 2835
+ 309 1751 308
+ 619 1721 3461
+ 280 3005 279
+ 3 57 3708
+ 138 139 1761
+ 1178 2094 2723
+ 1836 59 60
+ 1179 1836 2742
+ 61 2027 1
+ 62 63 2339
+ 63 64 3051
+ 64 65 3585
+ 65 66 3429
+ 66 67 2422
+ 67 68 1738
+ 68 69 2545
+ 69 70 2017
+ 164 165 2791
+ 70 71 3516
+ 71 72 2343
+ 72 73 3893
+ 630 631 2101
+ 631 55 3058
+ 2812 73 74
+ 1749 2812 3965
+ 768 2090 3699
+ 1753 3031 3968
+ 2491 77 78
+ 1649 78 79
+ 2153 79 80
+ 1467 3838 3143
+ 2418 81 82
+ 1265 2418 3165
+ 2471 748 3194
+ 2 85 2483
+ 85 86 1788
+ 86 87 2312
+ 5 3593 94
+ 100 6 2429
+ 3493 89 90
+ 2424 90 91
+ 3567 91 92
+ 2131 92 93
+ 1723 2131 3745
+ 96 2132 3746
+ 2226 1015 2425
+ 97 2132 96
+ 2110 1332 3597
+ 99 2425 98
+ 2953 104 7
+ 6 101 4023
+ 101 102 2994
+ 102 103 2415
+ 3212 1415 4019
+ 3282 7 105
+ 4019 105 106
+ 3212 106 107
+ 116 117 3734
+ 117 118 2802
+ 118 119 3847
+ 119 120 3210
+ 120 121 2652
+ 121 122 3851
+ 122 123 3217
+ 123 124 2655
+ 2041 1420 3722
+ 128 2041 127
+ 13 193 3738
+ 57 58 2094
+ 130 131 3024
+ 131 132 2541
+ 132 9 3572
+ 1761 1095 2500
+ 1971 9 133
+ 134 3903 133
+ 135 3546 134
+ 136 2448 135
+ 825 2588 3295
+ 1381 1761 3524
+ 2065 140 141
+ 3757 141 142
+ 3761 1095 2693
+ 1122 1969 3826
+ 1321 1720 3227
+ 144 2134 143
+ 3579 889 1677
+ 146 2319 145
+ 147 2790 146
+ 148 2767 147
+ 3705 148 149
+ 12 150 149
+ 149 150 3705
+ 150 151 3705
+ 151 152 2767
+ 152 153 2758
+ 153 154 2279
+ 11 156 2499
+ 2270 157 158
+ 2768 159 160
+ 3706 160 161
+ 10 162 161
+ 2726 158 159
+ 163 2768 3706
+ 1745 1205 2923
+ 164 1695 2768
+ 2270 158 2726
+ 2318 165 166
+ 166 167 1678
+ 167 168 2135
+ 168 169 2524
+ 169 170 3750
+ 170 171 2053
+ 1574 735 3761
+ 172 173 3406
+ 173 174 2372
+ 174 175 1856
+ 1624 1112 2570
+ 2460 178 3
+ 179 2284 16
+ 180 181 2844
+ 181 182 2397
+ 182 183 3001
+ 183 184 1843
+ 184 185 2583
+ 185 186 1918
+ 186 187 3290
+ 187 188 1920
+ 188 189 2554
+ 189 190 1700
+ 190 191 2546
+ 191 192 1928
+ 192 13 3302
+ 126 2033 125
+ 3722 127 2041
+ 196 3717 2798
+ 3718 125 2033
+ 2033 1420 2798
+ 2655 124 3718
+ 1423 2652 3851
+ 3211 198 199
+ 2652 121 3851
+ 2035 115 116
+ 2034 1421 3848
+ 1419 2037 3723
+ 202 3216 201
+ 2037 113 114
+ 3847 2802 118
+ 1416 2038 3724
+ 204 3733 2034
+ 2038 111 112
+ 3733 205 2797
+ 1426 2803 3720
+ 1419 2035 2797
+ 2036 1424 2803
+ 3736 207 2799
+ 1424 2392 3716
+ 1416 2037 2799
+ 2392 107 108
+ 210 3731 2804
+ 3731 211 2036
+ 2803 3716 109
+ 212 2036 211
+ 214 1579 2654
+ 215 3397 3215
+ 3397 216 14
+ 243 21 2883
+ 2955 230 15
+ 14 217 2954
+ 217 218 1756
+ 218 219 2527
+ 219 220 1997
+ 220 221 3521
+ 221 222 1956
+ 222 223 2555
+ 223 224 1713
+ 224 225 2537
+ 225 226 1944
+ 226 227 3292
+ 227 228 1982
+ 228 229 2549
+ 1203 1925 2846
+ 1428 2946 3726
+ 2039 1428 2801
+ 234 18 3725
+ 235 2940 18
+ 2645 236 237
+ 1898 237 238
+ 957 1807 2940
+ 809 2107 2769
+ 2374 251 19
+ 1433 4032 3895
+ 241 3157 240
+ 242 2262 241
+ 243 3425 242
+ 21 244 2883
+ 3270 244 245
+ 1810 245 246
+ 22 2882 247
+ 22 248 2882
+ 2374 1202 2638
+ 2168 1202 2919
+ 254 255 2669
+ 1852 19 252
+ 1212 1852 2944
+ 255 20 1747
+ 2881 259 23
+ 24 2884 263
+ 256 257 2786
+ 257 258 1696
+ 258 259 3192
+ 2171 1215 3096
+ 3268 260 261
+ 1811 261 262
+ 3271 262 263
+ 1239 2171 3130
+ 265 3267 264
+ 2568 267 268
+ 3267 265 1782
+ 1618 1107 3606
+ 269 3446 268
+ 17 3378 1771
+ 2256 1553 3981
+ 17 273 2942
+ 3243 274 275
+ 3815 275 276
+ 2817 276 16
+ 351 352 2603
+ 29 277 2000
+ 277 278 3266
+ 278 279 1989
+ 298 299 3671
+ 28 281 2807
+ 281 282 3306
+ 285 3502 284
+ 1688 1285 3341
+ 2341 1131 1799
+ 285 286 1800
+ 286 287 3000
+ 287 288 2099
+ 288 289 2518
+ 289 290 3362
+ 290 291 3078
+ 291 292 2122
+ 292 293 2730
+ 2109 758 2455
+ 26 2231 303
+ 295 296 2286
+ 296 297 3124
+ 297 298 2538
+ 3359 299 27
+ 1645 297 2538
+ 715 1597 2970
+ 2095 301 302
+ 233 234 2040
+ 305 3728 2800
+ 304 2800 3727
+ 2801 3726 231
+ 3037 377 378
+ 2528 309 310
+ 1995 310 311
+ 1977 761 2874
+ 1957 312 313
+ 2556 313 314
+ 1714 314 315
+ 2536 315 316
+ 1945 316 317
+ 1985 747 2823
+ 1981 318 319
+ 2997 319 320
+ 2210 320 321
+ 3101 321 32
+ 3719 33 3081
+ 1417 3082 3729
+ 2653 322 323
+ 3214 323 324
+ 31 326 3424
+ 1950 1022 2126
+ 328 1950 327
+ 329 30 2597
+ 328 329 3127
+ 1190 1950 3127
+ 2126 327 1950
+ 2847 331 332
+ 3500 332 333
+ 334 2924 333
+ 335 3974 334
+ 336 2413 335
+ 358 2281 357
+ 29 1815 2085
+ 356 2941 355
+ 355 4016 354
+ 1408 2408 3488
+ 2383 343 344
+ 3310 344 345
+ 2476 345 346
+ 4009 1187 2901
+ 2395 347 348
+ 3504 348 29
+ 1878 352 36
+ 35 349 3166
+ 349 350 2419
+ 350 351 3428
+ 1438 3813 3404
+ 342 2408 341
+ 3512 710 2759
+ 2224 1439 3405
+ 338 2409 337
+ 2409 1407 3487
+ 713 3831 1728
+ 1864 1072 2507
+ 1864 1323 3393
+ 360 1864 359
+ 1774 1072 2482
+ 1322 2030 3392
+ 1794 364 365
+ 2030 1322 3748
+ 1298 3415 3551
+ 2100 367 368
+ 1298 3551 3029
+ 325 3849 324
+ 1813 784 2610
+ 386 2676 385
+ 2697 1544 3629
+ 417 418 3438
+ 2635 371 3629
+ 381 382 3582
+ 3629 372 2697
+ 34 381 1743
+ 3213 374 375
+ 1422 2697 3850
+ 2653 3729 322
+ 1216 2879 3854
+ 3037 378 379
+ 3936 379 380
+ 3203 380 34
+ 383 384 1869
+ 3276 386 387
+ 3178 416 3554
+ 3825 39 3178
+ 437 39 3825
+ 394 395 3077
+ 395 396 3304
+ 396 397 2296
+ 1512 45 2895
+ 399 3945 2469
+ 3555 465 2684
+ 459 1792 458
+ 586 587 3376
+ 403 2289 402
+ 2005 1126 2577
+ 408 2005 407
+ 42 510 3877
+ 510 511 2400
+ 408 409 2608
+ 2029 413 414
+ 3602 984 2345
+ 1330 3511 2905
+ 2578 411 412
+ 414 415 3476
+ 415 37 3363
+ 383 2288 382
+ 1209 3841 3154
+ 3554 416 417
+ 3841 1011 1869
+ 1119 3915 2880
+ 1002 2857 2177
+ 421 3414 420
+ 424 2879 1854
+ 423 1791 422
+ 515 516 3436
+ 1916 405 406
+ 3804 426 38
+ 1819 2754 3952
+ 1798 1184 2774
+ 394 2154 393
+ 2754 391 392
+ 1511 1161 2269
+ 429 2651 428
+ 3059 431 432
+ 2102 390 391
+ 483 3479 45
+ 2282 433 434
+ 3622 925 2014
+ 436 437 3756
+ 2112 1271 3580
+ 2071 1324 2102
+ 2784 388 389
+ 1324 2866 2784
+ 481 482 2928
+ 2929 50 438
+ 440 44 3308
+ 441 3314 44
+ 1183 1932 3314
+ 2315 1036 2251
+ 443 3336 442
+ 2236 445 446
+ 487 3085 37
+ 488 1976 487
+ 448 3866 2520
+ 448 2520 447
+ 2209 694 1737
+ 451 1775 450
+ 2067 612 41
+ 3944 553 2927
+ 2930 51 452
+ 454 40 3309
+ 1171 3229 3686
+ 46 455 2200
+ 2623 1498 3583
+ 402 1868 401
+ 1193 1848 3946
+ 461 3413 460
+ 1010 1570 2630
+ 2853 1001 2176
+ 3092 1118 2794
+ 3945 399 400
+ 1010 3842 1868
+ 3555 464 465
+ 2469 398 399
+ 1208 3842 3439
+ 43 466 1816
+ 466 467 2581
+ 2093 740 3278
+ 2058 1595 3556
+ 472 2058 471
+ 3613 1278 2761
+ 720 1882 1698
+ 47 3432 593
+ 473 474 1941
+ 474 475 3480
+ 1171 2612 3693
+ 478 479 3283
+ 477 2340 48
+ 1895 479 49
+ 439 2929 438
+ 3261 49 480
+ 482 50 2928
+ 429 430 3375
+ 484 485 3953
+ 486 2885 485
+ 1538 925 2893
+ 443 444 2813
+ 488 489 3896
+ 1235 1874 3233
+ 48 3628 490
+ 413 2745 412
+ 1469 1905 3683
+ 2347 493 494
+ 2810 494 495
+ 3596 495 496
+ 1708 496 497
+ 1116 1708 2474
+ 1904 498 499
+ 1079 1904 2683
+ 1757 500 501
+ 1073 2206 2433
+ 2355 502 503
+ 1875 503 504
+ 2606 504 505
+ 3749 505 506
+ 3075 506 507
+ 2910 507 508
+ 2721 852 2896
+ 3388 509 42
+ 1752 229 230
+ 3749 506 3075
+ 1563 512 513
+ 669 2335 3800
+ 3203 34 2783
+ 3264 513 514
+ 3558 514 515
+ 517 518 2371
+ 518 519 3260
+ 2573 1259 2969
+ 2571 660 3951
+ 3641 519 520
+ 3291 318 1981
+ 1487 521 522
+ 3111 522 523
+ 3522 312 1957
+ 1647 524 525
+ 2549 229 1752
+ 2764 526 527
+ 1528 527 528
+ 3292 227 1982
+ 2937 529 530
+ 3144 530 531
+ 3521 221 1956
+ 976 1622 2254
+ 1606 533 534
+ 2050 1093 3408
+ 2521 535 536
+ 3035 536 537
+ 845 3013 3221
+ 2814 538 539
+ 2962 539 540
+ 3492 100 2429
+ 933 1492 2110
+ 1332 2110 3799
+ 545 546 3998
+ 546 547 2057
+ 547 548 1517
+ 548 54 2522
+ 549 1798 52
+ 2590 551 53
+ 827 2958 3538
+ 552 2590 53
+ 2927 554 51
+ 179 180 2844
+ 56 555 2699
+ 555 556 1475
+ 556 557 2987
+ 557 558 2864
+ 561 2544 560
+ 562 3711 3473
+ 1726 2714 3843
+ 3302 13 2167
+ 3711 562 563
+ 2086 1490 3868
+ 3290 187 1920
+ 2261 565 566
+ 3020 566 567
+ 769 1838 3857
+ 2364 568 569
+ 3891 569 570
+ 1258 1970 3299
+ 3107 888 1556
+ 1593 572 573
+ 3147 573 574
+ 576 577 3777
+ 577 578 2647
+ 3266 278 1989
+ 1129 2060 2519
+ 3566 578 579
+ 2625 579 580
+ 582 583 2501
+ 583 584 3122
+ 2191 1132 2897
+ 2794 885 3771
+ 2146 3744 3122
+ 586 3694 585
+ 3545 588 589
+ 3317 589 590
+ 923 3515 1793
+ 698 1339 2525
+ 3280 590 591
+ 3280 591 592
+ 3786 1440 3246
+ 594 3646 47
+ 595 3209 594
+ 606 2459 2920
+ 597 3806 596
+ 598 3333 597
+ 599 2124 598
+ 2145 1312 3418
+ 601 2145 600
+ 602 2295 601
+ 3182 1741 3668
+ 604 2239 603
+ 605 2909 604
+ 606 2920 605
+ 1565 1082 2459
+ 1443 3932 3358
+ 609 3067 608
+ 610 2580 609
+ 611 2019 610
+ 84 2127 83
+ 3311 922 2827
+ 1497 975 2354
+ 3435 1497 3940
+ 616 3435 615
+ 1687 1089 2922
+ 618 2741 617
+ 619 3461 618
+ 620 2984 619
+ 621 2984 620
+ 622 2671 621
+ 1967 1148 3645
+ 624 1847 623
+ 625 2856 624
+ 626 3536 625
+ 627 3475 626
+ 628 3933 627
+ 1659 1164 2782
+ 630 1659 629
+ 634 1555 633
+ 635 3320 634
+ 636 2462 635
+ 637 3073 636
+ 2092 1697 3796
+ 639 2092 638
+ 2097 1337 3300
+ 3697 2097 3134
+ 1060 2089 2303
+ 643 2624 642
+ 644 2899 643
+ 645 3992 644
+ 646 3992 645
+ 1764 705 1506
+ 648 3667 647
+ 649 2915 648
+ 2480 1447 3623
+ 56 2480 650
+ 2779 41 491
+ 492 1905 491
+ 2051 55 632
+ 1555 1061 2516
+ 3751 501 502
+ 1562 1032 2449
+ 733 1640 3153
+ 623 3892 622
+ 655 1683 3185
+ 642 3134 641
+ 1082 1565 2694
+ 2239 1371 3411
+ 3492 99 100
+ 544 2633 543
+ 294 295 3357
+ 1731 293 294
+ 3225 587 588
+ 458 1853 457
+ 3265 516 517
+ 424 1854 423
+ 1431 2648 2980
+ 596 2729 595
+ 2458 508 509
+ 937 1494 1998
+ 3335 947 2728
+ 2349 1361 3337
+ 2988 652 2513
+ 2728 1356 3335
+ 3525 558 559
+ 560 3958 559
+ 3272 1099 3519
+ 1845 666 2438
+ 3505 1630 3862
+ 656 2991 1935
+ 990 2454 2182
+ 2681 916 3657
+ 2862 511 512
+ 912 3109 2335
+ 1721 1115 2735
+ 617 3034 616
+ 3396 28 1970
+ 575 2644 574
+ 1664 570 571
+ 3095 1241 2996
+ 1631 567 568
+ 1314 673 2640
+ 3060 564 565
+ 1315 2129 3658
+ 2603 352 1878
+ 581 3329 580
+ 3004 88 2302
+ 3387 870 3859
+ 1492 540 541
+ 793 3526 3223
+ 2225 1750 3898
+ 593 3743 592
+ 177 178 3032
+ 176 177 4013
+ 3967 171 172
+ 2308 1930 3158
+ 3035 537 538
+ 1372 681 2660
+ 3303 534 535
+ 3927 682 2552
+ 1622 531 532
+ 3835 683 2689
+ 1387 655 2103
+ 1693 1130 3667
+ 1672 1154 3123
+ 2979 727 1533
+ 2968 528 529
+ 1368 686 2673
+ 3038 525 526
+ 3930 687 2547
+ 2386 523 524
+ 3834 688 2664
+ 3045 520 521
+ 3853 689 2649
+ 900 3228 2062
+ 1515 690 1906
+ 2283 1273 3763
+ 2565 691 1769
+ 2842 1475 3467
+ 3 3708 2891
+ 2072 1131 2359
+ 2718 693 2047
+ 2426 1252 2795
+ 807 2529 2702
+ 2453 776 3496
+ 1865 970 2361
+ 2215 1305 3541
+ 2598 911 2116
+ 2907 1404 3691
+ 2907 697 1975
+ 1849 3150 3591
+ 659 3946 3449
+ 2808 652 1687
+ 1658 1104 2865
+ 1120 1785 3801
+ 3273 1617 3798
+ 973 3838 2136
+ 4034 2542 3463
+ 1156 3355 3047
+ 613 2354 3240
+ 2001 865 1903
+ 3372 1889 3805
+ 1065 2695 2404
+ 1364 2497 2563
+ 1590 1068 2195
+ 1282 1780 2589
+ 2156 684 2753
+ 3316 706 1705
+ 1618 1128 3275
+ 1993 707 3275
+ 1808 235 236
+ 1949 1111 2007
+ 3281 709 2321
+ 353 354 3472
+ 361 362 1774
+ 971 1774 2030
+ 282 283 3698
+ 2939 283 284
+ 366 367 1724
+ 365 366 2390
+ 2012 356 357
+ 1323 2263 3830
+ 1384 996 2162
+ 714 3665 3052
+ 658 2727 1795
+ 303 3354 302
+ 951 3535 2235
+ 2399 791 3074
+ 1891 663 2493
+ 1017 3669 2505
+ 1998 1494 3244
+ 2733 937 1871
+ 3236 1442 3769
+ 632 2516 2051
+ 1371 2015 3103
+ 978 3163 2081
+ 1431 2980 3675
+ 754 2249 1496
+ 1611 1153 2932
+ 1099 3272 2711
+ 1277 2290 3453
+ 4028 723 1919
+ 3588 657 1329
+ 98 3568 97
+ 1035 1711 2485
+ 3048 1437 3605
+ 726 1833 2681
+ 795 2433 2206
+ 1302 2376 3114
+ 3519 1099 2348
+ 3197 612 2067
+ 727 1666 3482
+ 1987 1349 3417
+ 1987 729 2215
+ 2103 655 3137
+ 1387 2103 2706
+ 1879 8 3855
+ 564 1577 2990
+ 2448 136 1844
+ 1293 2672 3642
+ 1934 1354 3904
+ 1722 2744 3382
+ 1197 2044 3989
+ 1683 1148 3185
+ 1881 732 2672
+ 137 1844 136
+ 1510 1008 2297
+ 3046 1105 2194
+ 1900 2854 3656
+ 3533 679 2466
+ 1576 3219 3486
+ 1059 1835 2204
+ 2463 951 3448
+ 1389 2515 3614
+ 2179 1237 3390
+ 1152 1595 2093
+ 1143 2135 2524
+ 1745 741 2627
+ 2543 142 143
+ 1965 742 2276
+ 3095 902 1866
+ 672 2996 2678
+ 1958 1024 3542
+ 673 3852 2714
+ 2574 1071 2387
+ 992 1750 2225
+ 2073 1042 3638
+ 682 4005 2378
+ 2074 1044 3640
+ 687 4004 2379
+ 748 3910 2259
+ 1473 2054 3624
+ 749 2853 2176
+ 460 2615 459
+ 3188 1189 1805
+ 422 2616 421
+ 3616 909 2016
+ 1710 1231 2744
+ 2520 1531 3599
+ 447 3416 446
+ 753 3469 3135
+ 2502 1763 3097
+ 1941 1557 3762
+ 1395 2249 3828
+ 1049 1867 2650
+ 2575 1653 3547
+ 2136 841 3383
+ 670 3457 2202
+ 806 2454 1639
+ 1109 1639 3754
+ 1340 2820 2841
+ 1961 1340 3423
+ 2080 3651 3923
+ 1561 693 2718
+ 1084 1981 2997
+ 688 3768 2573
+ 2244 25 2956
+ 686 3753 2687
+ 810 2833 2230
+ 2265 1260 3759
+ 2247 14 2954
+ 681 3773 2670
+ 811 2836 2233
+ 677 3664 2532
+ 1333 3594 3365
+ 1584 1192 2839
+ 2795 766 2426
+ 2165 766 2208
+ 2849 1196 2918
+ 767 2750 3258
+ 2906 716 2157
+ 717 3707 3129
+ 1866 743 3990
+ 999 2211 2816
+ 1103 1989 3005
+ 4012 1125 2357
+ 3423 921 1961
+ 1553 1188 2698
+ 1214 3022 3506
+ 965 2525 2445
+ 2879 425 3364
+ 660 3692 3180
+ 1218 3013 2850
+ 3151 2461 1319
+ 1329 657 1939
+ 2298 1393 3164
+ 1363 2550 2934
+ 667 2981 1706
+ 1232 2472 2988
+ 1934 777 2917
+ 2267 726 1680
+ 3637 2736 667
+ 1305 1674 3187
+ 1154 1586 2734
+ 1968 1210 2604
+ 970 1706 2045
+ 1058 1903 3033
+ 730 1379 1955
+ 1946 1291 3534
+ 2752 729 3417
+ 2858 18 1807
+ 1457 3959 3887
+ 3385 712 2682
+ 370 2084 369
+ 785 3587 2992
+ 3594 1034 2510
+ 2155 483 484
+ 433 3617 432
+ 2539 1103 3994
+ 1196 2189 2918
+ 1228 2047 3207
+ 1012 1771 2467
+ 2031 1178 3689
+ 692 3631 2411
+ 1137 2586 2133
+ 2133 1621 3098
+ 1240 2399 3074
+ 3184 791 2089
+ 2990 563 564
+ 1435 1139 3298
+ 3223 2382 1220
+ 2250 1220 2959
+ 677 2532 3888
+ 2959 794 2250
+ 2304 726 2267
+ 2260 2991 656
+ 796 2478 3539
+ 662 2762 1972
+ 2317 1277 2548
+ 2317 797 1504
+ 718 3909 2220
+ 696 2385 3760
+ 3293 799 2831
+ 1033 1668 2396
+ 3393 359 1864
+ 800 3294 2832
+ 1763 1192 2828
+ 1141 2853 2447
+ 3625 33 2776
+ 689 3853 2695
+ 3632 725 2594
+ 3632 1508 3237
+ 1375 3264 3558
+ 700 1785 3450
+ 2237 1848 3447
+ 3503 2848 3790
+ 1639 1109 2622
+ 2454 990 2087
+ 1927 954 3027
+ 954 3113 3027
+ 808 2859 1587
+ 2978 1291 3090
+ 1366 1898 3312
+ 2531 1746 3356
+ 2947 25 2244
+ 2834 810 2229
+ 3274 14 2247
+ 2835 811 2232
+ 3995 994 2488
+ 2503 3675 661
+ 813 3647 1365
+ 1906 1365 3647
+ 1920 1024 2363
+ 1023 1918 2362
+ 815 2366 1343
+ 688 3834 3768
+ 2369 1087 1851
+ 1043 2367 1913
+ 1347 2167 2562
+ 1025 1928 2370
+ 2589 739 1772
+ 1636 2806 1037
+ 1305 2215 3248
+ 1452 3552 2444
+ 3128 670 1717
+ 2657 820 3752
+ 265 266 1782
+ 267 3040 266
+ 248 249 3132
+ 3132 249 250
+ 2806 1636 3189
+ 1705 706 3072
+ 824 2949 2463
+ 2241 1380 4015
+ 732 2142 1596
+ 981 4017 2026
+ 2011 1211 3057
+ 177 3032 4013
+ 827 3538 3287
+ 550 3044 549
+ 439 3963 2929
+ 3817 828 3327
+ 2188 1390 2783
+ 1009 1655 1909
+ 2186 906 1951
+ 561 1542 2544
+ 2740 1534 3549
+ 1409 1888 3765
+ 735 2076 1575
+ 3955 738 1787
+ 742 1999 2338
+ 2077 735 1574
+ 1607 1065 2668
+ 2819 834 1573
+ 1113 1635 2478
+ 1507 1026 2220
+ 2388 1481 3741
+ 2388 836 1526
+ 2300 694 1873
+ 2313 837 1594
+ 3238 666 2477
+ 607 1565 2459
+ 1956 1042 2557
+ 1091 2559 1991
+ 840 2560 1401
+ 1304 1994 2306
+ 1477 1923 3129
+ 1265 2127 3626
+ 3763 915 2283
+ 2009 3811 3883
+ 3931 693 2666
+ 1877 2841 758
+ 844 2792 3791
+ 677 2169 4007
+ 1509 2994 3964
+ 3013 845 3979
+ 2302 88 4
+ 1353 2128 3434
+ 2550 1363 3247
+ 3289 847 1531
+ 2423 706 2931
+ 1048 1550 2914
+ 1653 755 3547
+ 2090 1754 3914
+ 2379 1476 2540
+ 2908 850 3816
+ 1899 1442 3236
+ 901 1861 3897
+ 1614 495 3596
+ 668 3179 2449
+ 2378 1488 2504
+ 681 2670 2561
+ 2511 1975 3778
+ 1857 1402 2299
+ 1548 2518 3362
+ 2069 855 3433
+ 856 2680 3507
+ 856 2327 3563
+ 3171 857 3008
+ 939 3672 1885
+ 3150 678 3591
+ 1567 3208 3827
+ 2993 871 1495
+ 2646 1041 2540
+ 3230 2104 1078
+ 1650 715 2020
+ 861 3456 3353
+ 1408 2383 3939
+ 2413 1407 3938
+ 3352 1682 3957
+ 1478 2679 2904
+ 2888 671 2851
+ 2357 1483 4012
+ 1270 2352 3793
+ 3986 652 2808
+ 851 2781 1899
+ 2998 876 1500
+ 2619 1038 2504
+ 1350 1592 3224
+ 1671 3531 3774
+ 2003 1620 3595
+ 2701 868 3982
+ 1284 1685 3222
+ 346 1629 2476
+ 1770 702 3774
+ 1290 2257 2147
+ 2649 689 2533
+ 1495 980 3091
+ 2381 1201 3049
+ 2465 872 1736
+ 873 2967 4027
+ 671 2113 2111
+ 2162 874 1662
+ 3136 1384 2162
+ 2359 1414 2661
+ 2072 875 3279
+ 1535 2673 2686
+ 1500 976 3087
+ 1846 1198 3076
+ 3076 877 3775
+ 2780 1178 2031
+ 2933 878 3996
+ 1434 3140 3167
+ 3529 879 2855
+ 880 3043 1551
+ 1654 1150 2657
+ 2685 1432 3427
+ 1558 673 2427
+ 1658 719 2877
+ 3011 882 3688
+ 1698 987 3028
+ 598 2124 3333
+ 3161 1179 2515
+ 1938 1006 2753
+ 2630 461 462
+ 2965 749 1767
+ 1801 750 3120
+ 420 2629 419
+ 2171 1239 3079
+ 821 3130 2171
+ 1027 2512 2427
+ 1019 1556 3006
+ 1720 154 155
+ 2406 742 1730
+ 1678 167 2135
+ 156 1715 2499
+ 873 3466 2967
+ 711 3651 3315
+ 1661 281 3306
+ 1690 1285 3687
+ 2161 3803 3911
+ 1346 2434 3452
+ 2195 1299 3497
+ 65 3429 3585
+ 3041 1506 3615
+ 61 3654 2027
+ 1727 730 3993
+ 1692 1130 2320
+ 1672 696 2444
+ 653 1735 3670
+ 1164 1486 2330
+ 1773 898 1783
+ 1450 2787 3861
+ 1824 1464 3459
+ 2446 1173 3036
+ 3036 900 2446
+ 1784 1643 3196
+ 1955 1379 2190
+ 1689 181 2397
+ 3990 1241 3095
+ 2973 990 1858
+ 651 3696 2618
+ 1626 445 2236
+ 488 3896 1976
+ 2886 1587 4025
+ 808 2437 2530
+ 1264 2587 3331
+ 738 3219 1886
+ 2617 841 3131
+ 2082 1156 2696
+ 1532 3359 3540
+ 3501 715 1650
+ 1765 1028 2751
+ 3202 751 2016
+ 1760 3037 3936
+ 1364 2272 2497
+ 3065 798 2116
+ 1386 2116 2636
+ 669 3534 1617
+ 1568 3109 3823
+ 1598 1220 3873
+ 1939 913 1911
+ 3873 657 2869
+ 1391 3576 3907
+ 1397 1951 691
+ 9 3794 2950
+ 3696 651 2442
+ 1560 3183 3491
+ 917 2093 1595
+ 1609 2564 3508
+ 2926 721 1744
+ 1171 1824 3229
+ 1089 1687 2472
+ 663 1825 3680
+ 1317 2018 2738
+ 2566 2018 665
+ 1961 707 3810
+ 255 1747 2669
+ 1717 670 2202
+ 2708 1717 3311
+ 923 3577 1823
+ 47 2180 3432
+ 2913 434 435
+ 3580 924 2112
+ 1862 430 2893
+ 484 3953 2155
+ 2008 1286 3451
+ 745 2008 2662
+ 2358 1365 2936
+ 2936 927 2358
+ 1337 2097 3173
+ 3010 1727 3993
+ 2016 1451 3202
+ 623 1847 2253
+ 1896 1148 2715
+ 1809 777 2728
+ 3081 33 3625
+ 2649 1360 3853
+ 658 3465 3887
+ 708 3712 3350
+ 933 1455 2722
+ 794 2130 4029
+ 1121 1806 3016
+ 2090 934 1749
+ 1733 1889 3372
+ 655 1967 3137
+ 2939 1876 3789
+ 1980 936 1800
+ 1174 1871 3105
+ 1871 1170 2733
+ 938 1923 1753
+ 717 2739 3371
+ 939 1493 3084
+ 727 3672 1533
+ 2724 3368 1541
+ 1517 940 2057
+ 2011 1359 3569
+ 826 3239 2011
+ 2725 1453 3328
+ 726 1947 3190
+ 1198 1937 3070
+ 862 2022 3199
+ 2023 861 3200
+ 1922 1187 3089
+ 945 2360 1857
+ 1651 945 2059
+ 2006 1111 2455
+ 2109 946 3678
+ 2728 777 2049
+ 947 1867 2843
+ 948 1597 1933
+ 860 2719 3935
+ 1033 1724 3106
+ 784 2048 3415
+ 2438 666 3238
+ 610 2019 2580
+ 2235 1355 3448
+ 705 2481 3242
+ 2086 130 3024
+ 2983 952 2637
+ 1704 2637 731
+ 3019 1704 731
+ 2872 1936 685
+ 3885 954 2618
+ 1393 2443 3164
+ 2132 1723 3746
+ 2231 26 1925
+ 3528 956 3501
+ 1729 2107 3094
+ 3350 2775 708
+ 2672 732 3642
+ 958 3610 2076
+ 1292 3295 2142
+ 2163 1311 3349
+ 960 2841 2820
+ 658 2007 1583
+ 961 3048 2174
+ 1437 3048 3146
+ 3259 3039 1414
+ 273 2070 2942
+ 2106 240 3157
+ 1366 2106 3633
+ 804 3174 2266
+ 1740 964 2309
+ 965 1615 3449
+ 1339 2445 2525
+ 966 1665 3750
+ 680 2572 3254
+ 2241 739 1790
+ 818 2452 1387
+ 2065 141 3757
+ 3148 1122 2091
+ 1769 691 2867
+ 1459 969 2365
+ 970 2045 2187
+ 994 1935 2356
+ 799 3293 2246
+ 2010 1739 2871
+ 2012 357 2281
+ 1728 3343 3884
+ 1828 3129 3339
+ 841 2136 3987
+ 3149 1432 3875
+ 565 2261 3060
+ 820 2708 2184
+ 1470 3240 3458
+ 976 1500 2873
+ 866 1612 2771
+ 2025 725 3632
+ 1608 977 2909
+ 3163 1437 720
+ 3103 978 2295
+ 2088 738 1886
+ 832 2141 3462
+ 980 1495 2986
+ 1616 980 2840
+ 2091 1122 2338
+ 1962 2332 741
+ 2342 819 3226
+ 1076 2203 2778
+ 2490 654 1536
+ 1361 2974 3337
+ 2345 1369 3602
+ 2345 984 2139
+ 1191 2085 2331
+ 2166 1446 2750
+ 1312 2081 2957
+ 1267 1832 2225
+ 1882 961 1872
+ 3481 883 3028
+ 988 3288 2321
+ 3288 988 2223
+ 989 1681 2759
+ 1438 3353 3813
+ 1281 3142 3133
+ 668 2377 3179
+ 3864 1283 3168
+ 3864 991 2752
+ 992 1837 1915
+ 1837 992 2729
+ 1789 2093 3858
+ 661 3093 1887
+ 1601 2187 2989
+ 656 3995 1569
+ 995 3453 2290
+ 751 3370 1817
+ 2162 1662 3136
+ 769 2211 1838
+ 1787 738 3795
+ 737 1632 2075
+ 836 2674 3801
+ 808 3575 2859
+ 2111 996 1942
+ 2173 2889 1270
+ 1000 1943 2113
+ 1839 1000 2213
+ 1853 1214 3159
+ 2176 1001 3812
+ 2177 2857 750
+ 3025 1002 1854
+ 1003 1386 2385
+ 2252 1003 2242
+ 2594 725 1540
+ 2293 1004 2260
+ 1005 1628 2403
+ 3043 1005 2353
+ 3614 884 2748
+ 2423 2931 1412
+ 1007 1539 2205
+ 812 2648 1431
+ 2297 860 1510
+ 1650 2020 4020
+ 3951 660 1884
+ 829 1909 1655
+ 1901 462 463
+ 885 2632 3380
+ 2631 886 3679
+ 419 1902 418
+ 1012 2121 2120
+ 271 2256 3981
+ 1013 3137 2659
+ 1742 1013 2576
+ 2443 775 2925
+ 724 2118 2046
+ 2461 1461 2675
+ 955 1472 2046
+ 1845 1016 2217
+ 757 2214 2032
+ 1017 1870 1952
+ 1276 2505 3669
+ 1018 1809 3926
+ 2414 663 1891
+ 1019 1664 2737
+ 672 1556 2679
+ 2238 759 3050
+ 855 2069 3700
+ 1975 697 3900
+ 577 2647 1663
+ 877 3285 3781
+ 326 2126 3424
+ 1023 1843 2583
+ 743 2152 3241
+ 1920 188 2554
+ 1024 2292 3542
+ 1025 1700 2546
+ 744 2292 3715
+ 835 2185 2710
+ 798 2285 3976
+ 1027 1726 2639
+ 888 2512 3608
+ 2751 1536 654
+ 1822 2303 3412
+ 2607 823 3319
+ 1550 1029 2592
+ 2542 797 3463
+ 756 3997 2082
+ 2004 659 3820
+ 3495 1906 690
+ 1708 1116 2896
+ 1716 2376 2523
+ 1668 1033 3106
+ 1724 1033 2390
+ 2196 785 2189
+ 1701 1034 3135
+ 2477 666 1711
+ 1549 1035 2667
+ 2813 1626 2818
+ 490 2732 489
+ 2765 730 1727
+ 684 3201 2806
+ 2619 866 3822
+ 1712 1038 2709
+ 2663 863 3787
+ 864 2280 3674
+ 1560 3491 2217
+ 1224 2150 2304
+ 2646 859 3701
+ 1718 1041 2720
+ 1956 222 2555
+ 3638 2336 746
+ 1043 1713 2537
+ 746 2336 3589
+ 1957 313 2556
+ 3640 2337 747
+ 1045 1714 2536
+ 747 2337 3590
+ 1046 3588 2489
+ 2700 1046 2495
+ 1047 1873 2209
+ 837 2725 3328
+ 1550 2592 848
+ 692 2411 1699
+ 2534 755 1653
+ 1842 4011 3191
+ 2249 1395 2380
+ 2713 858 3779
+ 1051 1891 2125
+ 717 2398 3707
+ 2278 732 1596
+ 1856 1052 2372
+ 2464 895 1790
+ 1780 3055 739
+ 776 2934 2451
+ 1227 2161 3911
+ 2606 505 3749
+ 718 2221 3909
+ 3220 1555 3785
+ 1643 1056 3053
+ 3307 1057 2406
+ 981 1999 4017
+ 2513 652 3986
+ 1889 1058 3033
+ 2566 665 1860
+ 1460 2566 2770
+ 1060 1603 3184
+ 1734 3412 1028
+ 1984 719 1658
+ 851 1899 3220
+ 2312 87 3004
+ 748 2436 3430
+ 1063 2976 2323
+ 1399 2976 3421
+ 3578 735 1575
+ 1844 1064 2448
+ 2563 704 1805
+ 689 2695 1607
+ 1066 1815 2000
+ 2750 1066 2166
+ 1067 2178 1738
+ 1485 849 2575
+ 1068 2178 2456
+ 66 2422 3429
+ 2788 853 3874
+ 681 2561 2660
+ 2347 494 2810
+ 2377 1280 3179
+ 1887 1505 3999
+ 1892 918 1926
+ 2482 361 1774
+ 2010 1072 1739
+ 1073 2193 2492
+ 1073 2492 2206
+ 2842 848 3881
+ 692 2470 3871
+ 1075 2824 2533
+ 871 2824 3869
+ 2778 779 2350
+ 1076 2410 3363
+ 2208 766 1954
+ 752 2439 1874
+ 2104 736 3970
+ 1510 860 3384
+ 2683 500 1757
+ 1116 1904 2255
+ 2435 891 3954
+ 3301 873 4027
+ 1970 28 2807
+ 1662 1081 3145
+ 1082 2694 2613
+ 977 1608 2025
+ 2891 1491 3639
+ 1083 1900 2075
+ 3634 931 2140
+ 1084 2628 3890
+ 1085 1751 2528
+ 761 2417 3477
+ 1086 1752 2955
+ 762 2416 3912
+ 1087 1752 2416
+ 1851 3561 4018
+ 1088 1751 2417
+ 3913 2417 761
+ 2517 777 1934
+ 1640 2922 3153
+ 1090 2649 1529
+ 688 2573 3091
+ 1091 1756 2527
+ 763 2420 3478
+ 1092 1756 2420
+ 3905 2420 763
+ 2415 103 1755
+ 1093 2421 3408
+ 1094 1755 2953
+ 764 2421 3906
+ 2500 138 1761
+ 1844 1095 2098
+ 1096 2673 1535
+ 683 2582 3087
+ 2412 1228 3017
+ 707 2743 1543
+ 1098 2334 2084
+ 371 2635 370
+ 2348 903 3519
+ 1099 2711 2119
+ 2995 2720 850
+ 2687 1977 4000
+ 1973 2660 3947
+ 1492 933 2722
+ 2999 2709 853
+ 2670 1983 3985
+ 3991 1839 770
+ 3994 2691 770
+ 1104 1658 2877
+ 3498 2181 699
+ 1561 3433 3710
+ 2194 1105 2207
+ 2346 736 3950
+ 3156 1106 2727
+ 2690 921 1747
+ 3115 3485 887
+ 2483 85 1788
+ 2259 1108 2436
+ 2779 491 1905
+ 757 2325 3754
+ 1503 2995 850
+ 876 2911 3934
+ 2007 658 1949
+ 2222 1338 3712
+ 1963 732 2278
+ 175 2570 1856
+ 1113 1803 2910
+ 2185 1703 2710
+ 1114 1808 2645
+ 957 3205 1729
+ 2643 723 1628
+ 2671 1115 2984
+ 2474 498 1904
+ 1679 1116 2255
+ 1827 1117 3878
+ 2688 1117 2535
+ 1118 1792 2615
+ 749 3092 1767
+ 3915 750 1801
+ 1791 1119 2616
+ 2793 804 2266
+ 2674 1120 3801
+ 1121 1759 2887
+ 934 3016 1806
+ 2338 981 2091
+ 1965 2276 3826
+ 1687 2922 872
+ 1104 1702 2465
+ 2352 1270 2816
+ 1478 3169 2679
+ 1269 2888 2851
+ 697 2964 4012
+ 2437 1309 2530
+ 3367 782 2860
+ 2332 1962 4037
+ 2091 981 3808
+ 1128 2121 3548
+ 771 3606 2373
+ 1129 2992 2621
+ 767 2918 2519
+ 2320 896 1692
+ 823 2634 3319
+ 2359 875 2072
+ 1799 1131 3923
+ 1132 1405 3422
+ 1767 1405 2965
+ 1133 2662 2509
+ 745 2662 1908
+ 980 1647 2840
+ 1985 1134 3550
+ 1135 2284 2844
+ 769 2593 2287
+ 2863 785 1701
+ 2971 900 2062
+ 1884 1137 3703
+ 1137 1758 3174
+ 2949 824 1683
+ 2614 1138 2375
+ 1769 969 2351
+ 1117 2431 3878
+ 2771 976 1606
+ 1986 1140 3581
+ 1141 3584 3340
+ 801 2897 2479
+ 2514 750 2857
+ 3180 3692 1613
+ 1665 966 1962
+ 890 2703 1745
+ 2543 143 2134
+ 1965 1144 2890
+ 2595 2170 783
+ 932 2773 1978
+ 2296 1512 2895
+ 396 2296 3304
+ 830 3331 2587
+ 1147 2430 3204
+ 824 3026 2715
+ 1733 935 3645
+ 1878 36 3064
+ 1878 1149 2384
+ 2108 1551 3128
+ 617 2741 3034
+ 2052 2640 3562
+ 672 2678 1556
+ 1152 2093 3278
+ 1595 1152 2602
+ 1153 1611 2355
+ 1494 2932 3244
+ 1586 2350 779
+ 2013 1514 3170
+ 3120 750 1709
+ 1499 2631 3679
+ 2082 907 3355
+ 3253 1859 3262
+ 1157 2713 3779
+ 805 2848 2237
+ 1158 1695 2791
+ 1695 1158 2726
+ 1159 1694 2758
+ 1694 1159 2790
+ 2071 435 436
+ 924 1863 3489
+ 1862 925 3490
+ 52 2269 486
+ 3194 1353 2641
+ 1517 2724 940
+ 744 3410 2212
+ 2639 3843 881
+ 1486 2181 3498
+ 628 2782 3933
+ 1165 2785 3206
+ 1874 2526 752
+ 2624 1166 2301
+ 1692 896 1821
+ 2426 766 2165
+ 2313 1394 3250
+ 1722 751 1817
+ 1783 1168 3536
+ 2601 942 3758
+ 778 2902 2361
+ 3386 3780 653
+ 1274 2733 2868
+ 1171 3686 2612
+ 754 3229 1824
+ 1602 865 2001
+ 1820 1172 2201
+ 1173 2219 3166
+ 801 2479 2446
+ 1174 1484 3176
+ 1871 1174 3780
+ 3001 183 1843
+ 1960 3241 1023
+ 2441 3866 449
+ 1176 1775 2451
+ 2897 801 1907
+ 2447 1177 2484
+ 2723 59 1836
+ 3689 2656 789
+ 2742 1 3865
+ 2656 1179 3161
+ 2584 979 2141
+ 1787 1180 1930
+ 1181 3819 3039
+ 3433 1181 2069
+ 1182 1855 3698
+ 711 1690 2148
+ 828 3600 3342
+ 442 2275 441
+ 2774 52 1798
+ 427 2508 3899
+ 944 2003 3325
+ 800 2832 2263
+ 2831 799 2396
+ 2068 943 3193
+ 3595 713 2003
+ 345 2476 3310
+ 3374 2120 771
+ 1272 2789 3485
+ 2894 2487 790
+ 1805 1189 3251
+ 2847 330 331
+ 1190 1519 2055
+ 1732 2331 3921
+ 2085 1191 3504
+ 2839 2502 765
+ 927 2197 3744
+ 813 3973 1914
+ 965 1848 2237
+ 3078 291 2122
+ 2892 1194 2104
+ 1018 1842 2333
+ 3573 2125 3592
+ 1034 1701 2196
+ 2855 1331 3529
+ 2960 664 2044
+ 734 2137 1820
+ 1669 1198 3070
+ 1937 1198 3974
+ 2028 1199 3171
+ 1605 939 3084
+ 1200 2776 3037
+ 1444 2776 3186
+ 1201 1640 2809
+ 699 3049 3175
+ 2919 963 2168
+ 250 2638 1644
+ 1925 1203 2170
+ 1807 1203 2858
+ 1873 1047 2725
+ 2618 1394 3181
+ 1205 1745 2627
+ 11 2499 2322
+ 1206 1936 2872
+ 4036 3027 807
+ 1207 1709 2514
+ 2571 1207 2585
+ 3439 463 464
+ 401 3155 400
+ 2756 417 3438
+ 385 3154 384
+ 2981 1630 3496
+ 2045 2605 780
+ 1211 2011 3218
+ 1963 2760 4026
+ 3141 758 2109
+ 252 2944 1852
+ 2051 1061 3867
+ 631 3058 2101
+ 3159 456 457
+ 772 3506 3022
+ 887 3485 2789
+ 3126 3096 1696
+ 1216 1940 3764
+ 3025 3764 2277
+ 1814 1704 3019
+ 2129 2535 674
+ 2429 6 2307
+ 1319 2429 3151
+ 1219 2302 2428
+ 2302 1219 3245
+ 1598 914 2692
+ 793 3223 3080
+ 1221 3391 3086
+ 1167 2529 2426
+ 1594 837 2079
+ 1833 916 2681
+ 1772 967 2452
+ 3389 1223 3201
+ 1711 666 2150
+ 2267 1224 2304
+ 1225 2658 2633
+ 1441 2172 3326
+ 1502 838 1996
+ 1016 2438 2214
+ 1816 1227 2314
+ 893 3346 1777
+ 3017 2579 788
+ 3284 3017 788
+ 1229 3515 3150
+ 858 3208 2898
+ 3050 759 1980
+ 2238 3050 3809
+ 1231 1710 3175
+ 751 3382 2016
+ 3249 930 2049
+ 2192 1089 2951
+ 1233 2498 2574
+ 1233 2387 2626
+ 2600 1193 2450
+ 1376 3503 3790
+ 1235 2236 3416
+ 1874 1235 2526
+ 1236 1749 3031
+ 768 3699 1923
+ 2434 893 3117
+ 1007 2205 2179
+ 1238 2012 3343
+ 2012 1238 2941
+ 1239 1782 3040
+ 2789 2171 887
+ 3198 663 2414
+ 2216 1240 2398
+ 3095 1866 3990
+ 902 3095 2287
+ 1242 2478 3152
+ 1113 2478 2185
+ 3098 790 2133
+ 1990 1243 2586
+ 1244 1874 2439
+ 1976 1244 3085
+ 2665 1189 2405
+ 1573 834 2078
+ 1246 1924 3012
+ 1924 1246 3051
+ 3270 245 1810
+ 243 2883 3425
+ 1696 1249 3126
+ 1782 1248 3267
+ 3192 259 2881
+ 821 3126 3351
+ 1202 2168 3083
+ 3071 4024 822
+ 2829 2492 778
+ 2829 1935 1251
+ 1252 2426 2529
+ 2795 1252 2837
+ 1253 1987 2215
+ 1972 1253 3513
+ 1254 2210 3101
+ 2210 1254 2628
+ 2245 1255 2834
+ 3730 25 2947
+ 1256 1974 3440
+ 3857 1256 2593
+ 1257 2248 3232
+ 1257 2247 2836
+ 1970 1081 2972
+ 2243 1258 2691
+ 3919 815 3879
+ 1988 1090 2969
+ 1260 1851 4018
+ 1260 2582 3759
+ 1261 2325 3305
+ 611 3197 2019
+ 1262 2070 3243
+ 2080 2805 3651
+ 712 1953 2682
+ 3285 1813 3781
+ 3431 1860 665
+ 1264 2430 2587
+ 841 3987 3131
+ 1564 3355 3626
+ 1266 2275 3336
+ 3628 1266 2251
+ 1267 2225 3347
+ 594 3209 3646
+ 1268 2139 3800
+ 2345 1268 3322
+ 1125 2213 2815
+ 864 2357 2280
+ 2816 1124 2352
+ 1039 2173 2663
+ 3059 432 3617
+ 786 2948 2112
+ 1272 2373 2553
+ 1272 2066 2789
+ 3121 2283 842
+ 9 2950 3572
+ 1274 2868 3564
+ 1274 2096 3563
+ 3618 935 2234
+ 2659 1275 3655
+ 1779 701 2505
+ 2739 1276 3371
+ 2548 1277 3453
+ 1005 2403 2317
+ 917 1595 3321
+ 1941 2761 473
+ 3279 875 2412
+ 2121 1012 2467
+ 1280 2182 2457
+ 852 1562 2151
+ 2087 728 4021
+ 757 3142 2214
+ 2748 884 1780
+ 684 2156 3389
+ 2005 1283 2860
+ 2123 2608 409
+ 3313 869 2852
+ 868 3222 1685
+ 1688 3052 3665
+ 1182 1690 3088
+ 1286 1826 3361
+ 3066 1286 2008
+ 1287 1903 3118
+ 1056 3069 1646
+ 1288 2246 3293
+ 2021 1288 3257
+ 2871 710 3512
+ 2010 1289 3294
+ 3526 793 2172
+ 2147 2257 676
+ 1291 1617 3534
+ 782 2978 3090
+ 1292 2142 3832
+ 825 3295 2114
+ 1963 1112 2760
+ 1293 1781 3894
+ 924 1819 2154
+ 786 2821 2569
+ 3797 2014 786
+ 1146 2218 2569
+ 2823 747 4030
+ 2664 1296 3834
+ 1297 4031 3920
+ 1913 3920 4031
+ 3029 2100 368
+ 784 3415 2334
+ 2456 755 2235
+ 705 1764 2481
+ 3426 789 2468
+ 3400 1300 3631
+ 3186 802 2042
+ 1254 2024 3634
+ 2449 1032 2376
+ 1302 3114 2119
+ 1303 2305 3927
+ 1991 1303 3478
+ 2874 761 3477
+ 2547 1304 3930
+ 2215 911 2598
+ 819 3187 3611
+ 1030 2268 3338
+ 2083 3256 756
+ 3668 2087 2973
+ 2711 1858 668
+ 3889 982 2029
+ 1076 2778 2410
+ 1309 2437 3652
+ 1309 1916 2530
+ 958 2158 3610
+ 1310 2466 2921
+ 3349 833 2163
+ 2228 3684 3690
+ 2081 720 3988
+ 599 3418 2124
+ 1313 1958 3542
+ 2389 1313 3852
+ 1314 1960 2389
+ 743 3324 2052
+ 1315 1929 3603
+ 1315 3658 2212
+ 2843 1867 4010
+ 2887 3407 849
+ 3373 831 3286
+ 920 2738 2018
+ 1318 2050 3408
+ 3334 1318 3664
+ 3151 774 2461
+ 2429 1319 3492
+ 1320 2443 2925
+ 1014 2443 2227
+ 1321 1730 3537
+ 2322 3307 11
+ 3607 799 2246
+ 363 3392 2030
+ 1072 2010 2507
+ 972 2281 3830
+ 3445 389 390
+ 2866 1324 3756
+ 1325 1861 3379
+ 2234 3379 781
+ 3441 770 2402
+ 1921 1326 3140
+ 3395 746 1986
+ 2073 1327 2305
+ 2306 840 2074
+ 2540 687 2379
+ 3470 1911 775
+ 2489 1329 3470
+ 2905 2123 410
+ 3226 1330 2578
+ 3015 3856 675
+ 2849 1331 3015
+ 3799 2110 542
+ 2130 3597 4029
+ 3594 2510 675
+ 765 1333 2360
+ 1334 2539 787
+ 2620 1334 787
+ 3557 2258 773
+ 905 2886 3235
+ 3662 1978 3663
+ 2199 3663 783
+ 901 1697 2092
+ 2097 3300 640
+ 1831 3030 932
+ 2222 3712 708
+ 3560 1917 3966
+ 2291 1339 698
+ 3810 707 2820
+ 3423 1340 2841
+ 2657 1150 2108
+ 2657 1341 4001
+ 1024 1958 2363
+ 1960 1023 2362
+ 1343 1945 3291
+ 815 1343 2368
+ 1344 2369 816
+ 2367 1344 816
+ 3356 946 2222
+ 809 2531 2107
+ 1346 2045 3803
+ 695 1346 3452
+ 1347 2562 817
+ 1929 1025 2370
+ 3976 2285 3499
+ 2116 1348 2598
+ 1591 3360 3367
+ 912 3273 1987
+ 1350 3997 2268
+ 701 3172 2349
+ 1351 2197 3464
+ 2146 927 3744
+ 1352 2610 3116
+ 2126 1352 3424
+ 3194 748 3430
+ 2641 1353 3709
+ 1354 1934 2917
+ 3904 1354 3680
+ 1355 2650 3007
+ 1049 2650 2534
+ 2044 930 3989
+ 3335 1356 3772
+ 1357 2719 3062
+ 860 3935 2175
+ 2869 657 2700
+ 2440 1358 2495
+ 3032 178 2460
+ 3218 2011 941
+ 1360 1988 3792
+ 802 3860 2042
+ 3463 797 3747
+ 2349 3337 701
+ 3972 1202 2374
+ 1362 1746 2531
+ 3247 847 2550
+ 2209 1363 2453
+ 1364 2404 2876
+ 704 2563 2497
+ 1365 1906 3495
+ 813 1365 2358
+ 3312 239 2106
+ 2769 1366 3821
+ 3636 761 1977
+ 2830 1367 3753
+ 1368 2229 2830
+ 762 3635 1979
+ 3877 510 2400
+ 796 3539 2345
+ 3605 803 2293
+ 2174 1370 3704
+ 2015 803 2164
+ 602 3411 2295
+ 1372 3773 681
+ 764 3643 1973
+ 3644 763 1983
+ 2233 1373 2826
+ 3650 830 3263
+ 831 3549 2766
+ 1990 2586 804
+ 2793 3442 3574
+ 1883 805 2600
+ 1376 1641 2713
+ 1684 1052 2588
+ 1966 3460 825
+ 2513 1820 3249
+ 1232 2988 2517
+ 2659 3655 4014
+ 3844 1379 730
+ 3615 705 2063
+ 3598 1380 2241
+ 3524 140 2065
+ 2693 1761 3659
+ 1830 1468 3178
+ 2676 1382 2756
+ 2684 465 45
+ 1208 2755 2677
+ 2064 1080 2967
+ 1942 996 3466
+ 3961 2827 702
+ 1385 2054 2184
+ 1003 2252 3065
+ 2385 1386 3760
+ 1387 2452 2614
+ 1742 2706 1013
+ 3323 979 1971
+ 1388 3546 3462
+ 3614 2515 884
+ 3742 1389 3316
+ 1390 2188 3918
+ 3517 3918 829
+ 1391 2850 3013
+ 1391 3979 3576
+ 3014 1219 2642
+ 676 1797 2147
+ 1393 775 2443
+ 775 1393 3470
+ 1394 1927 4036
+ 3181 1394 2313
+ 3459 899 2291
+ 754 3828 2249
+ 1396 794 2692
+ 677 4007 2324
+ 2283 915 4022
+ 2311 842 3811
+ 1398 1130 2634
+ 1938 1398 3925
+ 1737 694 2976
+ 752 3421 2056
+ 1042 2073 2557
+ 2559 1400 839
+ 1401 1995 3522
+ 1401 1957 2558
+ 1402 2747 854
+ 945 2299 1604
+ 908 1532 2095
+ 956 3528 2231
+ 1404 2511 854
+ 879 3691 2747
+ 2632 1498 3380
+ 2219 1132 3422
+ 1406 2828 2975
+ 2971 1406 4006
+ 943 1937 2413
+ 3957 862 3199
+ 861 3353 3200
+ 1922 944 2383
+ 1888 692 2061
+ 1083 2933 1900
+ 2259 867 3262
+ 1162 1770 2471
+ 3969 654 2490
+ 2548 1411 3747
+ 2931 1006 1938
+ 2423 1412 2607
+ 1413 2470 2740
+ 2738 1413 3373
+ 3259 759 3039
+ 1228 2661 2047
+ 215 216 3397
+ 215 3215 214
+ 208 209 3735
+ 209 210 2804
+ 376 2393 375
+ 376 33 3719
+ 2391 197 198
+ 2391 1418 3717
+ 206 207 3736
+ 208 3735 2799
+ 193 194 2796
+ 2798 1420 3737
+ 204 2034 203
+ 202 203 3848
+ 373 374 3850
+ 372 373 2697
+ 201 2394 200
+ 200 3846 199
+ 212 213 3739
+ 213 214 2654
+ 1425 2041 3721
+ 2796 194 3737
+ 209 2804 3735
+ 210 211 3731
+ 204 205 3733
+ 3736 2797 206
+ 307 2039 306
+ 1428 2039 3730
+ 1430 2040 2800
+ 1429 2846 3727
+ 305 306 3728
+ 3728 306 2039
+ 2980 2294 3675
+ 812 1431 2707
+ 3468 674 1827
+ 566 1516 2261
+ 2262 1247 3071
+ 2168 3895 4032
+ 2907 1434 3167
+ 1446 2166 2717
+ 2009 691 2565
+ 2637 1435 3298
+ 3331 830 2344
+ 1436 3685 2496
+ 1437 2164 3605
+ 720 1437 3146
+ 3404 2224 340
+ 1438 2408 3200
+ 2409 1439 3199
+ 2224 3405 339
+ 3246 1440 3648
+ 2602 3246 469
+ 3326 2172 793
+ 3080 3326 793
+ 1964 865 2945
+ 1287 3118 2781
+ 3358 1996 838
+ 609 1443 3067
+ 1200 2876 3186
+ 3863 3420 931
+ 1445 2146 585
+ 813 1914 2450
+ 1331 2849 3258
+ 3770 2166 787
+ 1447 3319 2915
+ 1530 1029 3776
+ 1919 723 2643
+ 622 3892 2671
+ 3902 2290 4028
+ 929 1919 3971
+ 899 1464 3532
+ 1214 3861 2787
+ 1451 2016 3901
+ 1812 995 3471
+ 3474 819 2342
+ 696 3836 2444
+ 1453 2725 3505
+ 1453 1894 3328
+ 3056 895 2464
+ 2339 1454 3654
+ 1455 3888 2982
+ 2169 1455 933
+ 3007 664 2960
+ 2463 1456 3026
+ 3465 948 3444
+ 1949 3887 3959
+ 3666 868 3288
+ 353 3472 2223
+ 3234 792 2351
+ 2990 1459 3711
+ 1460 2018 2566
+ 737 3656 2770
+ 1461 2298 724
+ 774 1461 2461
+ 1462 2342 3226
+ 2029 982 3673
+ 928 2097 3697
+ 2301 1463 2624
+ 3138 2612 476
+ 1464 2200 3532
+ 1741 1465 3695
+ 3696 1465 3676
+ 3119 129 2086
+ 3855 1466 3807
+ 3143 2153 80
+ 1467 2418 3131
+ 3231 387 388
+ 437 3825 2866
+ 3683 493 2347
+ 806 4003 2457
+ 1470 3458 3387
+ 54 1470 2522
+ 1471 1014 2424
+ 955 3523 2131
+ 2046 2675 724
+ 97 3568 2132
+ 3624 2054 702
+ 1473 3624 2567
+ 1474 2561 2792
+ 2982 1474 844
+ 2592 1530 3881
+ 1534 2740 3467
+ 3550 1134 3042
+ 2540 1476 2646
+ 1051 2125 3573
+ 1923 3573 768
+ 1478 2904 863
+ 2352 1478 863
+ 1479 2223 3402
+ 1149 3064 2863
+ 1480 2321 2621
+ 3587 1480 2992
+ 1481 511 2862
+ 984 1481 2388
+ 2316 1482 2996
+ 769 1482 3110
+ 1483 2357 864
+ 1663 1021 2875
+ 1484 2220 2285
+ 2252 1174 3176
+ 2017 1485 2575
+ 2343 3516 71
+ 1710 898 2330
+ 882 1486 2838
+ 2819 1573 3702
+ 1686 2986 3869
+ 3581 1140 3054
+ 2504 1488 2619
+ 1489 2999 853
+ 2561 1489 2788
+ 1490 2541 3121
+ 3868 1490 3121
+ 1491 2780 878
+ 3639 1491 878
+ 2792 1572 3791
+ 2110 1492 541
+ 1493 939 2938
+ 3670 1493 2952
+ 3244 718 1998
+ 856 1494 2327
+ 1495 871 2986
+ 2573 1495 3091
+ 3591 678 3530
+ 754 1496 2564
+ 3752 820 2184
+ 614 3940 2354
+ 1010 1868 2289
+ 885 3380 3771
+ 1743 1499 3679
+ 1869 1011 2288
+ 1500 876 2873
+ 2582 1500 3087
+ 1501 3865 3399
+ 884 1501 3068
+ 1502 2401 838
+ 1502 1996 3381
+ 1503 850 2908
+ 686 2687 2686
+ 2542 1030 3338
+ 2353 1504 3457
+ 1505 3681 3783
+ 926 3999 2509
+ 1506 705 3615
+ 3056 1246 3401
+ 1507 2591 835
+ 2710 1507 835
+ 1508 2293 803
+ 3237 1508 803
+ 2994 102 2415
+ 3221 1509 3653
+ 1731 1510 3384
+ 1008 1510 2286
+ 2774 1184 2508
+ 1161 1511 2651
+ 2895 1146 2296
+ 2469 1512 3922
+ 3831 1513 2701
+ 1284 3222 2494
+ 1514 2734 3086
+ 685 3391 2837
+ 1515 2446 2971
+ 1515 1906 2966
+ 3427 1432 3149
+ 1631 2639 4008
+ 3859 870 2724
+ 547 1517 2057
+ 3297 2179 740
+ 1789 993 3297
+ 2055 1022 3437
+ 332 3500 2847
+ 2943 1524 3327
+ 2928 1520 3942
+ 3962 453 454
+ 1521 1931 2958
+ 3963 439 440
+ 828 3342 2943
+ 1523 3044 3943
+ 3287 1523 2590
+ 2340 1524 2943
+ 478 3949 477
+ 1525 2590 3944
+ 827 3601 3818
+ 1526 836 2811
+ 669 1526 2551
+ 3245 3014 846
+ 1062 3682 3840
+ 1041 1623 2764
+ 1582 2908 3816
+ 1529 2533 2824
+ 1090 1529 2993
+ 2480 1530 3776
+ 1530 2699 3881
+ 1531 847 3599
+ 2441 1531 3866
+ 3671 299 3359
+ 908 2095 3612
+ 727 1885 3672
+ 2979 1533 3113
+ 1534 557 2864
+ 2740 3549 831
+ 1535 2686 2911
+ 1096 1535 2998
+ 3767 3494 791
+ 1952 983 3767
+ 2709 1588 3874
+ 1572 2792 3604
+ 1538 431 3059
+ 786 2014 2948
+ 1539 695 2205
+ 2488 1539 2648
+ 2912 2485 795
+ 1642 1004 2912
+ 1541 2641 676
+ 940 1541 2257
+ 1542 2344 830
+ 1374 2544 3650
+ 707 1993 2743
+ 2985 1543 843
+ 2697 373 3850
+ 2599 1544 31
+ 3364 426 3804
+ 1216 3854 1940
+ 1039 1610 2644
+ 3510 1546 3777
+ 1547 2950 3794
+ 1886 915 3112
+ 1020 2099 2518
+ 855 3553 2892
+ 1549 838 2401
+ 725 1549 2667
+ 3072 706 2423
+ 2914 1550 848
+ 3128 2353 670
+ 880 1551 2108
+ 1552 3046 843
+ 2611 1552 843
+ 1012 2120 3374
+ 270 3981 2698
+ 1554 781 3379
+ 3173 1554 3366
+ 1555 2516 633
+ 851 3785 3069
+ 1556 888 3006
+ 2904 2679 1019
+ 3762 918 1941
+ 2612 3480 475
+ 1558 2427 2512
+ 1151 3562 3107
+ 2908 1582 3377
+ 1622 2873 3934
+ 1560 728 2977
+ 1833 1040 3183
+ 3970 736 3344
+ 693 1561 2666
+ 2151 2457 1070
+ 1032 1562 2721
+ 1563 513 3264
+ 1120 2674 3442
+ 2127 1564 3626
+ 1859 1156 3047
+ 3358 838 2694
+ 608 1565 607
+ 1021 2647 3566
+ 1604 854 3784
+ 3827 3208 858
+ 592 1567 3280
+ 3322 1268 3109
+ 1242 3152 2762
+ 1569 2488 812
+ 3009 1569 812
+ 3413 461 2630
+ 885 3619 2632
+ 3620 886 2631
+ 420 3414 2629
+ 2814 1572 3604
+ 1572 2962 3791
+ 2078 834 2665
+ 1573 3045 3702
+ 2077 1311 3684
+ 833 3349 2693
+ 1575 2076 3348
+ 2609 3348 832
+ 3369 906 2186
+ 1835 1059 3219
+ 3234 2117 792
+ 2990 1577 3234
+ 3216 1421 3210
+ 201 1578 2394
+ 3215 1415 3212
+ 213 2654 3739
+ 1580 123 2655
+ 1423 3217 3211
+ 1581 375 2393
+ 3213 1581 3214
+ 2968 1582 3816
+ 2911 3377 1559
+ 1583 960 2985
+ 3156 1583 843
+ 1584 690 2975
+ 765 2197 2839
+ 1585 2463 2949
+ 2481 1585 3242
+ 1586 2444 3552
+ 2734 1586 779
+ 1587 700 4025
+ 808 1587 2437
+ 1038 1599 3928
+ 1588 3035 3874
+ 1589 3114 3171
+ 939 1885 2938
+ 3984 2195 894
+ 3012 3984 894
+ 3417 1349 3360
+ 2752 1591 3864
+ 1592 907 3224
+ 1779 1592 3172
+ 1593 2737 572
+ 1610 2663 3787
+ 2079 942 2903
+ 3181 1594 3518
+ 3556 2602 470
+ 1595 2058 3321
+ 2142 959 3832
+ 2588 1596 3295
+ 1597 715 1933
+ 860 1597 2719
+ 1220 2382 3873
+ 914 2869 3907
+ 2771 1606 3822
+ 1599 2521 3928
+ 1877 758 3141
+ 254 1600 3509
+ 2989 2187 695
+ 994 2989 1539
+ 1602 2808 2945
+ 2201 2001 1058
+ 1060 1825 3198
+ 1603 2414 3570
+ 2625 1604 3784
+ 2059 945 3329
+ 1605 897 2013
+ 939 1605 1936
+ 1606 2254 533
+ 1606 3303 3822
+ 1065 1805 2668
+ 1075 1607 2819
+ 2025 2613 725
+ 605 1608 2909
+ 3229 754 2564
+ 918 3762 3508
+ 3147 1610 3787
+ 1039 2644 3674
+ 1611 502 2355
+ 856 3507 2932
+ 1612 866 3054
+ 683 1612 2689
+ 1142 2277 3332
+ 964 1613 2258
+ 3565 2896 852
+ 2151 3829 852
+ 1615 2445 3340
+ 3449 1615 3584
+ 1616 859 3042
+ 688 1616 2664
+ 2978 782 3798
+ 2335 1617 3273
+ 1961 921 2690
+ 1128 1618 2432
+ 3710 855 2892
+ 3710 1619 3983
+ 1620 2901 869
+ 2494 1620 869
+ 1621 2133 3265
+ 1621 2371 3098
+ 3144 1622 3934
+ 2254 1622 532
+ 2840 1647 3701
+ 1041 2764 1528
+ 1624 3032 3239
+ 176 4013 2570
+ 1803 2185 835
+ 1055 1625 2591
+ 1626 904 2818
+ 444 1626 2813
+ 1627 558 3525
+ 1147 2766 3788
+ 1628 723 2403
+ 880 1628 3043
+ 1629 346 347
+ 869 2901 2852
+ 1630 2453 3496
+ 1630 2981 3862
+ 3020 1631 4008
+ 1667 1027 2364
+ 1632 737 3782
+ 2308 3782 997
+ 1633 3651 2805
+ 3341 1633 3345
+ 2696 3872 1634
+ 1671 922 3872
+ 1635 509 3388
+ 2478 1635 3539
+ 1636 2900 896
+ 1398 2320 1130
+ 1637 3223 3526
+ 913 3956 3296
+ 1638 2072 3279
+ 2942 1638 3378
+ 1639 2622 806
+ 1281 3133 2454
+ 1640 733 2809
+ 872 1640 2381
+ 2713 1157 3503
+ 590 1641 3317
+ 1642 2206 2991
+ 1540 2912 1004
+ 1643 703 3196
+ 901 3897 3053
+ 1644 3083 4035
+ 250 1644 3132
+ 1008 2286 3124
+ 908 2538 1532
+ 3785 1555 3320
+ 1056 1646 2462
+ 1647 2386 524
+ 1647 3038 3701
+ 1976 904 3419
+ 2251 1036 2732
+ 938 1753 2491
+ 973 1649 2153
+ 4020 908 3612
+ 3501 1650 3528
+ 3464 765 2360
+ 3122 2501 583
+ 3658 674 3468
+ 881 2685 3427
+ 1653 2575 849
+ 2475 1653 849
+ 1654 2657 3752
+ 616 1654 3435
+ 1655 1009 1893
+ 829 1655 2002
+ 1656 51 2930
+ 2927 1656 3601
+ 1657 2929 3600
+ 50 1657 2928
+ 1658 2865 882
+ 1984 1658 3011
+ 3688 882 2838
+ 629 1659 2782
+ 3954 891 3345
+ 1974 1080 2817
+ 3960 3088 892
+ 1768 1081 3108
+ 1662 874 2972
+ 3136 1662 3145
+ 2875 1021 1483
+ 577 1663 3777
+ 1664 3891 570
+ 2737 1664 571
+ 1665 169 3750
+ 1143 1962 3162
+ 1666 727 2979
+ 903 1666 3676
+ 2364 1027 1631
+ 2512 1667 3608
+ 1668 712 3003
+ 2396 1668 2831
+ 1669 712 3385
+ 3076 1669 3285
+ 1670 3282 3397
+ 3232 1670 3274
+ 3872 922 1634
+ 2827 1671 3774
+ 1154 2013 3123
+ 3023 1672 897
+ 1673 142 2543
+ 742 1965 2890
+ 1674 991 3511
+ 3187 1674 3611
+ 3187 819 3474
+ 3760 1675 3836
+ 3428 351 2603
+ 3036 1676 3228
+ 2134 1677 2704
+ 145 1677 144
+ 2135 1143 2703
+ 3527 1678 890
+ 1679 2255 722
+ 2523 1679 722
+ 1680 3190 2601
+ 1073 1680 2193
+ 3353 989 3813
+ 1289 3512 3456
+ 1682 3257 3455
+ 2759 1682 3352
+ 1683 824 2715
+ 2375 1683 655
+ 2588 825 3195
+ 173 1684 3406
+ 1685 1284 3281
+ 868 1685 3288
+ 3111 1686 3869
+ 980 1686 2386
+ 1687 652 2472
+ 2916 1687 872
+ 1688 3341 891
+ 2064 714 3052
+ 2397 1175 3063
+ 3403 1689 3063
+ 1690 711 3315
+ 3088 1690 3687
+ 1691 3676 3885
+ 3676 1691 3696
+ 1821 896 3010
+ 2763 1692 646
+ 1130 2763 3667
+ 2634 1693 3319
+ 1694 152 2758
+ 147 1694 2790
+ 2768 163 164
+ 2318 1158 2791
+ 1696 2786 257
+ 1249 1696 3192
+ 1056 2462 3073
+ 901 2092 3366
+ 987 1826 3028
+ 3102 1698 3028
+ 2914 848 2842
+ 692 1699 2470
+ 1700 190 2546
+ 1024 1700 2292
+ 2196 2510 1034
+ 3469 1701 3135
+ 1702 719 3769
+ 872 2465 2916
+ 1703 2762 662
+ 2326 1703 662
+ 3807 1466 2983
+ 953 3807 1814
+ 3072 1550 1048
+ 3161 1389 3742
+ 1706 1210 2605
+ 667 1706 3637
+ 3117 893 3948
+ 3278 1707 3786
+ 1708 497 2474
+ 1614 3596 3565
+ 1709 750 2514
+ 2188 1709 3918
+ 1710 699 3175
+ 898 1710 2744
+ 2150 1040 2304
+ 2485 1711 3002
+ 1712 2709 2999
+ 682 1712 2552
+ 1713 224 2537
+ 1042 1713 2336
+ 1714 315 2536
+ 1044 1714 2337
+ 1715 156 157
+ 890 1715 2712
+ 1716 3008 857
+ 2376 1716 857
+ 1717 2202 922
+ 1341 1717 4001
+ 1718 2720 2995
+ 687 1718 2547
+ 1719 268 3446
+ 3079 1719 3115
+ 3537 889 2749
+ 3227 1720 155
+ 1721 2735 880
+ 2108 1829 880
+ 1817 929 3409
+ 898 1722 3018
+ 3745 2131 93
+ 95 3746 3593
+ 1724 949 3106
+ 366 1724 2390
+ 3853 1360 2870
+ 2404 2695 3860
+ 1726 673 2714
+ 2639 1726 3843
+ 1727 3010 896
+ 1037 1727 2900
+ 1728 3884 713
+ 868 2701 3222
+ 1729 1114 2107
+ 957 1729 2775
+ 1730 2704 889
+ 3537 1730 889
+ 1731 2730 293
+ 1510 1731 3357
+ 3921 709 3281
+ 2852 1732 3313
+ 1733 734 2201
+ 935 1733 3372
+ 1734 1765 909
+ 1201 3252 2271
+ 1735 1003 3023
+ 2952 653 3670
+ 1736 872 2381
+ 1104 1736 2181
+ 694 2323 2976
+ 3247 1737 3713
+ 1738 2422 67
+ 2017 1067 2545
+ 1072 1774 3330
+ 710 1739 2021
+ 1740 1120 2793
+ 700 3450 2309
+ 1741 903 3676
+ 916 2977 3695
+ 2576 730 2765
+ 2706 1742 3714
+ 1743 2783 34
+ 3582 1743 381
+ 2926 917 3321
+ 993 1744 3681
+ 1745 3162 741
+ 890 1745 2923
+ 2531 809 3937
+ 19 1746 3660
+ 2669 1747 3975
+ 2553 1747 20
+ 2609 832 3462
+ 135 1748 3546
+ 934 1806 2812
+ 3031 3965 75
+ 1750 1915 883
+ 3898 1750 3066
+ 1751 309 2528
+ 2417 1751 1085
+ 1752 230 2955
+ 2416 1752 1086
+ 3968 3031 76
+ 938 2491 3339
+ 1195 2333 2906
+ 768 1754 2090
+ 1755 104 2953
+ 1093 1755 2421
+ 1756 218 2527
+ 2420 1756 1091
+ 1757 501 3751
+ 2680 1757 3507
+ 1137 1884 3740
+ 964 3180 1613
+ 1759 716 3191
+ 2887 1759 3407
+ 2043 3517 910
+ 2272 1760 910
+ 1761 139 3524
+ 833 2693 3659
+ 1762 1057 3099
+ 2026 1762 741
+ 1763 1034 3097
+ 753 1763 2828
+ 2481 1764 3535
+ 3497 1764 3833
+ 1765 1734 1028
+ 3471 1765 654
+ 1766 2170 2595
+ 715 1766 3520
+ 1767 2794 3771
+ 1132 2965 1405
+ 3108 1081 1661
+ 1688 2746 1285
+ 2867 1436 2344
+ 3100 2351 792
+ 2471 1410 3910
+ 3387 2567 870
+ 2467 3284 788
+ 272 1771 2256
+ 2241 4015 967
+ 1223 1772 3021
+ 1773 2330 898
+ 627 1773 3475
+ 1774 362 2030
+ 1072 3330 1739
+ 1775 2441 450
+ 2407 1775 451
+ 1776 2237 2848
+ 2525 1776 3484
+ 1777 2581 467
+ 893 1777 3948
+ 1778 2263 2832
+ 713 1778 2935
+ 1779 841 1592
+ 701 1779 3172
+ 1780 884 3068
+ 2589 1780 739
+ 1781 3057 3158
+ 3894 2158 958
+ 1782 266 3040
+ 1782 3130 3351
+ 3018 1722 1168
+ 626 1783 3536
+ 1287 2781 3544
+ 1643 1784 1056
+ 3450 1120 1740
+ 2329 1785 700
+ 1786 958 2076
+ 959 1786 2077
+ 738 2088 3795
+ 997 1787 1930
+ 1788 86 2312
+ 2436 1788 1062
+ 3858 1744 993
+ 1518 3297 993
+ 1790 895 3598
+ 1053 1790 3055
+ 1791 1854 3814
+ 422 1791 2616
+ 3812 1001 1853
+ 1840 1118 2615
+ 1793 1229 1567
+ 3432 1793 3743
+ 2396 799 3607
+ 364 1794 3392
+ 1795 1106 2346
+ 658 1795 3465
+ 3979 845 3334
+ 1796 2324 3576
+ 1797 3434 3978
+ 913 2147 3255
+ 1798 549 3044
+ 2958 1798 3538
+ 1799 711 2148
+ 936 1980 3571
+ 936 1876 3502
+ 3000 1800 286
+ 1801 2861 886
+ 1841 1119 2880
+ 1802 2380 698
+ 1157 3484 1776
+ 3075 507 2910
+ 1625 1803 835
+ 1804 3021 818
+ 1037 3714 1742
+ 1805 704 3188
+ 834 3251 2665
+ 1121 2343 3893
+ 934 2812 1749
+ 1807 18 2940
+ 1807 2199 3061
+ 1808 236 2645
+ 957 1808 3205
+ 1809 947 3926
+ 1354 2917 3630
+ 1810 246 3269
+ 3071 1247 4024
+ 1811 3268 261
+ 3271 1811 262
+ 3471 995 1451
+ 2548 1812 3969
+ 1813 1263 3514
+ 2126 4033 1352
+ 1814 3019 1217
+ 817 1814 3941
+ 2085 985 2331
+ 2000 1815 29
+ 1816 2407 43
+ 2581 1816 466
+ 3370 1449 929
+ 1722 1817 1168
+ 2155 925 3622
+ 2269 1161 2885
+ 1819 1160 2754
+ 924 2154 3621
+ 1820 2513 1172
+ 734 1820 2201
+ 1821 2899 644
+ 1692 1821 3992
+ 1822 733 2192
+ 3627 1822 919
+ 1823 2626 678
+ 923 1823 3515
+ 1824 1171 3693
+ 899 3459 1464
+ 3198 1603 1060
+ 919 3904 3627
+ 1826 987 2503
+ 3361 1826 661
+ 1827 674 2535
+ 792 2117 3878
+ 3339 1649 973
+ 2739 1828 973
+ 1829 1721 880
+ 618 1829 2741
+ 1830 1382 3276
+ 1468 1830 3231
+ 3030 1831 3543
+ 3662 3350 1831
+ 2225 745 3347
+ 595 1832 3209
+ 3183 1040 3491
+ 1222 3657 2442
+ 2748 3908 1006
+ 706 1834 2931
+ 3219 1059 3486
+ 2204 1835 3955
+ 1836 60 2742
+ 789 2656 3161
+ 1837 986 1915
+ 597 1837 3806
+ 1838 1942 873
+ 2593 769 3857
+ 1839 874 1943
+ 770 1839 2213
+ 1840 460 3413
+ 2794 1840 3619
+ 1841 2880 3620
+ 421 1841 3414
+ 1842 3926 4011
+ 1018 2333 3318
+ 1843 184 2583
+ 2152 1843 1023
+ 1844 137 2500
+ 1064 1844 2098
+ 1845 2150 666
+ 2214 2438 1226
+ 1846 3076 3775
+ 333 1846 3500
+ 3409 1168 1817
+ 3971 2253 929
+ 1848 3449 3946
+ 805 2237 3447
+ 3591 1496 1050
+ 1229 1849 3208
+ 1850 2368 1084
+ 2969 3890 760
+ 4018 762 2961
+ 816 1851 3880
+ 1852 946 1746
+ 19 1852 1746
+ 1853 1001 3022
+ 1792 1853 458
+ 1854 1002 3814
+ 423 1854 1791
+ 3698 283 2939
+ 3306 1855 3960
+ 1856 3661 1052
+ 174 1856 2372
+ 1857 675 3856
+ 854 2299 1402
+ 1858 990 2377
+ 1307 1858 3272
+ 1859 2 2483
+ 1156 1859 3253
+ 1860 3755 906
+ 1576 1860 906
+ 2757 703 1643
+ 3366 1861 901
+ 3490 1818 1161
+ 430 1862 3375
+ 1863 434 2913
+ 1819 3489 1160
+ 1864 360 2482
+ 1323 2507 3839
+ 1865 1706 970
+ 1169 1865 2902
+ 1866 902 3063
+ 743 1866 2152
+ 1867 664 2650
+ 1316 4010 2475
+ 1868 3155 401
+ 1010 2289 1498
+ 2288 1011 1499
+ 3154 1869 384
+ 1870 983 1952
+ 701 1870 2505
+ 1871 937 3105
+ 3386 1871 3780
+ 1872 961 3009
+ 987 1872 2707
+ 1873 694 2209
+ 2313 3160 837
+ 1874 3419 904
+ 3233 1874 904
+ 1875 504 2606
+ 2221 1875 1055
+ 3502 1800 936
+ 3789 1876 936
+ 3141 1212 3882
+ 921 1877 3975
+ 3064 1479 2863
+ 1136 1878 2384
+ 1879 3855 953
+ 1879 2167 3139
+ 1880 905 1545
+ 2716 1880 38
+ 1881 958 1786
+ 959 1881 1786
+ 1882 1872 987
+ 1698 1882 987
+ 1883 1234 3225
+ 1376 3790 3545
+ 3740 1758 1137
+ 790 2487 3703
+ 1885 727 1589
+ 1199 1885 1589
+ 1886 1576 3369
+ 3763 3112 915
+ 3093 993 3681
+ 926 1887 3999
+ 3996 878 3400
+ 1888 2061 3765
+ 1889 1733 1058
+ 2757 1325 3805
+ 3207 693 3931
+ 1097 1890 1552
+ 2493 1018 3318
+ 1754 3592 1195
+ 1892 721 2926
+ 918 1892 3613
+ 1893 3917 2894
+ 1655 1893 3845
+ 1894 3862 667
+ 942 1894 3758
+ 1895 1524 3283
+ 1520 1895 3261
+ 1896 1197 2137
+ 2473 1896 734
+ 1146 2569 2821
+ 395 1897 3077
+ 1898 238 3312
+ 809 2769 3821
+ 3236 3769 719
+ 1555 3220 1061
+ 1900 1409 2854
+ 1083 2075 1959
+ 1901 463 3439
+ 1010 1901 3842
+ 2629 1571 1011
+ 3438 1902 3841
+ 1903 865 3118
+ 3033 1903 3196
+ 1904 499 2683
+ 2255 1904 1079
+ 1905 492 3683
+ 806 2622 4003
+ 1906 3647 1031
+ 1515 2966 801
+ 2966 1906 1031
+ 1177 1907 2705
+ 1908 1133 3577
+ 3347 1908 3454
+ 1909 829 3177
+ 1009 1909 3951
+ 1910 2486 771
+ 2373 1910 771
+ 1911 913 1392
+ 775 1911 2642
+ 1912 1045 2366
+ 2264 1296 3919
+ 1913 816 3920
+ 746 4031 2822
+ 1914 1445 3694
+ 1234 1914 3376
+ 1915 986 3102
+ 992 1915 1750
+ 1916 2716 405
+ 2577 1916 406
+ 1917 3506 3966
+ 3532 1450 3870
+ 1918 186 3290
+ 814 2362 1342
+ 2643 1115 3886
+ 1449 1919 929
+ 2554 1700 1024
+ 1342 2363 814
+ 1921 3994 3441
+ 787 1921 3140
+ 1922 3089 944
+ 3939 2383 944
+ 1923 1236 1753
+ 3129 1923 938
+ 1924 3585 3984
+ 64 1924 3051
+ 1925 26 2846
+ 783 2170 3061
+ 2574 2387 1233
+ 1892 1926 721
+ 1927 3027 4036
+ 651 2618 3181
+ 1928 192 3302
+ 817 2370 1347
+ 1929 817 3603
+ 3715 1929 3410
+ 1930 2466 679
+ 997 1930 2308
+ 2958 827 3818
+ 40 1931 3309
+ 1932 1522 3308
+ 2275 1183 3314
+ 3520 1766 1145
+ 948 1933 3444
+ 1934 3904 919
+ 2951 1934 919
+ 2356 1935 2829
+ 656 1935 3995
+ 1936 1605 685
+ 1533 3443 3113
+ 1937 943 3070
+ 335 1937 3974
+ 2753 684 3189
+ 1412 1938 823
+ 1939 2382 3956
+ 1329 1939 1911
+ 3235 1545 905
+ 773 1940 3557
+ 1941 918 3613
+ 3480 1941 474
+ 3466 996 1384
+ 999 1942 1838
+ 1943 996 2113
+ 1839 1943 1000
+ 1944 226 3292
+ 1043 1944 2367
+ 1945 317 3291
+ 1045 1945 2366
+ 1946 998 2859
+ 2149 1291 3575
+ 1947 2903 942
+ 3190 1947 942
+ 1238 2701 3982
+ 355 1948 4016
+ 1949 3959 932
+ 1111 1949 3030
+ 1950 328 3127
+ 1022 1950 3437
+ 2496 1264 3331
+ 691 1951 3685
+ 3767 983 1536
+ 1017 1952 2399
+ 1953 949 2682
+ 1668 1953 712
+ 1954 2506 1076
+ 1077 1954 2159
+ 1955 2190 928
+ 2301 1955 3697
+ 2555 1713 1042
+ 1400 2557 839
+ 2556 1714 1044
+ 1401 2558 840
+ 3542 744 2777
+ 814 1958 2389
+ 2891 3639 1083
+ 941 1959 2075
+ 1960 814 2389
+ 3241 1960 3324
+ 2690 1107 1618
+ 707 1961 1618
+ 4037 1966 1127
+ 1665 1962 1143
+ 2278 1052 3661
+ 4026 2760 826
+ 1964 3118 865
+ 1702 1964 1123
+ 1965 968 1673
+ 1144 1965 1673
+ 4037 966 3460
+ 1127 1966 2114
+ 1148 2473 3645
+ 3137 1967 3618
+ 2314 1054 1816
+ 2605 1968 780
+ 1969 1122 2163
+ 1969 3483 3977
+ 2807 1661 1081
+ 3299 1970 2972
+ 3794 979 1547
+ 3323 1971 3903
+ 1972 912 1987
+ 662 1972 3513
+ 1973 1372 2660
+ 1318 2845 2532
+ 2817 1080 1660
+ 2284 1256 3440
+ 3900 1483 1021
+ 1404 1975 2511
+ 1976 1648 904
+ 487 1976 3085
+ 2874 1304 2547
+ 1367 1977 2687
+ 1978 2595 783
+ 932 1978 3662
+ 1979 1368 2673
+ 1260 2961 2582
+ 2341 1799 3571
+ 1230 1980 1800
+ 1981 319 2997
+ 1343 1981 2368
+ 1982 228 2549
+ 1344 1982 2369
+ 2878 1303 2552
+ 1373 1983 2670
+ 3236 1061 1899
+ 1213 1984 3011
+ 1985 3394 747
+ 2664 2823 1296
+ 2822 1297 2689
+ 1327 1986 2378
+ 1987 3417 729
+ 1972 1987 1253
+ 1988 760 3792
+ 1090 1988 2649
+ 1989 279 3005
+ 1334 1989 2539
+ 3558 515 3436
+ 3574 1990 804
+ 1991 839 2305
+ 763 3478 2878
+ 1992 290 3078
+ 1548 1992 3553
+ 3548 2121 788
+ 2743 1993 1097
+ 1994 1085 2560
+ 2306 1994 840
+ 1995 311 3522
+ 1085 1995 2560
+ 1996 3358 3932
+ 1502 3381 1226
+ 1997 220 3521
+ 1091 1997 2559
+ 1998 718 1484
+ 1174 3105 1484
+ 1999 742 2406
+ 1762 4017 1057
+ 2000 277 3266
+ 1066 2000 2620
+ 2001 1903 1058
+ 1602 2001 1172
+ 2002 1655 3802
+ 829 2002 3517
+ 3325 1185 2023
+ 2003 3089 4009
+ 3820 1907 1031
+ 1193 2596 2450
+ 2005 2577 407
+ 2608 2005 408
+ 2006 960 2007
+ 758 2006 2455
+ 2007 1111 2006
+ 1583 2007 960
+ 2008 3451 926
+ 2662 2008 926
+ 2009 1397 691
+ 1435 2565 1139
+ 2010 2871 1289
+ 800 2010 3294
+ 2011 3569 941
+ 826 2011 3057
+ 2012 972 3343
+ 356 2012 2941
+ 2013 1154 1514
+ 1605 3170 685
+ 2014 925 1538
+ 1271 2948 3059
+ 2164 978 3103
+ 977 2015 3824
+ 2016 909 3901
+ 995 3202 1451
+ 2545 1067 1738
+ 3516 2017 70
+ 2018 3204 665
+ 920 2018 1460
+ 2019 3398 950
+ 3932 2580 950
+ 2020 2970 1008
+ 2020 3104 4020
+ 2021 3257 710
+ 971 2021 1739
+ 2022 862 2143
+ 943 3938 3193
+ 3939 944 3325
+ 861 2023 2144
+ 2024 32 3082
+ 3634 2024 3863
+ 2613 2025 3609
+ 977 2025 3237
+ 2026 741 2332
+ 981 2026 3808
+ 2027 2464 1053
+ 1501 3399 3068
+ 2028 1170 3386
+ 2952 2028 653
+ 2745 2029 3673
+ 3476 2029 414
+ 2030 362 363
+ 971 2030 3748
+ 1178 2656 3689
+ 878 2031 3400
+ 2032 3381 950
+ 3305 2032 3398
+ 2033 126 3722
+ 195 2798 3737
+ 2802 3734 117
+ 203 2034 3848
+ 2035 3723 115
+ 3734 2035 116
+ 2036 212 3739
+ 3720 2803 110
+ 2037 3724 113
+ 3723 2037 114
+ 2038 3720 111
+ 3724 2038 112
+ 2039 307 3730
+ 3732 2801 232
+ 2040 3732 233
+ 3725 2040 234
+ 2041 128 3721
+ 193 2796 3738
+ 2042 2870 931
+ 1444 2042 3420
+ 2043 380 3203
+ 1760 2043 910
+ 2044 664 3772
+ 930 2044 1356
+ 2045 780 3803
+ 695 2187 1346
+ 2675 2046 3586
+ 2046 2118 3523
+ 2047 1414 3819
+ 3207 2047 693
+ 3415 2048 3551
+ 3514 2048 784
+ 2049 930 1356
+ 2517 2049 777
+ 3408 764 2845
+ 845 2050 3334
+ 3867 1984 1213
+ 55 2051 3058
+ 2052 1314 2640
+ 1241 2772 2678
+ 2053 171 3967
+ 966 2053 3460
+ 2054 1385 3961
+ 975 2054 3458
+ 2055 3775 877
+ 1022 3781 1813
+ 2208 1954 1077
+ 2825 2439 1077
+ 2057 940 4002
+ 546 2057 3998
+ 2058 3556 471
+ 2761 2058 472
+ 3329 945 1604
+ 2501 2059 582
+ 2060 2331 985
+ 2519 2060 985
+ 2061 692 3871
+ 920 2061 2738
+ 2062 2384 753
+ 2828 2062 753
+ 3242 1585 2949
+ 967 2063 2614
+ 2064 3136 714
+ 1080 2064 3052
+ 3757 1673 968
+ 3977 2065 968
+ 2066 2553 20
+ 2786 2066 256
+ 2067 41 2779
+ 3305 2325 757
+ 3193 2022 1186
+ 1669 2068 712
+ 2069 2238 1020
+ 3553 855 3700
+ 2070 274 3243
+ 962 2070 2805
+ 2071 2102 1160
+ 1863 2913 1160
+ 2072 1638 962
+ 2080 2072 962
+ 1042 2336 3638
+ 839 2073 2305
+ 2558 1957 1044
+ 1328 2074 3394
+ 2075 1900 737
+ 941 2075 1632
+ 2076 1310 3348
+ 1786 2076 735
+ 2077 1786 735
+ 1311 2077 3349
+ 3641 3260 519
+ 1573 2078 3641
+ 2079 1894 942
+ 1594 2903 1222
+ 2080 1131 2072
+ 2805 2080 962
+ 2115 986 2957
+ 978 2081 3766
+ 3355 1564 3047
+ 756 2082 2696
+ 2083 756 1634
+ 922 2083 1634
+ 2084 3029 369
+ 1098 2084 2635
+ 2085 1815 985
+ 29 2085 3504
+ 2086 3868 952
+ 1466 2086 952
+ 2087 990 2973
+ 728 2217 4021
+ 2088 1547 979
+ 3795 2088 979
+ 2089 791 3494
+ 2303 2089 1028
+ 2090 3914 934
+ 1236 2090 1749
+ 3808 2026 1127
+ 2163 1122 3148
+ 2092 3796 638
+ 3300 2092 639
+ 2093 917 3858
+ 740 2093 1789
+ 2094 58 2723
+ 1491 2094 2780
+ 2095 3540 301
+ 3354 2095 302
+ 2680 856 3563
+ 722 2096 3564
+ 2097 928 3173
+ 641 2097 640
+ 2098 1095 3761
+ 1064 2098 3578
+ 2099 3000 287
+ 1020 2518 3700
+ 2100 949 1724
+ 367 2100 1724
+ 2101 3011 3688
+ 630 2101 1659
+ 2102 3445 390
+ 2754 2102 391
+ 3137 1275 2659
+ 1387 2706 818
+ 2104 2122 1078
+ 736 2104 3230
+ 2919 1202 3972
+ 809 2105 3937
+ 2106 963 3633
+ 240 2106 239
+ 2107 1345 3094
+ 1898 2769 1114
+ 2108 1150 1829
+ 1341 2108 3128
+ 2109 2455 3559
+ 1212 3678 1852
+ 2110 541 542
+ 933 2110 3597
+ 2111 1942 999
+ 2889 2111 999
+ 2112 924 3621
+ 786 2112 2821
+ 2113 996 2111
+ 1000 2113 2888
+ 2114 1966 825
+ 2572 2114 3254
+ 2115 720 1698
+ 986 2115 3102
+ 2116 798 3976
+ 2636 2116 911
+ 2117 1577 974
+ 1827 2117 974
+ 2118 1014 1471
+ 2046 3523 955
+ 2119 1589 727
+ 1099 2119 3482
+ 2120 2432 771
+ 1012 3374 1553
+ 3548 1993 1128
+ 2120 2121 1128
+ 2122 292 2730
+ 1194 2122 2104
+ 2123 409 410
+ 991 2123 3511
+ 2124 2957 986
+ 1837 3333 986
+ 2125 1891 1195
+ 1051 3573 1477
+ 2126 1022 4033
+ 327 2126 326
+ 2127 3165 83
+ 3916 2127 84
+ 2128 1062 3840
+ 3434 2128 846
+ 3941 1814 1217
+ 3658 2129 674
+ 2130 794 1396
+ 933 2130 2169
+ 2131 3567 92
+ 955 2131 1723
+ 2132 1472 955
+ 1723 2132 955
+ 2133 790 3703
+ 3265 2133 1243
+ 2134 144 1677
+ 889 2704 1677
+ 2135 168 2524
+ 1678 2703 890
+ 3383 1779 1276
+ 973 2136 2739
+ 2137 930 1820
+ 1896 2137 734
+ 2138 1139 2431
+ 1217 2688 2535
+ 2139 984 1526
+ 669 2139 1526
+ 2140 931 3876
+ 2628 2140 760
+ 2141 979 3323
+ 2921 2141 832
+ 2142 732 1881
+ 959 2142 1881
+ 2143 1186 2022
+ 3455 2143 862
+ 2144 3456 861
+ 1185 2144 2023
+ 3766 2081 1312
+ 600 2145 3418
+ 2146 584 585
+ 927 2146 4038
+ 3255 3978 1392
+ 3296 2147 913
+ 2148 1690 1182
+ 1799 2148 936
+ 3575 1291 1946
+ 1126 2530 1916
+ 2150 1845 1040
+ 1711 2150 1224
+ 2151 1562 1280
+ 1614 3829 1070
+ 2152 1866 1175
+ 1843 2152 1175
+ 2153 1649 79
+ 973 2153 3838
+ 2154 3952 393
+ 3077 2154 394
+ 2155 1818 925
+ 483 2155 3479
+ 2156 1006 3908
+ 3201 684 3389
+ 2157 716 1759
+ 1121 3016 1759
+ 2158 1781 679
+ 2158 3533 3610
+ 2159 1954 1076
+ 2439 2825 1244
+ 2160 275 3815
+ 3345 2160 3954
+ 2161 1227 3346
+ 2434 2161 893
+ 2162 996 1943
+ 874 2162 1943
+ 3148 680 3690
+ 1969 2163 833
+ 2164 803 3605
+ 978 2164 3163
+ 2208 2056 1063
+ 2300 2323 694
+ 2166 1066 2620
+ 2717 3770 1434
+ 2167 1879 953
+ 2562 2167 953
+ 2168 963 3895
+ 2638 3083 1644
+ 2169 2130 1396
+ 3888 2169 677
+ 2170 1766 956
+ 1925 2170 956
+ 2171 3079 887
+ 821 2171 3096
+ 2172 1441 4002
+ 2257 2172 940
+ 2173 1039 2851
+ 2889 2173 671
+ 2174 656 1569
+ 961 2174 3009
+ 3230 2175 3950
+ 1731 3384 1078
+ 3812 1792 1118
+ 749 2176 3092
+ 2177 750 3915
+ 1791 3814 1119
+ 2178 755 2456
+ 1738 2178 1068
+ 2179 3390 740
+ 1007 2179 1518
+ 2180 3454 923
+ 1793 3432 923
+ 2181 1736 699
+ 882 2865 1486
+ 2182 806 2457
+ 990 2182 2377
+ 2183 985 1815
+ 1066 2183 1815
+ 2184 2054 975
+ 1497 2184 975
+ 2185 1242 1703
+ 1113 2185 1803
+ 2186 915 1886
+ 1397 2186 1951
+ 2187 2045 1346
+ 970 2187 1601
+ 2188 1155 1709
+ 829 3918 3177
+ 2189 785 2992
+ 2849 2918 767
+ 2190 781 1554
+ 928 2190 3173
+ 1132 2479 2897
+ 749 2191 2447
+ 2951 2472 1232
+ 1822 2192 919
+ 2193 1680 1169
+ 778 2193 2902
+ 2207 736 2346
+ 843 2194 3156
+ 2195 1068 2456
+ 894 2195 3497
+ 2196 1701 785
+ 1196 2196 2189
+ 2197 765 3464
+ 1584 2197 927
+ 2198 1225 3677
+ 3998 2198 545
+ 3061 1203 1807
+ 957 2199 1807
+ 2200 3138 46
+ 3837 2200 455
+ 2201 1172 2001
+ 1733 2201 1058
+ 2202 1306 2083
+ 922 2202 2083
+ 2203 779 2778
+ 766 2506 1954
+ 2204 3955 997
+ 737 2204 3782
+ 2205 695 3452
+ 2179 2205 1237
+ 2206 1251 2991
+ 795 2206 1642
+ 2207 1105 3344
+ 2194 2207 1106
+ 2208 1077 2056
+ 2165 2208 1063
+ 2209 3247 1363
+ 1047 2209 2453
+ 2210 321 3101
+ 1084 2210 2628
+ 2211 999 1838
+ 1124 2211 3110
+ 2212 1652 1163
+ 1313 2777 2714
+ 2815 1269 2357
+ 770 2213 2402
+ 2214 1226 2032
+ 1016 2214 3142
+ 2215 729 3248
+ 911 2215 3541
+ 2216 1017 2399
+ 717 2216 2398
+ 2963 1281 2087
+ 1560 2217 728
+ 2218 45 3479
+ 786 2569 3797
+ 2219 35 3166
+ 2446 2479 1173
+ 2220 1026 2285
+ 718 2220 1484
+ 2221 1153 1875
+ 1507 3909 1055
+ 2222 946 3559
+ 3094 2222 708
+ 2223 988 3402
+ 353 2223 36
+ 2224 989 3352
+ 340 2224 339
+ 2225 1832 992
+ 745 2225 3898
+ 2226 2461 1015
+ 99 2226 2425
+ 2227 1320 3493
+ 2424 2227 90
+ 2228 959 3684
+ 3254 2228 680
+ 2229 810 2830
+ 2416 1086 3912
+ 1088 2417 3913
+ 810 2230 2830
+ 2231 1403 3354
+ 956 2231 1925
+ 2232 811 2826
+ 2421 1094 3906
+ 1092 2420 3905
+ 811 2233 2826
+ 2234 935 3372
+ 3655 2234 781
+ 2235 755 2534
+ 951 2235 3448
+ 2236 446 3416
+ 1626 3233 904
+ 3447 1848 1193
+ 965 2237 1776
+ 3809 1230 2099
+ 1181 2238 2069
+ 2239 977 3824
+ 603 2239 3411
+ 2240 447 2520
+ 2526 2240 1165
+ 2241 967 1772
+ 739 2241 1772
+ 2242 1003 1735
+ 653 2242 1735
+ 2243 28 3396
+ 1103 2243 2691
+ 2956 1751 1088
+ 3929 2833 810
+ 2245 15 2946
+ 810 2834 3929
+ 2246 1288 2021
+ 971 2246 2021
+ 2954 1756 1092
+ 1257 2836 3924
+ 2248 7 3232
+ 811 2835 3924
+ 2249 2380 1050
+ 1496 2249 1050
+ 2250 794 2658
+ 1220 2250 3223
+ 2732 1036 1648
+ 2731 1266 3628
+ 3065 1386 1003
+ 1174 2252 2242
+ 2253 1847 929
+ 623 2253 3892
+ 2254 532 533
+ 976 2254 1606
+ 2255 1079 2096
+ 722 2255 2096
+ 2256 1771 1012
+ 1553 2256 1012
+ 2257 1541 676
+ 2172 2257 1290
+ 2258 3332 773
+ 964 2258 2309
+ 2259 3531 867
+ 748 2259 2436
+ 2260 1004 1642
+ 3704 2260 656
+ 2261 3149 974
+ 1577 3060 974
+ 3071 822 4032
+ 241 2262 1433
+ 2263 3839 800
+ 972 2263 1778
+ 3919 1296 4030
+ 1259 3879 1850
+ 3880 1851 1260
+ 1297 2265 3835
+ 2266 1758 964
+ 1740 2266 964
+ 2267 1680 1073
+ 3002 2433 795
+ 3256 3338 2268
+ 2349 2268 1030
+ 2885 1161 1818
+ 2774 2269 52
+ 2270 1158 2712
+ 157 2270 1715
+ 1201 2809 3252
+ 1231 2271 3616
+ 2272 1200 1760
+ 2497 2272 910
+ 2273 772 3022
+ 1141 2273 2853
+ 2274 3849 325
+ 1544 2274 31
+ 2275 442 3336
+ 1183 2275 2731
+ 2276 2338 1122
+ 1965 3826 968
+ 2277 1002 3025
+ 1142 3332 3692
+ 2278 1596 1052
+ 1963 3661 1112
+ 2279 154 1720
+ 1159 2279 2749
+ 2851 671 2173
+ 3510 864 3674
+ 2281 358 3393
+ 2012 2281 972
+ 2282 434 1863
+ 924 2282 1863
+ 4022 2186 1397
+ 842 2283 3883
+ 2284 179 2844
+ 2593 2284 1135
+ 2285 1026 3499
+ 3176 2285 798
+ 2286 1510 295
+ 1008 3124 1645
+ 2287 1482 769
+ 902 2287 3403
+ 2288 3582 382
+ 1869 2288 383
+ 2289 1868 402
+ 3583 2289 403
+ 2290 2403 723
+ 995 2290 3902
+ 2291 899 3560
+ 1395 2291 698
+ 2292 1700 1025
+ 3410 744 3715
+ 2293 1508 1004
+ 1370 2293 2260
+ 2294 1518 993
+ 661 2294 3093
+ 2295 978 2145
+ 601 2295 2145
+ 3304 1146 1897
+ 3922 2296 397
+ 2297 1008 2970
+ 860 2297 1597
+ 2298 3164 724
+ 1046 2298 1461
+ 2299 854 1604
+ 1857 2299 945
+ 2323 1167 2165
+ 1204 2300 1873
+ 2301 730 1955
+ 1463 2301 3697
+ 2302 4 2428
+ 1527 2302 3245
+ 3412 733 1822
+ 1060 2303 1822
+ 2304 1040 1833
+ 726 2304 1833
+ 2305 1327 4005
+ 1991 2305 1303
+ 2306 2074 1328
+ 3930 2306 4004
+ 2307 6 4023
+ 845 3221 3653
+ 3158 1930 679
+ 1632 2308 1211
+ 2309 2258 1335
+ 700 2309 4025
+ 2310 995 3902
+ 751 2310 3370
+ 3811 2009 1435
+ 731 2637 3298
+ 2312 3004 3682
+ 1788 2312 1062
+ 2313 3250 1204
+ 1873 3160 1204
+ 2314 780 1968
+ 1054 2314 1968
+ 2813 2818 1036
+ 1266 2315 2251
+ 2316 672 3169
+ 1482 2316 3110
+ 2317 2548 797
+ 1005 2317 3980
+ 2318 166 1678
+ 1158 2318 3527
+ 2319 1159 3579
+ 145 2319 1677
+ 2320 1398 3189
+ 896 2320 1636
+ 2321 709 2621
+ 988 2321 3402
+ 2322 1205 3099
+ 3227 11 3307
+ 2323 2300 1167
+ 1063 2323 2165
+ 2324 1796 677
+ 914 2324 2692
+ 2325 1261 2067
+ 1109 2325 2067
+ 2326 1026 1703
+ 3513 2326 662
+ 2327 1494 937
+ 2733 2327 937
+ 2872 2837 1252
+ 807 2328 2529
+ 2329 998 1785
+ 1587 2329 700
+ 2330 1773 1164
+ 3498 2330 1486
+ 3921 2060 709
+ 1191 2331 1732
+ 4037 1962 966
+ 2026 2332 1127
+ 2333 1842 716
+ 1195 2906 1754
+ 2334 1298 2084
+ 1352 3116 2599
+ 2335 669 1617
+ 912 2335 3273
+ 2336 1713 1043
+ 1913 3589 1043
+ 2337 1714 1045
+ 1912 3590 1045
+ 2338 2276 742
+ 981 2338 1999
+ 2339 1246 3056
+ 62 2339 3654
+ 2943 3327 828
+ 48 2340 2731
+ 2341 1980 759
+ 1131 2341 3259
+ 2342 3673 982
+ 3552 2342 982
+ 3893 1806 1121
+ 1485 2343 1121
+ 2344 1542 969
+ 2867 2344 969
+ 2345 2139 1268
+ 796 2345 3322
+ 2346 1357 3062
+ 2207 2346 1106
+ 2810 1614 1070
+ 1469 2347 1070
+ 2348 1099 3482
+ 903 2348 1666
+ 2349 1350 2268
+ 1361 2349 4034
+ 2350 3552 982
+ 1308 2350 3889
+ 2351 969 1459
+ 1769 3100 1139
+ 2352 1124 3169
+ 3793 2352 863
+ 2353 1005 3980
+ 670 2353 3457
+ 3240 975 3458
+ 614 2354 613
+ 2355 503 1875
+ 1153 2355 1875
+ 2356 778 2361
+ 994 2356 1601
+ 2357 1125 2815
+ 2280 2357 1269
+ 2358 927 4038
+ 813 2358 3973
+ 2359 1131 3259
+ 875 2359 2661
+ 2360 1333 3365
+ 1651 2360 945
+ 2361 970 1601
+ 2356 2361 1601
+ 2362 1918 1342
+ 1960 2362 814
+ 2363 1958 814
+ 1920 2363 1342
+ 2364 1631 568
+ 1667 2364 569
+ 2365 969 1542
+ 561 3473 1542
+ 2366 1945 1343
+ 1912 2366 815
+ 2367 1944 1344
+ 1913 2367 816
+ 2368 1981 1084
+ 815 2368 1850
+ 2369 1982 1087
+ 816 2369 1851
+ 2370 1928 1347
+ 1929 2370 817
+ 2371 1621 517
+ 3260 2371 518
+ 2372 1052 1684
+ 173 2372 1684
+ 2373 1107 2553
+ 1910 2373 1272
+ 2374 2638 251
+ 3660 2374 19
+ 2375 1138 1683
+ 1387 2375 655
+ 2376 1032 2523
+ 3114 2376 857
+ 2377 2182 1280
+ 1858 2377 668
+ 2378 3581 1488
+ 682 2378 2504
+ 2379 1328 1985
+ 1476 2379 3550
+ 2380 1395 698
+ 1050 2380 1802
+ 2381 1640 1201
+ 1736 3049 699
+ 2382 1637 3956
+ 657 2382 1939
+ 2383 3488 343
+ 1922 2383 344
+ 2384 1149 3469
+ 1136 2384 2062
+ 2385 696 1672
+ 1003 2385 3023
+ 2386 1686 523
+ 980 2386 1647
+ 2387 1071 3530
+ 1233 2626 2509
+ 2388 3741 836
+ 984 2388 1526
+ 2389 1958 1313
+ 1314 3852 673
+ 2390 1033 1794
+ 365 2390 1794
+ 2391 3717 197
+ 1580 2391 198
+ 2392 1579 107
+ 3716 2392 108
+ 2393 376 3719
+ 1581 2393 2653
+ 2394 1578 2652
+ 200 2394 3846
+ 2395 1191 2852
+ 347 2395 1629
+ 3607 1322 1794
+ 1033 2396 1794
+ 2397 182 3001
+ 3403 3063 902
+ 2398 3570 1051
+ 1477 3707 1051
+ 2399 1952 791
+ 2216 2399 1240
+ 2400 511 1481
+ 984 3602 1481
+ 2401 2477 1035
+ 1549 2401 1035
+ 2402 2213 1125
+ 3167 2964 697
+ 2403 2290 1277
+ 2317 2403 1277
+ 2404 802 2876
+ 1065 2404 2563
+ 2405 2894 790
+ 1245 3098 2371
+ 2406 1730 1321
+ 1999 2406 1057
+ 2407 451 43
+ 1054 2407 1816
+ 2408 3404 341
+ 3488 2408 342
+ 2409 3487 337
+ 3405 2409 338
+ 2410 1308 3476
+ 1076 3363 2159
+ 2411 2468 1048
+ 1699 2411 1048
+ 2412 875 2661
+ 1279 2412 3284
+ 2413 1937 335
+ 3487 2413 336
+ 2414 1891 1051
+ 1603 3570 3074
+ 2415 1755 1093
+ 3653 1509 3964
+ 3912 1086 2229
+ 1087 2416 3561
+ 3477 1085 1994
+ 1088 3913 2230
+ 2418 3143 81
+ 3165 2418 82
+ 2419 350 3428
+ 900 3036 3228
+ 3478 1091 1991
+ 1092 3905 2233
+ 2421 1755 1094
+ 2232 3906 1094
+ 2422 1738 1068
+ 1590 2422 1068
+ 2423 2607 1029
+ 1550 2423 1029
+ 2424 1014 2227
+ 1471 2424 3567
+ 2425 1015 3586
+ 98 2425 3568
+ 2795 2837 1221
+ 1167 2426 2165
+ 2427 673 1726
+ 1027 2427 1726
+ 2428 89 3493
+ 1219 2428 2925
+ 2429 2307 1218
+ 3151 2429 1218
+ 2430 1264 3431
+ 1147 3204 3286
+ 2431 1139 3100
+ 2138 2431 1117
+ 2432 1618 3606
+ 1128 2432 2120
+ 2433 1224 2267
+ 1073 2433 2267
+ 2434 1346 2161
+ 1237 3117 3390
+ 2435 1688 891
+ 1080 2435 1660
+ 2436 1108 1788
+ 2128 3430 1062
+ 2437 2886 905
+ 3652 2437 905
+ 3238 1502 1226
+ 1845 2438 1016
+ 2439 752 2056
+ 1077 2439 2056
+ 3907 3576 914
+ 774 2440 2495
+ 2441 1775 1176
+ 3289 2441 1176
+ 3518 1594 1222
+ 3695 3657 916
+ 2443 1320 2227
+ 3164 2443 1014
+ 2444 1586 1154
+ 1672 2444 1154
+ 2445 772 3340
+ 965 2445 1615
+ 2446 900 2971
+ 801 2446 1515
+ 2447 2191 1177
+ 1141 2447 2484
+ 2448 1064 1748
+ 135 2448 1748
+ 2449 2376 1302
+ 668 2449 2711
+ 2450 2596 813
+ 1234 2450 1914
+ 2451 1775 1054
+ 1968 2604 1054
+ 2452 967 2614
+ 3021 2452 818
+ 2453 2934 776
+ 1047 2453 3505
+ 2454 806 2182
+ 1281 2454 2087
+ 2455 1111 3543
+ 3559 2455 1338
+ 2456 2235 1299
+ 2195 2456 1299
+ 2457 1469 1070
+ 1280 2457 2151
+ 2458 509 1635
+ 1113 2458 1635
+ 2920 1082 3609
+ 607 2459 606
+ 2460 3 1959
+ 941 3569 1959
+ 2461 2675 1015
+ 1319 2461 2226
+ 2462 1646 635
+ 1056 3073 1697
+ 2463 1585 951
+ 824 2463 3026
+ 2464 1790 1053
+ 1454 2464 2027
+ 2916 1702 1123
+ 1104 2465 1736
+ 2466 1930 1180
+ 3348 2921 832
+ 2467 1771 1279
+ 2121 2467 788
+ 2468 789 3742
+ 1048 2468 1705
+ 2469 1383 2684
+ 398 2469 3922
+ 2470 1699 1074
+ 2740 2470 1074
+ 2471 1770 1410
+ 1162 2471 3194
+ 2472 652 2988
+ 1089 2472 2951
+ 2473 1148 1896
+ 1733 2473 734
+ 2474 497 498
+ 1116 2474 1904
+ 2475 1049 1653
+ 3407 2475 849
+ 2476 2901 1187
+ 1922 3310 1187
+ 2477 1711 1035
+ 1502 2477 2401
+ 2478 796 3152
+ 2185 2478 1242
+ 2479 1132 2219
+ 1173 2479 2219
+ 2480 3623 650
+ 1530 2480 56
+ 3535 1764 3497
+ 1585 2481 951
+ 2482 1072 1864
+ 361 2482 360
+ 2483 1788 1108
+ 1859 2483 1108
+ 2484 2705 659
+ 1141 2484 3584
+ 2485 3002 795
+ 1035 2485 1540
+ 2486 1910 1188
+ 1553 2486 1188
+ 2487 2894 3917
+ 1884 2487 1009
+ 2488 994 1539
+ 812 2488 2648
+ 2489 1393 2298
+ 1046 2489 2298
+ 2490 1536 983
+ 2974 2490 983
+ 2491 3968 77
+ 1649 2491 78
+ 2492 2193 778
+ 2206 2492 1251
+ 2493 3630 1018
+ 1891 3318 1195
+ 2494 1513 3595
+ 3313 2494 869
+ 2495 1046 1461
+ 774 2495 1461
+ 2496 1951 906
+ 1264 2496 3755
+ 2497 910 2002
+ 704 2497 3802
+ 2498 3783 721
+ 2574 2498 721
+ 2499 2923 1205
+ 2322 2499 1205
+ 2500 1095 1844
+ 138 2500 137
+ 2501 1351 3464
+ 2059 2501 1651
+ 2502 1333 765
+ 1763 2502 1192
+ 2503 987 2707
+ 1826 2503 661
+ 2504 1038 1712
+ 682 2504 1712
+ 2505 1870 1017
+ 1779 2505 1276
+ 2506 1221 2203
+ 1076 2506 2203
+ 2507 2010 800
+ 1864 2507 1323
+ 3899 1184 1931
+ 1511 2508 428
+ 3999 2498 1233
+ 1133 2509 2626
+ 2510 2196 1196
+ 675 2510 3015
+ 3778 1975 1021
+ 854 2511 3784
+ 2512 1027 1667
+ 3107 2512 888
+ 3986 1602 1172
+ 1378 2513 3249
+ 2514 2857 1142
+ 2585 2514 1142
+ 2515 1179 3865
+ 884 2515 1501
+ 2516 1061 2051
+ 633 2516 632
+ 2517 1378 2049
+ 1232 2517 1934
+ 2518 2099 288
+ 3362 2518 289
+ 2519 985 2183
+ 767 2519 2183
+ 2520 3599 1165
+ 2240 2520 1165
+ 2521 1599 535
+ 1588 2521 536
+ 1470 3387 3859
+ 548 2522 1517
+ 2523 1032 1679
+ 1716 2523 722
+ 2524 169 1665
+ 1143 2524 1665
+ 2525 965 1776
+ 698 2525 3484
+ 2526 1235 2240
+ 3206 2526 1165
+ 2527 219 1997
+ 1091 2527 1997
+ 2528 310 1995
+ 1085 2528 1995
+ 2702 1167 2300
+ 1252 2529 2328
+ 2530 1126 2149
+ 808 2530 2149
+ 2531 3356 1345
+ 2107 2531 1345
+ 2532 2845 1101
+ 3888 2532 1101
+ 2533 689 1607
+ 1075 2533 1607
+ 2534 1355 2235
+ 1049 2534 1653
+ 2535 1117 1827
+ 1217 2535 2129
+ 2536 316 1945
+ 1045 2536 1945
+ 2537 225 1944
+ 1043 2537 1944
+ 2538 298 3671
+ 1645 2538 908
+ 2539 1989 1103
+ 787 2539 1921
+ 2540 1041 1718
+ 687 2540 1718
+ 2541 1273 3121
+ 131 2541 3024
+ 3338 1306 3457
+ 797 2542 1504
+ 2543 2134 1144
+ 1673 2543 1144
+ 3650 1542 830
+ 560 2544 3958
+ 2545 1738 68
+ 2017 2545 69
+ 2546 191 1928
+ 1025 2546 1928
+ 2547 1718 1100
+ 2874 2547 1100
+ 2548 3969 1411
+ 797 2548 3747
+ 2549 1752 1087
+ 1982 2549 1087
+ 2550 847 3289
+ 1363 2934 2453
+ 2551 1526 998
+ 1946 2551 998
+ 2552 1712 1102
+ 2878 2552 1102
+ 2553 1107 1747
+ 1272 2553 2066
+ 2554 189 1700
+ 1920 2554 1024
+ 2555 223 1713
+ 1956 2555 1042
+ 2556 314 1714
+ 1957 2556 1044
+ 2557 2073 839
+ 1956 2557 1400
+ 2558 1044 2074
+ 840 2558 2074
+ 2559 1997 1400
+ 1991 2559 839
+ 2560 1995 1401
+ 1994 2560 840
+ 2561 2788 1069
+ 2792 2561 1069
+ 2562 953 1814
+ 817 2562 1814
+ 2563 1805 1065
+ 1364 2563 2404
+ 2564 3530 1071
+ 3508 2564 1071
+ 2565 1769 1139
+ 2009 2565 1435
+ 2566 3486 1059
+ 2770 2566 1059
+ 2567 1770 1162
+ 870 2567 3368
+ 2568 268 1719
+ 887 3079 3115
+ 2569 2218 1295
+ 1146 2821 1897
+ 2570 1112 1856
+ 176 2570 175
+ 2571 1909 1207
+ 660 2571 2585
+ 2572 1127 2114
+ 2091 2572 680
+ 2573 2969 1090
+ 1495 2573 1090
+ 2574 721 1926
+ 1071 2574 1926
+ 2575 3547 1067
+ 2017 2575 1067
+ 2576 1013 3844
+ 1742 2765 1037
+ 2577 1126 1916
+ 407 2577 406
+ 2578 2905 411
+ 2745 2578 412
+ 2579 1890 1097
+ 1993 2579 1097
+ 2580 2019 950
+ 609 2580 1443
+ 2581 3346 1227
+ 1816 2581 1227
+ 2582 2961 1096
+ 1500 2582 1096
+ 2583 185 1918
+ 1023 2583 1918
+ 2584 2141 1180
+ 1787 2584 1180
+ 2585 1207 2514
+ 660 2585 3692
+ 2586 1243 2133
+ 804 2586 3174
+ 2587 2430 1147
+ 830 2587 3263
+ 2588 1052 1596
+ 3406 3195 1377
+ 2589 1772 1223
+ 1282 3389 2156
+ 2590 3943 551
+ 3944 2590 552
+ 2591 1625 835
+ 1055 2591 1507
+ 2592 1029 1530
+ 848 2592 3881
+ 2593 1256 2284
+ 2287 2593 1135
+ 2594 1540 1004
+ 1508 2594 1004
+ 2595 1978 1145
+ 1766 2595 1145
+ 2596 1193 2004
+ 1031 2596 2004
+ 2597 30 330
+ 2847 2597 330
+ 3513 1348 2326
+ 2215 2598 1253
+ 2599 3116 1098
+ 1544 2599 1098
+ 2600 2450 1234
+ 1883 2600 1234
+ 2601 3758 1169
+ 1680 2601 1169
+ 2602 1152 3786
+ 470 2602 469
+ 2603 1878 1136
+ 1676 2603 1136
+ 2604 776 2451
+ 1054 2604 2451
+ 2605 1210 1968
+ 1706 2605 2045
+ 3749 1625 1055
+ 1875 2606 1055
+ 2607 1412 823
+ 1029 2607 3776
+ 3168 2123 991
+ 2005 2608 1283
+ 2609 1748 1064
+ 3578 2609 1064
+ 2610 784 3116
+ 1813 2610 1022
+ 2611 1097 1552
+ 1543 2611 843
+ 2612 475 476
+ 2612 3138 3693
+ 2613 1549 725
+ 1608 3609 2025
+ 2614 2063 1138
+ 1387 2614 2375
+ 2615 1792 459
+ 1840 2615 460
+ 2616 1119 1841
+ 421 2616 1841
+ 2617 907 1592
+ 841 2617 1592
+ 2618 954 1927
+ 1394 2618 1927
+ 2619 3054 866
+ 1038 2619 1599
+ 2620 2000 1334
+ 2166 2620 787
+ 2621 709 2060
+ 1129 2621 2060
+ 2622 1109 1905
+ 1469 4003 1905
+ 2623 3583 404
+ 3422 2623 35
+ 2624 1463 642
+ 1166 2624 2899
+ 2625 1566 579
+ 1604 2625 580
+ 2626 2387 678
+ 1133 2626 1823
+ 2627 741 1762
+ 1205 2627 3099
+ 2628 1254 2140
+ 1084 3890 1850
+ 2629 1011 1902
+ 419 2629 1902
+ 2630 462 1901
+ 1010 2630 1901
+ 2631 1499 1011
+ 1571 2631 1011
+ 2632 1570 1010
+ 1498 2632 1010
+ 2633 3799 543
+ 3677 2633 544
+ 2634 1130 1693
+ 3925 2634 823
+ 2635 2084 370
+ 1098 2635 1544
+ 3541 3187 1675
+ 696 3760 3836
+ 2637 952 2311
+ 1435 2637 2311
+ 2638 1202 3083
+ 251 2638 250
+ 2639 881 4008
+ 1027 2639 1631
+ 2640 673 1558
+ 2052 3562 1151
+ 2641 3709 676
+ 1162 2641 3368
+ 2642 2925 775
+ 1392 2642 1911
+ 2643 2735 1115
+ 1919 3886 1448
+ 2644 1610 574
+ 1546 2644 575
+ 2645 237 1898
+ 1114 2645 1898
+ 2646 3042 859
+ 1041 2646 1623
+ 3566 3778 1021
+ 1663 2647 1021
+ 2648 1539 1007
+ 2980 2648 1007
+ 2649 1988 1360
+ 1529 2649 2533
+ 2650 664 3007
+ 2534 2650 1355
+ 2651 1511 428
+ 1161 3375 1862
+ 2652 1578 120
+ 2394 2652 1423
+ 2653 2393 1417
+ 1581 2653 323
+ 2654 1579 2392
+ 1424 2654 2392
+ 2655 1418 2391
+ 1580 2655 2391
+ 2656 1178 1836
+ 1179 2656 1836
+ 2657 2108 1341
+ 820 2657 4001
+ 2658 1332 2633
+ 2250 2658 1225
+ 3655 781 4014
+ 1013 2659 3844
+ 2660 2561 1474
+ 1973 3947 1101
+ 2661 1414 2047
+ 2412 2661 1228
+ 2662 926 2509
+ 1908 2662 1133
+ 3793 2173 1270
+ 1039 2663 1610
+ 2664 1616 1134
+ 2823 2664 1134
+ 2665 2405 1245
+ 2078 2665 1245
+ 2666 3983 1105
+ 1552 2666 3046
+ 2667 1035 1540
+ 725 2667 1540
+ 2668 1805 3251
+ 2819 2668 834
+ 3975 1747 921
+ 254 2669 1600
+ 3985 1983 1102
+ 2561 2670 1489
+ 2671 3886 1115
+ 621 2671 2984
+ 2672 1293 3894
+ 1881 2672 958
+ 2673 686 2686
+ 1979 2673 1096
+ 2674 836 3741
+ 3264 3442 1563
+ 2675 1461 724
+ 1472 3586 2046
+ 2676 386 3276
+ 1209 2676 2756
+ 2677 1383 3945
+ 1208 2677 3155
+ 2678 2772 1151
+ 1556 2678 1151
+ 2679 1556 1019
+ 672 2679 3169
+ 2680 2096 1079
+ 1757 2680 1079
+ 2681 1222 1947
+ 726 2681 1947
+ 2682 949 2048
+ 1263 2682 2048
+ 2683 499 500
+ 1079 2683 1757
+ 2684 45 1512
+ 2469 2684 1512
+ 2685 1163 1652
+ 1432 2685 3468
+ 2686 1503 1110
+ 2911 2686 1110
+ 4000 1977 1100
+ 2686 2687 1503
+ 2688 731 2138
+ 1117 2688 2138
+ 2689 1612 1140
+ 2822 2689 1140
+ 2690 1747 1107
+ 1961 2690 1618
+ 2691 1258 3991
+ 1103 2691 3994
+ 2692 2324 1396
+ 2959 2692 794
+ 2693 1095 1761
+ 1381 3659 1761
+ 2694 838 1549
+ 2613 2694 1549
+ 2695 1725 3860
+ 1607 2695 1065
+ 3253 867 3872
+ 756 2696 1634
+ 2697 1422 2274
+ 1544 2697 2274
+ 3446 1188 1719
+ 270 2698 269
+ 2699 1530 56
+ 1475 2699 555
+ 2700 657 3588
+ 1358 2700 2495
+ 3982 1948 1238
+ 3343 2701 1238
+ 2702 2529 1167
+ 1204 2702 2300
+ 2703 1143 1745
+ 2135 2703 1678
+ 2704 2890 1144
+ 2134 2704 1144
+ 2705 1907 3820
+ 1177 2705 2484
+ 2706 2103 1013
+ 818 2706 3714
+ 2707 1872 812
+ 2503 2707 1431
+ 3311 1717 922
+ 2184 2708 1385
+ 2709 1038 3928
+ 853 2709 3874
+ 2710 1703 1026
+ 1507 2710 1026
+ 2711 2449 1302
+ 2119 2711 1302
+ 2712 1715 2270
+ 890 2712 3527
+ 2713 3827 858
+ 1157 3779 1802
+ 2714 2777 1163
+ 3843 2714 1163
+ 2715 1148 1683
+ 1896 3026 1197
+ 2716 38 405
+ 1309 2716 1916
+ 2717 3691 879
+ 3529 2717 879
+ 2718 3819 1181
+ 1561 2718 3433
+ 2719 1597 948
+ 3062 2719 948
+ 2720 1041 1528
+ 850 2720 3816
+ 2721 1562 852
+ 1032 2721 1679
+ 2722 2982 844
+ 3791 2722 844
+ 2723 58 59
+ 1178 2723 1836
+ 2724 870 3368
+ 940 2724 1541
+ 2725 1047 3505
+ 1873 2725 3160
+ 2726 159 1695
+ 2270 2726 1158
+ 2727 1106 1795
+ 1583 2727 658
+ 2728 2049 1356
+ 1809 2728 947
+ 2729 992 1832
+ 595 2729 1832
+ 2730 1731 1078
+ 2122 2730 1078
+ 2731 2340 1183
+ 1266 2731 2275
+ 2732 3896 489
+ 2251 2732 490
+ 2733 1170 2868
+ 2327 2733 1274
+ 2734 779 3086
+ 1154 2734 1514
+ 2735 2643 1628
+ 880 2735 1628
+ 2736 1894 667
+ 1169 2736 1865
+ 2737 571 572
+ 1019 2737 1593
+ 2738 3871 1413
+ 1317 2738 3373
+ 2739 2136 1276
+ 1828 2739 717
+ 2740 1074 3467
+ 3373 2740 831
+ 2741 1829 1150
+ 1654 3034 1150
+ 2742 60 1
+ 1179 2742 3865
+ 2743 1097 2611
+ 1543 2743 2611
+ 3382 751 1722
+ 898 2744 1722
+ 2745 1462 2578
+ 2029 2745 413
+ 2746 1688 3665
+ 892 2746 1768
+ 2747 1404 854
+ 879 2747 2855
+ 2748 1780 1282
+ 1834 2748 1006
+ 2749 889 3579
+ 1720 2749 2279
+ 2750 767 2183
+ 1066 2750 2183
+ 2751 1028 3494
+ 1765 2751 654
+ 2752 991 1674
+ 729 2752 3248
+ 2753 1398 1938
+ 2156 2753 1006
+ 2754 1160 2102
+ 3952 2754 392
+ 2755 464 3555
+ 2677 2755 1383
+ 2756 1382 3554
+ 1209 3438 3841
+ 2757 1643 3897
+ 1325 2757 1861
+ 2758 153 2279
+ 1159 2758 2279
+ 2759 710 3257
+ 989 2759 3352
+ 2760 1112 1624
+ 1963 4026 3642
+ 2761 1278 2058
+ 473 2761 472
+ 2762 1568 3823
+ 1242 2762 1703
+ 2763 1130 1692
+ 647 2763 646
+ 2764 1623 526
+ 1528 2764 527
+ 2765 1727 1037
+ 2576 2765 1742
+ 2766 1627 3788
+ 831 2766 3286
+ 2767 152 1694
+ 147 2767 1694
+ 2768 1695 159
+ 163 3706 162
+ 2769 2107 1114
+ 1366 2769 1898
+ 2770 1059 2204
+ 737 2770 2204
+ 2771 1612 976
+ 866 2771 3822
+ 2772 743 2052
+ 1151 2772 2052
+ 2773 3444 1145
+ 1978 2773 1145
+ 2774 2508 1511
+ 2269 2774 1511
+ 2775 1729 708
+ 2199 2775 1336
+ 2776 377 3037
+ 3186 2776 1200
+ 2777 744 2212
+ 1163 2777 2212
+ 2778 2350 1308
+ 2410 2778 1308
+ 2779 1905 1109
+ 2067 2779 1109
+ 2780 2094 1178
+ 878 2780 2031
+ 2781 1442 1899
+ 3196 3544 1784
+ 3933 1164 1773
+ 629 2782 628
+ 2783 1743 1155
+ 2188 2783 1155
+ 2784 3231 388
+ 1324 2784 3445
+ 2785 847 3713
+ 3206 2785 1399
+ 2786 1696 1215
+ 2066 2786 1215
+ 2787 1450 3837
+ 3159 2787 456
+ 2788 1489 853
+ 1069 2788 3604
+ 2789 2066 1215
+ 2171 2789 1215
+ 2790 1159 2319
+ 146 2790 2319
+ 2791 1695 164
+ 2318 2791 165
+ 2792 1069 3604
+ 1474 2792 844
+ 2793 1120 3442
+ 1740 2793 2266
+ 2794 1118 1840
+ 885 2794 3619
+ 2795 1221 2506
+ 766 2795 2506
+ 2796 1420 2041
+ 1425 2796 2041
+ 2797 2035 1427
+ 206 2797 205
+ 2798 195 196
+ 2033 2798 1418
+ 2799 2037 1419
+ 208 2799 207
+ 2800 2040 1429
+ 305 2800 304
+ 2801 231 232
+ 2039 2801 1430
+ 2802 1421 2034
+ 1427 2802 2034
+ 2803 109 110
+ 2036 2803 1426
+ 2804 1426 2038
+ 1416 2804 2038
+ 2805 2070 1262
+ 3345 2805 1262
+ 2806 1804 1037
+ 684 2806 3189
+ 2807 281 1661
+ 1970 2807 1081
+ 2808 1687 1123
+ 2945 2808 1123
+ 2809 733 3412
+ 909 3252 1734
+ 2810 495 1614
+ 2347 2810 1070
+ 2811 1785 998
+ 1526 2811 998
+ 2812 1806 73
+ 3965 2812 74
+ 2813 1036 2315
+ 443 2813 2315
+ 2814 1537 538
+ 1572 2814 539
+ 2815 2213 1000
+ 1269 2815 2888
+ 2816 2211 1124
+ 999 2816 2889
+ 2817 3815 276
+ 1974 2817 16
+ 2818 904 1648
+ 1036 2818 1648
+ 2819 1607 2668
+ 1075 2819 3702
+ 2820 707 1543
+ 960 2820 2985
+ 2821 2112 1294
+ 1897 2821 1294
+ 2822 1140 1986
+ 746 2822 1986
+ 4030 1912 3919
+ 1985 2823 1134
+ 2824 1075 3702
+ 2993 2824 871
+ 2825 1077 2159
+ 37 2825 2159
+ 2826 1373 3773
+ 2232 2826 1372
+ 2827 922 1671
+ 702 2827 3774
+ 2828 1192 2975
+ 2062 2828 1406
+ 2829 1251 2492
+ 2356 2829 778
+ 2830 2230 1367
+ 1368 3753 686
+ 2831 1668 1186
+ 2143 2831 1186
+ 2832 2144 1185
+ 1778 2832 1185
+ 2833 1255 2244
+ 1088 2833 2244
+ 2834 2229 1086
+ 2245 2834 1086
+ 2835 1094 2248
+ 1257 2835 2248
+ 2836 2247 1092
+ 2233 2836 1092
+ 2837 2872 685
+ 1221 2837 3391
+ 2838 1486 1164
+ 1659 2838 1164
+ 2839 2197 1584
+ 2502 2839 1192
+ 2840 3701 859
+ 1616 2840 859
+ 2841 960 2006
+ 758 2841 2006
+ 2842 3467 1074
+ 1699 2842 1074
+ 4010 1867 1049
+ 4011 2843 1316
+ 2844 181 1689
+ 1135 2844 3403
+ 2845 764 1973
+ 1101 2845 1973
+ 2846 26 3727
+ 18 2858 3725
+ 2847 1519 1190
+ 2597 2847 1190
+ 2848 805 3790
+ 1776 2848 1157
+ 3258 3529 1331
+ 1196 2849 3015
+ 2850 1391 2440
+ 774 2850 2440
+ 2851 1039 2280
+ 1269 2851 2280
+ 2852 1629 2395
+ 1732 2852 1191
+ 2853 2273 1001
+ 2447 2853 749
+ 2854 920 1460
+ 1900 3656 737
+ 2855 2747 1402
+ 3015 1331 3856
+ 2856 1168 1847
+ 624 2856 1847
+ 2857 1002 2277
+ 1142 2857 2277
+ 2858 1203 2846
+ 1429 2858 2846
+ 2859 998 2329
+ 1587 2859 2329
+ 3090 2149 1126
+ 2005 2860 1126
+ 2861 3120 1155
+ 1743 2861 1155
+ 2862 512 1563
+ 2674 3741 1563
+ 2863 1479 3587
+ 1149 2863 3469
+ 2864 558 1627
+ 2766 3549 1627
+ 2865 1104 2181
+ 1486 2865 2181
+ 2866 1468 2784
+ 437 2866 3756
+ 2867 691 3685
+ 1769 2867 969
+ 2868 1170 1716
+ 722 3564 1716
+ 2869 2700 1358
+ 1598 2869 914
+ 2870 1360 3876
+ 1725 2870 2042
+ 2871 1739 710
+ 3456 3512 1681
+ 2872 1252 2328
+ 1206 2872 2328
+ 2873 876 3934
+ 976 2873 1622
+ 3477 1994 1304
+ 1977 2874 1100
+ 2875 1483 864
+ 3510 2875 864
+ 2876 1200 2272
+ 1364 2876 2272
+ 2877 719 1702
+ 1104 2877 1702
+ 2878 1102 1983
+ 763 2878 1983
+ 3364 1545 3854
+ 1854 2879 1216
+ 2880 1801 886
+ 3620 2880 886
+ 2881 23 260
+ 1249 2881 3268
+ 2882 248 3132
+ 247 2882 3269
+ 2883 244 3270
+ 2262 3425 1247
+ 2884 1248 3271
+ 264 2884 24
+ 2885 3953 485
+ 2269 2885 486
+ 3235 1335 3557
+ 1587 2886 2437
+ 2887 849 1485
+ 1121 2887 1485
+ 2888 2815 1000
+ 671 2888 2113
+ 2889 2816 1270
+ 2111 2889 671
+ 2890 2704 1730
+ 742 2890 1730
+ 2891 1083 1959
+ 3 2891 1959
+ 2892 1992 1194
+ 1619 2892 3970
+ 2893 431 1538
+ 1862 2893 925
+ 2894 2405 1189
+ 1893 2894 1189
+ 2895 45 2218
+ 1146 2895 2218
+ 2896 1116 1679
+ 2721 2896 1679
+ 2897 1907 1177
+ 2191 2897 1177
+ 2898 1849 1050
+ 1802 2898 1050
+ 2899 2624 643
+ 1166 2899 1821
+ 2900 1727 896
+ 1037 2900 1636
+ 2901 2476 1629
+ 2852 2901 1629
+ 2902 1865 2361
+ 1169 2902 2193
+ 2903 1947 1222
+ 2079 2903 1594
+ 2904 1019 1593
+ 863 2904 3787
+ 2905 410 411
+ 1330 2905 2578
+ 2906 2333 716
+ 1754 2906 3914
+ 2907 1975 1404
+ 1434 3691 2717
+ 2908 3377 1110
+ 1503 2908 1110
+ 2909 977 2239
+ 604 2909 2239
+ 2910 508 2458
+ 1113 2910 2458
+ 2911 1110 3377
+ 2998 2911 876
+ 2912 1540 2485
+ 1642 2912 795
+ 2913 435 2071
+ 1160 2913 2071
+ 2914 2842 1699
+ 1048 2914 1699
+ 2915 1693 648
+ 3623 2915 649
+ 2916 2465 1702
+ 1687 2916 1123
+ 2917 777 1809
+ 1018 3630 1809
+ 2918 2189 1129
+ 2519 2918 1129
+ 3972 1362 2105
+ 963 2919 2105
+ 2920 2459 1082
+ 605 2920 1608
+ 2921 2466 1180
+ 2141 2921 1180
+ 2922 1089 3153
+ 872 2922 1640
+ 2923 2499 1715
+ 890 2923 1715
+ 2924 1198 1846
+ 333 2924 1846
+ 2925 2642 1219
+ 1320 2925 2428
+ 2926 3858 917
+ 1892 2926 1278
+ 2927 51 1656
+ 1525 2927 3601
+ 2928 3817 1520
+ 481 2928 3942
+ 2929 1522 3600
+ 50 2929 1657
+ 2930 453 3962
+ 3818 2930 1521
+ 2931 1834 1006
+ 1412 2931 1938
+ 2932 1153 3244
+ 856 2932 1494
+ 3996 1888 1409
+ 1900 2933 1409
+ 2934 2550 1176
+ 2451 2934 1176
+ 2935 2003 713
+ 1185 2935 1778
+ 3495 690 1584
+ 927 2936 1584
+ 2937 1582 529
+ 1559 2937 530
+ 2938 1885 1199
+ 2952 2938 1199
+ 2939 284 1876
+ 1182 2939 3789
+ 2940 235 1808
+ 957 2940 1808
+ 2941 1238 1948
+ 355 2941 1948
+ 2942 2070 962
+ 17 2942 3378
+ 2943 1932 1183
+ 2340 2943 1183
+ 2944 252 253
+ 1212 3509 3882
+ 2945 1123 1964
+ 1602 2945 865
+ 2946 1255 2245
+ 3726 2946 15
+ 2947 2946 1428
+ 1255 2947 2244
+ 2948 2014 1538
+ 2112 2948 1271
+ 2949 1683 1138
+ 3242 2949 1138
+ 3763 1547 3112
+ 2541 3572 1273
+ 2951 1232 1934
+ 2192 2951 919
+ 2952 1493 2938
+ 2028 2952 1199
+ 2953 7 2248
+ 1094 2953 2248
+ 2954 217 1756
+ 2247 2954 1092
+ 2955 15 2245
+ 1086 2955 2245
+ 2956 308 1751
+ 2244 2956 1088
+ 2957 2124 1312
+ 2115 3988 720
+ 2958 1931 1184
+ 1798 2958 1184
+ 2959 1220 1598
+ 2692 2959 1598
+ 2960 2044 1197
+ 3026 2960 1197
+ 2961 762 1979
+ 1096 2961 1979
+ 2962 1572 539
+ 1492 2962 540
+ 2963 2217 1016
+ 1281 2963 3142
+ 2964 1326 2402
+ 1125 2964 2402
+ 2965 1132 2191
+ 749 2965 2191
+ 2966 1031 1907
+ 801 2966 1907
+ 2967 1080 1974
+ 2064 3466 1384
+ 2968 1528 528
+ 1582 2968 529
+ 2969 1259 1850
+ 1988 2969 760
+ 2970 2020 715
+ 2297 2970 1597
+ 2971 2062 1406
+ 1515 4006 690
+ 2972 1081 1662
+ 3299 2972 874
+ 2973 1858 1307
+ 2087 3668 728
+ 2974 1411 2490
+ 3337 2974 983
+ 2975 1192 1584
+ 4006 2975 690
+ 2976 1063 3421
+ 3713 2976 1399
+ 2977 916 3183
+ 1741 2977 728
+ 2978 1617 1291
+ 2149 3090 1291
+ 2979 3113 954
+ 3885 2979 954
+ 2980 1007 1518
+ 2294 2980 1518
+ 2981 3496 1210
+ 1706 2981 1210
+ 2982 1101 3947
+ 1455 2982 2722
+ 2983 1466 952
+ 1704 2983 2637
+ 2984 1115 1721
+ 619 2984 1721
+ 2985 2820 1543
+ 1583 2985 843
+ 2986 871 3869
+ 980 2986 1686
+ 2987 1475 556
+ 1534 2987 557
+ 2988 2513 1378
+ 2517 2988 1378
+ 2989 695 1539
+ 1601 2989 994
+ 2990 3234 1459
+ 563 2990 3711
+ 2991 1251 1935
+ 1642 2991 2260
+ 2992 1480 2621
+ 2189 2992 1129
+ 2993 1529 2824
+ 1090 2993 1495
+ 3964 2415 1093
+ 2307 4023 1509
+ 2995 4000 1100
+ 1718 2995 1100
+ 2996 1241 2678
+ 2316 2996 672
+ 2997 320 2210
+ 1084 2997 2210
+ 2998 1535 2911
+ 1096 2998 1500
+ 2999 3985 1102
+ 1712 2999 1102
+ 3000 2099 1230
+ 1800 3000 1230
+ 3001 1843 1175
+ 2397 3001 1175
+ 3002 1711 1224
+ 2433 3002 1224
+ 3003 1186 1668
+ 2068 3003 712
+ 3004 2302 1527
+ 3682 3004 1527
+ 3005 280 2243
+ 1103 3005 2243
+ 3006 888 3608
+ 1019 3006 1664
+ 3007 2960 1456
+ 2463 3448 1456
+ 3008 1716 1170
+ 2028 3008 1170
+ 3009 2174 1569
+ 1872 3009 812
+ 3010 3993 1166
+ 1821 3010 1166
+ 3011 1658 882
+ 1213 3011 2101
+ 3012 894 3833
+ 3041 3401 1506
+ 3221 1218 2307
+ 3576 3979 1796
+ 3014 2642 1392
+ 1797 3978 3255
+ 3856 1331 2855
+ 1196 3015 2510
+ 3016 934 2157
+ 1759 3016 2157
+ 3017 1228 1890
+ 2579 3017 1890
+ 3018 1168 1783
+ 898 3018 1783
+ 3019 731 2688
+ 1217 3019 2688
+ 3020 1516 566
+ 1631 3020 567
+ 3021 1772 2452
+ 1223 3021 1804
+ 3022 1214 1853
+ 2273 3022 1001
+ 3023 2385 1672
+ 3649 3023 897
+ 3024 2541 1490
+ 2086 3024 1490
+ 3025 1854 1216
+ 2277 3764 773
+ 3026 1456 2960
+ 2715 3026 1896
+ 3027 1206 2328
+ 807 3027 2328
+ 3481 1826 1286
+ 3102 3028 883
+ 3029 368 369
+ 1298 3029 2084
+ 3030 1949 932
+ 1338 3543 3712
+ 3031 75 76
+ 1236 3031 1753
+ 3032 2460 1359
+ 3239 3032 1359
+ 3033 3196 703
+ 3805 3033 703
+ 3034 2741 1150
+ 616 3034 1654
+ 3035 1588 536
+ 1537 3035 538
+ 3036 1173 2419
+ 1676 3036 2419
+ 3037 379 3936
+ 1200 3037 1760
+ 3038 1647 525
+ 1623 3038 526
+ 3039 759 2238
+ 1181 3039 2238
+ 3040 267 2568
+ 1239 3040 2568
+ 3041 1380 3598
+ 3401 3041 895
+ 3042 1134 1616
+ 1476 3042 2646
+ 3043 1628 1005
+ 1551 3043 2353
+ 3044 550 3943
+ 3538 3044 1523
+ 3045 3641 520
+ 1487 3045 521
+ 3046 2666 1105
+ 843 3046 2194
+ 3047 3916 2
+ 1859 3047 2
+ 3048 1370 2174
+ 3146 3048 961
+ 3049 1201 2271
+ 2381 3049 1736
+ 3050 1980 1230
+ 2238 3809 1020
+ 3051 1246 2339
+ 63 3051 2339
+ 3052 1688 2435
+ 1080 3052 2435
+ 3053 1056 1697
+ 901 3053 1697
+ 3054 1140 1612
+ 1488 3054 2619
+ 3055 1790 739
+ 1053 3055 3068
+ 3056 2464 1454
+ 2339 3056 1454
+ 3057 1211 3158
+ 826 3057 3277
+ 3058 2051 1213
+ 2101 3058 1213
+ 3617 2282 1271
+ 1538 3059 2948
+ 3060 2261 974
+ 564 3060 1577
+ 3061 2199 783
+ 1203 3061 2170
+ 3062 948 3465
+ 2346 3062 1795
+ 3063 1175 1866
+ 2397 3063 1689
+ 3064 2223 1479
+ 1878 3064 1149
+ 3065 2252 798
+ 1386 3065 2116
+ 3066 1750 883
+ 1286 3066 3481
+ 3067 1443 3358
+ 608 3067 1565
+ 3068 3399 1053
+ 1780 3068 3055
+ 3069 1056 1784
+ 851 3069 3544
+ 3070 943 2068
+ 1669 3070 2068
+ 4024 3270 1810
+ 2262 3071 1433
+ 3072 2423 1550
+ 1705 3072 1048
+ 3073 2462 636
+ 3796 3073 637
+ 3074 791 3184
+ 1240 3074 3570
+ 3075 2910 1803
+ 1625 3075 1803
+ 3076 1198 1669
+ 877 3076 3285
+ 3077 1897 1294
+ 2154 3077 1294
+ 3078 2122 1194
+ 1992 3078 1194
+ 3079 1239 2568
+ 1719 3079 2568
+ 3080 2250 1225
+ 2198 3080 1225
+ 3081 3625 1301
+ 3082 3081 1301
+ 3082 1417 3081
+ 2024 3082 1301
+ 3083 2168 822
+ 4035 3083 822
+ 3084 3649 897
+ 1605 3084 897
+ 3085 1244 2825
+ 37 3085 2825
+ 3086 779 2203
+ 1221 3086 2203
+ 3087 976 1612
+ 683 3087 1612
+ 3088 3687 892
+ 1182 3088 1855
+ 4009 1620 2003
+ 944 3089 2003
+ 3090 1126 2860
+ 782 3090 2860
+ 3091 980 1616
+ 688 3091 1616
+ 3092 2176 1118
+ 1767 3092 2794
+ 3093 2294 993
+ 1887 3093 1505
+ 3094 1345 2222
+ 1729 3094 708
+ 3095 2996 1482
+ 2287 3095 1482
+ 3096 1215 1696
+ 821 3096 3126
+ 3097 1034 3594
+ 2502 3097 1333
+ 3098 1245 2405
+ 790 3098 2405
+ 3099 2627 1762
+ 2322 3099 1057
+ 3100 1769 2351
+ 2431 3100 792
+ 3101 32 2024
+ 1254 3101 2024
+ 3102 2115 1698
+ 1915 3102 883
+ 3103 2295 1371
+ 2164 3103 2015
+ 3104 2020 1008
+ 908 3104 1645
+ 3105 937 1998
+ 1484 3105 1998
+ 3106 949 1953
+ 1668 3106 1953
+ 3107 1558 2512
+ 1151 3107 1556
+ 3108 3960 892
+ 1768 3108 892
+ 3109 1268 2335
+ 3823 3109 912
+ 3110 2316 1124
+ 769 3110 2211
+ 3111 1487 522
+ 1686 3111 523
+ 3112 1547 2088
+ 1886 3112 2088
+ 3113 3443 1206
+ 3027 3113 1206
+ 3114 857 3171
+ 2119 3114 1589
+ 3115 1719 1188
+ 1910 3115 1188
+ 3116 784 2334
+ 1098 3116 2334
+ 3948 3786 1707
+ 2434 3117 1237
+ 3118 1964 1442
+ 2781 3118 1442
+ 3119 1466 3855
+ 129 3119 8
+ 3120 1709 1155
+ 1801 3120 2861
+ 3121 1273 2283
+ 3868 3121 842
+ 3122 1351 2501
+ 2146 3122 584
+ 3123 2013 897
+ 1672 3123 897
+ 3124 2286 296
+ 1645 3124 297
+ 3125 1810 1250
+ 1644 4035 3132
+ 3126 1249 1811
+ 1248 3351 1811
+ 3127 329 2597
+ 1190 3127 2597
+ 3128 1551 2353
+ 1341 3128 1717
+ 3129 938 3339
+ 717 3129 1828
+ 3351 1248 1782
+ 1239 3130 1782
+ 3131 2418 1265
+ 2617 3131 1265
+ 3132 4035 1250
+ 2882 3132 1250
+ 3133 757 3754
+ 2454 3133 1639
+ 3134 2097 641
+ 1463 3134 642
+ 3135 1034 1763
+ 753 3135 1763
+ 3136 3145 714
+ 1384 3136 2064
+ 3137 3618 1275
+ 2103 3137 1013
+ 3138 476 46
+ 1464 3138 2200
+ 3139 2167 13
+ 3738 3139 13
+ 3140 1326 3167
+ 787 3140 3770
+ 3141 2109 1212
+ 1877 3882 1600
+ 3142 2963 1016
+ 3133 3142 757
+ 3143 80 81
+ 1467 3143 2418
+ 3144 1559 530
+ 1622 3144 531
+ 3145 1081 1768
+ 714 3145 3665
+ 3146 961 1882
+ 720 3146 1882
+ 3147 1593 573
+ 1610 3147 574
+ 3148 2091 680
+ 2163 3690 1311
+ 3149 3875 974
+ 1516 3149 2261
+ 3150 1823 678
+ 1229 3150 1849
+ 3151 1218 2850
+ 774 3151 2850
+ 3152 796 3322
+ 2762 3152 1568
+ 3153 1089 2192
+ 733 3153 2192
+ 3154 385 2676
+ 1209 3154 2676
+ 3155 2677 400
+ 1208 3155 3842
+ 3156 2194 1106
+ 1583 3156 2727
+ 3157 241 1433
+ 2106 3895 963
+ 3158 1211 2308
+ 1781 3158 679
+ 3159 1214 2787
+ 1853 3159 457
+ 3160 2725 837
+ 1204 3160 2313
+ 3161 2515 1389
+ 1705 3742 3316
+ 3162 1962 741
+ 1143 3162 1745
+ 3163 2164 1437
+ 2081 3163 720
+ 3164 1014 2118
+ 724 3164 2118
+ 3165 82 83
+ 1265 3165 2127
+ 3166 349 2419
+ 1173 3166 2419
+ 3167 1326 2964
+ 2907 3167 697
+ 3168 1283 2608
+ 2123 3168 2608
+ 3169 1478 2352
+ 2316 3169 1124
+ 3170 1514 3391
+ 2013 3170 1605
+ 3171 3008 2028
+ 1589 3171 1199
+ 3172 1592 1350
+ 2349 3172 1350
+ 3173 2190 1554
+ 1337 3173 3366
+ 3174 2586 1137
+ 2266 3174 1758
+ 3175 3049 2271
+ 1231 3175 2271
+ 3176 1484 2285
+ 2252 3176 798
+ 3177 1709 1207
+ 1909 3177 1207
+ 3178 39 416
+ 1830 3178 1382
+ 3179 1280 1562
+ 2449 3179 1562
+ 3180 964 1758
+ 660 3180 3740
+ 3181 2313 1594
+ 651 3181 3518
+ 3182 903 1741
+ 728 3668 1741
+ 3183 1560 2977
+ 1833 3183 916
+ 3184 2089 1060
+ 3074 3184 1603
+ 3185 1148 1967
+ 655 3185 1967
+ 3186 2876 802
+ 1444 3186 2042
+ 3474 1452 3836
+ 1305 3187 3541
+ 3188 704 3845
+ 1189 3188 1893
+ 3189 1636 2320
+ 2753 3189 1398
+ 3190 942 2601
+ 726 3190 1680
+ 3191 1316 1759
+ 1842 3191 716
+ 3192 1696 258
+ 1249 3192 2881
+ 3193 1186 3003
+ 2068 3193 3003
+ 3430 2128 1353
+ 1162 3194 2641
+ 3195 3460 1377
+ 2588 3195 1684
+ 3196 1903 1287
+ 3544 3196 1287
+ 3197 2067 1261
+ 2019 3197 1261
+ 3198 1825 663
+ 1603 3198 2414
+ 3199 2022 1407
+ 2409 3199 1407
+ 3200 2408 1408
+ 2023 3200 1408
+ 3201 1223 1804
+ 2806 3201 1804
+ 3202 995 2310
+ 751 3202 2310
+ 3203 2783 1390
+ 2043 3203 1390
+ 3204 2430 665
+ 1317 3204 2018
+ 3205 1808 1114
+ 1729 3205 1114
+ 3206 1399 3421
+ 2526 3206 752
+ 3931 1552 1890
+ 1228 3207 1890
+ 3208 1849 2898
+ 1229 3208 1567
+ 3209 1832 1267
+ 2180 3646 1267
+ 3210 1421 3847
+ 1578 3210 120
+ 3211 1580 198
+ 1423 3211 3846
+ 1415 3282 4019
+ 1579 3212 107
+ 3213 375 1581
+ 1422 3213 3214
+ 3214 1581 323
+ 1422 3214 3849
+ 3215 3212 1579
+ 214 3215 1579
+ 3216 3210 1578
+ 201 3216 1578
+ 3217 123 1580
+ 3211 3217 1580
+ 3218 941 1632
+ 1211 3218 1632
+ 3219 1576 1886
+ 1835 3219 738
+ 3220 1899 1061
+ 851 3220 3785
+ 3221 3013 1218
+ 1509 3221 2307
+ 3222 2701 1513
+ 2494 3222 1513
+ 3223 1637 2382
+ 3080 3223 2250
+ 3224 907 2082
+ 1350 3224 3997
+ 3225 3376 587
+ 3545 3225 588
+ 3611 1674 3511
+ 1462 3226 2578
+ 3227 155 11
+ 1321 3227 3307
+ 3228 1676 1136
+ 2062 3228 1136
+ 3229 2564 1609
+ 1557 3686 3762
+ 3230 1078 2175
+ 1357 3950 2175
+ 3231 1830 387
+ 1468 3231 2784
+ 3232 7 3282
+ 1257 3232 3274
+ 3233 1626 2236
+ 1235 3233 2236
+ 3234 1577 2117
+ 1459 3234 2351
+ 3235 2886 1335
+ 1545 3235 1940
+ 3236 719 1984
+ 1061 3236 1984
+ 3237 803 2015
+ 977 3237 2015
+ 3238 2477 1502
+ 2438 3238 1226
+ 3239 1359 2011
+ 1624 3239 2760
+ 3240 2354 975
+ 54 3240 1470
+ 3241 2152 1023
+ 743 3241 3324
+ 3242 1138 2063
+ 705 3242 2063
+ 3243 275 2160
+ 1262 3243 2160
+ 3244 1153 2221
+ 718 3244 2221
+ 3245 1219 3014
+ 3840 3245 846
+ 3648 1440 1777
+ 469 3246 468
+ 3247 2209 1737
+ 847 3247 3713
+ 3248 2752 1674
+ 1305 3248 1674
+ 3249 1820 930
+ 1378 3249 2049
+ 3250 807 2702
+ 1204 3250 2702
+ 3251 1189 2665
+ 2668 3251 834
+ 3252 2809 1734
+ 2271 3252 909
+ 3253 3262 867
+ 1156 3253 2696
+ 3254 2114 1292
+ 2228 3254 1292
+ 3255 2147 1797
+ 913 3255 1392
+ 3256 2268 756
+ 1306 3256 2083
+ 3257 1288 3455
+ 2759 3257 1682
+ 3258 2849 767
+ 1446 3258 2750
+ 3259 2341 759
+ 2359 3259 1414
+ 3260 2078 1245
+ 2371 3260 1245
+ 3261 1895 49
+ 3942 3261 480
+ 3262 1859 1108
+ 2259 3262 1108
+ 3263 2587 1147
+ 1374 3263 3788
+ 3264 514 3558
+ 3442 3264 1375
+ 3265 3436 516
+ 1621 3265 517
+ 3266 1989 1334
+ 2000 3266 1334
+ 3267 1248 2884
+ 264 3267 2884
+ 3268 2881 260
+ 1249 3268 1811
+ 3269 2882 1250
+ 1810 3269 1250
+ 3270 4024 1247
+ 2883 3270 1247
+ 3271 1248 1811
+ 2884 3271 263
+ 3272 1858 2711
+ 1307 3272 3519
+ 3273 3798 1349
+ 1987 3273 1349
+ 3274 1670 14
+ 1257 3274 2247
+ 3275 707 1618
+ 1993 3275 1128
+ 3276 1382 2676
+ 1830 3276 387
+ 3277 3057 1781
+ 1293 3277 1781
+ 3278 740 3390
+ 1152 3278 3786
+ 3279 2412 1279
+ 3378 3279 1279
+ 3827 2713 1641
+ 590 3280 1641
+ 3281 1284 1732
+ 1685 3281 2321
+ 3282 1415 3397
+ 3232 3282 1670
+ 3283 1524 3949
+ 1895 3283 479
+ 3284 2412 3017
+ 1279 3284 2467
+ 3285 3385 1263
+ 1813 3285 1263
+ 3286 2766 1147
+ 1317 3286 3204
+ 3287 2590 1525
+ 827 3287 3601
+ 3288 1685 2321
+ 1458 3288 2223
+ 3289 1531 2441
+ 2550 3289 1176
+ 3290 1920 1342
+ 1918 3290 1342
+ 3291 317 318
+ 1343 3291 1981
+ 3292 1982 1344
+ 1944 3292 1344
+ 3293 2831 2143
+ 1288 3293 2143
+ 3294 1289 2144
+ 2832 3294 2144
+ 3295 1596 2142
+ 2114 3295 1292
+ 3296 3526 1290
+ 2147 3296 1290
+ 3297 1518 2179
+ 1789 3297 740
+ 3298 1139 2138
+ 731 3298 2138
+ 3299 874 1839
+ 1258 3299 3991
+ 3300 1337 2092
+ 640 3300 639
+ 3301 1838 873
+ 1256 4027 1974
+ 3302 2167 1347
+ 1928 3302 1347
+ 3303 1606 534
+ 1599 3303 535
+ 3304 2296 1146
+ 395 3304 1897
+ 3305 757 2032
+ 1261 3305 3398
+ 3306 282 3698
+ 1661 3306 3960
+ 3307 2322 1057
+ 1321 3307 2406
+ 3308 1522 3963
+ 1932 3308 44
+ 3309 1931 1521
+ 454 3309 3962
+ 3310 2476 1187
+ 344 3310 1922
+ 3311 2827 1385
+ 2708 3311 1385
+ 3312 238 239
+ 1366 3312 2106
+ 3313 1732 1284
+ 2494 3313 1284
+ 3314 1932 44
+ 2275 3314 441
+ 3315 3341 1285
+ 1690 3315 1285
+ 3614 2748 1834
+ 706 3316 1834
+ 3317 1641 1376
+ 589 3317 3545
+ 3318 2333 1195
+ 2493 3318 1891
+ 3319 1693 2915
+ 2607 3319 1447
+ 3320 1555 634
+ 1646 3320 635
+ 3321 2058 1278
+ 2926 3321 1278
+ 3322 3109 1568
+ 3152 3322 1568
+ 3323 3903 1388
+ 3462 3323 1388
+ 3324 1960 1314
+ 2052 3324 1314
+ 3325 2003 2935
+ 1185 3325 2935
+ 3326 3080 2198
+ 1441 3326 2198
+ 3327 1524 1895
+ 1520 3327 1895
+ 3328 1894 2079
+ 837 3328 2079
+ 3329 1604 580
+ 2059 3329 581
+ 3330 1774 971
+ 1739 3330 971
+ 3331 2344 1436
+ 2496 3331 1436
+ 3332 2277 773
+ 1613 3332 2258
+ 3333 2124 986
+ 597 3333 1837
+ 3334 2050 1318
+ 1796 3664 677
+ 3772 664 1867
+ 947 3335 1867
+ 3336 443 2315
+ 1266 3336 2315
+ 3337 983 1870
+ 701 3337 1870
+ 3338 3256 1306
+ 2542 3338 1504
+ 3339 2491 1649
+ 1828 3339 973
+ 3340 772 2273
+ 1141 3340 2273
+ 3341 3315 1633
+ 891 3341 3345
+ 3342 1522 1932
+ 2943 3342 1932
+ 3343 972 3884
+ 2701 3343 1728
+ 3983 1561 3710
+ 2207 3344 736
+ 3345 1633 2805
+ 2160 3345 1262
+ 3346 2581 1777
+ 2161 3346 893
+ 3347 745 1908
+ 1267 3347 3454
+ 3348 1310 2921
+ 1575 3348 2609
+ 3349 2077 1574
+ 2693 3349 1574
+ 3662 1831 932
+ 2775 3350 1336
+ 3351 3130 821
+ 1811 3351 3126
+ 3957 1682 3455
+ 2224 3352 1439
+ 3353 1681 989
+ 3200 3353 1438
+ 3354 1403 2095
+ 2231 3354 303
+ 3355 907 3626
+ 2082 3355 1156
+ 3356 1746 946
+ 1345 3356 2222
+ 3357 1731 294
+ 1510 3357 295
+ 3358 2694 1565
+ 3067 3358 1565
+ 3359 27 300
+ 3540 3359 300
+ 3798 1617 2978
+ 3367 3360 782
+ 3361 661 1887
+ 1286 3361 3451
+ 3362 290 1992
+ 1548 3362 1992
+ 3363 2410 415
+ 2159 3363 37
+ 3364 425 426
+ 1545 3804 1880
+ 3365 675 1857
+ 2360 3365 1857
+ 3366 1554 1861
+ 1337 3366 2092
+ 3367 2860 1283
+ 1591 3367 3864
+ 3368 2567 1162
+ 1541 3368 2641
+ 3369 1576 906
+ 1886 3369 2186
+ 3370 2310 1449
+ 1817 3370 929
+ 3669 1017 2216
+ 717 3371 2216
+ 3372 3805 1325
+ 2234 3372 1325
+ 3373 1413 2740
+ 1317 3373 3286
+ 3374 771 2486
+ 1553 3374 2486
+ 3375 1161 2651
+ 429 3375 2651
+ 3376 3694 586
+ 1234 3376 3225
+ 3377 1582 2937
+ 1559 3377 2937
+ 3378 1638 3279
+ 1771 3378 1279
+ 3379 1861 1554
+ 1325 3379 2234
+ 3380 1498 2623
+ 1405 3380 2623
+ 3381 3932 950
+ 1226 3381 2032
+ 3382 2744 1231
+ 3616 3382 1231
+ 3383 841 1779
+ 2136 3383 1276
+ 3384 860 2175
+ 1078 3384 2175
+ 3385 2682 1263
+ 1669 3385 3285
+ 3386 1170 1871
+ 2028 3386 653
+ 3387 1473 2567
+ 1470 3859 2522
+ 3388 42 3877
+ 3539 3388 1369
+ 3389 1282 2589
+ 1223 3389 2589
+ 3390 3117 1707
+ 3278 3390 1707
+ 3391 685 3170
+ 3086 3391 1514
+ 3392 363 364
+ 1322 3392 1794
+ 3393 1323 2281
+ 359 3393 358
+ 3394 2074 3640
+ 1328 3394 1985
+ 3395 1986 1327
+ 2073 3395 1327
+ 3396 1970 1258
+ 2243 3396 1258
+ 3397 1415 3215
+ 1670 3397 14
+ 3398 2032 950
+ 1261 3398 2019
+ 3399 1 2027
+ 1053 3399 2027
+ 3400 2031 1300
+ 1888 3631 692
+ 3401 3012 1506
+ 3056 3401 895
+ 3402 2321 1480
+ 1479 3402 3587
+ 3403 2287 1135
+ 1689 3403 2844
+ 3404 340 341
+ 1438 3404 2408
+ 3405 1439 2409
+ 339 3405 338
+ 3406 1684 3195
+ 172 3406 3967
+ 3407 1759 1316
+ 2475 3407 1316
+ 3408 2421 764
+ 1318 3408 2845
+ 3409 929 1847
+ 1168 3409 1847
+ 3410 1929 1315
+ 2212 3410 1315
+ 3411 1371 2295
+ 603 3411 602
+ 3412 2303 1028
+ 2809 3412 1734
+ 3413 2630 1570
+ 3619 3413 1570
+ 3414 3620 1571
+ 2629 3414 1571
+ 3551 2048 949
+ 2334 3415 1298
+ 3416 447 2240
+ 1235 3416 2240
+ 3417 3360 1591
+ 2752 3417 1591
+ 3418 1312 2124
+ 600 3418 599
+ 3419 1874 1244
+ 1976 3419 1244
+ 3420 2042 931
+ 1444 3420 3625
+ 3421 1063 2056
+ 3206 3421 752
+ 3422 1405 2623
+ 2219 3422 35
+ 3423 2841 1877
+ 921 3423 1877
+ 3424 1352 2599
+ 31 3424 2599
+ 3425 2883 1247
+ 242 3425 2262
+ 3426 2468 1300
+ 2031 3426 1300
+ 3427 3149 1516
+ 3020 4008 1516
+ 3428 2603 1676
+ 2419 3428 1676
+ 3429 2422 1590
+ 3984 3585 1590
+ 3430 2436 1062
+ 3194 3430 1353
+ 3431 1264 3755
+ 2430 3431 665
+ 3432 2180 923
+ 593 3432 3743
+ 3433 855 3710
+ 1181 3433 2718
+ 3434 846 3978
+ 676 3709 1797
+ 3435 3752 1497
+ 615 3435 3940
+ 3436 3265 1243
+ 1990 3436 1243
+ 3437 1950 1190
+ 2055 3437 1190
+ 3438 418 1902
+ 2756 3438 1209
+ 3439 464 2755
+ 1208 3439 2755
+ 3440 1974 16
+ 2284 3440 16
+ 3441 2402 1326
+ 1921 3441 1326
+ 3442 2674 1563
+ 3574 3442 1375
+ 3443 939 1936
+ 1206 3443 1936
+ 3444 1933 1145
+ 1457 3444 2773
+ 3445 2784 389
+ 1324 3445 2102
+ 3446 269 2698
+ 1188 3446 2698
+ 3447 1193 2600
+ 805 3447 2600
+ 3448 1355 3007
+ 1456 3448 3007
+ 3449 1848 965
+ 659 3449 3584
+ 3450 1785 1120
+ 2309 3450 1740
+ 3451 3361 1887
+ 926 3451 1887
+ 3452 2434 1237
+ 2205 3452 1237
+ 3453 995 1812
+ 2548 3453 1812
+ 3454 1908 923
+ 1267 3454 2180
+ 3455 1288 2143
+ 3957 3455 862
+ 3456 1681 3353
+ 1289 3456 2144
+ 3457 1504 3338
+ 2202 3457 1306
+ 3458 2054 1473
+ 3387 3458 1473
+ 3459 2291 1395
+ 3828 3459 1395
+ 3460 2053 1377
+ 825 3460 3195
+ 3461 1721 1829
+ 618 3461 1829
+ 3462 2141 3323
+ 2609 3462 1748
+ 3747 2974 1361
+ 2542 4034 1030
+ 3464 2360 1651
+ 2501 3464 1651
+ 3465 1795 3062
+ 1457 3465 3444
+ 3466 2064 2967
+ 1942 3466 873
+ 3467 1475 2987
+ 1534 3467 2987
+ 3468 3875 1432
+ 1652 3468 2685
+ 3469 2863 1701
+ 2384 3469 753
+ 3470 1329 1911
+ 2489 3470 1393
+ 3471 1451 1765
+ 3969 3471 654
+ 4016 1948 3666
+ 2223 3472 1458
+ 3473 2365 1542
+ 562 3473 561
+ 3474 2342 1452
+ 3187 3474 1675
+ 3475 1773 1783
+ 626 3475 1783
+ 3476 1308 2029
+ 2410 3476 415
+ 3477 2417 1085
+ 2874 3477 1304
+ 3478 2420 1091
+ 2878 3478 1303
+ 3479 2155 1295
+ 2218 3479 1295
+ 3480 2612 1557
+ 1941 3480 1557
+ 3481 3066 883
+ 1826 3481 3028
+ 3482 2119 727
+ 2348 3482 1666
+ 3977 968 1969
+ 833 3483 1969
+ 3484 1157 1802
+ 698 3484 1802
+ 3485 3115 1910
+ 1272 3485 1910
+ 3486 2566 1860
+ 1576 3486 1860
+ 3487 1407 2413
+ 337 3487 336
+ 3488 342 343
+ 1408 3488 2383
+ 3489 1863 1160
+ 924 3489 1819
+ 3490 925 1818
+ 1862 3490 1161
+ 3491 1040 1845
+ 2217 3491 1845
+ 3492 1319 2226
+ 99 3492 2226
+ 3493 1320 2428
+ 2227 3493 90
+ 3494 1536 2751
+ 2089 3494 1028
+ 3495 1584 2936
+ 1365 3495 2936
+ 3496 776 2604
+ 1210 3496 2604
+ 3497 1299 3535
+ 894 3497 3833
+ 3498 699 1710
+ 2330 3498 1710
+ 3499 1026 2326
+ 1348 3499 2326
+ 3500 3775 1519
+ 2847 3500 1519
+ 3501 956 1766
+ 715 3501 1766
+ 3502 1876 284
+ 1800 3502 285
+ 3503 1376 2713
+ 2848 3503 1157
+ 3504 1191 2395
+ 348 3504 2395
+ 3505 2453 1630
+ 1453 3505 3862
+ 3506 772 3966
+ 1450 3861 3870
+ 3507 3751 1611
+ 2932 3507 1611
+ 3508 1071 1926
+ 918 3508 1926
+ 3509 1212 2944
+ 253 3509 2944
+ 3510 1663 2875
+ 1546 3510 3674
+ 3511 2123 2905
+ 3611 3511 1330
+ 3512 2759 1681
+ 2871 3512 1289
+ 3513 1253 2598
+ 1348 3513 2598
+ 3514 1263 2048
+ 1813 3514 784
+ 3515 1823 3150
+ 1793 3515 1229
+ 3516 2343 1485
+ 2017 3516 1485
+ 3517 2002 910
+ 1390 3517 2043
+ 3518 1222 2442
+ 651 3518 2442
+ 3519 903 3182
+ 1307 3519 3182
+ 3520 1145 1933
+ 715 3520 1933
+ 3521 1956 1400
+ 1997 3521 1400
+ 3522 311 312
+ 1401 3522 1957
+ 3523 2118 1471
+ 2131 3523 1471
+ 3524 139 140
+ 1381 3524 2065
+ 3525 559 3958
+ 3788 3525 1374
+ 3526 2172 1290
+ 1637 3526 3296
+ 3527 2712 1158
+ 1678 3527 2318
+ 3528 3612 1403
+ 2231 3528 1403
+ 3529 3258 1446
+ 2717 3529 1446
+ 3530 2564 1496
+ 2387 3530 678
+ 3531 3872 867
+ 1410 3531 2259
+ 3532 2200 1450
+ 1917 3870 3861
+ 3533 2158 679
+ 1310 3533 2466
+ 3534 669 2551
+ 1946 3534 2551
+ 3535 1299 2235
+ 2481 3535 951
+ 3536 1168 2856
+ 625 3536 2856
+ 3537 2749 1720
+ 1321 3537 1720
+ 3538 1798 3044
+ 3287 3538 1523
+ 3539 1635 3388
+ 2345 3539 1369
+ 3540 300 301
+ 1532 3540 2095
+ 3541 1675 2636
+ 911 3541 2636
+ 3542 2292 744
+ 1313 3542 2777
+ 3543 1338 2455
+ 3030 3543 1111
+ 3544 2781 851
+ 1784 3544 3069
+ 3545 1883 3225
+ 1376 3545 3317
+ 3546 1748 3462
+ 134 3546 3903
+ 3547 755 2178
+ 1067 3547 2178
+ 3548 788 2579
+ 1993 3548 2579
+ 3549 1534 2864
+ 1627 3549 2864
+ 3550 3042 1476
+ 1985 3550 2379
+ 3551 949 2100
+ 3029 3551 2100
+ 3552 1452 2342
+ 1586 3552 2350
+ 3553 1992 2892
+ 1548 3553 3700
+ 3554 1382 3178
+ 2756 3554 417
+ 3555 2684 1383
+ 2755 3555 1383
+ 3556 1595 2602
+ 471 3556 470
+ 3557 1940 3235
+ 2258 3557 1335
+ 3558 3436 1990
+ 1375 3558 1990
+ 3559 1338 2222
+ 2109 3559 946
+ 3560 899 3870
+ 1339 3560 3966
+ 3561 2416 762
+ 1087 3561 1851
+ 3562 2640 1558
+ 3107 3562 1558
+ 3563 2327 1274
+ 2680 3563 2096
+ 3564 2868 1716
+ 1274 3564 2096
+ 3565 1708 2896
+ 1614 3565 3829
+ 3566 2647 578
+ 1566 3566 579
+ 3567 2424 91
+ 1471 3567 2131
+ 3568 2425 1472
+ 2132 3568 1472
+ 3569 1359 2460
+ 1959 3569 2460
+ 3570 2414 1051
+ 1240 3570 2398
+ 3571 1799 936
+ 2341 3571 1980
+ 3572 2950 1273
+ 132 3572 2541
+ 3573 3592 768
+ 1477 3573 1923
+ 3574 1375 1990
+ 2793 3574 804
+ 3575 1946 2859
+ 2149 3575 808
+ 3576 2324 914
+ 1391 3907 2440
+ 3577 1133 1823
+ 1908 3577 923
+ 3578 2098 735
+ 2609 3578 1575
+ 3579 1677 2319
+ 2749 3579 1159
+ 3580 1271 2282
+ 924 3580 2282
+ 3581 3054 1488
+ 1986 3581 2378
+ 3582 2288 1499
+ 1743 3582 1499
+ 3583 1498 2289
+ 404 3583 403
+ 3584 2484 659
+ 3340 3584 1615
+ 3585 3429 1590
+ 64 3585 1924
+ 3586 1472 2425
+ 2675 3586 1015
+ 3587 3402 1480
+ 2863 3587 785
+ 3588 1329 2489
+ 2700 3588 1046
+ 3589 2336 1043
+ 746 3589 4031
+ 3590 2337 1045
+ 747 3590 4030
+ 3591 3530 1496
+ 1849 3591 1050
+ 3592 2125 1195
+ 768 3592 1754
+ 3593 3745 94
+ 95 3593 5
+ 3594 675 3365
+ 3097 3594 1333
+ 3595 1620 2494
+ 713 3595 3831
+ 3596 496 1708
+ 3565 3596 1708
+ 3597 1332 4029
+ 933 3597 2130
+ 3598 2241 1790
+ 3041 3598 895
+ 3599 847 2785
+ 1165 3599 2785
+ 3600 1522 3342
+ 1657 3817 2928
+ 3818 1656 2930
+ 1525 3601 3287
+ 3602 1369 2400
+ 1481 3602 2400
+ 3603 817 3941
+ 1315 3603 2129
+ 3604 2788 1537
+ 2814 3604 1537
+ 3605 2293 1370
+ 3048 3605 1370
+ 3606 1107 2373
+ 2432 3606 771
+ 3607 3748 1322
+ 2396 3607 1794
+ 3608 1667 3891
+ 3006 3608 1664
+ 3609 1608 2920
+ 2613 3609 1082
+ 3610 3533 1310
+ 2076 3610 1310
+ 3611 1330 3226
+ 819 3611 3226
+ 3612 2095 1403
+ 1650 3612 3528
+ 3613 1892 1278
+ 1941 3613 2761
+ 3614 1834 3316
+ 1389 3614 3316
+ 3615 4015 1380
+ 3041 3615 1380
+ 3616 2271 909
+ 3382 3616 2016
+ 3617 433 2282
+ 3059 3617 1271
+ 3618 3645 935
+ 1275 3618 2234
+ 3619 1840 3413
+ 2632 3619 1570
+ 3620 2631 1571
+ 1841 3620 3414
+ 3621 2154 1294
+ 2112 3621 1294
+ 3622 3797 1295
+ 2155 3622 1295
+ 3623 1447 2915
+ 650 3623 649
+ 3624 702 1770
+ 2567 3624 1770
+ 3625 2776 1444
+ 1301 3625 3420
+ 3626 907 2617
+ 1265 3626 2617
+ 3627 1825 1060
+ 1822 3627 1060
+ 3628 2251 490
+ 2731 3628 48
+ 3629 1544 2635
+ 372 3629 371
+ 3630 2917 1809
+ 1354 3630 3680
+ 3631 1300 2411
+ 3400 3631 1888
+ 3632 2594 1508
+ 2025 3632 3237
+ 3633 963 2105
+ 809 3821 2105
+ 3634 3863 931
+ 1254 3634 2140
+ 3635 2229 1368
+ 1979 3635 1368
+ 3636 1977 1367
+ 2230 3636 1367
+ 3637 1706 1865
+ 2736 3637 1865
+ 3638 746 3395
+ 2073 3638 3395
+ 3639 878 2933
+ 1083 3639 2933
+ 3640 1044 2337
+ 3394 3640 747
+ 3641 2078 3260
+ 1573 3641 3045
+ 3642 732 1963
+ 1293 3642 4026
+ 3643 2232 1372
+ 1973 3643 1372
+ 3644 1983 1373
+ 2233 3644 1373
+ 3645 2473 1733
+ 1967 3645 3618
+ 3646 3209 1267
+ 47 3646 2180
+ 3647 813 2596
+ 1031 3647 2596
+ 3648 1777 467
+ 3246 3648 468
+ 3649 1735 3023
+ 1493 3649 3084
+ 3650 2544 1542
+ 1374 3650 3263
+ 3651 1633 3315
+ 3923 3651 711
+ 3652 905 1880
+ 2716 3652 1880
+ 3653 1093 2050
+ 845 3653 2050
+ 3654 1454 2027
+ 62 3654 61
+ 3655 1275 2234
+ 2659 4014 1379
+ 3656 2854 1460
+ 2770 3656 1460
+ 3695 1465 2442
+ 2681 3657 1222
+ 3658 3468 1652
+ 2212 3658 1652
+ 3659 1381 3483
+ 833 3659 3483
+ 3660 1746 1362
+ 2374 3660 1362
+ 3661 1856 1112
+ 2278 3661 1963
+ 3662 3663 1336
+ 3350 3662 1336
+ 3663 1978 783
+ 1336 3663 2199
+ 3664 1318 2532
+ 3334 3664 1796
+ 3665 3145 1768
+ 2746 3665 1768
+ 3666 3288 1458
+ 4016 3666 1458
+ 3667 2763 647
+ 1693 3667 648
+ 3668 2973 1307
+ 3182 3668 1307
+ 3669 2216 3371
+ 1276 3669 3371
+ 3670 1735 3649
+ 1493 3670 3649
+ 3671 3359 1532
+ 2538 3671 1532
+ 3672 939 3443
+ 1533 3672 3443
+ 3673 2342 1462
+ 2745 3673 1462
+ 3674 2280 1039
+ 1546 3674 2644
+ 3675 2294 661
+ 1431 3675 2503
+ 3676 1465 1741
+ 3885 3676 1666
+ 3677 1225 2633
+ 2198 3677 544
+ 3678 946 1852
+ 2109 3678 1212
+ 3679 886 2861
+ 1743 3679 2861
+ 3680 3630 2493
+ 663 3680 2493
+ 3783 1744 721
+ 3093 3681 1505
+ 3682 1527 3840
+ 2312 3682 1062
+ 3683 492 493
+ 1469 3683 2347
+ 3684 1311 3690
+ 2077 3684 959
+ 3685 1951 2496
+ 2867 3685 1436
+ 3686 3229 1609
+ 2612 3686 1557
+ 3687 1285 2746
+ 892 3687 2746
+ 3688 2838 1659
+ 2101 3688 1659
+ 3689 789 3426
+ 2031 3689 3426
+ 3690 2163 3148
+ 2228 3690 680
+ 3691 1404 2747
+ 2907 3691 1434
+ 3692 2585 1142
+ 1613 3692 3332
+ 3693 3138 1464
+ 1824 3693 1464
+ 3694 1445 585
+ 1914 3694 3376
+ 3695 2977 1741
+ 3657 3695 2442
+ 3696 1691 2618
+ 1465 3696 2442
+ 3697 1955 928
+ 1463 3697 3134
+ 3698 2939 1182
+ 3306 3698 1855
+ 3699 2090 1236
+ 1923 3699 1236
+ 3700 2069 1020
+ 1548 3700 2518
+ 3701 3038 1623
+ 2646 3701 1623
+ 3702 3045 1487
+ 2824 3702 1487
+ 3703 2487 1884
+ 2133 3703 1137
+ 3704 1370 2260
+ 2174 3704 656
+ 3705 151 2767
+ 148 3705 2767
+ 3706 2768 160
+ 162 3706 161
+ 3707 2398 1051
+ 3129 3707 1477
+ 3708 2094 1491
+ 2891 3708 1491
+ 3709 1353 3434
+ 1797 3709 3434
+ 3710 2892 1619
+ 3344 3983 1619
+ 3711 1459 2365
+ 3473 3711 2365
+ 3712 3543 1831
+ 3350 3712 1831
+ 3713 1737 2976
+ 2785 3713 1399
+ 3714 1037 1804
+ 818 3714 1804
+ 3715 2292 1025
+ 1929 3715 1025
+ 3716 108 109
+ 1424 3716 2803
+ 3717 1418 2798
+ 197 3717 196
+ 3718 1418 2655
+ 125 3718 124
+ 3719 3081 1417
+ 2393 3719 1417
+ 3720 110 111
+ 1426 3720 2038
+ 3721 128 8
+ 1425 3721 1879
+ 3722 1420 2033
+ 127 3722 126
+ 3723 114 115
+ 1419 3723 2035
+ 3724 112 113
+ 1416 3724 2037
+ 3725 2858 1429
+ 2040 3725 1429
+ 3726 15 231
+ 1428 3726 2801
+ 3727 26 304
+ 1429 3727 2800
+ 3728 2039 1430
+ 2800 3728 1430
+ 3729 32 322
+ 1417 3729 2653
+ 3730 307 25
+ 1428 3730 2947
+ 3731 2036 1426
+ 2804 3731 1426
+ 3732 1430 2801
+ 233 3732 232
+ 3733 2797 1427
+ 2034 3733 1427
+ 3734 2802 1427
+ 2035 3734 1427
+ 3735 2804 1416
+ 2799 3735 1416
+ 3736 2799 1419
+ 2797 3736 1419
+ 3737 1420 2796
+ 195 3737 194
+ 3738 2796 1425
+ 3139 3738 1425
+ 3739 2654 1424
+ 2036 3739 1424
+ 3740 1884 660
+ 1758 3740 3180
+ 3741 1481 2862
+ 1563 3741 2862
+ 3742 1705 2468
+ 3161 3742 789
+ 3743 1793 1567
+ 592 3743 1567
+ 3744 2197 1351
+ 3122 3744 1351
+ 3745 93 94
+ 1723 3745 3593
+ 3746 1723 3593
+ 96 3746 95
+ 3747 1411 2974
+ 3463 3747 1361
+ 3748 3607 2246
+ 971 3748 2246
+ 3749 3075 1625
+ 2606 3749 1055
+ 3750 170 2053
+ 966 3750 2053
+ 3751 502 1611
+ 1757 3751 3507
+ 3752 2184 1497
+ 1654 3752 3435
+ 3753 1367 2687
+ 2830 3753 1368
+ 3754 2325 1109
+ 3133 3754 1639
+ 3755 2496 906
+ 3431 3755 1860
+ 3756 1324 2071
+ 436 3756 2071
+ 3757 142 1673
+ 2065 3757 968
+ 3758 1894 2736
+ 1169 3758 2736
+ 3759 2582 683
+ 3835 3759 683
+ 3760 1386 2636
+ 1675 3760 2636
+ 3761 2693 1574
+ 2098 3761 735
+ 3762 3686 1609
+ 3508 3762 1609
+ 3763 1273 2950
+ 1547 3763 2950
+ 3764 1940 773
+ 1216 3764 3025
+ 3765 2061 920
+ 1409 3765 2854
+ 3766 1312 2145
+ 978 3766 2145
+ 3767 1536 3494
+ 1952 3767 791
+ 3768 2264 1259
+ 2573 3768 1259
+ 3769 1442 1964
+ 1702 3769 1964
+ 3770 3140 1434
+ 2166 3770 2717
+ 3771 3380 1405
+ 1767 3771 1405
+ 3772 1356 2044
+ 3335 3772 1867
+ 3773 1373 2670
+ 2826 3773 1372
+ 3774 3531 1410
+ 1770 3774 1410
+ 3775 2055 1519
+ 1846 3775 3500
+ 3776 2607 1447
+ 2480 3776 1447
+ 3777 1546 575
+ 3510 3777 1663
+ 3778 3566 1566
+ 2511 3778 1566
+ 3779 858 2898
+ 1802 3779 2898
+ 3780 1174 2242
+ 653 3780 2242
+ 3781 1022 2055
+ 877 3781 2055
+ 3782 2204 997
+ 1632 3782 2308
+ 3783 3681 1744
+ 1505 3783 2498
+ 3784 2511 1566
+ 2625 3784 1566
+ 3785 3320 1646
+ 3069 3785 1646
+ 3786 3948 1440
+ 2602 3786 3246
+ 3787 2904 1593
+ 3147 3787 1593
+ 3788 1627 3525
+ 1147 3788 3263
+ 3789 936 2148
+ 1182 3789 2148
+ 3790 805 1883
+ 3545 3790 1883
+ 3791 2962 1492
+ 2722 3791 1492
+ 3792 760 2140
+ 1360 3792 3876
+ 3793 863 2663
+ 2173 3793 2663
+ 3794 9 1971
+ 979 3794 1971
+ 3795 979 2584
+ 1787 3795 2584
+ 3796 1697 3073
+ 638 3796 637
+ 3797 2569 1295
+ 2014 3797 3622
+ 3798 782 3360
+ 1349 3798 3360
+ 3799 542 543
+ 1332 3799 2633
+ 3800 2335 1268
+ 669 3800 2139
+ 3801 1785 2811
+ 836 3801 2811
+ 3802 3845 704
+ 2002 3802 2497
+ 3803 780 3911
+ 1346 3803 2161
+ 3804 38 1880
+ 3364 3804 1545
+ 3805 1889 3033
+ 2757 3805 703
+ 3806 1837 2729
+ 596 3806 2729
+ 3807 2983 1704
+ 1814 3807 1704
+ 3808 1127 2572
+ 2091 3808 2572
+ 3809 3050 1230
+ 1020 3809 2099
+ 3810 2820 1340
+ 1961 3810 1340
+ 3811 842 3883
+ 2311 3811 1435
+ 3812 1853 1792
+ 2176 3812 1118
+ 3813 989 2224
+ 3404 3813 2224
+ 3814 1002 2177
+ 1119 3814 2177
+ 3815 2817 1660
+ 3954 3815 1660
+ 3816 2720 1528
+ 2968 3816 1528
+ 3817 1657 3600
+ 828 3817 3600
+ 3818 3601 1656
+ 2958 3818 1521
+ 3819 1414 3039
+ 2047 3819 2718
+ 3820 1031 2004
+ 2705 3820 659
+ 3821 1366 3633
+ 2105 3821 3633
+ 3822 3303 1599
+ 2619 3822 1599
+ 3823 912 1972
+ 2762 3823 1972
+ 3824 2015 1371
+ 2239 3824 1371
+ 3825 3178 1468
+ 2866 3825 1468
+ 3826 2276 1122
+ 968 3826 1969
+ 3827 1641 3280
+ 1567 3827 3280
+ 3828 754 1824
+ 3459 3828 1824
+ 3829 3565 852
+ 1070 3829 2151
+ 3830 2281 1323
+ 972 3830 2263
+ 3831 3595 1513
+ 1728 3831 2701
+ 3832 959 2228
+ 1292 3832 2228
+ 3833 1764 1506
+ 3012 3833 1506
+ 3834 1296 2264
+ 3768 3834 2264
+ 3835 2265 3759
+ 1297 3835 2689
+ 3836 1675 3474
+ 2444 3836 1452
+ 3837 1450 2200
+ 2787 3837 456
+ 3838 2153 3143
+ 3987 3838 1467
+ 3839 2507 800
+ 1323 3839 2263
+ 3840 1527 3245
+ 2128 3840 846
+ 3841 1902 1011
+ 3154 3841 1869
+ 3842 1901 3439
+ 1868 3842 3155
+ 3843 1163 2685
+ 881 3843 2685
+ 3844 2659 1379
+ 2576 3844 730
+ 3845 1893 3188
+ 1655 3845 3802
+ 3846 3211 199
+ 1423 3846 2394
+ 3847 1421 2802
+ 3210 3847 119
+ 3848 1421 3216
+ 202 3848 3216
+ 3849 3214 324
+ 1422 3849 2274
+ 3850 374 3213
+ 1422 3850 3213
+ 3851 122 3217
+ 1423 3851 3217
+ 3852 1313 2714
+ 2389 3852 1314
+ 3853 2870 1725
+ 2695 3853 1725
+ 3854 1545 1940
+ 3364 3854 2879
+ 3855 3807 953
+ 3119 3855 8
+ 3856 2855 1402
+ 1857 3856 1402
+ 3857 1838 3301
+ 1256 3857 3301
+ 3858 2926 1744
+ 1789 3858 993
+ 3859 2724 1517
+ 2522 3859 1517
+ 3860 1725 2042
+ 2404 3860 802
+ 3861 1214 3506
+ 1917 3861 3506
+ 3862 2981 667
+ 1453 3862 1894
+ 3863 2024 1301
+ 3420 3863 1301
+ 3864 3367 1283
+ 991 3864 3168
+ 3865 1 3399
+ 2515 3865 1501
+ 3866 1531 2520
+ 449 3866 448
+ 3867 1061 1984
+ 2051 3867 1213
+ 3868 842 2311
+ 952 3868 2311
+ 3869 2824 1487
+ 3111 3869 1487
+ 3870 1917 3560
+ 3532 3870 899
+ 3871 2470 1413
+ 2061 3871 2738
+ 3872 2696 3253
+ 1671 3872 3531
+ 3873 2382 657
+ 1598 3873 2869
+ 3874 3035 1537
+ 2788 3874 1537
+ 3875 3468 1827
+ 974 3875 1827
+ 3876 3792 2140
+ 2870 3876 931
+ 3877 2400 1369
+ 3388 3877 1369
+ 3878 2431 792
+ 1827 3878 2117
+ 3879 815 1850
+ 2264 3879 1259
+ 3880 1260 2265
+ 816 3880 3920
+ 3881 2699 1475
+ 2842 3881 1475
+ 3882 3509 1600
+ 3141 3882 1877
+ 3883 2283 1397
+ 2009 3883 1397
+ 3884 972 1778
+ 713 3884 1778
+ 3885 1666 2979
+ 1691 3885 2618
+ 3886 2671 1448
+ 2643 3886 1919
+ 3887 1949 658
+ 1457 3887 3465
+ 3888 1101 2982
+ 2169 3888 1455
+ 3889 2350 982
+ 1308 3889 2029
+ 3890 2628 760
+ 1850 3890 2969
+ 3891 1667 569
+ 3608 3891 1664
+ 3892 2253 1448
+ 2671 3892 1448
+ 3893 2343 72
+ 1806 3893 73
+ 3894 1781 2158
+ 2672 3894 958
+ 3895 2106 3157
+ 1433 3895 3157
+ 3896 2732 1648
+ 1976 3896 1648
+ 3897 1861 2757
+ 3053 3897 1643
+ 3898 3066 2008
+ 745 3898 2008
+ 3899 2508 1184
+ 40 3899 1931
+ 3900 4012 1483
+ 1975 3900 1021
+ 3901 909 1765
+ 1451 3901 1765
+ 3902 4028 1449
+ 2310 3902 1449
+ 3903 1971 133
+ 1388 3903 3546
+ 3904 3680 1825
+ 3627 3904 1825
+ 3905 763 3644
+ 2233 3905 3644
+ 3906 2232 3643
+ 764 3906 3643
+ 3907 2869 1358
+ 2440 3907 1358
+ 3908 2748 1282
+ 2156 3908 1282
+ 3909 2221 1055
+ 2220 3909 1507
+ 3910 1410 2259
+ 2471 3910 748
+ 3911 780 2314
+ 1227 3911 2314
+ 3912 2229 3635
+ 762 3912 3635
+ 3913 761 3636
+ 2230 3913 3636
+ 3914 2906 2157
+ 934 3914 2157
+ 3915 1801 2880
+ 2177 3915 1119
+ 3916 1564 2127
+ 2 3916 84
+ 3917 1893 1009
+ 2487 3917 1009
+ 3918 1709 3177
+ 1390 3918 3517
+ 3919 1912 815
+ 2264 3919 3879
+ 3920 3880 2265
+ 1297 3920 2265
+ 3921 2331 2060
+ 1732 3921 3281
+ 3922 1512 2296
+ 398 3922 397
+ 3923 711 1799
+ 2080 3923 1131
+ 3924 2836 811
+ 1257 3924 2835
+ 3925 1398 2634
+ 1938 3925 823
+ 3926 947 4011
+ 1018 3926 1842
+ 3927 4005 682
+ 1303 3927 2552
+ 3928 2521 1588
+ 2709 3928 1588
+ 3929 2834 1255
+ 2833 3929 1255
+ 3930 1304 2306
+ 687 3930 4004
+ 3931 2666 1552
+ 3207 3931 1890
+ 3932 1443 2580
+ 1996 3932 3381
+ 3933 2782 1164
+ 627 3933 1773
+ 3934 2911 1559
+ 3144 3934 1559
+ 3935 2719 1357
+ 2175 3935 1357
+ 3936 380 2043
+ 1760 3936 2043
+ 3937 2105 1362
+ 2531 3937 1362
+ 3938 1407 2022
+ 3193 3938 2022
+ 3939 3325 2023
+ 1408 3939 2023
+ 3940 1497 2354
+ 615 3940 614
+ 3941 1217 2129
+ 3603 3941 2129
+ 3942 1520 3261
+ 481 3942 480
+ 3943 550 551
+ 1523 3943 2590
+ 3944 552 553
+ 1525 3944 2927
+ 3945 1383 2469
+ 2677 3945 400
+ 3946 659 2004
+ 1193 3946 2004
+ 3947 2660 1474
+ 2982 3947 1474
+ 3948 1777 1440
+ 3117 3948 1707
+ 3949 1524 2340
+ 3283 3949 478
+ 3950 1357 2346
+ 3230 3950 736
+ 3951 1884 1009
+ 2571 3951 1909
+ 3952 392 393
+ 1819 3952 2154
+ 3953 2885 1818
+ 2155 3953 1818
+ 3954 2160 3815
+ 2435 3954 1660
+ 3955 1835 738
+ 997 3955 1787
+ 3956 1637 3296
+ 1939 3956 913
+ 3957 3199 1439
+ 3352 3957 1439
+ 3958 2544 1374
+ 3525 3958 1374
+ 3959 1457 2773
+ 932 3959 2773
+ 3960 1855 3088
+ 1661 3960 3108
+ 3961 1385 2827
+ 2054 3961 702
+ 3962 3309 1521
+ 2930 3962 1521
+ 3963 1522 2929
+ 3308 3963 440
+ 3964 2994 2415
+ 3653 3964 1093
+ 3965 74 75
+ 1749 3965 3031
+ 3966 772 2445
+ 1339 3966 2445
+ 3967 3406 1377
+ 2053 3967 1377
+ 3968 76 77
+ 1753 3968 2491
+ 3969 1812 3471
+ 1411 3969 2490
+ 3970 3344 1619
+ 2104 3970 2892
+ 3971 1919 1448
+ 2253 3971 1448
+ 3972 2374 1362
+ 2919 3972 2105
+ 3973 2358 1445
+ 1914 3973 1445
+ 3974 1198 2924
+ 334 3974 2924
+ 3975 1877 1600
+ 2669 3975 1600
+ 3976 3499 1348
+ 2116 3976 1348
+ 3977 3483 1381
+ 2065 3977 1381
+ 3978 846 3014
+ 1392 3978 3014
+ 3979 3334 1796
+ 3013 3979 1391
+ 3980 2317 1504
+ 2353 3980 1504
+ 3981 1553 2698
+ 271 3981 270
+ 3982 868 3666
+ 1948 3982 3666
+ 3983 3344 1105
+ 1561 3983 2666
+ 3984 1590 2195
+ 1924 3984 3012
+ 3985 2999 1489
+ 2670 3985 1489
+ 3986 2808 1602
+ 2513 3986 1172
+ 3987 2136 3838
+ 3131 3987 1467
+ 3988 2115 2957
+ 2081 3988 2957
+ 3989 930 2137
+ 1197 3989 2137
+ 3990 743 2772
+ 1241 3990 2772
+ 3991 3299 1839
+ 2691 3991 770
+ 3992 1821 644
+ 1692 3992 646
+ 3993 730 2301
+ 1166 3993 2301
+ 3994 770 3441
+ 2539 3994 1921
+ 3995 1935 994
+ 1569 3995 2488
+ 3996 3400 1888
+ 2933 3996 1409
+ 3997 3224 2082
+ 2268 3997 756
+ 3998 2057 1441
+ 2198 3998 1441
+ 3999 1505 2498
+ 2509 3999 1233
+ 4000 2995 1503
+ 2687 4000 1503
+ 4001 1717 2708
+ 820 4001 2708
+ 4002 1441 2057
+ 2172 4002 940
+ 4003 2622 1905
+ 2457 4003 1469
+ 4004 2306 1328
+ 2379 4004 1328
+ 4005 1327 2378
+ 2305 4005 3927
+ 4006 1406 2975
+ 2971 4006 1515
+ 4007 2169 1396
+ 2324 4007 1396
+ 4008 881 3427
+ 1516 4008 3427
+ 4009 3089 1187
+ 1620 4009 2901
+ 4010 1049 2475
+ 2843 4010 1316
+ 4011 947 2843
+ 3191 4011 1316
+ 4012 3900 697
+ 1125 4012 2964
+ 4013 3032 1624
+ 2570 4013 1624
+ 4014 781 2190
+ 1379 4014 2190
+ 4015 3615 2063
+ 967 4015 2063
+ 4016 1458 3472
+ 354 4016 3472
+ 4017 1999 1057
+ 2026 4017 1762
+ 4018 3561 762
+ 1260 4018 2961
+ 4019 3282 105
+ 3212 4019 106
+ 4020 3104 908
+ 1650 4020 3612
+ 4021 2217 2963
+ 2087 4021 2963
+ 4022 915 2186
+ 2283 4022 1397
+ 4023 101 2994
+ 1509 4023 2994
+ 4024 1810 3125
+ 822 4024 3125
+ 4025 2309 1335
+ 2886 4025 1335
+ 4026 826 3277
+ 1293 4026 3277
+ 4027 2967 1974
+ 3301 4027 1256
+ 4028 2290 723
+ 1449 4028 1919
+ 4029 1332 2658
+ 794 4029 2658
+ 4030 3590 1912
+ 2823 4030 1296
+ 4031 3589 1913
+ 2822 4031 1297
+ 4032 1433 3071
+ 2168 4032 822
+ 4033 1022 2610
+ 1352 4033 2610
+ 4034 2349 1030
+ 1361 4034 3463
+ 4035 822 3125
+ 1250 4035 3125
+ 4036 807 3250
+ 1394 4036 3250
+ 4037 3460 1966
+ 2332 4037 1127
+ 4038 2146 1445
+ 2358 4038 1445
Index: /inundation/pymetis/metis-4.0/Graphs/test.mgraph
===================================================================
--- /inundation/pymetis/metis-4.0/Graphs/test.mgraph	(revision 2051)
+++ /inundation/pymetis/metis-4.0/Graphs/test.mgraph	(revision 2051)
@@ -0,0 +1,770 @@
+%% graph file %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% 1st line:  n, m
+%% ff lines:  vwgt1, vwgt2, adjacencies
+ 766  1314 10 2
+  1  1  479  389  571    2
+  2  2  395    1  534    4
+  4  4  148  207  409  498
+  4  4    2  729    6  695
+  4  4  572    6  708  393
+  2  2  571  727    4    5
+  2  2  746  397  575  573
+ 24  8  152  733  638  746
+  1  1  573  524   11   13
+  1  1   11  497  532   14
+  2  2   12  531   10    9
+  4  4  754  490  616   11
+  1  1    9  706  403   14
+  1  1   13   10   18   15
+  1  1   14  402  530   20
+ 24  8  742  692   17  581
+  4  4   16  109  116  620
+  1  1   14  512  535   20
+  1  1   20  404  408   24
+  1  1   18   15   19   22
+ 38  8  645  628  148  536
+  1  1   20  527  421   24
+ 24  8  179   28  629   30
+  1  1   19   22  513   27
+ 24  8  742  159  174   28
+  0  0  411  440  539  442
+  1  1   24  411  410  538
+ 24  8   25  254   23   29
+  4  4  174   28  750   30
+  4  4  596   23   29  745
+ 52  8  645  192  581  525
+  1  1   51  332  406
+  1  1  577  330   51
+  1  1  418  682  423
+ 68  8  711   36  606
+ 68  8  626   35  153
+  0  0   52  333  420
+  2  2  422  358  419
+  1  1   58  345  578
+  1  1   59  348   58
+ 68  8  208  144  734
+ 68  8  143  483  484
+  1  1   64  349  425
+  2  2   66  334  426
+ 68  8  579  141  427
+  0  0  420   50  339
+ 68  8  764   48  564
+ 68  8  587   47  443
+  2  2   62  673  687
+  0  0  578   46  565
+  1  1   33  584   32
+  0  0  406  429   37
+ 68  8  485  335  731
+ 68  8  758   55  519
+ 68  8  586   54  183
+  1  1  426   64  577
+  0  0  552  630
+  1  1   40  429   39
+  1  1  425  584   40
+  0  0  462
+ 68  8  308  162  647
+  4  4  690  431   49
+ 68  8  161  672  305
+  1  1  687   56   43
+ 68  8  588  168  253
+  4  4  368  431   44
+ 68  8  560   68  709
+ 68  8  500   67  196
+ 68  8  566  170  433
+ 68  8  724  163  366
+  1  1  113   97
+  1  1  177   79
+  1  1  601  142
+ 24  8   92  738  739
+ 24  8  454  644  595
+  1  1  545  146  502
+  1  1  591  351  435
+  1  1  344  436  437
+  1  1  146   72  487  434
+  1  1  103  354  439
+  2  2  437  463  115
+  1  1  601  304
+  2  2  109  174  592
+  0  0  110  355  440
+  1  1  112  353  441
+  0  0  440  442  593
+  0  0  263
+  1  1  444  381  111
+  0  0   91  442  357
+  8  8  594  740  732
+  0  0  445  446   89
+ 24  8  595  447   74
+  8  8  763  741  744
+  1  1  757  667  448
+  1  1  453  436  108
+ 52  8  130  686  208
+  1  1   71  268
+  1  1  304  157
+  0  0  101  100
+  0  0  474   99  126
+  0  0  474  630   99
+  1  1  117  383  107
+  1  1  441  449   80
+  2  2  116  207  338
+ 52  8  763  187  205  692
+ 24  8  713  447  763
+  1  1  102  449  444
+  2  2   95  388  450
+  4  4  742   17   83
+  1  1  439  451   84
+  1  1   88  451  445
+  1  1  435  452   85
+  1  1  309   71  282
+  0  0  743
+  4  4   81  119  454
+  4  4  744   17  104
+  1  1  448  452  102
+  1  1  178  600
+  4  4  450  115  661
+  1  1  356  178
+  1  1  601  602
+  0  0  123  460
+  0  0  663  122  248
+ 24  8  222  253
+ 24  8  603  461
+  0  0  100  248
+  4  4  220  218  604
+  1  1  549  685
+  0  0  529  234  567  151
+ 68  8  606   96
+  0  0  607  261  462
+ 68  8  417  711
+  1  1  550  608  267
+  1  1  649  214
+  1  1  235  611  704
+  1  1  280  219  613
+  0  0  654  221
+  1  1  266  211  615
+ 24  8  736  176
+ 24  8  579  558
+ 68  8  676   45  518
+  1  1  177   73  542
+ 68  8   42  526  191
+ 68  8  179   41  629
+  0  0  224  621
+  1  1   76   79  258
+ 68  8  468  747  731
+  8  8  391  392   21    3
+  4  4  346  556
+  2  2  639  229  232
+  0  0  464  129
+ 24  8  526  191    8  412
+ 52  8   36  738  712  167
+ 68  8  466  194  526
+ 52  8  496  695  753  748
+  2  2  350  623
+  1  1   98  465  309
+  1  1  233  217  238
+ 52  8  167  190  179   25
+ 68  8  644  595  626
+ 52  8  390   63  308
+ 68  8  697   61  749
+ 68  8  628   70  725
+  4  4  225  674
+ 68  8  629  726  191
+  4  4  710  328  169  318
+ 68  8  153  739  159
+ 68  8  631   65  751
+  4  4  721  166  398  490
+ 68  8  632   69  637
+  0  0  657  226
+ 68  8  253  603
+ 68  8  468  200  640
+  4  4   25   83  413   29
+  0  0  203  469  470
+ 52  8  564  139  609  240
+  1  1  142   72  438
+  1  1  455  120  118
+ 52  8  159  144  180   23
+ 24  8  190  179  208  596
+  4  4  237  659
+ 68  8  183  205  628
+ 64  8   55  568  735  182
+ 68  8  748  209  715
+  1  1  227  471
+  1  1  231  310
+ 68  8  447  105  739
+  1  1  215  650
+ 68  8  707  209  619
+ 24  8  159  686  180  413
+ 52  8  143  165  752  152
+ 68  8   31  726  618
+ 68  8  599  595  447
+ 68  8  624  154  733
+  1  1  241  635
+ 68  8   68  210  632
+  8  8  651  756  662
+ 24  8  387  683  651
+ 52  8  749  651  758  586
+ 68  8  641  173  528
+  0  0  252  239  256
+ 68  8  213  642  546
+  0  0  696  250  175
+ 24  8  759  694  386
+ 68  8  105  182  645
+  0  0  246  322
+  4  4  391  407  104    3
+ 52  8   96   41  180  223
+ 68  8  189  184  617
+ 68  8  546  196  624
+  1  1  646  138  354
+ 68  8  647  758
+ 68  8  475  202  648
+  1  1  134  610  233  330
+  1  1  290  260  472  188
+ 68  8  519  694
+  1  1  330  158  332
+  4  4  612  652  127
+  1  1  653  136  353
+  2  2  704  297  127
+  0  0  137  243  657
+ 24  8  604  588  124
+ 24  8  208  734  350
+  0  0  655  145  270  355
+  4  4  295  249  164  278
+  0  0  467  171  262  339
+  1  1  327  185  681  517
+  1  1  471  259  456
+  4  4  271  150  334
+  4  4  461  561  639
+  1  1  659  244  186
+  1  1  150  299  649
+  1  1  214  291  158
+  0  0  593  129  462
+  1  1  602  236  135
+  1  1  633  235  491
+  8  8  558  242  181
+  1  1  158  301  654
+  0  0  540  201  319
+ 24  8  176  718  579
+  1  1  310  247  195
+ 24  8  427  518  237  504
+  0  0  614  221  313  333
+  2  2  307  292  231  658
+  0  0  416  460  567
+  0  0  319  256  477  206
+  1  1  241  660  289  635
+  0  0  126  264  123
+  2  2  650  312  225
+  0  0  503  565  203
+  1  1  542  255  465
+  1  1  541  300  201
+ 52  8  124   65  172  554
+ 24  8  581   28  726  750
+  1  1  478  251  523
+  0  0  201  562  246
+  0  0  265  481  263
+  1  1  146  327  478
+  1  1  523  228  455
+  1  1  482  285  215
+  0  0  363  131  460
+  0  0  226  316  627
+  0  0  257  470   87
+  0  0  480  663  343  248
+  0  0  570  257
+  1  1  613  360  138
+  1  1  133  361  549
+  1  1   97  282  597
+  0  0  671  287
+  1  1  615  362  224
+ 24  8  582  315  229
+  1  1  670  284
+  0  0  621  688  547
+ 68  8  427  483
+  1  1  352  293
+ 68  8  734  484
+ 68  8  335  764
+  8  8  225  580  656  674
+  2  2  643  384
+  1  1  668  765  136
+ 68  8  485  414
+  1  1  113  356  458  268
+  4  4  486  387
+  1  1  272  665  381  348
+  1  1  487  260  590
+ 24  8  724  430  643
+  0  0  269  345  570
+ 24  8  324  636  320
+  1  1  488  247  321
+  1  1  548  365  215
+  1  1  537  233  329
+  2  2  318  244  634
+  1  1  428  275  383  349
+  2  2  491  341  297
+  2  2  650  723  225
+ 24  8  680  631  331
+  4  4  294  220  563
+  1  1  458  597  358  388
+  1  1  398  232  492
+  1  1  493  252  562
+  1  1  329  238  494
+  8  8  755  473  561
+  1  1  590  341  495
+  1  1   82   98  418
+ 68  8   63  761
+  1  1  492  317  537
+  4  4  504  659  675  244
+ 68  8  161   61
+  1  1  113  157  422
+  1  1  186  677  241
+ 24  8  676  473  559
+  4  4  495  249  669
+  0  0  494  326  243
+  1  1  635  374  540
+ 52  8  566  271  368
+  0  0  499  262  760
+  1  1  634  306  488
+  4  4  702  166  292
+  0  0  239  378  246
+ 24  8  288  475  678
+  1  1  289  501  493
+  0  0  206  679  474
+ 68  8  366  433
+ 24  8  669  432  288
+  1  1  550  471  361
+  0  0  313  562  499
+  1  1  502  258  227
+  2  2  561  166  398
+  1  1  291  501  301
+  1  1  214   33  217
+ 24  8  296  475  751
+  1  1  217   32  654
+  0  0  243   37  657  467
+  2  2  229   44  649
+ 52  8  585   53  277
+  1  1  602  682  611
+ 24  8  483  340  569
+  1  1  104  544  757
+  0  0  226   46  503
+ 24  8  484  337  372
+  2  2  303  727  294  708
+  0  0  343  469  416
+  0  0  720  264  342
+  1  1  608   78  549
+  1  1  671   39  700  287
+  2  2  685  463  149
+ 24  8  556  644  594
+  1  1  284   40  671
+  1  1  293   43  670
+  4  4  596  223  156  745
+  1  1  623   77  653
+  1  1  384  673  275
+  1  1  219   85  646
+  1  1  211   80  655
+  0  0  224   84  621  666
+  1  1  120  282  453
+  0  0   89  470  464
+  2  2  298   38  486
+  0  0  370  679  663
+  1  1  689  266  377
+  1  1  325  267  505
+  1  1  506  270  379
+  0  0  364  507  261
+  0  0  508  688  363
+  1  1  681  290  511
+ 52  8   70  323  430  698
+  2  2  505  691  369
+ 24  8  433  315   66
+  4  4  367  509  701
+  0  0  510  507  359
+  2  2  372  765  376
+  4  4  340  396  693  371
+  2  2  511  691  723
+  1  1  385  314  405
+  1  1  399  677  514
+  1  1  371  380  689
+  1  1  360  400  506
+  0  0  515  319  510
+  0  0  362  382  508
+  1  1  693  376  399
+  1  1  284   88  671
+  0  0  405  379  515
+  1  1  293  102  670
+  1  1  279  667  352
+  1  1  514  400  374
+ 24  8  401  204  766  407
+ 24  8  283  664  749  198
+  2  2  298  108  486
+  1  1  517    1  516  505
+ 24  8  419  496  697  161
+  8  8  401  744  148  207
+ 38  8  401  628  766  148
+ 24  8    5  468  707  619
+ 52  8  695  622  753  641
+  1  1  523  521  522    2
+  4  4  752  412  372  575
+  2  2  553    7  435  524
+  2  2  639  328  169  299
+  1  1  737  380  375  574
+  1  1  512  377  385  404
+ 24  8  735  392  386  391
+  1  1  449   15  444  408
+  1  1  452   13  441  449
+  1  1  400   19  506  405
+  1  1  374  404  513  382
+  1  1   32  421  614   52
+  4  4  386  207  409
+  1  1  402  439   19  451
+  4  4  766  407    3  643
+  1  1  429   27  578  420
+  1  1  451   27  445   26
+  4  4  152  717  396  746
+  4  4  190  174  596
+ 68  8  281  415  417
+ 52  8  701  424  640  414
+  0  0  459  529  342  245
+ 52  8  556  414  132
+  1  1  304  589  465   34
+  4  4  423   38  390
+  0  0   37  410  467   46
+  1  1  584  406   22  429
+  1  1  309  458  522   38
+  2  2  522   34  419  729
+ 24  8  463  415  625  556
+  1  1   43  530  665   59
+  1  1   44  531  532   56
+ 52  8   45  558  274  242
+  1  1  673  448  687  293
+  1  1  421   58   52  410
+ 24  8  366  286  690
+  4  4  533   66   62  531
+ 24  8  563  520  324  617
+ 52  8  323   69  368  533
+  1  1  478   79  438  699
+  1  1   77  397  653  112
+  1  1  521   78   95  534
+  1  1   78  605  534   81
+  1  1  542  177  434  633
+  1  1   80  408  655  110
+  0  0   84   26  666   86
+  1  1   85  403  646  103
+  0  0   26   89   86  529
+ 52  8  636   48  564  678
+  1  1  107  665  402   88
+  1  1  111  700  411   91
+  0  0  700  570   91  481
+ 52  8  193  106   92  187
+  1  1   94  524  428  117
+  1  1  403  107  402  103
+  4  4  534  108  622  119
+  1  1  408  111  110  411
+  1  1  524  112  117  403
+  1  1  356  521  458   95
+ 24  8  115  625  528   75
+  1  1  178  259  521  600
+  1  1  228  550  600
+ 24  8  483  504  526  675
+  1  1  282  422  453  298
+  0  0  507  416  663  460
+  0  0  459  261  245  122
+ 24  8  560  125  582  230
+  0  0  131  234  567   60
+  4  4  509   81  346  424
+  0  0  529  357  469  151
+  1  1  157  251  418  522
+ 52  8  518  154  702  504
+  0  0  333  499  420  226
+ 52  8  393  730  173  147
+  0  0  342  175  464
+  0  0  481  357  175  263
+  1  1  228  185  517  325
+  1  1  215  511  705  650
+ 24  8  546  311  302  710
+  0  0  322  101  480  100
+ 52  8  617  320  331  213
+  1  1  502  548  681
+  0  0  246  510  499  679
+  1  1  258  255  434  479
+  1  1  517  478  523    1
+  0  0  679  760  474  264
+  0  0  446  565  257  470
+  1  1  545  548  260
+ 52  8  274   42  457  337
+ 52  8   42  276  752  340
+ 52  8  701   53  281
+  4  4  358  388  664  283
+  1  1  545   79  285
+  1  1  317  660  289  535
+  4  4  643  498  690  667
+  2  2  169   12  634  492
+  1  1  236  703  294  704
+  1  1  299  490  497  306
+  1  1  321  541  300  527
+  1  1  301  527  614  313
+  2  2  705  303  312  708
+ 24  8  729  390  155  672
+  1  1  492  610   10  537
+  4  4    3  536  757  489
+  0  0  326  467  477  316
+ 52  8  648  755   68  546
+  1  1  535  329  321  527
+  1  1   76  476  327
+  0  0  339  627  250
+ 24  8  242  457  466  307
+  1  1  361  389  605  367
+  1  1  377  615  404  362
+  0  0  539  370  363  459
+  0  0  379  666  539  364
+  2  2  605  685  369  463
+  0  0  378  538  477  370
+  1  1  365  516  472  373
+  1  1  574  514   18  400
+  1  1  405  540   24  515
+  1  1  375  512  660  385
+  0  0  513  382  378  538
+  2  2  389  511  572  691
+  1  1  479  227  471  389
+ 52  8  141  559  466  242
+ 52  8  756   54  759  216
+ 24  8  708  669  619  432
+  1  1  455  453  395  436
+  1  1  465  422  395  423
+  1  1  259  255  479  395
+  1  1  397  448    9  452
+ 24  8   31  536  618  598
+ 52  8  143  154  457  152
+  1  1  501   22  494  493
+ 52  8  661  454  200  599
+  0  0  442  416  464  129
+  1  1  577  425   15  584
+  2  2  431   11  426  687
+  1  1  426  610   10  577
+ 24  8  433  698  637  431
+  2  2  436    2  437  450
+  1  1  537  488   18  501
+ 24  8   21  525  725  498
+  1  1  306  497  291  535
+  0  0  515   27  539  510
+  0  0  538  508   26  507
+  1  1  314  541  513  239
+  1  1  635  493  252  540
+  1  1  142  251  438  589
+  1  1  592  544  591
+  2  2  620  338  598  543
+  1  1   76  487  482
+ 52  8  202  500  473  210
+  0  0  273  607
+  1  1  476  482  290
+  1  1  267  344  605  128
+  1  1  456  325  133
+  0  0  743  552  696
+  0  0   57  551  720
+  4  4  638  591  598  397
+ 24  8  253  555  603
+ 24  8  751  554  755
+ 24  8  149  424  417  347
+  8  8  674  636  736
+ 24  8  140  427  237
+ 24  8  311  518  702
+ 52  8  603   67  755  461
+  4  4  302  230  328
+  0  0  300  326  256
+  8  8  297  432  680
+ 52  8  736   47  443  176
+  0  0   50  481  250
+ 68  8  709  315   69
+  0  0  245  129  462
+ 32  8  583  741  763  183
+  4  4  337  675  693
+  0  0  287  446  265
+  1  1  699    1  572    6
+  2  2  571  705  516    5
+  1  1    7  616    9  706
+  1  1  399  706  689  512
+  2  2  396  668    7  765
+ 52  8  715  604  761  588
+  1  1   56  532   33  530
+  1  1   39  410  700   50
+ 52  8  609  240   45  140
+ 24  8  278  585  587  764
+ 24  8   16  254   31  620
+ 24  8  461  709  271  639
+ 52  8  651  713  586  568
+  1  1   51  530   59  421
+ 24  8  723  731  335  580
+ 68  8  199  583   55
+ 52  8  580  656  747   48
+ 52  8  576  631  222   65
+  1  1  601  542  418  714
+  1  1  285  699  705  303
+  2  2  750  543  553   77
+  2  2  620   83  750  543
+  0  0   86  607  234
+ 24  8  347  711   90  626
+ 52  8   75  193   92  160
+  4  4  180  413   30  350
+  1  1  268  298
+  4  4  525  544  757  553
+ 68  8  528  713  193
+  1  1  118  456  455  608
+  1  1   73   82  121  589
+  1  1  121  714  235  336
+ 52  8  172  554  125  560
+ 24  8  127  576  652  222
+  1  1  549  505  437  509
+ 52  8  740   35  712  130
+  0  0  688  547  593  131
+  1  1  600  133  344
+ 68  8  176  579
+  1  1  649  497  532  214
+  1  1  336  135  612
+  2  2  611  719  704  218
+  1  1  136  722  646  266
+  1  1  654  494  406  243
+  1  1  138  506  655  270
+  2  2  746   12  737  573
+ 52  8  432  680  209  475
+ 52  8  192  716  525  638
+ 52  8  393  520  747  189
+  4  4   17  581  592  544
+  0  0  145  355  273
+ 24  8  450  394  664  661
+  2  2  745  351  156  668
+ 52  8  210  194  710  721
+ 52  8  454  424  640  644
+ 52  8  594  160   36  738
+  0  0  262  503  696  743
+ 64  8  182  392  163   21
+ 52  8  144  165   23  762
+  0  0  760  101   57
+ 52  8  715  588  296  168
+ 52  8  196  170  709  721
+  1  1  438  714  236  703
+  1  1  292  490  658  317
+  1  1  247  195  314  541
+ 24  8  656  557  288  443
+ 52  8  170  728  754  533
+ 24  8  726  618    8  553
+  4  4  230  582  398  150
+ 68  8  173  415  625
+ 68  8  707  394  200
+ 68  8  678  202  676
+  4  4  409  286  279  489
+ 52  8  625   75  347  160
+ 52  8  205  692   21   31
+  1  1  353  613  441  211
+ 52  8  749   61  212
+ 68  8  751  213  500
+  1  1  232  334  610  134
+  1  1  188  472  295  249
+ 24  8  198  199  197  583
+ 24  8  218  761  604
+  1  1  351  668  435  219
+  1  1  238  332  614  137
+  1  1  354  615  439  224
+ 24  8  278  669  587  636
+  0  0  221  333  171
+  1  1  244  737  634  677
+  2  2  181  307  231
+  1  1  677  488  247  514
+ 24  8  119  622  528  683
+  8  8  197  741  759
+  0  0  359  459  264  123
+ 24  8  486  697  622  387
+  1  1  670  444  425  284
+  0  0  355  508  440  688
+  2  2  489  384   94  673
+  2  2  623  575  653  280
+ 24  8  312  520  656  324
+  1  1  383  349  665  272
+  1  1  348  381  269  345
+ 52  8  496  761   63  748
+  2  2  667   49  352  428
+  8  8  278  164  684  557
+  4  4  457  569  307  717
+ 52  8  642  718  141  311
+  1  1  658  310  375  660
+ 52  8  443  320  642  718
+  0  0  477  322  359  480
+ 24  8  563  715  617  296
+  1  1  476  227  365
+  1  1  714   34  336  719
+ 24  8  661  198  713
+ 24  8  674  764  736
+  1  1  128  509  346
+ 24  8  712   96  190
+  1  1   49  531  428   64
+  0  0  273  666  364  607
+  1  1  376  722  574  360
+  8  8  430  698  489   62
+  4  4  367  516  373  730
+ 24  8  105  744   16  645
+  2  2  569  372  717  380
+ 52  8  216  204  724
+ 24  8    4  394  155  707
+  0  0  627  720  203  551
+ 52  8  390  664  753  162
+ 24  8  366  725  533  690
+  1  1  434  571  590  727
+  1  1  345  445  578  446
+ 24  8  369  730  415  485
+ 24  8  559  710  466  318
+  1  1  633  727  719  491
+  1  1  135  491  612  220
+  1  1  590  472  572  495
+  1  1  573  722  574   13
+ 52  8  695  393  641  189
+  4  4  495    5  341  520
+ 52  8   67  566  582  632
+ 24  8  473  624  702  166
+ 52  8  594  132  740   35
+ 24  8  606  732  153  686
+ 52  8  683  599  106  583
+  1  1  589  602  633  682
+ 52  8  576  680  184  631
+ 68  8  728  618  733
+  2  2  675  412  693  737
+ 24  8  678  240  676
+  2  2  682  703  729  612
+  0  0  760  696  343  552
+ 24  8  624  632  754  169
+  1  1  765  706  689  613
+  4  4  373  295  585
+ 52  8  694   70  766  286
+ 52  8  163  728  536  698
+ 52  8  192  165  254  638
+  1  1  699  703    6  341
+ 68  8  716  725  637
+  4  4  423    4  719  496
+ 24  8  691  701  468  731
+ 52  8  730  585   53  147
+  8  8   90  738  712
+ 52  8  194  716  754    8
+ 52  8   41  276  223  762
+ 38  8  183  759  741  401
+ 24  8  684  557  564  139
+  1  1  717  658  616  399
+ 24  8  626  732   74  153
+ 52  8   74  187  167  742
+ 24  8  711   90  606
+  8  8  568  662   93  735
+ 24  8  739  109   16   25
+  0  0  627  114  551
+  8  8   93  692  116  391
+  4  4   30  350  762  623
+  4  4    8  412  616    7
+ 68  8  147  619  587
+ 68  8  155  672  184
+ 52  8  387  647  162  199
+  4  4  592  254   29  591
+ 52  8  168  331  648  555
+ 24  8  191  484  762  396
+ 68  8  155  697  394
+ 24  8  721  733  637   12
+ 24  8  555  500  560  302
+ 24  8  758  197  519
+  2  2  498  338  598   94
+ 52  8  199  212  756   54
+ 24  8  519  662  735  204
+  0  0  316  480  630  720
+ 52  8  672  652  305  576
+ 24  8  629  734  752  745
+ 24  8  106  568   93  105
+ 52  8  580  684  277   47
+  1  1  575  371  280  722
+ 24  8  386  392  724  409
Index: /inundation/pymetis/metis-4.0/INSTALL
===================================================================
--- /inundation/pymetis/metis-4.0/INSTALL	(revision 2051)
+++ /inundation/pymetis/metis-4.0/INSTALL	(revision 2051)
@@ -0,0 +1,79 @@
+
+Copyright 1998, Regents of the University of Minnesota.
+METIS was written by George Karypis (karypis@cs.umn.edu)
+
+Introduction ------------------------------------------------------------
+
+METIS is a software package for partitioning unstructured graphs, partitioning 
+meshes, and computing fill-reducing orderings of sparse matrices. 
+The documentation of METIS can be found in the Doc/manual.ps file.
+
+METIS is written in ANSI C and should compile on Unix systems that have
+a ANSI C compiler. It has been extensively tested on the following
+architectures:
+
+   AIX 
+   SunOS 
+   Solaris 
+   IRIX 
+   Unicos
+   Linux
+   HP-UX
+   FreeBSD
+
+
+Installation Instructions -----------------------------------------------
+
+In order to build METIS you need
+  (a) a C compiler that is ANSI compatible 
+  (b) make 
+
+Edit the file Makefile.in that resides in the same directory as this file 
+according to the requirements of your system. In particular you may need
+to modify the following:
+  1. The CC variable, to be the name of the ANSI C compiler 
+     in your system. The GNU C compiler (gcc) will do. 
+  2. The settings for the AR and RANLIB variables that are suitable for
+     you system. Note that some systems do not have 'ranlib' but they use
+     'ar -ts' instead, or it is not needed all together. 
+  3. You can use COPTIONS and LDOPTIONS to provide additional command line
+     options that are required by your compiler and linker.
+
+
+After saving the modified Makefile.in, type 'make' at the prompt. This will
+build all of METIS's stand-alone programs, METIS's library, and a program that
+tests the various partitioning algorithms.
+Upon successful completion, make creates the following 11 files:
+
+  pmetis, 
+  kmetis, 
+  oemetis, 
+  onmetis, 
+  partnmesh, 
+  partdmesh, 
+  mesh2nodal,
+  mesh2dual,
+  graphchk,
+  libmetis.a
+  Graphs/mtest
+
+Please read the instructions in the file Graphs/0README on how to go and
+test the various programs.
+
+
+Contact Information -----------------------------------------------------
+
+If you have any comments, suggestions, or bug reports, please send them
+to metis@cs.umn.edu.
+
+Any bug fixes and upgrades of the METIS packages is available on WWW at
+URL: http://www.cs.umn.edu/~metis
+or
+URL: http://www.cs.umn.edu/~karypis/metis
+
+
+George Karypis
+Sun Sep 20 13:18:36 CDT 1998
+
+
+
Index: /inundation/pymetis/metis-4.0/Lib/Makefile
===================================================================
--- /inundation/pymetis/metis-4.0/Lib/Makefile	(revision 2051)
+++ /inundation/pymetis/metis-4.0/Lib/Makefile	(revision 2051)
@@ -0,0 +1,31 @@
+include ../Makefile.in
+
+INCLUDES = -I.
+
+CFLAGS = $(COPTIONS) $(OPTFLAGS) $(INCLUDES)
+LD = $(CC) -L. 
+
+
+OBJS = coarsen.o fm.o initpart.o match.o ccgraph.o memory.o \
+       pmetis.o pqueue.o refine.o util.o timing.o debug.o \
+       bucketsort.o graph.o stat.o kmetis.o kwayrefine.o \
+       kwayfm.o balance.o ometis.o srefine.o sfm.o separator.o \
+       mincover.o mmd.o mesh.o meshpart.o frename.o fortran.o \
+       myqsort.o compress.o parmetis.o estmem.o \
+       mpmetis.o mcoarsen.o mmatch.o minitpart.o mbalance.o \
+       mrefine.o mutil.o mfm.o mkmetis.o mkwayrefine.o mkwayfmh.o \
+       mrefine2.o minitpart2.o mbalance2.o mfm2.o \
+       kvmetis.o kwayvolrefine.o kwayvolfm.o subdomains.o
+
+.c.o:
+	$(CC) $(CFLAGS) -c $*.c
+
+../libmetis.a: $(OBJS)
+	$(AR) $@ $(OBJS)
+	$(RANLIB) $@
+
+clean:
+	rm -f *.o
+
+realclean:
+	rm -f *.o ; rm -f ../libmetis.a
Index: /inundation/pymetis/metis-4.0/Lib/balance.c
===================================================================
--- /inundation/pymetis/metis-4.0/Lib/balance.c	(revision 2051)
+++ /inundation/pymetis/metis-4.0/Lib/balance.c	(revision 2051)
@@ -0,0 +1,278 @@
+/*
+ * Copyright 1997, Regents of the University of Minnesota
+ *
+ * balance.c
+ *
+ * This file contains code that is used to forcefully balance either
+ * bisections or k-sections
+ *
+ * Started 7/29/97
+ * George
+ *
+ * $Id: balance.c,v 1.1 1998/11/27 17:59:10 karypis Exp $
+ *
+ */
+
+#include <metis.h>
+
+/*************************************************************************
+* This function is the entry point of the bisection balancing algorithms.
+**************************************************************************/
+void Balance2Way(CtrlType *ctrl, GraphType *graph, int *tpwgts, float ubfactor)
+{
+  int i, j, nvtxs, from, imax, gain, mindiff;
+  idxtype *id, *ed;
+
+  /* Return right away if the balance is OK */
+  mindiff = abs(tpwgts[0]-graph->pwgts[0]);
+  if (mindiff < 3*(graph->pwgts[0]+graph->pwgts[1])/graph->nvtxs)
+    return;
+  if (graph->pwgts[0] > tpwgts[0] && graph->pwgts[0] < (int)(ubfactor*tpwgts[0]))
+    return;
+  if (graph->pwgts[1] > tpwgts[1] && graph->pwgts[1] < (int)(ubfactor*tpwgts[1]))
+    return;
+
+  if (graph->nbnd > 0)
+    Bnd2WayBalance(ctrl, graph, tpwgts);
+  else
+    General2WayBalance(ctrl, graph, tpwgts);
+
+}
+
+
+
+/*************************************************************************
+* This function balances two partitions by moving boundary nodes
+* from the domain that is overweight to the one that is underweight.
+**************************************************************************/
+void Bnd2WayBalance(CtrlType *ctrl, GraphType *graph, int *tpwgts)
+{
+  int i, ii, j, k, kwgt, nvtxs, nbnd, nswaps, from, to, pass, me, tmp;
+  idxtype *xadj, *vwgt, *adjncy, *adjwgt, *where, *id, *ed, *bndptr, *bndind, *pwgts;
+  idxtype *moved, *perm;
+  PQueueType parts;
+  int higain, oldgain, mincut, mindiff;
+
+  nvtxs = graph->nvtxs;
+  xadj = graph->xadj;
+  vwgt = graph->vwgt;
+  adjncy = graph->adjncy;
+  adjwgt = graph->adjwgt;
+  where = graph->where;
+  id = graph->id;
+  ed = graph->ed;
+  pwgts = graph->pwgts;
+  bndptr = graph->bndptr;
+  bndind = graph->bndind;
+
+  moved = idxwspacemalloc(ctrl, nvtxs);
+  perm = idxwspacemalloc(ctrl, nvtxs);
+
+  /* Determine from which domain you will be moving data */
+  mindiff = abs(tpwgts[0]-pwgts[0]);
+  from = (pwgts[0] < tpwgts[0] ? 1 : 0);
+  to = (from+1)%2;
+
+  IFSET(ctrl->dbglvl, DBG_REFINE, 
+     printf("Partitions: [%6d %6d] T[%6d %6d], Nv-Nb[%6d %6d]. ICut: %6d [B]\n",
+             pwgts[0], pwgts[1], tpwgts[0], tpwgts[1], graph->nvtxs, graph->nbnd, graph->mincut));
+
+  tmp = graph->adjwgtsum[idxamax(nvtxs, graph->adjwgtsum)];
+  PQueueInit(ctrl, &parts, nvtxs, tmp);
+
+  idxset(nvtxs, -1, moved);
+
+  ASSERT(ComputeCut(graph, where) == graph->mincut);
+  ASSERT(CheckBnd(graph));
+
+  /* Insert the boundary nodes of the proper partition whose size is OK in the priority queue */
+  nbnd = graph->nbnd;
+  RandomPermute(nbnd, perm, 1);
+  for (ii=0; ii<nbnd; ii++) {
+    i = perm[ii];
+    ASSERT(ed[bndind[i]] > 0 || id[bndind[i]] == 0);
+    ASSERT(bndptr[bndind[i]] != -1);
+    if (where[bndind[i]] == from && vwgt[bndind[i]] <= mindiff)
+      PQueueInsert(&parts, bndind[i], ed[bndind[i]]-id[bndind[i]]);
+  }
+
+  mincut = graph->mincut;
+  for (nswaps=0; nswaps<nvtxs; nswaps++) {
+    if ((higain = PQueueGetMax(&parts)) == -1)
+      break;
+    ASSERT(bndptr[higain] != -1);
+
+    if (pwgts[to]+vwgt[higain] > tpwgts[to])
+      break;
+
+    mincut -= (ed[higain]-id[higain]);
+    INC_DEC(pwgts[to], pwgts[from], vwgt[higain]);
+
+    where[higain] = to;
+    moved[higain] = nswaps;
+
+    IFSET(ctrl->dbglvl, DBG_MOVEINFO, 
+      printf("Moved %6d from %d. [%3d %3d] %5d [%4d %4d]\n", higain, from, ed[higain]-id[higain], vwgt[higain], mincut, pwgts[0], pwgts[1]));
+
+    /**************************************************************
+    * Update the id[i]/ed[i] values of the affected nodes
+    ***************************************************************/
+    SWAP(id[higain], ed[higain], tmp);
+    if (ed[higain] == 0 && xadj[higain] < xadj[higain+1]) 
+      BNDDelete(nbnd, bndind,  bndptr, higain);
+
+    for (j=xadj[higain]; j<xadj[higain+1]; j++) {
+      k = adjncy[j];
+      oldgain = ed[k]-id[k];
+
+      kwgt = (to == where[k] ? adjwgt[j] : -adjwgt[j]);
+      INC_DEC(id[k], ed[k], kwgt);
+
+      /* Update its boundary information and queue position */
+      if (bndptr[k] != -1) { /* If k was a boundary vertex */
+        if (ed[k] == 0) { /* Not a boundary vertex any more */
+          BNDDelete(nbnd, bndind, bndptr, k);
+          if (moved[k] == -1 && where[k] == from && vwgt[k] <= mindiff)  /* Remove it if in the queues */
+            PQueueDelete(&parts, k, oldgain);
+        }
+        else { /* If it has not been moved, update its position in the queue */
+          if (moved[k] == -1 && where[k] == from && vwgt[k] <= mindiff)
+            PQueueUpdate(&parts, k, oldgain, ed[k]-id[k]);
+        }
+      }
+      else {
+        if (ed[k] > 0) {  /* It will now become a boundary vertex */
+          BNDInsert(nbnd, bndind, bndptr, k);
+          if (moved[k] == -1 && where[k] == from && vwgt[k] <= mindiff) 
+            PQueueInsert(&parts, k, ed[k]-id[k]);
+        }
+      }
+    }
+  }
+
+  IFSET(ctrl->dbglvl, DBG_REFINE, 
+    printf("\tMinimum cut: %6d, PWGTS: [%6d %6d], NBND: %6d\n", mincut, pwgts[0], pwgts[1], nbnd));
+
+  graph->mincut = mincut;
+  graph->nbnd = nbnd;
+
+  PQueueFree(ctrl, &parts);
+
+  idxwspacefree(ctrl, nvtxs);
+  idxwspacefree(ctrl, nvtxs);
+}
+
+
+/*************************************************************************
+* This function balances two partitions by moving the highest gain 
+* (including negative gain) vertices to the other domain.
+* It is used only when tha unbalance is due to non contigous
+* subdomains. That is, the are no boundary vertices.
+* It moves vertices from the domain that is overweight to the one that 
+* is underweight.
+**************************************************************************/
+void General2WayBalance(CtrlType *ctrl, GraphType *graph, int *tpwgts)
+{
+  int i, ii, j, k, kwgt, nvtxs, nbnd, nswaps, from, to, pass, me, tmp;
+  idxtype *xadj, *vwgt, *adjncy, *adjwgt, *where, *id, *ed, *bndptr, *bndind, *pwgts;
+  idxtype *moved, *perm;
+  PQueueType parts;
+  int higain, oldgain, mincut, mindiff;
+
+  nvtxs = graph->nvtxs;
+  xadj = graph->xadj;
+  vwgt = graph->vwgt;
+  adjncy = graph->adjncy;
+  adjwgt = graph->adjwgt;
+  where = graph->where;
+  id = graph->id;
+  ed = graph->ed;
+  pwgts = graph->pwgts;
+  bndptr = graph->bndptr;
+  bndind = graph->bndind;
+
+  moved = idxwspacemalloc(ctrl, nvtxs);
+  perm = idxwspacemalloc(ctrl, nvtxs);
+
+  /* Determine from which domain you will be moving data */
+  mindiff = abs(tpwgts[0]-pwgts[0]);
+  from = (pwgts[0] < tpwgts[0] ? 1 : 0);
+  to = (from+1)%2;
+
+  IFSET(ctrl->dbglvl, DBG_REFINE, 
+     printf("Partitions: [%6d %6d] T[%6d %6d], Nv-Nb[%6d %6d]. ICut: %6d [B]\n",
+             pwgts[0], pwgts[1], tpwgts[0], tpwgts[1], graph->nvtxs, graph->nbnd, graph->mincut));
+
+  tmp = graph->adjwgtsum[idxamax(nvtxs, graph->adjwgtsum)];
+  PQueueInit(ctrl, &parts, nvtxs, tmp);
+
+  idxset(nvtxs, -1, moved);
+
+  ASSERT(ComputeCut(graph, where) == graph->mincut);
+  ASSERT(CheckBnd(graph));
+
+  /* Insert the nodes of the proper partition whose size is OK in the priority queue */
+  RandomPermute(nvtxs, perm, 1);
+  for (ii=0; ii<nvtxs; ii++) {
+    i = perm[ii];
+    if (where[i] == from && vwgt[i] <= mindiff)
+      PQueueInsert(&parts, i, ed[i]-id[i]);
+  }
+
+  mincut = graph->mincut;
+  nbnd = graph->nbnd;
+  for (nswaps=0; nswaps<nvtxs; nswaps++) {
+    if ((higain = PQueueGetMax(&parts)) == -1)
+      break;
+
+    if (pwgts[to]+vwgt[higain] > tpwgts[to])
+      break;
+
+    mincut -= (ed[higain]-id[higain]);
+    INC_DEC(pwgts[to], pwgts[from], vwgt[higain]);
+
+    where[higain] = to;
+    moved[higain] = nswaps;
+
+    IFSET(ctrl->dbglvl, DBG_MOVEINFO, 
+      printf("Moved %6d from %d. [%3d %3d] %5d [%4d %4d]\n", higain, from, ed[higain]-id[higain], vwgt[higain], mincut, pwgts[0], pwgts[1]));
+
+    /**************************************************************
+    * Update the id[i]/ed[i] values of the affected nodes
+    ***************************************************************/
+    SWAP(id[higain], ed[higain], tmp);
+    if (ed[higain] == 0 && bndptr[higain] != -1 && xadj[higain] < xadj[higain+1]) 
+      BNDDelete(nbnd, bndind,  bndptr, higain);
+    if (ed[higain] > 0 && bndptr[higain] == -1)
+      BNDInsert(nbnd, bndind,  bndptr, higain);
+
+    for (j=xadj[higain]; j<xadj[higain+1]; j++) {
+      k = adjncy[j];
+      oldgain = ed[k]-id[k];
+
+      kwgt = (to == where[k] ? adjwgt[j] : -adjwgt[j]);
+      INC_DEC(id[k], ed[k], kwgt);
+
+      /* Update the queue position */
+      if (moved[k] == -1 && where[k] == from && vwgt[k] <= mindiff)
+        PQueueUpdate(&parts, k, oldgain, ed[k]-id[k]);
+
+      /* Update its boundary information */
+      if (ed[k] == 0 && bndptr[k] != -1) 
+        BNDDelete(nbnd, bndind, bndptr, k);
+      else if (ed[k] > 0 && bndptr[k] == -1)  
+        BNDInsert(nbnd, bndind, bndptr, k);
+    }
+  }
+
+  IFSET(ctrl->dbglvl, DBG_REFINE, 
+    printf("\tMinimum cut: %6d, PWGTS: [%6d %6d], NBND: %6d\n", mincut, pwgts[0], pwgts[1], nbnd));
+
+  graph->mincut = mincut;
+  graph->nbnd = nbnd;
+
+  PQueueFree(ctrl, &parts);
+
+  idxwspacefree(ctrl, nvtxs);
+  idxwspacefree(ctrl, nvtxs);
+}
Index: /inundation/pymetis/metis-4.0/Lib/bucketsort.c
===================================================================
--- /inundation/pymetis/metis-4.0/Lib/bucketsort.c	(revision 2051)
+++ /inundation/pymetis/metis-4.0/Lib/bucketsort.c	(revision 2051)
@@ -0,0 +1,43 @@
+/*
+ * Copyright 1997, Regents of the University of Minnesota
+ *
+ * bucketsort.c
+ *
+ * This file contains code that implement a variety of counting sorting
+ * algorithms
+ *
+ * Started 7/25/97
+ * George
+ *
+ * $Id: bucketsort.c,v 1.1 1998/11/27 17:59:11 karypis Exp $
+ *
+ */
+
+#include <metis.h>
+
+
+
+/*************************************************************************
+* This function uses simple counting sort to return a permutation array
+* corresponding to the sorted order. The keys are assumed to start from
+* 0 and they are positive.  This sorting is used during matching.
+**************************************************************************/
+void BucketSortKeysInc(int n, int max, idxtype *keys, idxtype *tperm, idxtype *perm)
+{
+  int i, ii;
+  idxtype *counts;
+
+  counts = idxsmalloc(max+2, 0, "BucketSortKeysInc: counts");
+
+  for (i=0; i<n; i++)
+    counts[keys[i]]++;
+  MAKECSR(i, max+1, counts);
+
+  for (ii=0; ii<n; ii++) {
+    i = tperm[ii];
+    perm[counts[keys[i]]++] = i;
+  }
+
+  free(counts);
+}
+
Index: /inundation/pymetis/metis-4.0/Lib/ccgraph.c
===================================================================
--- /inundation/pymetis/metis-4.0/Lib/ccgraph.c	(revision 2051)
+++ /inundation/pymetis/metis-4.0/Lib/ccgraph.c	(revision 2051)
@@ -0,0 +1,599 @@
+/*
+ * Copyright 1997, Regents of the University of Minnesota
+ *
+ * ccgraph.c
+ *
+ * This file contains the functions that create the coarse graph
+ *
+ * Started 8/11/97
+ * George
+ *
+ * $Id: ccgraph.c,v 1.1 1998/11/27 17:59:12 karypis Exp $
+ *
+ */
+
+#include <metis.h>
+
+
+
+/*************************************************************************
+* This function creates the coarser graph
+**************************************************************************/
+void CreateCoarseGraph(CtrlType *ctrl, GraphType *graph, int cnvtxs, idxtype *match, idxtype *perm)
+{
+  int i, j, jj, k, kk, l, m, istart, iend, nvtxs, nedges, ncon, cnedges, v, u, mask, dovsize;
+  idxtype *xadj, *vwgt, *vsize, *adjncy, *adjwgt, *adjwgtsum, *auxadj;
+  idxtype *cmap, *htable;
+  idxtype *cxadj, *cvwgt, *cvsize, *cadjncy, *cadjwgt, *cadjwgtsum;
+  float *nvwgt, *cnvwgt;
+  GraphType *cgraph;
+
+  dovsize = (ctrl->optype == OP_KVMETIS ? 1 : 0);
+
+  mask = HTLENGTH;
+  if (cnvtxs < 8*mask || graph->nedges/graph->nvtxs > 15) { 
+    CreateCoarseGraphNoMask(ctrl, graph, cnvtxs, match, perm);
+    return;
+  }
+
+  IFSET(ctrl->dbglvl, DBG_TIME, starttimer(ctrl->ContractTmr));
+
+  nvtxs = graph->nvtxs;
+  ncon = graph->ncon;
+  xadj = graph->xadj;
+  vwgt = graph->vwgt;
+  vsize = graph->vsize;
+  nvwgt = graph->nvwgt;
+  adjncy = graph->adjncy;
+  adjwgt = graph->adjwgt;
+  adjwgtsum = graph->adjwgtsum;
+  cmap = graph->cmap;
+
+  /* Initialize the coarser graph */
+  cgraph = SetUpCoarseGraph(graph, cnvtxs, dovsize);
+  cxadj = cgraph->xadj;
+  cvwgt = cgraph->vwgt;
+  cvsize = cgraph->vsize;
+  cnvwgt = cgraph->nvwgt;
+  cadjwgtsum = cgraph->adjwgtsum;
+  cadjncy = cgraph->adjncy;
+  cadjwgt = cgraph->adjwgt;
+
+
+  iend = xadj[nvtxs];
+  auxadj = ctrl->wspace.auxcore; 
+  memcpy(auxadj, adjncy, iend*sizeof(idxtype)); 
+  for (i=0; i<iend; i++)
+    auxadj[i] = cmap[auxadj[i]];
+
+  htable = idxset(mask+1, -1, idxwspacemalloc(ctrl, mask+1)); 
+
+  cxadj[0] = cnvtxs = cnedges = 0;
+  for (i=0; i<nvtxs; i++) {
+    v = perm[i];
+    if (cmap[v] != cnvtxs) 
+      continue;
+
+    u = match[v];
+    if (ncon == 1)
+      cvwgt[cnvtxs] = vwgt[v];
+    else
+      scopy(ncon, nvwgt+v*ncon, cnvwgt+cnvtxs*ncon);
+
+    if (dovsize)
+      cvsize[cnvtxs] = vsize[v];
+
+    cadjwgtsum[cnvtxs] = adjwgtsum[v];
+    nedges = 0;
+
+    istart = xadj[v];
+    iend = xadj[v+1];
+    for (j=istart; j<iend; j++) {
+      k = auxadj[j];
+      kk = k&mask;
+      if ((m = htable[kk]) == -1) {
+        cadjncy[nedges] = k;
+        cadjwgt[nedges] = adjwgt[j];
+        htable[kk] = nedges++;
+      }
+      else if (cadjncy[m] == k) {
+        cadjwgt[m] += adjwgt[j];
+      }
+      else {
+        for (jj=0; jj<nedges; jj++) {
+          if (cadjncy[jj] == k) {
+            cadjwgt[jj] += adjwgt[j];
+            break;
+          }
+        }
+        if (jj == nedges) {
+          cadjncy[nedges] = k;
+          cadjwgt[nedges++] = adjwgt[j];
+        }
+      }
+    }
+
+    if (v != u) { 
+      if (ncon == 1)
+        cvwgt[cnvtxs] += vwgt[u];
+      else
+        saxpy(ncon, 1.0, nvwgt+u*ncon, 1, cnvwgt+cnvtxs*ncon, 1);
+
+      if (dovsize)
+        cvsize[cnvtxs] += vsize[u];
+
+      cadjwgtsum[cnvtxs] += adjwgtsum[u];
+
+      istart = xadj[u];
+      iend = xadj[u+1];
+      for (j=istart; j<iend; j++) {
+        k = auxadj[j];
+        kk = k&mask;
+        if ((m = htable[kk]) == -1) {
+          cadjncy[nedges] = k;
+          cadjwgt[nedges] = adjwgt[j];
+          htable[kk] = nedges++;
+        }
+        else if (cadjncy[m] == k) {
+          cadjwgt[m] += adjwgt[j];
+        }
+        else {
+          for (jj=0; jj<nedges; jj++) {
+            if (cadjncy[jj] == k) {
+              cadjwgt[jj] += adjwgt[j];
+              break;
+            }
+          }
+          if (jj == nedges) {
+            cadjncy[nedges] = k;
+            cadjwgt[nedges++] = adjwgt[j];
+          }
+        }
+      }
+
+      /* Remove the contracted adjacency weight */
+      jj = htable[cnvtxs&mask];
+      if (jj >= 0 && cadjncy[jj] != cnvtxs) {
+        for (jj=0; jj<nedges; jj++) {
+          if (cadjncy[jj] == cnvtxs) 
+            break;
+        }
+      }
+      if (jj >= 0 && cadjncy[jj] == cnvtxs) { /* This 2nd check is needed for non-adjacent matchings */
+        cadjwgtsum[cnvtxs] -= cadjwgt[jj];
+        cadjncy[jj] = cadjncy[--nedges];
+        cadjwgt[jj] = cadjwgt[nedges];
+      }
+    }
+
+    ASSERTP(cadjwgtsum[cnvtxs] == idxsum(nedges, cadjwgt), ("%d %d %d %d %d\n", cnvtxs, cadjwgtsum[cnvtxs], idxsum(nedges, cadjwgt), adjwgtsum[u], adjwgtsum[v]));
+
+    for (j=0; j<nedges; j++)
+      htable[cadjncy[j]&mask] = -1;  /* Zero out the htable */
+    htable[cnvtxs&mask] = -1;
+
+    cnedges += nedges;
+    cxadj[++cnvtxs] = cnedges;
+    cadjncy += nedges;
+    cadjwgt += nedges;
+  }
+
+  cgraph->nedges = cnedges;
+
+  ReAdjustMemory(graph, cgraph, dovsize);
+
+  IFSET(ctrl->dbglvl, DBG_TIME, stoptimer(ctrl->ContractTmr));
+
+  idxwspacefree(ctrl, mask+1);
+
+}
+
+
+/*************************************************************************
+* This function creates the coarser graph
+**************************************************************************/
+void CreateCoarseGraphNoMask(CtrlType *ctrl, GraphType *graph, int cnvtxs, idxtype *match, idxtype *perm)
+{
+  int i, j, k, m, istart, iend, nvtxs, nedges, ncon, cnedges, v, u, dovsize;
+  idxtype *xadj, *vwgt, *vsize, *adjncy, *adjwgt, *adjwgtsum, *auxadj;
+  idxtype *cmap, *htable;
+  idxtype *cxadj, *cvwgt, *cvsize, *cadjncy, *cadjwgt, *cadjwgtsum;
+  float *nvwgt, *cnvwgt;
+  GraphType *cgraph;
+
+  dovsize = (ctrl->optype == OP_KVMETIS ? 1 : 0);
+
+  IFSET(ctrl->dbglvl, DBG_TIME, starttimer(ctrl->ContractTmr));
+
+  nvtxs = graph->nvtxs;
+  ncon = graph->ncon;
+  xadj = graph->xadj;
+  vwgt = graph->vwgt;
+  vsize = graph->vsize;
+  nvwgt = graph->nvwgt;
+  adjncy = graph->adjncy;
+  adjwgt = graph->adjwgt;
+  adjwgtsum = graph->adjwgtsum;
+  cmap = graph->cmap;
+
+
+  /* Initialize the coarser graph */
+  cgraph = SetUpCoarseGraph(graph, cnvtxs, dovsize);
+  cxadj = cgraph->xadj;
+  cvwgt = cgraph->vwgt;
+  cvsize = cgraph->vsize;
+  cnvwgt = cgraph->nvwgt;
+  cadjwgtsum = cgraph->adjwgtsum;
+  cadjncy = cgraph->adjncy;
+  cadjwgt = cgraph->adjwgt;
+
+
+  htable = idxset(cnvtxs, -1, idxwspacemalloc(ctrl, cnvtxs));
+
+  iend = xadj[nvtxs];
+  auxadj = ctrl->wspace.auxcore; 
+  memcpy(auxadj, adjncy, iend*sizeof(idxtype)); 
+  for (i=0; i<iend; i++)
+    auxadj[i] = cmap[auxadj[i]];
+
+  cxadj[0] = cnvtxs = cnedges = 0;
+  for (i=0; i<nvtxs; i++) {
+    v = perm[i];
+    if (cmap[v] != cnvtxs) 
+      continue;
+
+    u = match[v];
+    if (ncon == 1)
+      cvwgt[cnvtxs] = vwgt[v];
+    else
+      scopy(ncon, nvwgt+v*ncon, cnvwgt+cnvtxs*ncon);
+
+    if (dovsize)
+      cvsize[cnvtxs] = vsize[v];
+
+    cadjwgtsum[cnvtxs] = adjwgtsum[v];
+    nedges = 0;
+
+    istart = xadj[v];
+    iend = xadj[v+1];
+    for (j=istart; j<iend; j++) {
+      k = auxadj[j];
+      if ((m = htable[k]) == -1) {
+        cadjncy[nedges] = k;
+        cadjwgt[nedges] = adjwgt[j];
+        htable[k] = nedges++;
+      }
+      else {
+        cadjwgt[m] += adjwgt[j];
+      }
+    }
+
+    if (v != u) { 
+      if (ncon == 1)
+        cvwgt[cnvtxs] += vwgt[u];
+      else
+        saxpy(ncon, 1.0, nvwgt+u*ncon, 1, cnvwgt+cnvtxs*ncon, 1);
+
+      if (dovsize)
+        cvsize[cnvtxs] += vsize[u];
+
+      cadjwgtsum[cnvtxs] += adjwgtsum[u];
+
+      istart = xadj[u];
+      iend = xadj[u+1];
+      for (j=istart; j<iend; j++) {
+        k = auxadj[j];
+        if ((m = htable[k]) == -1) {
+          cadjncy[nedges] = k;
+          cadjwgt[nedges] = adjwgt[j];
+          htable[k] = nedges++;
+        }
+        else {
+          cadjwgt[m] += adjwgt[j];
+        }
+      }
+
+      /* Remove the contracted adjacency weight */
+      if ((j = htable[cnvtxs]) != -1) {
+        ASSERT(cadjncy[j] == cnvtxs);
+        cadjwgtsum[cnvtxs] -= cadjwgt[j];
+        cadjncy[j] = cadjncy[--nedges];
+        cadjwgt[j] = cadjwgt[nedges];
+        htable[cnvtxs] = -1;
+      }
+    }
+
+    ASSERTP(cadjwgtsum[cnvtxs] == idxsum(nedges, cadjwgt), ("%d %d\n", cadjwgtsum[cnvtxs], idxsum(nedges, cadjwgt)));
+
+    for (j=0; j<nedges; j++)
+      htable[cadjncy[j]] = -1;  /* Zero out the htable */
+
+    cnedges += nedges;
+    cxadj[++cnvtxs] = cnedges;
+    cadjncy += nedges;
+    cadjwgt += nedges;
+  }
+
+  cgraph->nedges = cnedges;
+
+  ReAdjustMemory(graph, cgraph, dovsize);
+
+  IFSET(ctrl->dbglvl, DBG_TIME, stoptimer(ctrl->ContractTmr));
+
+  idxwspacefree(ctrl, cnvtxs);
+}
+
+
+/*************************************************************************
+* This function creates the coarser graph
+**************************************************************************/
+void CreateCoarseGraph_NVW(CtrlType *ctrl, GraphType *graph, int cnvtxs, idxtype *match, idxtype *perm)
+{
+  int i, j, jj, k, kk, l, m, istart, iend, nvtxs, nedges, ncon, cnedges, v, u, mask;
+  idxtype *xadj, *adjncy, *adjwgtsum, *auxadj;
+  idxtype *cmap, *htable;
+  idxtype *cxadj, *cvwgt, *cadjncy, *cadjwgt, *cadjwgtsum;
+  float *nvwgt, *cnvwgt;
+  GraphType *cgraph;
+
+
+  IFSET(ctrl->dbglvl, DBG_TIME, starttimer(ctrl->ContractTmr));
+
+  nvtxs = graph->nvtxs;
+  ncon = graph->ncon;
+  xadj = graph->xadj;
+  nvwgt = graph->nvwgt;
+  adjncy = graph->adjncy;
+  adjwgtsum = graph->adjwgtsum;
+  cmap = graph->cmap;
+
+  /* Initialize the coarser graph */
+  cgraph = SetUpCoarseGraph(graph, cnvtxs, 0);
+  cxadj = cgraph->xadj;
+  cvwgt = cgraph->vwgt;
+  cnvwgt = cgraph->nvwgt;
+  cadjwgtsum = cgraph->adjwgtsum;
+  cadjncy = cgraph->adjncy;
+  cadjwgt = cgraph->adjwgt;
+
+
+  iend = xadj[nvtxs];
+  auxadj = ctrl->wspace.auxcore; 
+  memcpy(auxadj, adjncy, iend*sizeof(idxtype)); 
+  for (i=0; i<iend; i++)
+    auxadj[i] = cmap[auxadj[i]];
+
+  mask = HTLENGTH;
+  htable = idxset(mask+1, -1, idxwspacemalloc(ctrl, mask+1)); 
+
+  cxadj[0] = cnvtxs = cnedges = 0;
+  for (i=0; i<nvtxs; i++) {
+    v = perm[i];
+    if (cmap[v] != cnvtxs) 
+      continue;
+
+    u = match[v];
+    cvwgt[cnvtxs] = 1;
+    cadjwgtsum[cnvtxs] = adjwgtsum[v];
+    nedges = 0;
+
+    istart = xadj[v];
+    iend = xadj[v+1];
+    for (j=istart; j<iend; j++) {
+      k = auxadj[j];
+      kk = k&mask;
+      if ((m = htable[kk]) == -1) {
+        cadjncy[nedges] = k;
+        cadjwgt[nedges] = 1;
+        htable[kk] = nedges++;
+      }
+      else if (cadjncy[m] == k) {
+        cadjwgt[m]++;
+      }
+      else {
+        for (jj=0; jj<nedges; jj++) {
+          if (cadjncy[jj] == k) {
+            cadjwgt[jj]++;
+            break;
+          }
+        }
+        if (jj == nedges) {
+          cadjncy[nedges] = k;
+          cadjwgt[nedges++] = 1;
+        }
+      }
+    }
+
+    if (v != u) { 
+      cvwgt[cnvtxs]++;
+      cadjwgtsum[cnvtxs] += adjwgtsum[u];
+
+      istart = xadj[u];
+      iend = xadj[u+1];
+      for (j=istart; j<iend; j++) {
+        k = auxadj[j];
+        kk = k&mask;
+        if ((m = htable[kk]) == -1) {
+          cadjncy[nedges] = k;
+          cadjwgt[nedges] = 1;
+          htable[kk] = nedges++;
+        }
+        else if (cadjncy[m] == k) {
+          cadjwgt[m]++;
+        }
+        else {
+          for (jj=0; jj<nedges; jj++) {
+            if (cadjncy[jj] == k) {
+              cadjwgt[jj]++;
+              break;
+            }
+          }
+          if (jj == nedges) {
+            cadjncy[nedges] = k;
+            cadjwgt[nedges++] = 1;
+          }
+        }
+      }
+
+      /* Remove the contracted adjacency weight */
+      jj = htable[cnvtxs&mask];
+      if (jj >= 0 && cadjncy[jj] != cnvtxs) {
+        for (jj=0; jj<nedges; jj++) {
+          if (cadjncy[jj] == cnvtxs) 
+            break;
+        }
+      }
+      if (jj >= 0 && cadjncy[jj] == cnvtxs) { /* This 2nd check is needed for non-adjacent matchings */
+        cadjwgtsum[cnvtxs] -= cadjwgt[jj];
+        cadjncy[jj] = cadjncy[--nedges];
+        cadjwgt[jj] = cadjwgt[nedges];
+      }
+    }
+
+    ASSERTP(cadjwgtsum[cnvtxs] == idxsum(nedges, cadjwgt), ("%d %d %d %d %d\n", cnvtxs, cadjwgtsum[cnvtxs], idxsum(nedges, cadjwgt), adjwgtsum[u], adjwgtsum[v]));
+
+    for (j=0; j<nedges; j++)
+      htable[cadjncy[j]&mask] = -1;  /* Zero out the htable */
+    htable[cnvtxs&mask] = -1;
+
+    cnedges += nedges;
+    cxadj[++cnvtxs] = cnedges;
+    cadjncy += nedges;
+    cadjwgt += nedges;
+  }
+
+  cgraph->nedges = cnedges;
+
+  ReAdjustMemory(graph, cgraph, 0);
+
+  IFSET(ctrl->dbglvl, DBG_TIME, stoptimer(ctrl->ContractTmr));
+
+  idxwspacefree(ctrl, mask+1);
+
+}
+
+
+/*************************************************************************
+* Setup the various arrays for the coarse graph
+**************************************************************************/
+GraphType *SetUpCoarseGraph(GraphType *graph, int cnvtxs, int dovsize)
+{
+  GraphType *cgraph;
+
+  cgraph = CreateGraph();
+  cgraph->nvtxs = cnvtxs;
+  cgraph->ncon = graph->ncon;
+
+  cgraph->finer = graph;
+  graph->coarser = cgraph;
+
+
+  /* Allocate memory for the coarser graph */
+  if (graph->ncon == 1) {
+    if (dovsize) {
+      cgraph->gdata = idxmalloc(5*cnvtxs+1 + 2*graph->nedges, "SetUpCoarseGraph: gdata");
+      cgraph->xadj 		= cgraph->gdata;
+      cgraph->vwgt 		= cgraph->gdata + cnvtxs+1;
+      cgraph->vsize 		= cgraph->gdata + 2*cnvtxs+1;
+      cgraph->adjwgtsum 	= cgraph->gdata + 3*cnvtxs+1;
+      cgraph->cmap 		= cgraph->gdata + 4*cnvtxs+1;
+      cgraph->adjncy 		= cgraph->gdata + 5*cnvtxs+1;
+      cgraph->adjwgt 		= cgraph->gdata + 5*cnvtxs+1 + graph->nedges;
+    }
+    else {
+      cgraph->gdata = idxmalloc(4*cnvtxs+1 + 2*graph->nedges, "SetUpCoarseGraph: gdata");
+      cgraph->xadj 		= cgraph->gdata;
+      cgraph->vwgt 		= cgraph->gdata + cnvtxs+1;
+      cgraph->adjwgtsum 	= cgraph->gdata + 2*cnvtxs+1;
+      cgraph->cmap 		= cgraph->gdata + 3*cnvtxs+1;
+      cgraph->adjncy 		= cgraph->gdata + 4*cnvtxs+1;
+      cgraph->adjwgt 		= cgraph->gdata + 4*cnvtxs+1 + graph->nedges;
+    }
+  }
+  else {
+    if (dovsize) {
+      cgraph->gdata = idxmalloc(4*cnvtxs+1 + 2*graph->nedges, "SetUpCoarseGraph: gdata");
+      cgraph->xadj 		= cgraph->gdata;
+      cgraph->vsize 		= cgraph->gdata + cnvtxs+1;
+      cgraph->adjwgtsum 	= cgraph->gdata + 2*cnvtxs+1;
+      cgraph->cmap 		= cgraph->gdata + 3*cnvtxs+1;
+      cgraph->adjncy 		= cgraph->gdata + 4*cnvtxs+1;
+      cgraph->adjwgt 		= cgraph->gdata + 4*cnvtxs+1 + graph->nedges;
+    }
+    else {
+      cgraph->gdata = idxmalloc(3*cnvtxs+1 + 2*graph->nedges, "SetUpCoarseGraph: gdata");
+      cgraph->xadj 		= cgraph->gdata;
+      cgraph->adjwgtsum 	= cgraph->gdata + cnvtxs+1;
+      cgraph->cmap 		= cgraph->gdata + 2*cnvtxs+1;
+      cgraph->adjncy 		= cgraph->gdata + 3*cnvtxs+1;
+      cgraph->adjwgt 		= cgraph->gdata + 3*cnvtxs+1 + graph->nedges;
+    }
+
+    cgraph->nvwgt 	= fmalloc(graph->ncon*cnvtxs, "SetUpCoarseGraph: nvwgt");
+  }
+
+  return cgraph;
+}
+
+
+/*************************************************************************
+* This function re-adjusts the amount of memory that was allocated if
+* it will lead to significant savings
+**************************************************************************/
+void ReAdjustMemory(GraphType *graph, GraphType *cgraph, int dovsize) 
+{
+
+  if (cgraph->nedges > 100000 && graph->nedges < 0.7*graph->nedges) {
+    idxcopy(cgraph->nedges, cgraph->adjwgt, cgraph->adjncy+cgraph->nedges);
+
+    if (graph->ncon == 1) {
+      if (dovsize) {
+        cgraph->gdata = realloc(cgraph->gdata, (5*cgraph->nvtxs+1 + 2*cgraph->nedges)*sizeof(idxtype));
+
+        /* Do this, in case everything was copied into new space */
+        cgraph->xadj 		= cgraph->gdata;
+        cgraph->vwgt 		= cgraph->gdata + cgraph->nvtxs+1;
+        cgraph->vsize 		= cgraph->gdata + 2*cgraph->nvtxs+1;
+        cgraph->adjwgtsum	= cgraph->gdata + 3*cgraph->nvtxs+1;
+        cgraph->cmap 		= cgraph->gdata + 4*cgraph->nvtxs+1;
+        cgraph->adjncy 		= cgraph->gdata + 5*cgraph->nvtxs+1;
+        cgraph->adjwgt 		= cgraph->gdata + 5*cgraph->nvtxs+1 + cgraph->nedges;
+      }
+      else {
+        cgraph->gdata = realloc(cgraph->gdata, (4*cgraph->nvtxs+1 + 2*cgraph->nedges)*sizeof(idxtype));
+
+        /* Do this, in case everything was copied into new space */
+        cgraph->xadj 	= cgraph->gdata;
+        cgraph->vwgt 	= cgraph->gdata + cgraph->nvtxs+1;
+        cgraph->adjwgtsum	= cgraph->gdata + 2*cgraph->nvtxs+1;
+        cgraph->cmap 	= cgraph->gdata + 3*cgraph->nvtxs+1;
+        cgraph->adjncy 	= cgraph->gdata + 4*cgraph->nvtxs+1;
+        cgraph->adjwgt 	= cgraph->gdata + 4*cgraph->nvtxs+1 + cgraph->nedges;
+      }
+    }
+    else {
+      if (dovsize) {
+        cgraph->gdata = realloc(cgraph->gdata, (4*cgraph->nvtxs+1 + 2*cgraph->nedges)*sizeof(idxtype));
+
+        /* Do this, in case everything was copied into new space */
+        cgraph->xadj 		= cgraph->gdata;
+        cgraph->vsize		= cgraph->gdata + cgraph->nvtxs+1;
+        cgraph->adjwgtsum	= cgraph->gdata + 2*cgraph->nvtxs+1;
+        cgraph->cmap 		= cgraph->gdata + 3*cgraph->nvtxs+1;
+        cgraph->adjncy 		= cgraph->gdata + 4*cgraph->nvtxs+1;
+        cgraph->adjwgt 		= cgraph->gdata + 4*cgraph->nvtxs+1 + cgraph->nedges;
+      }
+      else {
+        cgraph->gdata = realloc(cgraph->gdata, (3*cgraph->nvtxs+1 + 2*cgraph->nedges)*sizeof(idxtype));
+
+        /* Do this, in case everything was copied into new space */
+        cgraph->xadj 		= cgraph->gdata;
+        cgraph->adjwgtsum	= cgraph->gdata + cgraph->nvtxs+1;
+        cgraph->cmap 		= cgraph->gdata + 2*cgraph->nvtxs+1;
+        cgraph->adjncy 		= cgraph->gdata + 3*cgraph->nvtxs+1;
+        cgraph->adjwgt 		= cgraph->gdata + 3*cgraph->nvtxs+1 + cgraph->nedges;
+      }
+    }
+  }
+
+}
Index: /inundation/pymetis/metis-4.0/Lib/coarsen.c
===================================================================
--- /inundation/pymetis/metis-4.0/Lib/coarsen.c	(revision 2051)
+++ /inundation/pymetis/metis-4.0/Lib/coarsen.c	(revision 2051)
@@ -0,0 +1,83 @@
+/*
+ * coarsen.c
+ *
+ * This file contains the driving routines for the coarsening process 
+ *
+ * Started 7/23/97
+ * George
+ *
+ * $Id: coarsen.c,v 1.1 1998/11/27 17:59:12 karypis Exp $
+ *
+ */
+
+#include <metis.h>
+
+
+/*************************************************************************
+* This function takes a graph and creates a sequence of coarser graphs
+**************************************************************************/
+GraphType *Coarsen2Way(CtrlType *ctrl, GraphType *graph)
+{
+  int clevel;
+  GraphType *cgraph;
+
+  IFSET(ctrl->dbglvl, DBG_TIME, starttimer(ctrl->CoarsenTmr));
+
+  cgraph = graph;
+
+  /* The following is ahack to allow the multiple bisections to go through with correct
+     coarsening */
+  if (ctrl->CType > 20) {
+    clevel = 1;
+    ctrl->CType -= 20;
+  }
+  else
+    clevel = 0;
+
+  do {
+    IFSET(ctrl->dbglvl, DBG_COARSEN, printf("%6d %7d [%d] [%d %d]\n",
+          cgraph->nvtxs, cgraph->nedges, ctrl->CoarsenTo, ctrl->maxvwgt, 
+          (cgraph->vwgt ? idxsum(cgraph->nvtxs, cgraph->vwgt) : cgraph->nvtxs)));
+
+    if (cgraph->adjwgt) {
+      switch (ctrl->CType) {
+        case MATCH_RM:
+          Match_RM(ctrl, cgraph);
+          break;
+        case MATCH_HEM:
+          if (clevel < 1)
+            Match_RM(ctrl, cgraph);
+          else
+            Match_HEM(ctrl, cgraph);
+          break;
+        case MATCH_SHEM:
+          if (clevel < 1)
+            Match_RM(ctrl, cgraph);
+          else
+            Match_SHEM(ctrl, cgraph);
+          break;
+        case MATCH_SHEMKWAY:
+          Match_SHEM(ctrl, cgraph);
+          break;
+        default:
+          errexit("Unknown CType: %d\n", ctrl->CType);
+      }
+    }
+    else {
+      Match_RM_NVW(ctrl, cgraph);
+    }
+
+    cgraph = cgraph->coarser;
+    clevel++;
+
+  } while (cgraph->nvtxs > ctrl->CoarsenTo && cgraph->nvtxs < COARSEN_FRACTION2*cgraph->finer->nvtxs && cgraph->nedges > cgraph->nvtxs/2); 
+
+  IFSET(ctrl->dbglvl, DBG_COARSEN, printf("%6d %7d [%d] [%d %d]\n",
+        cgraph->nvtxs, cgraph->nedges, ctrl->CoarsenTo, ctrl->maxvwgt, 
+        (cgraph->vwgt ? idxsum(cgraph->nvtxs, cgraph->vwgt) : cgraph->nvtxs)));
+
+  IFSET(ctrl->dbglvl, DBG_TIME, stoptimer(ctrl->CoarsenTmr));
+
+  return cgraph;
+}
+
Index: /inundation/pymetis/metis-4.0/Lib/compress.c
===================================================================
--- /inundation/pymetis/metis-4.0/Lib/compress.c	(revision 2051)
+++ /inundation/pymetis/metis-4.0/Lib/compress.c	(revision 2051)
@@ -0,0 +1,256 @@
+/*
+ * Copyright 1997, Regents of the University of Minnesota
+ *
+ * compress.c
+ *
+ * This file contains code for compressing nodes with identical adjacency
+ * structure and for prunning dense columns
+ *
+ * Started 9/17/97
+ * George
+ *
+ * $Id: compress.c,v 1.1 1998/11/27 17:59:12 karypis Exp $
+ */
+
+#include <metis.h>
+
+/*************************************************************************
+* This function compresses a graph by merging identical vertices
+* The compression should lead to at least 10% reduction.
+**************************************************************************/
+void CompressGraph(CtrlType *ctrl, GraphType *graph, int nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *cptr, idxtype *cind)
+{
+  int i, ii, iii, j, jj, k, l, cnvtxs, cnedges;
+  idxtype *cxadj, *cadjncy, *cvwgt, *mark, *map;
+  KeyValueType *keys;
+
+  mark = idxsmalloc(nvtxs, -1, "CompressGraph: mark");
+  map = idxsmalloc(nvtxs, -1, "CompressGraph: map");
+  keys = (KeyValueType *)GKmalloc(nvtxs*sizeof(KeyValueType), "CompressGraph: keys");
+
+  /* Compute a key for each adjacency list */
+  for (i=0; i<nvtxs; i++) {
+    k = 0;
+    for (j=xadj[i]; j<xadj[i+1]; j++)
+      k += adjncy[j];
+    keys[i].key = k+i; /* Add the diagonal entry as well */
+    keys[i].val = i;
+  }
+
+  ikeysort(nvtxs, keys);
+
+  l = cptr[0] = 0;
+  for (cnvtxs=i=0; i<nvtxs; i++) {
+    ii = keys[i].val;
+    if (map[ii] == -1) { 
+      mark[ii] = i;  /* Add the diagonal entry */
+      for (j=xadj[ii]; j<xadj[ii+1]; j++) 
+        mark[adjncy[j]] = i;
+
+      cind[l++] = ii;
+      map[ii] = cnvtxs;
+
+      for (j=i+1; j<nvtxs; j++) {
+        iii = keys[j].val;
+
+        if (keys[i].key != keys[j].key || xadj[ii+1]-xadj[ii] != xadj[iii+1]-xadj[iii])
+          break; /* Break if keys or degrees are different */
+
+        if (map[iii] == -1) { /* Do a comparison if iii has not been mapped */ 
+          for (jj=xadj[iii]; jj<xadj[iii+1]; jj++) {
+            if (mark[adjncy[jj]] != i)
+              break;
+          }
+
+          if (jj == xadj[iii+1]) { /* Identical adjacency structure */
+            map[iii] = cnvtxs;
+            cind[l++] = iii;
+          }
+        }
+      }
+
+      cptr[++cnvtxs] = l;
+    }
+  }
+
+  /* printf("Original: %6d, Compressed: %6d\n", nvtxs, cnvtxs); */
+
+
+  InitGraph(graph);
+
+  if (cnvtxs >= COMPRESSION_FRACTION*nvtxs) {
+    graph->nvtxs = nvtxs;
+    graph->nedges = xadj[nvtxs];
+    graph->ncon = 1;
+    graph->xadj = xadj;
+    graph->adjncy = adjncy;
+
+    graph->gdata = idxmalloc(3*nvtxs+graph->nedges, "CompressGraph: gdata");
+    graph->vwgt    	= graph->gdata;
+    graph->adjwgtsum    = graph->gdata+nvtxs;
+    graph->cmap		= graph->gdata+2*nvtxs;
+    graph->adjwgt	= graph->gdata+3*nvtxs;
+
+    idxset(nvtxs, 1, graph->vwgt);
+    idxset(graph->nedges, 1, graph->adjwgt);
+    for (i=0; i<nvtxs; i++)
+      graph->adjwgtsum[i] = xadj[i+1]-xadj[i];
+
+    graph->label = idxmalloc(nvtxs, "CompressGraph: label");
+    for (i=0; i<nvtxs; i++)
+      graph->label[i] = i;
+  }
+  else { /* Ok, form the compressed graph  */
+    cnedges = 0;
+    for (i=0; i<cnvtxs; i++) {
+      ii = cind[cptr[i]];
+      cnedges += xadj[ii+1]-xadj[ii];
+    }
+
+    /* Allocate memory for the compressed graph*/
+    graph->gdata = idxmalloc(4*cnvtxs+1 + 2*cnedges, "CompressGraph: gdata");
+    cxadj = graph->xadj		= graph->gdata;
+    cvwgt = graph->vwgt         = graph->gdata + cnvtxs+1;
+    graph->adjwgtsum        	= graph->gdata + 2*cnvtxs+1;
+    graph->cmap                 = graph->gdata + 3*cnvtxs+1;
+    cadjncy = graph->adjncy     = graph->gdata + 4*cnvtxs+1;
+    graph->adjwgt            	= graph->gdata + 4*cnvtxs+1 + cnedges;
+
+    /* Now go and compress the graph */
+    idxset(nvtxs, -1, mark);
+    l = cxadj[0] = 0;
+    for (i=0; i<cnvtxs; i++) {
+      cvwgt[i] = cptr[i+1]-cptr[i];
+      mark[i] = i;  /* Remove any dioganal entries in the compressed graph */
+      for (j=cptr[i]; j<cptr[i+1]; j++) {
+        ii = cind[j];
+        for (jj=xadj[ii]; jj<xadj[ii+1]; jj++) {
+          k = map[adjncy[jj]];
+          if (mark[k] != i) 
+            cadjncy[l++] = k;
+          mark[k] = i;
+        }
+      }
+      cxadj[i+1] = l;
+    }
+
+    graph->nvtxs = cnvtxs;
+    graph->nedges = l;
+    graph->ncon = 1;
+
+    idxset(graph->nedges, 1, graph->adjwgt);
+    for (i=0; i<cnvtxs; i++)
+      graph->adjwgtsum[i] = cxadj[i+1]-cxadj[i];
+
+    graph->label = idxmalloc(cnvtxs, "CompressGraph: label");
+    for (i=0; i<cnvtxs; i++)
+      graph->label[i] = i;
+
+  }
+
+  GKfree(&keys, &map, &mark, LTERM);
+}
+
+
+
+/*************************************************************************
+* This function prunes all the vertices in a graph with degree greater 
+* than factor*average
+**************************************************************************/
+void PruneGraph(CtrlType *ctrl, GraphType *graph, int nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *iperm, float factor)
+{
+  int i, j, k, l, nlarge, pnvtxs, pnedges;
+  idxtype *pxadj, *padjncy, *padjwgt, *pvwgt;
+  idxtype *perm;
+
+  perm = idxmalloc(nvtxs, "PruneGraph: perm");
+
+  factor = factor*xadj[nvtxs]/nvtxs;
+
+  pnvtxs = pnedges = nlarge = 0;
+  for (i=0; i<nvtxs; i++) {
+    if (xadj[i+1]-xadj[i] < factor) {
+      perm[i] = pnvtxs;
+      iperm[pnvtxs++] = i;
+      pnedges += xadj[i+1]-xadj[i];
+    }
+    else {
+      perm[i] = nvtxs - ++nlarge;
+      iperm[nvtxs-nlarge] = i;
+    }
+  }
+
+  /* printf("Pruned %d vertices\n", nlarge); */
+
+  InitGraph(graph);
+
+  if (nlarge == 0) { /* No prunning */
+    graph->nvtxs = nvtxs;
+    graph->nedges = xadj[nvtxs];
+    graph->ncon = 1;
+    graph->xadj = xadj;
+    graph->adjncy = adjncy;
+
+    graph->gdata = idxmalloc(3*nvtxs+graph->nedges, "CompressGraph: gdata");
+    graph->vwgt    	= graph->gdata;
+    graph->adjwgtsum    = graph->gdata+nvtxs;
+    graph->cmap		= graph->gdata+2*nvtxs;
+    graph->adjwgt	= graph->gdata+3*nvtxs;
+
+    idxset(nvtxs, 1, graph->vwgt);
+    idxset(graph->nedges, 1, graph->adjwgt);
+    for (i=0; i<nvtxs; i++)
+      graph->adjwgtsum[i] = xadj[i+1]-xadj[i];
+
+    graph->label = idxmalloc(nvtxs, "CompressGraph: label");
+    for (i=0; i<nvtxs; i++)
+      graph->label[i] = i;
+  }
+  else { /* Prune the graph */
+    /* Allocate memory for the compressed graph*/
+    graph->gdata = idxmalloc(4*pnvtxs+1 + 2*pnedges, "PruneGraph: gdata");
+    pxadj = graph->xadj		= graph->gdata;
+    graph->vwgt         	= graph->gdata + pnvtxs+1;
+    graph->adjwgtsum        	= graph->gdata + 2*pnvtxs+1;
+    graph->cmap                 = graph->gdata + 3*pnvtxs+1;
+    padjncy = graph->adjncy     = graph->gdata + 4*pnvtxs+1;
+    graph->adjwgt            	= graph->gdata + 4*pnvtxs+1 + pnedges;
+
+    pxadj[0] = pnedges = l = 0;
+    for (i=0; i<nvtxs; i++) {
+      if (xadj[i+1]-xadj[i] < factor) {
+        for (j=xadj[i]; j<xadj[i+1]; j++) {
+          k = perm[adjncy[j]];
+          if (k < pnvtxs) 
+            padjncy[pnedges++] = k;
+        }
+        pxadj[++l] = pnedges;
+      }
+    }
+
+    graph->nvtxs = pnvtxs;
+    graph->nedges = pnedges;
+    graph->ncon = 1;
+
+    idxset(pnvtxs, 1, graph->vwgt);
+    idxset(pnedges, 1, graph->adjwgt);
+    for (i=0; i<pnvtxs; i++)
+      graph->adjwgtsum[i] = pxadj[i+1]-pxadj[i];
+
+    graph->label = idxmalloc(pnvtxs, "CompressGraph: label");
+    for (i=0; i<pnvtxs; i++)
+      graph->label[i] = i;
+  }
+
+  free(perm);
+
+}
+
+
+
+
+
+
+
+
+
Index: /inundation/pymetis/metis-4.0/Lib/debug.c
===================================================================
--- /inundation/pymetis/metis-4.0/Lib/debug.c	(revision 2051)
+++ /inundation/pymetis/metis-4.0/Lib/debug.c	(revision 2051)
@@ -0,0 +1,239 @@
+/*
+ * Copyright 1997, Regents of the University of Minnesota
+ *
+ * debug.c
+ *
+ * This file contains code that performs self debuging
+ *
+ * Started 7/24/97
+ * George
+ *
+ * $Id: debug.c,v 1.1 1998/11/27 17:59:13 karypis Exp $
+ *
+ */
+
+#include <metis.h>
+
+/*************************************************************************
+* This function computes the cut given the graph and a where vector
+**************************************************************************/
+int ComputeCut(GraphType *graph, idxtype *where)
+{
+  int i, j, cut;
+
+  if (graph->adjwgt == NULL) {
+    for (cut=0, i=0; i<graph->nvtxs; i++) {
+      for (j=graph->xadj[i]; j<graph->xadj[i+1]; j++)
+        if (where[i] != where[graph->adjncy[j]])
+          cut++;
+    }
+  }
+  else {
+    for (cut=0, i=0; i<graph->nvtxs; i++) {
+      for (j=graph->xadj[i]; j<graph->xadj[i+1]; j++)
+        if (where[i] != where[graph->adjncy[j]])
+          cut += graph->adjwgt[j];
+    }
+  }
+
+  return cut/2;
+}
+
+
+/*************************************************************************
+* This function checks whether or not the boundary information is correct
+**************************************************************************/
+int CheckBnd(GraphType *graph) 
+{
+  int i, j, nvtxs, nbnd;
+  idxtype *xadj, *adjncy, *where, *bndptr, *bndind;
+
+  nvtxs = graph->nvtxs;
+  xadj = graph->xadj;
+  adjncy = graph->adjncy;
+  where = graph->where;
+  bndptr = graph->bndptr;
+  bndind = graph->bndind;
+
+  for (nbnd=0, i=0; i<nvtxs; i++) {
+    if (xadj[i+1]-xadj[i] == 0)
+      nbnd++;   /* Islands are considered to be boundary vertices */
+
+    for (j=xadj[i]; j<xadj[i+1]; j++) {
+      if (where[i] != where[adjncy[j]]) {
+        nbnd++;
+        ASSERT(bndptr[i] != -1);
+        ASSERT(bndind[bndptr[i]] == i);
+        break;
+      }
+    }
+  }
+
+  ASSERTP(nbnd == graph->nbnd, ("%d %d\n", nbnd, graph->nbnd));
+
+  return 1;
+}
+
+
+
+/*************************************************************************
+* This function checks whether or not the boundary information is correct
+**************************************************************************/
+int CheckBnd2(GraphType *graph) 
+{
+  int i, j, nvtxs, nbnd, id, ed;
+  idxtype *xadj, *adjncy, *where, *bndptr, *bndind;
+
+  nvtxs = graph->nvtxs;
+  xadj = graph->xadj;
+  adjncy = graph->adjncy;
+  where = graph->where;
+  bndptr = graph->bndptr;
+  bndind = graph->bndind;
+
+  for (nbnd=0, i=0; i<nvtxs; i++) {
+    id = ed = 0;
+    for (j=xadj[i]; j<xadj[i+1]; j++) {
+      if (where[i] != where[adjncy[j]]) 
+        ed += graph->adjwgt[j];
+      else
+        id += graph->adjwgt[j];
+    }
+    if (ed - id >= 0 && xadj[i] < xadj[i+1]) {
+      nbnd++;
+      ASSERTP(bndptr[i] != -1, ("%d %d %d\n", i, id, ed));
+      ASSERT(bndind[bndptr[i]] == i);
+    }
+  }
+
+  ASSERTP(nbnd == graph->nbnd, ("%d %d\n", nbnd, graph->nbnd));
+
+  return 1;
+}
+
+/*************************************************************************
+* This function checks whether or not the boundary information is correct
+**************************************************************************/
+int CheckNodeBnd(GraphType *graph, int onbnd) 
+{
+  int i, j, nvtxs, nbnd;
+  idxtype *xadj, *adjncy, *where, *bndptr, *bndind;
+
+  nvtxs = graph->nvtxs;
+  xadj = graph->xadj;
+  adjncy = graph->adjncy;
+  where = graph->where;
+  bndptr = graph->bndptr;
+  bndind = graph->bndind;
+
+  for (nbnd=0, i=0; i<nvtxs; i++) {
+    if (where[i] == 2) 
+      nbnd++;   
+  }
+
+  ASSERTP(nbnd == onbnd, ("%d %d\n", nbnd, onbnd));
+
+  for (i=0; i<nvtxs; i++) {
+    if (where[i] != 2) {
+      ASSERTP(bndptr[i] == -1, ("%d %d\n", i, bndptr[i]));
+    }
+    else {
+      ASSERTP(bndptr[i] != -1, ("%d %d\n", i, bndptr[i]));
+    }
+  }
+
+  return 1;
+}
+
+
+
+/*************************************************************************
+* This function checks whether or not the rinfo of a vertex is consistent
+**************************************************************************/
+int CheckRInfo(RInfoType *rinfo)
+{
+  int i, j;
+
+  for (i=0; i<rinfo->ndegrees; i++) {
+    for (j=i+1; j<rinfo->ndegrees; j++)
+      ASSERTP(rinfo->edegrees[i].pid != rinfo->edegrees[j].pid, ("%d %d %d %d\n", i, j, rinfo->edegrees[i].pid, rinfo->edegrees[j].pid));
+  }
+
+  return 1;
+}
+
+
+
+/*************************************************************************
+* This function checks the correctness of the NodeFM data structures
+**************************************************************************/
+int CheckNodePartitionParams(GraphType *graph)
+{
+  int i, j, k, l, nvtxs, me, other;
+  idxtype *xadj, *adjncy, *adjwgt, *vwgt, *where;
+  idxtype edegrees[2], pwgts[3];
+
+  nvtxs = graph->nvtxs;
+  xadj = graph->xadj;
+  vwgt = graph->vwgt;
+  adjncy = graph->adjncy;
+  adjwgt = graph->adjwgt;
+
+  where = graph->where;
+
+  /*------------------------------------------------------------
+  / Compute now the separator external degrees
+  /------------------------------------------------------------*/
+  pwgts[0] = pwgts[1] = pwgts[2] = 0;
+  for (i=0; i<nvtxs; i++) {
+    me = where[i];
+    pwgts[me] += vwgt[i];
+
+    if (me == 2) { /* If it is on the separator do some computations */
+      edegrees[0] = edegrees[1] = 0;
+
+      for (j=xadj[i]; j<xadj[i+1]; j++) {
+        other = where[adjncy[j]];
+        if (other != 2)
+          edegrees[other] += vwgt[adjncy[j]];
+      }
+      if (edegrees[0] != graph->nrinfo[i].edegrees[0] || edegrees[1] != graph->nrinfo[i].edegrees[1]) {
+        printf("Something wrong with edegrees: %d %d %d %d %d\n", i, edegrees[0], edegrees[1], graph->nrinfo[i].edegrees[0], graph->nrinfo[i].edegrees[1]);
+        return 0;
+      }
+    }
+  }
+
+  if (pwgts[0] != graph->pwgts[0] || pwgts[1] != graph->pwgts[1] || pwgts[2] != graph->pwgts[2])
+    printf("Something wrong with part-weights: %d %d %d %d %d %d\n", pwgts[0], pwgts[1], pwgts[2], graph->pwgts[0], graph->pwgts[1], graph->pwgts[2]);
+
+  return 1;
+}
+
+
+/*************************************************************************
+* This function checks if the separator is indeed a separator
+**************************************************************************/
+int IsSeparable(GraphType *graph)
+{
+  int i, j, nvtxs, other;
+  idxtype *xadj, *adjncy, *where;
+
+  nvtxs = graph->nvtxs;
+  xadj = graph->xadj;
+  adjncy = graph->adjncy;
+  where = graph->where;
+
+  for (i=0; i<nvtxs; i++) {
+    if (where[i] == 2)
+      continue;
+    other = (where[i]+1)%2;
+    for (j=xadj[i]; j<xadj[i+1]; j++) {
+      ASSERTP(where[adjncy[j]] != other, ("%d %d %d %d %d %d\n", i, where[i], adjncy[j], where[adjncy[j]], xadj[i+1]-xadj[i], xadj[adjncy[j]+1]-xadj[adjncy[j]]));
+    }
+  }
+
+  return 1;
+}
+
+
Index: /inundation/pymetis/metis-4.0/Lib/defs.h
===================================================================
--- /inundation/pymetis/metis-4.0/Lib/defs.h	(revision 2051)
+++ /inundation/pymetis/metis-4.0/Lib/defs.h	(revision 2051)
@@ -0,0 +1,161 @@
+/*
+ * Copyright 1997, Regents of the University of Minnesota
+ *
+ * defs.h
+ *
+ * This file contains constant definitions
+ *
+ * Started 8/27/94
+ * George
+ *
+ * $Id: defs.h,v 1.1 1998/11/27 17:59:13 karypis Exp $
+ *
+ */
+
+#define METISTITLE              "  METIS 4.0.1 Copyright 1998, Regents of the University of Minnesota\n\n"
+#define MAXLINE			1280000
+
+#define LTERM			(void **) 0	/* List terminator for GKfree() */
+
+#define MAXNCON			16		/* The maximum number of constrains */
+#define MAXNOBJ			16		/* The maximum number of objectives */
+
+#define PLUS_GAINSPAN   	500             /* Parameters for FM buckets */
+#define NEG_GAINSPAN    	500
+
+#define HTLENGTH		((1<<11)-1)
+
+/* Meaning of various options[] parameters */
+#define OPTION_PTYPE		0
+#define OPTION_CTYPE		1
+#define OPTION_ITYPE		2
+#define OPTION_RTYPE		3
+#define OPTION_DBGLVL		4
+#define OPTION_OFLAGS		5
+#define OPTION_PFACTOR		6
+#define OPTION_NSEPS		7
+
+#define OFLAG_COMPRESS		1	/* Try to compress the graph */
+#define OFLAG_CCMP		2	/* Find and order connected components */
+
+
+/* Default options for PMETIS */
+#define PMETIS_CTYPE		MATCH_SHEM
+#define PMETIS_ITYPE		IPART_GGPKL
+#define PMETIS_RTYPE		RTYPE_FM
+#define PMETIS_DBGLVL		0
+
+/* Default options for KMETIS */
+#define KMETIS_CTYPE		MATCH_SHEM
+#define KMETIS_ITYPE		IPART_PMETIS
+#define KMETIS_RTYPE		RTYPE_KWAYRANDOM_MCONN
+#define KMETIS_DBGLVL		0
+
+/* Default options for OEMETIS */
+#define OEMETIS_CTYPE		MATCH_SHEM
+#define OEMETIS_ITYPE		IPART_GGPKL
+#define OEMETIS_RTYPE		RTYPE_FM
+#define OEMETIS_DBGLVL		0
+
+/* Default options for ONMETIS */
+#define ONMETIS_CTYPE		MATCH_SHEM
+#define ONMETIS_ITYPE		IPART_GGPKL
+#define ONMETIS_RTYPE		RTYPE_SEP1SIDED
+#define ONMETIS_DBGLVL		0
+#define ONMETIS_OFLAGS		OFLAG_COMPRESS
+#define ONMETIS_PFACTOR		-1
+#define ONMETIS_NSEPS		1
+
+/* Default options for McPMETIS */
+#define McPMETIS_CTYPE		MATCH_SHEBM_ONENORM
+#define McPMETIS_ITYPE		IPART_RANDOM
+#define McPMETIS_RTYPE		RTYPE_FM
+#define McPMETIS_DBGLVL		0
+
+/* Default options for McKMETIS */
+#define McKMETIS_CTYPE		MATCH_SHEBM_ONENORM
+#define McKMETIS_ITYPE		IPART_McHPMETIS
+#define McKMETIS_RTYPE		RTYPE_KWAYRANDOM
+#define McKMETIS_DBGLVL		0
+
+/* Default options for KVMETIS */
+#define KVMETIS_CTYPE		MATCH_SHEM
+#define KVMETIS_ITYPE		IPART_PMETIS
+#define KVMETIS_RTYPE		RTYPE_KWAYRANDOM
+#define KVMETIS_DBGLVL		0
+
+
+/* Operations supported by stand-alone code */
+#define OP_PMETIS		1
+#define OP_KMETIS		2
+#define OP_OEMETIS		3
+#define OP_ONMETIS		4
+#define OP_ONWMETIS		5
+#define OP_KVMETIS		6
+
+
+/* Matching Schemes */
+#define MATCH_RM		1
+#define MATCH_HEM		2
+#define MATCH_SHEM		3
+#define MATCH_SHEMKWAY		4
+#define MATCH_SHEBM_ONENORM	5
+#define MATCH_SHEBM_INFNORM	6
+#define MATCH_SBHEM_ONENORM	7
+#define MATCH_SBHEM_INFNORM	8
+
+/* Initial partitioning schemes for PMETIS and ONMETIS */
+#define IPART_GGPKL		1
+#define IPART_GGPKLNODE		2
+#define IPART_RANDOM		2
+
+/* Refinement schemes for PMETIS */
+#define RTYPE_FM		1
+
+/* Initial partitioning schemes for KMETIS */
+#define IPART_PMETIS		1
+
+/* Refinement schemes for KMETIS */
+#define RTYPE_KWAYRANDOM	1
+#define RTYPE_KWAYGREEDY	2
+#define RTYPE_KWAYRANDOM_MCONN	3
+
+/* Refinement schemes for ONMETIS */
+#define RTYPE_SEP2SIDED		1
+#define RTYPE_SEP1SIDED		2
+
+/* Initial Partitioning Schemes for McKMETIS */
+#define IPART_McPMETIS		1   	/* Simple McPMETIS */
+#define IPART_McHPMETIS		2	/* horizontally relaxed McPMETIS */
+
+#define UNMATCHED		-1
+
+#define HTABLE_EMPTY    	-1
+
+#define NGR_PASSES		4	/* Number of greedy refinement passes */
+#define NLGR_PASSES		5	/* Number of GR refinement during IPartition */
+
+#define LARGENIPARTS		8	/* Number of random initial partitions */
+#define SMALLNIPARTS		3	/* Number of random initial partitions */
+
+#define COARSEN_FRACTION	0.75	/* Node reduction between succesive coarsening levels */
+#define COARSEN_FRACTION2	0.90	/* Node reduction between succesive coarsening levels */
+#define UNBALANCE_FRACTION		1.05
+
+#define COMPRESSION_FRACTION		0.85
+
+#define ORDER_UNBALANCE_FRACTION	1.10
+
+#define MMDSWITCH		200
+
+#define HORIZONTAL_IMBALANCE		1.05
+
+/* Debug Levels */
+#define DBG_TIME	1		/* Perform timing analysis */
+#define DBG_OUTPUT	2
+#define DBG_COARSEN   	4		/* Show the coarsening progress */
+#define DBG_REFINE	8		/* Show info on communication during folding */
+#define DBG_IPART	16		/* Show info on initial partition */
+#define DBG_MOVEINFO	32		/* Show info on communication during folding */
+#define DBG_KWAYPINFO	64		/* Show info on communication during folding */
+#define DBG_SEPINFO	128		/* Show info on communication during folding */
Index: /inundation/pymetis/metis-4.0/Lib/estmem.c
===================================================================
--- /inundation/pymetis/metis-4.0/Lib/estmem.c	(revision 2051)
+++ /inundation/pymetis/metis-4.0/Lib/estmem.c	(revision 2051)
@@ -0,0 +1,157 @@
+/*
+ * Copyright 1997, Regents of the University of Minnesota
+ *
+ * estmem.c
+ *
+ * This file contains code for estimating the amount of memory required by
+ * the various routines in METIS
+ *
+ * Started 11/4/97
+ * George
+ *
+ * $Id: estmem.c,v 1.1 1998/11/27 17:59:13 karypis Exp $
+ *
+ */
+
+#include <metis.h>
+
+/*************************************************************************
+* This function computes how much memory will be required by the various
+* routines in METIS
+**************************************************************************/
+void METIS_EstimateMemory(int *nvtxs, idxtype *xadj, idxtype *adjncy, int *numflag, int *optype, int *nbytes)
+{
+  int i, j, k, nedges, nlevels;
+  float vfraction, efraction, vmult, emult;
+  int coresize, gdata, rdata;
+
+  if (*numflag == 1)
+    Change2CNumbering(*nvtxs, xadj, adjncy);
+
+  nedges = xadj[*nvtxs];
+
+  InitRandom(-1);
+  EstimateCFraction(*nvtxs, xadj, adjncy, &vfraction, &efraction);
+
+  /* Estimate the amount of memory for coresize */
+  if (*optype == 2) 
+    coresize = nedges;
+  else
+    coresize = 0;
+  coresize += nedges + 11*(*nvtxs) + 4*1024 + 2*(NEG_GAINSPAN+PLUS_GAINSPAN+1)*(sizeof(ListNodeType *)/sizeof(idxtype));
+  coresize += 2*(*nvtxs);  /* add some more fore other vectors */
+
+  gdata = nedges;   /* Assume that the user does not pass weights */
+
+  nlevels = (int)(log(100.0/(*nvtxs))/log(vfraction) + .5);
+  vmult = 0.5 + (1.0 - pow(vfraction, nlevels))/(1.0 - vfraction);
+  emult = 1.0 + (1.0 - pow(efraction, nlevels+1))/(1.0 - efraction);
+
+  gdata += vmult*4*(*nvtxs) + emult*2*nedges;
+  if ((vmult-1.0)*4*(*nvtxs) + (emult-1.0)*2*nedges < 5*(*nvtxs))
+    rdata = 0;
+  else
+    rdata = 5*(*nvtxs);
+
+  *nbytes = sizeof(idxtype)*(coresize+gdata+rdata+(*nvtxs));
+
+  if (*numflag == 1)
+    Change2FNumbering2(*nvtxs, xadj, adjncy);
+}
+  
+
+/*************************************************************************
+* This function finds a matching using the HEM heuristic
+**************************************************************************/
+void EstimateCFraction(int nvtxs, idxtype *xadj, idxtype *adjncy, float *vfraction, float *efraction)
+{
+  int i, ii, j, cnvtxs, cnedges, maxidx;
+  idxtype *match, *cmap, *perm;
+
+  cmap = idxmalloc(nvtxs, "cmap");
+  match = idxsmalloc(nvtxs, UNMATCHED, "match");
+  perm = idxmalloc(nvtxs, "perm");
+  RandomPermute(nvtxs, perm, 1);
+
+  cnvtxs = 0;
+  for (ii=0; ii<nvtxs; ii++) {
+    i = perm[ii];
+
+    if (match[i] == UNMATCHED) {  /* Unmatched */
+      maxidx = i;
+
+      /* Find a random matching, subject to maxvwgt constraints */
+      for (j=xadj[i]; j<xadj[i+1]; j++) {
+        if (match[adjncy[j]] == UNMATCHED) {
+          maxidx = adjncy[j];
+          break;
+        }
+      }
+
+      cmap[i] = cmap[maxidx] = cnvtxs++;
+      match[i] = maxidx;
+      match[maxidx] = i;
+    }
+  }
+
+  cnedges = ComputeCoarseGraphSize(nvtxs, xadj, adjncy, cnvtxs, cmap, match, perm);
+
+  *vfraction = (1.0*cnvtxs)/(1.0*nvtxs);
+  *efraction = (1.0*cnedges)/(1.0*xadj[nvtxs]);
+
+  GKfree(&cmap, &match, &perm, LTERM);
+}
+
+
+
+
+/*************************************************************************
+* This function computes the size of the coarse graph
+**************************************************************************/
+int ComputeCoarseGraphSize(int nvtxs, idxtype *xadj, idxtype *adjncy, int cnvtxs, idxtype *cmap, idxtype *match, idxtype *perm)
+{
+  int i, j, k, istart, iend, nedges, cnedges, v, u;
+  idxtype *htable;
+
+  htable = idxsmalloc(cnvtxs, -1, "htable");
+
+  cnvtxs = cnedges = 0;
+  for (i=0; i<nvtxs; i++) {
+    v = perm[i];
+    if (cmap[v] != cnvtxs) 
+      continue;
+
+    htable[cnvtxs] = cnvtxs;
+
+    u = match[v];
+
+    istart = xadj[v];
+    iend = xadj[v+1];
+    for (j=istart; j<iend; j++) {
+      k = cmap[adjncy[j]];
+      if (htable[k] != cnvtxs) {
+        htable[k] = cnvtxs;
+        cnedges++;
+      }
+    }
+
+    if (v != u) { 
+      istart = xadj[u];
+      iend = xadj[u+1];
+      for (j=istart; j<iend; j++) {
+        k = cmap[adjncy[j]];
+        if (htable[k] != cnvtxs) {
+          htable[k] = cnvtxs;
+          cnedges++;
+        }
+      }
+    }
+    cnvtxs++;
+  }
+
+  GKfree(&htable, LTERM);
+
+  return cnedges;
+}
+
+
Index: /inundation/pymetis/metis-4.0/Lib/fm.c
===================================================================
--- /inundation/pymetis/metis-4.0/Lib/fm.c	(revision 2051)
+++ /inundation/pymetis/metis-4.0/Lib/fm.c	(revision 2051)
@@ -0,0 +1,194 @@
+/*
+ * Copyright 1997, Regents of the University of Minnesota
+ *
+ * fm.c
+ *
+ * This file contains code that implements the edge-based FM refinement
+ *
+ * Started 7/23/97
+ * George
+ *
+ * $Id: fm.c,v 1.1 1998/11/27 17:59:14 karypis Exp $
+ */
+
+#include <metis.h>
+
+
+/*************************************************************************
+* This function performs an edge-based FM refinement
+**************************************************************************/
+void FM_2WayEdgeRefine(CtrlType *ctrl, GraphType *graph, int *tpwgts, int npasses)
+{
+  int i, ii, j, k, kwgt, nvtxs, nbnd, nswaps, from, to, pass, me, limit, tmp;
+  idxtype *xadj, *vwgt, *adjncy, *adjwgt, *where, *id, *ed, *bndptr, *bndind, *pwgts;
+  idxtype *moved, *swaps, *perm;
+  PQueueType parts[2];
+  int higain, oldgain, mincut, mindiff, origdiff, initcut, newcut, mincutorder, avgvwgt;
+
+  nvtxs = graph->nvtxs;
+  xadj = graph->xadj;
+  vwgt = graph->vwgt;
+  adjncy = graph->adjncy;
+  adjwgt = graph->adjwgt;
+  where = graph->where;
+  id = graph->id;
+  ed = graph->ed;
+  pwgts = graph->pwgts;
+  bndptr = graph->bndptr;
+  bndind = graph->bndind;
+
+  moved = idxwspacemalloc(ctrl, nvtxs);
+  swaps = idxwspacemalloc(ctrl, nvtxs);
+  perm = idxwspacemalloc(ctrl, nvtxs);
+
+  limit = amin(amax(0.01*nvtxs, 15), 100);
+  avgvwgt = amin((pwgts[0]+pwgts[1])/20, 2*(pwgts[0]+pwgts[1])/nvtxs);
+
+  tmp = graph->adjwgtsum[idxamax(nvtxs, graph->adjwgtsum)];
+  PQueueInit(ctrl, &parts[0], nvtxs, tmp);
+  PQueueInit(ctrl, &parts[1], nvtxs, tmp);
+
+  IFSET(ctrl->dbglvl, DBG_REFINE, 
+     printf("Partitions: [%6d %6d] T[%6d %6d], Nv-Nb[%6d %6d]. ICut: %6d\n",
+             pwgts[0], pwgts[1], tpwgts[0], tpwgts[1], graph->nvtxs, graph->nbnd, graph->mincut));
+
+  origdiff = abs(tpwgts[0]-pwgts[0]);
+  idxset(nvtxs, -1, moved);
+  for (pass=0; pass<npasses; pass++) { /* Do a number of passes */
+    PQueueReset(&parts[0]);
+    PQueueReset(&parts[1]);
+
+    mincutorder = -1;
+    newcut = mincut = initcut = graph->mincut;
+    mindiff = abs(tpwgts[0]-pwgts[0]);
+
+    ASSERT(ComputeCut(graph, where) == graph->mincut);
+    ASSERT(CheckBnd(graph));
+
+    /* Insert boundary nodes in the priority queues */
+    nbnd = graph->nbnd;
+    RandomPermute(nbnd, perm, 1);
+    for (ii=0; ii<nbnd; ii++) {
+      i = perm[ii];
+      ASSERT(ed[bndind[i]] > 0 || id[bndind[i]] == 0);
+      ASSERT(bndptr[bndind[i]] != -1);
+      PQueueInsert(&parts[where[bndind[i]]], bndind[i], ed[bndind[i]]-id[bndind[i]]);
+    }
+
+    for (nswaps=0; nswaps<nvtxs; nswaps++) {
+      from = (tpwgts[0]-pwgts[0] < tpwgts[1]-pwgts[1] ? 0 : 1);
+      to = (from+1)%2;
+
+      if ((higain = PQueueGetMax(&parts[from])) == -1)
+        break;
+      ASSERT(bndptr[higain] != -1);
+
+      newcut -= (ed[higain]-id[higain]);
+      INC_DEC(pwgts[to], pwgts[from], vwgt[higain]);
+
+      if ((newcut < mincut && abs(tpwgts[0]-pwgts[0]) <= origdiff+avgvwgt) || 
+          (newcut == mincut && abs(tpwgts[0]-pwgts[0]) < mindiff)) {
+        mincut = newcut;
+        mindiff = abs(tpwgts[0]-pwgts[0]);
+        mincutorder = nswaps;
+      }
+      else if (nswaps-mincutorder > limit) { /* We hit the limit, undo last move */
+        newcut += (ed[higain]-id[higain]);
+        INC_DEC(pwgts[from], pwgts[to], vwgt[higain]);
+        break;
+      }
+
+      where[higain] = to;
+      moved[higain] = nswaps;
+      swaps[nswaps] = higain;
+
+      IFSET(ctrl->dbglvl, DBG_MOVEINFO, 
+        printf("Moved %6d from %d. [%3d %3d] %5d [%4d %4d]\n", higain, from, ed[higain]-id[higain], vwgt[higain], newcut, pwgts[0], pwgts[1]));
+
+      /**************************************************************
+      * Update the id[i]/ed[i] values of the affected nodes
+      ***************************************************************/
+      SWAP(id[higain], ed[higain], tmp);
+      if (ed[higain] == 0 && xadj[higain] < xadj[higain+1]) 
+        BNDDelete(nbnd, bndind,  bndptr, higain);
+
+      for (j=xadj[higain]; j<xadj[higain+1]; j++) {
+        k = adjncy[j];
+        oldgain = ed[k]-id[k];
+
+        kwgt = (to == where[k] ? adjwgt[j] : -adjwgt[j]);
+        INC_DEC(id[k], ed[k], kwgt);
+
+        /* Update its boundary information and queue position */
+        if (bndptr[k] != -1) { /* If k was a boundary vertex */
+          if (ed[k] == 0) { /* Not a boundary vertex any more */
+            BNDDelete(nbnd, bndind, bndptr, k);
+            if (moved[k] == -1)  /* Remove it if in the queues */
+              PQueueDelete(&parts[where[k]], k, oldgain);
+          }
+          else { /* If it has not been moved, update its position in the queue */
+            if (moved[k] == -1)
+              PQueueUpdate(&parts[where[k]], k, oldgain, ed[k]-id[k]);
+          }
+        }
+        else {
+          if (ed[k] > 0) {  /* It will now become a boundary vertex */
+            BNDInsert(nbnd, bndind, bndptr, k);
+            if (moved[k] == -1) 
+              PQueueInsert(&parts[where[k]], k, ed[k]-id[k]);
+          }
+        }
+      }
+
+    }
+
+
+    /****************************************************************
+    * Roll back computations
+    *****************************************************************/
+    for (i=0; i<nswaps; i++)
+      moved[swaps[i]] = -1;  /* reset moved array */
+    for (nswaps--; nswaps>mincutorder; nswaps--) {
+      higain = swaps[nswaps];
+
+      to = where[higain] = (where[higain]+1)%2;
+      SWAP(id[higain], ed[higain], tmp);
+      if (ed[higain] == 0 && bndptr[higain] != -1 && xadj[higain] < xadj[higain+1])
+        BNDDelete(nbnd, bndind,  bndptr, higain);
+      else if (ed[higain] > 0 && bndptr[higain] == -1)
+        BNDInsert(nbnd, bndind,  bndptr, higain);
+
+      INC_DEC(pwgts[to], pwgts[(to+1)%2], vwgt[higain]);
+      for (j=xadj[higain]; j<xadj[higain+1]; j++) {
+        k = adjncy[j];
+
+        kwgt = (to == where[k] ? adjwgt[j] : -adjwgt[j]);
+        INC_DEC(id[k], ed[k], kwgt);
+
+        if (bndptr[k] != -1 && ed[k] == 0)
+          BNDDelete(nbnd, bndind, bndptr, k);
+        if (bndptr[k] == -1 && ed[k] > 0)
+          BNDInsert(nbnd, bndind, bndptr, k);
+      }
+    }
+
+    IFSET(ctrl->dbglvl, DBG_REFINE, 
+      printf("\tMinimum cut: %6d at %5d, PWGTS: [%6d %6d], NBND: %6d\n", mincut, mincutorder, pwgts[0], pwgts[1], nbnd));
+
+    graph->mincut = mincut;
+    graph->nbnd = nbnd;
+
+    if (mincutorder == -1 || mincut == initcut)
+      break;
+  }
+
+  PQueueFree(ctrl, &parts[0]);
+  PQueueFree(ctrl, &parts[1]);
+
+  idxwspacefree(ctrl, nvtxs);
+  idxwspacefree(ctrl, nvtxs);
+  idxwspacefree(ctrl, nvtxs);
+
+}
+
+
Index: /inundation/pymetis/metis-4.0/Lib/fortran.c
===================================================================
--- /inundation/pymetis/metis-4.0/Lib/fortran.c	(revision 2051)
+++ /inundation/pymetis/metis-4.0/Lib/fortran.c	(revision 2051)
@@ -0,0 +1,141 @@
+/*
+ * Copyright 1997, Regents of the University of Minnesota
+ *
+ * fortran.c
+ *
+ * This file contains code for the fortran to C interface
+ *
+ * Started 8/19/97
+ * George
+ *
+ * $Id: fortran.c,v 1.1 1998/11/27 17:59:14 karypis Exp $
+ *
+ */
+
+#include <metis.h>
+
+
+/*************************************************************************
+* This function changes the numbering to start from 0 instead of 1
+**************************************************************************/
+void Change2CNumbering(int nvtxs, idxtype *xadj, idxtype *adjncy)
+{
+  int i, nedges;
+
+  for (i=0; i<=nvtxs; i++)
+    xadj[i]--;
+
+  nedges = xadj[nvtxs];
+  for (i=0; i<nedges; i++)
+    adjncy[i]--;
+}
+
+/*************************************************************************
+* This function changes the numbering to start from 1 instead of 0
+**************************************************************************/
+void Change2FNumbering(int nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vector)
+{
+  int i, nedges;
+
+  for (i=0; i<nvtxs; i++)
+    vector[i]++;
+
+  nedges = xadj[nvtxs];
+  for (i=0; i<nedges; i++)
+    adjncy[i]++;
+
+  for (i=0; i<=nvtxs; i++)
+    xadj[i]++;
+}
+
+/*************************************************************************
+* This function changes the numbering to start from 1 instead of 0
+**************************************************************************/
+void Change2FNumbering2(int nvtxs, idxtype *xadj, idxtype *adjncy)
+{
+  int i, nedges;
+
+  nedges = xadj[nvtxs];
+  for (i=0; i<nedges; i++)
+    adjncy[i]++;
+
+  for (i=0; i<=nvtxs; i++)
+    xadj[i]++;
+}
+
+
+
+/*************************************************************************
+* This function changes the numbering to start from 1 instead of 0
+**************************************************************************/
+void Change2FNumberingOrder(int nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *v1, idxtype *v2)
+{
+  int i, nedges;
+
+  for (i=0; i<nvtxs; i++) {
+    v1[i]++;
+    v2[i]++;
+  }
+
+  nedges = xadj[nvtxs];
+  for (i=0; i<nedges; i++)
+    adjncy[i]++;
+
+  for (i=0; i<=nvtxs; i++)
+    xadj[i]++;
+
+}
+
+
+
+/*************************************************************************
+* This function changes the numbering to start from 0 instead of 1
+**************************************************************************/
+void ChangeMesh2CNumbering(int n, idxtype *mesh)
+{
+  int i;
+
+  for (i=0; i<n; i++)
+    mesh[i]--;
+
+}
+
+
+/*************************************************************************
+* This function changes the numbering to start from 1 instead of 0
+**************************************************************************/
+void ChangeMesh2FNumbering(int n, idxtype *mesh, int nvtxs, idxtype *xadj, idxtype *adjncy)
+{
+  int i, nedges;
+
+  for (i=0; i<n; i++)
+    mesh[i]++;
+
+  nedges = xadj[nvtxs];
+  for (i=0; i<nedges; i++)
+    adjncy[i]++;
+
+  for (i=0; i<=nvtxs; i++)
+    xadj[i]++;
+
+}
+
+
+/*************************************************************************
+* This function changes the numbering to start from 1 instead of 0
+**************************************************************************/
+void ChangeMesh2FNumbering2(int n, idxtype *mesh, int ne, int nn, idxtype *epart, idxtype *npart)
+{
+  int i, nedges;
+
+  for (i=0; i<n; i++)
+    mesh[i]++;
+
+  for (i=0; i<ne; i++)
+    epart[i]++;
+
+  for (i=0; i<nn; i++)
+    npart[i]++;
+
+}
+
Index: /inundation/pymetis/metis-4.0/Lib/frename.c
===================================================================
--- /inundation/pymetis/metis-4.0/Lib/frename.c	(revision 2051)
+++ /inundation/pymetis/metis-4.0/Lib/frename.c	(revision 2051)
@@ -0,0 +1,312 @@
+/*
+ * Copyright 1997, Regents of the University of Minnesota
+ *
+ * frename.c
+ * 
+ * This file contains some renaming routines to deal with different Fortran compilers
+ *
+ * Started 9/15/97
+ * George
+ *
+ * $Id: frename.c,v 1.1 1998/11/27 17:59:14 karypis Exp $
+ *
+ */
+
+#include <metis.h>
+
+
+void METIS_PARTGRAPHRECURSIVE(int *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *adjwgt, int *wgtflag, int *numflag, int *nparts, int *options, int *edgecut, idxtype *part)
+{
+  METIS_PartGraphRecursive(nvtxs, xadj, adjncy, vwgt, adjwgt, wgtflag, numflag, nparts, options, edgecut, part);
+}
+void metis_partgraphrecursive(int *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *adjwgt, int *wgtflag, int *numflag, int *nparts, int *options, int *edgecut, idxtype *part)
+{ 
+  METIS_PartGraphRecursive(nvtxs, xadj, adjncy, vwgt, adjwgt, wgtflag, numflag, nparts, options, edgecut, part); 
+}
+void metis_partgraphrecursive_(int *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *adjwgt, int *wgtflag, int *numflag, int *nparts, int *options, int *edgecut, idxtype *part)
+{
+  METIS_PartGraphRecursive(nvtxs, xadj, adjncy, vwgt, adjwgt, wgtflag, numflag, nparts, options, edgecut, part);
+}
+void metis_partgraphrecursive__(int *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *adjwgt, int *wgtflag, int *numflag, int *nparts, int *options, int *edgecut, idxtype *part)
+{
+  METIS_PartGraphRecursive(nvtxs, xadj, adjncy, vwgt, adjwgt, wgtflag, numflag, nparts, options, edgecut, part);
+}
+
+
+void METIS_WPARTGRAPHRECURSIVE(int *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *adjwgt, int *wgtflag, int *numflag, int *nparts, float *tpwgts, int *options, int *edgecut, idxtype *part)
+{
+  METIS_WPartGraphRecursive(nvtxs, xadj, adjncy, vwgt, adjwgt, wgtflag, numflag, nparts, tpwgts, options, edgecut, part);
+}
+void metis_wpartgraphrecursive(int *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *adjwgt, int *wgtflag, int *numflag, int *nparts, float *tpwgts, int *options, int *edgecut, idxtype *part)
+{
+  METIS_WPartGraphRecursive(nvtxs, xadj, adjncy, vwgt, adjwgt, wgtflag, numflag, nparts, tpwgts, options, edgecut, part);
+}
+void metis_wpartgraphrecursive_(int *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *adjwgt, int *wgtflag, int *numflag, int *nparts, float *tpwgts, int *options, int *edgecut, idxtype *part)
+{
+  METIS_WPartGraphRecursive(nvtxs, xadj, adjncy, vwgt, adjwgt, wgtflag, numflag, nparts, tpwgts, options, edgecut, part);
+}
+void metis_wpartgraphrecursive__(int *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *adjwgt, int *wgtflag, int *numflag, int *nparts, float *tpwgts, int *options, int *edgecut, idxtype *part)
+{
+  METIS_WPartGraphRecursive(nvtxs, xadj, adjncy, vwgt, adjwgt, wgtflag, numflag, nparts, tpwgts, options, edgecut, part);
+}
+
+
+
+void METIS_PARTGRAPHKWAY(int *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *adjwgt, int *wgtflag, int *numflag, int *nparts, int *options, int *edgecut, idxtype *part)
+{
+  METIS_PartGraphKway(nvtxs, xadj, adjncy, vwgt, adjwgt, wgtflag, numflag, nparts, options, edgecut, part);
+}
+void metis_partgraphkway(int *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *adjwgt, int *wgtflag, int *numflag, int *nparts, int *options, int *edgecut, idxtype *part)
+{
+  METIS_PartGraphKway(nvtxs, xadj, adjncy, vwgt, adjwgt, wgtflag, numflag, nparts, options, edgecut, part);
+}
+void metis_partgraphkway_(int *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *adjwgt, int *wgtflag, int *numflag, int *nparts, int *options, int *edgecut, idxtype *part)
+{
+  METIS_PartGraphKway(nvtxs, xadj, adjncy, vwgt, adjwgt, wgtflag, numflag, nparts, options, edgecut, part);
+}
+void metis_partgraphkway__(int *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *adjwgt, int *wgtflag, int *numflag, int *nparts, int *options, int *edgecut, idxtype *part)
+{
+  METIS_PartGraphKway(nvtxs, xadj, adjncy, vwgt, adjwgt, wgtflag, numflag, nparts, options, edgecut, part);
+}
+
+
+
+void METIS_WPARTGRAPHKWAY(int *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *adjwgt, int *wgtflag, int *numflag, int *nparts, float *tpwgts, int *options, int *edgecut, idxtype *part)
+{
+  METIS_WPartGraphKway(nvtxs, xadj, adjncy, vwgt, adjwgt, wgtflag, numflag, nparts, tpwgts, options, edgecut, part);
+}
+void metis_wpartgraphkway(int *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *adjwgt, int *wgtflag, int *numflag, int *nparts, float *tpwgts, int *options, int *edgecut, idxtype *part)
+{
+  METIS_WPartGraphKway(nvtxs, xadj, adjncy, vwgt, adjwgt, wgtflag, numflag, nparts, tpwgts, options, edgecut, part);
+}
+void metis_wpartgraphkway_(int *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *adjwgt, int *wgtflag, int *numflag, int *nparts, float *tpwgts, int *options, int *edgecut, idxtype *part)
+{
+  METIS_WPartGraphKway(nvtxs, xadj, adjncy, vwgt, adjwgt, wgtflag, numflag, nparts, tpwgts, options, edgecut, part);
+}
+void metis_wpartgraphkway__(int *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *adjwgt, int *wgtflag, int *numflag, int *nparts, float *tpwgts, int *options, int *edgecut, idxtype *part)
+{
+  METIS_WPartGraphKway(nvtxs, xadj, adjncy, vwgt, adjwgt, wgtflag, numflag, nparts, tpwgts, options, edgecut, part);
+}
+
+
+
+void METIS_EDGEND(int *nvtxs, idxtype *xadj, idxtype *adjncy, int *numflag, int *options, idxtype *perm, idxtype *iperm)
+{
+  METIS_EdgeND(nvtxs, xadj, adjncy, numflag, options, perm, iperm);
+}
+void metis_edgend(int *nvtxs, idxtype *xadj, idxtype *adjncy, int *numflag, int *options, idxtype *perm, idxtype *iperm)
+{
+  METIS_EdgeND(nvtxs, xadj, adjncy, numflag, options, perm, iperm);
+}
+void metis_edgend_(int *nvtxs, idxtype *xadj, idxtype *adjncy, int *numflag, int *options, idxtype *perm, idxtype *iperm)
+{
+  METIS_EdgeND(nvtxs, xadj, adjncy, numflag, options, perm, iperm);
+}
+void metis_edgend__(int *nvtxs, idxtype *xadj, idxtype *adjncy, int *numflag, int *options, idxtype *perm, idxtype *iperm)
+{
+  METIS_EdgeND(nvtxs, xadj, adjncy, numflag, options, perm, iperm);
+}
+
+
+
+void METIS_NODEND(int *nvtxs, idxtype *xadj, idxtype *adjncy, int *numflag, int *options, idxtype *perm, idxtype *iperm)
+{
+  METIS_NodeND(nvtxs, xadj, adjncy, numflag, options, perm, iperm);
+}
+void metis_nodend(int *nvtxs, idxtype *xadj, idxtype *adjncy, int *numflag, int *options, idxtype *perm, idxtype *iperm)
+{
+  METIS_NodeND(nvtxs, xadj, adjncy, numflag, options, perm, iperm);
+}
+void metis_nodend_(int *nvtxs, idxtype *xadj, idxtype *adjncy, int *numflag, int *options, idxtype *perm, idxtype *iperm)
+{
+  METIS_NodeND(nvtxs, xadj, adjncy, numflag, options, perm, iperm);
+}
+void metis_nodend__(int *nvtxs, idxtype *xadj, idxtype *adjncy, int *numflag, int *options, idxtype *perm, idxtype *iperm)
+{
+  METIS_NodeND(nvtxs, xadj, adjncy, numflag, options, perm, iperm);
+}
+
+
+
+void METIS_NODEWND(int *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, int *numflag, int *options, idxtype *perm, idxtype *iperm)
+{
+  METIS_NodeWND(nvtxs, xadj, adjncy, vwgt, numflag, options, perm, iperm);
+}
+void metis_nodewnd(int *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, int *numflag, int *options, idxtype *perm, idxtype *iperm)
+{
+  METIS_NodeWND(nvtxs, xadj, adjncy, vwgt, numflag, options, perm, iperm);
+}
+void metis_nodewnd_(int *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, int *numflag, int *options, idxtype *perm, idxtype *iperm)
+{
+  METIS_NodeWND(nvtxs, xadj, adjncy, vwgt, numflag, options, perm, iperm);
+}
+void metis_nodewnd__(int *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, int *numflag, int *options, idxtype *perm, idxtype *iperm)
+{
+  METIS_NodeWND(nvtxs, xadj, adjncy, vwgt, numflag, options, perm, iperm);
+}
+
+
+
+void METIS_PARTMESHNODAL(int *ne, int *nn, idxtype *elmnts, int *etype, int *numflag, int *nparts, int *edgecut, idxtype *epart, idxtype *npart)
+{
+  METIS_PartMeshNodal(ne, nn, elmnts, etype, numflag, nparts, edgecut, epart, npart);
+}
+void metis_partmeshnodal(int *ne, int *nn, idxtype *elmnts, int *etype, int *numflag, int *nparts, int *edgecut, idxtype *epart, idxtype *npart)
+{
+  METIS_PartMeshNodal(ne, nn, elmnts, etype, numflag, nparts, edgecut, epart, npart);
+}
+void metis_partmeshnodal_(int *ne, int *nn, idxtype *elmnts, int *etype, int *numflag, int *nparts, int *edgecut, idxtype *epart, idxtype *npart)
+{
+  METIS_PartMeshNodal(ne, nn, elmnts, etype, numflag, nparts, edgecut, epart, npart);
+}
+void metis_partmeshnodal__(int *ne, int *nn, idxtype *elmnts, int *etype, int *numflag, int *nparts, int *edgecut, idxtype *epart, idxtype *npart)
+{
+  METIS_PartMeshNodal(ne, nn, elmnts, etype, numflag, nparts, edgecut, epart, npart);
+}
+
+
+void METIS_PARTMESHDUAL(int *ne, int *nn, idxtype *elmnts, int *etype, int *numflag, int *nparts, int *edgecut, idxtype *epart, idxtype *npart)
+{
+  METIS_PartMeshDual(ne, nn, elmnts, etype, numflag, nparts, edgecut, epart, npart);
+}
+void metis_partmeshdual(int *ne, int *nn, idxtype *elmnts, int *etype, int *numflag, int *nparts, int *edgecut, idxtype *epart, idxtype *npart)
+{
+  METIS_PartMeshDual(ne, nn, elmnts, etype, numflag, nparts, edgecut, epart, npart);
+}
+void metis_partmeshdual_(int *ne, int *nn, idxtype *elmnts, int *etype, int *numflag, int *nparts, int *edgecut, idxtype *epart, idxtype *npart)
+{
+  METIS_PartMeshDual(ne, nn, elmnts, etype, numflag, nparts, edgecut, epart, npart);
+}
+void metis_partmeshdual__(int *ne, int *nn, idxtype *elmnts, int *etype, int *numflag, int *nparts, int *edgecut, idxtype *epart, idxtype *npart)
+{
+  METIS_PartMeshDual(ne, nn, elmnts, etype, numflag, nparts, edgecut, epart, npart);
+}
+
+
+void METIS_MESHTONODAL(int *ne, int *nn, idxtype *elmnts, int *etype, int *numflag, idxtype *dxadj, idxtype *dadjncy)
+{
+  METIS_MeshToNodal(ne, nn, elmnts, etype, numflag, dxadj, dadjncy);
+}
+void metis_meshtonodal(int *ne, int *nn, idxtype *elmnts, int *etype, int *numflag, idxtype *dxadj, idxtype *dadjncy)
+{
+  METIS_MeshToNodal(ne, nn, elmnts, etype, numflag, dxadj, dadjncy);
+}
+void metis_meshtonodal_(int *ne, int *nn, idxtype *elmnts, int *etype, int *numflag, idxtype *dxadj, idxtype *dadjncy)
+{
+  METIS_MeshToNodal(ne, nn, elmnts, etype, numflag, dxadj, dadjncy);
+}
+void metis_meshtonodal__(int *ne, int *nn, idxtype *elmnts, int *etype, int *numflag, idxtype *dxadj, idxtype *dadjncy)
+{
+  METIS_MeshToNodal(ne, nn, elmnts, etype, numflag, dxadj, dadjncy);
+}
+
+
+void METIS_MESHTODUAL(int *ne, int *nn, idxtype *elmnts, int *etype, int *numflag, idxtype *dxadj, idxtype *dadjncy)
+{
+  METIS_MeshToDual(ne, nn, elmnts, etype, numflag, dxadj, dadjncy);
+}
+void metis_meshtodual(int *ne, int *nn, idxtype *elmnts, int *etype, int *numflag, idxtype *dxadj, idxtype *dadjncy)
+{
+  METIS_MeshToDual(ne, nn, elmnts, etype, numflag, dxadj, dadjncy);
+}
+void metis_meshtodual_(int *ne, int *nn, idxtype *elmnts, int *etype, int *numflag, idxtype *dxadj, idxtype *dadjncy)
+{
+  METIS_MeshToDual(ne, nn, elmnts, etype, numflag, dxadj, dadjncy);
+}
+void metis_meshtodual__(int *ne, int *nn, idxtype *elmnts, int *etype, int *numflag, idxtype *dxadj, idxtype *dadjncy)
+{
+  METIS_MeshToDual(ne, nn, elmnts, etype, numflag, dxadj, dadjncy);
+}
+
+
+void METIS_ESTIMATEMEMORY(int *nvtxs, idxtype *xadj, idxtype *adjncy, int *numflag, int *optype, int *nbytes)
+{
+  METIS_EstimateMemory(nvtxs, xadj, adjncy, numflag, optype, nbytes);
+}
+void metis_estimatememory(int *nvtxs, idxtype *xadj, idxtype *adjncy, int *numflag, int *optype, int *nbytes)
+{
+  METIS_EstimateMemory(nvtxs, xadj, adjncy, numflag, optype, nbytes);
+}
+void metis_estimatememory_(int *nvtxs, idxtype *xadj, idxtype *adjncy, int *numflag, int *optype, int *nbytes)
+{
+  METIS_EstimateMemory(nvtxs, xadj, adjncy, numflag, optype, nbytes);
+}
+void metis_estimatememory__(int *nvtxs, idxtype *xadj, idxtype *adjncy, int *numflag, int *optype, int *nbytes)
+{
+  METIS_EstimateMemory(nvtxs, xadj, adjncy, numflag, optype, nbytes);
+}
+
+
+
+void METIS_MCPARTGRAPHRECURSIVE(int *nvtxs, int *ncon, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *adjwgt, int *wgtflag, int *numflag, int *nparts, int *options, int *edgecut, idxtype *part)
+{
+  METIS_mCPartGraphRecursive(nvtxs, ncon, xadj, adjncy, vwgt, adjwgt, wgtflag, numflag, nparts, options, edgecut, part);
+}
+void metis_mcpartgraphrecursive(int *nvtxs, int *ncon, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *adjwgt, int *wgtflag, int *numflag, int *nparts, int *options, int *edgecut, idxtype *part)
+{
+  METIS_mCPartGraphRecursive(nvtxs, ncon, xadj, adjncy, vwgt, adjwgt, wgtflag, numflag, nparts, options, edgecut, part);
+}
+void metis_mcpartgraphrecursive_(int *nvtxs, int *ncon, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *adjwgt, int *wgtflag, int *numflag, int *nparts, int *options, int *edgecut, idxtype *part)
+{
+  METIS_mCPartGraphRecursive(nvtxs, ncon, xadj, adjncy, vwgt, adjwgt, wgtflag, numflag, nparts, options, edgecut, part);
+}
+void metis_mcpartgraphrecursive__(int *nvtxs, int *ncon, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *adjwgt, int *wgtflag, int *numflag, int *nparts, int *options, int *edgecut, idxtype *part)
+{
+  METIS_mCPartGraphRecursive(nvtxs, ncon, xadj, adjncy, vwgt, adjwgt, wgtflag, numflag, nparts, options, edgecut, part);
+}
+
+
+void METIS_MCPARTGRAPHKWAY(int *nvtxs, int *ncon, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *adjwgt, int *wgtflag, int *numflag, int *nparts, float *rubvec, int *options, int *edgecut, idxtype *part)
+{
+  METIS_mCPartGraphKway(nvtxs, ncon, xadj, adjncy, vwgt, adjwgt, wgtflag, numflag, nparts, rubvec, options, edgecut, part);
+}
+void metis_mcpartgraphkway(int *nvtxs, int *ncon, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *adjwgt, int *wgtflag, int *numflag, int *nparts, float *rubvec, int *options, int *edgecut, idxtype *part)
+{
+  METIS_mCPartGraphKway(nvtxs, ncon, xadj, adjncy, vwgt, adjwgt, wgtflag, numflag, nparts, rubvec, options, edgecut, part);
+}
+void metis_mcpartgraphkway_(int *nvtxs, int *ncon, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *adjwgt, int *wgtflag, int *numflag, int *nparts, float *rubvec, int *options, int *edgecut, idxtype *part)
+{
+  METIS_mCPartGraphKway(nvtxs, ncon, xadj, adjncy, vwgt, adjwgt, wgtflag, numflag, nparts, rubvec, options, edgecut, part);
+}
+void metis_mcpartgraphkway__(int *nvtxs, int *ncon, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *adjwgt, int *wgtflag, int *numflag, int *nparts, float *rubvec, int *options, int *edgecut, idxtype *part)
+{
+  METIS_mCPartGraphKway(nvtxs, ncon, xadj, adjncy, vwgt, adjwgt, wgtflag, numflag, nparts, rubvec, options, edgecut, part);
+}
+
+
+void METIS_PARTGRAPHVKWAY(int *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *vsize, int *wgtflag, int *numflag, int *nparts, int *options, int *volume, idxtype *part)
+{
+  METIS_PartGraphVKway(nvtxs, xadj, adjncy, vwgt, vsize, wgtflag, numflag, nparts, options, volume, part);
+}
+void metis_partgraphvkway(int *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *vsize, int *wgtflag, int *numflag, int *nparts, int *options, int *volume, idxtype *part)
+{
+  METIS_PartGraphVKway(nvtxs, xadj, adjncy, vwgt, vsize, wgtflag, numflag, nparts, options, volume, part);
+}
+void metis_partgraphvkway_(int *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *vsize, int *wgtflag, int *numflag, int *nparts, int *options, int *volume, idxtype *part)
+{
+  METIS_PartGraphVKway(nvtxs, xadj, adjncy, vwgt, vsize, wgtflag, numflag, nparts, options, volume, part);
+}
+void metis_partgraphvkway__(int *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *vsize, int *wgtflag, int *numflag, int *nparts, int *options, int *volume, idxtype *part)
+{
+  METIS_PartGraphVKway(nvtxs, xadj, adjncy, vwgt, vsize, wgtflag, numflag, nparts, options, volume, part);
+}
+
+void METIS_WPARTGRAPHVKWAY(int *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *vsize, int *wgtflag, int *numflag, int *nparts, float *tpwgts, int *options, int *volume, idxtype *part)
+{
+  METIS_WPartGraphVKway(nvtxs, xadj, adjncy, vwgt, vsize, wgtflag, numflag, nparts, tpwgts, options, volume, part);
+}
+void metis_wpartgraphvkway(int *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *vsize, int *wgtflag, int *numflag, int *nparts, float *tpwgts, int *options, int *volume, idxtype *part)
+{
+  METIS_WPartGraphVKway(nvtxs, xadj, adjncy, vwgt, vsize, wgtflag, numflag, nparts, tpwgts, options, volume, part);
+}
+void metis_wpartgraphvkway_(int *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *vsize, int *wgtflag, int *numflag, int *nparts, float *tpwgts, int *options, int *volume, idxtype *part)
+{
+  METIS_WPartGraphVKway(nvtxs, xadj, adjncy, vwgt, vsize, wgtflag, numflag, nparts, tpwgts, options, volume, part);
+}
+void metis_wpartgraphvkway__(int *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *vsize, int *wgtflag, int *numflag, int *nparts, float *tpwgts, int *options, int *volume, idxtype *part)
+{
+  METIS_WPartGraphVKway(nvtxs, xadj, adjncy, vwgt, vsize, wgtflag, numflag, nparts, tpwgts, options, volume, part);
+}
+
+
+
Index: /inundation/pymetis/metis-4.0/Lib/graph.c
===================================================================
--- /inundation/pymetis/metis-4.0/Lib/graph.c	(revision 2051)
+++ /inundation/pymetis/metis-4.0/Lib/graph.c	(revision 2051)
@@ -0,0 +1,616 @@
+/*
+ * Copyright 1997, Regents of the University of Minnesota
+ *
+ * graph.c
+ *
+ * This file contains functions that deal with setting up the graphs
+ * for METIS.
+ *
+ * Started 7/25/97
+ * George
+ *
+ * $Id: graph.c,v 1.1 1998/11/27 17:59:15 karypis Exp $
+ *
+ */
+
+#include <metis.h>
+
+/*************************************************************************
+* This function sets up the graph from the user input
+**************************************************************************/
+void SetUpGraph(GraphType *graph, int OpType, int nvtxs, int ncon,
+       idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *adjwgt, int wgtflag)
+{
+  int i, j, k, sum, gsize;
+  float *nvwgt;
+  idxtype tvwgt[MAXNCON];
+
+  if (OpType == OP_KMETIS && ncon == 1 && (wgtflag&2) == 0 && (wgtflag&1) == 0) {
+    SetUpGraphKway(graph, nvtxs, xadj, adjncy);
+    return;
+  }
+
+  InitGraph(graph);
+
+  graph->nvtxs = nvtxs;
+  graph->nedges = xadj[nvtxs];
+  graph->ncon = ncon;
+  graph->xadj = xadj;
+  graph->adjncy = adjncy;
+
+  if (ncon == 1) { /* We are in the non mC mode */
+    gsize = 0; 
+    if ((wgtflag&2) == 0)
+      gsize += nvtxs;
+    if ((wgtflag&1) == 0)
+      gsize += graph->nedges;
+
+    gsize += 2*nvtxs;
+
+    graph->gdata = idxmalloc(gsize, "SetUpGraph: gdata");
+
+    /* Create the vertex/edge weight vectors if they are not supplied */
+    gsize = 0;
+    if ((wgtflag&2) == 0) {
+      vwgt = graph->vwgt = idxset(nvtxs, 1, graph->gdata);
+      gsize += nvtxs;
+    }
+    else
+      graph->vwgt = vwgt;
+
+    if ((wgtflag&1) == 0) {
+      adjwgt = graph->adjwgt = idxset(graph->nedges, 1, graph->gdata+gsize);
+      gsize += graph->nedges;
+    }
+    else
+      graph->adjwgt = adjwgt;
+
+
+    /* Compute the initial values of the adjwgtsum */
+    graph->adjwgtsum = graph->gdata + gsize;
+    gsize += nvtxs;
+
+    for (i=0; i<nvtxs; i++) {
+      sum = 0;
+      for (j=xadj[i]; j<xadj[i+1]; j++)
+        sum += adjwgt[j];
+      graph->adjwgtsum[i] = sum;
+    }
+
+    graph->cmap = graph->gdata + gsize;
+    gsize += nvtxs;
+
+  }
+  else {  /* Set up the graph in MOC mode */
+    gsize = 0; 
+    if ((wgtflag&1) == 0)
+      gsize += graph->nedges;
+
+    gsize += 2*nvtxs;
+
+    graph->gdata = idxmalloc(gsize, "SetUpGraph: gdata");
+    gsize = 0;
+
+    for (i=0; i<ncon; i++) 
+      tvwgt[i] = idxsum_strd(nvtxs, vwgt+i, ncon);
+    
+    nvwgt = graph->nvwgt = fmalloc(ncon*nvtxs, "SetUpGraph: nvwgt");
+
+    for (i=0; i<nvtxs; i++) {
+      for (j=0; j<ncon; j++) 
+        nvwgt[i*ncon+j] = (1.0*vwgt[i*ncon+j])/(1.0*tvwgt[j]);
+    }
+
+
+    /* Create the edge weight vectors if they are not supplied */
+    if ((wgtflag&1) == 0) {
+      adjwgt = graph->adjwgt = idxset(graph->nedges, 1, graph->gdata+gsize);
+      gsize += graph->nedges;
+    }
+    else
+      graph->adjwgt = adjwgt;
+
+    /* Compute the initial values of the adjwgtsum */
+    graph->adjwgtsum = graph->gdata + gsize;
+    gsize += nvtxs;
+
+    for (i=0; i<nvtxs; i++) {
+      sum = 0;
+      for (j=xadj[i]; j<xadj[i+1]; j++)
+        sum += adjwgt[j];
+      graph->adjwgtsum[i] = sum;
+    }
+
+    graph->cmap = graph->gdata + gsize;
+    gsize += nvtxs;
+
+  }
+
+  if (OpType != OP_KMETIS && OpType != OP_KVMETIS) {
+    graph->label = idxmalloc(nvtxs, "SetUpGraph: label");
+
+    for (i=0; i<nvtxs; i++)
+      graph->label[i] = i;
+  }
+
+}
+
+
+/*************************************************************************
+* This function sets up the graph from the user input
+**************************************************************************/
+void SetUpGraphKway(GraphType *graph, int nvtxs, idxtype *xadj, idxtype *adjncy)
+{
+  int i;
+
+  InitGraph(graph);
+
+  graph->nvtxs = nvtxs;
+  graph->nedges = xadj[nvtxs];
+  graph->ncon = 1;
+  graph->xadj = xadj;
+  graph->vwgt = NULL;
+  graph->adjncy = adjncy;
+  graph->adjwgt = NULL;
+
+  graph->gdata = idxmalloc(2*nvtxs, "SetUpGraph: gdata");
+  graph->adjwgtsum = graph->gdata;
+  graph->cmap = graph->gdata + nvtxs;
+
+  /* Compute the initial values of the adjwgtsum */
+  for (i=0; i<nvtxs; i++) 
+    graph->adjwgtsum[i] = xadj[i+1]-xadj[i];
+
+}
+
+
+
+/*************************************************************************
+* This function sets up the graph from the user input
+**************************************************************************/
+void SetUpGraph2(GraphType *graph, int nvtxs, int ncon, idxtype *xadj, 
+       idxtype *adjncy, float *nvwgt, idxtype *adjwgt)
+{
+  int i, j, sum;
+
+  InitGraph(graph);
+
+  graph->nvtxs = nvtxs;
+  graph->nedges = xadj[nvtxs];
+  graph->ncon = ncon;
+  graph->xadj = xadj;
+  graph->adjncy = adjncy;
+  graph->adjwgt = adjwgt;
+
+  graph->nvwgt = fmalloc(nvtxs*ncon, "SetUpGraph2: graph->nvwgt");
+  scopy(nvtxs*ncon, nvwgt, graph->nvwgt);
+
+  graph->gdata = idxmalloc(2*nvtxs, "SetUpGraph: gdata");
+
+  /* Compute the initial values of the adjwgtsum */
+  graph->adjwgtsum = graph->gdata;
+  for (i=0; i<nvtxs; i++) {
+    sum = 0;
+    for (j=xadj[i]; j<xadj[i+1]; j++)
+      sum += adjwgt[j];
+    graph->adjwgtsum[i] = sum;
+  }
+
+  graph->cmap = graph->gdata+nvtxs;
+
+  graph->label = idxmalloc(nvtxs, "SetUpGraph: label");
+  for (i=0; i<nvtxs; i++)
+    graph->label[i] = i;
+
+}
+
+
+/*************************************************************************
+* This function sets up the graph from the user input
+**************************************************************************/
+void VolSetUpGraph(GraphType *graph, int OpType, int nvtxs, int ncon, idxtype *xadj, 
+                   idxtype *adjncy, idxtype *vwgt, idxtype *vsize, int wgtflag)
+{
+  int i, j, k, sum, gsize;
+  idxtype *adjwgt;
+  float *nvwgt;
+  idxtype tvwgt[MAXNCON];
+
+  InitGraph(graph);
+
+  graph->nvtxs = nvtxs;
+  graph->nedges = xadj[nvtxs];
+  graph->ncon = ncon;
+  graph->xadj = xadj;
+  graph->adjncy = adjncy;
+
+  if (ncon == 1) { /* We are in the non mC mode */
+    gsize = graph->nedges;  /* This is for the edge weights */
+    if ((wgtflag&2) == 0)
+      gsize += nvtxs; /* vwgts */
+    if ((wgtflag&1) == 0)
+      gsize += nvtxs; /* vsize */
+
+    gsize += 2*nvtxs;
+
+    graph->gdata = idxmalloc(gsize, "SetUpGraph: gdata");
+
+    /* Create the vertex/edge weight vectors if they are not supplied */
+    gsize = 0;
+    if ((wgtflag&2) == 0) {
+      vwgt = graph->vwgt = idxset(nvtxs, 1, graph->gdata);
+      gsize += nvtxs;
+    }
+    else
+      graph->vwgt = vwgt;
+
+    if ((wgtflag&1) == 0) {
+      vsize = graph->vsize = idxset(nvtxs, 1, graph->gdata);
+      gsize += nvtxs;
+    }
+    else
+      graph->vsize = vsize;
+
+    /* Allocate memory for edge weights and initialize them to the sum of the vsize */
+    adjwgt = graph->adjwgt = graph->gdata+gsize;
+    gsize += graph->nedges;
+
+    for (i=0; i<nvtxs; i++) {
+      for (j=xadj[i]; j<xadj[i+1]; j++)
+        adjwgt[j] = 1+vsize[i]+vsize[adjncy[j]];
+    }
+
+
+    /* Compute the initial values of the adjwgtsum */
+    graph->adjwgtsum = graph->gdata + gsize;
+    gsize += nvtxs;
+
+    for (i=0; i<nvtxs; i++) {
+      sum = 0;
+      for (j=xadj[i]; j<xadj[i+1]; j++)
+        sum += adjwgt[j];
+      graph->adjwgtsum[i] = sum;
+    }
+
+    graph->cmap = graph->gdata + gsize;
+    gsize += nvtxs;
+
+  }
+  else {  /* Set up the graph in MOC mode */
+    gsize = graph->nedges; 
+    if ((wgtflag&1) == 0)
+      gsize += nvtxs;
+
+    gsize += 2*nvtxs;
+
+    graph->gdata = idxmalloc(gsize, "SetUpGraph: gdata");
+    gsize = 0;
+
+    /* Create the normalized vertex weights along each constrain */
+    if ((wgtflag&2) == 0) 
+      vwgt = idxsmalloc(nvtxs, 1, "SetUpGraph: vwgt");
+
+    for (i=0; i<ncon; i++) 
+      tvwgt[i] = idxsum_strd(nvtxs, vwgt+i, ncon);
+    
+    nvwgt = graph->nvwgt = fmalloc(ncon*nvtxs, "SetUpGraph: nvwgt");
+
+    for (i=0; i<nvtxs; i++) {
+      for (j=0; j<ncon; j++) 
+        nvwgt[i*ncon+j] = (1.0*vwgt[i*ncon+j])/(1.0*tvwgt[j]);
+    }
+    if ((wgtflag&2) == 0) 
+      free(vwgt);
+
+
+    /* Create the vsize vector if it is not supplied */
+    if ((wgtflag&1) == 0) {
+      vsize = graph->vsize = idxset(nvtxs, 1, graph->gdata);
+      gsize += nvtxs;
+    }
+    else
+      graph->vsize = vsize;
+
+    /* Allocate memory for edge weights and initialize them to the sum of the vsize */
+    adjwgt = graph->adjwgt = graph->gdata+gsize;
+    gsize += graph->nedges;
+
+    for (i=0; i<nvtxs; i++) {
+      for (j=xadj[i]; j<xadj[i+1]; j++)
+        adjwgt[j] = 1+vsize[i]+vsize[adjncy[j]];
+    }
+
+    /* Compute the initial values of the adjwgtsum */
+    graph->adjwgtsum = graph->gdata + gsize;
+    gsize += nvtxs;
+
+    for (i=0; i<nvtxs; i++) {
+      sum = 0;
+      for (j=xadj[i]; j<xadj[i+1]; j++)
+        sum += adjwgt[j];
+      graph->adjwgtsum[i] = sum;
+    }
+
+    graph->cmap = graph->gdata + gsize;
+    gsize += nvtxs;
+
+  }
+
+  if (OpType != OP_KVMETIS) {
+    graph->label = idxmalloc(nvtxs, "SetUpGraph: label");
+
+    for (i=0; i<nvtxs; i++)
+      graph->label[i] = i;
+  }
+
+}
+
+
+/*************************************************************************
+* This function randomly permutes the adjacency lists of a graph
+**************************************************************************/
+void RandomizeGraph(GraphType *graph)
+{
+  int i, j, k, l, tmp, nvtxs;
+  idxtype *xadj, *adjncy, *adjwgt;
+
+  nvtxs = graph->nvtxs;
+  xadj = graph->xadj;
+  adjncy = graph->adjncy;
+  adjwgt = graph->adjwgt;
+
+  for (i=0; i<nvtxs; i++) {
+    l = xadj[i+1]-xadj[i];
+    for (j=xadj[i]; j<xadj[i+1]; j++) {
+      k = xadj[i] + RandomInRange(l);
+      SWAP(adjncy[j], adjncy[k], tmp);
+      SWAP(adjwgt[j], adjwgt[k], tmp);
+    }
+  }
+}
+
+
+/*************************************************************************
+* This function checks whether or not partition pid is contigous
+**************************************************************************/
+int IsConnectedSubdomain(CtrlType *ctrl, GraphType *graph, int pid, int report)
+{
+  int i, j, k, nvtxs, first, last, nleft, ncmps, wgt;
+  idxtype *xadj, *adjncy, *where, *touched, *queue;
+  idxtype *cptr;
+
+  nvtxs = graph->nvtxs;
+  xadj = graph->xadj;
+  adjncy = graph->adjncy;
+  where = graph->where;
+
+  touched = idxsmalloc(nvtxs, 0, "IsConnected: touched");
+  queue = idxmalloc(nvtxs, "IsConnected: queue");
+  cptr = idxmalloc(nvtxs, "IsConnected: cptr");
+
+  nleft = 0;
+  for (i=0; i<nvtxs; i++) {
+    if (where[i] == pid) 
+      nleft++;
+  }
+
+  for (i=0; i<nvtxs; i++) {
+    if (where[i] == pid) 
+      break;
+  }
+
+  touched[i] = 1;
+  queue[0] = i;
+  first = 0; last = 1;
+
+  cptr[0] = 0;  /* This actually points to queue */
+  ncmps = 0;
+  while (first != nleft) {
+    if (first == last) { /* Find another starting vertex */
+      cptr[++ncmps] = first;
+      for (i=0; i<nvtxs; i++) {
+        if (where[i] == pid && !touched[i])
+          break;
+      }
+      queue[last++] = i;
+      touched[i] = 1;
+    }
+
+    i = queue[first++];
+    for (j=xadj[i]; j<xadj[i+1]; j++) {
+      k = adjncy[j];
+      if (where[k] == pid && !touched[k]) {
+        queue[last++] = k;
+        touched[k] = 1;
+      }
+    }
+  }
+  cptr[++ncmps] = first;
+
+  if (ncmps > 1 && report) {
+    printf("The graph has %d connected components in partition %d:\t", ncmps, pid);
+    for (i=0; i<ncmps; i++) {
+      wgt = 0;
+      for (j=cptr[i]; j<cptr[i+1]; j++)
+        wgt += graph->vwgt[queue[j]];
+      printf("[%5d %5d] ", cptr[i+1]-cptr[i], wgt);
+      /*
+      if (cptr[i+1]-cptr[i] == 1)
+        printf("[%d %d] ", queue[cptr[i]], xadj[queue[cptr[i]]+1]-xadj[queue[cptr[i]]]);
+      */
+    }
+    printf("\n");
+  }
+
+  GKfree(&touched, &queue, &cptr, LTERM);
+
+  return (ncmps == 1 ? 1 : 0);
+}
+
+
+/*************************************************************************
+* This function checks whether a graph is contigous or not
+**************************************************************************/
+int IsConnected(CtrlType *ctrl, GraphType *graph, int report)
+{
+  int i, j, k, nvtxs, first, last;
+  idxtype *xadj, *adjncy, *touched, *queue;
+
+  nvtxs = graph->nvtxs;
+  xadj = graph->xadj;
+  adjncy = graph->adjncy;
+
+  touched = idxsmalloc(nvtxs, 0, "IsConnected: touched");
+  queue = idxmalloc(nvtxs, "IsConnected: queue");
+
+  touched[0] = 1;
+  queue[0] = 0;
+  first = 0; last = 1;
+
+  while (first < last) {
+    i = queue[first++];
+    for (j=xadj[i]; j<xadj[i+1]; j++) {
+      k = adjncy[j];
+      if (!touched[k]) {
+        queue[last++] = k;
+        touched[k] = 1;
+      }
+    }
+  }
+
+  if (first != nvtxs && report)
+    printf("The graph is not connected. It has %d disconnected vertices!\n", nvtxs-first);
+
+  return (first == nvtxs ? 1 : 0);
+}
+
+
+/*************************************************************************
+* This function checks whether or not partition pid is contigous
+**************************************************************************/
+int IsConnected2(GraphType *graph, int report)
+{
+  int i, j, k, nvtxs, first, last, nleft, ncmps, wgt;
+  idxtype *xadj, *adjncy, *where, *touched, *queue;
+  idxtype *cptr;
+
+  nvtxs = graph->nvtxs;
+  xadj = graph->xadj;
+  adjncy = graph->adjncy;
+  where = graph->where;
+
+  touched = idxsmalloc(nvtxs, 0, "IsConnected: touched");
+  queue = idxmalloc(nvtxs, "IsConnected: queue");
+  cptr = idxmalloc(nvtxs, "IsConnected: cptr");
+
+  nleft = nvtxs;
+  touched[0] = 1;
+  queue[0] = 0;
+  first = 0; last = 1;
+
+  cptr[0] = 0;  /* This actually points to queue */
+  ncmps = 0;
+  while (first != nleft) {
+    if (first == last) { /* Find another starting vertex */
+      cptr[++ncmps] = first;
+      for (i=0; i<nvtxs; i++) {
+        if (!touched[i])
+          break;
+      }
+      queue[last++] = i;
+      touched[i] = 1;
+    }
+
+    i = queue[first++];
+    for (j=xadj[i]; j<xadj[i+1]; j++) {
+      k = adjncy[j];
+      if (!touched[k]) {
+        queue[last++] = k;
+        touched[k] = 1;
+      }
+    }
+  }
+  cptr[++ncmps] = first;
+
+  if (ncmps > 1 && report) {
+    printf("%d connected components:\t", ncmps);
+    for (i=0; i<ncmps; i++) {
+      if (cptr[i+1]-cptr[i] > 200)
+        printf("[%5d] ", cptr[i+1]-cptr[i]);
+    }
+    printf("\n");
+  }
+
+  GKfree(&touched, &queue, &cptr, LTERM);
+
+  return (ncmps == 1 ? 1 : 0);
+}
+
+
+/*************************************************************************
+* This function returns the number of connected components in cptr,cind
+* The separator of the graph is used to split it and then find its components.
+**************************************************************************/
+int FindComponents(CtrlType *ctrl, GraphType *graph, idxtype *cptr, idxtype *cind)
+{
+  int i, j, k, nvtxs, first, last, nleft, ncmps, wgt;
+  idxtype *xadj, *adjncy, *where, *touched, *queue;
+
+  nvtxs = graph->nvtxs;
+  xadj = graph->xadj;
+  adjncy = graph->adjncy;
+  where = graph->where;
+
+  touched = idxsmalloc(nvtxs, 0, "IsConnected: queue");
+
+  for (i=0; i<graph->nbnd; i++)
+    touched[graph->bndind[i]] = 1;
+
+  queue = cind;
+
+  nleft = 0;
+  for (i=0; i<nvtxs; i++) {
+    if (where[i] != 2) 
+      nleft++;
+  }
+
+  for (i=0; i<nvtxs; i++) {
+    if (where[i] != 2)
+      break;
+  }
+
+  touched[i] = 1;
+  queue[0] = i;
+  first = 0; last = 1;
+
+  cptr[0] = 0;  /* This actually points to queue */
+  ncmps = 0;
+  while (first != nleft) {
+    if (first == last) { /* Find another starting vertex */
+      cptr[++ncmps] = first;
+      for (i=0; i<nvtxs; i++) {
+        if (!touched[i])
+          break;
+      }
+      queue[last++] = i;
+      touched[i] = 1;
+    }
+
+    i = queue[first++];
+    for (j=xadj[i]; j<xadj[i+1]; j++) {
+      k = adjncy[j];
+      if (!touched[k]) {
+        queue[last++] = k;
+        touched[k] = 1;
+      }
+    }
+  }
+  cptr[++ncmps] = first;
+
+  free(touched);
+
+  return ncmps;
+}
+
+
+
Index: /inundation/pymetis/metis-4.0/Lib/initpart.c
===================================================================
--- /inundation/pymetis/metis-4.0/Lib/initpart.c	(revision 2051)
+++ /inundation/pymetis/metis-4.0/Lib/initpart.c	(revision 2051)
@@ -0,0 +1,422 @@
+/*
+ * Copyright 1997, Regents of the University of Minnesota
+ *
+ * initpart.c
+ *
+ * This file contains code that performs the initial partition of the
+ * coarsest graph
+ *
+ * Started 7/23/97
+ * George
+ *
+ * $Id: initpart.c,v 1.1 1998/11/27 17:59:15 karypis Exp $
+ *
+ */
+
+#include <metis.h>
+
+/*************************************************************************
+* This function computes the initial bisection of the coarsest graph
+**************************************************************************/
+void Init2WayPartition(CtrlType *ctrl, GraphType *graph, int *tpwgts, float ubfactor) 
+{
+  int dbglvl;
+
+  dbglvl = ctrl->dbglvl;
+  IFSET(ctrl->dbglvl, DBG_REFINE, ctrl->dbglvl -= DBG_REFINE);
+  IFSET(ctrl->dbglvl, DBG_MOVEINFO, ctrl->dbglvl -= DBG_MOVEINFO);
+
+  IFSET(ctrl->dbglvl, DBG_TIME, starttimer(ctrl->InitPartTmr));
+
+  switch (ctrl->IType) {
+    case IPART_GGPKL:
+      GrowBisection(ctrl, graph, tpwgts, ubfactor);
+      break;
+    case 3:
+      RandomBisection(ctrl, graph, tpwgts, ubfactor);
+      break;
+    default:
+      errexit("Unknown initial partition type: %d\n", ctrl->IType);
+  }
+
+  IFSET(ctrl->dbglvl, DBG_IPART, printf("Initial Cut: %d\n", graph->mincut));
+  IFSET(ctrl->dbglvl, DBG_TIME, stoptimer(ctrl->InitPartTmr));
+  ctrl->dbglvl = dbglvl;
+
+/*
+  IsConnectedSubdomain(ctrl, graph, 0);
+  IsConnectedSubdomain(ctrl, graph, 1);
+*/
+}
+
+/*************************************************************************
+* This function computes the initial bisection of the coarsest graph
+**************************************************************************/
+void InitSeparator(CtrlType *ctrl, GraphType *graph, float ubfactor) 
+{
+  int dbglvl;
+
+  dbglvl = ctrl->dbglvl;
+  IFSET(ctrl->dbglvl, DBG_REFINE, ctrl->dbglvl -= DBG_REFINE);
+  IFSET(ctrl->dbglvl, DBG_MOVEINFO, ctrl->dbglvl -= DBG_MOVEINFO);
+
+  IFSET(ctrl->dbglvl, DBG_TIME, starttimer(ctrl->InitPartTmr));
+
+  GrowBisectionNode(ctrl, graph, ubfactor);
+  Compute2WayNodePartitionParams(ctrl, graph);
+
+  IFSET(ctrl->dbglvl, DBG_IPART, printf("Initial Sep: %d\n", graph->mincut));
+  IFSET(ctrl->dbglvl, DBG_TIME, stoptimer(ctrl->InitPartTmr));
+
+  ctrl->dbglvl = dbglvl;
+
+}
+
+
+
+/*************************************************************************
+* This function takes a graph and produces a bisection by using a region
+* growing algorithm. The resulting partition is returned in
+* graph->where
+**************************************************************************/
+void GrowBisection(CtrlType *ctrl, GraphType *graph, int *tpwgts, float ubfactor)
+{
+  int i, j, k, nvtxs, drain, nleft, first, last, pwgts[2], minpwgt[2], maxpwgt[2], from, bestcut, icut, mincut, me, pass, nbfs;
+  idxtype *xadj, *vwgt, *adjncy, *adjwgt, *where;
+  idxtype *queue, *touched, *gain, *bestwhere;
+
+
+  nvtxs = graph->nvtxs;
+  xadj = graph->xadj;
+  vwgt = graph->vwgt;
+  adjncy = graph->adjncy;
+  adjwgt = graph->adjwgt;
+
+  Allocate2WayPartitionMemory(ctrl, graph);
+  where = graph->where;
+
+  bestwhere = idxmalloc(nvtxs, "BisectGraph: bestwhere");
+  queue = idxmalloc(nvtxs, "BisectGraph: queue");
+  touched = idxmalloc(nvtxs, "BisectGraph: touched");
+
+  ASSERTP(tpwgts[0]+tpwgts[1] == idxsum(nvtxs, vwgt), ("%d %d\n", tpwgts[0]+tpwgts[1], idxsum(nvtxs, vwgt)));
+
+  maxpwgt[0] = ubfactor*tpwgts[0];
+  maxpwgt[1] = ubfactor*tpwgts[1];
+  minpwgt[0] = (1.0/ubfactor)*tpwgts[0];
+  minpwgt[1] = (1.0/ubfactor)*tpwgts[1];
+
+  nbfs = (nvtxs <= ctrl->CoarsenTo ? SMALLNIPARTS : LARGENIPARTS);
+  bestcut = idxsum(nvtxs, graph->adjwgtsum)+1;  /* The +1 is for the 0 edges case */
+  for (; nbfs>0; nbfs--) {
+    idxset(nvtxs, 0, touched);
+
+    pwgts[1] = tpwgts[0]+tpwgts[1];
+    pwgts[0] = 0;
+
+    idxset(nvtxs, 1, where);
+
+    queue[0] = RandomInRange(nvtxs);
+    touched[queue[0]] = 1;
+    first = 0; last = 1;
+    nleft = nvtxs-1;
+    drain = 0;
+
+    /* Start the BFS from queue to get a partition */
+    for (;;) {
+      if (first == last) { /* Empty. Disconnected graph! */
+        if (nleft == 0 || drain)
+          break;
+
+        k = RandomInRange(nleft);
+        for (i=0; i<nvtxs; i++) {
+          if (touched[i] == 0) {
+            if (k == 0)
+              break;
+            else
+              k--;
+          }
+        }
+
+        queue[0] = i;
+        touched[i] = 1;
+        first = 0; last = 1;;
+        nleft--;
+      }
+
+      i = queue[first++];
+      if (pwgts[0] > 0 && pwgts[1]-vwgt[i] < minpwgt[1]) {
+        drain = 1;
+        continue;
+      }
+
+      where[i] = 0;
+      INC_DEC(pwgts[0], pwgts[1], vwgt[i]);
+      if (pwgts[1] <= maxpwgt[1])
+        break;
+
+      drain = 0;
+      for (j=xadj[i]; j<xadj[i+1]; j++) {
+        k = adjncy[j];
+        if (touched[k] == 0) {
+          queue[last++] = k;
+          touched[k] = 1;
+          nleft--;
+        }
+      }
+    }
+
+    /* Check to see if we hit any bad limiting cases */
+    if (pwgts[1] == 0) { 
+      i = RandomInRange(nvtxs);
+      where[i] = 1;
+      INC_DEC(pwgts[1], pwgts[0], vwgt[i]);
+    }
+
+    /*************************************************************
+    * Do some partition refinement 
+    **************************************************************/
+    Compute2WayPartitionParams(ctrl, graph);
+    /*printf("IPART: %3d [%5d %5d] [%5d %5d] %5d\n", graph->nvtxs, pwgts[0], pwgts[1], graph->pwgts[0], graph->pwgts[1], graph->mincut); */
+
+    Balance2Way(ctrl, graph, tpwgts, ubfactor);
+    /*printf("BPART: [%5d %5d] %5d\n", graph->pwgts[0], graph->pwgts[1], graph->mincut);*/
+
+    FM_2WayEdgeRefine(ctrl, graph, tpwgts, 4);
+    /*printf("RPART: [%5d %5d] %5d\n", graph->pwgts[0], graph->pwgts[1], graph->mincut);*/
+
+    if (bestcut > graph->mincut) {
+      bestcut = graph->mincut;
+      idxcopy(nvtxs, where, bestwhere);
+      if (bestcut == 0)
+        break;
+    }
+  }
+
+  graph->mincut = bestcut;
+  idxcopy(nvtxs, bestwhere, where);
+
+  GKfree(&bestwhere, &queue, &touched, LTERM);
+}
+
+
+
+
+/*************************************************************************
+* This function takes a graph and produces a bisection by using a region
+* growing algorithm. The resulting partition is returned in
+* graph->where
+**************************************************************************/
+void GrowBisectionNode(CtrlType *ctrl, GraphType *graph, float ubfactor)
+{
+  int i, j, k, nvtxs, drain, nleft, first, last, pwgts[2], tpwgts[2], minpwgt[2], maxpwgt[2], from, bestcut, icut, mincut, me, pass, nbfs;
+  idxtype *xadj, *vwgt, *adjncy, *adjwgt, *where, *bndind;
+  idxtype *queue, *touched, *gain, *bestwhere;
+
+  nvtxs = graph->nvtxs;
+  xadj = graph->xadj;
+  vwgt = graph->vwgt;
+  adjncy = graph->adjncy;
+  adjwgt = graph->adjwgt;
+
+  bestwhere = idxmalloc(nvtxs, "BisectGraph: bestwhere");
+  queue = idxmalloc(nvtxs, "BisectGraph: queue");
+  touched = idxmalloc(nvtxs, "BisectGraph: touched");
+
+  tpwgts[0] = idxsum(nvtxs, vwgt);
+  tpwgts[1] = tpwgts[0]/2;
+  tpwgts[0] -= tpwgts[1];
+
+  maxpwgt[0] = ubfactor*tpwgts[0];
+  maxpwgt[1] = ubfactor*tpwgts[1];
+  minpwgt[0] = (1.0/ubfactor)*tpwgts[0];
+  minpwgt[1] = (1.0/ubfactor)*tpwgts[1];
+
+  /* Allocate memory for graph->rdata. Allocate sufficient memory for both edge and node */
+  graph->rdata = idxmalloc(5*nvtxs+3, "GrowBisectionNode: graph->rdata");
+  graph->pwgts    = graph->rdata;
+  graph->where    = graph->rdata + 3;
+  graph->bndptr   = graph->rdata + nvtxs + 3;
+  graph->bndind   = graph->rdata + 2*nvtxs + 3;
+  graph->nrinfo   = (NRInfoType *)(graph->rdata + 3*nvtxs + 3);
+  graph->id       = graph->rdata + 3*nvtxs + 3;
+  graph->ed       = graph->rdata + 4*nvtxs + 3;
+  
+  where = graph->where;
+  bndind = graph->bndind;
+
+  nbfs = (nvtxs <= ctrl->CoarsenTo ? SMALLNIPARTS : LARGENIPARTS);
+  bestcut = tpwgts[0]+tpwgts[1];
+  for (nbfs++; nbfs>0; nbfs--) {
+    idxset(nvtxs, 0, touched);
+
+    pwgts[1] = tpwgts[0]+tpwgts[1];
+    pwgts[0] = 0;
+
+    idxset(nvtxs, 1, where);
+
+    queue[0] = RandomInRange(nvtxs);
+    touched[queue[0]] = 1;
+    first = 0; last = 1;
+    nleft = nvtxs-1;
+    drain = 0;
+
+    /* Start the BFS from queue to get a partition */
+    if (nbfs >= 1) {
+      for (;;) {
+        if (first == last) { /* Empty. Disconnected graph! */
+          if (nleft == 0 || drain)
+            break;
+  
+          k = RandomInRange(nleft);
+          for (i=0; i<nvtxs; i++) {
+            if (touched[i] == 0) {
+              if (k == 0)
+                break;
+              else
+                k--;
+            }
+          }
+
+          queue[0] = i;
+          touched[i] = 1;
+          first = 0; last = 1;;
+          nleft--;
+        }
+
+        i = queue[first++];
+        if (pwgts[1]-vwgt[i] < minpwgt[1]) {
+          drain = 1;
+          continue;
+        }
+
+        where[i] = 0;
+        INC_DEC(pwgts[0], pwgts[1], vwgt[i]);
+        if (pwgts[1] <= maxpwgt[1])
+          break;
+
+        drain = 0;
+        for (j=xadj[i]; j<xadj[i+1]; j++) {
+          k = adjncy[j];
+          if (touched[k] == 0) {
+            queue[last++] = k;
+            touched[k] = 1;
+            nleft--;
+          }
+        }
+      }
+    }
+
+    /*************************************************************
+    * Do some partition refinement 
+    **************************************************************/
+    Compute2WayPartitionParams(ctrl, graph);
+    Balance2Way(ctrl, graph, tpwgts, ubfactor);
+    FM_2WayEdgeRefine(ctrl, graph, tpwgts, 4);
+
+    /* Construct and refine the vertex separator */
+    for (i=0; i<graph->nbnd; i++) 
+      where[bndind[i]] = 2;
+
+    Compute2WayNodePartitionParams(ctrl, graph); 
+    FM_2WayNodeRefine(ctrl, graph, ubfactor, 6);
+
+    /* printf("ISep: [%d %d %d] %d\n", graph->pwgts[0], graph->pwgts[1], graph->pwgts[2], bestcut); */
+
+    if (bestcut > graph->mincut) {
+      bestcut = graph->mincut;
+      idxcopy(nvtxs, where, bestwhere);
+    }
+  }
+
+  graph->mincut = bestcut;
+  idxcopy(nvtxs, bestwhere, where);
+
+  Compute2WayNodePartitionParams(ctrl, graph); 
+
+  GKfree(&bestwhere, &queue, &touched, LTERM);
+}
+
+
+/*************************************************************************
+* This function takes a graph and produces a bisection by using a region
+* growing algorithm. The resulting partition is returned in
+* graph->where
+**************************************************************************/
+void RandomBisection(CtrlType *ctrl, GraphType *graph, int *tpwgts, float ubfactor)
+{
+  int i, ii, j, k, nvtxs, pwgts[2], minpwgt[2], maxpwgt[2], from, bestcut, icut, mincut, me, pass, nbfs;
+  idxtype *xadj, *vwgt, *adjncy, *adjwgt, *where;
+  idxtype *perm, *bestwhere;
+
+  nvtxs = graph->nvtxs;
+  xadj = graph->xadj;
+  vwgt = graph->vwgt;
+  adjncy = graph->adjncy;
+  adjwgt = graph->adjwgt;
+
+  Allocate2WayPartitionMemory(ctrl, graph);
+  where = graph->where;
+
+  bestwhere = idxmalloc(nvtxs, "BisectGraph: bestwhere");
+  perm = idxmalloc(nvtxs, "BisectGraph: queue");
+
+  ASSERTP(tpwgts[0]+tpwgts[1] == idxsum(nvtxs, vwgt), ("%d %d\n", tpwgts[0]+tpwgts[1], idxsum(nvtxs, vwgt)));
+
+  maxpwgt[0] = ubfactor*tpwgts[0];
+  maxpwgt[1] = ubfactor*tpwgts[1];
+  minpwgt[0] = (1.0/ubfactor)*tpwgts[0];
+  minpwgt[1] = (1.0/ubfactor)*tpwgts[1];
+
+  nbfs = (nvtxs <= ctrl->CoarsenTo ? SMALLNIPARTS : LARGENIPARTS);
+  bestcut = idxsum(nvtxs, graph->adjwgtsum)+1;  /* The +1 is for the 0 edges case */
+  for (; nbfs>0; nbfs--) {
+    RandomPermute(nvtxs, perm, 1);
+
+    idxset(nvtxs, 1, where);
+    pwgts[1] = tpwgts[0]+tpwgts[1];
+    pwgts[0] = 0;
+
+
+    if (nbfs != 1) {
+      for (ii=0; ii<nvtxs; ii++) {
+        i = perm[ii];
+        if (pwgts[0]+vwgt[i] < maxpwgt[0]) {
+          where[i] = 0;
+          pwgts[0] += vwgt[i];
+          pwgts[1] -= vwgt[i];
+          if (pwgts[0] > minpwgt[0])
+            break;
+        }
+      }
+    }
+
+    /*************************************************************
+    * Do some partition refinement 
+    **************************************************************/
+    Compute2WayPartitionParams(ctrl, graph);
+    /* printf("IPART: %3d [%5d %5d] [%5d %5d] %5d\n", graph->nvtxs, pwgts[0], pwgts[1], graph->pwgts[0], graph->pwgts[1], graph->mincut); */
+
+    Balance2Way(ctrl, graph, tpwgts, ubfactor);
+    /* printf("BPART: [%5d %5d] %5d\n", graph->pwgts[0], graph->pwgts[1], graph->mincut); */
+
+    FM_2WayEdgeRefine(ctrl, graph, tpwgts, 4);
+    /* printf("RPART: [%5d %5d] %5d\n", graph->pwgts[0], graph->pwgts[1], graph->mincut); */
+
+    if (bestcut > graph->mincut) {
+      bestcut = graph->mincut;
+      idxcopy(nvtxs, where, bestwhere);
+      if (bestcut == 0)
+        break;
+    }
+  }
+
+  graph->mincut = bestcut;
+  idxcopy(nvtxs, bestwhere, where);
+
+  GKfree(&bestwhere, &perm, LTERM);
+}
+
+
+
+
Index: /inundation/pymetis/metis-4.0/Lib/kmetis.c
===================================================================
--- /inundation/pymetis/metis-4.0/Lib/kmetis.c	(revision 2051)
+++ /inundation/pymetis/metis-4.0/Lib/kmetis.c	(revision 2051)
@@ -0,0 +1,129 @@
+/*
+ * Copyright 1997, Regents of the University of Minnesota
+ *
+ * kmetis.c
+ *
+ * This file contains the top level routines for the multilevel k-way partitioning
+ * algorithm KMETIS.
+ *
+ * Started 7/28/97
+ * George
+ *
+ * $Id: kmetis.c,v 1.1 1998/11/27 17:59:15 karypis Exp $
+ *
+ */
+
+#include <metis.h>
+
+
+/*************************************************************************
+* This function is the entry point for KMETIS
+**************************************************************************/
+void METIS_PartGraphKway(int *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, 
+                         idxtype *adjwgt, int *wgtflag, int *numflag, int *nparts, 
+                         int *options, int *edgecut, idxtype *part)
+{
+  int i;
+  float *tpwgts;
+
+  tpwgts = fmalloc(*nparts, "KMETIS: tpwgts");
+  for (i=0; i<*nparts; i++) 
+    tpwgts[i] = 1.0/(1.0*(*nparts));
+
+  METIS_WPartGraphKway(nvtxs, xadj, adjncy, vwgt, adjwgt, wgtflag, numflag, nparts, 
+                       tpwgts, options, edgecut, part);
+
+  free(tpwgts);
+}
+
+
+/*************************************************************************
+* This function is the entry point for KWMETIS
+**************************************************************************/
+void METIS_WPartGraphKway(int *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, 
+                          idxtype *adjwgt, int *wgtflag, int *numflag, int *nparts, 
+                          float *tpwgts, int *options, int *edgecut, idxtype *part)
+{
+  int i, j;
+  GraphType graph;
+  CtrlType ctrl;
+
+  if (*numflag == 1)
+    Change2CNumbering(*nvtxs, xadj, adjncy);
+
+  SetUpGraph(&graph, OP_KMETIS, *nvtxs, 1, xadj, adjncy, vwgt, adjwgt, *wgtflag);
+
+  if (options[0] == 0) {  /* Use the default parameters */
+    ctrl.CType = KMETIS_CTYPE;
+    ctrl.IType = KMETIS_ITYPE;
+    ctrl.RType = KMETIS_RTYPE;
+    ctrl.dbglvl = KMETIS_DBGLVL;
+  }
+  else {
+    ctrl.CType = options[OPTION_CTYPE];
+    ctrl.IType = options[OPTION_ITYPE];
+    ctrl.RType = options[OPTION_RTYPE];
+    ctrl.dbglvl = options[OPTION_DBGLVL];
+  }
+  ctrl.optype = OP_KMETIS;
+  ctrl.CoarsenTo = amax((*nvtxs)/(40*log2(*nparts)), 20*(*nparts));
+  ctrl.maxvwgt = 1.5*((graph.vwgt ? idxsum(*nvtxs, graph.vwgt) : (*nvtxs))/ctrl.CoarsenTo);
+
+  InitRandom(-1);
+
+  AllocateWorkSpace(&ctrl, &graph, *nparts);
+
+  IFSET(ctrl.dbglvl, DBG_TIME, InitTimers(&ctrl));
+  IFSET(ctrl.dbglvl, DBG_TIME, starttimer(ctrl.TotalTmr));
+
+  *edgecut = MlevelKWayPartitioning(&ctrl, &graph, *nparts, part, tpwgts, 1.03);
+
+  IFSET(ctrl.dbglvl, DBG_TIME, stoptimer(ctrl.TotalTmr));
+  IFSET(ctrl.dbglvl, DBG_TIME, PrintTimers(&ctrl));
+
+  FreeWorkSpace(&ctrl, &graph);
+
+  if (*numflag == 1)
+    Change2FNumbering(*nvtxs, xadj, adjncy, part);
+}
+
+
+/*************************************************************************
+* This function takes a graph and produces a bisection of it
+**************************************************************************/
+int MlevelKWayPartitioning(CtrlType *ctrl, GraphType *graph, int nparts, idxtype *part, float *tpwgts, float ubfactor)
+{
+  int i, j, nvtxs, tvwgt, tpwgts2[2];
+  GraphType *cgraph;
+  int wgtflag=3, numflag=0, options[10], edgecut;
+
+  cgraph = Coarsen2Way(ctrl, graph);
+
+  IFSET(ctrl->dbglvl, DBG_TIME, starttimer(ctrl->InitPartTmr));
+  AllocateKWayPartitionMemory(ctrl, cgraph, nparts);
+
+  options[0] = 1; 
+  options[OPTION_CTYPE] = MATCH_SHEMKWAY;
+  options[OPTION_ITYPE] = IPART_GGPKL;
+  options[OPTION_RTYPE] = RTYPE_FM;
+  options[OPTION_DBGLVL] = 0;
+
+  METIS_WPartGraphRecursive(&cgraph->nvtxs, cgraph->xadj, cgraph->adjncy, cgraph->vwgt, 
+                            cgraph->adjwgt, &wgtflag, &numflag, &nparts, tpwgts, options, 
+                            &edgecut, cgraph->where);
+
+  IFSET(ctrl->dbglvl, DBG_TIME, stoptimer(ctrl->InitPartTmr));
+  IFSET(ctrl->dbglvl, DBG_IPART, printf("Initial %d-way partitioning cut: %d\n", nparts, edgecut));
+
+  IFSET(ctrl->dbglvl, DBG_KWAYPINFO, ComputePartitionInfo(cgraph, nparts, cgraph->where));
+
+  RefineKWay(ctrl, graph, cgraph, nparts, tpwgts, ubfactor);
+
+  idxcopy(graph->nvtxs, graph->where, part);
+
+  GKfree(&graph->gdata, &graph->rdata, LTERM);
+
+  return graph->mincut;
+
+}
+
Index: /inundation/pymetis/metis-4.0/Lib/kvmetis.c
===================================================================
--- /inundation/pymetis/metis-4.0/Lib/kvmetis.c	(revision 2051)
+++ /inundation/pymetis/metis-4.0/Lib/kvmetis.c	(revision 2051)
@@ -0,0 +1,130 @@
+/*
+ * Copyright 1997, Regents of the University of Minnesota
+ *
+ * kvmetis.c
+ *
+ * This file contains the top level routines for the multilevel k-way partitioning
+ * algorithm KMETIS.
+ *
+ * Started 7/28/97
+ * George
+ *
+ * $Id: kvmetis.c,v 1.1 1998/11/27 17:59:16 karypis Exp $
+ *
+ */
+
+#include <metis.h>
+
+
+/*************************************************************************
+* This function is the entry point for KMETIS
+**************************************************************************/
+void METIS_PartGraphVKway(int *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, 
+                         idxtype *vsize, int *wgtflag, int *numflag, int *nparts, 
+                         int *options, int *volume, idxtype *part)
+{
+  int i;
+  float *tpwgts;
+
+  tpwgts = fmalloc(*nparts, "KMETIS: tpwgts");
+  for (i=0; i<*nparts; i++) 
+    tpwgts[i] = 1.0/(1.0*(*nparts));
+
+  METIS_WPartGraphVKway(nvtxs, xadj, adjncy, vwgt, vsize, wgtflag, numflag, nparts, 
+                       tpwgts, options, volume, part);
+
+  free(tpwgts);
+}
+
+
+/*************************************************************************
+* This function is the entry point for KWMETIS
+**************************************************************************/
+void METIS_WPartGraphVKway(int *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, 
+                          idxtype *vsize, int *wgtflag, int *numflag, int *nparts, 
+                          float *tpwgts, int *options, int *volume, idxtype *part)
+{
+  int i, j;
+  GraphType graph;
+  CtrlType ctrl;
+
+  if (*numflag == 1)
+    Change2CNumbering(*nvtxs, xadj, adjncy);
+
+  VolSetUpGraph(&graph, OP_KVMETIS, *nvtxs, 1, xadj, adjncy, vwgt, vsize, *wgtflag);
+
+  if (options[0] == 0) {  /* Use the default parameters */
+    ctrl.CType = KVMETIS_CTYPE;
+    ctrl.IType = KVMETIS_ITYPE;
+    ctrl.RType = KVMETIS_RTYPE;
+    ctrl.dbglvl = KVMETIS_DBGLVL;
+  }
+  else {
+    ctrl.CType = options[OPTION_CTYPE];
+    ctrl.IType = options[OPTION_ITYPE];
+    ctrl.RType = options[OPTION_RTYPE];
+    ctrl.dbglvl = options[OPTION_DBGLVL];
+  }
+  ctrl.optype = OP_KVMETIS;
+  ctrl.CoarsenTo = amax((*nvtxs)/(40*log2(*nparts)), 20*(*nparts));
+  ctrl.maxvwgt = 1.5*((graph.vwgt ? idxsum(*nvtxs, graph.vwgt) : (*nvtxs))/ctrl.CoarsenTo);
+
+  InitRandom(-1);
+
+  AllocateWorkSpace(&ctrl, &graph, *nparts);
+
+  IFSET(ctrl.dbglvl, DBG_TIME, InitTimers(&ctrl));
+  IFSET(ctrl.dbglvl, DBG_TIME, starttimer(ctrl.TotalTmr));
+
+  *volume = MlevelVolKWayPartitioning(&ctrl, &graph, *nparts, part, tpwgts, 1.03);
+
+  IFSET(ctrl.dbglvl, DBG_TIME, stoptimer(ctrl.TotalTmr));
+  IFSET(ctrl.dbglvl, DBG_TIME, PrintTimers(&ctrl));
+
+  FreeWorkSpace(&ctrl, &graph);
+
+  if (*numflag == 1)
+    Change2FNumbering(*nvtxs, xadj, adjncy, part);
+}
+
+
+/*************************************************************************
+* This function takes a graph and produces a bisection of it
+**************************************************************************/
+int MlevelVolKWayPartitioning(CtrlType *ctrl, GraphType *graph, int nparts, idxtype *part, 
+                              float *tpwgts, float ubfactor)
+{
+  int i, j, nvtxs, tvwgt, tpwgts2[2];
+  GraphType *cgraph;
+  int wgtflag=3, numflag=0, options[10], edgecut;
+
+  cgraph = Coarsen2Way(ctrl, graph);
+
+  IFSET(ctrl->dbglvl, DBG_TIME, starttimer(ctrl->InitPartTmr));
+  AllocateVolKWayPartitionMemory(ctrl, cgraph, nparts);
+
+  options[0] = 1; 
+  options[OPTION_CTYPE] = MATCH_SHEMKWAY;
+  options[OPTION_ITYPE] = IPART_GGPKL;
+  options[OPTION_RTYPE] = RTYPE_FM;
+  options[OPTION_DBGLVL] = 0;
+
+  METIS_WPartGraphRecursive(&cgraph->nvtxs, cgraph->xadj, cgraph->adjncy, cgraph->vwgt, 
+                            cgraph->adjwgt, &wgtflag, &numflag, &nparts, tpwgts, options, 
+                            &edgecut, cgraph->where);
+
+  IFSET(ctrl->dbglvl, DBG_TIME, stoptimer(ctrl->InitPartTmr));
+  IFSET(ctrl->dbglvl, DBG_IPART, printf("Initial %d-way partitioning cut: %d\n", nparts, edgecut));
+
+  IFSET(ctrl->dbglvl, DBG_KWAYPINFO, ComputePartitionInfo(cgraph, nparts, cgraph->where));
+
+  RefineVolKWay(ctrl, graph, cgraph, nparts, tpwgts, ubfactor);
+
+  idxcopy(graph->nvtxs, graph->where, part);
+
+  GKfree(&graph->gdata, &graph->rdata, LTERM);
+
+  return graph->minvol;
+
+}
+
Index: /inundation/pymetis/metis-4.0/Lib/kwayfm.c
===================================================================
--- /inundation/pymetis/metis-4.0/Lib/kwayfm.c	(revision 2051)
+++ /inundation/pymetis/metis-4.0/Lib/kwayfm.c	(revision 2051)
@@ -0,0 +1,672 @@
+/*
+ * kwayfm.c
+ *
+ * This file contains code that implements the multilevel k-way refinement
+ *
+ * Started 7/28/97
+ * George
+ *
+ * $Id: kwayfm.c,v 1.1 1998/11/27 17:59:16 karypis Exp $
+ *
+ */
+
+#include <metis.h>
+
+
+/*************************************************************************
+* This function performs k-way refinement
+**************************************************************************/
+void Random_KWayEdgeRefine(CtrlType *ctrl, GraphType *graph, int nparts, float *tpwgts, float ubfactor, int npasses, int ffactor)
+{
+  int i, ii, iii, j, jj, k, l, pass, nvtxs, nmoves, nbnd, tvwgt, myndegrees; 
+  int from, me, to, oldcut, vwgt, gain;
+  idxtype *xadj, *adjncy, *adjwgt;
+  idxtype *where, *pwgts, *perm, *bndptr, *bndind, *minwgt, *maxwgt, *itpwgts;
+  EDegreeType *myedegrees;
+  RInfoType *myrinfo;
+
+  nvtxs = graph->nvtxs;
+  xadj = graph->xadj;
+  adjncy = graph->adjncy;
+  adjwgt = graph->adjwgt;
+
+  bndptr = graph->bndptr;
+  bndind = graph->bndind;
+
+  where = graph->where;
+  pwgts = graph->pwgts;
+  
+  /* Setup the weight intervals of the various subdomains */
+  minwgt =  idxwspacemalloc(ctrl, nparts);
+  maxwgt = idxwspacemalloc(ctrl, nparts);
+  itpwgts = idxwspacemalloc(ctrl, nparts);
+  tvwgt = idxsum(nparts, pwgts);
+  ASSERT(tvwgt == idxsum(nvtxs, graph->vwgt));
+
+  for (i=0; i<nparts; i++) {
+    itpwgts[i] = tpwgts[i]*tvwgt;
+    maxwgt[i] = tpwgts[i]*tvwgt*ubfactor;
+    minwgt[i] = tpwgts[i]*tvwgt*(1.0/ubfactor);
+  }
+
+  perm = idxwspacemalloc(ctrl, nvtxs);
+
+  IFSET(ctrl->dbglvl, DBG_REFINE,
+     printf("Partitions: [%6d %6d]-[%6d %6d], Balance: %5.3f, Nv-Nb[%6d %6d]. Cut: %6d\n",
+             pwgts[idxamin(nparts, pwgts)], pwgts[idxamax(nparts, pwgts)], minwgt[0], maxwgt[0], 
+             1.0*nparts*pwgts[idxamax(nparts, pwgts)]/tvwgt, graph->nvtxs, graph->nbnd,
+             graph->mincut));
+
+  for (pass=0; pass<npasses; pass++) {
+    ASSERT(ComputeCut(graph, where) == graph->mincut);
+
+    oldcut = graph->mincut;
+    nbnd = graph->nbnd;
+
+    RandomPermute(nbnd, perm, 1);
+    for (nmoves=iii=0; iii<graph->nbnd; iii++) {
+      ii = perm[iii];
+      if (ii >= nbnd)
+        continue;
+      i = bndind[ii];
+
+      myrinfo = graph->rinfo+i;
+
+      if (myrinfo->ed >= myrinfo->id) { /* Total ED is too high */
+        from = where[i];
+        vwgt = graph->vwgt[i];
+
+        if (myrinfo->id > 0 && pwgts[from]-vwgt < minwgt[from]) 
+          continue;   /* This cannot be moved! */
+
+        myedegrees = myrinfo->edegrees;
+        myndegrees = myrinfo->ndegrees;
+
+        j = myrinfo->id;
+        for (k=0; k<myndegrees; k++) {
+          to = myedegrees[k].pid;
+          gain = myedegrees[k].ed-j; /* j = myrinfo->id. Allow good nodes to move */ 
+          if (pwgts[to]+vwgt <= maxwgt[to]+ffactor*gain && gain >= 0)  
+            break;
+        }
+        if (k == myndegrees)
+          continue;  /* break out if you did not find a candidate */
+
+        for (j=k+1; j<myndegrees; j++) {
+          to = myedegrees[j].pid;
+          if ((myedegrees[j].ed > myedegrees[k].ed && pwgts[to]+vwgt <= maxwgt[to]) ||
+              (myedegrees[j].ed == myedegrees[k].ed && 
+               itpwgts[myedegrees[k].pid]*pwgts[to] < itpwgts[to]*pwgts[myedegrees[k].pid]))
+            k = j;
+        }
+
+        to = myedegrees[k].pid;
+
+        j = 0;
+        if (myedegrees[k].ed-myrinfo->id > 0)
+          j = 1;
+        else if (myedegrees[k].ed-myrinfo->id == 0) {
+          if ((iii&7) == 0 || pwgts[from] >= maxwgt[from] || itpwgts[from]*(pwgts[to]+vwgt) < itpwgts[to]*pwgts[from])
+            j = 1;
+        }
+        if (j == 0)
+          continue;
+          
+        /*=====================================================================
+        * If we got here, we can now move the vertex from 'from' to 'to' 
+        *======================================================================*/
+        graph->mincut -= myedegrees[k].ed-myrinfo->id;
+
+        IFSET(ctrl->dbglvl, DBG_MOVEINFO, printf("\t\tMoving %6d to %3d. Gain: %4d. Cut: %6d\n", i, to, myedegrees[k].ed-myrinfo->id, graph->mincut));
+
+        /* Update where, weight, and ID/ED information of the vertex you moved */
+        where[i] = to;
+        INC_DEC(pwgts[to], pwgts[from], vwgt);
+        myrinfo->ed += myrinfo->id-myedegrees[k].ed;
+        SWAP(myrinfo->id, myedegrees[k].ed, j);
+        if (myedegrees[k].ed == 0) 
+          myedegrees[k] = myedegrees[--myrinfo->ndegrees];
+        else
+          myedegrees[k].pid = from;
+
+        if (myrinfo->ed-myrinfo->id < 0)
+          BNDDelete(nbnd, bndind, bndptr, i);
+
+        /* Update the degrees of adjacent vertices */
+        for (j=xadj[i]; j<xadj[i+1]; j++) {
+          ii = adjncy[j];
+          me = where[ii];
+
+          myrinfo = graph->rinfo+ii;
+          if (myrinfo->edegrees == NULL) {
+            myrinfo->edegrees = ctrl->wspace.edegrees+ctrl->wspace.cdegree;
+            ctrl->wspace.cdegree += xadj[ii+1]-xadj[ii];
+          }
+          myedegrees = myrinfo->edegrees;
+
+          ASSERT(CheckRInfo(myrinfo));
+
+          if (me == from) {
+            INC_DEC(myrinfo->ed, myrinfo->id, adjwgt[j]);
+
+            if (myrinfo->ed-myrinfo->id >= 0 && bndptr[ii] == -1)
+              BNDInsert(nbnd, bndind, bndptr, ii);
+          }
+          else if (me == to) {
+            INC_DEC(myrinfo->id, myrinfo->ed, adjwgt[j]);
+
+            if (myrinfo->ed-myrinfo->id < 0 && bndptr[ii] != -1)
+              BNDDelete(nbnd, bndind, bndptr, ii);
+          }
+
+          /* Remove contribution from the .ed of 'from' */
+          if (me != from) {
+            for (k=0; k<myrinfo->ndegrees; k++) {
+              if (myedegrees[k].pid == from) {
+                if (myedegrees[k].ed == adjwgt[j])
+                  myedegrees[k] = myedegrees[--myrinfo->ndegrees];
+                else
+                  myedegrees[k].ed -= adjwgt[j];
+                break;
+              }
+            }
+          }
+
+          /* Add contribution to the .ed of 'to' */
+          if (me != to) {
+            for (k=0; k<myrinfo->ndegrees; k++) {
+              if (myedegrees[k].pid == to) {
+                myedegrees[k].ed += adjwgt[j];
+                break;
+              }
+            }
+            if (k == myrinfo->ndegrees) {
+              myedegrees[myrinfo->ndegrees].pid = to;
+              myedegrees[myrinfo->ndegrees++].ed = adjwgt[j];
+            }
+          }
+
+          ASSERT(myrinfo->ndegrees <= xadj[ii+1]-xadj[ii]);
+          ASSERT(CheckRInfo(myrinfo));
+
+        }
+        nmoves++;
+      }
+    }
+
+    graph->nbnd = nbnd;
+
+    IFSET(ctrl->dbglvl, DBG_REFINE,
+       printf("\t[%6d %6d], Balance: %5.3f, Nb: %6d. Nmoves: %5d, Cut: %6d, Vol: %6d\n",
+               pwgts[idxamin(nparts, pwgts)], pwgts[idxamax(nparts, pwgts)],
+               1.0*nparts*pwgts[idxamax(nparts, pwgts)]/tvwgt, graph->nbnd, nmoves, graph->mincut, ComputeVolume(graph, where)));
+
+    if (graph->mincut == oldcut)
+      break;
+  }
+
+  idxwspacefree(ctrl, nparts);
+  idxwspacefree(ctrl, nparts);
+  idxwspacefree(ctrl, nparts);
+  idxwspacefree(ctrl, nvtxs);
+}
+
+
+
+
+
+
+/*************************************************************************
+* This function performs k-way refinement
+**************************************************************************/
+void Greedy_KWayEdgeRefine(CtrlType *ctrl, GraphType *graph, int nparts, float *tpwgts, float ubfactor, int npasses)
+{
+  int i, ii, iii, j, jj, k, l, pass, nvtxs, nbnd, tvwgt, myndegrees, oldgain, gain; 
+  int from, me, to, oldcut, vwgt;
+  idxtype *xadj, *adjncy, *adjwgt;
+  idxtype *where, *pwgts, *perm, *bndptr, *bndind, *minwgt, *maxwgt, *moved, *itpwgts;
+  EDegreeType *myedegrees;
+  RInfoType *myrinfo;
+  PQueueType queue;
+
+  nvtxs = graph->nvtxs;
+  xadj = graph->xadj;
+  adjncy = graph->adjncy;
+  adjwgt = graph->adjwgt;
+
+  bndind = graph->bndind;
+  bndptr = graph->bndptr;
+
+  where = graph->where;
+  pwgts = graph->pwgts;
+  
+  /* Setup the weight intervals of the various subdomains */
+  minwgt =  idxwspacemalloc(ctrl, nparts);
+  maxwgt = idxwspacemalloc(ctrl, nparts);
+  itpwgts = idxwspacemalloc(ctrl, nparts);
+  tvwgt = idxsum(nparts, pwgts);
+  ASSERT(tvwgt == idxsum(nvtxs, graph->vwgt));
+
+  for (i=0; i<nparts; i++) {
+    itpwgts[i] = tpwgts[i]*tvwgt;
+    maxwgt[i] = tpwgts[i]*tvwgt*ubfactor;
+    minwgt[i] = tpwgts[i]*tvwgt*(1.0/ubfactor);
+  }
+
+  perm = idxwspacemalloc(ctrl, nvtxs);
+  moved = idxwspacemalloc(ctrl, nvtxs);
+
+  PQueueInit(ctrl, &queue, nvtxs, graph->adjwgtsum[idxamax(nvtxs, graph->adjwgtsum)]);
+
+  IFSET(ctrl->dbglvl, DBG_REFINE,
+     printf("Partitions: [%6d %6d]-[%6d %6d], Balance: %5.3f, Nv-Nb[%6d %6d]. Cut: %6d\n",
+             pwgts[idxamin(nparts, pwgts)], pwgts[idxamax(nparts, pwgts)], minwgt[0], maxwgt[0], 
+             1.0*nparts*pwgts[idxamax(nparts, pwgts)]/tvwgt, graph->nvtxs, graph->nbnd,
+             graph->mincut));
+
+  for (pass=0; pass<npasses; pass++) {
+    ASSERT(ComputeCut(graph, where) == graph->mincut);
+
+    PQueueReset(&queue);
+    idxset(nvtxs, -1, moved);
+
+    oldcut = graph->mincut;
+    nbnd = graph->nbnd;
+
+    RandomPermute(nbnd, perm, 1);
+    for (ii=0; ii<nbnd; ii++) {
+      i = bndind[perm[ii]];
+      PQueueInsert(&queue, i, graph->rinfo[i].ed - graph->rinfo[i].id);
+      moved[i] = 2;
+    }
+
+    for (iii=0;;iii++) {
+      if ((i = PQueueGetMax(&queue)) == -1) 
+        break;
+      moved[i] = 1;
+
+      myrinfo = graph->rinfo+i;
+      from = where[i];
+      vwgt = graph->vwgt[i];
+
+      if (pwgts[from]-vwgt < minwgt[from]) 
+        continue;   /* This cannot be moved! */
+
+      myedegrees = myrinfo->edegrees;
+      myndegrees = myrinfo->ndegrees;
+
+      j = myrinfo->id;
+      for (k=0; k<myndegrees; k++) {
+        to = myedegrees[k].pid;
+        gain = myedegrees[k].ed-j; /* j = myrinfo->id. Allow good nodes to move */ 
+        if (pwgts[to]+vwgt <= maxwgt[to]+gain && gain >= 0)  
+          break;
+      }
+      if (k == myndegrees)
+        continue;  /* break out if you did not find a candidate */
+
+      for (j=k+1; j<myndegrees; j++) {
+        to = myedegrees[j].pid;
+        if ((myedegrees[j].ed > myedegrees[k].ed && pwgts[to]+vwgt <= maxwgt[to]) ||
+            (myedegrees[j].ed == myedegrees[k].ed && 
+             itpwgts[myedegrees[k].pid]*pwgts[to] < itpwgts[to]*pwgts[myedegrees[k].pid]))
+          k = j;
+      }
+
+      to = myedegrees[k].pid;
+
+      j = 0;
+      if (myedegrees[k].ed-myrinfo->id > 0)
+        j = 1;
+      else if (myedegrees[k].ed-myrinfo->id == 0) {
+        if ((iii&7) == 0 || pwgts[from] >= maxwgt[from] || itpwgts[from]*(pwgts[to]+vwgt) < itpwgts[to]*pwgts[from])
+          j = 1;
+      }
+      if (j == 0)
+        continue;
+          
+      /*=====================================================================
+      * If we got here, we can now move the vertex from 'from' to 'to' 
+      *======================================================================*/
+      graph->mincut -= myedegrees[k].ed-myrinfo->id;
+
+      IFSET(ctrl->dbglvl, DBG_MOVEINFO, printf("\t\tMoving %6d to %3d. Gain: %4d. Cut: %6d\n", i, to, myedegrees[k].ed-myrinfo->id, graph->mincut));
+
+      /* Update where, weight, and ID/ED information of the vertex you moved */
+      where[i] = to;
+      INC_DEC(pwgts[to], pwgts[from], vwgt);
+      myrinfo->ed += myrinfo->id-myedegrees[k].ed;
+      SWAP(myrinfo->id, myedegrees[k].ed, j);
+      if (myedegrees[k].ed == 0) 
+        myedegrees[k] = myedegrees[--myrinfo->ndegrees];
+      else
+        myedegrees[k].pid = from;
+
+      if (myrinfo->ed < myrinfo->id)
+        BNDDelete(nbnd, bndind, bndptr, i);
+
+      /* Update the degrees of adjacent vertices */
+      for (j=xadj[i]; j<xadj[i+1]; j++) {
+        ii = adjncy[j];
+        me = where[ii];
+
+        myrinfo = graph->rinfo+ii;
+        if (myrinfo->edegrees == NULL) {
+          myrinfo->edegrees = ctrl->wspace.edegrees+ctrl->wspace.cdegree;
+          ctrl->wspace.cdegree += xadj[ii+1]-xadj[ii];
+        }
+        myedegrees = myrinfo->edegrees;
+
+        ASSERT(CheckRInfo(myrinfo));
+
+        oldgain = (myrinfo->ed-myrinfo->id);
+
+        if (me == from) {
+          INC_DEC(myrinfo->ed, myrinfo->id, adjwgt[j]);
+
+          if (myrinfo->ed-myrinfo->id >= 0 && bndptr[ii] == -1)
+            BNDInsert(nbnd, bndind, bndptr, ii);
+        }
+        else if (me == to) {
+          INC_DEC(myrinfo->id, myrinfo->ed, adjwgt[j]);
+
+          if (myrinfo->ed-myrinfo->id < 0 && bndptr[ii] != -1)
+            BNDDelete(nbnd, bndind, bndptr, ii);
+        }
+
+        /* Remove contribution from the .ed of 'from' */
+        if (me != from) {
+          for (k=0; k<myrinfo->ndegrees; k++) {
+            if (myedegrees[k].pid == from) {
+              if (myedegrees[k].ed == adjwgt[j])
+                myedegrees[k] = myedegrees[--myrinfo->ndegrees];
+              else
+                myedegrees[k].ed -= adjwgt[j];
+              break;
+            }
+          }
+        }
+
+        /* Add contribution to the .ed of 'to' */
+        if (me != to) {
+          for (k=0; k<myrinfo->ndegrees; k++) {
+            if (myedegrees[k].pid == to) {
+              myedegrees[k].ed += adjwgt[j];
+              break;
+            }
+          }
+          if (k == myrinfo->ndegrees) {
+            myedegrees[myrinfo->ndegrees].pid = to;
+            myedegrees[myrinfo->ndegrees++].ed = adjwgt[j];
+          }
+        }
+
+        /* Update the queue */
+        if (me == to || me == from) { 
+          gain = myrinfo->ed-myrinfo->id;
+          if (moved[ii] == 2) {
+            if (gain >= 0)
+              PQueueUpdate(&queue, ii, oldgain, gain);
+            else {
+              PQueueDelete(&queue, ii, oldgain);
+              moved[ii] = -1;
+            }
+          }
+          else if (moved[ii] == -1 && gain >= 0) {
+            PQueueInsert(&queue, ii, gain);
+            moved[ii] = 2;
+          }
+        } 
+
+        ASSERT(myrinfo->ndegrees <= xadj[ii+1]-xadj[ii]);
+        ASSERT(CheckRInfo(myrinfo));
+
+      }
+    }
+
+    graph->nbnd = nbnd;
+
+    IFSET(ctrl->dbglvl, DBG_REFINE,
+       printf("\t[%6d %6d], Balance: %5.3f, Nb: %6d. Cut: %6d\n",
+               pwgts[idxamin(nparts, pwgts)], pwgts[idxamax(nparts, pwgts)],
+               1.0*nparts*pwgts[idxamax(nparts, pwgts)]/tvwgt, graph->nbnd, graph->mincut));
+
+    if (graph->mincut == oldcut)
+      break;
+  }
+
+  PQueueFree(ctrl, &queue);
+
+  idxwspacefree(ctrl, nparts);
+  idxwspacefree(ctrl, nparts);
+  idxwspacefree(ctrl, nparts);
+  idxwspacefree(ctrl, nvtxs);
+  idxwspacefree(ctrl, nvtxs);
+
+}
+
+
+/*************************************************************************
+* This function performs k-way refinement
+**************************************************************************/
+void Greedy_KWayEdgeBalance(CtrlType *ctrl, GraphType *graph, int nparts, float *tpwgts, float ubfactor, int npasses)
+{
+  int i, ii, iii, j, jj, k, l, pass, nvtxs, nbnd, tvwgt, myndegrees, oldgain, gain, nmoves; 
+  int from, me, to, oldcut, vwgt;
+  idxtype *xadj, *adjncy, *adjwgt;
+  idxtype *where, *pwgts, *perm, *bndptr, *bndind, *minwgt, *maxwgt, *moved, *itpwgts;
+  EDegreeType *myedegrees;
+  RInfoType *myrinfo;
+  PQueueType queue;
+
+  nvtxs = graph->nvtxs;
+  xadj = graph->xadj;
+  adjncy = graph->adjncy;
+  adjwgt = graph->adjwgt;
+
+  bndind = graph->bndind;
+  bndptr = graph->bndptr;
+
+  where = graph->where;
+  pwgts = graph->pwgts;
+  
+  /* Setup the weight intervals of the various subdomains */
+  minwgt =  idxwspacemalloc(ctrl, nparts);
+  maxwgt = idxwspacemalloc(ctrl, nparts);
+  itpwgts = idxwspacemalloc(ctrl, nparts);
+  tvwgt = idxsum(nparts, pwgts);
+  ASSERT(tvwgt == idxsum(nvtxs, graph->vwgt));
+
+  for (i=0; i<nparts; i++) {
+    itpwgts[i] = tpwgts[i]*tvwgt;
+    maxwgt[i] = tpwgts[i]*tvwgt*ubfactor;
+    minwgt[i] = tpwgts[i]*tvwgt*(1.0/ubfactor);
+  }
+
+  perm = idxwspacemalloc(ctrl, nvtxs);
+  moved = idxwspacemalloc(ctrl, nvtxs);
+
+  PQueueInit(ctrl, &queue, nvtxs, graph->adjwgtsum[idxamax(nvtxs, graph->adjwgtsum)]);
+
+  IFSET(ctrl->dbglvl, DBG_REFINE,
+     printf("Partitions: [%6d %6d]-[%6d %6d], Balance: %5.3f, Nv-Nb[%6d %6d]. Cut: %6d [B]\n",
+             pwgts[idxamin(nparts, pwgts)], pwgts[idxamax(nparts, pwgts)], minwgt[0], maxwgt[0], 
+             1.0*nparts*pwgts[idxamax(nparts, pwgts)]/tvwgt, graph->nvtxs, graph->nbnd,
+             graph->mincut));
+
+  for (pass=0; pass<npasses; pass++) {
+    ASSERT(ComputeCut(graph, where) == graph->mincut);
+
+    /* Check to see if things are out of balance, given the tolerance */
+    for (i=0; i<nparts; i++) {
+      if (pwgts[i] > maxwgt[i])
+        break;
+    }
+    if (i == nparts) /* Things are balanced. Return right away */
+      break;
+
+    PQueueReset(&queue);
+    idxset(nvtxs, -1, moved);
+
+    oldcut = graph->mincut;
+    nbnd = graph->nbnd;
+
+    RandomPermute(nbnd, perm, 1);
+    for (ii=0; ii<nbnd; ii++) {
+      i = bndind[perm[ii]];
+      PQueueInsert(&queue, i, graph->rinfo[i].ed - graph->rinfo[i].id);
+      moved[i] = 2;
+    }
+
+    nmoves = 0;
+    for (;;) {
+      if ((i = PQueueGetMax(&queue)) == -1) 
+        break;
+      moved[i] = 1;
+
+      myrinfo = graph->rinfo+i;
+      from = where[i];
+      vwgt = graph->vwgt[i];
+
+      if (pwgts[from]-vwgt < minwgt[from]) 
+        continue;   /* This cannot be moved! */
+
+      myedegrees = myrinfo->edegrees;
+      myndegrees = myrinfo->ndegrees;
+
+      for (k=0; k<myndegrees; k++) {
+        to = myedegrees[k].pid;
+        if (pwgts[to]+vwgt <= maxwgt[to] || itpwgts[from]*(pwgts[to]+vwgt) <= itpwgts[to]*pwgts[from]) 
+          break;
+      }
+      if (k == myndegrees)
+        continue;  /* break out if you did not find a candidate */
+
+      for (j=k+1; j<myndegrees; j++) {
+        to = myedegrees[j].pid;
+        if (itpwgts[myedegrees[k].pid]*pwgts[to] < itpwgts[to]*pwgts[myedegrees[k].pid]) 
+          k = j;
+      }
+
+      to = myedegrees[k].pid;
+
+      if (pwgts[from] < maxwgt[from] && pwgts[to] > minwgt[to] && myedegrees[k].ed-myrinfo->id < 0) 
+        continue;
+
+      /*=====================================================================
+      * If we got here, we can now move the vertex from 'from' to 'to' 
+      *======================================================================*/
+      graph->mincut -= myedegrees[k].ed-myrinfo->id;
+
+      IFSET(ctrl->dbglvl, DBG_MOVEINFO, printf("\t\tMoving %6d to %3d. Gain: %4d. Cut: %6d\n", i, to, myedegrees[k].ed-myrinfo->id, graph->mincut));
+
+      /* Update where, weight, and ID/ED information of the vertex you moved */
+      where[i] = to;
+      INC_DEC(pwgts[to], pwgts[from], vwgt);
+      myrinfo->ed += myrinfo->id-myedegrees[k].ed;
+      SWAP(myrinfo->id, myedegrees[k].ed, j);
+      if (myedegrees[k].ed == 0) 
+        myedegrees[k] = myedegrees[--myrinfo->ndegrees];
+      else
+        myedegrees[k].pid = from;
+
+      if (myrinfo->ed == 0)
+        BNDDelete(nbnd, bndind, bndptr, i);
+
+      /* Update the degrees of adjacent vertices */
+      for (j=xadj[i]; j<xadj[i+1]; j++) {
+        ii = adjncy[j];
+        me = where[ii];
+
+        myrinfo = graph->rinfo+ii;
+        if (myrinfo->edegrees == NULL) {
+          myrinfo->edegrees = ctrl->wspace.edegrees+ctrl->wspace.cdegree;
+          ctrl->wspace.cdegree += xadj[ii+1]-xadj[ii];
+        }
+        myedegrees = myrinfo->edegrees;
+
+        ASSERT(CheckRInfo(myrinfo));
+
+        oldgain = (myrinfo->ed-myrinfo->id);
+
+        if (me == from) {
+          INC_DEC(myrinfo->ed, myrinfo->id, adjwgt[j]);
+
+          if (myrinfo->ed > 0 && bndptr[ii] == -1)
+            BNDInsert(nbnd, bndind, bndptr, ii);
+        }
+        else if (me == to) {
+          INC_DEC(myrinfo->id, myrinfo->ed, adjwgt[j]);
+
+          if (myrinfo->ed == 0 && bndptr[ii] != -1)
+            BNDDelete(nbnd, bndind, bndptr, ii);
+        }
+
+        /* Remove contribution from the .ed of 'from' */
+        if (me != from) {
+          for (k=0; k<myrinfo->ndegrees; k++) {
+            if (myedegrees[k].pid == from) {
+              if (myedegrees[k].ed == adjwgt[j])
+                myedegrees[k] = myedegrees[--myrinfo->ndegrees];
+              else
+                myedegrees[k].ed -= adjwgt[j];
+              break;
+            }
+          }
+        }
+
+        /* Add contribution to the .ed of 'to' */
+        if (me != to) {
+          for (k=0; k<myrinfo->ndegrees; k++) {
+            if (myedegrees[k].pid == to) {
+              myedegrees[k].ed += adjwgt[j];
+              break;
+            }
+          }
+          if (k == myrinfo->ndegrees) {
+            myedegrees[myrinfo->ndegrees].pid = to;
+            myedegrees[myrinfo->ndegrees++].ed = adjwgt[j];
+          }
+        }
+
+        /* Update the queue */
+        if (me == to || me == from) { 
+          gain = myrinfo->ed-myrinfo->id;
+          if (moved[ii] == 2) {
+            if (myrinfo->ed > 0)
+              PQueueUpdate(&queue, ii, oldgain, gain);
+            else {
+              PQueueDelete(&queue, ii, oldgain);
+              moved[ii] = -1;
+            }
+          }
+          else if (moved[ii] == -1 && myrinfo->ed > 0) {
+            PQueueInsert(&queue, ii, gain);
+            moved[ii] = 2;
+          }
+        } 
+
+        ASSERT(myrinfo->ndegrees <= xadj[ii+1]-xadj[ii]);
+        ASSERT(CheckRInfo(myrinfo));
+      }
+      nmoves++;
+    }
+
+    graph->nbnd = nbnd;
+
+    IFSET(ctrl->dbglvl, DBG_REFINE,
+       printf("\t[%6d %6d], Balance: %5.3f, Nb: %6d. Nmoves: %5d, Cut: %6d\n",
+               pwgts[idxamin(nparts, pwgts)], pwgts[idxamax(nparts, pwgts)],
+               1.0*nparts*pwgts[idxamax(nparts, pwgts)]/tvwgt, graph->nbnd, nmoves, graph->mincut));
+  }
+
+  PQueueFree(ctrl, &queue);
+
+  idxwspacefree(ctrl, nparts);
+  idxwspacefree(ctrl, nparts);
+  idxwspacefree(ctrl, nparts);
+  idxwspacefree(ctrl, nvtxs);
+  idxwspacefree(ctrl, nvtxs);
+
+}
+
Index: /inundation/pymetis/metis-4.0/Lib/kwayrefine.c
===================================================================
--- /inundation/pymetis/metis-4.0/Lib/kwayrefine.c	(revision 2051)
+++ /inundation/pymetis/metis-4.0/Lib/kwayrefine.c	(revision 2051)
@@ -0,0 +1,392 @@
+/*
+ * Copyright 1997, Regents of the University of Minnesota
+ *
+ * kwayrefine.c
+ *
+ * This file contains the driving routines for multilevel k-way refinement
+ *
+ * Started 7/28/97
+ * George
+ *
+ * $Id: kwayrefine.c,v 1.1 1998/11/27 17:59:17 karypis Exp $
+ */
+
+#include <metis.h>
+
+
+/*************************************************************************
+* This function is the entry point of refinement
+**************************************************************************/
+void RefineKWay(CtrlType *ctrl, GraphType *orggraph, GraphType *graph, int nparts, float *tpwgts, float ubfactor)
+{
+  int i, nlevels, mustfree=0;
+  GraphType *ptr;
+
+  IFSET(ctrl->dbglvl, DBG_TIME, starttimer(ctrl->UncoarsenTmr));
+
+  /* Compute the parameters of the coarsest graph */
+  ComputeKWayPartitionParams(ctrl, graph, nparts);
+
+  /* Take care any non-contiguity */
+  IFSET(ctrl->dbglvl, DBG_TIME, starttimer(ctrl->AuxTmr1));
+  if (ctrl->RType == RTYPE_KWAYRANDOM_MCONN) {
+    EliminateComponents(ctrl, graph, nparts, tpwgts, 1.25);
+    EliminateSubDomainEdges(ctrl, graph, nparts, tpwgts);
+    EliminateComponents(ctrl, graph, nparts, tpwgts, 1.25);
+  }
+  IFSET(ctrl->dbglvl, DBG_TIME, stoptimer(ctrl->AuxTmr1));
+
+  /* Determine how many levels are there */
+  for (ptr=graph, nlevels=0; ptr!=orggraph; ptr=ptr->finer, nlevels++); 
+
+  for (i=0; ;i++) {
+    /* PrintSubDomainGraph(graph, nparts, graph->where); */
+    if (ctrl->RType == RTYPE_KWAYRANDOM_MCONN && (i == nlevels/2 || i == nlevels/2+1))
+      EliminateSubDomainEdges(ctrl, graph, nparts, tpwgts);
+
+    IFSET(ctrl->dbglvl, DBG_TIME, starttimer(ctrl->RefTmr));
+
+    if (2*i >= nlevels && !IsBalanced(graph->pwgts, nparts, tpwgts, 1.04*ubfactor)) {
+      ComputeKWayBalanceBoundary(ctrl, graph, nparts);
+      if (ctrl->RType == RTYPE_KWAYRANDOM_MCONN)
+        Greedy_KWayEdgeBalanceMConn(ctrl, graph, nparts, tpwgts, ubfactor, 1); 
+      else
+        Greedy_KWayEdgeBalance(ctrl, graph, nparts, tpwgts, ubfactor, 1); 
+      ComputeKWayBoundary(ctrl, graph, nparts);
+    }
+
+    switch (ctrl->RType) {
+      case RTYPE_KWAYRANDOM:
+        Random_KWayEdgeRefine(ctrl, graph, nparts, tpwgts, ubfactor, 10, 1); 
+        break;
+      case RTYPE_KWAYGREEDY:
+        Greedy_KWayEdgeRefine(ctrl, graph, nparts, tpwgts, ubfactor, 10); 
+        break;
+      case RTYPE_KWAYRANDOM_MCONN:
+        Random_KWayEdgeRefineMConn(ctrl, graph, nparts, tpwgts, ubfactor, 10, 1); 
+        break;
+    }
+    IFSET(ctrl->dbglvl, DBG_TIME, stoptimer(ctrl->RefTmr));
+
+    if (graph == orggraph)
+      break;
+
+    GKfree(&graph->gdata, LTERM);  /* Deallocate the graph related arrays */
+
+    graph = graph->finer;
+
+    IFSET(ctrl->dbglvl, DBG_TIME, starttimer(ctrl->ProjectTmr));
+    if (graph->vwgt == NULL) {
+      graph->vwgt = idxsmalloc(graph->nvtxs, 1, "RefineKWay: graph->vwgt");
+      graph->adjwgt = idxsmalloc(graph->nedges, 1, "RefineKWay: graph->adjwgt");
+      mustfree = 1;
+    }
+    ProjectKWayPartition(ctrl, graph, nparts);
+    IFSET(ctrl->dbglvl, DBG_TIME, stoptimer(ctrl->ProjectTmr));
+  }
+
+  if (!IsBalanced(graph->pwgts, nparts, tpwgts, ubfactor)) {
+    ComputeKWayBalanceBoundary(ctrl, graph, nparts);
+    if (ctrl->RType == RTYPE_KWAYRANDOM_MCONN) {
+      Greedy_KWayEdgeBalanceMConn(ctrl, graph, nparts, tpwgts, ubfactor, 8); 
+      Random_KWayEdgeRefineMConn(ctrl, graph, nparts, tpwgts, ubfactor, 10, 0); 
+    }
+    else {
+      Greedy_KWayEdgeBalance(ctrl, graph, nparts, tpwgts, ubfactor, 8); 
+      Random_KWayEdgeRefine(ctrl, graph, nparts, tpwgts, ubfactor, 10, 0); 
+    }
+  }
+
+  /* Take care any trivial non-contiguity */
+  IFSET(ctrl->dbglvl, DBG_TIME, starttimer(ctrl->AuxTmr2));
+  EliminateComponents(ctrl, graph, nparts, tpwgts, ubfactor);
+  IFSET(ctrl->dbglvl, DBG_TIME, stoptimer(ctrl->AuxTmr2));
+
+  if (mustfree) 
+    GKfree(&graph->vwgt, &graph->adjwgt, LTERM);
+
+  IFSET(ctrl->dbglvl, DBG_TIME, stoptimer(ctrl->UncoarsenTmr));
+}
+
+
+/*************************************************************************
+* This function allocates memory for k-way edge refinement
+**************************************************************************/
+void AllocateKWayPartitionMemory(CtrlType *ctrl, GraphType *graph, int nparts)
+{
+  int nvtxs, pad64;
+
+  nvtxs = graph->nvtxs;
+
+  pad64 = (3*nvtxs+nparts)%2;
+
+  graph->rdata = idxmalloc(3*nvtxs+nparts+(sizeof(RInfoType)/sizeof(idxtype))*nvtxs+pad64, "AllocateKWayPartitionMemory: rdata");
+  graph->pwgts          = graph->rdata;
+  graph->where          = graph->rdata + nparts;
+  graph->bndptr         = graph->rdata + nvtxs + nparts;
+  graph->bndind         = graph->rdata + 2*nvtxs + nparts;
+  graph->rinfo          = (RInfoType *)(graph->rdata + 3*nvtxs+nparts + pad64);
+
+/*
+  if (ctrl->wspace.edegrees != NULL)
+    free(ctrl->wspace.edegrees);
+  ctrl->wspace.edegrees = (EDegreeType *)GKmalloc(graph->nedges*sizeof(EDegreeType), "AllocateKWayPartitionMemory: edegrees");
+*/
+}
+
+
+/*************************************************************************
+* This function computes the initial id/ed 
+**************************************************************************/
+void ComputeKWayPartitionParams(CtrlType *ctrl, GraphType *graph, int nparts)
+{
+  int i, j, k, l, nvtxs, nbnd, mincut, me, other;
+  idxtype *xadj, *vwgt, *adjncy, *adjwgt, *pwgts, *where, *bndind, *bndptr;
+  RInfoType *rinfo, *myrinfo;
+  EDegreeType *myedegrees;
+
+  nvtxs = graph->nvtxs;
+  xadj = graph->xadj;
+  vwgt = graph->vwgt;
+  adjncy = graph->adjncy;
+  adjwgt = graph->adjwgt;
+
+  where = graph->where;
+  pwgts = idxset(nparts, 0, graph->pwgts);
+  bndind = graph->bndind;
+  bndptr = idxset(nvtxs, -1, graph->bndptr);
+  rinfo = graph->rinfo;
+
+
+  /*------------------------------------------------------------
+  / Compute now the id/ed degrees
+  /------------------------------------------------------------*/
+  ctrl->wspace.cdegree = 0;
+  nbnd = mincut = 0;
+  for (i=0; i<nvtxs; i++) {
+    me = where[i];
+    pwgts[me] += vwgt[i];
+
+    myrinfo = rinfo+i;
+    myrinfo->id = myrinfo->ed = myrinfo->ndegrees = 0;
+    myrinfo->edegrees = NULL;
+
+    for (j=xadj[i]; j<xadj[i+1]; j++) {
+      if (me != where[adjncy[j]])
+        myrinfo->ed += adjwgt[j];
+    }
+    myrinfo->id = graph->adjwgtsum[i] - myrinfo->ed;
+
+    if (myrinfo->ed > 0) 
+      mincut += myrinfo->ed;
+
+    if (myrinfo->ed-myrinfo->id >= 0)
+      BNDInsert(nbnd, bndind, bndptr, i);
+
+    /* Time to compute the particular external degrees */
+    if (myrinfo->ed > 0) { 
+      myedegrees = myrinfo->edegrees = ctrl->wspace.edegrees+ctrl->wspace.cdegree;
+      ctrl->wspace.cdegree += xadj[i+1]-xadj[i];
+
+      for (j=xadj[i]; j<xadj[i+1]; j++) {
+        other = where[adjncy[j]];
+        if (me != other) {
+          for (k=0; k<myrinfo->ndegrees; k++) {
+            if (myedegrees[k].pid == other) {
+              myedegrees[k].ed += adjwgt[j];
+              break;
+            }
+          }
+          if (k == myrinfo->ndegrees) {
+            myedegrees[myrinfo->ndegrees].pid = other;
+            myedegrees[myrinfo->ndegrees++].ed = adjwgt[j];
+          }
+        }
+      }
+
+      ASSERT(myrinfo->ndegrees <= xadj[i+1]-xadj[i]);
+    }
+  }
+
+  graph->mincut = mincut/2;
+  graph->nbnd = nbnd;
+
+}
+
+
+
+/*************************************************************************
+* This function projects a partition, and at the same time computes the
+* parameters for refinement.
+**************************************************************************/
+void ProjectKWayPartition(CtrlType *ctrl, GraphType *graph, int nparts)
+{
+  int i, j, k, nvtxs, nbnd, me, other, istart, iend, ndegrees;
+  idxtype *xadj, *adjncy, *adjwgt, *adjwgtsum;
+  idxtype *cmap, *where, *bndptr, *bndind;
+  idxtype *cwhere;
+  GraphType *cgraph;
+  RInfoType *crinfo, *rinfo, *myrinfo;
+  EDegreeType *myedegrees;
+  idxtype *htable;
+
+  cgraph = graph->coarser;
+  cwhere = cgraph->where;
+  crinfo = cgraph->rinfo;
+
+  nvtxs = graph->nvtxs;
+  cmap = graph->cmap;
+  xadj = graph->xadj;
+  adjncy = graph->adjncy;
+  adjwgt = graph->adjwgt;
+  adjwgtsum = graph->adjwgtsum;
+
+  AllocateKWayPartitionMemory(ctrl, graph, nparts);
+  where = graph->where;
+  rinfo = graph->rinfo;
+  bndind = graph->bndind;
+  bndptr = idxset(nvtxs, -1, graph->bndptr);
+
+  /* Go through and project partition and compute id/ed for the nodes */
+  for (i=0; i<nvtxs; i++) {
+    k = cmap[i];
+    where[i] = cwhere[k];
+    cmap[i] = crinfo[k].ed;  /* For optimization */
+  }
+
+  htable = idxset(nparts, -1, idxwspacemalloc(ctrl, nparts));
+
+  ctrl->wspace.cdegree = 0;
+  for (nbnd=0, i=0; i<nvtxs; i++) {
+    me = where[i];
+
+    myrinfo = rinfo+i;
+    myrinfo->id = myrinfo->ed = myrinfo->ndegrees = 0;
+    myrinfo->edegrees = NULL;
+
+    myrinfo->id = adjwgtsum[i];
+
+    if (cmap[i] > 0) { /* If it is an interface node. Note cmap[i] = crinfo[cmap[i]].ed */
+      istart = xadj[i];
+      iend = xadj[i+1];
+
+      myedegrees = myrinfo->edegrees = ctrl->wspace.edegrees+ctrl->wspace.cdegree;
+      ctrl->wspace.cdegree += iend-istart;
+
+      ndegrees = 0;
+      for (j=istart; j<iend; j++) {
+        other = where[adjncy[j]];
+        if (me != other) {
+          myrinfo->ed += adjwgt[j];
+          if ((k = htable[other]) == -1) {
+            htable[other] = ndegrees;
+            myedegrees[ndegrees].pid = other;
+            myedegrees[ndegrees++].ed = adjwgt[j];
+          }
+          else {
+            myedegrees[k].ed += adjwgt[j];
+          }
+        }
+      }
+      myrinfo->id -= myrinfo->ed;
+
+      /* Remove space for edegrees if it was interior */
+      if (myrinfo->ed == 0) { 
+        myrinfo->edegrees = NULL;
+        ctrl->wspace.cdegree -= iend-istart;
+      }
+      else {
+        if (myrinfo->ed-myrinfo->id >= 0) 
+          BNDInsert(nbnd, bndind, bndptr, i); 
+
+        myrinfo->ndegrees = ndegrees;
+
+        for (j=0; j<ndegrees; j++)
+          htable[myedegrees[j].pid] = -1;
+      }
+    }
+  }
+
+  idxcopy(nparts, cgraph->pwgts, graph->pwgts);
+  graph->mincut = cgraph->mincut;
+  graph->nbnd = nbnd;
+
+  FreeGraph(graph->coarser);
+  graph->coarser = NULL;
+
+  idxwspacefree(ctrl, nparts);
+
+  ASSERT(CheckBnd2(graph));
+
+}
+
+
+
+/*************************************************************************
+* This function checks if the partition weights are within the balance
+* contraints
+**************************************************************************/
+int IsBalanced(idxtype *pwgts, int nparts, float *tpwgts, float ubfactor)
+{
+  int i, j, tvwgt;
+
+  tvwgt = idxsum(nparts, pwgts);
+  for (i=0; i<nparts; i++) {
+    if (pwgts[i] > tpwgts[i]*tvwgt*(ubfactor+0.005))
+      return 0;
+  }
+
+  return 1;
+}
+
+
+/*************************************************************************
+* This function computes the boundary definition for balancing
+**************************************************************************/
+void ComputeKWayBoundary(CtrlType *ctrl, GraphType *graph, int nparts)
+{
+  int i, nvtxs, nbnd;
+  idxtype *bndind, *bndptr;
+
+  nvtxs = graph->nvtxs;
+  bndind = graph->bndind;
+  bndptr = idxset(nvtxs, -1, graph->bndptr);
+
+
+  /*------------------------------------------------------------
+  / Compute the new boundary
+  /------------------------------------------------------------*/
+  nbnd = 0;
+  for (i=0; i<nvtxs; i++) {
+    if (graph->rinfo[i].ed-graph->rinfo[i].id >= 0) 
+      BNDInsert(nbnd, bndind, bndptr, i);
+  }
+
+  graph->nbnd = nbnd;
+}
+
+/*************************************************************************
+* This function computes the boundary definition for balancing
+**************************************************************************/
+void ComputeKWayBalanceBoundary(CtrlType *ctrl, GraphType *graph, int nparts)
+{
+  int i, nvtxs, nbnd;
+  idxtype *bndind, *bndptr;
+
+  nvtxs = graph->nvtxs;
+  bndind = graph->bndind;
+  bndptr = idxset(nvtxs, -1, graph->bndptr);
+
+
+  /*------------------------------------------------------------
+  / Compute the new boundary
+  /------------------------------------------------------------*/
+  nbnd = 0;
+  for (i=0; i<nvtxs; i++) {
+    if (graph->rinfo[i].ed > 0) 
+      BNDInsert(nbnd, bndind, bndptr, i);
+  }
+
+  graph->nbnd = nbnd;
+}
+
Index: /inundation/pymetis/metis-4.0/Lib/kwayvolfm.c
===================================================================
--- /inundation/pymetis/metis-4.0/Lib/kwayvolfm.c	(revision 2051)
+++ /inundation/pymetis/metis-4.0/Lib/kwayvolfm.c	(revision 2051)
@@ -0,0 +1,1778 @@
+/*
+ * kwayvolfm.c
+ *
+ * This file contains code that implements the multilevel k-way refinement
+ *
+ * Started 7/8/98
+ * George
+ *
+ * $Id: kwayvolfm.c,v 1.1 1998/11/27 17:59:17 karypis Exp $
+ *
+ */
+
+#include <metis.h>
+
+
+/*************************************************************************
+* This function performs k-way refinement
+**************************************************************************/
+void Random_KWayVolRefine(CtrlType *ctrl, GraphType *graph, int nparts, float *tpwgts, 
+                          float ubfactor, int npasses, int ffactor)
+{
+  int i, ii, iii, j, jj, k, kk, l, u, pass, nvtxs, nmoves, tvwgt, myndegrees, xgain; 
+  int from, me, to, oldcut, oldvol, vwgt;
+  idxtype *xadj, *adjncy, *adjwgt;
+  idxtype *where, *pwgts, *perm, *bndptr, *bndind, *minwgt, *maxwgt, *itpwgts, *updind, *marker, *phtable;
+  VEDegreeType *myedegrees;
+  VRInfoType *myrinfo; 
+
+  nvtxs = graph->nvtxs;
+  xadj = graph->xadj;
+  adjncy = graph->adjncy;
+  adjwgt = graph->adjwgt;
+
+  bndptr = graph->bndptr;
+  bndind = graph->bndind;
+
+  where = graph->where;
+  pwgts = graph->pwgts;
+  
+  /* Setup the weight intervals of the various subdomains */
+  minwgt =  idxwspacemalloc(ctrl, nparts);
+  maxwgt = idxwspacemalloc(ctrl, nparts);
+  itpwgts = idxwspacemalloc(ctrl, nparts);
+  tvwgt = idxsum(nparts, pwgts);
+  ASSERT(tvwgt == idxsum(nvtxs, graph->vwgt));
+
+  updind = idxmalloc(nvtxs, "Random_KWayVolRefine: updind");
+  marker = idxsmalloc(nvtxs, 0, "Random_KWayVolRefine: marker");
+  phtable = idxsmalloc(nparts, -1, "Random_KWayVolRefine: phtable");
+
+  for (i=0; i<nparts; i++) {
+    itpwgts[i] = tpwgts[i]*tvwgt;
+    maxwgt[i] = tpwgts[i]*tvwgt*ubfactor;
+    minwgt[i] = tpwgts[i]*tvwgt*(1.0/ubfactor);
+  }
+
+  perm = idxwspacemalloc(ctrl, nvtxs);
+
+  IFSET(ctrl->dbglvl, DBG_REFINE,
+     printf("VolPart: [%5d %5d]-[%5d %5d], Balance: %3.2f, Nv-Nb[%5d %5d]. Cut: %5d, Vol: %5d\n",
+             pwgts[idxamin(nparts, pwgts)], pwgts[idxamax(nparts, pwgts)], minwgt[0], maxwgt[0], 
+             1.0*nparts*pwgts[idxamax(nparts, pwgts)]/tvwgt, graph->nvtxs, graph->nbnd,
+             graph->mincut, graph->minvol));
+
+  for (pass=0; pass<npasses; pass++) {
+    ASSERT(ComputeCut(graph, where) == graph->mincut);
+
+    oldcut = graph->mincut;
+    oldvol = graph->minvol;
+
+    RandomPermute(graph->nbnd, perm, 1);
+    for (nmoves=iii=0; iii<graph->nbnd; iii++) {
+      ii = perm[iii];
+      if (ii >= graph->nbnd)
+        continue;
+      i = bndind[ii];
+      myrinfo = graph->vrinfo+i;
+
+      if (myrinfo->gv >= 0) { /* Total volume gain is too high */
+        from = where[i];
+        vwgt = graph->vwgt[i];
+
+        if (myrinfo->id > 0 && pwgts[from]-vwgt < minwgt[from]) 
+          continue;   /* This cannot be moved! */
+
+        xgain = (myrinfo->id == 0 && myrinfo->ed > 0 ? graph->vsize[i] : 0);
+
+        myedegrees = myrinfo->edegrees;
+        myndegrees = myrinfo->ndegrees;
+
+        for (k=0; k<myndegrees; k++) {
+          to = myedegrees[k].pid;
+          if (pwgts[to]+vwgt <= maxwgt[to]+ffactor*myedegrees[k].gv && xgain+myedegrees[k].gv >= 0)  
+            break;
+        }
+        if (k == myndegrees)
+          continue;  /* break out if you did not find a candidate */
+
+        for (j=k+1; j<myndegrees; j++) {
+          to = myedegrees[j].pid;
+          if (pwgts[to]+vwgt > maxwgt[to])
+            continue;
+          if (myedegrees[j].gv > myedegrees[k].gv ||
+              (myedegrees[j].gv == myedegrees[k].gv && myedegrees[j].ed > myedegrees[k].ed) ||
+              (myedegrees[j].gv == myedegrees[k].gv && myedegrees[j].ed == myedegrees[k].ed &&
+               itpwgts[myedegrees[k].pid]*pwgts[to] < itpwgts[to]*pwgts[myedegrees[k].pid]))
+            k = j;
+        }
+
+        to = myedegrees[k].pid;
+
+        j = 0;
+        if (xgain+myedegrees[k].gv > 0 || myedegrees[k].ed-myrinfo->id > 0)
+          j = 1;
+        else if (myedegrees[k].ed-myrinfo->id == 0) {
+          if ((iii&5) == 0 || pwgts[from] >= maxwgt[from] || itpwgts[from]*(pwgts[to]+vwgt) < itpwgts[to]*pwgts[from])
+            j = 1;
+        }
+        if (j == 0)
+          continue;
+          
+        /*=====================================================================
+        * If we got here, we can now move the vertex from 'from' to 'to' 
+        *======================================================================*/
+        INC_DEC(pwgts[to], pwgts[from], vwgt);
+        graph->mincut -= myedegrees[k].ed-myrinfo->id;
+        graph->minvol -= (xgain+myedegrees[k].gv);
+        where[i] = to;
+
+        IFSET(ctrl->dbglvl, DBG_MOVEINFO, printf("\t\tMoving %6d from %3d to %3d. Gain: [%4d %4d]. Cut: %6d, Vol: %6d\n", 
+              i, from, to, xgain+myedegrees[k].gv, myedegrees[k].ed-myrinfo->id, graph->mincut, graph->minvol));
+
+        KWayVolUpdate(ctrl, graph, i, from, to, marker, phtable, updind);
+
+        nmoves++;
+
+        /* CheckVolKWayPartitionParams(ctrl, graph, nparts); */
+      }
+    }
+
+    IFSET(ctrl->dbglvl, DBG_REFINE,
+       printf("\t[%6d %6d], Balance: %5.3f, Nb: %6d. Nmoves: %5d, Cut: %6d, Vol: %6d\n",
+               pwgts[idxamin(nparts, pwgts)], pwgts[idxamax(nparts, pwgts)],
+               1.0*nparts*pwgts[idxamax(nparts, pwgts)]/tvwgt, graph->nbnd, nmoves, graph->mincut, 
+               graph->minvol));
+
+    if (graph->minvol == oldvol && graph->mincut == oldcut)
+      break;
+  }
+
+  GKfree(&marker, &updind, &phtable, LTERM);
+
+  idxwspacefree(ctrl, nparts);
+  idxwspacefree(ctrl, nparts);
+  idxwspacefree(ctrl, nparts);
+  idxwspacefree(ctrl, nvtxs);
+}
+
+
+/*************************************************************************
+* This function performs k-way refinement
+**************************************************************************/
+void Random_KWayVolRefineMConn(CtrlType *ctrl, GraphType *graph, int nparts, float *tpwgts, 
+            float ubfactor, int npasses, int ffactor)
+{
+  int i, ii, iii, j, jj, k, kk, l, u, pass, nvtxs, nmoves, tvwgt, myndegrees, xgain; 
+  int from, me, to, oldcut, oldvol, vwgt, nadd, maxndoms;
+  idxtype *xadj, *adjncy, *adjwgt;
+  idxtype *where, *pwgts, *perm, *bndptr, *bndind, *minwgt, *maxwgt, *itpwgts, *updind, *marker, *phtable;
+  idxtype *pmat, *pmatptr, *ndoms;
+  VEDegreeType *myedegrees;
+  VRInfoType *myrinfo; 
+
+  nvtxs = graph->nvtxs;
+  xadj = graph->xadj;
+  adjncy = graph->adjncy;
+  adjwgt = graph->adjwgt;
+
+  bndptr = graph->bndptr;
+  bndind = graph->bndind;
+
+  where = graph->where;
+  pwgts = graph->pwgts;
+  
+  /* Setup the weight intervals of the various subdomains */
+  minwgt =  idxwspacemalloc(ctrl, nparts);
+  maxwgt = idxwspacemalloc(ctrl, nparts);
+  itpwgts = idxwspacemalloc(ctrl, nparts);
+  tvwgt = idxsum(nparts, pwgts);
+  ASSERT(tvwgt == idxsum(nvtxs, graph->vwgt));
+
+  updind = idxmalloc(nvtxs, "Random_KWayVolRefine: updind");
+  marker = idxsmalloc(nvtxs, 0, "Random_KWayVolRefine: marker");
+  phtable = idxsmalloc(nparts, -1, "Random_KWayVolRefine: phtable");
+
+  pmat = ctrl->wspace.pmat;
+  ndoms = idxwspacemalloc(ctrl, nparts);
+
+  ComputeVolSubDomainGraph(graph, nparts, pmat, ndoms);
+
+  for (i=0; i<nparts; i++) {
+    itpwgts[i] = tpwgts[i]*tvwgt;
+    maxwgt[i] = tpwgts[i]*tvwgt*ubfactor;
+    minwgt[i] = tpwgts[i]*tvwgt*(1.0/ubfactor);
+  }
+
+  perm = idxwspacemalloc(ctrl, nvtxs);
+
+  IFSET(ctrl->dbglvl, DBG_REFINE,
+     printf("VolPart: [%5d %5d]-[%5d %5d], Balance: %3.2f, Nv-Nb[%5d %5d]. Cut: %5d, Vol: %5d\n",
+             pwgts[idxamin(nparts, pwgts)], pwgts[idxamax(nparts, pwgts)], minwgt[0], maxwgt[0], 
+             1.0*nparts*pwgts[idxamax(nparts, pwgts)]/tvwgt, graph->nvtxs, graph->nbnd,
+             graph->mincut, graph->minvol));
+
+  for (pass=0; pass<npasses; pass++) {
+    ASSERT(ComputeCut(graph, where) == graph->mincut);
+
+    maxndoms = ndoms[idxamax(nparts, ndoms)];
+
+    oldcut = graph->mincut;
+    oldvol = graph->minvol;
+
+    RandomPermute(graph->nbnd, perm, 1);
+    for (nmoves=iii=0; iii<graph->nbnd; iii++) {
+      ii = perm[iii];
+      if (ii >= graph->nbnd)
+        continue;
+      i = bndind[ii];
+      myrinfo = graph->vrinfo+i;
+
+      if (myrinfo->gv >= 0) { /* Total volume gain is too high */
+        from = where[i];
+        vwgt = graph->vwgt[i];
+
+        if (myrinfo->id > 0 && pwgts[from]-vwgt < minwgt[from]) 
+          continue;   /* This cannot be moved! */
+
+        xgain = (myrinfo->id == 0 && myrinfo->ed > 0 ? graph->vsize[i] : 0);
+
+        myedegrees = myrinfo->edegrees;
+        myndegrees = myrinfo->ndegrees;
+
+        /* Determine the valid domains */
+        for (j=0; j<myndegrees; j++) {
+          to = myedegrees[j].pid;
+          phtable[to] = 1;
+          pmatptr = pmat + to*nparts;
+          for (nadd=0, k=0; k<myndegrees; k++) {
+            if (k == j)
+              continue;
+
+            l = myedegrees[k].pid;
+            if (pmatptr[l] == 0) {
+              if (ndoms[l] > maxndoms-1) {
+                phtable[to] = 0;
+                nadd = maxndoms;
+                break;
+              }
+              nadd++;
+            }
+          }
+          if (ndoms[to]+nadd > maxndoms)
+            phtable[to] = 0;
+          if (nadd == 0)
+            phtable[to] = 2;
+        }
+
+        for (k=0; k<myndegrees; k++) {
+          to = myedegrees[k].pid;
+          if (!phtable[to])
+            continue;
+          if (pwgts[to]+vwgt <= maxwgt[to]+ffactor*myedegrees[k].gv && xgain+myedegrees[k].gv >= 0)  
+            break;
+        }
+        if (k == myndegrees)
+          continue;  /* break out if you did not find a candidate */
+
+        for (j=k+1; j<myndegrees; j++) {
+          to = myedegrees[j].pid;
+          if (!phtable[to] || pwgts[to]+vwgt > maxwgt[to])
+            continue;
+          if (myedegrees[j].gv > myedegrees[k].gv ||
+              (myedegrees[j].gv == myedegrees[k].gv && myedegrees[j].ed > myedegrees[k].ed) ||
+              (myedegrees[j].gv == myedegrees[k].gv && myedegrees[j].ed == myedegrees[k].ed &&
+               itpwgts[myedegrees[k].pid]*pwgts[to] < itpwgts[to]*pwgts[myedegrees[k].pid]))
+            k = j;
+        }
+
+        to = myedegrees[k].pid;
+
+        j = 0;
+        if (xgain+myedegrees[k].gv > 0 || myedegrees[k].ed-myrinfo->id > 0)
+          j = 1;
+        else if (myedegrees[k].ed-myrinfo->id == 0) {
+          if ((iii&5) == 0 || phtable[myedegrees[k].pid] == 2 || pwgts[from] >= maxwgt[from] || itpwgts[from]*(pwgts[to]+vwgt) < itpwgts[to]*pwgts[from])
+            j = 1;
+        }
+
+        if (j == 0)
+          continue;
+
+        for (j=0; j<myndegrees; j++) 
+          phtable[myedegrees[j].pid] = -1;
+
+          
+        /*=====================================================================
+        * If we got here, we can now move the vertex from 'from' to 'to' 
+        *======================================================================*/
+        INC_DEC(pwgts[to], pwgts[from], vwgt);
+        graph->mincut -= myedegrees[k].ed-myrinfo->id;
+        graph->minvol -= (xgain+myedegrees[k].gv);
+        where[i] = to;
+
+        IFSET(ctrl->dbglvl, DBG_MOVEINFO, printf("\t\tMoving %6d from %3d to %3d. Gain: [%4d %4d]. Cut: %6d, Vol: %6d\n", 
+              i, from, to, xgain+myedegrees[k].gv, myedegrees[k].ed-myrinfo->id, graph->mincut, graph->minvol));
+
+        /* Update pmat to reflect the move of 'i' */
+        pmat[from*nparts+to] += (myrinfo->id-myedegrees[k].ed);
+        pmat[to*nparts+from] += (myrinfo->id-myedegrees[k].ed);
+        if (pmat[from*nparts+to] == 0) {
+          ndoms[from]--;
+          if (ndoms[from]+1 == maxndoms)
+            maxndoms = ndoms[idxamax(nparts, ndoms)];
+        }
+        if (pmat[to*nparts+from] == 0) {
+          ndoms[to]--;
+          if (ndoms[to]+1 == maxndoms)
+            maxndoms = ndoms[idxamax(nparts, ndoms)];
+        }
+
+        for (j=xadj[i]; j<xadj[i+1]; j++) {
+          ii = adjncy[j];
+          me = where[ii];
+
+          /* Update pmat to reflect the move of 'i' for domains other than 'from' and 'to' */
+          if (me != from && me != to) {
+            pmat[me*nparts+from] -= adjwgt[j];
+            pmat[from*nparts+me] -= adjwgt[j];
+            if (pmat[me*nparts+from] == 0) {
+              ndoms[me]--;
+              if (ndoms[me]+1 == maxndoms)
+                maxndoms = ndoms[idxamax(nparts, ndoms)];
+            }
+            if (pmat[from*nparts+me] == 0) {
+              ndoms[from]--;
+              if (ndoms[from]+1 == maxndoms)
+                maxndoms = ndoms[idxamax(nparts, ndoms)];
+            }
+
+            if (pmat[me*nparts+to] == 0) {
+              ndoms[me]++;
+              if (ndoms[me] > maxndoms) {
+                printf("You just increased the maxndoms: %d %d\n", ndoms[me], maxndoms);
+                maxndoms = ndoms[me];
+              }
+            }
+            if (pmat[to*nparts+me] == 0) {
+              ndoms[to]++;
+              if (ndoms[to] > maxndoms) {
+                printf("You just increased the maxndoms: %d %d\n", ndoms[to], maxndoms);
+                maxndoms = ndoms[to];
+              }
+            }
+            pmat[me*nparts+to] += adjwgt[j];
+            pmat[to*nparts+me] += adjwgt[j];
+          }
+        }
+
+        KWayVolUpdate(ctrl, graph, i, from, to, marker, phtable, updind);
+
+        nmoves++;
+
+        /* CheckVolKWayPartitionParams(ctrl, graph, nparts); */
+      }
+    }
+
+    IFSET(ctrl->dbglvl, DBG_REFINE,
+       printf("\t[%6d %6d], Balance: %5.3f, Nb: %6d. Nmoves: %5d, Cut: %6d, Vol: %6d\n",
+               pwgts[idxamin(nparts, pwgts)], pwgts[idxamax(nparts, pwgts)],
+               1.0*nparts*pwgts[idxamax(nparts, pwgts)]/tvwgt, graph->nbnd, nmoves, graph->mincut, 
+               graph->minvol));
+
+    if (graph->minvol == oldvol && graph->mincut == oldcut)
+      break;
+  }
+
+  GKfree(&marker, &updind, &phtable, LTERM);
+
+  idxwspacefree(ctrl, nparts);
+  idxwspacefree(ctrl, nparts);
+  idxwspacefree(ctrl, nparts);
+  idxwspacefree(ctrl, nparts);
+  idxwspacefree(ctrl, nvtxs);
+}
+
+
+
+
+/*************************************************************************
+* This function performs k-way refinement
+**************************************************************************/
+void Greedy_KWayVolBalance(CtrlType *ctrl, GraphType *graph, int nparts, float *tpwgts, 
+                           float ubfactor, int npasses)
+{
+  int i, ii, iii, j, jj, k, kk, l, u, pass, nvtxs, nmoves, tvwgt, myndegrees, xgain; 
+  int from, me, to, vwgt, gain;
+  idxtype *xadj, *adjncy, *adjwgt;
+  idxtype *where, *pwgts, *perm, *moved, *bndptr, *bndind, *minwgt, *maxwgt, *itpwgts, *updind, *marker, *phtable;
+  VEDegreeType *myedegrees;
+  VRInfoType *myrinfo; 
+  PQueueType queue;
+
+  nvtxs = graph->nvtxs;
+  xadj = graph->xadj;
+  adjncy = graph->adjncy;
+  adjwgt = graph->adjwgt;
+
+  bndptr = graph->bndptr;
+  bndind = graph->bndind;
+
+  where = graph->where;
+  pwgts = graph->pwgts;
+  
+  /* Setup the weight intervals of the various subdomains */
+  minwgt =  idxwspacemalloc(ctrl, nparts);
+  maxwgt = idxwspacemalloc(ctrl, nparts);
+  itpwgts = idxwspacemalloc(ctrl, nparts);
+  tvwgt = idxsum(nparts, pwgts);
+  ASSERT(tvwgt == idxsum(nvtxs, graph->vwgt));
+
+  updind = idxmalloc(nvtxs, "Random_KWayVolRefine: updind");
+  marker = idxsmalloc(nvtxs, 0, "Random_KWayVolRefine: marker");
+  phtable = idxsmalloc(nparts, -1, "Random_KWayVolRefine: phtable");
+
+  for (i=0; i<nparts; i++) {
+    itpwgts[i] = tpwgts[i]*tvwgt;
+    maxwgt[i] = tpwgts[i]*tvwgt*ubfactor;
+    minwgt[i] = tpwgts[i]*tvwgt*(1.0/ubfactor);
+  }
+
+  perm = idxwspacemalloc(ctrl, nvtxs);
+  moved = idxwspacemalloc(ctrl, nvtxs);
+
+  PQueueInit(ctrl, &queue, nvtxs, graph->adjwgtsum[idxamax(nvtxs, graph->adjwgtsum)]);
+
+  IFSET(ctrl->dbglvl, DBG_REFINE,
+     printf("VolPart: [%5d %5d]-[%5d %5d], Balance: %3.2f, Nv-Nb[%5d %5d]. Cut: %5d, Vol: %5d [B]\n",
+             pwgts[idxamin(nparts, pwgts)], pwgts[idxamax(nparts, pwgts)], minwgt[0], maxwgt[0], 
+             1.0*nparts*pwgts[idxamax(nparts, pwgts)]/tvwgt, graph->nvtxs, graph->nbnd,
+             graph->mincut, graph->minvol));
+
+
+  for (pass=0; pass<npasses; pass++) {
+    ASSERT(ComputeCut(graph, where) == graph->mincut);
+    /* Check to see if things are out of balance, given the tolerance */
+    for (i=0; i<nparts; i++) {
+      if (pwgts[i] > maxwgt[i])
+        break;
+    }
+    if (i == nparts) /* Things are balanced. Return right away */
+      break;
+
+    PQueueReset(&queue);
+    idxset(nvtxs, -1, moved);
+
+    RandomPermute(graph->nbnd, perm, 1);
+    for (ii=0; ii<graph->nbnd; ii++) {
+      i = bndind[perm[ii]];
+      PQueueInsert(&queue, i, graph->vrinfo[i].gv);
+      moved[i] = 2;
+    }
+
+    for (nmoves=0;;) {
+      if ((i = PQueueGetMax(&queue)) == -1) 
+        break;
+      moved[i] = 1;
+
+      myrinfo = graph->vrinfo+i;
+      from = where[i];
+      vwgt = graph->vwgt[i];
+
+      if (pwgts[from]-vwgt < minwgt[from]) 
+        continue;   /* This cannot be moved! */
+
+      xgain = (myrinfo->id == 0 && myrinfo->ed > 0 ? graph->vsize[i] : 0);
+
+      myedegrees = myrinfo->edegrees;
+      myndegrees = myrinfo->ndegrees;
+
+      for (k=0; k<myndegrees; k++) {
+        to = myedegrees[k].pid;
+        if (pwgts[to]+vwgt <= maxwgt[to] || 
+            itpwgts[from]*(pwgts[to]+vwgt) <= itpwgts[to]*pwgts[from]) 
+          break;
+      }
+      if (k == myndegrees)
+        continue;  /* break out if you did not find a candidate */
+
+      for (j=k+1; j<myndegrees; j++) {
+        to = myedegrees[j].pid;
+        if (itpwgts[myedegrees[k].pid]*pwgts[to] < itpwgts[to]*pwgts[myedegrees[k].pid]) 
+          k = j;
+      }
+
+      to = myedegrees[k].pid;
+
+      if (pwgts[from] < maxwgt[from] && pwgts[to] > minwgt[to] && 
+          (xgain+myedegrees[k].gv < 0 || 
+           (xgain+myedegrees[k].gv == 0 &&  myedegrees[k].ed-myrinfo->id < 0))
+         )
+        continue;
+  
+
+      /*=====================================================================
+      * If we got here, we can now move the vertex from 'from' to 'to' 
+      *======================================================================*/
+      INC_DEC(pwgts[to], pwgts[from], vwgt);
+      graph->mincut -= myedegrees[k].ed-myrinfo->id;
+      graph->minvol -= (xgain+myedegrees[k].gv);
+      where[i] = to;
+
+      IFSET(ctrl->dbglvl, DBG_MOVEINFO, printf("\t\tMoving %6d from %3d to %3d. Gain: [%4d %4d]. Cut: %6d, Vol: %6d\n", 
+            i, from, to, xgain+myedegrees[k].gv, myedegrees[k].ed-myrinfo->id, graph->mincut, graph->minvol));
+
+      KWayVolUpdate(ctrl, graph, i, from, to, marker, phtable, updind);
+
+      nmoves++;
+
+      /*CheckVolKWayPartitionParams(ctrl, graph, nparts); */
+    }
+
+    IFSET(ctrl->dbglvl, DBG_REFINE,
+       printf("\t[%6d %6d], Balance: %5.3f, Nb: %6d. Nmoves: %5d, Cut: %6d, Vol: %6d\n",
+               pwgts[idxamin(nparts, pwgts)], pwgts[idxamax(nparts, pwgts)],
+               1.0*nparts*pwgts[idxamax(nparts, pwgts)]/tvwgt, graph->nbnd, nmoves, graph->mincut, 
+               graph->minvol));
+
+  }
+
+  GKfree(&marker, &updind, &phtable, LTERM);
+
+  PQueueFree(ctrl, &queue);
+
+  idxwspacefree(ctrl, nparts);
+  idxwspacefree(ctrl, nparts);
+  idxwspacefree(ctrl, nparts);
+  idxwspacefree(ctrl, nvtxs);
+  idxwspacefree(ctrl, nvtxs);
+}
+
+
+
+/*************************************************************************
+* This function performs k-way refinement
+**************************************************************************/
+void Greedy_KWayVolBalanceMConn(CtrlType *ctrl, GraphType *graph, int nparts, float *tpwgts, 
+                                float ubfactor, int npasses)
+{
+  int i, ii, iii, j, jj, k, kk, l, u, pass, nvtxs, nmoves, tvwgt, myndegrees, xgain; 
+  int from, me, to, vwgt, gain, maxndoms, nadd;
+  idxtype *xadj, *adjncy, *adjwgt;
+  idxtype *where, *pwgts, *perm, *moved, *bndptr, *bndind, *minwgt, *maxwgt, *itpwgts, *updind, *marker, *phtable;
+  idxtype *pmat, *pmatptr, *ndoms;
+  VEDegreeType *myedegrees;
+  VRInfoType *myrinfo; 
+  PQueueType queue;
+
+  nvtxs = graph->nvtxs;
+  xadj = graph->xadj;
+  adjncy = graph->adjncy;
+  adjwgt = graph->adjwgt;
+
+  bndptr = graph->bndptr;
+  bndind = graph->bndind;
+
+  where = graph->where;
+  pwgts = graph->pwgts;
+  
+  /* Setup the weight intervals of the various subdomains */
+  minwgt =  idxwspacemalloc(ctrl, nparts);
+  maxwgt = idxwspacemalloc(ctrl, nparts);
+  itpwgts = idxwspacemalloc(ctrl, nparts);
+  tvwgt = idxsum(nparts, pwgts);
+  ASSERT(tvwgt == idxsum(nvtxs, graph->vwgt));
+
+  updind = idxmalloc(nvtxs, "Random_KWayVolRefine: updind");
+  marker = idxsmalloc(nvtxs, 0, "Random_KWayVolRefine: marker");
+  phtable = idxsmalloc(nparts, -1, "Random_KWayVolRefine: phtable");
+
+  pmat = ctrl->wspace.pmat;
+  ndoms = idxwspacemalloc(ctrl, nparts);
+
+  ComputeVolSubDomainGraph(graph, nparts, pmat, ndoms);
+
+  for (i=0; i<nparts; i++) {
+    itpwgts[i] = tpwgts[i]*tvwgt;
+    maxwgt[i] = tpwgts[i]*tvwgt*ubfactor;
+    minwgt[i] = tpwgts[i]*tvwgt*(1.0/ubfactor);
+  }
+
+  perm = idxwspacemalloc(ctrl, nvtxs);
+  moved = idxwspacemalloc(ctrl, nvtxs);
+
+  PQueueInit(ctrl, &queue, nvtxs, graph->adjwgtsum[idxamax(nvtxs, graph->adjwgtsum)]);
+
+  IFSET(ctrl->dbglvl, DBG_REFINE,
+     printf("VolPart: [%5d %5d]-[%5d %5d], Balance: %3.2f, Nv-Nb[%5d %5d]. Cut: %5d, Vol: %5d [B]\n",
+             pwgts[idxamin(nparts, pwgts)], pwgts[idxamax(nparts, pwgts)], minwgt[0], maxwgt[0], 
+             1.0*nparts*pwgts[idxamax(nparts, pwgts)]/tvwgt, graph->nvtxs, graph->nbnd,
+             graph->mincut, graph->minvol));
+
+
+  for (pass=0; pass<npasses; pass++) {
+    ASSERT(ComputeCut(graph, where) == graph->mincut);
+    /* Check to see if things are out of balance, given the tolerance */
+    for (i=0; i<nparts; i++) {
+      if (pwgts[i] > maxwgt[i])
+        break;
+    }
+    if (i == nparts) /* Things are balanced. Return right away */
+      break;
+
+    PQueueReset(&queue);
+    idxset(nvtxs, -1, moved);
+
+    RandomPermute(graph->nbnd, perm, 1);
+    for (ii=0; ii<graph->nbnd; ii++) {
+      i = bndind[perm[ii]];
+      PQueueInsert(&queue, i, graph->vrinfo[i].gv);
+      moved[i] = 2;
+    }
+
+    maxndoms = ndoms[idxamax(nparts, ndoms)];
+
+    for (nmoves=0;;) {
+      if ((i = PQueueGetMax(&queue)) == -1) 
+        break;
+      moved[i] = 1;
+
+      myrinfo = graph->vrinfo+i;
+      from = where[i];
+      vwgt = graph->vwgt[i];
+
+      if (pwgts[from]-vwgt < minwgt[from]) 
+        continue;   /* This cannot be moved! */
+
+      xgain = (myrinfo->id == 0 && myrinfo->ed > 0 ? graph->vsize[i] : 0);
+
+      myedegrees = myrinfo->edegrees;
+      myndegrees = myrinfo->ndegrees;
+
+      /* Determine the valid domains */
+      for (j=0; j<myndegrees; j++) {
+        to = myedegrees[j].pid;
+        phtable[to] = 1;
+        pmatptr = pmat + to*nparts;
+        for (nadd=0, k=0; k<myndegrees; k++) {
+          if (k == j)
+            continue;
+
+          l = myedegrees[k].pid;
+          if (pmatptr[l] == 0) {
+            if (ndoms[l] > maxndoms-1) {
+              phtable[to] = 0;
+              nadd = maxndoms;
+              break;
+            }
+            nadd++;
+          }
+        }
+        if (ndoms[to]+nadd > maxndoms)
+          phtable[to] = 0;
+      }
+
+      for (k=0; k<myndegrees; k++) {
+        to = myedegrees[k].pid;
+        if (!phtable[to])
+          continue;
+        if (pwgts[to]+vwgt <= maxwgt[to] || 
+            itpwgts[from]*(pwgts[to]+vwgt) <= itpwgts[to]*pwgts[from]) 
+          break;
+      }
+      if (k == myndegrees)
+        continue;  /* break out if you did not find a candidate */
+
+      for (j=k+1; j<myndegrees; j++) {
+        to = myedegrees[j].pid;
+        if (!phtable[to])
+          continue;
+        if (itpwgts[myedegrees[k].pid]*pwgts[to] < itpwgts[to]*pwgts[myedegrees[k].pid]) 
+          k = j;
+      }
+
+      to = myedegrees[k].pid;
+
+      for (j=0; j<myndegrees; j++) 
+        phtable[myedegrees[j].pid] = -1;
+
+      if (pwgts[from] < maxwgt[from] && pwgts[to] > minwgt[to] && 
+          (xgain+myedegrees[k].gv < 0 || 
+           (xgain+myedegrees[k].gv == 0 &&  myedegrees[k].ed-myrinfo->id < 0))
+         )
+        continue;
+  
+
+      /*=====================================================================
+      * If we got here, we can now move the vertex from 'from' to 'to' 
+      *======================================================================*/
+      INC_DEC(pwgts[to], pwgts[from], vwgt);
+      graph->mincut -= myedegrees[k].ed-myrinfo->id;
+      graph->minvol -= (xgain+myedegrees[k].gv);
+      where[i] = to;
+
+      IFSET(ctrl->dbglvl, DBG_MOVEINFO, printf("\t\tMoving %6d from %3d to %3d. Gain: [%4d %4d]. Cut: %6d, Vol: %6d\n", 
+            i, from, to, xgain+myedegrees[k].gv, myedegrees[k].ed-myrinfo->id, graph->mincut, graph->minvol));
+
+      /* Update pmat to reflect the move of 'i' */
+      pmat[from*nparts+to] += (myrinfo->id-myedegrees[k].ed);
+      pmat[to*nparts+from] += (myrinfo->id-myedegrees[k].ed);
+      if (pmat[from*nparts+to] == 0) {
+        ndoms[from]--;
+        if (ndoms[from]+1 == maxndoms)
+          maxndoms = ndoms[idxamax(nparts, ndoms)];
+      }
+      if (pmat[to*nparts+from] == 0) {
+        ndoms[to]--;
+        if (ndoms[to]+1 == maxndoms)
+          maxndoms = ndoms[idxamax(nparts, ndoms)];
+      }
+
+      for (j=xadj[i]; j<xadj[i+1]; j++) {
+        ii = adjncy[j];
+        me = where[ii];
+
+        /* Update pmat to reflect the move of 'i' for domains other than 'from' and 'to' */
+        if (me != from && me != to) {
+          pmat[me*nparts+from] -= adjwgt[j];
+          pmat[from*nparts+me] -= adjwgt[j];
+          if (pmat[me*nparts+from] == 0) {
+            ndoms[me]--;
+            if (ndoms[me]+1 == maxndoms)
+              maxndoms = ndoms[idxamax(nparts, ndoms)];
+          }
+          if (pmat[from*nparts+me] == 0) {
+            ndoms[from]--;
+            if (ndoms[from]+1 == maxndoms)
+              maxndoms = ndoms[idxamax(nparts, ndoms)];
+          }
+
+          if (pmat[me*nparts+to] == 0) {
+            ndoms[me]++;
+            if (ndoms[me] > maxndoms) {
+              printf("You just increased the maxndoms: %d %d\n", ndoms[me], maxndoms);
+              maxndoms = ndoms[me];
+            }
+          }
+          if (pmat[to*nparts+me] == 0) {
+            ndoms[to]++;
+            if (ndoms[to] > maxndoms) {
+              printf("You just increased the maxndoms: %d %d\n", ndoms[to], maxndoms);
+              maxndoms = ndoms[to];
+            }
+          }
+          pmat[me*nparts+to] += adjwgt[j];
+          pmat[to*nparts+me] += adjwgt[j];
+        }
+      }
+
+      KWayVolUpdate(ctrl, graph, i, from, to, marker, phtable, updind);
+
+      nmoves++;
+
+      /*CheckVolKWayPartitionParams(ctrl, graph, nparts); */
+    }
+
+    IFSET(ctrl->dbglvl, DBG_REFINE,
+       printf("\t[%6d %6d], Balance: %5.3f, Nb: %6d. Nmoves: %5d, Cut: %6d, Vol: %6d\n",
+               pwgts[idxamin(nparts, pwgts)], pwgts[idxamax(nparts, pwgts)],
+               1.0*nparts*pwgts[idxamax(nparts, pwgts)]/tvwgt, graph->nbnd, nmoves, graph->mincut, 
+               graph->minvol));
+
+  }
+
+  GKfree(&marker, &updind, &phtable, LTERM);
+
+  PQueueFree(ctrl, &queue);
+
+  idxwspacefree(ctrl, nparts);
+  idxwspacefree(ctrl, nparts);
+  idxwspacefree(ctrl, nparts);
+  idxwspacefree(ctrl, nparts);
+  idxwspacefree(ctrl, nvtxs);
+  idxwspacefree(ctrl, nvtxs);
+}
+
+
+
+
+/*************************************************************************
+* This function updates the edge and volume gains as a result of moving
+* v from 'from' to 'to'.
+* The working arrays marker and phtable are assumed to be initialized to
+* -1, and they left to -1 upon return
+**************************************************************************/
+void KWayVolUpdate(CtrlType *ctrl, GraphType *graph, int v, int from, int to,
+                   idxtype *marker, idxtype *phtable, idxtype *updind)
+{
+  int ii, iii, j, jj, k, kk, l, u, nupd, other, me, myidx; 
+  idxtype *xadj, *vsize, *adjncy, *adjwgt, *where;
+  VEDegreeType *myedegrees, *oedegrees;
+  VRInfoType *myrinfo, *orinfo;
+
+  xadj = graph->xadj;
+  adjncy = graph->adjncy;
+  adjwgt = graph->adjwgt;
+  vsize = graph->vsize;
+  where = graph->where;
+
+  myrinfo = graph->vrinfo+v;
+  myedegrees = myrinfo->edegrees;
+
+
+  /*======================================================================
+   * Remove the contributions on the gain made by 'v'. 
+   *=====================================================================*/
+  for (k=0; k<myrinfo->ndegrees; k++)
+    phtable[myedegrees[k].pid] = k;
+  phtable[from] = k;
+
+  myidx = phtable[to];  /* Keep track of the index in myedegrees of the 'to' domain */
+
+  for (j=xadj[v]; j<xadj[v+1]; j++) {
+    ii = adjncy[j];
+    other = where[ii];
+    orinfo = graph->vrinfo+ii;
+    oedegrees = orinfo->edegrees;
+
+    if (other == from) {
+      for (k=0; k<orinfo->ndegrees; k++) {
+        if (phtable[oedegrees[k].pid] == -1) 
+          oedegrees[k].gv += vsize[v];
+      }
+    }
+    else {
+      ASSERT(phtable[other] != -1);
+
+      if (myedegrees[phtable[other]].ned > 1) {
+        for (k=0; k<orinfo->ndegrees; k++) {
+          if (phtable[oedegrees[k].pid] == -1) 
+            oedegrees[k].gv += vsize[v];
+        }
+      }
+      else { /* There is only one connection */
+        for (k=0; k<orinfo->ndegrees; k++) {
+          if (phtable[oedegrees[k].pid] != -1) 
+            oedegrees[k].gv -= vsize[v];
+        }
+      }
+    }
+  }
+
+  for (k=0; k<myrinfo->ndegrees; k++)
+    phtable[myedegrees[k].pid] = -1;
+  phtable[from] = -1;
+
+
+  /*======================================================================
+   * Update the id/ed of vertex 'v'
+   *=====================================================================*/
+  myrinfo->ed += myrinfo->id-myedegrees[myidx].ed;
+  SWAP(myrinfo->id, myedegrees[myidx].ed, j);
+  SWAP(myrinfo->nid, myedegrees[myidx].ned, j);
+  if (myedegrees[myidx].ed == 0) 
+    myedegrees[myidx] = myedegrees[--myrinfo->ndegrees];
+  else
+    myedegrees[myidx].pid = from;
+
+  /*======================================================================
+   * Update the degrees of adjacent vertices and their volume gains
+   *=====================================================================*/
+  marker[v] = 1;
+  updind[0] = v;
+  nupd = 1;
+  for (j=xadj[v]; j<xadj[v+1]; j++) {
+    ii = adjncy[j];
+    me = where[ii];
+
+    if (!marker[ii]) {  /* The marking is done for boundary and max gv calculations */
+      marker[ii] = 2;
+      updind[nupd++] = ii;
+    }
+
+    myrinfo = graph->vrinfo+ii;
+    if (myrinfo->edegrees == NULL) {
+      myrinfo->edegrees = ctrl->wspace.vedegrees+ctrl->wspace.cdegree;
+      ctrl->wspace.cdegree += xadj[ii+1]-xadj[ii];
+    }
+    myedegrees = myrinfo->edegrees;
+
+    if (me == from) {
+      INC_DEC(myrinfo->ed, myrinfo->id, adjwgt[j]);
+      myrinfo->nid--;
+    } 
+    else if (me == to) {
+      INC_DEC(myrinfo->id, myrinfo->ed, adjwgt[j]);
+      myrinfo->nid++;
+    }
+
+    /* Remove the edgeweight from the 'pid == from' entry of the vertex */
+    if (me != from) {
+      for (k=0; k<myrinfo->ndegrees; k++) {
+        if (myedegrees[k].pid == from) {
+          if (myedegrees[k].ned == 1) {
+            myedegrees[k] = myedegrees[--myrinfo->ndegrees];
+            marker[ii] = 1;  /* You do a complete .gv calculation */
+
+            /* All vertices adjacent to 'ii' need to be updated */
+            for (jj=xadj[ii]; jj<xadj[ii+1]; jj++) {
+              u = adjncy[jj];
+              other = where[u];
+              orinfo = graph->vrinfo+u;
+              oedegrees = orinfo->edegrees;
+
+              for (kk=0; kk<orinfo->ndegrees; kk++) {
+                if (oedegrees[kk].pid == from) {
+                  oedegrees[kk].gv -= vsize[ii];
+                  break;
+                }
+              }
+            }
+          }
+          else {
+            myedegrees[k].ed -= adjwgt[j];
+            myedegrees[k].ned--;
+
+            /* Update the gv due to single 'ii' connection to 'from' */
+            if (myedegrees[k].ned == 1) {
+              /* find the vertex 'u' that 'ii' was connected into 'from' */
+              for (jj=xadj[ii]; jj<xadj[ii+1]; jj++) {
+                u = adjncy[jj];
+                other = where[u];
+                orinfo = graph->vrinfo+u;
+                oedegrees = orinfo->edegrees;
+
+                if (other == from) {
+                  for (kk=0; kk<orinfo->ndegrees; kk++) 
+                    oedegrees[kk].gv += vsize[ii];
+                  break;  
+                }
+              }
+            }
+          }
+
+          break; 
+        }
+      }
+    }
+
+    /* Add the edgeweight to the 'pid == to' entry of the vertex */
+    if (me != to) {
+      for (k=0; k<myrinfo->ndegrees; k++) {
+        if (myedegrees[k].pid == to) {
+          myedegrees[k].ed += adjwgt[j];
+          myedegrees[k].ned++;
+
+          /* Update the gv due to non-single 'ii' connection to 'to' */
+          if (myedegrees[k].ned == 2) {
+            /* find the vertex 'u' that 'ii' was connected into 'to' */
+            for (jj=xadj[ii]; jj<xadj[ii+1]; jj++) {
+              u = adjncy[jj];
+              other = where[u];
+              orinfo = graph->vrinfo+u;
+              oedegrees = orinfo->edegrees;
+
+              if (u != v && other == to) {
+                for (kk=0; kk<orinfo->ndegrees; kk++) 
+                  oedegrees[kk].gv -= vsize[ii];
+                break;  
+              }
+            }
+          }
+          break;
+        }
+      }
+
+      if (k == myrinfo->ndegrees) {
+        myedegrees[myrinfo->ndegrees].pid = to;
+        myedegrees[myrinfo->ndegrees].ed = adjwgt[j];
+        myedegrees[myrinfo->ndegrees++].ned = 1;
+        marker[ii] = 1;  /* You do a complete .gv calculation */
+
+        /* All vertices adjacent to 'ii' need to be updated */
+        for (jj=xadj[ii]; jj<xadj[ii+1]; jj++) {
+          u = adjncy[jj];
+          other = where[u];
+          orinfo = graph->vrinfo+u;
+          oedegrees = orinfo->edegrees;
+
+          for (kk=0; kk<orinfo->ndegrees; kk++) {
+            if (oedegrees[kk].pid == to) {
+              oedegrees[kk].gv += vsize[ii];
+              if (!marker[u]) { /* Need to update boundary etc */
+                marker[u] = 2;
+                updind[nupd++] = u;
+              }
+              break;
+            }
+          }
+        }
+      }
+    }
+
+    ASSERT(myrinfo->ndegrees <= xadj[ii+1]-xadj[ii]);
+  }
+
+  /*======================================================================
+   * Add the contributions on the volume gain due to 'v'
+   *=====================================================================*/
+  myrinfo = graph->vrinfo+v;
+  myedegrees = myrinfo->edegrees;
+  for (k=0; k<myrinfo->ndegrees; k++)
+    phtable[myedegrees[k].pid] = k;
+  phtable[to] = k;
+
+  for (j=xadj[v]; j<xadj[v+1]; j++) {
+    ii = adjncy[j];
+    other = where[ii];
+    orinfo = graph->vrinfo+ii;
+    oedegrees = orinfo->edegrees;
+
+    if (other == to) {
+      for (k=0; k<orinfo->ndegrees; k++) {
+        if (phtable[oedegrees[k].pid] == -1) 
+          oedegrees[k].gv -= vsize[v];
+      }
+    }
+    else {
+      ASSERT(phtable[other] != -1);
+
+      if (myedegrees[phtable[other]].ned > 1) {
+        for (k=0; k<orinfo->ndegrees; k++) {
+          if (phtable[oedegrees[k].pid] == -1) 
+            oedegrees[k].gv -= vsize[v];
+        }
+      }
+      else { /* There is only one connection */
+        for (k=0; k<orinfo->ndegrees; k++) {
+          if (phtable[oedegrees[k].pid] != -1) 
+            oedegrees[k].gv += vsize[v];
+        }
+      }
+    }
+  }
+  for (k=0; k<myrinfo->ndegrees; k++)
+    phtable[myedegrees[k].pid] = -1;
+  phtable[to] = -1;
+
+
+  /*======================================================================
+   * Recompute the volume information of the 'hard' nodes, and update the
+   * max volume gain for all the update vertices
+   *=====================================================================*/
+  ComputeKWayVolume(graph, nupd, updind, marker, phtable);
+
+
+  /*======================================================================
+   * Maintain a consistent boundary
+   *=====================================================================*/
+  for (j=0; j<nupd; j++) {
+    k = updind[j];
+    marker[k] = 0;
+    myrinfo = graph->vrinfo+k;
+
+    if ((myrinfo->gv >= 0 || myrinfo->ed-myrinfo->id >= 0) && graph->bndptr[k] == -1)
+      BNDInsert(graph->nbnd, graph->bndind, graph->bndptr, k);
+
+    if (myrinfo->gv < 0 && myrinfo->ed-myrinfo->id < 0 && graph->bndptr[k] != -1)
+      BNDDelete(graph->nbnd, graph->bndind, graph->bndptr, k);
+  }
+
+}
+
+
+
+
+/*************************************************************************
+* This function computes the initial id/ed 
+**************************************************************************/
+void ComputeKWayVolume(GraphType *graph, int nupd, idxtype *updind, idxtype *marker, idxtype *phtable)
+{
+  int ii, iii, i, j, k, kk, l, nvtxs, me, other, pid;
+  idxtype *xadj, *vsize, *adjncy, *adjwgt, *where;
+  VRInfoType *rinfo, *myrinfo, *orinfo;
+  VEDegreeType *myedegrees, *oedegrees;
+
+  nvtxs = graph->nvtxs;
+  xadj = graph->xadj;
+  vsize = graph->vsize;
+  adjncy = graph->adjncy;
+  adjwgt = graph->adjwgt;
+  where = graph->where;
+  rinfo = graph->vrinfo;
+
+
+  /*------------------------------------------------------------
+  / Compute now the iv/ev degrees
+  /------------------------------------------------------------*/
+  for (iii=0; iii<nupd; iii++) {
+    i = updind[iii];
+    me = where[i];
+
+    myrinfo = rinfo+i;
+    myedegrees = myrinfo->edegrees;
+
+    if (marker[i] == 1) {  /* Only complete gain updates go through */
+      for (k=0; k<myrinfo->ndegrees; k++) 
+        myedegrees[k].gv = 0;
+
+      for (j=xadj[i]; j<xadj[i+1]; j++) {
+        ii = adjncy[j];
+        other = where[ii];
+        orinfo = rinfo+ii;
+        oedegrees = orinfo->edegrees;
+
+        for (kk=0; kk<orinfo->ndegrees; kk++) 
+          phtable[oedegrees[kk].pid] = kk;
+        phtable[other] = 1;
+
+        if (me == other) {
+          /* Find which domains 'i' is connected and 'ii' is not and update their gain */
+          for (k=0; k<myrinfo->ndegrees; k++) {
+            if (phtable[myedegrees[k].pid] == -1)
+              myedegrees[k].gv -= vsize[ii];
+          }
+        }
+        else {
+          ASSERT(phtable[me] != -1);
+
+          /* I'm the only connection of 'ii' in 'me' */
+          if (oedegrees[phtable[me]].ned == 1) { 
+            /* Increase the gains for all the common domains between 'i' and 'ii' */
+            for (k=0; k<myrinfo->ndegrees; k++) {
+              if (phtable[myedegrees[k].pid] != -1) 
+                myedegrees[k].gv += vsize[ii];
+            }
+          }
+          else {
+            /* Find which domains 'i' is connected and 'ii' is not and update their gain */
+            for (k=0; k<myrinfo->ndegrees; k++) {
+              if (phtable[myedegrees[k].pid] == -1) 
+                myedegrees[k].gv -= vsize[ii];
+            }
+          }
+        }
+
+        for (kk=0; kk<orinfo->ndegrees; kk++) 
+          phtable[oedegrees[kk].pid] = -1;
+        phtable[other] = -1;
+  
+      }
+    }
+
+    myrinfo->gv = -MAXIDX;
+    for (k=0; k<myrinfo->ndegrees; k++) {
+      if (myedegrees[k].gv > myrinfo->gv)
+        myrinfo->gv = myedegrees[k].gv;
+    }
+    if (myrinfo->ed > 0 && myrinfo->id == 0)
+      myrinfo->gv += vsize[i];
+
+  }
+
+}
+
+
+
+/*************************************************************************
+* This function computes the total volume
+**************************************************************************/
+int ComputeVolume(GraphType *graph, idxtype *where)
+{
+  int i, j, k, me, nvtxs, nparts, totalv;
+  idxtype *xadj, *adjncy, *vsize, *marker;
+
+
+  nvtxs = graph->nvtxs;
+  xadj = graph->xadj;
+  adjncy = graph->adjncy;
+  vsize = (graph->vsize == NULL ? graph->vwgt : graph->vsize);
+
+  nparts = where[idxamax(nvtxs, where)]+1;
+  marker = idxsmalloc(nparts, -1, "ComputeVolume: marker");
+
+  totalv = 0;
+
+  for (i=0; i<nvtxs; i++) {
+    marker[where[i]] = i;
+    for (j=xadj[i]; j<xadj[i+1]; j++) {
+      k = where[adjncy[j]];
+      if (marker[k] != i) {
+        marker[k] = i;
+        totalv += vsize[i];
+      }
+    }
+  }
+
+  free(marker);
+
+  return totalv;
+}
+
+
+
+
+
+/*************************************************************************
+* This function computes the initial id/ed 
+**************************************************************************/
+void CheckVolKWayPartitionParams(CtrlType *ctrl, GraphType *graph, int nparts)
+{
+  int i, ii, j, k, kk, l, nvtxs, nbnd, mincut, minvol, me, other, pid;
+  idxtype *xadj, *vsize, *adjncy, *adjwgt, *pwgts, *where, *bndind, *bndptr;
+  VRInfoType *rinfo, *myrinfo, *orinfo, tmprinfo;
+  VEDegreeType *myedegrees, *oedegrees, *tmpdegrees;
+
+  nvtxs = graph->nvtxs;
+  xadj = graph->xadj;
+  vsize = graph->vsize;
+  adjncy = graph->adjncy;
+  adjwgt = graph->adjwgt;
+  where = graph->where;
+  rinfo = graph->vrinfo;
+
+  tmpdegrees = (VEDegreeType *)GKmalloc(nparts*sizeof(VEDegreeType), "CheckVolKWayPartitionParams: tmpdegrees");
+
+  /*------------------------------------------------------------
+  / Compute now the iv/ev degrees
+  /------------------------------------------------------------*/
+  for (i=0; i<nvtxs; i++) {
+    me = where[i];
+
+    myrinfo = rinfo+i;
+    myedegrees = myrinfo->edegrees;
+
+    for (k=0; k<myrinfo->ndegrees; k++)
+      tmpdegrees[k] = myedegrees[k];
+
+    tmprinfo.ndegrees = myrinfo->ndegrees;
+    tmprinfo.id = myrinfo->id;
+    tmprinfo.ed = myrinfo->ed;
+
+    myrinfo = &tmprinfo;
+    myedegrees = tmpdegrees;
+
+
+    for (k=0; k<myrinfo->ndegrees; k++)
+      myedegrees[k].gv = 0;
+
+    for (j=xadj[i]; j<xadj[i+1]; j++) {
+      ii = adjncy[j];
+      other = where[ii];
+      orinfo = rinfo+ii;
+      oedegrees = orinfo->edegrees;
+
+      if (me == other) {
+        /* Find which domains 'i' is connected and 'ii' is not and update their gain */
+        for (k=0; k<myrinfo->ndegrees; k++) {
+          pid = myedegrees[k].pid;
+          for (kk=0; kk<orinfo->ndegrees; kk++) {
+            if (oedegrees[kk].pid == pid)
+              break;
+          }
+          if (kk == orinfo->ndegrees) 
+            myedegrees[k].gv -= vsize[ii];
+        }
+      }
+      else {
+        /* Find the orinfo[me].ed and see if I'm the only connection */
+        for (k=0; k<orinfo->ndegrees; k++) {
+          if (oedegrees[k].pid == me)
+            break;
+        }
+
+        if (oedegrees[k].ned == 1) { /* I'm the only connection of 'ii' in 'me' */
+          for (k=0; k<myrinfo->ndegrees; k++) {
+            if (myedegrees[k].pid == other) {
+              myedegrees[k].gv += vsize[ii];
+              break;
+            }
+          }
+
+          /* Increase the gains for all the common domains between 'i' and 'ii' */
+          for (k=0; k<myrinfo->ndegrees; k++) {
+            if ((pid = myedegrees[k].pid) == other)
+              continue;
+            for (kk=0; kk<orinfo->ndegrees; kk++) {
+              if (oedegrees[kk].pid == pid) {
+                myedegrees[k].gv += vsize[ii];
+                break;
+              }
+            }
+          }
+
+        }
+        else {
+          /* Find which domains 'i' is connected and 'ii' is not and update their gain */
+          for (k=0; k<myrinfo->ndegrees; k++) {
+            if ((pid = myedegrees[k].pid) == other)
+              continue;
+            for (kk=0; kk<orinfo->ndegrees; kk++) {
+              if (oedegrees[kk].pid == pid)
+                break;
+            }
+            if (kk == orinfo->ndegrees) 
+              myedegrees[k].gv -= vsize[ii];
+          }
+        }
+      }
+    }
+
+    myrinfo = rinfo+i;
+    myedegrees = myrinfo->edegrees;
+
+    for (k=0; k<myrinfo->ndegrees; k++) {
+      pid = myedegrees[k].pid;
+      for (kk=0; kk<tmprinfo.ndegrees; kk++) {
+        if (tmpdegrees[kk].pid == pid) {
+          if (tmpdegrees[kk].gv != myedegrees[k].gv)
+            printf("[%d %d %d %d]\n", i, pid, myedegrees[k].gv, tmpdegrees[kk].gv);
+          break;
+        }
+      }
+    }
+
+  }
+
+  free(tmpdegrees);
+
+}
+
+
+/*************************************************************************
+* This function computes the subdomain graph
+**************************************************************************/
+void ComputeVolSubDomainGraph(GraphType *graph, int nparts, idxtype *pmat, idxtype *ndoms)
+{
+  int i, j, k, me, nvtxs, ndegrees;
+  idxtype *xadj, *adjncy, *adjwgt, *where;
+  VRInfoType *rinfo;
+  VEDegreeType *edegrees;
+
+  nvtxs = graph->nvtxs;
+  xadj = graph->xadj;
+  adjncy = graph->adjncy;
+  adjwgt = graph->adjwgt;
+  where = graph->where;
+  rinfo = graph->vrinfo;
+
+  idxset(nparts*nparts, 0, pmat);
+
+  for (i=0; i<nvtxs; i++) {
+    if (rinfo[i].ed > 0) {
+      me = where[i];
+      ndegrees = rinfo[i].ndegrees;
+      edegrees = rinfo[i].edegrees;
+
+      k = me*nparts;
+      for (j=0; j<ndegrees; j++) 
+        pmat[k+edegrees[j].pid] += edegrees[j].ed;
+    }
+  }
+
+  for (i=0; i<nparts; i++) {
+    ndoms[i] = 0;
+    for (j=0; j<nparts; j++) {
+      if (pmat[i*nparts+j] > 0)
+        ndoms[i]++;
+    }
+  }
+}
+
+
+
+/*************************************************************************
+* This function computes the subdomain graph
+**************************************************************************/
+void EliminateVolSubDomainEdges(CtrlType *ctrl, GraphType *graph, int nparts, float *tpwgts)
+{
+  int i, ii, j, k, me, other, nvtxs, total, max, avg, totalout, nind, ncand, ncand2, target, target2, nadd;
+  int min, move, cpwgt, tvwgt;
+  idxtype *xadj, *adjncy, *vwgt, *adjwgt, *pwgts, *where, *maxpwgt, *pmat, *ndoms, *mypmat, *otherpmat, *ind;
+  KeyValueType *cand, *cand2;
+
+  nvtxs = graph->nvtxs;
+  xadj = graph->xadj;
+  adjncy = graph->adjncy;
+  vwgt = graph->vwgt;
+  adjwgt = graph->adjwgt;
+
+  where = graph->where;
+  pwgts = idxset(nparts, 0, graph->pwgts);
+
+  maxpwgt = idxwspacemalloc(ctrl, nparts);
+  ndoms = idxwspacemalloc(ctrl, nparts);
+  otherpmat = idxwspacemalloc(ctrl, nparts);
+  ind = idxwspacemalloc(ctrl, nvtxs);
+  pmat = idxset(nparts*nparts, 0, ctrl->wspace.pmat);
+
+  cand = (KeyValueType *)GKmalloc(nparts*sizeof(KeyValueType), "EliminateSubDomainEdges: cand");
+  cand2 = (KeyValueType *)GKmalloc(nparts*sizeof(KeyValueType), "EliminateSubDomainEdges: cand");
+
+  /* Compute the pmat matrix */
+  for (i=0; i<nvtxs; i++) {
+    me = where[i];
+    pwgts[me] += vwgt[i];
+    for (j=xadj[i]; j<xadj[i+1]; j++) {
+      k = adjncy[j];
+      if (where[k] != me) 
+        pmat[me*nparts+where[k]] += adjwgt[j];
+    }
+  }
+
+  /* Compute the maximum allowed weight for each domain */
+  tvwgt = idxsum(nparts, pwgts);
+  for (i=0; i<nparts; i++)
+    maxpwgt[i] = 1.25*tpwgts[i]*tvwgt;
+
+  /* Determine the domain connectivity */
+  for (i=0; i<nparts; i++) {
+    for (k=0, j=0; j<nparts; j++) {
+      if (pmat[i*nparts+j] > 0)
+        k++;
+    }
+    ndoms[i] = k;
+  }
+
+  /* Get into the loop eliminating subdomain connections */
+  for (;;) {
+    total = idxsum(nparts, ndoms);
+    avg = total/nparts;
+    max = ndoms[idxamax(nparts, ndoms)];
+
+    /* printf("Adjacent Subdomain Stats: Total: %3d, Max: %3d, Avg: %3d\n", total, max, avg); */
+
+    if (max < 1.5*avg)
+      break;
+
+    me = idxamax(nparts, ndoms);
+    mypmat = pmat + me*nparts;
+    totalout = idxsum(nparts, mypmat);
+
+    /*printf("Me: %d, TotalOut: %d,\n", me, totalout);*/
+
+    /* Sort the connections according to their cut */
+    for (ncand2=0, i=0; i<nparts; i++) {
+      if (mypmat[i] > 0) {
+        cand2[ncand2].key = mypmat[i];
+        cand2[ncand2++].val = i;
+      }
+    }
+    ikeysort(ncand2, cand2);
+
+    move = 0;
+    for (min=0; min<ncand2; min++) {
+      if (cand2[min].key > totalout/(2*ndoms[me])) 
+        break;
+
+      other = cand2[min].val;
+
+      /*printf("\tMinOut: %d to %d\n", mypmat[other], other);*/
+
+      idxset(nparts, 0, otherpmat);
+
+      /* Go and find the vertices in 'other' that are connected in 'me' */
+      for (nind=0, i=0; i<nvtxs; i++) {
+        if (where[i] == other) {
+          for (j=xadj[i]; j<xadj[i+1]; j++) {
+            if (where[adjncy[j]] == me) {
+              ind[nind++] = i;
+              break;
+            }
+          }
+        }
+      }
+
+      /* Go and construct the otherpmat to see where these nind vertices are connected to */
+      for (cpwgt=0, ii=0; ii<nind; ii++) {
+        i = ind[ii];
+        cpwgt += vwgt[i];
+
+        for (j=xadj[i]; j<xadj[i+1]; j++) {
+          k = adjncy[j];
+          if (where[k] != other) 
+            otherpmat[where[k]] += adjwgt[j];
+        }
+      }
+
+      for (ncand=0, i=0; i<nparts; i++) {
+        if (otherpmat[i] > 0) {
+          cand[ncand].key = -otherpmat[i];
+          cand[ncand++].val = i;
+        }
+      }
+      ikeysort(ncand, cand);
+
+      /* 
+       * Go through and the select the first domain that is common with 'me', and
+       * does not increase the ndoms[target] higher than my ndoms, subject to the
+       * maxpwgt constraint. Traversal is done from the mostly connected to the least.
+       */
+      target = target2 = -1;
+      for (i=0; i<ncand; i++) {
+        k = cand[i].val;
+
+        if (mypmat[k] > 0) {
+          if (pwgts[k] + cpwgt > maxpwgt[k])  /* Check if balance will go off */
+            continue;
+
+          for (j=0; j<nparts; j++) {
+            if (otherpmat[j] > 0 && ndoms[j] >= ndoms[me]-1 && pmat[nparts*j+k] == 0)
+              break;
+          }
+          if (j == nparts) { /* No bad second level effects */
+            for (nadd=0, j=0; j<nparts; j++) {
+              if (otherpmat[j] > 0 && pmat[nparts*k+j] == 0)
+                nadd++;
+            }
+
+            /*printf("\t\tto=%d, nadd=%d, %d\n", k, nadd, ndoms[k]);*/
+            if (target2 == -1 && ndoms[k]+nadd < ndoms[me]) {
+              target2 = k;
+            }
+            if (nadd == 0) {
+              target = k;
+              break;
+            }
+          }
+        }
+      }
+      if (target == -1 && target2 != -1)
+        target = target2;
+
+      if (target == -1) {
+        /* printf("\t\tCould not make the move\n");*/
+        continue;
+      }
+
+      /*printf("\t\tMoving to %d\n", target);*/
+
+      /* Update the partition weights */
+      INC_DEC(pwgts[target], pwgts[other], cpwgt);
+
+      /* Set all nind vertices to belong to 'target' */
+      for (ii=0; ii<nind; ii++) {
+        i = ind[ii];
+        where[i] = target;
+
+        /* First remove any contribution that this vertex may have made */
+        for (j=xadj[i]; j<xadj[i+1]; j++) {
+          k = adjncy[j];
+          if (where[k] != other) {
+            if (pmat[nparts*other + where[k]] == 0)
+              printf("Something wrong\n");
+            pmat[nparts*other + where[k]] -= adjwgt[j];
+            if (pmat[nparts*other + where[k]] == 0)
+              ndoms[other]--;
+
+            if (pmat[nparts*where[k] + other] == 0)
+              printf("Something wrong\n");
+            pmat[nparts*where[k] + other] -= adjwgt[j];
+            if (pmat[nparts*where[k] + other] == 0)
+              ndoms[where[k]]--;
+          }
+        }
+
+        /* Next add the new contributions as a result of the move */
+        for (j=xadj[i]; j<xadj[i+1]; j++) {
+          k = adjncy[j];
+          if (where[k] != target) {
+            if (pmat[nparts*target + where[k]] == 0)
+              ndoms[target]++;
+            pmat[nparts*target + where[k]] += adjwgt[j];
+  
+            if (pmat[nparts*where[k] + target] == 0)
+              ndoms[where[k]]++;
+            pmat[nparts*where[k] + target] += adjwgt[j];
+          }
+        }
+      }
+
+      move = 1;
+      break;
+    }
+
+    if (move == 0)
+      break;
+  }
+
+  idxwspacefree(ctrl, nparts);
+  idxwspacefree(ctrl, nparts);
+  idxwspacefree(ctrl, nparts);
+  idxwspacefree(ctrl, nvtxs);
+
+  GKfree(&cand, &cand2, LTERM);
+}
+
+
+
+/*************************************************************************
+* This function finds all the connected components induced by the 
+* partitioning vector in wgraph->where and tries to push them around to 
+* remove some of them
+**************************************************************************/
+void EliminateVolComponents(CtrlType *ctrl, GraphType *graph, int nparts, float *tpwgts, float ubfactor)
+{
+  int i, ii, j, jj, k, me, nvtxs, tvwgt, first, last, nleft, ncmps, cwgt, ncand, other, target, deltawgt;
+  idxtype *xadj, *adjncy, *vwgt, *adjwgt, *where, *pwgts, *maxpwgt;
+  idxtype *cpvec, *touched, *perm, *todo, *cind, *cptr, *npcmps;
+  KeyValueType *cand;
+  int recompute=0;
+
+  nvtxs = graph->nvtxs;
+  xadj = graph->xadj;
+  adjncy = graph->adjncy;
+  vwgt = graph->vwgt;
+  adjwgt = graph->adjwgt;
+
+  where = graph->where;
+  pwgts = idxset(nparts, 0, graph->pwgts);
+
+  touched = idxset(nvtxs, 0, idxwspacemalloc(ctrl, nvtxs));
+  cptr = idxwspacemalloc(ctrl, nvtxs);
+  cind = idxwspacemalloc(ctrl, nvtxs);
+  perm = idxwspacemalloc(ctrl, nvtxs);
+  todo = idxwspacemalloc(ctrl, nvtxs);
+  maxpwgt = idxwspacemalloc(ctrl, nparts);
+  cpvec = idxwspacemalloc(ctrl, nparts);
+  npcmps = idxset(nparts, 0, idxwspacemalloc(ctrl, nparts));
+
+  for (i=0; i<nvtxs; i++) 
+    perm[i] = todo[i] = i;
+
+  /* Find the connected componends induced by the partition */
+  ncmps = -1;
+  first = last = 0;
+  nleft = nvtxs;
+  while (nleft > 0) {
+    if (first == last) { /* Find another starting vertex */
+      cptr[++ncmps] = first;
+      ASSERT(touched[todo[0]] == 0);
+      i = todo[0];
+      cind[last++] = i;
+      touched[i] = 1;
+      me = where[i];
+      npcmps[me]++;
+    }
+
+    i = cind[first++];
+    k = perm[i];
+    j = todo[k] = todo[--nleft];
+    perm[j] = k;
+
+    for (j=xadj[i]; j<xadj[i+1]; j++) {
+      k = adjncy[j];
+      if (where[k] == me && !touched[k]) {
+        cind[last++] = k;
+        touched[k] = 1;
+      }
+    }
+  }
+  cptr[++ncmps] = first;
+
+  /* printf("I found %d components, for this %d-way partition\n", ncmps, nparts); */
+
+  if (ncmps > nparts) { /* There are more components than processors */
+    cand = (KeyValueType *)GKmalloc(nparts*sizeof(KeyValueType), "EliminateSubDomainEdges: cand");
+
+    /* First determine the partition sizes and max allowed load imbalance */
+    for (i=0; i<nvtxs; i++) 
+      pwgts[where[i]] += vwgt[i];
+    tvwgt = idxsum(nparts, pwgts);
+    for (i=0; i<nparts; i++)
+      maxpwgt[i] = ubfactor*tpwgts[i]*tvwgt;
+
+    deltawgt = tvwgt/(100*nparts);
+    deltawgt = 5;
+
+    for (i=0; i<ncmps; i++) {
+      me = where[cind[cptr[i]]];  /* Get the domain of this component */
+      if (npcmps[me] == 1)
+        continue;  /* Skip it because it is contigous */
+
+      /*printf("Trying to move %d from %d\n", i, me); */
+
+      /* Determine the connectivity */
+      idxset(nparts, 0, cpvec);
+      for (cwgt=0, j=cptr[i]; j<cptr[i+1]; j++) {
+        ii = cind[j];
+        cwgt += vwgt[ii];
+        for (jj=xadj[ii]; jj<xadj[ii+1]; jj++) {
+          other = where[adjncy[jj]];
+          if (me != other)
+            cpvec[other] += adjwgt[jj];
+        }
+      }
+
+      /*printf("\tCmp weight: %d\n", cwgt);*/
+
+      if (cwgt > .30*pwgts[me])
+        continue;  /* Skip the component if it is over 30% of the weight */
+
+      for (ncand=0, j=0; j<nparts; j++) {
+        if (cpvec[j] > 0) {
+          cand[ncand].key = -cpvec[j];
+          cand[ncand++].val = j;
+        }
+      }
+      if (ncand == 0)
+        continue;
+
+      ikeysort(ncand, cand);
+
+      target = -1;
+      for (j=0; j<ncand; j++) {
+        k = cand[j].val;
+        if (cwgt < deltawgt || pwgts[k] + cwgt < maxpwgt[k]) {
+          target = k;
+          break;
+        }
+      }
+
+      /*printf("\tMoving it to %d [%d]\n", target, cpvec[target]);*/
+
+      if (target != -1) {
+        /* Assign all the vertices of 'me' to 'target' and update data structures */
+        pwgts[me] -= cwgt;
+        pwgts[target] += cwgt;
+        npcmps[me]--;
+
+        for (j=cptr[i]; j<cptr[i+1]; j++) 
+          where[cind[j]] = target;
+
+        graph->mincut -= cpvec[target];
+        recompute = 1;
+      }
+    }
+
+    free(cand);
+  }
+
+  if (recompute) {
+    int ttlv;
+    idxtype *marker;
+
+    marker = idxset(nparts, -1, cpvec);
+    for (ttlv=0, i=0; i<nvtxs; i++) {
+      marker[where[i]] = i;
+      for (j=xadj[i]; j<xadj[i+1]; j++) {
+        if (marker[where[adjncy[j]]] != i) {
+          ttlv += graph->vsize[i];
+          marker[where[adjncy[j]]] = i;
+        }
+      }
+    }
+    graph->minvol = ttlv;
+  }
+
+  idxwspacefree(ctrl, nparts);
+  idxwspacefree(ctrl, nparts);
+  idxwspacefree(ctrl, nparts);
+  idxwspacefree(ctrl, nvtxs);
+  idxwspacefree(ctrl, nvtxs);
+  idxwspacefree(ctrl, nvtxs);
+  idxwspacefree(ctrl, nvtxs);
+  idxwspacefree(ctrl, nvtxs);
+
+}
+
Index: /inundation/pymetis/metis-4.0/Lib/kwayvolrefine.c
===================================================================
--- /inundation/pymetis/metis-4.0/Lib/kwayvolrefine.c	(revision 2051)
+++ /inundation/pymetis/metis-4.0/Lib/kwayvolrefine.c	(revision 2051)
@@ -0,0 +1,460 @@
+/*
+ * Copyright 1997, Regents of the University of Minnesota
+ *
+ * kwayvolrefine.c
+ *
+ * This file contains the driving routines for multilevel k-way refinement
+ *
+ * Started 7/28/97
+ * George
+ *
+ * $Id: kwayvolrefine.c,v 1.2 1998/11/30 16:13:57 karypis Exp $
+ */
+
+#include <metis.h>
+
+
+/*************************************************************************
+* This function is the entry point of refinement
+**************************************************************************/
+void RefineVolKWay(CtrlType *ctrl, GraphType *orggraph, GraphType *graph, int nparts, 
+                   float *tpwgts, float ubfactor)
+{
+  int i, nlevels;
+  GraphType *ptr;
+
+  IFSET(ctrl->dbglvl, DBG_TIME, starttimer(ctrl->UncoarsenTmr));
+
+  /* Take care any non-contiguity */
+  if (ctrl->RType == RTYPE_KWAYRANDOM_MCONN) {
+    ComputeVolKWayPartitionParams(ctrl, graph, nparts);
+    EliminateVolComponents(ctrl, graph, nparts, tpwgts, 1.25);
+    EliminateVolSubDomainEdges(ctrl, graph, nparts, tpwgts);
+    EliminateVolComponents(ctrl, graph, nparts, tpwgts, 1.25);
+  }
+
+
+  /* Determine how many levels are there */
+  for (ptr=graph, nlevels=0; ptr!=orggraph; ptr=ptr->finer, nlevels++); 
+
+  /* Compute the parameters of the coarsest graph */
+  ComputeVolKWayPartitionParams(ctrl, graph, nparts);
+
+  for (i=0; ;i++) {
+    /*PrintSubDomainGraph(graph, nparts, graph->where);*/
+    MALLOC_CHECK(NULL);
+    IFSET(ctrl->dbglvl, DBG_TIME, starttimer(ctrl->RefTmr));
+
+    if (2*i >= nlevels && !IsBalanced(graph->pwgts, nparts, tpwgts, 1.04*ubfactor)) {
+      ComputeVolKWayBalanceBoundary(ctrl, graph, nparts);
+      switch (ctrl->RType) {
+        case RTYPE_KWAYRANDOM:
+          Greedy_KWayVolBalance(ctrl, graph, nparts, tpwgts, ubfactor, 1); 
+          break;
+        case RTYPE_KWAYRANDOM_MCONN:
+          Greedy_KWayVolBalanceMConn(ctrl, graph, nparts, tpwgts, ubfactor, 1); 
+          break;
+      }
+      ComputeVolKWayBoundary(ctrl, graph, nparts);
+    }
+
+    switch (ctrl->RType) {
+      case RTYPE_KWAYRANDOM:
+        Random_KWayVolRefine(ctrl, graph, nparts, tpwgts, ubfactor, 10, 0); 
+        break;
+      case RTYPE_KWAYRANDOM_MCONN:
+        Random_KWayVolRefineMConn(ctrl, graph, nparts, tpwgts, ubfactor, 10, 0); 
+        break;
+    }
+    IFSET(ctrl->dbglvl, DBG_TIME, stoptimer(ctrl->RefTmr));
+
+    if (graph == orggraph)
+      break;
+
+    GKfree(&graph->gdata, LTERM);  /* Deallocate the graph related arrays */
+
+    graph = graph->finer;
+
+    IFSET(ctrl->dbglvl, DBG_TIME, starttimer(ctrl->ProjectTmr));
+    ProjectVolKWayPartition(ctrl, graph, nparts);
+    IFSET(ctrl->dbglvl, DBG_TIME, stoptimer(ctrl->ProjectTmr));
+  }
+
+  if (!IsBalanced(graph->pwgts, nparts, tpwgts, ubfactor)) {
+    ComputeVolKWayBalanceBoundary(ctrl, graph, nparts);
+    switch (ctrl->RType) {
+      case RTYPE_KWAYRANDOM:
+        Greedy_KWayVolBalance(ctrl, graph, nparts, tpwgts, ubfactor, 8); 
+        Random_KWayVolRefine(ctrl, graph, nparts, tpwgts, ubfactor, 10, 0); 
+        break;
+      case RTYPE_KWAYRANDOM_MCONN:
+        Greedy_KWayVolBalanceMConn(ctrl, graph, nparts, tpwgts, ubfactor, 8); 
+        Random_KWayVolRefineMConn(ctrl, graph, nparts, tpwgts, ubfactor, 10, 0); 
+        break;
+    }
+  }
+
+  EliminateVolComponents(ctrl, graph, nparts, tpwgts, ubfactor); 
+
+  IFSET(ctrl->dbglvl, DBG_TIME, stoptimer(ctrl->UncoarsenTmr));
+}
+
+
+
+/*************************************************************************
+* This function allocates memory for k-way edge refinement
+**************************************************************************/
+void AllocateVolKWayPartitionMemory(CtrlType *ctrl, GraphType *graph, int nparts)
+{
+  int nvtxs, pad64;
+
+  nvtxs = graph->nvtxs;
+
+  pad64 = (3*nvtxs+nparts)%2;
+
+  graph->rdata = idxmalloc(3*nvtxs+nparts+(sizeof(VRInfoType)/sizeof(idxtype))*nvtxs+pad64, "AllocateVolKWayPartitionMemory: rdata");
+  graph->pwgts          = graph->rdata;
+  graph->where          = graph->rdata + nparts;
+  graph->bndptr         = graph->rdata + nvtxs + nparts;
+  graph->bndind         = graph->rdata + 2*nvtxs + nparts;
+  graph->vrinfo          = (VRInfoType *)(graph->rdata + 3*nvtxs+nparts + pad64);
+
+}
+
+
+
+/*************************************************************************
+* This function computes the initial id/ed 
+**************************************************************************/
+void ComputeVolKWayPartitionParams(CtrlType *ctrl, GraphType *graph, int nparts)
+{
+  int i, ii, j, k, kk, l, nvtxs, nbnd, mincut, minvol, me, other, pid; 
+  idxtype *xadj, *vwgt, *adjncy, *adjwgt, *pwgts, *where;
+  VRInfoType *rinfo, *myrinfo, *orinfo;
+  VEDegreeType *myedegrees, *oedegrees;
+
+  nvtxs = graph->nvtxs;
+  xadj = graph->xadj;
+  vwgt = graph->vwgt;
+  adjncy = graph->adjncy;
+  adjwgt = graph->adjwgt;
+
+  where = graph->where;
+  pwgts = idxset(nparts, 0, graph->pwgts);
+  rinfo = graph->vrinfo;
+
+
+  /*------------------------------------------------------------
+  / Compute now the id/ed degrees
+  /------------------------------------------------------------*/
+  ctrl->wspace.cdegree = 0;
+  mincut = 0;
+  for (i=0; i<nvtxs; i++) {
+    me = where[i];
+    pwgts[me] += vwgt[i];
+
+    myrinfo = rinfo+i;
+    myrinfo->id = myrinfo->ed = myrinfo->nid = myrinfo->ndegrees = 0;
+    myrinfo->edegrees = NULL;
+
+    for (j=xadj[i]; j<xadj[i+1]; j++) {
+      if (me == where[adjncy[j]]) {
+        myrinfo->id += adjwgt[j];
+        myrinfo->nid++;
+      }
+    }
+    myrinfo->ed = graph->adjwgtsum[i] - myrinfo->id;
+
+    mincut += myrinfo->ed;
+
+    /* Time to compute the particular external degrees */
+    if (myrinfo->ed > 0) { 
+      myedegrees = myrinfo->edegrees = ctrl->wspace.vedegrees+ctrl->wspace.cdegree;
+      ctrl->wspace.cdegree += xadj[i+1]-xadj[i];
+
+      for (j=xadj[i]; j<xadj[i+1]; j++) {
+        other = where[adjncy[j]];
+        if (me != other) {
+          for (k=0; k<myrinfo->ndegrees; k++) {
+            if (myedegrees[k].pid == other) {
+              myedegrees[k].ed += adjwgt[j];
+              myedegrees[k].ned++;
+              break;
+            }
+          }
+          if (k == myrinfo->ndegrees) {
+            myedegrees[myrinfo->ndegrees].gv = 0;
+            myedegrees[myrinfo->ndegrees].pid = other;
+            myedegrees[myrinfo->ndegrees].ed = adjwgt[j];
+            myedegrees[myrinfo->ndegrees++].ned = 1;
+          }
+        }
+      }
+
+      ASSERT(myrinfo->ndegrees <= xadj[i+1]-xadj[i]);
+    }
+  }
+  graph->mincut = mincut/2;
+
+
+  ComputeKWayVolGains(ctrl, graph, nparts);
+
+}
+
+
+
+/*************************************************************************
+* This function computes the initial id/ed 
+**************************************************************************/
+void ComputeKWayVolGains(CtrlType *ctrl, GraphType *graph, int nparts)
+{
+  int i, ii, j, k, kk, l, nvtxs, me, other, pid, myndegrees; 
+  idxtype *xadj, *vsize, *adjncy, *adjwgt, *where, *bndind, *bndptr, *ophtable;
+  VRInfoType *rinfo, *myrinfo, *orinfo;
+  VEDegreeType *myedegrees, *oedegrees;
+
+  nvtxs = graph->nvtxs;
+  xadj = graph->xadj;
+  vsize = graph->vsize;
+  adjncy = graph->adjncy;
+  adjwgt = graph->adjwgt;
+
+  where = graph->where;
+  bndind = graph->bndind;
+  bndptr = idxset(nvtxs, -1, graph->bndptr);
+  rinfo = graph->vrinfo;
+
+  ophtable = idxset(nparts, -1, idxwspacemalloc(ctrl, nparts));
+
+  /*------------------------------------------------------------
+  / Compute now the iv/ev degrees
+  /------------------------------------------------------------*/
+  graph->minvol = graph->nbnd = 0;
+  for (i=0; i<nvtxs; i++) {
+    myrinfo = rinfo+i;
+    myrinfo->gv = -MAXIDX;
+
+    if (myrinfo->ndegrees > 0) {
+      me = where[i];
+      myedegrees = myrinfo->edegrees;
+      myndegrees = myrinfo->ndegrees;
+
+      graph->minvol += myndegrees*vsize[i];
+
+      for (j=xadj[i]; j<xadj[i+1]; j++) {
+        ii = adjncy[j];
+        other = where[ii];
+        orinfo = rinfo+ii;
+        oedegrees = orinfo->edegrees;
+
+        for (k=0; k<orinfo->ndegrees; k++) 
+          ophtable[oedegrees[k].pid] = k;
+        ophtable[other] = 1;  /* this is to simplify coding */
+
+        if (me == other) {
+          /* Find which domains 'i' is connected and 'ii' is not and update their gain */
+          for (k=0; k<myndegrees; k++) {
+            if (ophtable[myedegrees[k].pid] == -1)
+              myedegrees[k].gv -= vsize[ii];
+          }
+        }
+        else {
+          ASSERT(ophtable[me] != -1);
+
+          if (oedegrees[ophtable[me]].ned == 1) { /* I'm the only connection of 'ii' in 'me' */
+            /* Increase the gains for all the common domains between 'i' and 'ii' */
+            for (k=0; k<myndegrees; k++) {
+              if (ophtable[myedegrees[k].pid] != -1) 
+                myedegrees[k].gv += vsize[ii];
+            }
+          }
+          else {
+            /* Find which domains 'i' is connected and 'ii' is not and update their gain */
+            for (k=0; k<myndegrees; k++) {
+              if (ophtable[myedegrees[k].pid] == -1) 
+                myedegrees[k].gv -= vsize[ii];
+            }
+          }
+        }
+
+        for (kk=0; kk<orinfo->ndegrees; kk++) 
+          ophtable[oedegrees[kk].pid] = -1;
+        ophtable[other] = -1;
+      }
+
+      /* Compute the max vgain */
+      for (k=0; k<myndegrees; k++) {
+        if (myedegrees[k].gv > myrinfo->gv)
+          myrinfo->gv = myedegrees[k].gv;
+      }
+    }
+
+    if (myrinfo->ed > 0 && myrinfo->id == 0) 
+      myrinfo->gv += vsize[i];
+
+    if (myrinfo->gv >= 0 || myrinfo->ed-myrinfo->id >= 0)
+      BNDInsert(graph->nbnd, bndind, bndptr, i);
+  }
+
+  idxwspacefree(ctrl, nparts);
+
+}
+
+
+
+/*************************************************************************
+* This function projects a partition, and at the same time computes the
+* parameters for refinement.
+**************************************************************************/
+void ProjectVolKWayPartition(CtrlType *ctrl, GraphType *graph, int nparts)
+{
+  int i, j, k, nvtxs, me, other, istart, iend, ndegrees;
+  idxtype *xadj, *adjncy, *adjwgt, *adjwgtsum;
+  idxtype *cmap, *where;
+  idxtype *cwhere;
+  GraphType *cgraph;
+  VRInfoType *crinfo, *rinfo, *myrinfo;
+  VEDegreeType *myedegrees;
+  idxtype *htable;
+
+  cgraph = graph->coarser;
+  cwhere = cgraph->where;
+  crinfo = cgraph->vrinfo;
+
+  nvtxs = graph->nvtxs;
+  cmap = graph->cmap;
+  xadj = graph->xadj;
+  adjncy = graph->adjncy;
+  adjwgt = graph->adjwgt;
+  adjwgtsum = graph->adjwgtsum;
+
+  AllocateVolKWayPartitionMemory(ctrl, graph, nparts);
+  where = graph->where;
+  rinfo = graph->vrinfo;
+
+  /* Go through and project partition and compute id/ed for the nodes */
+  for (i=0; i<nvtxs; i++) {
+    k = cmap[i];
+    where[i] = cwhere[k];
+    cmap[i] = crinfo[k].ed;  /* For optimization */
+  }
+
+  htable = idxset(nparts, -1, idxwspacemalloc(ctrl, nparts));
+
+  ctrl->wspace.cdegree = 0;
+  for (i=0; i<nvtxs; i++) {
+    me = where[i];
+
+    myrinfo = rinfo+i;
+    myrinfo->id = myrinfo->ed = myrinfo->nid = myrinfo->ndegrees = 0;
+    myrinfo->edegrees = NULL;
+
+    myrinfo->id = adjwgtsum[i];
+    myrinfo->nid = xadj[i+1]-xadj[i];
+
+    if (cmap[i] > 0) { /* If it is an interface node. Note cmap[i] = crinfo[cmap[i]].ed */
+      istart = xadj[i];
+      iend = xadj[i+1];
+
+      myedegrees = myrinfo->edegrees = ctrl->wspace.vedegrees+ctrl->wspace.cdegree;
+      ctrl->wspace.cdegree += iend-istart;
+
+      ndegrees = 0;
+      for (j=istart; j<iend; j++) {
+        other = where[adjncy[j]];
+        if (me != other) {
+          myrinfo->ed += adjwgt[j];
+          myrinfo->nid--;
+          if ((k = htable[other]) == -1) {
+            htable[other] = ndegrees;
+            myedegrees[ndegrees].gv = 0;
+            myedegrees[ndegrees].pid = other;
+            myedegrees[ndegrees].ed = adjwgt[j];
+            myedegrees[ndegrees++].ned = 1;
+          }
+          else {
+            myedegrees[k].ed += adjwgt[j];
+            myedegrees[k].ned++;
+          }
+        }
+      }
+      myrinfo->id -= myrinfo->ed;
+
+      /* Remove space for edegrees if it was interior */
+      if (myrinfo->ed == 0) { 
+        myrinfo->edegrees = NULL;
+        ctrl->wspace.cdegree -= iend-istart;
+      }
+      else {
+        myrinfo->ndegrees = ndegrees;
+
+        for (j=0; j<ndegrees; j++)
+          htable[myedegrees[j].pid] = -1;
+      }
+    }
+  }
+
+  ComputeKWayVolGains(ctrl, graph, nparts);
+
+  idxcopy(nparts, cgraph->pwgts, graph->pwgts);
+  graph->mincut = cgraph->mincut;
+
+  FreeGraph(graph->coarser);
+  graph->coarser = NULL;
+
+  idxwspacefree(ctrl, nparts);
+
+}
+
+
+
+/*************************************************************************
+* This function computes the boundary definition for balancing
+**************************************************************************/
+void ComputeVolKWayBoundary(CtrlType *ctrl, GraphType *graph, int nparts)
+{
+  int i, nvtxs, nbnd;
+  idxtype *bndind, *bndptr;
+
+  nvtxs = graph->nvtxs;
+  bndind = graph->bndind;
+  bndptr = idxset(nvtxs, -1, graph->bndptr);
+
+
+  /*------------------------------------------------------------
+  / Compute the new boundary
+  /------------------------------------------------------------*/
+  nbnd = 0;
+  for (i=0; i<nvtxs; i++) {
+    if (graph->vrinfo[i].gv >=0 || graph->vrinfo[i].ed-graph->vrinfo[i].id >= 0) 
+      BNDInsert(nbnd, bndind, bndptr, i);
+  }
+
+  graph->nbnd = nbnd;
+}
+
+/*************************************************************************
+* This function computes the boundary definition for balancing
+**************************************************************************/
+void ComputeVolKWayBalanceBoundary(CtrlType *ctrl, GraphType *graph, int nparts)
+{
+  int i, nvtxs, nbnd;
+  idxtype *bndind, *bndptr;
+
+  nvtxs = graph->nvtxs;
+  bndind = graph->bndind;
+  bndptr = idxset(nvtxs, -1, graph->bndptr);
+
+
+  /*------------------------------------------------------------
+  / Compute the new boundary
+  /------------------------------------------------------------*/
+  nbnd = 0;
+  for (i=0; i<nvtxs; i++) {
+    if (graph->vrinfo[i].ed > 0) 
+      BNDInsert(nbnd, bndind, bndptr, i);
+  }
+
+  graph->nbnd = nbnd;
+}
+
Index: /inundation/pymetis/metis-4.0/Lib/macros.h
===================================================================
--- /inundation/pymetis/metis-4.0/Lib/macros.h	(revision 2051)
+++ /inundation/pymetis/metis-4.0/Lib/macros.h	(revision 2051)
@@ -0,0 +1,143 @@
+/*
+ * Copyright 1997, Regents of the University of Minnesota
+ *
+ * macros.h
+ *
+ * This file contains macros used in multilevel
+ *
+ * Started 9/25/94
+ * George
+ *
+ * $Id: macros.h,v 1.1 1998/11/27 17:59:18 karypis Exp $
+ *
+ */
+
+
+/*************************************************************************
+* The following macro returns a random number in the specified range
+**************************************************************************/
+#ifdef __VC__
+#define RandomInRange(u) ((rand()>>3)%(u))
+#define RandomInRangeFast(u) ((rand()>>3)%(u))
+#else
+#define RandomInRange(u) ((int)(drand48()*((double)(u))))
+#define RandomInRangeFast(u) ((rand()>>3)%(u))
+#endif
+
+
+
+#define amax(a, b) ((a) >= (b) ? (a) : (b))
+#define amin(a, b) ((a) >= (b) ? (b) : (a))
+
+#define AND(a, b) ((a) < 0 ? ((-(a))&(b)) : ((a)&(b)))
+#define OR(a, b) ((a) < 0 ? -((-(a))|(b)) : ((a)|(b)))
+#define XOR(a, b) ((a) < 0 ? -((-(a))^(b)) : ((a)^(b)))
+
+#define SWAP(a, b, tmp)  \
+                 do {(tmp) = (a); (a) = (b); (b) = (tmp);} while(0) 
+
+#define INC_DEC(a, b, val) \
+                 do {(a) += (val); (b) -= (val);} while(0)
+
+
+#define scopy(n, a, b) (float *)memcpy((void *)(b), (void *)(a), sizeof(float)*(n))
+#define idxcopy(n, a, b) (idxtype *)memcpy((void *)(b), (void *)(a), sizeof(idxtype)*(n)) 
+
+#define HASHFCT(key, size) ((key)%(size))
+
+
+/*************************************************************************
+* Timer macros
+**************************************************************************/
+#define cleartimer(tmr) (tmr = 0.0)
+#define starttimer(tmr) (tmr -= seconds())
+#define stoptimer(tmr) (tmr += seconds())
+#define gettimer(tmr) (tmr)
+
+
+/*************************************************************************
+* This macro is used to handle dbglvl
+**************************************************************************/
+#define IFSET(a, flag, cmd) if ((a)&(flag)) (cmd);
+
+/*************************************************************************
+* These macros are used for debuging memory leaks
+**************************************************************************/
+#ifdef DMALLOC
+#define imalloc(n, msg) (malloc(sizeof(int)*(n)))
+#define fmalloc(n, msg) (malloc(sizeof(float)*(n)))
+#define idxmalloc(n, msg) (malloc(sizeof(idxtype)*(n)))
+#define ismalloc(n, val, msg) (iset((n), (val), malloc(sizeof(int)*(n))))
+#define idxsmalloc(n, val, msg) (idxset((n), (val), malloc(sizeof(idxtype)*(n))))
+#define GKmalloc(a, b) (malloc((a)))
+#endif
+
+#ifdef DMALLOC
+#   define MALLOC_CHECK(ptr)                                          \
+    if (malloc_verify((ptr)) == DMALLOC_VERIFY_ERROR) {  \
+        printf("***MALLOC_CHECK failed on line %d of file %s: " #ptr "\n", \
+              __LINE__, __FILE__);                               \
+        abort();                                                \
+    }
+#else
+#   define MALLOC_CHECK(ptr) ;
+#endif 
+
+
+
+/*************************************************************************
+* This macro converts a length array in a CSR one
+**************************************************************************/
+#define MAKECSR(i, n, a) \
+   do { \
+     for (i=1; i<n; i++) a[i] += a[i-1]; \
+     for (i=n; i>0; i--) a[i] = a[i-1]; \
+     a[0] = 0; \
+   } while(0) 
+
+
+/*************************************************************************
+* These macros insert and remove nodes from the boundary list
+**************************************************************************/
+#define BNDInsert(nbnd, bndind, bndptr, vtx) \
+   do { \
+     ASSERT(bndptr[vtx] == -1); \
+     bndind[nbnd] = vtx; \
+     bndptr[vtx] = nbnd++;\
+   } while(0) 
+
+#define BNDDelete(nbnd, bndind, bndptr, vtx) \
+   do { \
+     ASSERT(bndptr[vtx] != -1); \
+     bndind[bndptr[vtx]] = bndind[--nbnd]; \
+     bndptr[bndind[nbnd]] = bndptr[vtx]; \
+     bndptr[vtx] = -1; \
+   } while(0) 
+
+
+
+/*************************************************************************
+* These are debugging macros
+**************************************************************************/
+#ifdef DEBUG
+#   define ASSERT(expr)                                          \
+    if (!(expr)) {                                               \
+        printf("***ASSERTION failed on line %d of file %s: " #expr "\n", \
+              __LINE__, __FILE__);                               \
+        abort();                                                \
+    }
+#else
+#   define ASSERT(expr) ;
+#endif 
+
+#ifdef DEBUG
+#   define ASSERTP(expr, msg)                                          \
+    if (!(expr)) {                                               \
+        printf("***ASSERTION failed on line %d of file %s: " #expr "\n", \
+              __LINE__, __FILE__);                               \
+        printf msg ; \
+        abort();                                                \
+    }
+#else
+#   define ASSERTP(expr, msg) ;
+#endif 
Index: /inundation/pymetis/metis-4.0/Lib/match.c
===================================================================
--- /inundation/pymetis/metis-4.0/Lib/match.c	(revision 2051)
+++ /inundation/pymetis/metis-4.0/Lib/match.c	(revision 2051)
@@ -0,0 +1,267 @@
+/*
+ * Copyright 1997, Regents of the University of Minnesota
+ *
+ * match.c
+ *
+ * This file contains the code that computes matchings and creates the next
+ * level coarse graph.
+ *
+ * Started 7/23/97
+ * George
+ *
+ * $Id: match.c,v 1.1 1998/11/27 17:59:18 karypis Exp $
+ *
+ */
+
+#include <metis.h>
+
+
+/*************************************************************************
+* This function finds a matching using the HEM heuristic
+**************************************************************************/
+void Match_RM(CtrlType *ctrl, GraphType *graph)
+{
+  int i, ii, j, nvtxs, cnvtxs, maxidx;
+  idxtype *xadj, *vwgt, *adjncy, *adjwgt;
+  idxtype *match, *cmap, *perm;
+
+  IFSET(ctrl->dbglvl, DBG_TIME, starttimer(ctrl->MatchTmr));
+
+  nvtxs = graph->nvtxs;
+  xadj = graph->xadj;
+  vwgt = graph->vwgt;
+  adjncy = graph->adjncy;
+  adjwgt = graph->adjwgt;
+
+  cmap = graph->cmap;
+  match = idxset(nvtxs, UNMATCHED, idxwspacemalloc(ctrl, nvtxs));
+
+  perm = idxwspacemalloc(ctrl, nvtxs);
+  RandomPermute(nvtxs, perm, 1);
+
+  cnvtxs = 0;
+  for (ii=0; ii<nvtxs; ii++) {
+    i = perm[ii];
+
+    if (match[i] == UNMATCHED) {  /* Unmatched */
+      maxidx = i;
+
+      /* Find a random matching, subject to maxvwgt constraints */
+      for (j=xadj[i]; j<xadj[i+1]; j++) {
+        if (match[adjncy[j]] == UNMATCHED && vwgt[i]+vwgt[adjncy[j]] <= ctrl->maxvwgt) {
+          maxidx = adjncy[j];
+          break;
+        }
+      }
+
+      cmap[i] = cmap[maxidx] = cnvtxs++;
+      match[i] = maxidx;
+      match[maxidx] = i;
+    }
+  }
+
+  IFSET(ctrl->dbglvl, DBG_TIME, stoptimer(ctrl->MatchTmr));
+
+  CreateCoarseGraph(ctrl, graph, cnvtxs, match, perm);
+
+  idxwspacefree(ctrl, nvtxs);
+  idxwspacefree(ctrl, nvtxs);
+}
+
+
+/*************************************************************************
+* This function finds a matching using the HEM heuristic
+**************************************************************************/
+void Match_RM_NVW(CtrlType *ctrl, GraphType *graph)
+{
+  int i, ii, j, nvtxs, cnvtxs, maxidx;
+  idxtype *xadj, *adjncy;
+  idxtype *match, *cmap, *perm;
+
+  IFSET(ctrl->dbglvl, DBG_TIME, starttimer(ctrl->MatchTmr));
+
+  nvtxs = graph->nvtxs;
+  xadj = graph->xadj;
+  adjncy = graph->adjncy;
+
+  cmap = graph->cmap;
+  match = idxset(nvtxs, UNMATCHED, idxwspacemalloc(ctrl, nvtxs));
+
+  perm = idxwspacemalloc(ctrl, nvtxs);
+  RandomPermute(nvtxs, perm, 1);
+
+  cnvtxs = 0;
+  for (ii=0; ii<nvtxs; ii++) {
+    i = perm[ii];
+
+    if (match[i] == UNMATCHED) {  /* Unmatched */
+      maxidx = i;
+
+      /* Find a random matching, subject to maxvwgt constraints */
+      for (j=xadj[i]; j<xadj[i+1]; j++) {
+        if (match[adjncy[j]] == UNMATCHED) {
+          maxidx = adjncy[j];
+          break;
+        }
+      }
+
+      cmap[i] = cmap[maxidx] = cnvtxs++;
+      match[i] = maxidx;
+      match[maxidx] = i;
+    }
+  }
+
+  IFSET(ctrl->dbglvl, DBG_TIME, stoptimer(ctrl->MatchTmr));
+
+  CreateCoarseGraph_NVW(ctrl, graph, cnvtxs, match, perm);
+
+  idxwspacefree(ctrl, nvtxs);
+  idxwspacefree(ctrl, nvtxs);
+}
+
+
+
+/*************************************************************************
+* This function finds a matching using the HEM heuristic
+**************************************************************************/
+void Match_HEM(CtrlType *ctrl, GraphType *graph)
+{
+  int i, ii, j, k, nvtxs, cnvtxs, maxidx, maxwgt;
+  idxtype *xadj, *vwgt, *adjncy, *adjwgt;
+  idxtype *match, *cmap, *perm;
+
+  IFSET(ctrl->dbglvl, DBG_TIME, starttimer(ctrl->MatchTmr));
+
+  nvtxs = graph->nvtxs;
+  xadj = graph->xadj;
+  vwgt = graph->vwgt;
+  adjncy = graph->adjncy;
+  adjwgt = graph->adjwgt;
+
+  cmap = graph->cmap;
+  match = idxset(nvtxs, UNMATCHED, idxwspacemalloc(ctrl, nvtxs));
+
+  perm = idxwspacemalloc(ctrl, nvtxs);
+  RandomPermute(nvtxs, perm, 1);
+
+  cnvtxs = 0;
+  for (ii=0; ii<nvtxs; ii++) {
+    i = perm[ii];
+
+    if (match[i] == UNMATCHED) {  /* Unmatched */
+      maxidx = i;
+      maxwgt = 0;
+
+      /* Find a heavy-edge matching, subject to maxvwgt constraints */
+      for (j=xadj[i]; j<xadj[i+1]; j++) {
+        k = adjncy[j];
+        if (match[k] == UNMATCHED && maxwgt < adjwgt[j] && vwgt[i]+vwgt[k] <= ctrl->maxvwgt) {
+          maxwgt = adjwgt[j];
+          maxidx = adjncy[j];
+        }
+      }
+
+      cmap[i] = cmap[maxidx] = cnvtxs++;
+      match[i] = maxidx;
+      match[maxidx] = i;
+    }
+  }
+
+  IFSET(ctrl->dbglvl, DBG_TIME, stoptimer(ctrl->MatchTmr));
+
+  CreateCoarseGraph(ctrl, graph, cnvtxs, match, perm);
+
+  idxwspacefree(ctrl, nvtxs);
+  idxwspacefree(ctrl, nvtxs);
+}
+
+
+
+/*************************************************************************
+* This function finds a matching using the HEM heuristic
+**************************************************************************/
+void Match_SHEM(CtrlType *ctrl, GraphType *graph)
+{
+  int i, ii, j, k, nvtxs, cnvtxs, maxidx, maxwgt, avgdegree;
+  idxtype *xadj, *vwgt, *adjncy, *adjwgt;
+  idxtype *match, *cmap, *degrees, *perm, *tperm;
+
+  IFSET(ctrl->dbglvl, DBG_TIME, starttimer(ctrl->MatchTmr));
+
+  nvtxs = graph->nvtxs;
+  xadj = graph->xadj;
+  vwgt = graph->vwgt;
+  adjncy = graph->adjncy;
+  adjwgt = graph->adjwgt;
+
+  cmap = graph->cmap;
+  match = idxset(nvtxs, UNMATCHED, idxwspacemalloc(ctrl, nvtxs));
+
+  perm = idxwspacemalloc(ctrl, nvtxs);
+  tperm = idxwspacemalloc(ctrl, nvtxs);
+  degrees = idxwspacemalloc(ctrl, nvtxs);
+
+  RandomPermute(nvtxs, tperm, 1);
+  avgdegree = 0.7*(xadj[nvtxs]/nvtxs);
+  for (i=0; i<nvtxs; i++) 
+    degrees[i] = (xadj[i+1]-xadj[i] > avgdegree ? avgdegree : xadj[i+1]-xadj[i]);
+  BucketSortKeysInc(nvtxs, avgdegree, degrees, tperm, perm);
+
+  cnvtxs = 0;
+
+  /* Take care any islands. Islands are matched with non-islands due to coarsening */
+  for (ii=0; ii<nvtxs; ii++) {
+    i = perm[ii];
+
+    if (match[i] == UNMATCHED) {  /* Unmatched */
+      if (xadj[i] < xadj[i+1])
+        break;
+
+      maxidx = i;
+      for (j=nvtxs-1; j>ii; j--) {
+        k = perm[j];
+        if (match[k] == UNMATCHED && xadj[k] < xadj[k+1]) {
+          maxidx = k;
+          break;
+        }
+      }
+
+      cmap[i] = cmap[maxidx] = cnvtxs++;
+      match[i] = maxidx;
+      match[maxidx] = i;
+    }
+  }
+
+  /* Continue with normal matching */
+  for (; ii<nvtxs; ii++) {
+    i = perm[ii];
+
+    if (match[i] == UNMATCHED) {  /* Unmatched */
+      maxidx = i;
+      maxwgt = 0;
+
+      /* Find a heavy-edge matching, subject to maxvwgt constraints */
+      for (j=xadj[i]; j<xadj[i+1]; j++) {
+        if (match[adjncy[j]] == UNMATCHED && maxwgt < adjwgt[j] && vwgt[i]+vwgt[adjncy[j]] <= ctrl->maxvwgt) {
+          maxwgt = adjwgt[j];
+          maxidx = adjncy[j];
+        }
+      }
+
+      cmap[i] = cmap[maxidx] = cnvtxs++;
+      match[i] = maxidx;
+      match[maxidx] = i;
+    }
+  }
+
+  IFSET(ctrl->dbglvl, DBG_TIME, stoptimer(ctrl->MatchTmr));
+
+  idxwspacefree(ctrl, nvtxs);  /* degrees */
+  idxwspacefree(ctrl, nvtxs);  /* tperm */
+
+  CreateCoarseGraph(ctrl, graph, cnvtxs, match, perm);
+
+  idxwspacefree(ctrl, nvtxs);
+  idxwspacefree(ctrl, nvtxs);
+}
+
Index: /inundation/pymetis/metis-4.0/Lib/mbalance.c
===================================================================
--- /inundation/pymetis/metis-4.0/Lib/mbalance.c	(revision 2051)
+++ /inundation/pymetis/metis-4.0/Lib/mbalance.c	(revision 2051)
@@ -0,0 +1,260 @@
+/*
+ * Copyright 1997, Regents of the University of Minnesota
+ *
+ * mbalance.c
+ *
+ * This file contains code that is used to forcefully balance either
+ * bisections or k-sections
+ *
+ * Started 7/29/97
+ * George
+ *
+ * $Id: mbalance.c,v 1.1 1998/11/27 17:59:19 karypis Exp $
+ *
+ */
+
+#include <metis.h>
+
+
+/*************************************************************************
+* This function is the entry point of the bisection balancing algorithms.
+**************************************************************************/
+void MocBalance2Way(CtrlType *ctrl, GraphType *graph, float *tpwgts, float lbfactor)
+{
+
+  if (Compute2WayHLoadImbalance(graph->ncon, graph->npwgts, tpwgts) < lbfactor)
+    return;
+
+  MocGeneral2WayBalance(ctrl, graph, tpwgts, lbfactor);
+
+}
+
+
+/*************************************************************************
+* This function performs an edge-based FM refinement
+**************************************************************************/
+void MocGeneral2WayBalance(CtrlType *ctrl, GraphType *graph, float *tpwgts, float lbfactor)
+{
+  int i, ii, j, k, l, kwgt, nvtxs, ncon, nbnd, nswaps, from, to, pass, me, limit, tmp, cnum;
+  idxtype *xadj, *adjncy, *adjwgt, *where, *id, *ed, *bndptr, *bndind;
+  idxtype *moved, *swaps, *perm, *qnum;
+  float *nvwgt, *npwgts, mindiff[MAXNCON], origbal, minbal, newbal;
+  PQueueType parts[MAXNCON][2];
+  int higain, oldgain, mincut, newcut, mincutorder;
+  int qsizes[MAXNCON][2];
+
+  nvtxs = graph->nvtxs;
+  ncon = graph->ncon;
+  xadj = graph->xadj;
+  nvwgt = graph->nvwgt;
+  adjncy = graph->adjncy;
+  adjwgt = graph->adjwgt;
+  where = graph->where;
+  id = graph->id;
+  ed = graph->ed;
+  npwgts = graph->npwgts;
+  bndptr = graph->bndptr;
+  bndind = graph->bndind;
+
+  moved = idxwspacemalloc(ctrl, nvtxs);
+  swaps = idxwspacemalloc(ctrl, nvtxs);
+  perm = idxwspacemalloc(ctrl, nvtxs);
+  qnum = idxwspacemalloc(ctrl, nvtxs);
+
+  limit = amin(amax(0.01*nvtxs, 15), 100);
+
+  /* Initialize the queues */
+  for (i=0; i<ncon; i++) {
+    PQueueInit(ctrl, &parts[i][0], nvtxs, PLUS_GAINSPAN+1);
+    PQueueInit(ctrl, &parts[i][1], nvtxs, PLUS_GAINSPAN+1);
+    qsizes[i][0] = qsizes[i][1] = 0;
+  }
+
+  for (i=0; i<nvtxs; i++) {
+    qnum[i] = samax(ncon, nvwgt+i*ncon);
+    qsizes[qnum[i]][where[i]]++;
+  }
+
+/*
+  printf("Weight Distribution:    \t");
+  for (i=0; i<ncon; i++) 
+    printf(" [%d %d]", qsizes[i][0], qsizes[i][1]); 
+  printf("\n");
+*/
+
+  for (from=0; from<2; from++) {
+    for (j=0; j<ncon; j++) {
+      if (qsizes[j][from] == 0) {
+        for (i=0; i<nvtxs; i++) {
+          if (where[i] != from)
+            continue;
+
+          k = samax2(ncon, nvwgt+i*ncon);
+          if (k == j && qsizes[qnum[i]][from] > qsizes[j][from] && nvwgt[i*ncon+qnum[i]] < 1.3*nvwgt[i*ncon+j]) {
+            qsizes[qnum[i]][from]--;
+            qsizes[j][from]++;
+            qnum[i] = j;
+          }
+        }
+      }
+    }
+  }
+
+/*
+  printf("Weight Distribution (after):\t ");
+  for (i=0; i<ncon; i++) 
+    printf(" [%d %d]", qsizes[i][0], qsizes[i][1]); 
+  printf("\n");
+*/
+
+
+
+  for (i=0; i<ncon; i++) 
+    mindiff[i] = fabs(tpwgts[0]-npwgts[i]);
+  minbal = origbal = Compute2WayHLoadImbalance(ncon, npwgts, tpwgts);
+  newcut = mincut = graph->mincut;
+  mincutorder = -1;
+
+  if (ctrl->dbglvl&DBG_REFINE) {
+    printf("Parts: [");
+    for (l=0; l<ncon; l++)
+      printf("(%.3f, %.3f) ", npwgts[l], npwgts[ncon+l]);
+    printf("] T[%.3f %.3f], Nv-Nb[%5d, %5d]. ICut: %6d, LB: %.3f [B]\n", tpwgts[0], tpwgts[1], graph->nvtxs, graph->nbnd, graph->mincut, origbal);
+  }
+
+  idxset(nvtxs, -1, moved);
+
+  ASSERT(ComputeCut(graph, where) == graph->mincut);
+  ASSERT(CheckBnd(graph));
+
+  /* Insert all nodes in the priority queues */
+  nbnd = graph->nbnd;
+  RandomPermute(nvtxs, perm, 1);
+  for (ii=0; ii<nvtxs; ii++) {
+    i = perm[ii];
+    PQueueInsert(&parts[qnum[i]][where[i]], i, ed[i]-id[i]);
+  }
+
+  for (nswaps=0; nswaps<nvtxs; nswaps++) {
+    if (minbal < lbfactor)
+      break;
+
+    SelectQueue(ncon, npwgts, tpwgts, &from, &cnum, parts);
+    to = (from+1)%2;
+
+    if (from == -1 || (higain = PQueueGetMax(&parts[cnum][from])) == -1)
+      break;
+
+    saxpy(ncon, 1.0, nvwgt+higain*ncon, 1, npwgts+to*ncon, 1);
+    saxpy(ncon, -1.0, nvwgt+higain*ncon, 1, npwgts+from*ncon, 1);
+    newcut -= (ed[higain]-id[higain]);
+    newbal = Compute2WayHLoadImbalance(ncon, npwgts, tpwgts);
+
+    if (newbal < minbal || (newbal == minbal && 
+        (newcut < mincut || (newcut == mincut && BetterBalance(ncon, npwgts, tpwgts, mindiff))))) {
+      mincut = newcut;
+      minbal = newbal;
+      mincutorder = nswaps;
+      for (i=0; i<ncon; i++)
+        mindiff[i] = fabs(tpwgts[0]-npwgts[i]);
+    }
+    else if (nswaps-mincutorder > limit) { /* We hit the limit, undo last move */
+      newcut += (ed[higain]-id[higain]);
+      saxpy(ncon, 1.0, nvwgt+higain*ncon, 1, npwgts+from*ncon, 1);
+      saxpy(ncon, -1.0, nvwgt+higain*ncon, 1, npwgts+to*ncon, 1);
+      break;
+    }
+
+    where[higain] = to;
+    moved[higain] = nswaps;
+    swaps[nswaps] = higain;
+
+    if (ctrl->dbglvl&DBG_MOVEINFO) {
+      printf("Moved %6d from %d(%d). Gain: %5d, Cut: %5d, NPwgts: ", higain, from, cnum, ed[higain]-id[higain], newcut);
+      for (l=0; l<ncon; l++) 
+        printf("(%.3f, %.3f) ", npwgts[l], npwgts[ncon+l]);
+      printf(", %.3f LB: %.3f\n", minbal, newbal);
+    }
+
+
+    /**************************************************************
+    * Update the id[i]/ed[i] values of the affected nodes
+    ***************************************************************/
+    SWAP(id[higain], ed[higain], tmp);
+    if (ed[higain] == 0 && bndptr[higain] != -1 && xadj[higain] < xadj[higain+1]) 
+      BNDDelete(nbnd, bndind,  bndptr, higain);
+    if (ed[higain] > 0 && bndptr[higain] == -1)
+      BNDInsert(nbnd, bndind,  bndptr, higain);
+
+    for (j=xadj[higain]; j<xadj[higain+1]; j++) {
+      k = adjncy[j];
+      oldgain = ed[k]-id[k];
+
+      kwgt = (to == where[k] ? adjwgt[j] : -adjwgt[j]);
+      INC_DEC(id[k], ed[k], kwgt);
+
+      /* Update the queue position */
+      if (moved[k] == -1)
+        PQueueUpdate(&parts[qnum[k]][where[k]], k, oldgain, ed[k]-id[k]);
+
+      /* Update its boundary information */
+      if (ed[k] == 0 && bndptr[k] != -1) 
+        BNDDelete(nbnd, bndind, bndptr, k);
+      else if (ed[k] > 0 && bndptr[k] == -1)  
+        BNDInsert(nbnd, bndind, bndptr, k);
+    }
+  }
+
+
+
+  /****************************************************************
+  * Roll back computations
+  *****************************************************************/
+  for (nswaps--; nswaps>mincutorder; nswaps--) {
+    higain = swaps[nswaps];
+
+    to = where[higain] = (where[higain]+1)%2;
+    SWAP(id[higain], ed[higain], tmp);
+    if (ed[higain] == 0 && bndptr[higain] != -1 && xadj[higain] < xadj[higain+1])
+      BNDDelete(nbnd, bndind,  bndptr, higain);
+    else if (ed[higain] > 0 && bndptr[higain] == -1)
+      BNDInsert(nbnd, bndind,  bndptr, higain);
+
+    saxpy(ncon, 1.0, nvwgt+higain*ncon, 1, npwgts+to*ncon, 1);
+    saxpy(ncon, -1.0, nvwgt+higain*ncon, 1, npwgts+((to+1)%2)*ncon, 1);
+    for (j=xadj[higain]; j<xadj[higain+1]; j++) {
+      k = adjncy[j];
+
+      kwgt = (to == where[k] ? adjwgt[j] : -adjwgt[j]);
+      INC_DEC(id[k], ed[k], kwgt);
+
+      if (bndptr[k] != -1 && ed[k] == 0)
+        BNDDelete(nbnd, bndind, bndptr, k);
+      if (bndptr[k] == -1 && ed[k] > 0)
+        BNDInsert(nbnd, bndind, bndptr, k);
+    }
+  }
+
+  if (ctrl->dbglvl&DBG_REFINE) {
+    printf("\tMincut: %6d at %5d, NBND: %6d, NPwgts: [", mincut, mincutorder, nbnd);
+    for (l=0; l<ncon; l++)
+      printf("(%.3f, %.3f) ", npwgts[l], npwgts[ncon+l]);
+    printf("], LB: %.3f\n", Compute2WayHLoadImbalance(ncon, npwgts, tpwgts));
+  }
+
+  graph->mincut = mincut;
+  graph->nbnd = nbnd;
+
+
+  for (i=0; i<ncon; i++) {
+    PQueueFree(ctrl, &parts[i][0]);
+    PQueueFree(ctrl, &parts[i][1]);
+  }
+
+  idxwspacefree(ctrl, nvtxs);
+  idxwspacefree(ctrl, nvtxs);
+  idxwspacefree(ctrl, nvtxs);
+  idxwspacefree(ctrl, nvtxs);
+
+}
+
Index: /inundation/pymetis/metis-4.0/Lib/mbalance2.c
===================================================================
--- /inundation/pymetis/metis-4.0/Lib/mbalance2.c	(revision 2051)
+++ /inundation/pymetis/metis-4.0/Lib/mbalance2.c	(revision 2051)
@@ -0,0 +1,328 @@
+/*
+ * Copyright 1997, Regents of the University of Minnesota
+ *
+ * mbalance2.c
+ *
+ * This file contains code that is used to forcefully balance either
+ * bisections or k-sections
+ *
+ * Started 7/29/97
+ * George
+ *
+ * $Id: mbalance2.c,v 1.1 1998/11/27 17:59:19 karypis Exp $
+ *
+ */
+
+#include <metis.h>
+
+
+/*************************************************************************
+* This function is the entry point of the bisection balancing algorithms.
+**************************************************************************/
+void MocBalance2Way2(CtrlType *ctrl, GraphType *graph, float *tpwgts, float *ubvec)
+{
+  int i;
+  float tvec[MAXNCON];
+
+  Compute2WayHLoadImbalanceVec(graph->ncon, graph->npwgts, tpwgts, tvec);
+  if (!AreAllBelow(graph->ncon, tvec, ubvec))
+    MocGeneral2WayBalance2(ctrl, graph, tpwgts, ubvec);
+}
+
+
+
+/*************************************************************************
+* This function performs an edge-based FM refinement
+**************************************************************************/
+void MocGeneral2WayBalance2(CtrlType *ctrl, GraphType *graph, float *tpwgts, float *ubvec)
+{
+  int i, ii, j, k, l, kwgt, nvtxs, ncon, nbnd, nswaps, from, to, pass, me, limit, tmp, cnum;
+  idxtype *xadj, *adjncy, *adjwgt, *where, *id, *ed, *bndptr, *bndind;
+  idxtype *moved, *swaps, *perm, *qnum;
+  float *nvwgt, *npwgts, origbal[MAXNCON], minbal[MAXNCON], newbal[MAXNCON];
+  PQueueType parts[MAXNCON][2];
+  int higain, oldgain, mincut, newcut, mincutorder;
+  float *maxwgt, *minwgt, tvec[MAXNCON];
+
+
+  nvtxs = graph->nvtxs;
+  ncon = graph->ncon;
+  xadj = graph->xadj;
+  nvwgt = graph->nvwgt;
+  adjncy = graph->adjncy;
+  adjwgt = graph->adjwgt;
+  where = graph->where;
+  id = graph->id;
+  ed = graph->ed;
+  npwgts = graph->npwgts;
+  bndptr = graph->bndptr;
+  bndind = graph->bndind;
+
+  moved = idxwspacemalloc(ctrl, nvtxs);
+  swaps = idxwspacemalloc(ctrl, nvtxs);
+  perm = idxwspacemalloc(ctrl, nvtxs);
+  qnum = idxwspacemalloc(ctrl, nvtxs);
+
+  limit = amin(amax(0.01*nvtxs, 15), 100);
+
+  /* Setup the weight intervals of the two subdomains */
+  minwgt = fwspacemalloc(ctrl, 2*ncon);
+  maxwgt = fwspacemalloc(ctrl, 2*ncon);
+
+  for (i=0; i<2; i++) {
+    for (j=0; j<ncon; j++) {
+      maxwgt[i*ncon+j] = tpwgts[i]*ubvec[j];
+      minwgt[i*ncon+j] = tpwgts[i]*(1.0/ubvec[j]);
+    }
+  }
+
+
+  /* Initialize the queues */
+  for (i=0; i<ncon; i++) {
+    PQueueInit(ctrl, &parts[i][0], nvtxs, PLUS_GAINSPAN+1);
+    PQueueInit(ctrl, &parts[i][1], nvtxs, PLUS_GAINSPAN+1);
+  }
+  for (i=0; i<nvtxs; i++)
+    qnum[i] = samax(ncon, nvwgt+i*ncon);
+
+  Compute2WayHLoadImbalanceVec(ncon, npwgts, tpwgts, origbal);
+  for (i=0; i<ncon; i++) 
+    minbal[i] = origbal[i];
+
+  newcut = mincut = graph->mincut;
+  mincutorder = -1;
+
+  if (ctrl->dbglvl&DBG_REFINE) {
+    printf("Parts: [");
+    for (l=0; l<ncon; l++)
+      printf("(%.3f, %.3f) ", npwgts[l], npwgts[ncon+l]);
+    printf("] T[%.3f %.3f], Nv-Nb[%5d, %5d]. ICut: %6d, LB: ", tpwgts[0], tpwgts[1], 
+            graph->nvtxs, graph->nbnd, graph->mincut);
+    for (i=0; i<ncon; i++)
+      printf("%.3f ", origbal[i]);
+    printf("[B]\n");
+  }
+
+  idxset(nvtxs, -1, moved);
+
+  ASSERT(ComputeCut(graph, where) == graph->mincut);
+  ASSERT(CheckBnd(graph));
+
+  /* Insert all nodes in the priority queues */
+  nbnd = graph->nbnd;
+  RandomPermute(nvtxs, perm, 1);
+  for (ii=0; ii<nvtxs; ii++) {
+    i = perm[ii];
+    PQueueInsert(&parts[qnum[i]][where[i]], i, ed[i]-id[i]);
+  }
+
+
+  for (nswaps=0; nswaps<nvtxs; nswaps++) {
+    if (AreAllBelow(ncon, minbal, ubvec))
+      break;
+
+    SelectQueue3(ncon, npwgts, tpwgts, &from, &cnum, parts, maxwgt);
+    to = (from+1)%2;
+
+    if (from == -1 || (higain = PQueueGetMax(&parts[cnum][from])) == -1)
+      break;
+
+    saxpy(ncon, 1.0, nvwgt+higain*ncon, 1, npwgts+to*ncon, 1);
+    saxpy(ncon, -1.0, nvwgt+higain*ncon, 1, npwgts+from*ncon, 1);
+    newcut -= (ed[higain]-id[higain]);
+    Compute2WayHLoadImbalanceVec(ncon, npwgts, tpwgts, newbal);
+
+    if (IsBetter2wayBalance(ncon, newbal, minbal, ubvec) || 
+        (IsBetter2wayBalance(ncon, newbal, origbal, ubvec) && newcut < mincut)) {
+      mincut = newcut;
+      for (i=0; i<ncon; i++) 
+        minbal[i] = newbal[i];
+      mincutorder = nswaps;
+    }
+    else if (nswaps-mincutorder > limit) { /* We hit the limit, undo last move */
+      newcut += (ed[higain]-id[higain]);
+      saxpy(ncon, 1.0, nvwgt+higain*ncon, 1, npwgts+from*ncon, 1);
+      saxpy(ncon, -1.0, nvwgt+higain*ncon, 1, npwgts+to*ncon, 1);
+      break;
+    }
+
+    where[higain] = to;
+    moved[higain] = nswaps;
+    swaps[nswaps] = higain;
+
+    if (ctrl->dbglvl&DBG_MOVEINFO) {
+      printf("Moved %6d from %d(%d). Gain: %5d, Cut: %5d, NPwgts: ", higain, from, cnum, ed[higain]-id[higain], newcut);
+      for (i=0; i<ncon; i++) 
+        printf("(%.3f, %.3f) ", npwgts[i], npwgts[ncon+i]);
+
+      Compute2WayHLoadImbalanceVec(ncon, npwgts, tpwgts, tvec);
+      printf(", LB: ");
+      for (i=0; i<ncon; i++) 
+        printf("%.3f ", tvec[i]);
+      if (mincutorder == nswaps)
+        printf(" *\n");
+      else
+        printf("\n");
+    }
+
+
+    /**************************************************************
+    * Update the id[i]/ed[i] values of the affected nodes
+    ***************************************************************/
+    SWAP(id[higain], ed[higain], tmp);
+    if (ed[higain] == 0 && bndptr[higain] != -1 && xadj[higain] < xadj[higain+1]) 
+      BNDDelete(nbnd, bndind,  bndptr, higain);
+    if (ed[higain] > 0 && bndptr[higain] == -1)
+      BNDInsert(nbnd, bndind,  bndptr, higain);
+
+    for (j=xadj[higain]; j<xadj[higain+1]; j++) {
+      k = adjncy[j];
+      oldgain = ed[k]-id[k];
+
+      kwgt = (to == where[k] ? adjwgt[j] : -adjwgt[j]);
+      INC_DEC(id[k], ed[k], kwgt);
+
+      /* Update the queue position */
+      if (moved[k] == -1)
+        PQueueUpdate(&parts[qnum[k]][where[k]], k, oldgain, ed[k]-id[k]);
+
+      /* Update its boundary information */
+      if (ed[k] == 0 && bndptr[k] != -1) 
+        BNDDelete(nbnd, bndind, bndptr, k);
+      else if (ed[k] > 0 && bndptr[k] == -1)  
+        BNDInsert(nbnd, bndind, bndptr, k);
+    }
+   
+  }
+
+
+
+  /****************************************************************
+  * Roll back computations
+  *****************************************************************/
+  for (i=0; i<nswaps; i++)
+    moved[swaps[i]] = -1;  /* reset moved array */
+  for (nswaps--; nswaps>mincutorder; nswaps--) {
+    higain = swaps[nswaps];
+
+    to = where[higain] = (where[higain]+1)%2;
+    SWAP(id[higain], ed[higain], tmp);
+    if (ed[higain] == 0 && bndptr[higain] != -1 && xadj[higain] < xadj[higain+1])
+      BNDDelete(nbnd, bndind,  bndptr, higain);
+    else if (ed[higain] > 0 && bndptr[higain] == -1)
+      BNDInsert(nbnd, bndind,  bndptr, higain);
+
+    saxpy(ncon, 1.0, nvwgt+higain*ncon, 1, npwgts+to*ncon, 1);
+    saxpy(ncon, -1.0, nvwgt+higain*ncon, 1, npwgts+((to+1)%2)*ncon, 1);
+    for (j=xadj[higain]; j<xadj[higain+1]; j++) {
+      k = adjncy[j];
+
+      kwgt = (to == where[k] ? adjwgt[j] : -adjwgt[j]);
+      INC_DEC(id[k], ed[k], kwgt);
+
+      if (bndptr[k] != -1 && ed[k] == 0)
+        BNDDelete(nbnd, bndind, bndptr, k);
+      if (bndptr[k] == -1 && ed[k] > 0)
+        BNDInsert(nbnd, bndind, bndptr, k);
+    }
+  }
+
+  if (ctrl->dbglvl&DBG_REFINE) {
+    printf("\tMincut: %6d at %5d, NBND: %6d, NPwgts: [", mincut, mincutorder, nbnd);
+    for (i=0; i<ncon; i++)
+      printf("(%.3f, %.3f) ", npwgts[i], npwgts[ncon+i]);
+    printf("], LB: ");
+    Compute2WayHLoadImbalanceVec(ncon, npwgts, tpwgts, tvec);
+    for (i=0; i<ncon; i++) 
+      printf("%.3f ", tvec[i]);
+    printf("\n");
+  }
+
+  graph->mincut = mincut;
+  graph->nbnd = nbnd;
+
+
+  for (i=0; i<ncon; i++) {
+    PQueueFree(ctrl, &parts[i][0]);
+    PQueueFree(ctrl, &parts[i][1]);
+  }
+
+  idxwspacefree(ctrl, nvtxs);
+  idxwspacefree(ctrl, nvtxs);
+  idxwspacefree(ctrl, nvtxs);
+  idxwspacefree(ctrl, nvtxs);
+  fwspacefree(ctrl, 2*ncon);
+  fwspacefree(ctrl, 2*ncon);
+
+}
+
+
+
+
+/*************************************************************************
+* This function selects the partition number and the queue from which
+* we will move vertices out
+**************************************************************************/ 
+void SelectQueue3(int ncon, float *npwgts, float *tpwgts, int *from, int *cnum, 
+       PQueueType queues[MAXNCON][2], float *maxwgt)
+{
+  int i, j, maxgain=0;
+  float maxdiff=0.0, diff;
+
+  *from = -1;
+  *cnum = -1;
+
+  /* First determine the side and the queue, irrespective of the presence of nodes */
+  for (j=0; j<2; j++) {
+    for (i=0; i<ncon; i++) {
+      diff = npwgts[j*ncon+i]-maxwgt[j*ncon+i];
+      if (diff >= maxdiff) {
+        maxdiff = diff;
+        *from = j;
+        *cnum = i;
+      }
+    }
+  }
+
+/* DELETE
+j = *from;
+for (i=0; i<ncon; i++)
+  printf("[%5d %5d %.4f %.4f] ", i, PQueueGetSize(&queues[i][j]), npwgts[j*ncon+i], maxwgt[j*ncon+i]);
+printf("***[%5d %5d]\n", *cnum, *from);
+*/
+
+  /* If the desired queue is empty, select a node from that side anyway */
+  if (*from != -1 && PQueueGetSize(&queues[*cnum][*from]) == 0) {
+    for (i=0; i<ncon; i++) {
+      if (PQueueGetSize(&queues[i][*from]) > 0) {
+        maxdiff = (npwgts[(*from)*ncon+i] - maxwgt[(*from)*ncon+i]);
+        *cnum = i;
+        break;
+      }
+    }
+
+    for (i++; i<ncon; i++) {
+      diff = npwgts[(*from)*ncon+i] - maxwgt[(*from)*ncon+i];
+      if (diff > maxdiff && PQueueGetSize(&queues[i][*from]) > 0) {
+        maxdiff = diff;
+        *cnum = i;
+      }
+    }
+  }
+
+  /* If the constraints ar OK, select a high gain vertex */
+  if (*from == -1) {
+    maxgain = -100000;
+    for (j=0; j<2; j++) {
+      for (i=0; i<ncon; i++) {
+        if (PQueueGetSize(&queues[i][j]) > 0 && PQueueGetKey(&queues[i][j]) > maxgain) {
+          maxgain = PQueueGetKey(&queues[i][0]); 
+          *from = j;
+          *cnum = i;
+        }
+      }
+    }
+
+    /* printf("(%2d %2d) %3d\n", *from, *cnum, maxgain); */
+  }
+}
Index: /inundation/pymetis/metis-4.0/Lib/mcoarsen.c
===================================================================
--- /inundation/pymetis/metis-4.0/Lib/mcoarsen.c	(revision 2051)
+++ /inundation/pymetis/metis-4.0/Lib/mcoarsen.c	(revision 2051)
@@ -0,0 +1,91 @@
+/*
+ * mcoarsen.c
+ *
+ * This file contains the driving routines for the coarsening process 
+ *
+ * Started 7/23/97
+ * George
+ *
+ * $Id: mcoarsen.c,v 1.1 1998/11/27 17:59:19 karypis Exp $
+ *
+ */
+
+#include <metis.h>
+
+
+/*************************************************************************
+* This function takes a graph and creates a sequence of coarser graphs
+**************************************************************************/
+GraphType *MCCoarsen2Way(CtrlType *ctrl, GraphType *graph)
+{
+  int i, clevel;
+  GraphType *cgraph;
+
+  IFSET(ctrl->dbglvl, DBG_TIME, starttimer(ctrl->CoarsenTmr));
+
+  cgraph = graph;
+
+  clevel = 0;
+  do {
+    if (ctrl->dbglvl&DBG_COARSEN) {
+      printf("%6d %7d %10d [%d] [%6.4f", cgraph->nvtxs, cgraph->nedges, 
+              idxsum(cgraph->nvtxs, cgraph->adjwgtsum), ctrl->CoarsenTo, ctrl->nmaxvwgt);
+      for (i=0; i<graph->ncon; i++)
+        printf(" %5.3f", ssum_strd(cgraph->nvtxs, cgraph->nvwgt+i, cgraph->ncon));
+      printf("]\n");
+    }
+
+    switch (ctrl->CType) {
+      case MATCH_RM:
+        MCMatch_RM(ctrl, cgraph);
+        break;
+      case MATCH_HEM:
+        if (clevel < 1)
+          MCMatch_RM(ctrl, cgraph);
+        else
+          MCMatch_HEM(ctrl, cgraph);
+        break;
+      case MATCH_SHEM:
+        if (clevel < 1)
+          MCMatch_RM(ctrl, cgraph);
+        else
+          MCMatch_SHEM(ctrl, cgraph);
+        break;
+      case MATCH_SHEMKWAY:
+        MCMatch_SHEM(ctrl, cgraph);
+        break;
+      case MATCH_SHEBM_ONENORM:
+        MCMatch_SHEBM(ctrl, cgraph, 1);
+        break;
+      case MATCH_SHEBM_INFNORM:
+        MCMatch_SHEBM(ctrl, cgraph, -1);
+        break;
+      case MATCH_SBHEM_ONENORM:
+        MCMatch_SBHEM(ctrl, cgraph, 1);
+        break;
+      case MATCH_SBHEM_INFNORM:
+        MCMatch_SBHEM(ctrl, cgraph, -1);
+        break;
+      default:
+        errexit("Unknown CType: %d\n", ctrl->CType);
+    }
+
+    cgraph = cgraph->coarser;
+    clevel++;
+
+  } while (cgraph->nvtxs > ctrl->CoarsenTo && cgraph->nvtxs < COARSEN_FRACTION2*cgraph->finer->nvtxs && cgraph->nedges > cgraph->nvtxs/2); 
+
+  if (ctrl->dbglvl&DBG_COARSEN) {
+    printf("%6d %7d %10d [%d] [%6.4f", cgraph->nvtxs, cgraph->nedges, 
+            idxsum(cgraph->nvtxs, cgraph->adjwgtsum), ctrl->CoarsenTo, ctrl->nmaxvwgt);
+    for (i=0; i<graph->ncon; i++)
+      printf(" %5.3f", ssum_strd(cgraph->nvtxs, cgraph->nvwgt+i, cgraph->ncon));
+    printf("]\n");
+  }
+
+
+  IFSET(ctrl->dbglvl, DBG_TIME, stoptimer(ctrl->CoarsenTmr));
+
+  return cgraph;
+}
+
Index: /inundation/pymetis/metis-4.0/Lib/memory.c
===================================================================
--- /inundation/pymetis/metis-4.0/Lib/memory.c	(revision 2051)
+++ /inundation/pymetis/metis-4.0/Lib/memory.c	(revision 2051)
@@ -0,0 +1,208 @@
+/*
+ * Copyright 1997, Regents of the University of Minnesota
+ *
+ * memory.c
+ *
+ * This file contains routines that deal with memory allocation
+ *
+ * Started 2/24/96
+ * George
+ *
+ * $Id: memory.c,v 1.2 1998/11/27 18:16:18 karypis Exp $
+ *
+ */
+
+#include <metis.h>
+
+
+/*************************************************************************
+* This function allocates memory for the workspace
+**************************************************************************/
+void AllocateWorkSpace(CtrlType *ctrl, GraphType *graph, int nparts)
+{
+  ctrl->wspace.pmat = NULL;
+
+  if (ctrl->optype == OP_KMETIS) {
+    ctrl->wspace.edegrees = (EDegreeType *)GKmalloc(graph->nedges*sizeof(EDegreeType), "AllocateWorkSpace: edegrees");
+    ctrl->wspace.vedegrees = NULL;
+    ctrl->wspace.auxcore = (idxtype *)ctrl->wspace.edegrees;
+
+    ctrl->wspace.pmat = idxmalloc(nparts*nparts, "AllocateWorkSpace: pmat");
+
+    /* Memory requirements for different phases
+          Coarsening
+                    Matching: 4*nvtxs vectors
+                 Contraction: 2*nvtxs vectors (from the above 4), 1*nparts, 1*Nedges
+            Total = MAX(4*nvtxs, 2*nvtxs+nparts+nedges)
+
+          Refinement
+                Random Refinement/Balance: 5*nparts + 1*nvtxs + 2*nedges
+                Greedy Refinement/Balance: 5*nparts + 2*nvtxs + 2*nedges + 1*PQueue(==Nvtxs)
+            Total = 5*nparts + 3*nvtxs + 2*nedges
+
+         Total = 5*nparts + 3*nvtxs + 2*nedges 
+    */
+    ctrl->wspace.maxcore = 3*(graph->nvtxs+1) +                 /* Match/Refinement vectors */
+                           5*(nparts+1) +                       /* Partition weights etc */
+                           graph->nvtxs*(sizeof(ListNodeType)/sizeof(idxtype)) + /* Greedy k-way balance/refine */
+                           20  /* padding for 64 bit machines */
+                           ;
+  }
+  else if (ctrl->optype == OP_KVMETIS) {
+    ctrl->wspace.edegrees = NULL;
+    ctrl->wspace.vedegrees = (VEDegreeType *)GKmalloc(graph->nedges*sizeof(VEDegreeType), "AllocateWorkSpace: vedegrees");
+    ctrl->wspace.auxcore = (idxtype *)ctrl->wspace.vedegrees;
+
+    ctrl->wspace.pmat = idxmalloc(nparts*nparts, "AllocateWorkSpace: pmat");
+
+    /* Memory requirements for different phases are identical to KMETIS */
+    ctrl->wspace.maxcore = 3*(graph->nvtxs+1) +                 /* Match/Refinement vectors */
+                           3*(nparts+1) +                       /* Partition weights etc */
+                           graph->nvtxs*(sizeof(ListNodeType)/sizeof(idxtype)) + /* Greedy k-way balance/refine */
+                           20  /* padding for 64 bit machines */
+                           ;
+  }
+  else {
+    ctrl->wspace.edegrees = (EDegreeType *)idxmalloc(graph->nedges, "AllocateWorkSpace: edegrees");
+    ctrl->wspace.vedegrees = NULL;
+    ctrl->wspace.auxcore = (idxtype *)ctrl->wspace.edegrees;
+
+    ctrl->wspace.maxcore = 5*(graph->nvtxs+1) +                 /* Refinement vectors */
+                           4*(nparts+1) +                       /* Partition weights etc */
+                           2*graph->ncon*graph->nvtxs*(sizeof(ListNodeType)/sizeof(idxtype)) + /* 2-way refinement */
+                           2*graph->ncon*(NEG_GAINSPAN+PLUS_GAINSPAN+1)*(sizeof(ListNodeType *)/sizeof(idxtype)) + /* 2-way refinement */
+                           20  /* padding for 64 bit machines */
+                           ;
+  }
+
+  ctrl->wspace.maxcore += HTLENGTH;
+  ctrl->wspace.core = idxmalloc(ctrl->wspace.maxcore, "AllocateWorkSpace: maxcore");
+  ctrl->wspace.ccore = 0;
+}
+
+
+/*************************************************************************
+* This function allocates memory for the workspace
+**************************************************************************/
+void FreeWorkSpace(CtrlType *ctrl, GraphType *graph)
+{
+  GKfree(&ctrl->wspace.edegrees, &ctrl->wspace.vedegrees, &ctrl->wspace.core, &ctrl->wspace.pmat, LTERM);
+}
+
+/*************************************************************************
+* This function returns how may words are left in the workspace
+**************************************************************************/
+int WspaceAvail(CtrlType *ctrl)
+{
+  return ctrl->wspace.maxcore - ctrl->wspace.ccore;
+}
+
+
+/*************************************************************************
+* This function allocate space from the core 
+**************************************************************************/
+idxtype *idxwspacemalloc(CtrlType *ctrl, int n)
+{
+  n += n%2; /* This is a fix for 64 bit machines that require 8-byte pointer allignment */
+
+  ctrl->wspace.ccore += n;
+  ASSERT(ctrl->wspace.ccore <= ctrl->wspace.maxcore);
+  return ctrl->wspace.core + ctrl->wspace.ccore - n;
+}
+
+/*************************************************************************
+* This function frees space from the core 
+**************************************************************************/
+void idxwspacefree(CtrlType *ctrl, int n)
+{
+  n += n%2; /* This is a fix for 64 bit machines that require 8-byte pointer allignment */
+
+  ctrl->wspace.ccore -= n;
+  ASSERT(ctrl->wspace.ccore >= 0);
+}
+
+
+/*************************************************************************
+* This function allocate space from the core 
+**************************************************************************/
+float *fwspacemalloc(CtrlType *ctrl, int n)
+{
+  n += n%2; /* This is a fix for 64 bit machines that require 8-byte pointer allignment */
+
+  ctrl->wspace.ccore += n;
+  ASSERT(ctrl->wspace.ccore <= ctrl->wspace.maxcore);
+  return (float *) (ctrl->wspace.core + ctrl->wspace.ccore - n);
+}
+
+/*************************************************************************
+* This function frees space from the core 
+**************************************************************************/
+void fwspacefree(CtrlType *ctrl, int n)
+{
+  n += n%2; /* This is a fix for 64 bit machines that require 8-byte pointer allignment */
+
+  ctrl->wspace.ccore -= n;
+  ASSERT(ctrl->wspace.ccore >= 0);
+}
+
+
+
+/*************************************************************************
+* This function creates a CoarseGraphType data structure and initializes
+* the various fields
+**************************************************************************/
+GraphType *CreateGraph(void)
+{
+  GraphType *graph;
+
+  graph = (GraphType *)GKmalloc(sizeof(GraphType), "CreateCoarseGraph: graph");
+
+  InitGraph(graph);
+
+  return graph;
+}
+
+
+/*************************************************************************
+* This function creates a CoarseGraphType data structure and initializes
+* the various fields
+**************************************************************************/
+void InitGraph(GraphType *graph) 
+{
+  graph->gdata = graph->rdata = NULL;
+
+  graph->nvtxs = graph->nedges = -1;
+  graph->mincut = graph->minvol = -1;
+
+  graph->xadj = graph->vwgt = graph->adjncy = graph->adjwgt = NULL;
+  graph->adjwgtsum = NULL;
+  graph->label = NULL;
+  graph->cmap = NULL;
+
+  graph->where = graph->pwgts = NULL;
+  graph->id = graph->ed = NULL;
+  graph->bndptr = graph->bndind = NULL;
+  graph->rinfo = NULL;
+  graph->vrinfo = NULL;
+  graph->nrinfo = NULL;
+
+  graph->ncon = -1;
+  graph->nvwgt = NULL;
+  graph->npwgts = NULL;
+
+  graph->vsize = NULL;
+
+  graph->coarser = graph->finer = NULL;
+
+}
+
+/*************************************************************************
+* This function deallocates any memory stored in a graph
+**************************************************************************/
+void FreeGraph(GraphType *graph) 
+{
+
+  GKfree(&graph->gdata, &graph->nvwgt, &graph->rdata, &graph->npwgts, LTERM);
+  free(graph);
+}
+
Index: /inundation/pymetis/metis-4.0/Lib/mesh.c
===================================================================
--- /inundation/pymetis/metis-4.0/Lib/mesh.c	(revision 2051)
+++ /inundation/pymetis/metis-4.0/Lib/mesh.c	(revision 2051)
@@ -0,0 +1,398 @@
+/*
+ * Copyright 1997, Regents of the University of Minnesota
+ *
+ * mesh.c
+ *
+ * This file contains routines for converting 3D and 4D finite element
+ * meshes into dual or nodal graphs
+ *
+ * Started 8/18/97
+ * George
+ *
+ * $Id: mesh.c,v 1.1 1998/11/27 17:59:20 karypis Exp $
+ *
+ */
+
+#include <metis.h>
+
+/*****************************************************************************
+* This function creates a graph corresponding to the dual of a finite element
+* mesh. At this point the supported elements are triangles, tetrahedrons, and
+* bricks.
+******************************************************************************/
+void METIS_MeshToDual(int *ne, int *nn, idxtype *elmnts, int *etype, int *numflag, 
+                      idxtype *dxadj, idxtype *dadjncy)
+{
+  int esizes[] = {-1, 3, 4, 8, 4};
+
+  if (*numflag == 1)
+    ChangeMesh2CNumbering((*ne)*esizes[*etype], elmnts);
+
+  GENDUALMETIS(*ne, *nn, *etype, elmnts, dxadj, dadjncy);
+
+  if (*numflag == 1)
+    ChangeMesh2FNumbering((*ne)*esizes[*etype], elmnts, *ne, dxadj, dadjncy);
+}
+
+
+/*****************************************************************************
+* This function creates a graph corresponding to the finite element mesh. 
+* At this point the supported elements are triangles, tetrahedrons.
+******************************************************************************/
+void METIS_MeshToNodal(int *ne, int *nn, idxtype *elmnts, int *etype, int *numflag, 
+                       idxtype *dxadj, idxtype *dadjncy)
+{
+  int esizes[] = {-1, 3, 4, 8, 4};
+
+  if (*numflag == 1)
+    ChangeMesh2CNumbering((*ne)*esizes[*etype], elmnts);
+
+  switch (*etype) {
+    case 1:
+      TRINODALMETIS(*ne, *nn, elmnts, dxadj, dadjncy);
+      break;
+    case 2:
+      TETNODALMETIS(*ne, *nn, elmnts, dxadj, dadjncy);
+      break;
+    case 3:
+      HEXNODALMETIS(*ne, *nn, elmnts, dxadj, dadjncy);
+      break;
+    case 4:
+      QUADNODALMETIS(*ne, *nn, elmnts, dxadj, dadjncy);
+      break;
+  }
+
+  if (*numflag == 1)
+    ChangeMesh2FNumbering((*ne)*esizes[*etype], elmnts, *nn, dxadj, dadjncy);
+}
+
+
+
+/*****************************************************************************
+* This function creates the dual of a finite element mesh
+******************************************************************************/
+void GENDUALMETIS(int nelmnts, int nvtxs, int etype, idxtype *elmnts, idxtype *dxadj, idxtype *dadjncy)
+{
+   int i, j, jj, k, kk, kkk, l, m, n, nedges, mask;
+   idxtype *nptr, *nind;
+   idxtype *mark, ind[200], wgt[200];
+   int esize, esizes[] = {-1, 3, 4, 8, 4},
+       mgcnum, mgcnums[] = {-1, 2, 3, 4, 2};
+
+   mask = (1<<11)-1;
+   mark = idxsmalloc(mask+1, -1, "GENDUALMETIS: mark");
+
+   /* Get the element size and magic number for the particular element */
+   esize = esizes[etype];
+   mgcnum = mgcnums[etype];
+
+   /* Construct the node-element list first */
+   nptr = idxsmalloc(nvtxs+1, 0, "GENDUALMETIS: nptr");
+   for (j=esize*nelmnts, i=0; i<j; i++) 
+     nptr[elmnts[i]]++;
+   MAKECSR(i, nvtxs, nptr);
+
+   nind = idxmalloc(nptr[nvtxs], "GENDUALMETIS: nind");
+   for (k=i=0; i<nelmnts; i++) {
+     for (j=0; j<esize; j++, k++) 
+       nind[nptr[elmnts[k]]++] = i;
+   }
+   for (i=nvtxs; i>0; i--)
+     nptr[i] = nptr[i-1];
+   nptr[0] = 0;
+
+   for (i=0; i<nelmnts; i++) 
+     dxadj[i] = esize*i;
+
+   for (i=0; i<nelmnts; i++) {
+     for (m=j=0; j<esize; j++) {
+       n = elmnts[esize*i+j];
+       for (k=nptr[n+1]-1; k>=nptr[n]; k--) {
+         if ((kk = nind[k]) <= i)
+           break;
+
+         kkk = kk&mask;
+         if ((l = mark[kkk]) == -1) {
+           ind[m] = kk;
+           wgt[m] = 1;
+           mark[kkk] = m++;
+         }
+         else if (ind[l] == kk) {
+           wgt[l]++;
+         }
+         else {
+           for (jj=0; jj<m; jj++) {
+             if (ind[jj] == kk) {
+               wgt[jj]++;
+               break;
+             }
+           }
+           if (jj == m) {
+             ind[m] = kk;
+             wgt[m++] = 1;
+           }
+         }
+       }
+     }
+     for (j=0; j<m; j++) {
+       if (wgt[j] == mgcnum) {
+         k = ind[j];
+         dadjncy[dxadj[i]++] = k;
+         dadjncy[dxadj[k]++] = i;
+       }
+       mark[ind[j]&mask] = -1;
+     }
+   }
+
+   /* Go and consolidate the dxadj and dadjncy */
+   for (j=i=0; i<nelmnts; i++) {
+     for (k=esize*i; k<dxadj[i]; k++, j++)
+       dadjncy[j] = dadjncy[k];
+     dxadj[i] = j;
+   }
+   for (i=nelmnts; i>0; i--)
+     dxadj[i] = dxadj[i-1];
+   dxadj[0] = 0;
+
+   free(mark);
+   free(nptr);
+   free(nind);
+
+}
+
+
+
+
+/*****************************************************************************
+* This function creates the nodal graph of a finite element mesh
+******************************************************************************/
+void TRINODALMETIS(int nelmnts, int nvtxs, idxtype *elmnts, idxtype *dxadj, idxtype *dadjncy)
+{
+   int i, j, jj, k, kk, kkk, l, m, n, nedges;
+   idxtype *nptr, *nind;
+   idxtype *mark;
+
+   /* Construct the node-element list first */
+   nptr = idxsmalloc(nvtxs+1, 0, "TRINODALMETIS: nptr");
+   for (j=3*nelmnts, i=0; i<j; i++) 
+     nptr[elmnts[i]]++;
+   MAKECSR(i, nvtxs, nptr);
+
+   nind = idxmalloc(nptr[nvtxs], "TRINODALMETIS: nind");
+   for (k=i=0; i<nelmnts; i++) {
+     for (j=0; j<3; j++, k++) 
+       nind[nptr[elmnts[k]]++] = i;
+   }
+   for (i=nvtxs; i>0; i--)
+     nptr[i] = nptr[i-1];
+   nptr[0] = 0;
+
+
+   mark = idxsmalloc(nvtxs, -1, "TRINODALMETIS: mark");
+
+   nedges = dxadj[0] = 0;
+   for (i=0; i<nvtxs; i++) {
+     mark[i] = i;
+     for (j=nptr[i]; j<nptr[i+1]; j++) {
+       for (jj=3*nind[j], k=0; k<3; k++, jj++) {
+         kk = elmnts[jj];
+         if (mark[kk] != i) {
+           mark[kk] = i;
+           dadjncy[nedges++] = kk;
+         }
+       }
+     }
+     dxadj[i+1] = nedges;
+   }
+
+   free(mark);
+   free(nptr);
+   free(nind);
+
+}
+
+
+/*****************************************************************************
+* This function creates the nodal graph of a finite element mesh
+******************************************************************************/
+void TETNODALMETIS(int nelmnts, int nvtxs, idxtype *elmnts, idxtype *dxadj, idxtype *dadjncy)
+{
+   int i, j, jj, k, kk, kkk, l, m, n, nedges;
+   idxtype *nptr, *nind;
+   idxtype *mark;
+
+   /* Construct the node-element list first */
+   nptr = idxsmalloc(nvtxs+1, 0, "TETNODALMETIS: nptr");
+   for (j=4*nelmnts, i=0; i<j; i++) 
+     nptr[elmnts[i]]++;
+   MAKECSR(i, nvtxs, nptr);
+
+   nind = idxmalloc(nptr[nvtxs], "TETNODALMETIS: nind");
+   for (k=i=0; i<nelmnts; i++) {
+     for (j=0; j<4; j++, k++) 
+       nind[nptr[elmnts[k]]++] = i;
+   }
+   for (i=nvtxs; i>0; i--)
+     nptr[i] = nptr[i-1];
+   nptr[0] = 0;
+
+
+   mark = idxsmalloc(nvtxs, -1, "TETNODALMETIS: mark");
+
+   nedges = dxadj[0] = 0;
+   for (i=0; i<nvtxs; i++) {
+     mark[i] = i;
+     for (j=nptr[i]; j<nptr[i+1]; j++) {
+       for (jj=4*nind[j], k=0; k<4; k++, jj++) {
+         kk = elmnts[jj];
+         if (mark[kk] != i) {
+           mark[kk] = i;
+           dadjncy[nedges++] = kk;
+         }
+       }
+     }
+     dxadj[i+1] = nedges;
+   }
+
+   free(mark);
+   free(nptr);
+   free(nind);
+
+}
+
+
+/*****************************************************************************
+* This function creates the nodal graph of a finite element mesh
+******************************************************************************/
+void HEXNODALMETIS(int nelmnts, int nvtxs, idxtype *elmnts, idxtype *dxadj, idxtype *dadjncy)
+{
+   int i, j, jj, k, kk, kkk, l, m, n, nedges;
+   idxtype *nptr, *nind;
+   idxtype *mark;
+   int table[8][3] = {1, 3, 4,
+                      0, 2, 5,
+                      1, 3, 6,
+                      0, 2, 7,
+                      0, 5, 7,
+                      1, 4, 6,
+                      2, 5, 7,
+                      3, 4, 6};
+
+   /* Construct the node-element list first */
+   nptr = idxsmalloc(nvtxs+1, 0, "HEXNODALMETIS: nptr");
+   for (j=8*nelmnts, i=0; i<j; i++) 
+     nptr[elmnts[i]]++;
+   MAKECSR(i, nvtxs, nptr);
+
+   nind = idxmalloc(nptr[nvtxs], "HEXNODALMETIS: nind");
+   for (k=i=0; i<nelmnts; i++) {
+     for (j=0; j<8; j++, k++) 
+       nind[nptr[elmnts[k]]++] = i;
+   }
+   for (i=nvtxs; i>0; i--)
+     nptr[i] = nptr[i-1];
+   nptr[0] = 0;
+
+
+   mark = idxsmalloc(nvtxs, -1, "HEXNODALMETIS: mark");
+
+   nedges = dxadj[0] = 0;
+   for (i=0; i<nvtxs; i++) {
+     mark[i] = i;
+     for (j=nptr[i]; j<nptr[i+1]; j++) {
+       jj=8*nind[j];
+       for (k=0; k<8; k++) {
+         if (elmnts[jj+k] == i)
+           break;
+       }
+       ASSERT(k != 8);
+
+       /* You found the index, now go and put the 3 neighbors */
+       kk = elmnts[jj+table[k][0]];
+       if (mark[kk] != i) {
+         mark[kk] = i;
+         dadjncy[nedges++] = kk;
+       }
+       kk = elmnts[jj+table[k][1]];
+       if (mark[kk] != i) {
+         mark[kk] = i;
+         dadjncy[nedges++] = kk;
+       }
+       kk = elmnts[jj+table[k][2]];
+       if (mark[kk] != i) {
+         mark[kk] = i;
+         dadjncy[nedges++] = kk;
+       }
+     }
+     dxadj[i+1] = nedges;
+   }
+
+   free(mark);
+   free(nptr);
+   free(nind);
+
+}
+
+
+/*****************************************************************************
+* This function creates the nodal graph of a finite element mesh
+******************************************************************************/
+void QUADNODALMETIS(int nelmnts, int nvtxs, idxtype *elmnts, idxtype *dxadj, idxtype *dadjncy)
+{
+   int i, j, jj, k, kk, kkk, l, m, n, nedges;
+   idxtype *nptr, *nind;
+   idxtype *mark;
+   int table[4][2] = {1, 3, 
+                      0, 2,
+                      1, 3, 
+                      0, 2}; 
+
+   /* Construct the node-element list first */
+   nptr = idxsmalloc(nvtxs+1, 0, "QUADNODALMETIS: nptr");
+   for (j=4*nelmnts, i=0; i<j; i++) 
+     nptr[elmnts[i]]++;
+   MAKECSR(i, nvtxs, nptr);
+
+   nind = idxmalloc(nptr[nvtxs], "QUADNODALMETIS: nind");
+   for (k=i=0; i<nelmnts; i++) {
+     for (j=0; j<4; j++, k++) 
+       nind[nptr[elmnts[k]]++] = i;
+   }
+   for (i=nvtxs; i>0; i--)
+     nptr[i] = nptr[i-1];
+   nptr[0] = 0;
+
+
+   mark = idxsmalloc(nvtxs, -1, "QUADNODALMETIS: mark");
+
+   nedges = dxadj[0] = 0;
+   for (i=0; i<nvtxs; i++) {
+     mark[i] = i;
+     for (j=nptr[i]; j<nptr[i+1]; j++) {
+       jj=4*nind[j];
+       for (k=0; k<4; k++) {
+         if (elmnts[jj+k] == i)
+           break;
+       }
+       ASSERT(k != 4);
+
+       /* You found the index, now go and put the 2 neighbors */
+       kk = elmnts[jj+table[k][0]];
+       if (mark[kk] != i) {
+         mark[kk] = i;
+         dadjncy[nedges++] = kk;
+       }
+       kk = elmnts[jj+table[k][1]];
+       if (mark[kk] != i) {
+         mark[kk] = i;
+         dadjncy[nedges++] = kk;
+       }
+     }
+     dxadj[i+1] = nedges;
+   }
+
+   free(mark);
+   free(nptr);
+   free(nind);
+
+}
Index: /inundation/pymetis/metis-4.0/Lib/meshpart.c
===================================================================
--- /inundation/pymetis/metis-4.0/Lib/meshpart.c	(revision 2051)
+++ /inundation/pymetis/metis-4.0/Lib/meshpart.c	(revision 2051)
@@ -0,0 +1,204 @@
+/*
+ * Copyright 1997, Regents of the University of Minnesota
+ *
+ * meshpart.c
+ *
+ * This file contains routines for partitioning finite element meshes.
+ *
+ * Started 9/29/97
+ * George
+ *
+ * $Id: meshpart.c,v 1.1 1998/11/27 17:59:21 karypis Exp $
+ *
+ */
+
+#include <metis.h>
+
+
+/*************************************************************************
+* This function partitions a finite element mesh by partitioning its nodal
+* graph using KMETIS and then assigning elements in a load balanced fashion.
+**************************************************************************/
+void METIS_PartMeshNodal(int *ne, int *nn, idxtype *elmnts, int *etype, int *numflag, 
+                         int *nparts, int *edgecut, idxtype *epart, idxtype *npart)
+{
+  int i, j, k, me;
+  idxtype *xadj, *adjncy, *pwgts;
+  int options[10], pnumflag=0, wgtflag=0;
+  int nnbrs, nbrind[200], nbrwgt[200], maxpwgt;
+  int esize, esizes[] = {-1, 3, 4, 8, 4};
+
+  esize = esizes[*etype];
+
+  if (*numflag == 1)
+    ChangeMesh2CNumbering((*ne)*esize, elmnts);
+
+  xadj = idxmalloc(*nn+1, "METIS_MESHPARTNODAL: xadj");
+  adjncy = idxmalloc(20*(*nn), "METIS_MESHPARTNODAL: adjncy");
+
+  METIS_MeshToNodal(ne, nn, elmnts, etype, &pnumflag, xadj, adjncy);
+
+  adjncy = realloc(adjncy, xadj[*nn]*sizeof(idxtype));
+
+  options[0] = 0;
+  METIS_PartGraphKway(nn, xadj, adjncy, NULL, NULL, &wgtflag, &pnumflag, nparts, options, edgecut, npart);
+
+  /* OK, now compute an element partition based on the nodal partition npart */
+  idxset(*ne, -1, epart);
+  pwgts = idxsmalloc(*nparts, 0, "METIS_MESHPARTNODAL: pwgts");
+  for (i=0; i<*ne; i++) {
+    me = npart[elmnts[i*esize]];
+    for (j=1; j<esize; j++) {
+      if (npart[elmnts[i*esize+j]] != me)
+        break;
+    }
+    if (j == esize) {
+      epart[i] = me;
+      pwgts[me]++;
+    }
+  }
+
+  maxpwgt = 1.03*(*ne)/(*nparts);
+  for (i=0; i<*ne; i++) {
+    if (epart[i] == -1) { /* Assign the boundary element */
+      nnbrs = 0;
+      for (j=0; j<esize; j++) {
+        me = npart[elmnts[i*esize+j]];
+        for (k=0; k<nnbrs; k++) {
+          if (nbrind[k] == me) {
+            nbrwgt[k]++;
+            break;
+          }
+        }
+        if (k == nnbrs) {
+          nbrind[nnbrs] = me;
+          nbrwgt[nnbrs++] = 1;
+        }
+      }
+      /* Try to assign it first to the domain with most things in common */
+      j = iamax(nnbrs, nbrwgt);
+      if (pwgts[nbrind[j]] < maxpwgt) {
+        epart[i] = nbrind[j];
+      }
+      else {
+        /* If that fails, assign it to a light domain */
+        for (j=0; j<nnbrs; j++) {
+          if (pwgts[nbrind[j]] < maxpwgt) {
+            epart[i] = nbrind[j];
+            break;
+          }
+        }
+        if (j == nnbrs) 
+          epart[i] = nbrind[iamax(nnbrs, nbrwgt)];
+      }
+      pwgts[epart[i]]++;
+    }
+  }
+
+  if (*numflag == 1)
+    ChangeMesh2FNumbering2((*ne)*esize, elmnts, *ne, *nn, epart, npart);
+
+  GKfree(&xadj, &adjncy, &pwgts, LTERM);
+
+}
+
+
+/*************************************************************************
+* This function partitions a finite element mesh by partitioning its dual
+* graph using KMETIS and then assigning nodes in a load balanced fashion.
+**************************************************************************/
+void METIS_PartMeshDual(int *ne, int *nn, idxtype *elmnts, int *etype, int *numflag, 
+                        int *nparts, int *edgecut, idxtype *epart, idxtype *npart)
+{
+  int i, j, k, me;
+  idxtype *xadj, *adjncy, *pwgts, *nptr, *nind;
+  int options[10], pnumflag=0, wgtflag=0;
+  int nnbrs, nbrind[200], nbrwgt[200], maxpwgt;
+  int esize, esizes[] = {-1, 3, 4, 8, 4};
+
+  esize = esizes[*etype];
+
+  if (*numflag == 1)
+    ChangeMesh2CNumbering((*ne)*esize, elmnts);
+
+  xadj = idxmalloc(*ne+1, "METIS_MESHPARTNODAL: xadj");
+  adjncy = idxmalloc(esize*(*ne), "METIS_MESHPARTNODAL: adjncy");
+
+  METIS_MeshToDual(ne, nn, elmnts, etype, &pnumflag, xadj, adjncy);
+
+  options[0] = 0;
+  METIS_PartGraphKway(ne, xadj, adjncy, NULL, NULL, &wgtflag, &pnumflag, nparts, options, edgecut, epart);
+
+  /* Construct the node-element list */
+  nptr = idxsmalloc(*nn+1, 0, "METIS_MESHPARTDUAL: nptr");
+  for (j=esize*(*ne), i=0; i<j; i++) 
+    nptr[elmnts[i]]++;
+  MAKECSR(i, *nn, nptr);
+
+  nind = idxmalloc(nptr[*nn], "METIS_MESHPARTDUAL: nind");
+  for (k=i=0; i<(*ne); i++) {
+    for (j=0; j<esize; j++, k++) 
+      nind[nptr[elmnts[k]]++] = i;
+  }
+  for (i=(*nn); i>0; i--)
+    nptr[i] = nptr[i-1];
+  nptr[0] = 0;
+
+
+  /* OK, now compute a nodal partition based on the element partition npart */
+  idxset(*nn, -1, npart);
+  pwgts = idxsmalloc(*nparts, 0, "METIS_MESHPARTDUAL: pwgts");
+  for (i=0; i<*nn; i++) {
+    me = epart[nind[nptr[i]]];
+    for (j=nptr[i]+1; j<nptr[i+1]; j++) {
+      if (epart[nind[j]] != me)
+        break;
+    }
+    if (j == nptr[i+1]) {
+      npart[i] = me;
+      pwgts[me]++;
+    }
+  }
+
+  maxpwgt = 1.03*(*nn)/(*nparts);
+  for (i=0; i<*nn; i++) {
+    if (npart[i] == -1) { /* Assign the boundary element */
+      nnbrs = 0;
+      for (j=nptr[i]; j<nptr[i+1]; j++) {
+        me = epart[nind[j]];
+        for (k=0; k<nnbrs; k++) {
+          if (nbrind[k] == me) {
+            nbrwgt[k]++;
+            break;
+          }
+        }
+        if (k == nnbrs) {
+          nbrind[nnbrs] = me;
+          nbrwgt[nnbrs++] = 1;
+        }
+      }
+      /* Try to assign it first to the domain with most things in common */
+      j = iamax(nnbrs, nbrwgt);
+      if (pwgts[nbrind[j]] < maxpwgt) {
+        npart[i] = nbrind[j];
+      }
+      else {
+        /* If that fails, assign it to a light domain */
+        npart[i] = nbrind[0];
+        for (j=0; j<nnbrs; j++) {
+          if (pwgts[nbrind[j]] < maxpwgt) {
+            npart[i] = nbrind[j];
+            break;
+          }
+        }
+      }
+      pwgts[npart[i]]++;
+    }
+  }
+
+  if (*numflag == 1)
+    ChangeMesh2FNumbering2((*ne)*esize, elmnts, *ne, *nn, epart, npart);
+
+  GKfree(&xadj, &adjncy, &pwgts, &nptr, &nind, LTERM);
+
+}
Index: /inundation/pymetis/metis-4.0/Lib/metis.h
===================================================================
--- /inundation/pymetis/metis-4.0/Lib/metis.h	(revision 2051)
+++ /inundation/pymetis/metis-4.0/Lib/metis.h	(revision 2051)
@@ -0,0 +1,37 @@
+/*
+ * Copyright 1997, Regents of the University of Minnesota
+ *
+ * metis.h
+ *
+ * This file includes all necessary header files
+ *
+ * Started 8/27/94
+ * George
+ *
+ * $Id: metis.h,v 1.1 1998/11/27 17:59:21 karypis Exp $
+ */
+
+
+#include <stdio.h>
+#ifdef __STDC__
+#include <stdlib.h>
+#else
+#include <malloc.h>
+#endif
+#include <strings.h>
+#include <string.h>
+#include <ctype.h>
+#include <math.h>
+#include <stdarg.h>
+#include <time.h>
+
+#ifdef DMALLOC
+#include <dmalloc.h>
+#endif
+
+#include <defs.h>
+#include <struct.h>
+#include <macros.h>
+#include <rename.h>
+#include <proto.h>
+
Index: /inundation/pymetis/metis-4.0/Lib/mfm.c
===================================================================
--- /inundation/pymetis/metis-4.0/Lib/mfm.c	(revision 2051)
+++ /inundation/pymetis/metis-4.0/Lib/mfm.c	(revision 2051)
@@ -0,0 +1,344 @@
+/*
+ * Copyright 1997, Regents of the University of Minnesota
+ *
+ * mfm.c
+ *
+ * This file contains code that implements the edge-based FM refinement
+ *
+ * Started 7/23/97
+ * George
+ *
+ * $Id: mfm.c,v 1.3 1998/11/30 14:50:44 karypis Exp $
+ */
+
+#include <metis.h>
+
+
+/*************************************************************************
+* This function performs an edge-based FM refinement
+**************************************************************************/
+void MocFM_2WayEdgeRefine(CtrlType *ctrl, GraphType *graph, float *tpwgts, int npasses)
+{
+  int i, ii, j, k, l, kwgt, nvtxs, ncon, nbnd, nswaps, from, to, pass, me, limit, tmp, cnum;
+  idxtype *xadj, *adjncy, *adjwgt, *where, *id, *ed, *bndptr, *bndind;
+  idxtype *moved, *swaps, *perm, *qnum;
+  float *nvwgt, *npwgts, mindiff[MAXNCON], origbal, minbal, newbal;
+  PQueueType parts[MAXNCON][2];
+  int higain, oldgain, mincut, initcut, newcut, mincutorder;
+  float rtpwgts[2];
+
+  nvtxs = graph->nvtxs;
+  ncon = graph->ncon;
+  xadj = graph->xadj;
+  nvwgt = graph->nvwgt;
+  adjncy = graph->adjncy;
+  adjwgt = graph->adjwgt;
+  where = graph->where;
+  id = graph->id;
+  ed = graph->ed;
+  npwgts = graph->npwgts;
+  bndptr = graph->bndptr;
+  bndind = graph->bndind;
+
+  moved = idxwspacemalloc(ctrl, nvtxs);
+  swaps = idxwspacemalloc(ctrl, nvtxs);
+  perm = idxwspacemalloc(ctrl, nvtxs);
+  qnum = idxwspacemalloc(ctrl, nvtxs);
+
+  limit = amin(amax(0.01*nvtxs, 25), 150);
+
+  /* Initialize the queues */
+  for (i=0; i<ncon; i++) {
+    PQueueInit(ctrl, &parts[i][0], nvtxs, PLUS_GAINSPAN+1);
+    PQueueInit(ctrl, &parts[i][1], nvtxs, PLUS_GAINSPAN+1);
+  }
+  for (i=0; i<nvtxs; i++)
+    qnum[i] = samax(ncon, nvwgt+i*ncon);
+
+  origbal = Compute2WayHLoadImbalance(ncon, npwgts, tpwgts);
+
+  rtpwgts[0] = origbal*tpwgts[0];
+  rtpwgts[1] = origbal*tpwgts[1];
+
+
+  if (ctrl->dbglvl&DBG_REFINE) {
+    printf("Parts: [");
+    for (l=0; l<ncon; l++)
+      printf("(%.3f, %.3f) ", npwgts[l], npwgts[ncon+l]);
+    printf("] T[%.3f %.3f], Nv-Nb[%5d, %5d]. ICut: %6d, LB: %.3f\n", tpwgts[0], tpwgts[1], graph->nvtxs, graph->nbnd, graph->mincut, origbal);
+  }
+
+  idxset(nvtxs, -1, moved);
+  for (pass=0; pass<npasses; pass++) { /* Do a number of passes */
+    for (i=0; i<ncon; i++) { 
+      PQueueReset(&parts[i][0]);
+      PQueueReset(&parts[i][1]);
+    }
+
+    mincutorder = -1;
+    newcut = mincut = initcut = graph->mincut;
+    for (i=0; i<ncon; i++)
+      mindiff[i] = fabs(tpwgts[0]-npwgts[i]);
+    minbal = Compute2WayHLoadImbalance(ncon, npwgts, tpwgts);
+
+    ASSERT(ComputeCut(graph, where) == graph->mincut);
+    ASSERT(CheckBnd(graph));
+
+    /* Insert boundary nodes in the priority queues */
+    nbnd = graph->nbnd;
+    RandomPermute(nbnd, perm, 1);
+    for (ii=0; ii<nbnd; ii++) {
+      i = bndind[perm[ii]];
+      ASSERT(ed[i] > 0 || id[i] == 0);
+      ASSERT(bndptr[i] != -1);
+      PQueueInsert(&parts[qnum[i]][where[i]], i, ed[i]-id[i]);
+    }
+
+    for (nswaps=0; nswaps<nvtxs; nswaps++) {
+      SelectQueue(ncon, npwgts, rtpwgts, &from, &cnum, parts);
+      to = (from+1)%2;
+
+      if (from == -1 || (higain = PQueueGetMax(&parts[cnum][from])) == -1)
+        break;
+      ASSERT(bndptr[higain] != -1);
+
+      saxpy(ncon, 1.0, nvwgt+higain*ncon, 1, npwgts+to*ncon, 1);
+      saxpy(ncon, -1.0, nvwgt+higain*ncon, 1, npwgts+from*ncon, 1);
+
+      newcut -= (ed[higain]-id[higain]);
+      newbal = Compute2WayHLoadImbalance(ncon, npwgts, tpwgts);
+
+      if ((newcut < mincut && newbal-origbal <= .00001) || 
+          (newcut == mincut && (newbal < minbal || 
+                                (newbal == minbal && BetterBalance(ncon, npwgts, tpwgts, mindiff))))) {
+        mincut = newcut;
+        minbal = newbal;
+        mincutorder = nswaps;
+        for (i=0; i<ncon; i++)
+          mindiff[i] = fabs(tpwgts[0]-npwgts[i]);
+      }
+      else if (nswaps-mincutorder > limit) { /* We hit the limit, undo last move */
+        newcut += (ed[higain]-id[higain]);
+        saxpy(ncon, 1.0, nvwgt+higain*ncon, 1, npwgts+from*ncon, 1);
+        saxpy(ncon, -1.0, nvwgt+higain*ncon, 1, npwgts+to*ncon, 1);
+        break;
+      }
+
+      where[higain] = to;
+      moved[higain] = nswaps;
+      swaps[nswaps] = higain;
+
+      if (ctrl->dbglvl&DBG_MOVEINFO) {
+        printf("Moved %6d from %d(%d). Gain: %5d, Cut: %5d, NPwgts: ", higain, from, cnum, ed[higain]-id[higain], newcut);
+        for (l=0; l<ncon; l++) 
+          printf("(%.3f, %.3f) ", npwgts[l], npwgts[ncon+l]);
+        printf(", %.3f LB: %.3f\n", minbal, newbal);
+      }
+
+
+      /**************************************************************
+      * Update the id[i]/ed[i] values of the affected nodes
+      ***************************************************************/
+      SWAP(id[higain], ed[higain], tmp);
+      if (ed[higain] == 0 && xadj[higain] < xadj[higain+1]) 
+        BNDDelete(nbnd, bndind,  bndptr, higain);
+
+      for (j=xadj[higain]; j<xadj[higain+1]; j++) {
+        k = adjncy[j];
+        oldgain = ed[k]-id[k];
+
+        kwgt = (to == where[k] ? adjwgt[j] : -adjwgt[j]);
+        INC_DEC(id[k], ed[k], kwgt);
+
+        /* Update its boundary information and queue position */
+        if (bndptr[k] != -1) { /* If k was a boundary vertex */
+          if (ed[k] == 0) { /* Not a boundary vertex any more */
+            BNDDelete(nbnd, bndind, bndptr, k);
+            if (moved[k] == -1)  /* Remove it if in the queues */
+              PQueueDelete(&parts[qnum[k]][where[k]], k, oldgain);
+          }
+          else { /* If it has not been moved, update its position in the queue */
+            if (moved[k] == -1)
+              PQueueUpdate(&parts[qnum[k]][where[k]], k, oldgain, ed[k]-id[k]);
+          }
+        }
+        else {
+          if (ed[k] > 0) {  /* It will now become a boundary vertex */
+            BNDInsert(nbnd, bndind, bndptr, k);
+            if (moved[k] == -1) 
+              PQueueInsert(&parts[qnum[k]][where[k]], k, ed[k]-id[k]);
+          }
+        }
+      }
+
+    }
+
+
+    /****************************************************************
+    * Roll back computations
+    *****************************************************************/
+    for (i=0; i<nswaps; i++)
+      moved[swaps[i]] = -1;  /* reset moved array */
+    for (nswaps--; nswaps>mincutorder; nswaps--) {
+      higain = swaps[nswaps];
+
+      to = where[higain] = (where[higain]+1)%2;
+      SWAP(id[higain], ed[higain], tmp);
+      if (ed[higain] == 0 && bndptr[higain] != -1 && xadj[higain] < xadj[higain+1])
+        BNDDelete(nbnd, bndind,  bndptr, higain);
+      else if (ed[higain] > 0 && bndptr[higain] == -1)
+        BNDInsert(nbnd, bndind,  bndptr, higain);
+
+      saxpy(ncon, 1.0, nvwgt+higain*ncon, 1, npwgts+to*ncon, 1);
+      saxpy(ncon, -1.0, nvwgt+higain*ncon, 1, npwgts+((to+1)%2)*ncon, 1);
+      for (j=xadj[higain]; j<xadj[higain+1]; j++) {
+        k = adjncy[j];
+
+        kwgt = (to == where[k] ? adjwgt[j] : -adjwgt[j]);
+        INC_DEC(id[k], ed[k], kwgt);
+
+        if (bndptr[k] != -1 && ed[k] == 0)
+          BNDDelete(nbnd, bndind, bndptr, k);
+        if (bndptr[k] == -1 && ed[k] > 0)
+          BNDInsert(nbnd, bndind, bndptr, k);
+      }
+    }
+
+    if (ctrl->dbglvl&DBG_REFINE) {
+      printf("\tMincut: %6d at %5d, NBND: %6d, NPwgts: [", mincut, mincutorder, nbnd);
+      for (l=0; l<ncon; l++)
+        printf("(%.3f, %.3f) ", npwgts[l], npwgts[ncon+l]);
+      printf("], LB: %.3f\n", Compute2WayHLoadImbalance(ncon, npwgts, tpwgts));
+    }
+
+    graph->mincut = mincut;
+    graph->nbnd = nbnd;
+
+    if (mincutorder == -1 || mincut == initcut)
+      break;
+  }
+
+  for (i=0; i<ncon; i++) {
+    PQueueFree(ctrl, &parts[i][0]);
+    PQueueFree(ctrl, &parts[i][1]);
+  }
+
+  idxwspacefree(ctrl, nvtxs);
+  idxwspacefree(ctrl, nvtxs);
+  idxwspacefree(ctrl, nvtxs);
+  idxwspacefree(ctrl, nvtxs);
+
+}
+
+
+/*************************************************************************
+* This function selects the partition number and the queue from which
+* we will move vertices out
+**************************************************************************/ 
+void SelectQueue(int ncon, float *npwgts, float *tpwgts, int *from, int *cnum, PQueueType queues[MAXNCON][2])
+{
+  int i, part, maxgain=0;
+  float max, maxdiff=0.0;
+
+  *from = -1;
+  *cnum = -1;
+
+  /* First determine the side and the queue, irrespective of the presence of nodes */
+  for (part=0; part<2; part++) {
+    for (i=0; i<ncon; i++) {
+      if (npwgts[part*ncon+i]-tpwgts[part] >= maxdiff) {
+        maxdiff = npwgts[part*ncon+i]-tpwgts[part];
+        *from = part;
+        *cnum = i;
+      }
+    }
+  }
+
+  /* printf("Selected1 %d(%d) -> %d [%5f]\n", *from, *cnum, PQueueGetSize(&queues[*cnum][*from]), maxdiff); */
+
+  if (*from != -1 && PQueueGetSize(&queues[*cnum][*from]) == 0) {
+    /* The desired queue is empty, select a node from that side anyway */
+    for (i=0; i<ncon; i++) {
+      if (PQueueGetSize(&queues[i][*from]) > 0) {
+        max = npwgts[(*from)*ncon + i];
+        *cnum = i;
+        break;
+      }
+    }
+
+    for (i++; i<ncon; i++) {
+      if (npwgts[(*from)*ncon + i] > max && PQueueGetSize(&queues[i][*from]) > 0) {
+        max = npwgts[(*from)*ncon + i];
+        *cnum = i;
+      }
+    }
+  }
+
+  /* Check to see if you can focus on the cut */
+  if (maxdiff <= 0.0 || *from == -1) {
+    maxgain = -100000;
+
+    for (part=0; part<2; part++) {
+      for (i=0; i<ncon; i++) {
+        if (PQueueGetSize(&queues[i][part]) > 0 && PQueueGetKey(&queues[i][part]) > maxgain) {
+          maxgain = PQueueGetKey(&queues[i][part]); 
+          *from = part;
+          *cnum = i;
+        }
+      }
+    }
+  }
+
+  /* printf("Selected2 %d(%d) -> %d\n", *from, *cnum, PQueueGetSize(&queues[*cnum][*from])); */
+}
+
+
+
+
+
+/*************************************************************************
+* This function checks if the balance achieved is better than the diff 
+* For now, it uses a 2-norm measure
+**************************************************************************/ 
+int BetterBalance(int ncon, float *npwgts, float *tpwgts, float *diff)
+{
+  int i;
+  float ndiff[MAXNCON];
+
+  for (i=0; i<ncon; i++)
+    ndiff[i] = fabs(tpwgts[0]-npwgts[i]);
+   
+  return snorm2(ncon, ndiff) < snorm2(ncon, diff);
+}
+
+
+
+/*************************************************************************
+* This function computes the load imbalance over all the constrains
+**************************************************************************/ 
+float Compute2WayHLoadImbalance(int ncon, float *npwgts, float *tpwgts)
+{
+  int i;
+  float max=0.0, temp;
+
+  for (i=0; i<ncon; i++) {
+    /* temp = amax(npwgts[i]/tpwgts[0], npwgts[ncon+i]/tpwgts[1]); */
+    temp = fabs(tpwgts[0]-npwgts[i])/tpwgts[0];
+    max = (max < temp ? temp : max);
+  }
+  return 1.0+max;
+}
+
+
+/*************************************************************************
+* This function computes the load imbalance over all the constrains
+* For now assume that we just want balanced partitionings
+**************************************************************************/ 
+void Compute2WayHLoadImbalanceVec(int ncon, float *npwgts, float *tpwgts, float *lbvec)
+{
+  int i;
+
+  for (i=0; i<ncon; i++) 
+    lbvec[i] = 1.0 + fabs(tpwgts[0]-npwgts[i])/tpwgts[0];
+}
+
Index: /inundation/pymetis/metis-4.0/Lib/mfm2.c
===================================================================
--- /inundation/pymetis/metis-4.0/Lib/mfm2.c	(revision 2051)
+++ /inundation/pymetis/metis-4.0/Lib/mfm2.c	(revision 2051)
@@ -0,0 +1,349 @@
+/*
+ * Copyright 1997, Regents of the University of Minnesota
+ *
+ * mfm2.c
+ *
+ * This file contains code that implements the edge-based FM refinement
+ *
+ * Started 7/23/97
+ * George
+ *
+ * $Id: mfm2.c,v 1.2 1998/11/30 14:50:44 karypis Exp $
+ */
+
+#include <metis.h>
+
+
+/*************************************************************************
+* This function performs an edge-based FM refinement
+**************************************************************************/
+void MocFM_2WayEdgeRefine2(CtrlType *ctrl, GraphType *graph, float *tpwgts, float *orgubvec, 
+       int npasses)
+{
+  int i, ii, j, k, l, kwgt, nvtxs, ncon, nbnd, nswaps, from, to, pass, me, limit, tmp, cnum;
+  idxtype *xadj, *adjncy, *adjwgt, *where, *id, *ed, *bndptr, *bndind;
+  idxtype *moved, *swaps, *perm, *qnum;
+  float *nvwgt, *npwgts, origdiff[MAXNCON], origbal[MAXNCON], minbal[MAXNCON];
+  PQueueType parts[MAXNCON][2];
+  int higain, oldgain, mincut, initcut, newcut, mincutorder;
+  float *maxwgt, *minwgt, ubvec[MAXNCON], tvec[MAXNCON];
+
+  nvtxs = graph->nvtxs;
+  ncon = graph->ncon;
+  xadj = graph->xadj;
+  nvwgt = graph->nvwgt;
+  adjncy = graph->adjncy;
+  adjwgt = graph->adjwgt;
+  where = graph->where;
+  id = graph->id;
+  ed = graph->ed;
+  npwgts = graph->npwgts;
+  bndptr = graph->bndptr;
+  bndind = graph->bndind;
+
+  moved = idxwspacemalloc(ctrl, nvtxs);
+  swaps = idxwspacemalloc(ctrl, nvtxs);
+  perm = idxwspacemalloc(ctrl, nvtxs);
+  qnum = idxwspacemalloc(ctrl, nvtxs);
+
+  limit = amin(amax(0.01*nvtxs, 15), 100);
+
+  Compute2WayHLoadImbalanceVec(ncon, npwgts, tpwgts, origbal);
+  for (i=0; i<ncon; i++) {
+    origdiff[i] = fabs(tpwgts[0]-npwgts[i]);
+    ubvec[i] = amax(origbal[i], orgubvec[i]);
+  }
+
+  /* Setup the weight intervals of the two subdomains */
+  minwgt = fwspacemalloc(ctrl, 2*ncon);
+  maxwgt = fwspacemalloc(ctrl, 2*ncon);
+
+  for (i=0; i<2; i++) {
+    for (j=0; j<ncon; j++) {
+      maxwgt[i*ncon+j] = tpwgts[i]*ubvec[j];
+      minwgt[i*ncon+j] = tpwgts[i]*(1.0/ubvec[j]);
+    }
+  }
+
+  /* Initialize the queues */
+  for (i=0; i<ncon; i++) {
+    PQueueInit(ctrl, &parts[i][0], nvtxs, PLUS_GAINSPAN+1);
+    PQueueInit(ctrl, &parts[i][1], nvtxs, PLUS_GAINSPAN+1);
+  }
+  for (i=0; i<nvtxs; i++)
+    qnum[i] = samax(ncon, nvwgt+i*ncon);
+
+
+  if (ctrl->dbglvl&DBG_REFINE) {
+    printf("Parts: [");
+    for (l=0; l<ncon; l++)
+      printf("(%.3f, %.3f) ", npwgts[l], npwgts[ncon+l]);
+    printf("] T[%.3f %.3f], Nv-Nb[%5d, %5d]. ICut: %6d, LB: ", tpwgts[0], tpwgts[1], 
+            graph->nvtxs, graph->nbnd, graph->mincut);
+    for (i=0; i<ncon; i++)
+      printf("%.3f ", origbal[i]);
+    printf("\n");
+  }
+
+  idxset(nvtxs, -1, moved);
+  for (pass=0; pass<npasses; pass++) { /* Do a number of passes */
+    for (i=0; i<ncon; i++) { 
+      PQueueReset(&parts[i][0]);
+      PQueueReset(&parts[i][1]);
+    }
+
+    mincutorder = -1;
+    newcut = mincut = initcut = graph->mincut;
+    Compute2WayHLoadImbalanceVec(ncon, npwgts, tpwgts, minbal);
+
+    ASSERT(ComputeCut(graph, where) == graph->mincut);
+    ASSERT(CheckBnd(graph));
+
+    /* Insert boundary nodes in the priority queues */
+    nbnd = graph->nbnd;
+    RandomPermute(nbnd, perm, 1);
+    for (ii=0; ii<nbnd; ii++) {
+      i = bndind[perm[ii]];
+      ASSERT(ed[i] > 0 || id[i] == 0);
+      ASSERT(bndptr[i] != -1);
+      PQueueInsert(&parts[qnum[i]][where[i]], i, ed[i]-id[i]);
+    }
+
+    for (nswaps=0; nswaps<nvtxs; nswaps++) {
+      SelectQueue2(ncon, npwgts, tpwgts, &from, &cnum, parts, maxwgt);
+      to = (from+1)%2;
+
+      if (from == -1 || (higain = PQueueGetMax(&parts[cnum][from])) == -1)
+        break;
+      ASSERT(bndptr[higain] != -1);
+
+      newcut -= (ed[higain]-id[higain]);
+      saxpy(ncon, 1.0, nvwgt+higain*ncon, 1, npwgts+to*ncon, 1);
+      saxpy(ncon, -1.0, nvwgt+higain*ncon, 1, npwgts+from*ncon, 1);
+
+      Compute2WayHLoadImbalanceVec(ncon, npwgts, tpwgts, tvec);
+      if ((newcut < mincut && AreAllBelow(ncon, tvec, ubvec)) ||
+          (newcut == mincut && IsBetter2wayBalance(ncon, tvec, minbal, ubvec))) {
+        mincut = newcut;
+        for (i=0; i<ncon; i++) 
+          minbal[i] = tvec[i];
+        mincutorder = nswaps;
+      }
+      else if (nswaps-mincutorder > limit) { /* We hit the limit, undo last move */
+        newcut += (ed[higain]-id[higain]);
+        saxpy(ncon, 1.0, nvwgt+higain*ncon, 1, npwgts+from*ncon, 1);
+        saxpy(ncon, -1.0, nvwgt+higain*ncon, 1, npwgts+to*ncon, 1);
+        break;
+      }
+
+      where[higain] = to;
+      moved[higain] = nswaps;
+      swaps[nswaps] = higain;
+
+      if (ctrl->dbglvl&DBG_MOVEINFO) {
+        printf("Moved %6d from %d(%d). Gain: %5d, Cut: %5d, NPwgts: ", higain, from, cnum, ed[higain]-id[higain], newcut);
+        for (l=0; l<ncon; l++) 
+          printf("(%.3f, %.3f) ", npwgts[l], npwgts[ncon+l]);
+
+        printf(", LB: ");
+        for (i=0; i<ncon; i++) 
+          printf("%.3f ", tvec[i]);
+        if (mincutorder == nswaps)
+          printf(" *\n");
+        else
+          printf("\n");
+      }
+
+
+      /**************************************************************
+      * Update the id[i]/ed[i] values of the affected nodes
+      ***************************************************************/
+      SWAP(id[higain], ed[higain], tmp);
+      if (ed[higain] == 0 && xadj[higain] < xadj[higain+1]) 
+        BNDDelete(nbnd, bndind,  bndptr, higain);
+
+      for (j=xadj[higain]; j<xadj[higain+1]; j++) {
+        k = adjncy[j];
+        oldgain = ed[k]-id[k];
+
+        kwgt = (to == where[k] ? adjwgt[j] : -adjwgt[j]);
+        INC_DEC(id[k], ed[k], kwgt);
+
+        /* Update its boundary information and queue position */
+        if (bndptr[k] != -1) { /* If k was a boundary vertex */
+          if (ed[k] == 0) { /* Not a boundary vertex any more */
+            BNDDelete(nbnd, bndind, bndptr, k);
+            if (moved[k] == -1)  /* Remove it if in the queues */
+              PQueueDelete(&parts[qnum[k]][where[k]], k, oldgain);
+          }
+          else { /* If it has not been moved, update its position in the queue */
+            if (moved[k] == -1)
+              PQueueUpdate(&parts[qnum[k]][where[k]], k, oldgain, ed[k]-id[k]);
+          }
+        }
+        else {
+          if (ed[k] > 0) {  /* It will now become a boundary vertex */
+            BNDInsert(nbnd, bndind, bndptr, k);
+            if (moved[k] == -1) 
+              PQueueInsert(&parts[qnum[k]][where[k]], k, ed[k]-id[k]);
+          }
+        }
+      }
+
+    }
+
+
+    /****************************************************************
+    * Roll back computations
+    *****************************************************************/
+    for (i=0; i<nswaps; i++)
+      moved[swaps[i]] = -1;  /* reset moved array */
+    for (nswaps--; nswaps>mincutorder; nswaps--) {
+      higain = swaps[nswaps];
+
+      to = where[higain] = (where[higain]+1)%2;
+      SWAP(id[higain], ed[higain], tmp);
+      if (ed[higain] == 0 && bndptr[higain] != -1 && xadj[higain] < xadj[higain+1])
+        BNDDelete(nbnd, bndind,  bndptr, higain);
+      else if (ed[higain] > 0 && bndptr[higain] == -1)
+        BNDInsert(nbnd, bndind,  bndptr, higain);
+
+      saxpy(ncon, 1.0, nvwgt+higain*ncon, 1, npwgts+to*ncon, 1);
+      saxpy(ncon, -1.0, nvwgt+higain*ncon, 1, npwgts+((to+1)%2)*ncon, 1);
+      for (j=xadj[higain]; j<xadj[higain+1]; j++) {
+        k = adjncy[j];
+
+        kwgt = (to == where[k] ? adjwgt[j] : -adjwgt[j]);
+        INC_DEC(id[k], ed[k], kwgt);
+
+        if (bndptr[k] != -1 && ed[k] == 0)
+          BNDDelete(nbnd, bndind, bndptr, k);
+        if (bndptr[k] == -1 && ed[k] > 0)
+          BNDInsert(nbnd, bndind, bndptr, k);
+      }
+    }
+
+    if (ctrl->dbglvl&DBG_REFINE) {
+      printf("\tMincut: %6d at %5d, NBND: %6d, NPwgts: [", mincut, mincutorder, nbnd);
+      for (l=0; l<ncon; l++)
+        printf("(%.3f, %.3f) ", npwgts[l], npwgts[ncon+l]);
+      printf("], LB: ");
+      Compute2WayHLoadImbalanceVec(ncon, npwgts, tpwgts, tvec);
+      for (i=0; i<ncon; i++) 
+        printf("%.3f ", tvec[i]);
+      printf("\n");
+    }
+
+    graph->mincut = mincut;
+    graph->nbnd = nbnd;
+
+    if (mincutorder == -1 || mincut == initcut)
+      break;
+  }
+
+  for (i=0; i<ncon; i++) {
+    PQueueFree(ctrl, &parts[i][0]);
+    PQueueFree(ctrl, &parts[i][1]);
+  }
+
+  idxwspacefree(ctrl, nvtxs);
+  idxwspacefree(ctrl, nvtxs);
+  idxwspacefree(ctrl, nvtxs);
+  idxwspacefree(ctrl, nvtxs);
+  fwspacefree(ctrl, 2*ncon);
+  fwspacefree(ctrl, 2*ncon);
+
+}
+
+
+/*************************************************************************
+* This function selects the partition number and the queue from which
+* we will move vertices out
+**************************************************************************/ 
+void SelectQueue2(int ncon, float *npwgts, float *tpwgts, int *from, int *cnum, 
+       PQueueType queues[MAXNCON][2], float *maxwgt)
+{
+  int i, j, maxgain=0;
+  float diff, max, maxdiff=0.0;
+
+  *from = -1;
+  *cnum = -1;
+
+  /* First determine the side and the queue, irrespective of the presence of nodes */
+  for (j=0; j<2; j++) {
+    for (i=0; i<ncon; i++) {
+      diff = npwgts[j*ncon+i]-maxwgt[j*ncon+i];
+      if (diff >= maxdiff) {
+        maxdiff = diff;
+        *from = j;
+        *cnum = i;
+      }
+    }
+  }
+
+  if (*from != -1 && PQueueGetSize(&queues[*cnum][*from]) == 0) {
+    /* The desired queue is empty, select a node from that side anyway */
+    for (i=0; i<ncon; i++) {
+      if (PQueueGetSize(&queues[i][*from]) > 0) {
+        max = (npwgts[(*from)*ncon+i] - maxwgt[(*from)*ncon+i]);
+        *cnum = i;
+        break;
+      }
+    }
+
+    for (i++; i<ncon; i++) {
+      diff = npwgts[(*from)*ncon+i] - maxwgt[(*from)*ncon+i];
+      if (diff > max && PQueueGetSize(&queues[i][*from]) > 0) {
+        max = diff;
+        *cnum = i;
+      }
+    }
+  }
+
+  /* Check to see if you can focus on the cut */
+  if (maxdiff <= 0.0 || *from == -1) {
+    maxgain = -100000;
+
+    for (j=0; j<2; j++) {
+      for (i=0; i<ncon; i++) {
+        if (PQueueGetSize(&queues[i][j]) > 0 && PQueueGetKey(&queues[i][j]) > maxgain) {
+          maxgain = PQueueGetKey(&queues[i][j]); 
+          *from = j;
+          *cnum = i;
+        }
+      }
+    }
+
+    /* printf("(%2d %2d) %3d\n", *from, *cnum, maxgain); */
+  }
+}
+
+
+/*************************************************************************
+* This function checks if the newbal is better than oldbal given the
+* ubvector ubvec
+**************************************************************************/
+int IsBetter2wayBalance(int ncon, float *newbal, float *oldbal, float *ubvec)
+{
+  int i, j;
+  float max1=0.0, max2=0.0, sum1=0.0, sum2=0.0, tmp;
+
+  for (i=0; i<ncon; i++) {
+    tmp = (newbal[i]-1)/(ubvec[i]-1);
+    max1 = (max1 < tmp ? tmp : max1);
+    sum1 += tmp;
+
+    tmp = (oldbal[i]-1)/(ubvec[i]-1);
+    max2 = (max2 < tmp ? tmp : max2);
+    sum2 += tmp;
+  }
+
+  if (max1 < max2)
+    return 1;
+  else if (max1 > max2)
+    return 0;
+  else
+    return sum1 <= sum2;
+}
+
+
Index: /inundation/pymetis/metis-4.0/Lib/mincover.c
===================================================================
--- /inundation/pymetis/metis-4.0/Lib/mincover.c	(revision 2051)
+++ /inundation/pymetis/metis-4.0/Lib/mincover.c	(revision 2051)
@@ -0,0 +1,259 @@
+/*
+ * Copyright 1997, Regents of the University of Minnesota
+ *
+ * mincover.c
+ *
+ * This file implements the minimum cover algorithm
+ *
+ * Started 8/1/97
+ * George
+ *
+ * $Id: mincover.c,v 1.1 1998/11/27 17:59:22 karypis Exp $
+ */
+
+#include <metis.h>
+
+/*************************************************************************
+* Constants used by mincover algorithm
+**************************************************************************/
+#define INCOL 10
+#define INROW 20
+#define VC 1
+#define SC 2
+#define HC 3
+#define VR 4
+#define SR 5
+#define HR 6
+
+
+/*************************************************************************
+* This function returns the min-cover of a bipartite graph.
+* The algorithm used is due to Hopcroft and Karp as modified by Duff etal
+* adj: the adjacency list of the bipartite graph
+*       asize: the number of vertices in the first part of the bipartite graph
+* bsize-asize: the number of vertices in the second part
+*        0..(asize-1) > A vertices
+*        asize..bsize > B vertices
+*
+* Returns:
+*  cover : the actual cover (array)
+*  csize : the size of the cover
+**************************************************************************/
+void MinCover(idxtype *xadj, idxtype *adjncy, int asize, int bsize, idxtype *cover, int *csize)
+{
+  int i, j;
+  idxtype *mate, *queue, *flag, *level, *lst;
+  int fptr, rptr, lstptr;
+  int row, maxlevel, col;
+
+  mate = idxsmalloc(bsize, -1, "MinCover: mate");
+  flag = idxmalloc(bsize, "MinCover: flag");
+  level = idxmalloc(bsize, "MinCover: level");
+  queue = idxmalloc(bsize, "MinCover: queue");
+  lst = idxmalloc(bsize, "MinCover: lst");
+
+  /* Get a cheap matching */
+  for (i=0; i<asize; i++) {
+    for (j=xadj[i]; j<xadj[i+1]; j++) {
+      if (mate[adjncy[j]] == -1) {
+        mate[i] = adjncy[j];
+        mate[adjncy[j]] = i;
+        break;
+      }
+    }
+  }
+
+  /* Get into the main loop */
+  while (1) {
+    /* Initialization */
+    fptr = rptr = 0;   /* Empty Queue */
+    lstptr = 0;        /* Empty List */
+    for (i=0; i<bsize; i++) {
+      level[i] = -1;
+      flag[i] = 0;
+    }
+    maxlevel = bsize;
+
+    /* Insert free nodes into the queue */
+    for (i=0; i<asize; i++) 
+      if (mate[i] == -1) {
+        queue[rptr++] = i;
+        level[i] = 0;
+      }
+
+    /* Perform the BFS */
+    while (fptr != rptr) {
+      row = queue[fptr++];
+      if (level[row] < maxlevel) {
+        flag[row] = 1;
+        for (j=xadj[row]; j<xadj[row+1]; j++) {
+          col = adjncy[j];
+          if (!flag[col]) {  /* If this column has not been accessed yet */
+            flag[col] = 1;
+            if (mate[col] == -1) { /* Free column node was found */
+              maxlevel = level[row];
+              lst[lstptr++] = col;
+            }
+            else { /* This column node is matched */
+              if (flag[mate[col]]) 
+                printf("\nSomething wrong, flag[%d] is 1",mate[col]);
+              queue[rptr++] = mate[col];
+              level[mate[col]] = level[row] + 1;
+            }
+          }
+        }
+      } 
+    }
+
+    if (lstptr == 0)
+      break;   /* No free columns can be reached */
+
+    /* Perform restricted DFS from the free column nodes */
+    for (i=0; i<lstptr; i++)
+      MinCover_Augment(xadj, adjncy, lst[i], mate, flag, level, maxlevel);
+  }
+
+  MinCover_Decompose(xadj, adjncy, asize, bsize, mate, cover, csize);
+
+  GKfree(&mate, &flag, &level, &queue, &lst, LTERM);
+
+}
+
+
+/*************************************************************************
+* This function perfoms a restricted DFS and augments matchings
+**************************************************************************/
+int MinCover_Augment(idxtype *xadj, idxtype *adjncy, int col, idxtype *mate, idxtype *flag, idxtype *level, int maxlevel)
+{
+  int i;
+  int row = -1;
+  int status;
+
+  flag[col] = 2;
+  for (i=xadj[col]; i<xadj[col+1]; i++) {
+    row = adjncy[i];
+
+    if (flag[row] == 1) { /* First time through this row node */
+      if (level[row] == maxlevel) {  /* (col, row) is an edge of the G^T */
+        flag[row] = 2;  /* Mark this node as being visited */
+        if (maxlevel != 0)
+          status = MinCover_Augment(xadj, adjncy, mate[row], mate, flag, level, maxlevel-1);
+        else
+          status = 1;
+
+        if (status) {
+          mate[col] = row;
+          mate[row] = col;
+          return 1;
+        }
+      }
+    }
+  }
+
+  return 0;
+}
+
+
+
+/*************************************************************************
+* This function performs a coarse decomposition and determines the 
+* min-cover.
+* REF: Pothen ACMTrans. on Amth Software
+**************************************************************************/
+void MinCover_Decompose(idxtype *xadj, idxtype *adjncy, int asize, int bsize, idxtype *mate, idxtype *cover, int *csize)
+{
+  int i, k;
+  idxtype *where;
+  int card[10];
+
+  where = idxmalloc(bsize, "MinCover_Decompose: where");
+  for (i=0; i<10; i++)
+    card[i] = 0;
+
+  for (i=0; i<asize; i++)
+    where[i] = SC;
+  for (; i<bsize; i++)
+    where[i] = SR;
+
+  for (i=0; i<asize; i++) 
+    if (mate[i] == -1)  
+      MinCover_ColDFS(xadj, adjncy, i, mate, where, INCOL);
+  for (; i<bsize; i++) 
+    if (mate[i] == -1)  
+      MinCover_RowDFS(xadj, adjncy, i, mate, where, INROW);
+
+  for (i=0; i<bsize; i++) 
+    card[where[i]]++;
+
+  k = 0;
+  if (abs(card[VC]+card[SC]-card[HR]) < abs(card[VC]-card[SR]-card[HR])) {  /* S = VC+SC+HR */
+    /* printf("%d %d ",vc+sc, hr); */
+    for (i=0; i<bsize; i++) 
+      if (where[i] == VC || where[i] == SC || where[i] == HR)
+        cover[k++] = i;
+  }
+  else {  /* S = VC+SR+HR */
+    /* printf("%d %d ",vc, hr+sr); */
+    for (i=0; i<bsize; i++) 
+      if (where[i] == VC || where[i] == SR || where[i] == HR)
+        cover[k++] = i;
+  }
+
+  *csize = k;
+  free(where);
+
+}
+
+
+/*************************************************************************
+* This function perfoms a dfs starting from an unmatched col node
+* forming alternate paths
+**************************************************************************/
+void MinCover_ColDFS(idxtype *xadj, idxtype *adjncy, int root, idxtype *mate, idxtype *where, int flag)
+{
+  int i;
+
+  if (flag == INCOL) {
+    if (where[root] == HC)
+      return;
+    where[root] = HC;
+    for (i=xadj[root]; i<xadj[root+1]; i++) 
+      MinCover_ColDFS(xadj, adjncy, adjncy[i], mate, where, INROW);
+  }
+  else {
+    if (where[root] == HR)
+      return;
+    where[root] = HR;
+    if (mate[root] != -1)
+      MinCover_ColDFS(xadj, adjncy, mate[root], mate, where, INCOL);
+  }
+
+}
+
+/*************************************************************************
+* This function perfoms a dfs starting from an unmatched col node
+* forming alternate paths
+**************************************************************************/
+void MinCover_RowDFS(idxtype *xadj, idxtype *adjncy, int root, idxtype *mate, idxtype *where, int flag)
+{
+  int i;
+
+  if (flag == INROW) {
+    if (where[root] == VR)
+      return;
+    where[root] = VR;
+    for (i=xadj[root]; i<xadj[root+1]; i++) 
+      MinCover_RowDFS(xadj, adjncy, adjncy[i], mate, where, INCOL);
+  }
+  else {
+    if (where[root] == VC)
+      return;
+    where[root] = VC;
+    if (mate[root] != -1)
+      MinCover_RowDFS(xadj, adjncy, mate[root], mate, where, INROW);
+  }
+
+}
+
+
+
Index: /inundation/pymetis/metis-4.0/Lib/minitpart.c
===================================================================
--- /inundation/pymetis/metis-4.0/Lib/minitpart.c	(revision 2051)
+++ /inundation/pymetis/metis-4.0/Lib/minitpart.c	(revision 2051)
@@ -0,0 +1,355 @@
+/*
+ * Copyright 1997, Regents of the University of Minnesota
+ *
+ * minitpart.c
+ *
+ * This file contains code that performs the initial partition of the
+ * coarsest graph
+ *
+ * Started 7/23/97
+ * George
+ *
+ * $Id: minitpart.c,v 1.2 1998/11/30 15:08:37 karypis Exp $
+ *
+ */
+
+#include <metis.h>
+
+/*************************************************************************
+* This function computes the initial bisection of the coarsest graph
+**************************************************************************/
+void MocInit2WayPartition(CtrlType *ctrl, GraphType *graph, float *tpwgts, float ubfactor) 
+{
+  int i, dbglvl;
+
+  dbglvl = ctrl->dbglvl;
+  IFSET(ctrl->dbglvl, DBG_REFINE, ctrl->dbglvl -= DBG_REFINE);
+  IFSET(ctrl->dbglvl, DBG_MOVEINFO, ctrl->dbglvl -= DBG_MOVEINFO);
+
+  IFSET(ctrl->dbglvl, DBG_TIME, starttimer(ctrl->InitPartTmr));
+
+  switch (ctrl->IType) {
+    case IPART_GGPKL:
+      MocGrowBisection(ctrl, graph, tpwgts, ubfactor);
+      break;
+    case IPART_RANDOM:
+      MocRandomBisection(ctrl, graph, tpwgts, ubfactor);
+      break;
+    default:
+      errexit("Unknown initial partition type: %d\n", ctrl->IType);
+  }
+
+  IFSET(ctrl->dbglvl, DBG_IPART, printf("Initial Cut: %d [%d]\n", graph->mincut, graph->where[0]));
+  IFSET(ctrl->dbglvl, DBG_TIME, stoptimer(ctrl->InitPartTmr));
+  ctrl->dbglvl = dbglvl;
+
+}
+
+
+
+
+
+/*************************************************************************
+* This function takes a graph and produces a bisection by using a region
+* growing algorithm. The resulting partition is returned in
+* graph->where
+**************************************************************************/
+void MocGrowBisection(CtrlType *ctrl, GraphType *graph, float *tpwgts, float ubfactor)
+{
+  int i, j, k, nvtxs, ncon, from, bestcut, mincut, nbfs;
+  idxtype *bestwhere, *where;
+
+  nvtxs = graph->nvtxs;
+
+  MocAllocate2WayPartitionMemory(ctrl, graph);
+  where = graph->where;
+
+  bestwhere = idxmalloc(nvtxs, "BisectGraph: bestwhere");
+  nbfs = 2*(nvtxs <= ctrl->CoarsenTo ? SMALLNIPARTS : LARGENIPARTS);
+  bestcut = idxsum(graph->nedges, graph->adjwgt);  
+
+  for (; nbfs>0; nbfs--) {
+    idxset(nvtxs, 1, where);
+    where[RandomInRange(nvtxs)] = 0;
+
+    MocCompute2WayPartitionParams(ctrl, graph);
+
+    MocInit2WayBalance(ctrl, graph, tpwgts);
+
+    MocFM_2WayEdgeRefine(ctrl, graph, tpwgts, 4); 
+
+    MocBalance2Way(ctrl, graph, tpwgts, 1.02);
+    MocFM_2WayEdgeRefine(ctrl, graph, tpwgts, 4); 
+
+    if (bestcut >= graph->mincut) {
+      bestcut = graph->mincut;
+      idxcopy(nvtxs, where, bestwhere);
+      if (bestcut == 0)
+        break;
+    }
+  }
+
+  graph->mincut = bestcut;
+  idxcopy(nvtxs, bestwhere, where);
+
+  GKfree(&bestwhere, LTERM);
+}
+
+
+
+/*************************************************************************
+* This function takes a graph and produces a bisection by using a region
+* growing algorithm. The resulting partition is returned in
+* graph->where
+**************************************************************************/
+void MocRandomBisection(CtrlType *ctrl, GraphType *graph, float *tpwgts, float ubfactor)
+{
+  int i, ii, j, k, nvtxs, ncon, from, bestcut, mincut, nbfs, qnum;
+  idxtype *bestwhere, *where, *perm;
+  int counts[MAXNCON];
+  float *nvwgt;
+
+  nvtxs = graph->nvtxs;
+  ncon = graph->ncon;
+  nvwgt = graph->nvwgt;
+
+  MocAllocate2WayPartitionMemory(ctrl, graph);
+  where = graph->where;
+
+  bestwhere = idxmalloc(nvtxs, "BisectGraph: bestwhere");
+  nbfs = 2*(nvtxs <= ctrl->CoarsenTo ? SMALLNIPARTS : LARGENIPARTS);
+  bestcut = idxsum(graph->nedges, graph->adjwgt);  
+  perm = idxmalloc(nvtxs, "BisectGraph: perm");
+
+  for (; nbfs>0; nbfs--) {
+    for (i=0; i<ncon; i++)
+      counts[i] = 0;
+
+    RandomPermute(nvtxs, perm, 1);
+
+    /* Partition by spliting the queues randomly */
+    for (ii=0; ii<nvtxs; ii++) {
+      i = perm[ii];
+      qnum = samax(ncon, nvwgt+i*ncon);
+      where[i] = counts[qnum];
+      counts[qnum] = (counts[qnum]+1)%2;
+    }
+
+    MocCompute2WayPartitionParams(ctrl, graph);
+
+    MocFM_2WayEdgeRefine(ctrl, graph, tpwgts, 6); 
+    MocBalance2Way(ctrl, graph, tpwgts, 1.02);
+    MocFM_2WayEdgeRefine(ctrl, graph, tpwgts, 6); 
+    MocBalance2Way(ctrl, graph, tpwgts, 1.02);
+    MocFM_2WayEdgeRefine(ctrl, graph, tpwgts, 6); 
+
+    /*
+    printf("Edgecut: %6d, NPwgts: [", graph->mincut);
+    for (i=0; i<graph->ncon; i++)
+      printf("(%.3f %.3f) ", graph->npwgts[i], graph->npwgts[graph->ncon+i]);
+    printf("]\n");
+    */
+
+    if (bestcut >= graph->mincut) {
+      bestcut = graph->mincut;
+      idxcopy(nvtxs, where, bestwhere);
+      if (bestcut == 0)
+        break;
+    }
+  }
+
+  graph->mincut = bestcut;
+  idxcopy(nvtxs, bestwhere, where);
+
+  GKfree(&bestwhere, &perm, LTERM);
+}
+
+
+
+
+/*************************************************************************
+* This function balances two partitions by moving the highest gain 
+* (including negative gain) vertices to the other domain.
+* It is used only when tha unbalance is due to non contigous
+* subdomains. That is, the are no boundary vertices.
+* It moves vertices from the domain that is overweight to the one that 
+* is underweight.
+**************************************************************************/
+void MocInit2WayBalance(CtrlType *ctrl, GraphType *graph, float *tpwgts)
+{
+  int i, ii, j, k, l, kwgt, nvtxs, nbnd, ncon, nswaps, from, to, pass, me, cnum, tmp;
+  idxtype *xadj, *adjncy, *adjwgt, *where, *id, *ed, *bndptr, *bndind;
+  idxtype *perm, *qnum;
+  float *nvwgt, *npwgts;
+  PQueueType parts[MAXNCON][2];
+  int higain, oldgain, mincut;
+
+  nvtxs = graph->nvtxs;
+  ncon = graph->ncon;
+  xadj = graph->xadj;
+  adjncy = graph->adjncy;
+  nvwgt = graph->nvwgt;
+  adjwgt = graph->adjwgt;
+  where = graph->where;
+  id = graph->id;
+  ed = graph->ed;
+  npwgts = graph->npwgts;
+  bndptr = graph->bndptr;
+  bndind = graph->bndind;
+
+  perm = idxwspacemalloc(ctrl, nvtxs);
+  qnum = idxwspacemalloc(ctrl, nvtxs);
+
+  /* This is called for initial partitioning so we know from where to pick nodes */
+  from = 1;
+  to = (from+1)%2;
+
+  if (ctrl->dbglvl&DBG_REFINE) {
+    printf("Parts: [");
+    for (l=0; l<ncon; l++)
+      printf("(%.3f, %.3f) ", npwgts[l], npwgts[ncon+l]);
+    printf("] T[%.3f %.3f], Nv-Nb[%5d, %5d]. ICut: %6d, LB: %.3f [B]\n", tpwgts[0], tpwgts[1], 
+           graph->nvtxs, graph->nbnd, graph->mincut, 
+           Compute2WayHLoadImbalance(ncon, npwgts, tpwgts));
+  }
+
+  for (i=0; i<ncon; i++) {
+    PQueueInit(ctrl, &parts[i][0], nvtxs, PLUS_GAINSPAN+1);
+    PQueueInit(ctrl, &parts[i][1], nvtxs, PLUS_GAINSPAN+1);
+  }
+
+  ASSERT(ComputeCut(graph, where) == graph->mincut);
+  ASSERT(CheckBnd(graph));
+  ASSERT(CheckGraph(graph));
+
+  /* Compute the queues in which each vertex will be assigned to */
+  for (i=0; i<nvtxs; i++)
+    qnum[i] = samax(ncon, nvwgt+i*ncon);
+
+  /* Insert the nodes of the proper partition in the appropriate priority queue */
+  RandomPermute(nvtxs, perm, 1);
+  for (ii=0; ii<nvtxs; ii++) {
+    i = perm[ii];
+    if (where[i] == from) {
+      if (ed[i] > 0)
+        PQueueInsert(&parts[qnum[i]][0], i, ed[i]-id[i]);
+      else
+        PQueueInsert(&parts[qnum[i]][1], i, ed[i]-id[i]);
+    }
+  }
+
+
+  mincut = graph->mincut;
+  nbnd = graph->nbnd;
+  for (nswaps=0; nswaps<nvtxs; nswaps++) {
+    if (AreAnyVwgtsBelow(ncon, 1.0, npwgts+from*ncon, 0.0, nvwgt, tpwgts[from]))
+      break;
+
+    if ((cnum = SelectQueueOneWay(ncon, npwgts, tpwgts, from, parts)) == -1)
+      break;
+
+    if ((higain = PQueueGetMax(&parts[cnum][0])) == -1)
+      higain = PQueueGetMax(&parts[cnum][1]);
+
+    mincut -= (ed[higain]-id[higain]);
+    saxpy(ncon, 1.0, nvwgt+higain*ncon, 1, npwgts+to*ncon, 1);
+    saxpy(ncon, -1.0, nvwgt+higain*ncon, 1, npwgts+from*ncon, 1);
+
+    where[higain] = to;
+
+    if (ctrl->dbglvl&DBG_MOVEINFO) {
+      printf("Moved %6d from %d(%d). [%5d] %5d, NPwgts: ", higain, from, cnum, ed[higain]-id[higain], mincut);
+      for (l=0; l<ncon; l++) 
+        printf("(%.3f, %.3f) ", npwgts[l], npwgts[ncon+l]);
+      printf(", LB: %.3f\n", Compute2WayHLoadImbalance(ncon, npwgts, tpwgts));
+      if (ed[higain] == 0 && id[higain] > 0)
+        printf("\t Pulled from the interior!\n");
+    }
+
+
+    /**************************************************************
+    * Update the id[i]/ed[i] values of the affected nodes
+    ***************************************************************/
+    SWAP(id[higain], ed[higain], tmp);
+    if (ed[higain] == 0 && bndptr[higain] != -1 && xadj[higain] < xadj[higain+1]) 
+      BNDDelete(nbnd, bndind,  bndptr, higain);
+    if (ed[higain] > 0 && bndptr[higain] == -1)
+      BNDInsert(nbnd, bndind,  bndptr, higain);
+
+    for (j=xadj[higain]; j<xadj[higain+1]; j++) {
+      k = adjncy[j];
+      oldgain = ed[k]-id[k];
+
+      kwgt = (to == where[k] ? adjwgt[j] : -adjwgt[j]);
+      INC_DEC(id[k], ed[k], kwgt);
+
+      /* Update the queue position */
+      if (where[k] == from) {
+        if (ed[k] > 0 && bndptr[k] == -1) {  /* It moves in boundary */
+          PQueueDelete(&parts[qnum[k]][1], k, oldgain);
+          PQueueInsert(&parts[qnum[k]][0], k, ed[k]-id[k]);
+        }
+        else { /* It must be in the boundary already */
+          if (bndptr[k] == -1)
+            printf("What you thought was wrong!\n");
+          PQueueUpdate(&parts[qnum[k]][0], k, oldgain, ed[k]-id[k]);
+        }
+      }
+
+      /* Update its boundary information */
+      if (ed[k] == 0 && bndptr[k] != -1) 
+        BNDDelete(nbnd, bndind, bndptr, k);
+      else if (ed[k] > 0 && bndptr[k] == -1)  
+        BNDInsert(nbnd, bndind, bndptr, k);
+    }
+
+    ASSERTP(ComputeCut(graph, where) == mincut, ("%d != %d\n", ComputeCut(graph, where), mincut));
+
+  }
+
+  if (ctrl->dbglvl&DBG_REFINE) {
+    printf("\tMincut: %6d, NBND: %6d, NPwgts: ", mincut, nbnd);
+    for (l=0; l<ncon; l++)
+      printf("(%.3f, %.3f) ", npwgts[l], npwgts[ncon+l]);
+    printf(", LB: %.3f\n", Compute2WayHLoadImbalance(ncon, npwgts, tpwgts));
+  }
+
+  graph->mincut = mincut;
+  graph->nbnd = nbnd;
+
+  for (i=0; i<ncon; i++) {
+    PQueueFree(ctrl, &parts[i][0]);
+    PQueueFree(ctrl, &parts[i][1]);
+  }
+
+  ASSERT(ComputeCut(graph, where) == graph->mincut);
+  ASSERT(CheckBnd(graph));
+
+  idxwspacefree(ctrl, nvtxs);
+  idxwspacefree(ctrl, nvtxs);
+}
+
+
+
+
+/*************************************************************************
+* This function selects the partition number and the queue from which
+* we will move vertices out
+**************************************************************************/ 
+int SelectQueueOneWay(int ncon, float *npwgts, float *tpwgts, int from, PQueueType queues[MAXNCON][2])
+{
+  int i, cnum=-1;
+  float max=0.0;
+
+  for (i=0; i<ncon; i++) {
+    if (npwgts[from*ncon+i]-tpwgts[from] >= max && 
+        PQueueGetSize(&queues[i][0]) + PQueueGetSize(&queues[i][1]) > 0) {
+      max = npwgts[from*ncon+i]-tpwgts[0];
+      cnum = i;
+    }
+  }
+
+  return cnum;
+}
+
+
Index: /inundation/pymetis/metis-4.0/Lib/minitpart2.c
===================================================================
--- /inundation/pymetis/metis-4.0/Lib/minitpart2.c	(revision 2051)
+++ /inundation/pymetis/metis-4.0/Lib/minitpart2.c	(revision 2051)
@@ -0,0 +1,368 @@
+/*
+ * Copyright 1997, Regents of the University of Minnesota
+ *
+ * minitpart2.c
+ *
+ * This file contains code that performs the initial partition of the
+ * coarsest graph
+ *
+ * Started 7/23/97
+ * George
+ *
+ * $Id: minitpart2.c,v 1.1 1998/11/27 17:59:23 karypis Exp $
+ *
+ */
+
+#include <metis.h>
+
+/*************************************************************************
+* This function computes the initial bisection of the coarsest graph
+**************************************************************************/
+void MocInit2WayPartition2(CtrlType *ctrl, GraphType *graph, float *tpwgts, float *ubvec) 
+{
+  int dbglvl;
+
+  dbglvl = ctrl->dbglvl;
+  IFSET(ctrl->dbglvl, DBG_REFINE, ctrl->dbglvl -= DBG_REFINE);
+  IFSET(ctrl->dbglvl, DBG_MOVEINFO, ctrl->dbglvl -= DBG_MOVEINFO);
+
+  IFSET(ctrl->dbglvl, DBG_TIME, starttimer(ctrl->InitPartTmr));
+
+  switch (ctrl->IType) {
+    case IPART_GGPKL:
+    case IPART_RANDOM:
+      MocGrowBisection2(ctrl, graph, tpwgts, ubvec);
+      break;
+    case 3:
+      MocGrowBisectionNew2(ctrl, graph, tpwgts, ubvec);
+      break;
+    default:
+      errexit("Unknown initial partition type: %d\n", ctrl->IType);
+  }
+
+  IFSET(ctrl->dbglvl, DBG_IPART, printf("Initial Cut: %d\n", graph->mincut));
+  IFSET(ctrl->dbglvl, DBG_TIME, stoptimer(ctrl->InitPartTmr));
+  ctrl->dbglvl = dbglvl;
+
+}
+
+
+
+
+/*************************************************************************
+* This function takes a graph and produces a bisection by using a region
+* growing algorithm. The resulting partition is returned in
+* graph->where
+**************************************************************************/
+void MocGrowBisection2(CtrlType *ctrl, GraphType *graph, float *tpwgts, float *ubvec)
+{
+  int i, j, k, nvtxs, ncon, from, bestcut, mincut, nbfs;
+  idxtype *bestwhere, *where;
+
+  nvtxs = graph->nvtxs;
+
+  MocAllocate2WayPartitionMemory(ctrl, graph);
+  where = graph->where;
+
+  bestwhere = idxmalloc(nvtxs, "BisectGraph: bestwhere");
+  nbfs = 2*(nvtxs <= ctrl->CoarsenTo ? SMALLNIPARTS : LARGENIPARTS);
+  bestcut = idxsum(graph->nedges, graph->adjwgt);  
+
+  for (; nbfs>0; nbfs--) {
+    idxset(nvtxs, 1, where);
+    where[RandomInRange(nvtxs)] = 0;
+
+    MocCompute2WayPartitionParams(ctrl, graph);
+
+    MocBalance2Way2(ctrl, graph, tpwgts, ubvec);
+
+    MocFM_2WayEdgeRefine2(ctrl, graph, tpwgts, ubvec, 4); 
+
+    MocBalance2Way2(ctrl, graph, tpwgts, ubvec);
+    MocFM_2WayEdgeRefine2(ctrl, graph, tpwgts, ubvec, 4); 
+
+    if (bestcut > graph->mincut) {
+      bestcut = graph->mincut;
+      idxcopy(nvtxs, where, bestwhere);
+      if (bestcut == 0)
+        break;
+    }
+  }
+
+  graph->mincut = bestcut;
+  idxcopy(nvtxs, bestwhere, where);
+
+  GKfree(&bestwhere, LTERM);
+}
+
+
+
+
+
+
+/*************************************************************************
+* This function takes a graph and produces a bisection by using a region
+* growing algorithm. The resulting partition is returned in
+* graph->where
+**************************************************************************/
+void MocGrowBisectionNew2(CtrlType *ctrl, GraphType *graph, float *tpwgts, float *ubvec)
+{
+  int i, j, k, nvtxs, ncon, from, bestcut, mincut, nbfs;
+  idxtype *bestwhere, *where;
+
+  nvtxs = graph->nvtxs;
+
+  MocAllocate2WayPartitionMemory(ctrl, graph);
+  where = graph->where;
+
+  bestwhere = idxmalloc(nvtxs, "BisectGraph: bestwhere");
+  nbfs = 2*(nvtxs <= ctrl->CoarsenTo ? SMALLNIPARTS : LARGENIPARTS);
+  bestcut = idxsum(graph->nedges, graph->adjwgt);  
+
+  for (; nbfs>0; nbfs--) {
+    idxset(nvtxs, 1, where);
+    where[RandomInRange(nvtxs)] = 0;
+
+    MocCompute2WayPartitionParams(ctrl, graph);
+
+    MocInit2WayBalance2(ctrl, graph, tpwgts, ubvec);
+
+    MocFM_2WayEdgeRefine2(ctrl, graph, tpwgts, ubvec, 4); 
+
+    if (bestcut > graph->mincut) {
+      bestcut = graph->mincut;
+      idxcopy(nvtxs, where, bestwhere);
+      if (bestcut == 0)
+        break;
+    }
+  }
+
+  graph->mincut = bestcut;
+  idxcopy(nvtxs, bestwhere, where);
+
+  GKfree(&bestwhere, LTERM);
+}
+
+
+
+/*************************************************************************
+* This function balances two partitions by moving the highest gain 
+* (including negative gain) vertices to the other domain.
+* It is used only when tha unbalance is due to non contigous
+* subdomains. That is, the are no boundary vertices.
+* It moves vertices from the domain that is overweight to the one that 
+* is underweight.
+**************************************************************************/
+void MocInit2WayBalance2(CtrlType *ctrl, GraphType *graph, float *tpwgts, float *ubvec)
+{
+  int i, ii, j, k, l, kwgt, nvtxs, nbnd, ncon, nswaps, from, to, pass, me, cnum, tmp, imin;
+  idxtype *xadj, *adjncy, *adjwgt, *where, *id, *ed, *bndptr, *bndind;
+  idxtype *moved, *perm, *qnum;
+  float *nvwgt, *npwgts, minwgt;
+  PQueueType parts[MAXNCON][2];
+  int higain, oldgain, mincut;
+
+  nvtxs = graph->nvtxs;
+  ncon = graph->ncon;
+  xadj = graph->xadj;
+  adjncy = graph->adjncy;
+  nvwgt = graph->nvwgt;
+  adjwgt = graph->adjwgt;
+  where = graph->where;
+  id = graph->id;
+  ed = graph->ed;
+  npwgts = graph->npwgts;
+  bndptr = graph->bndptr;
+  bndind = graph->bndind;
+
+  moved = idxwspacemalloc(ctrl, nvtxs);
+  perm = idxwspacemalloc(ctrl, nvtxs);
+  qnum = idxwspacemalloc(ctrl, nvtxs);
+
+  /* This is called for initial partitioning so we know from where to pick nodes */
+  from = 1;
+  to = (from+1)%2;
+
+  if (ctrl->dbglvl&DBG_REFINE) {
+    printf("Parts: [");
+    for (l=0; l<ncon; l++)
+      printf("(%.3f, %.3f) ", npwgts[l], npwgts[ncon+l]);
+    printf("] T[%.3f %.3f], Nv-Nb[%5d, %5d]. ICut: %6d, LB: %.3f [B]\n", tpwgts[0], tpwgts[1], graph->nvtxs, graph->nbnd, graph->mincut, ComputeLoadImbalance(ncon, 2, npwgts, tpwgts));
+  }
+
+  for (i=0; i<ncon; i++) {
+    PQueueInit(ctrl, &parts[i][0], nvtxs, PLUS_GAINSPAN+1);
+    PQueueInit(ctrl, &parts[i][1], nvtxs, PLUS_GAINSPAN+1);
+  }
+
+  idxset(nvtxs, -1, moved);
+
+  ASSERT(ComputeCut(graph, where) == graph->mincut);
+  ASSERT(CheckBnd(graph));
+  ASSERT(CheckGraph(graph));
+
+  /* Compute the queues in which each vertex will be assigned to */
+  for (i=0; i<nvtxs; i++)
+    qnum[i] = samax(ncon, nvwgt+i*ncon);
+
+  /* Insert the nodes of the proper partition in the appropriate priority queue */
+  RandomPermute(nvtxs, perm, 1);
+  for (ii=0; ii<nvtxs; ii++) {
+    i = perm[ii];
+    if (where[i] == from) {
+      if (ed[i] > 0)
+        PQueueInsert(&parts[qnum[i]][0], i, ed[i]-id[i]);
+      else
+        PQueueInsert(&parts[qnum[i]][1], i, ed[i]-id[i]);
+    }
+  }
+
+/*
+  for (i=0; i<ncon; i++)
+    printf("Queue #%d has %d %d\n", i, parts[i][0].nnodes, parts[i][1].nnodes);
+*/
+
+  /* Determine the termination criterion */
+  imin = 0;
+  for (i=1; i<ncon; i++) 
+    imin = (ubvec[i] < ubvec[imin] ? i : imin);
+  minwgt = .5/ubvec[imin];
+
+  mincut = graph->mincut;
+  nbnd = graph->nbnd;
+  for (nswaps=0; nswaps<nvtxs; nswaps++) {
+    /* Exit as soon as the minimum weight crossed over */
+    if (npwgts[to*ncon+imin] > minwgt)  
+      break;
+
+    if ((cnum = SelectQueueOneWay2(ncon, npwgts+to*ncon, parts, ubvec)) == -1)
+      break;
+
+    if ((higain = PQueueGetMax(&parts[cnum][0])) == -1)
+      higain = PQueueGetMax(&parts[cnum][1]);
+
+    mincut -= (ed[higain]-id[higain]);
+    saxpy(ncon, 1.0, nvwgt+higain*ncon, 1, npwgts+to*ncon, 1);
+    saxpy(ncon, -1.0, nvwgt+higain*ncon, 1, npwgts+from*ncon, 1);
+
+    where[higain] = to;
+    moved[higain] = nswaps;
+
+    if (ctrl->dbglvl&DBG_MOVEINFO) {
+      printf("Moved %6d from %d(%d). [%5d] %5d, NPwgts: ", higain, from, cnum, ed[higain]-id[higain], mincut);
+      for (l=0; l<ncon; l++) 
+        printf("(%.3f, %.3f) ", npwgts[l], npwgts[ncon+l]);
+      printf(", LB: %.3f\n", ComputeLoadImbalance(ncon, 2, npwgts, tpwgts));
+      if (ed[higain] == 0 && id[higain] > 0)
+        printf("\t Pulled from the interior!\n");
+    }
+
+
+    /**************************************************************
+    * Update the id[i]/ed[i] values of the affected nodes
+    ***************************************************************/
+    SWAP(id[higain], ed[higain], tmp);
+    if (ed[higain] == 0 && bndptr[higain] != -1 && xadj[higain] < xadj[higain+1]) 
+      BNDDelete(nbnd, bndind,  bndptr, higain);
+    if (ed[higain] > 0 && bndptr[higain] == -1)
+      BNDInsert(nbnd, bndind,  bndptr, higain);
+
+    for (j=xadj[higain]; j<xadj[higain+1]; j++) {
+      k = adjncy[j];
+      oldgain = ed[k]-id[k];
+
+      kwgt = (to == where[k] ? adjwgt[j] : -adjwgt[j]);
+      INC_DEC(id[k], ed[k], kwgt);
+
+      /* Update the queue position */
+      if (moved[k] == -1 && where[k] == from) {
+        if (ed[k] > 0 && bndptr[k] == -1) {  /* It moves in boundary */
+          PQueueDelete(&parts[qnum[k]][1], k, oldgain);
+          PQueueInsert(&parts[qnum[k]][0], k, ed[k]-id[k]);
+        }
+        else { /* It must be in the boundary already */
+          if (bndptr[k] == -1)
+            printf("What you thought was wrong!\n");
+          PQueueUpdate(&parts[qnum[k]][0], k, oldgain, ed[k]-id[k]);
+        }
+      }
+
+      /* Update its boundary information */
+      if (ed[k] == 0 && bndptr[k] != -1) 
+        BNDDelete(nbnd, bndind, bndptr, k);
+      else if (ed[k] > 0 && bndptr[k] == -1)  
+        BNDInsert(nbnd, bndind, bndptr, k);
+    }
+
+    ASSERTP(ComputeCut(graph, where) == mincut, ("%d != %d\n", ComputeCut(graph, where), mincut));
+
+  }
+
+  if (ctrl->dbglvl&DBG_REFINE) {
+    printf("\tMincut: %6d, NBND: %6d, NPwgts: ", mincut, nbnd);
+    for (l=0; l<ncon; l++)
+      printf("(%.3f, %.3f) ", npwgts[l], npwgts[ncon+l]);
+    printf(", LB: %.3f\n", ComputeLoadImbalance(ncon, 2, npwgts, tpwgts));
+  }
+
+  graph->mincut = mincut;
+  graph->nbnd = nbnd;
+
+  for (i=0; i<ncon; i++) {
+    PQueueFree(ctrl, &parts[i][0]);
+    PQueueFree(ctrl, &parts[i][1]);
+  }
+
+  ASSERT(ComputeCut(graph, where) == graph->mincut);
+  ASSERT(CheckBnd(graph));
+
+  idxwspacefree(ctrl, nvtxs);
+  idxwspacefree(ctrl, nvtxs);
+  idxwspacefree(ctrl, nvtxs);
+}
+
+
+
+/*************************************************************************
+* This function selects the partition number and the queue from which
+* we will move vertices out
+**************************************************************************/ 
+int SelectQueueOneWay2(int ncon, float *pto, PQueueType queues[MAXNCON][2], float *ubvec)
+{
+  int i, cnum=-1, imax, maxgain;
+  float max=0.0;
+  float twgt[MAXNCON];
+
+  for (i=0; i<ncon; i++) {
+    if (max < pto[i]) {
+      imax = i;
+      max = pto[i];
+    }
+  }
+  for (i=0; i<ncon; i++) 
+    twgt[i] = (max/(ubvec[imax]*ubvec[i]))/pto[i];
+  twgt[imax] = 0.0;
+
+  max = 0.0;
+  for (i=0; i<ncon; i++) {
+    if (max < twgt[i] && (PQueueGetSize(&queues[i][0]) > 0 || PQueueGetSize(&queues[i][1]) > 0)) {
+      max = twgt[i];
+      cnum = i;
+    }
+  }
+  if (max > 1)
+    return cnum;
+
+  /* optimize of cut */
+  maxgain = -10000000;
+  for (i=0; i<ncon; i++) {
+    if (PQueueGetSize(&queues[i][0]) > 0 && PQueueGetKey(&queues[i][0]) > maxgain) {
+      maxgain = PQueueGetKey(&queues[i][0]);
+      cnum = i;
+    }
+  }
+
+  return cnum;
+
+}
+
Index: /inundation/pymetis/metis-4.0/Lib/mkmetis.c
===================================================================
--- /inundation/pymetis/metis-4.0/Lib/mkmetis.c	(revision 2051)
+++ /inundation/pymetis/metis-4.0/Lib/mkmetis.c	(revision 2051)
@@ -0,0 +1,123 @@
+/*
+ * Copyright 1997, Regents of the University of Minnesota
+ *
+ * mkmetis.c
+ *
+ * This file contains the top level routines for the multilevel k-way partitioning
+ * algorithm KMETIS.
+ *
+ * Started 7/28/97
+ * George
+ *
+ * $Id: mkmetis.c,v 1.2 1998/11/27 18:25:09 karypis Exp $
+ *
+ */
+
+#include <metis.h>
+
+
+
+/*************************************************************************
+* This function is the entry point for KWMETIS
+**************************************************************************/
+void METIS_mCPartGraphKway(int *nvtxs, int *ncon, idxtype *xadj, idxtype *adjncy, 
+                          idxtype *vwgt, idxtype *adjwgt, int *wgtflag, int *numflag, 
+                          int *nparts, float *rubvec, int *options, int *edgecut, 
+                          idxtype *part)
+{
+  int i, j;
+  GraphType graph;
+  CtrlType ctrl;
+
+  if (*numflag == 1)
+    Change2CNumbering(*nvtxs, xadj, adjncy);
+
+  SetUpGraph(&graph, OP_KMETIS, *nvtxs, *ncon, xadj, adjncy, vwgt, adjwgt, *wgtflag);
+
+  if (options[0] == 0) {  /* Use the default parameters */
+    ctrl.CType  = McKMETIS_CTYPE;
+    ctrl.IType  = McKMETIS_ITYPE;
+    ctrl.RType  = McKMETIS_RTYPE;
+    ctrl.dbglvl = McKMETIS_DBGLVL;
+  }
+  else {
+    ctrl.CType  = options[OPTION_CTYPE];
+    ctrl.IType  = options[OPTION_ITYPE];
+    ctrl.RType  = options[OPTION_RTYPE];
+    ctrl.dbglvl = options[OPTION_DBGLVL];
+  }
+  ctrl.optype = OP_KMETIS;
+  ctrl.CoarsenTo = amax((*nvtxs)/(20*log2(*nparts)), 30*(*nparts));
+
+  ctrl.nmaxvwgt = 1.5/(1.0*ctrl.CoarsenTo);
+
+  InitRandom(-1);
+
+  AllocateWorkSpace(&ctrl, &graph, *nparts);
+
+  IFSET(ctrl.dbglvl, DBG_TIME, InitTimers(&ctrl));
+  IFSET(ctrl.dbglvl, DBG_TIME, starttimer(ctrl.TotalTmr));
+
+  *edgecut = MCMlevelKWayPartitioning(&ctrl, &graph, *nparts, part, rubvec);
+
+  IFSET(ctrl.dbglvl, DBG_TIME, stoptimer(ctrl.TotalTmr));
+  IFSET(ctrl.dbglvl, DBG_TIME, PrintTimers(&ctrl));
+
+  FreeWorkSpace(&ctrl, &graph);
+
+  if (*numflag == 1)
+    Change2FNumbering(*nvtxs, xadj, adjncy, part);
+}
+
+
+/*************************************************************************
+* This function takes a graph and produces a bisection of it
+**************************************************************************/
+int MCMlevelKWayPartitioning(CtrlType *ctrl, GraphType *graph, int nparts, idxtype *part, 
+      float *rubvec)
+{
+  int i, j, nvtxs;
+  GraphType *cgraph;
+  int options[10], edgecut;
+
+  cgraph = MCCoarsen2Way(ctrl, graph);
+
+  IFSET(ctrl->dbglvl, DBG_TIME, starttimer(ctrl->InitPartTmr));
+  MocAllocateKWayPartitionMemory(ctrl, cgraph, nparts);
+
+  options[0] = 1; 
+  options[OPTION_CTYPE] = MATCH_SBHEM_INFNORM;
+  options[OPTION_ITYPE] = IPART_RANDOM;
+  options[OPTION_RTYPE] = RTYPE_FM;
+  options[OPTION_DBGLVL] = 0;
+
+  /* Determine what you will use as the initial partitioner, based on tolerances */
+  for (i=0; i<graph->ncon; i++) {
+    if (rubvec[i] > 1.2)
+      break;
+  }
+  if (i == graph->ncon)
+    METIS_mCPartGraphRecursiveInternal(&cgraph->nvtxs, &cgraph->ncon, 
+          cgraph->xadj, cgraph->adjncy, cgraph->nvwgt, cgraph->adjwgt, &nparts, 
+          options, &edgecut, cgraph->where);
+  else
+    METIS_mCHPartGraphRecursiveInternal(&cgraph->nvtxs, &cgraph->ncon, 
+          cgraph->xadj, cgraph->adjncy, cgraph->nvwgt, cgraph->adjwgt, &nparts, 
+          rubvec, options, &edgecut, cgraph->where);
+
+
+  IFSET(ctrl->dbglvl, DBG_TIME, stoptimer(ctrl->InitPartTmr));
+  IFSET(ctrl->dbglvl, DBG_IPART, printf("Initial %d-way partitioning cut: %d\n", nparts, edgecut));
+
+  IFSET(ctrl->dbglvl, DBG_KWAYPINFO, ComputePartitionInfo(cgraph, nparts, cgraph->where));
+
+  MocRefineKWayHorizontal(ctrl, graph, cgraph, nparts, rubvec);
+
+  idxcopy(graph->nvtxs, graph->where, part);
+
+  GKfree(&graph->nvwgt, &graph->npwgts, &graph->gdata, &graph->rdata, LTERM);
+
+  return graph->mincut;
+
+}
+
Index: /inundation/pymetis/metis-4.0/Lib/mkwayfmh.c
===================================================================
--- /inundation/pymetis/metis-4.0/Lib/mkwayfmh.c	(revision 2051)
+++ /inundation/pymetis/metis-4.0/Lib/mkwayfmh.c	(revision 2051)
@@ -0,0 +1,677 @@
+/*
+ * mkwayfmh.c
+ *
+ * This file contains code that implements the multilevel k-way refinement
+ *
+ * Started 7/28/97
+ * George
+ *
+ * $Id: mkwayfmh.c,v 1.1 1998/11/27 17:59:24 karypis Exp $
+ *
+ */
+
+#include <metis.h>
+
+
+
+/*************************************************************************
+* This function performs k-way refinement
+**************************************************************************/
+void MCRandom_KWayEdgeRefineHorizontal(CtrlType *ctrl, GraphType *graph, int nparts, 
+       float *orgubvec, int npasses)
+{
+  int i, ii, iii, j, jj, k, l, pass, nvtxs, ncon, nmoves, nbnd, myndegrees, same; 
+  int from, me, to, oldcut, gain;
+  idxtype *xadj, *adjncy, *adjwgt;
+  idxtype *where, *perm, *bndptr, *bndind;
+  EDegreeType *myedegrees;
+  RInfoType *myrinfo;
+  float *npwgts, *nvwgt, *minwgt, *maxwgt, maxlb, minlb, ubvec[MAXNCON], tvec[MAXNCON];
+
+  nvtxs = graph->nvtxs;
+  ncon = graph->ncon;
+  xadj = graph->xadj;
+  adjncy = graph->adjncy;
+  adjwgt = graph->adjwgt;
+
+  bndptr = graph->bndptr;
+  bndind = graph->bndind;
+
+  where = graph->where;
+  npwgts = graph->npwgts;
+  
+  /* Setup the weight intervals of the various subdomains */
+  minwgt =  fwspacemalloc(ctrl, nparts*ncon);
+  maxwgt = fwspacemalloc(ctrl, nparts*ncon);
+
+  /* See if the orgubvec consists of identical constraints */
+  maxlb = minlb = orgubvec[0];
+  for (i=1; i<ncon; i++) {
+    minlb = (orgubvec[i] < minlb ? orgubvec[i] : minlb);
+    maxlb = (orgubvec[i] > maxlb ? orgubvec[i] : maxlb);
+  }
+  same = (fabs(maxlb-minlb) < .01 ? 1 : 0);
+
+
+  /* Let's not get very optimistic. Let Balancing do the work */
+  ComputeHKWayLoadImbalance(ncon, nparts, npwgts, ubvec);
+  for (i=0; i<ncon; i++)
+    ubvec[i] = amax(ubvec[i], orgubvec[i]);
+
+  if (!same) {
+    for (i=0; i<nparts; i++) {
+      for (j=0; j<ncon; j++) {
+        maxwgt[i*ncon+j] = ubvec[j]/nparts;
+        minwgt[i*ncon+j] = 1.0/(ubvec[j]*nparts);
+      }
+    }
+  }
+  else {
+    maxlb = ubvec[0];
+    for (i=1; i<ncon; i++) 
+      maxlb = (ubvec[i] > maxlb ? ubvec[i] : maxlb);
+
+    for (i=0; i<nparts; i++) {
+      for (j=0; j<ncon; j++) {
+        maxwgt[i*ncon+j] = maxlb/nparts;
+        minwgt[i*ncon+j] = 1.0/(maxlb*nparts);
+      }
+    }
+  }
+
+
+  perm = idxwspacemalloc(ctrl, nvtxs);
+
+  if (ctrl->dbglvl&DBG_REFINE) {
+    printf("Partitions: [%5.4f %5.4f], Nv-Nb[%6d %6d]. Cut: %6d, LB: ",
+            npwgts[samin(ncon*nparts, npwgts)], npwgts[samax(ncon*nparts, npwgts)], 
+            graph->nvtxs, graph->nbnd, graph->mincut);
+    ComputeHKWayLoadImbalance(ncon, nparts, npwgts, tvec);
+    for (i=0; i<ncon; i++)
+      printf("%.3f ", tvec[i]);
+    printf("\n");
+  }
+
+  for (pass=0; pass<npasses; pass++) {
+    ASSERT(ComputeCut(graph, where) == graph->mincut);
+
+    oldcut = graph->mincut;
+    nbnd = graph->nbnd;
+
+    RandomPermute(nbnd, perm, 1);
+    for (nmoves=iii=0; iii<graph->nbnd; iii++) {
+      ii = perm[iii];
+      if (ii >= nbnd)
+        continue;
+      i = bndind[ii];
+
+      myrinfo = graph->rinfo+i;
+
+      if (myrinfo->ed >= myrinfo->id) { /* Total ED is too high */
+        from = where[i];
+        nvwgt = graph->nvwgt+i*ncon;
+
+        if (myrinfo->id > 0 && AreAllHVwgtsBelow(ncon, 1.0, npwgts+from*ncon, -1.0, nvwgt, minwgt+from*ncon)) 
+          continue;   /* This cannot be moved! */
+
+        myedegrees = myrinfo->edegrees;
+        myndegrees = myrinfo->ndegrees;
+
+        for (k=0; k<myndegrees; k++) {
+          to = myedegrees[k].pid;
+          gain = myedegrees[k].ed - myrinfo->id; 
+          if (gain >= 0 && 
+              (AreAllHVwgtsBelow(ncon, 1.0, npwgts+to*ncon, 1.0, nvwgt, maxwgt+to*ncon) ||
+               IsHBalanceBetterFT(ncon, nparts, npwgts+from*ncon, npwgts+to*ncon, nvwgt, ubvec)))
+            break;
+        }
+        if (k == myndegrees)
+          continue;  /* break out if you did not find a candidate */
+
+        for (j=k+1; j<myndegrees; j++) {
+          to = myedegrees[j].pid;
+          if ((myedegrees[j].ed > myedegrees[k].ed &&
+               (AreAllHVwgtsBelow(ncon, 1.0, npwgts+to*ncon, 1.0, nvwgt, maxwgt+to*ncon) || 
+               IsHBalanceBetterFT(ncon, nparts, npwgts+from*ncon, npwgts+to*ncon, nvwgt, ubvec))) ||
+              (myedegrees[j].ed == myedegrees[k].ed && 
+               IsHBalanceBetterTT(ncon, nparts, npwgts+myedegrees[k].pid*ncon, npwgts+to*ncon, nvwgt, ubvec)))
+            k = j;
+        }
+
+        to = myedegrees[k].pid;
+
+        if (myedegrees[k].ed-myrinfo->id == 0 
+            && !IsHBalanceBetterFT(ncon, nparts, npwgts+from*ncon, npwgts+to*ncon, nvwgt, ubvec)
+            && AreAllHVwgtsBelow(ncon, 1.0, npwgts+from*ncon, 0.0, npwgts+from*ncon, maxwgt+from*ncon)) 
+          continue;
+
+        /*=====================================================================
+        * If we got here, we can now move the vertex from 'from' to 'to' 
+        *======================================================================*/
+        graph->mincut -= myedegrees[k].ed-myrinfo->id;
+
+        IFSET(ctrl->dbglvl, DBG_MOVEINFO, printf("\t\tMoving %6d to %3d. Gain: %4d. Cut: %6d\n", i, to, myedegrees[k].ed-myrinfo->id, graph->mincut));
+
+        /* Update where, weight, and ID/ED information of the vertex you moved */
+        saxpy(ncon, 1.0, nvwgt, 1, npwgts+to*ncon, 1);
+        saxpy(ncon, -1.0, nvwgt, 1, npwgts+from*ncon, 1);
+        where[i] = to;
+        myrinfo->ed += myrinfo->id-myedegrees[k].ed;
+        SWAP(myrinfo->id, myedegrees[k].ed, j);
+        if (myedegrees[k].ed == 0) 
+          myedegrees[k] = myedegrees[--myrinfo->ndegrees];
+        else
+          myedegrees[k].pid = from;
+
+        if (myrinfo->ed-myrinfo->id < 0)
+          BNDDelete(nbnd, bndind, bndptr, i);
+
+        /* Update the degrees of adjacent vertices */
+        for (j=xadj[i]; j<xadj[i+1]; j++) {
+          ii = adjncy[j];
+          me = where[ii];
+
+          myrinfo = graph->rinfo+ii;
+          if (myrinfo->edegrees == NULL) {
+            myrinfo->edegrees = ctrl->wspace.edegrees+ctrl->wspace.cdegree;
+            ctrl->wspace.cdegree += xadj[ii+1]-xadj[ii];
+          }
+          myedegrees = myrinfo->edegrees;
+
+          ASSERT(CheckRInfo(myrinfo));
+
+          if (me == from) {
+            INC_DEC(myrinfo->ed, myrinfo->id, adjwgt[j]);
+
+            if (myrinfo->ed-myrinfo->id >= 0 && bndptr[ii] == -1)
+              BNDInsert(nbnd, bndind, bndptr, ii);
+          }
+          else if (me == to) {
+            INC_DEC(myrinfo->id, myrinfo->ed, adjwgt[j]);
+
+            if (myrinfo->ed-myrinfo->id < 0 && bndptr[ii] != -1)
+              BNDDelete(nbnd, bndind, bndptr, ii);
+          }
+
+          /* Remove contribution from the .ed of 'from' */
+          if (me != from) {
+            for (k=0; k<myrinfo->ndegrees; k++) {
+              if (myedegrees[k].pid == from) {
+                if (myedegrees[k].ed == adjwgt[j])
+                  myedegrees[k] = myedegrees[--myrinfo->ndegrees];
+                else
+                  myedegrees[k].ed -= adjwgt[j];
+                break;
+              }
+            }
+          }
+
+          /* Add contribution to the .ed of 'to' */
+          if (me != to) {
+            for (k=0; k<myrinfo->ndegrees; k++) {
+              if (myedegrees[k].pid == to) {
+                myedegrees[k].ed += adjwgt[j];
+                break;
+              }
+            }
+            if (k == myrinfo->ndegrees) {
+              myedegrees[myrinfo->ndegrees].pid = to;
+              myedegrees[myrinfo->ndegrees++].ed = adjwgt[j];
+            }
+          }
+
+          ASSERT(myrinfo->ndegrees <= xadj[ii+1]-xadj[ii]);
+          ASSERT(CheckRInfo(myrinfo));
+
+        }
+        nmoves++;
+      }
+    }
+
+    graph->nbnd = nbnd;
+
+    if (ctrl->dbglvl&DBG_REFINE) {
+      printf("\t [%5.4f %5.4f], Nb: %6d, Nmoves: %5d, Cut: %6d, LB: ",
+              npwgts[samin(ncon*nparts, npwgts)], npwgts[samax(ncon*nparts, npwgts)], 
+              nbnd, nmoves, graph->mincut);
+      ComputeHKWayLoadImbalance(ncon, nparts, npwgts, tvec);
+      for (i=0; i<ncon; i++)
+        printf("%.3f ", tvec[i]);
+      printf("\n");
+    }
+
+    if (graph->mincut == oldcut)
+      break;
+  }
+
+  fwspacefree(ctrl, ncon*nparts);
+  fwspacefree(ctrl, ncon*nparts);
+  idxwspacefree(ctrl, nvtxs);
+}
+
+
+
+/*************************************************************************
+* This function performs k-way refinement
+**************************************************************************/
+void MCGreedy_KWayEdgeBalanceHorizontal(CtrlType *ctrl, GraphType *graph, int nparts, 
+       float *ubvec, int npasses)
+{
+  int i, ii, iii, j, jj, k, l, pass, nvtxs, ncon, nbnd, myndegrees, oldgain, gain, nmoves; 
+  int from, me, to, oldcut;
+  idxtype *xadj, *adjncy, *adjwgt;
+  idxtype *where, *perm, *bndptr, *bndind, *moved;
+  EDegreeType *myedegrees;
+  RInfoType *myrinfo;
+  PQueueType queue;
+  float *npwgts, *nvwgt, *minwgt, *maxwgt, tvec[MAXNCON];
+
+  nvtxs = graph->nvtxs;
+  ncon = graph->ncon;
+  xadj = graph->xadj;
+  adjncy = graph->adjncy;
+  adjwgt = graph->adjwgt;
+
+  bndind = graph->bndind;
+  bndptr = graph->bndptr;
+
+  where = graph->where;
+  npwgts = graph->npwgts;
+  
+  /* Setup the weight intervals of the various subdomains */
+  minwgt =  fwspacemalloc(ctrl, ncon*nparts);
+  maxwgt = fwspacemalloc(ctrl, ncon*nparts);
+
+  for (i=0; i<nparts; i++) {
+    for (j=0; j<ncon; j++) {
+      maxwgt[i*ncon+j] = ubvec[j]/nparts;
+      minwgt[i*ncon+j] = 1.0/(ubvec[j]*nparts);
+    }
+  }
+
+  perm = idxwspacemalloc(ctrl, nvtxs);
+  moved = idxwspacemalloc(ctrl, nvtxs);
+
+  PQueueInit(ctrl, &queue, nvtxs, graph->adjwgtsum[idxamax(nvtxs, graph->adjwgtsum)]);
+
+  if (ctrl->dbglvl&DBG_REFINE) {
+    printf("Partitions: [%5.4f %5.4f], Nv-Nb[%6d %6d]. Cut: %6d, LB: ",
+            npwgts[samin(ncon*nparts, npwgts)], npwgts[samax(ncon*nparts, npwgts)], 
+            graph->nvtxs, graph->nbnd, graph->mincut);
+    ComputeHKWayLoadImbalance(ncon, nparts, npwgts, tvec);
+    for (i=0; i<ncon; i++)
+      printf("%.3f ", tvec[i]);
+    printf("[B]\n");
+  }
+
+
+  for (pass=0; pass<npasses; pass++) {
+    ASSERT(ComputeCut(graph, where) == graph->mincut);
+
+    /* Check to see if things are out of balance, given the tolerance */
+    if (MocIsHBalanced(ncon, nparts, npwgts, ubvec))
+      break;
+
+    PQueueReset(&queue);
+    idxset(nvtxs, -1, moved);
+
+    oldcut = graph->mincut;
+    nbnd = graph->nbnd;
+
+    RandomPermute(nbnd, perm, 1);
+    for (ii=0; ii<nbnd; ii++) {
+      i = bndind[perm[ii]];
+      PQueueInsert(&queue, i, graph->rinfo[i].ed - graph->rinfo[i].id);
+      moved[i] = 2;
+    }
+
+    nmoves = 0;
+    for (;;) {
+      if ((i = PQueueGetMax(&queue)) == -1) 
+        break;
+      moved[i] = 1;
+
+      myrinfo = graph->rinfo+i;
+      from = where[i];
+      nvwgt = graph->nvwgt+i*ncon;
+
+      if (AreAllHVwgtsBelow(ncon, 1.0, npwgts+from*ncon, -1.0, nvwgt, minwgt+from*ncon))
+        continue;   /* This cannot be moved! */
+
+      myedegrees = myrinfo->edegrees;
+      myndegrees = myrinfo->ndegrees;
+
+      for (k=0; k<myndegrees; k++) {
+        to = myedegrees[k].pid;
+        if (IsHBalanceBetterFT(ncon, nparts, npwgts+from*ncon, npwgts+to*ncon, nvwgt, ubvec))
+          break;
+      }
+      if (k == myndegrees) 
+        continue;  /* break out if you did not find a candidate */
+
+      for (j=k+1; j<myndegrees; j++) {
+        to = myedegrees[j].pid;
+        if (IsHBalanceBetterTT(ncon, nparts, npwgts+myedegrees[k].pid*ncon, npwgts+to*ncon, nvwgt, ubvec)) 
+          k = j;
+      }
+
+      to = myedegrees[k].pid;
+
+      j = 0;
+      if (!AreAllHVwgtsBelow(ncon, 1.0, npwgts+from*ncon, 0.0, nvwgt, maxwgt+from*ncon))
+        j++;
+      if (myedegrees[k].ed-myrinfo->id >= 0)
+        j++;
+      if (!AreAllHVwgtsAbove(ncon, 1.0, npwgts+to*ncon, 0.0, nvwgt, minwgt+to*ncon) &&
+          AreAllHVwgtsBelow(ncon, 1.0, npwgts+to*ncon, 1.0, nvwgt, maxwgt+to*ncon))
+        j++;
+      if (j == 0)
+        continue;
+
+/* DELETE
+      if (myedegrees[k].ed-myrinfo->id < 0 && 
+          AreAllHVwgtsBelow(ncon, 1.0, npwgts+from*ncon, 0.0, nvwgt, maxwgt+from*ncon) &&
+          AreAllHVwgtsAbove(ncon, 1.0, npwgts+to*ncon, 0.0, nvwgt, minwgt+to*ncon) &&
+          AreAllHVwgtsBelow(ncon, 1.0, npwgts+to*ncon, 1.0, nvwgt, maxwgt+to*ncon))
+        continue;
+*/
+      /*=====================================================================
+      * If we got here, we can now move the vertex from 'from' to 'to' 
+      *======================================================================*/
+      graph->mincut -= myedegrees[k].ed-myrinfo->id;
+
+      IFSET(ctrl->dbglvl, DBG_MOVEINFO, printf("\t\tMoving %6d to %3d. Gain: %4d. Cut: %6d\n", i, to, myedegrees[k].ed-myrinfo->id, graph->mincut));
+
+      /* Update where, weight, and ID/ED information of the vertex you moved */
+      saxpy(ncon, 1.0, nvwgt, 1, npwgts+to*ncon, 1);
+      saxpy(ncon, -1.0, nvwgt, 1, npwgts+from*ncon, 1);
+      where[i] = to;
+      myrinfo->ed += myrinfo->id-myedegrees[k].ed;
+      SWAP(myrinfo->id, myedegrees[k].ed, j);
+      if (myedegrees[k].ed == 0) 
+        myedegrees[k] = myedegrees[--myrinfo->ndegrees];
+      else
+        myedegrees[k].pid = from;
+
+      if (myrinfo->ed == 0)
+        BNDDelete(nbnd, bndind, bndptr, i);
+
+      /* Update the degrees of adjacent vertices */
+      for (j=xadj[i]; j<xadj[i+1]; j++) {
+        ii = adjncy[j];
+        me = where[ii];
+
+        myrinfo = graph->rinfo+ii;
+        if (myrinfo->edegrees == NULL) {
+          myrinfo->edegrees = ctrl->wspace.edegrees+ctrl->wspace.cdegree;
+          ctrl->wspace.cdegree += xadj[ii+1]-xadj[ii];
+        }
+        myedegrees = myrinfo->edegrees;
+
+        ASSERT(CheckRInfo(myrinfo));
+
+        oldgain = (myrinfo->ed-myrinfo->id);
+
+        if (me == from) {
+          INC_DEC(myrinfo->ed, myrinfo->id, adjwgt[j]);
+
+          if (myrinfo->ed > 0 && bndptr[ii] == -1)
+            BNDInsert(nbnd, bndind, bndptr, ii);
+        }
+        else if (me == to) {
+          INC_DEC(myrinfo->id, myrinfo->ed, adjwgt[j]);
+
+          if (myrinfo->ed == 0 && bndptr[ii] != -1)
+            BNDDelete(nbnd, bndind, bndptr, ii);
+        }
+
+        /* Remove contribution from the .ed of 'from' */
+        if (me != from) {
+          for (k=0; k<myrinfo->ndegrees; k++) {
+            if (myedegrees[k].pid == from) {
+              if (myedegrees[k].ed == adjwgt[j])
+                myedegrees[k] = myedegrees[--myrinfo->ndegrees];
+              else
+                myedegrees[k].ed -= adjwgt[j];
+              break;
+            }
+          }
+        }
+
+        /* Add contribution to the .ed of 'to' */
+        if (me != to) {
+          for (k=0; k<myrinfo->ndegrees; k++) {
+            if (myedegrees[k].pid == to) {
+              myedegrees[k].ed += adjwgt[j];
+              break;
+            }
+          }
+          if (k == myrinfo->ndegrees) {
+            myedegrees[myrinfo->ndegrees].pid = to;
+            myedegrees[myrinfo->ndegrees++].ed = adjwgt[j];
+          }
+        }
+
+
+        /* Update the queue */
+        if (me == to || me == from) { 
+          gain = myrinfo->ed-myrinfo->id;
+          if (moved[ii] == 2) {
+            if (myrinfo->ed > 0)
+              PQueueUpdate(&queue, ii, oldgain, gain);
+            else {
+              PQueueDelete(&queue, ii, oldgain);
+              moved[ii] = -1;
+            }
+          }
+          else if (moved[ii] == -1 && myrinfo->ed > 0) {
+            PQueueInsert(&queue, ii, gain);
+            moved[ii] = 2;
+          }
+        } 
+
+        ASSERT(myrinfo->ndegrees <= xadj[ii+1]-xadj[ii]);
+        ASSERT(CheckRInfo(myrinfo));
+      }
+      nmoves++;
+    }
+
+    graph->nbnd = nbnd;
+
+    if (ctrl->dbglvl&DBG_REFINE) {
+      printf("\t [%5.4f %5.4f], Nb: %6d, Nmoves: %5d, Cut: %6d, LB: ",
+              npwgts[samin(ncon*nparts, npwgts)], npwgts[samax(ncon*nparts, npwgts)], 
+              nbnd, nmoves, graph->mincut);
+      ComputeHKWayLoadImbalance(ncon, nparts, npwgts, tvec);
+      for (i=0; i<ncon; i++)
+        printf("%.3f ", tvec[i]);
+      printf("\n");
+    }
+
+    if (nmoves == 0)
+      break;
+  }
+
+  PQueueFree(ctrl, &queue);
+
+  fwspacefree(ctrl, ncon*nparts);
+  fwspacefree(ctrl, ncon*nparts);
+  idxwspacefree(ctrl, nvtxs);
+  idxwspacefree(ctrl, nvtxs);
+
+}
+
+
+
+
+
+/*************************************************************************
+* This function checks if the vertex weights of two vertices are below 
+* a given set of values
+**************************************************************************/
+int AreAllHVwgtsBelow(int ncon, float alpha, float *vwgt1, float beta, float *vwgt2, float *limit)
+{
+  int i;
+
+  for (i=0; i<ncon; i++)
+    if (alpha*vwgt1[i] + beta*vwgt2[i] > limit[i])
+      return 0;
+
+  return 1;
+}
+
+
+
+/*************************************************************************
+* This function checks if the vertex weights of two vertices are above 
+* a given set of values
+**************************************************************************/
+int AreAllHVwgtsAbove(int ncon, float alpha, float *vwgt1, float beta, float *vwgt2, float *limit)
+{
+  int i;
+
+  for (i=0; i<ncon; i++)
+    if (alpha*vwgt1[i] + beta*vwgt2[i] < limit[i])
+      return 0;
+
+  return 1;
+}
+
+
+/*************************************************************************
+* This function computes the load imbalance over all the constrains
+* For now assume that we just want balanced partitionings
+**************************************************************************/ 
+void ComputeHKWayLoadImbalance(int ncon, int nparts, float *npwgts, float *lbvec)
+{
+  int i, j;
+  float max;
+
+  for (i=0; i<ncon; i++) {
+    max = 0.0;
+    for (j=0; j<nparts; j++) {
+      if (npwgts[j*ncon+i] > max)
+        max = npwgts[j*ncon+i];
+    }
+
+    lbvec[i] = max*nparts;
+  }
+}
+
+
+/*************************************************************************
+* This function determines if a partitioning is horizontally balanced
+**************************************************************************/
+int MocIsHBalanced(int ncon, int nparts, float *npwgts, float *ubvec)
+{
+  int i, j;
+  float max;
+
+  for (i=0; i<ncon; i++) {
+    max = 0.0;
+    for (j=0; j<nparts; j++) {
+      if (npwgts[j*ncon+i] > max)
+        max = npwgts[j*ncon+i];
+    }
+
+    if (ubvec[i] < max*nparts)
+      return 0;
+  }
+
+  return 1;
+}
+
+
+
+
+
+/*************************************************************************
+* This function checks if the pairwise balance of the between the two 
+* partitions will improve by moving the vertex v from pfrom to pto,
+* subject to the target partition weights of tfrom, and tto respectively
+**************************************************************************/
+int IsHBalanceBetterFT(int ncon, int nparts, float *pfrom, float *pto, float *vwgt, float *ubvec)
+{
+  int i, j, k;
+  float blb1=0.0, alb1=0.0, sblb=0.0, salb=0.0;
+  float blb2=0.0, alb2=0.0;
+  float temp;
+
+  for (i=0; i<ncon; i++) {
+    temp = amax(pfrom[i], pto[i])*nparts/ubvec[i];
+    if (blb1 < temp) {
+      blb2 = blb1;
+      blb1 = temp;
+    }
+    else if (blb2 < temp)
+      blb2 = temp;
+    sblb += temp;
+
+    temp = amax(pfrom[i]-vwgt[i], pto[i]+vwgt[i])*nparts/ubvec[i];
+    if (alb1 < temp) {
+      alb2 = alb1;
+      alb1 = temp;
+    }
+    else if (alb2 < temp)
+      alb2 = temp;
+    salb += temp;
+  }
+
+  if (alb1 < blb1)
+    return 1;
+  if (blb1 < alb1)
+    return 0;
+  if (alb2 < blb2)
+    return 1;
+  if (blb2 < alb2)
+    return 0;
+  
+  return salb < sblb;
+
+}
+
+
+
+
+/*************************************************************************
+* This function checks if it will be better to move a vertex to pt2 than
+* to pt1 subject to their target weights of tt1 and tt2, respectively
+* This routine takes into account the weight of the vertex in question
+**************************************************************************/
+int IsHBalanceBetterTT(int ncon, int nparts, float *pt1, float *pt2, float *vwgt, float *ubvec)
+{
+  int i;
+  float m11=0.0, m12=0.0, m21=0.0, m22=0.0, sm1=0.0, sm2=0.0, temp;
+
+  for (i=0; i<ncon; i++) {
+    temp = (pt1[i]+vwgt[i])*nparts/ubvec[i];
+    if (m11 < temp) {
+      m12 = m11;
+      m11 = temp;
+    }
+    else if (m12 < temp)
+      m12 = temp;
+    sm1 += temp;
+
+    temp = (pt2[i]+vwgt[i])*nparts/ubvec[i];
+    if (m21 < temp) {
+      m22 = m21;
+      m21 = temp;
+    }
+    else if (m22 < temp)
+      m22 = temp;
+    sm2 += temp;
+  }
+
+  if (m21 < m11)
+    return 1;
+  if (m21 > m11)
+    return 0;
+  if (m22 < m12)
+    return 1;
+  if (m22 > m12)
+    return 0;
+
+  return sm2 < sm1;  
+}
+
Index: /inundation/pymetis/metis-4.0/Lib/mkwayrefine.c
===================================================================
--- /inundation/pymetis/metis-4.0/Lib/mkwayrefine.c	(revision 2051)
+++ /inundation/pymetis/metis-4.0/Lib/mkwayrefine.c	(revision 2051)
@@ -0,0 +1,297 @@
+/*
+ * Copyright 1997, Regents of the University of Minnesota
+ *
+ * mkwayrefine.c
+ *
+ * This file contains the driving routines for multilevel k-way refinement
+ *
+ * Started 7/28/97
+ * George
+ *
+ * $Id: mkwayrefine.c,v 1.2 1998/11/27 18:16:19 karypis Exp $
+ */
+
+#include <metis.h>
+
+
+/*************************************************************************
+* This function is the entry point of refinement
+**************************************************************************/
+void MocRefineKWayHorizontal(CtrlType *ctrl, GraphType *orggraph, GraphType *graph, int nparts, 
+       float *ubvec)
+{
+
+  IFSET(ctrl->dbglvl, DBG_TIME, starttimer(ctrl->UncoarsenTmr));
+
+  /* Compute the parameters of the coarsest graph */
+  MocComputeKWayPartitionParams(ctrl, graph, nparts);
+
+  for (;;) {
+    IFSET(ctrl->dbglvl, DBG_TIME, starttimer(ctrl->RefTmr));
+
+    if (!MocIsHBalanced(graph->ncon, nparts, graph->npwgts, ubvec)) {
+      MocComputeKWayBalanceBoundary(ctrl, graph, nparts);
+      MCGreedy_KWayEdgeBalanceHorizontal(ctrl, graph, nparts, ubvec, 4); 
+      ComputeKWayBoundary(ctrl, graph, nparts);
+    }
+
+    MCRandom_KWayEdgeRefineHorizontal(ctrl, graph, nparts, ubvec, 10); 
+
+    IFSET(ctrl->dbglvl, DBG_TIME, stoptimer(ctrl->RefTmr));
+
+    if (graph == orggraph)
+      break;
+
+    graph = graph->finer;
+    IFSET(ctrl->dbglvl, DBG_TIME, starttimer(ctrl->ProjectTmr));
+    MocProjectKWayPartition(ctrl, graph, nparts);
+    IFSET(ctrl->dbglvl, DBG_TIME, stoptimer(ctrl->ProjectTmr));
+  }
+
+  if (!MocIsHBalanced(graph->ncon, nparts, graph->npwgts, ubvec)) {
+    MocComputeKWayBalanceBoundary(ctrl, graph, nparts);
+    MCGreedy_KWayEdgeBalanceHorizontal(ctrl, graph, nparts, ubvec, 4); 
+    ComputeKWayBoundary(ctrl, graph, nparts);
+    MCRandom_KWayEdgeRefineHorizontal(ctrl, graph, nparts, ubvec, 10); 
+  }
+
+  IFSET(ctrl->dbglvl, DBG_TIME, stoptimer(ctrl->UncoarsenTmr));
+}
+
+
+
+
+/*************************************************************************
+* This function allocates memory for k-way edge refinement
+**************************************************************************/
+void MocAllocateKWayPartitionMemory(CtrlType *ctrl, GraphType *graph, int nparts)
+{
+  int nvtxs, ncon, pad64;
+
+  nvtxs = graph->nvtxs;
+  ncon = graph->ncon;
+
+  pad64 = (3*nvtxs)%2;
+
+  graph->rdata = idxmalloc(3*nvtxs+(sizeof(RInfoType)/sizeof(idxtype))*nvtxs+pad64, "AllocateKWayPartitionMemory: rdata");
+  graph->where          = graph->rdata;
+  graph->bndptr         = graph->rdata + nvtxs;
+  graph->bndind         = graph->rdata + 2*nvtxs;
+  graph->rinfo          = (RInfoType *)(graph->rdata + 3*nvtxs + pad64);
+
+  graph->npwgts         = fmalloc(ncon*nparts, "MocAllocateKWayPartitionMemory: npwgts");
+}
+
+
+/*************************************************************************
+* This function computes the initial id/ed 
+**************************************************************************/
+void MocComputeKWayPartitionParams(CtrlType *ctrl, GraphType *graph, int nparts)
+{
+  int i, j, k, l, nvtxs, ncon, nbnd, mincut, me, other;
+  idxtype *xadj, *adjncy, *adjwgt, *where, *bndind, *bndptr;
+  RInfoType *rinfo, *myrinfo;
+  EDegreeType *myedegrees;
+  float *nvwgt, *npwgts;
+
+  nvtxs = graph->nvtxs;
+  ncon = graph->ncon;
+  xadj = graph->xadj;
+  nvwgt = graph->nvwgt;
+  adjncy = graph->adjncy;
+  adjwgt = graph->adjwgt;
+
+  where = graph->where;
+  npwgts = sset(ncon*nparts, 0.0, graph->npwgts);
+  bndind = graph->bndind;
+  bndptr = idxset(nvtxs, -1, graph->bndptr);
+  rinfo = graph->rinfo;
+
+
+  /*------------------------------------------------------------
+  / Compute now the id/ed degrees
+  /------------------------------------------------------------*/
+  ctrl->wspace.cdegree = 0;
+  nbnd = mincut = 0;
+  for (i=0; i<nvtxs; i++) {
+    me = where[i];
+    saxpy(ncon, 1.0, nvwgt+i*ncon, 1, npwgts+me*ncon, 1);
+
+    myrinfo = rinfo+i;
+    myrinfo->id = myrinfo->ed = myrinfo->ndegrees = 0;
+    myrinfo->edegrees = NULL;
+
+    for (j=xadj[i]; j<xadj[i+1]; j++) {
+      if (me != where[adjncy[j]])
+        myrinfo->ed += adjwgt[j];
+    }
+    myrinfo->id = graph->adjwgtsum[i] - myrinfo->ed;
+
+    if (myrinfo->ed > 0) 
+      mincut += myrinfo->ed;
+
+    if (myrinfo->ed-myrinfo->id >= 0)
+      BNDInsert(nbnd, bndind, bndptr, i);
+
+    /* Time to compute the particular external degrees */
+    if (myrinfo->ed > 0) { 
+      myedegrees = myrinfo->edegrees = ctrl->wspace.edegrees+ctrl->wspace.cdegree;
+      ctrl->wspace.cdegree += xadj[i+1]-xadj[i];
+
+      for (j=xadj[i]; j<xadj[i+1]; j++) {
+        other = where[adjncy[j]];
+        if (me != other) {
+          for (k=0; k<myrinfo->ndegrees; k++) {
+            if (myedegrees[k].pid == other) {
+              myedegrees[k].ed += adjwgt[j];
+              break;
+            }
+          }
+          if (k == myrinfo->ndegrees) {
+            myedegrees[myrinfo->ndegrees].pid = other;
+            myedegrees[myrinfo->ndegrees++].ed = adjwgt[j];
+          }
+        }
+      }
+
+      ASSERT(myrinfo->ndegrees <= xadj[i+1]-xadj[i]);
+    }
+  }
+
+  graph->mincut = mincut/2;
+  graph->nbnd = nbnd;
+
+}
+
+
+
+/*************************************************************************
+* This function projects a partition, and at the same time computes the
+* parameters for refinement.
+**************************************************************************/
+void MocProjectKWayPartition(CtrlType *ctrl, GraphType *graph, int nparts)
+{
+  int i, j, k, nvtxs, nbnd, me, other, istart, iend, ndegrees;
+  idxtype *xadj, *adjncy, *adjwgt, *adjwgtsum;
+  idxtype *cmap, *where, *bndptr, *bndind;
+  idxtype *cwhere;
+  GraphType *cgraph;
+  RInfoType *crinfo, *rinfo, *myrinfo;
+  EDegreeType *myedegrees;
+  idxtype *htable;
+
+  cgraph = graph->coarser;
+  cwhere = cgraph->where;
+  crinfo = cgraph->rinfo;
+
+  nvtxs = graph->nvtxs;
+  cmap = graph->cmap;
+  xadj = graph->xadj;
+  adjncy = graph->adjncy;
+  adjwgt = graph->adjwgt;
+  adjwgtsum = graph->adjwgtsum;
+
+  MocAllocateKWayPartitionMemory(ctrl, graph, nparts);
+  where = graph->where;
+  rinfo = graph->rinfo;
+  bndind = graph->bndind;
+  bndptr = idxset(nvtxs, -1, graph->bndptr);
+
+  /* Go through and project partition and compute id/ed for the nodes */
+  for (i=0; i<nvtxs; i++) {
+    k = cmap[i];
+    where[i] = cwhere[k];
+    cmap[i] = crinfo[k].ed;  /* For optimization */
+  }
+
+  htable = idxset(nparts, -1, idxwspacemalloc(ctrl, nparts));
+
+  ctrl->wspace.cdegree = 0;
+  for (nbnd=0, i=0; i<nvtxs; i++) {
+    me = where[i];
+
+    myrinfo = rinfo+i;
+    myrinfo->id = myrinfo->ed = myrinfo->ndegrees = 0;
+    myrinfo->edegrees = NULL;
+
+    myrinfo->id = adjwgtsum[i];
+
+    if (cmap[i] > 0) { /* If it is an interface node. Note cmap[i] = crinfo[cmap[i]].ed */
+      istart = xadj[i];
+      iend = xadj[i+1];
+
+      myedegrees = myrinfo->edegrees = ctrl->wspace.edegrees+ctrl->wspace.cdegree;
+      ctrl->wspace.cdegree += iend-istart;
+
+      ndegrees = 0;
+      for (j=istart; j<iend; j++) {
+        other = where[adjncy[j]];
+        if (me != other) {
+          myrinfo->ed += adjwgt[j];
+          if ((k = htable[other]) == -1) {
+            htable[other] = ndegrees;
+            myedegrees[ndegrees].pid = other;
+            myedegrees[ndegrees++].ed = adjwgt[j];
+          }
+          else {
+            myedegrees[k].ed += adjwgt[j];
+          }
+        }
+      }
+      myrinfo->id -= myrinfo->ed;
+
+      /* Remove space for edegrees if it was interior */
+      if (myrinfo->ed == 0) { 
+        myrinfo->edegrees = NULL;
+        ctrl->wspace.cdegree -= iend-istart;
+      }
+      else {
+        if (myrinfo->ed-myrinfo->id >= 0) 
+          BNDInsert(nbnd, bndind, bndptr, i); 
+
+        myrinfo->ndegrees = ndegrees;
+
+        for (j=0; j<ndegrees; j++)
+          htable[myedegrees[j].pid] = -1;
+      }
+    }
+  }
+
+  scopy(graph->ncon*nparts, cgraph->npwgts, graph->npwgts);
+  graph->mincut = cgraph->mincut;
+  graph->nbnd = nbnd;
+
+  FreeGraph(graph->coarser);
+  graph->coarser = NULL;
+
+  idxwspacefree(ctrl, nparts);
+
+  ASSERT(CheckBnd2(graph));
+
+}
+
+
+
+/*************************************************************************
+* This function computes the boundary definition for balancing
+**************************************************************************/
+void MocComputeKWayBalanceBoundary(CtrlType *ctrl, GraphType *graph, int nparts)
+{
+  int i, nvtxs, nbnd;
+  idxtype *bndind, *bndptr;
+
+  nvtxs = graph->nvtxs;
+  bndind = graph->bndind;
+  bndptr = idxset(nvtxs, -1, graph->bndptr);
+
+
+  /* Compute the new boundary */
+  nbnd = 0;
+  for (i=0; i<nvtxs; i++) {
+    if (graph->rinfo[i].ed > 0) 
+      BNDInsert(nbnd, bndind, bndptr, i);
+  }
+
+  graph->nbnd = nbnd;
+}
+
Index: /inundation/pymetis/metis-4.0/Lib/mmatch.c
===================================================================
--- /inundation/pymetis/metis-4.0/Lib/mmatch.c	(revision 2051)
+++ /inundation/pymetis/metis-4.0/Lib/mmatch.c	(revision 2051)
@@ -0,0 +1,506 @@
+/*
+ * Copyright 1997, Regents of the University of Minnesota
+ *
+ * mmatch.c
+ *
+ * This file contains the code that computes matchings and creates the next
+ * level coarse graph.
+ *
+ * Started 7/23/97
+ * George
+ *
+ * $Id: mmatch.c,v 1.3 1998/11/30 14:50:44 karypis Exp $
+ *
+ */
+
+#include <metis.h>
+
+
+/*************************************************************************
+* This function finds a matching using the HEM heuristic
+**************************************************************************/
+void MCMatch_RM(CtrlType *ctrl, GraphType *graph)
+{
+  int i, ii, j, k, nvtxs, ncon, cnvtxs, maxidx;
+  idxtype *xadj, *adjncy, *adjwgt;
+  idxtype *match, *cmap, *perm;
+  float *nvwgt;
+
+  IFSET(ctrl->dbglvl, DBG_TIME, starttimer(ctrl->MatchTmr));
+
+  nvtxs = graph->nvtxs;
+  ncon = graph->ncon;
+  xadj = graph->xadj;
+  nvwgt = graph->nvwgt;
+  adjncy = graph->adjncy;
+  adjwgt = graph->adjwgt;
+
+  cmap = graph->cmap;
+  match = idxset(nvtxs, UNMATCHED, idxwspacemalloc(ctrl, nvtxs));
+
+  perm = idxwspacemalloc(ctrl, nvtxs);
+  RandomPermute(nvtxs, perm, 1);
+
+  cnvtxs = 0;
+  for (ii=0; ii<nvtxs; ii++) {
+    i = perm[ii];
+
+    if (match[i] == UNMATCHED) {  /* Unmatched */
+      maxidx = i;
+
+      /* Find a random matching, subject to maxvwgt constraints */
+      for (j=xadj[i]; j<xadj[i+1]; j++) {
+        k = adjncy[j];
+        if (match[k] == UNMATCHED && AreAllVwgtsBelowFast(ncon, nvwgt+i*ncon, nvwgt+k*ncon, ctrl->nmaxvwgt)) {
+          maxidx = k;
+          break;
+        }
+      }
+
+      cmap[i] = cmap[maxidx] = cnvtxs++;
+      match[i] = maxidx;
+      match[maxidx] = i;
+    }
+  }
+
+  IFSET(ctrl->dbglvl, DBG_TIME, stoptimer(ctrl->MatchTmr));
+
+  CreateCoarseGraph(ctrl, graph, cnvtxs, match, perm);
+
+  idxwspacefree(ctrl, nvtxs);
+  idxwspacefree(ctrl, nvtxs);
+}
+
+
+
+/*************************************************************************
+* This function finds a matching using the HEM heuristic
+**************************************************************************/
+void MCMatch_HEM(CtrlType *ctrl, GraphType *graph)
+{
+  int i, ii, j, k, l, nvtxs, cnvtxs, ncon, maxidx, maxwgt;
+  idxtype *xadj, *adjncy, *adjwgt;
+  idxtype *match, *cmap, *perm;
+  float *nvwgt;
+
+  IFSET(ctrl->dbglvl, DBG_TIME, starttimer(ctrl->MatchTmr));
+
+  nvtxs = graph->nvtxs;
+  ncon = graph->ncon;
+  xadj = graph->xadj;
+  nvwgt = graph->nvwgt;
+  adjncy = graph->adjncy;
+  adjwgt = graph->adjwgt;
+
+  cmap = graph->cmap;
+  match = idxset(nvtxs, UNMATCHED, idxwspacemalloc(ctrl, nvtxs));
+
+  perm = idxwspacemalloc(ctrl, nvtxs);
+  RandomPermute(nvtxs, perm, 1);
+
+  cnvtxs = 0;
+  for (ii=0; ii<nvtxs; ii++) {
+    i = perm[ii];
+
+    if (match[i] == UNMATCHED) {  /* Unmatched */
+      maxidx = i;
+      maxwgt = 0;
+
+      /* Find a heavy-edge matching, subject to maxvwgt constraints */
+      for (j=xadj[i]; j<xadj[i+1]; j++) {
+        k = adjncy[j];
+        if (match[k] == UNMATCHED && maxwgt <= adjwgt[j] &&
+               AreAllVwgtsBelowFast(ncon, nvwgt+i*ncon, nvwgt+k*ncon, ctrl->nmaxvwgt)) {
+          maxwgt = adjwgt[j];
+          maxidx = adjncy[j];
+        }
+      }
+
+      cmap[i] = cmap[maxidx] = cnvtxs++;
+      match[i] = maxidx;
+      match[maxidx] = i;
+    }
+  }
+
+  IFSET(ctrl->dbglvl, DBG_TIME, stoptimer(ctrl->MatchTmr));
+
+  CreateCoarseGraph(ctrl, graph, cnvtxs, match, perm);
+
+  idxwspacefree(ctrl, nvtxs);
+  idxwspacefree(ctrl, nvtxs);
+}
+
+
+
+/*************************************************************************
+* This function finds a matching using the HEM heuristic
+**************************************************************************/
+void MCMatch_SHEM(CtrlType *ctrl, GraphType *graph)
+{
+  int i, ii, j, k, nvtxs, cnvtxs, ncon, maxidx, maxwgt, avgdegree;
+  idxtype *xadj, *adjncy, *adjwgt;
+  idxtype *match, *cmap, *degrees, *perm, *tperm;
+  float *nvwgt;
+
+  IFSET(ctrl->dbglvl, DBG_TIME, starttimer(ctrl->MatchTmr));
+
+  nvtxs = graph->nvtxs;
+  ncon = graph->ncon;
+  xadj = graph->xadj;
+  nvwgt = graph->nvwgt;
+  adjncy = graph->adjncy;
+  adjwgt = graph->adjwgt;
+
+  cmap = graph->cmap;
+  match = idxset(nvtxs, UNMATCHED, idxwspacemalloc(ctrl, nvtxs));
+
+  perm = idxwspacemalloc(ctrl, nvtxs);
+  tperm = idxwspacemalloc(ctrl, nvtxs);
+  degrees = idxwspacemalloc(ctrl, nvtxs);
+
+  RandomPermute(nvtxs, tperm, 1);
+  avgdegree = 0.7*(xadj[nvtxs]/nvtxs);
+  for (i=0; i<nvtxs; i++) 
+    degrees[i] = (xadj[i+1]-xadj[i] > avgdegree ? avgdegree : xadj[i+1]-xadj[i]);
+  BucketSortKeysInc(nvtxs, avgdegree, degrees, tperm, perm);
+
+  cnvtxs = 0;
+
+  /* Take care any islands. Islands are matched with non-islands due to coarsening */
+  for (ii=0; ii<nvtxs; ii++) {
+    i = perm[ii];
+
+    if (match[i] == UNMATCHED) {  /* Unmatched */
+      if (xadj[i] < xadj[i+1])
+        break;
+
+      maxidx = i;
+      for (j=nvtxs-1; j>ii; j--) {
+        k = perm[j];
+        if (match[k] == UNMATCHED && xadj[k] < xadj[k+1]) {
+          maxidx = k;
+          break;
+        }
+      }
+
+      cmap[i] = cmap[maxidx] = cnvtxs++;
+      match[i] = maxidx;
+      match[maxidx] = i;
+    }
+  }
+
+  /* Continue with normal matching */
+  for (; ii<nvtxs; ii++) {
+    i = perm[ii];
+
+    if (match[i] == UNMATCHED) {  /* Unmatched */
+      maxidx = i;
+      maxwgt = 0;
+
+      /* Find a heavy-edge matching, subject to maxvwgt constraints */
+      for (j=xadj[i]; j<xadj[i+1]; j++) {
+        k = adjncy[j];
+        if (match[k] == UNMATCHED && maxwgt <= adjwgt[j] &&
+               AreAllVwgtsBelowFast(ncon, nvwgt+i*ncon, nvwgt+k*ncon, ctrl->nmaxvwgt)) {
+          maxwgt = adjwgt[j];
+          maxidx = adjncy[j];
+        }
+      }
+
+      cmap[i] = cmap[maxidx] = cnvtxs++;
+      match[i] = maxidx;
+      match[maxidx] = i;
+    }
+  }
+
+  IFSET(ctrl->dbglvl, DBG_TIME, stoptimer(ctrl->MatchTmr));
+
+  idxwspacefree(ctrl, nvtxs);  /* degrees */
+  idxwspacefree(ctrl, nvtxs);  /* tperm */
+
+  CreateCoarseGraph(ctrl, graph, cnvtxs, match, perm);
+
+  idxwspacefree(ctrl, nvtxs);
+  idxwspacefree(ctrl, nvtxs);
+}
+
+
+
+/*************************************************************************
+* This function finds a matching using the HEM heuristic
+**************************************************************************/
+void MCMatch_SHEBM(CtrlType *ctrl, GraphType *graph, int norm)
+{
+  int i, ii, j, k, nvtxs, cnvtxs, ncon, maxidx, maxwgt, avgdegree;
+  idxtype *xadj, *adjncy, *adjwgt;
+  idxtype *match, *cmap, *degrees, *perm, *tperm;
+  float *nvwgt;
+
+  IFSET(ctrl->dbglvl, DBG_TIME, starttimer(ctrl->MatchTmr));
+
+  nvtxs = graph->nvtxs;
+  ncon = graph->ncon;
+  xadj = graph->xadj;
+  nvwgt = graph->nvwgt;
+  adjncy = graph->adjncy;
+  adjwgt = graph->adjwgt;
+
+  cmap = graph->cmap;
+  match = idxset(nvtxs, UNMATCHED, idxwspacemalloc(ctrl, nvtxs));
+
+  perm = idxwspacemalloc(ctrl, nvtxs);
+  tperm = idxwspacemalloc(ctrl, nvtxs);
+  degrees = idxwspacemalloc(ctrl, nvtxs);
+
+  RandomPermute(nvtxs, tperm, 1);
+  avgdegree = 0.7*(xadj[nvtxs]/nvtxs);
+  for (i=0; i<nvtxs; i++) 
+    degrees[i] = (xadj[i+1]-xadj[i] > avgdegree ? avgdegree : xadj[i+1]-xadj[i]);
+  BucketSortKeysInc(nvtxs, avgdegree, degrees, tperm, perm);
+
+  cnvtxs = 0;
+
+  /* Take care any islands. Islands are matched with non-islands due to coarsening */
+  for (ii=0; ii<nvtxs; ii++) {
+    i = perm[ii];
+
+    if (match[i] == UNMATCHED) {  /* Unmatched */
+      if (xadj[i] < xadj[i+1])
+        break;
+
+      maxidx = i;
+      for (j=nvtxs-1; j>ii; j--) {
+        k = perm[j];
+        if (match[k] == UNMATCHED && xadj[k] < xadj[k+1]) {
+          maxidx = k;
+          break;
+        }
+      }
+
+      cmap[i] = cmap[maxidx] = cnvtxs++;
+      match[i] = maxidx;
+      match[maxidx] = i;
+    }
+  }
+
+  /* Continue with normal matching */
+  for (; ii<nvtxs; ii++) {
+    i = perm[ii];
+
+    if (match[i] == UNMATCHED) {  /* Unmatched */
+      maxidx = i;
+      maxwgt = -1;
+
+      /* Find a heavy-edge matching, subject to maxvwgt constraints */
+      for (j=xadj[i]; j<xadj[i+1]; j++) {
+        k = adjncy[j];
+
+        if (match[k] == UNMATCHED && 
+            AreAllVwgtsBelowFast(ncon, nvwgt+i*ncon, nvwgt+k*ncon, ctrl->nmaxvwgt) &&
+            (maxwgt < adjwgt[j] || 
+              (maxwgt == adjwgt[j] && 
+               BetterVBalance(ncon, norm, nvwgt+i*ncon, nvwgt+maxidx*ncon, nvwgt+k*ncon) >= 0
+              )
+            )
+           ) {
+          maxwgt = adjwgt[j];
+          maxidx = k;
+        }
+      }
+
+      cmap[i] = cmap[maxidx] = cnvtxs++;
+      match[i] = maxidx;
+      match[maxidx] = i;
+    }
+  }
+
+  IFSET(ctrl->dbglvl, DBG_TIME, stoptimer(ctrl->MatchTmr));
+
+  idxwspacefree(ctrl, nvtxs);  /* degrees */
+  idxwspacefree(ctrl, nvtxs);  /* tperm */
+
+  CreateCoarseGraph(ctrl, graph, cnvtxs, match, perm);
+
+  idxwspacefree(ctrl, nvtxs);
+  idxwspacefree(ctrl, nvtxs);
+}
+
+
+
+/*************************************************************************
+* This function finds a matching using the HEM heuristic
+**************************************************************************/
+void MCMatch_SBHEM(CtrlType *ctrl, GraphType *graph, int norm)
+{
+  int i, ii, j, k, nvtxs, cnvtxs, ncon, maxidx, maxwgt, avgdegree;
+  idxtype *xadj, *adjncy, *adjwgt;
+  idxtype *match, *cmap, *degrees, *perm, *tperm;
+  float *nvwgt, vbal;
+
+  IFSET(ctrl->dbglvl, DBG_TIME, starttimer(ctrl->MatchTmr));
+
+  nvtxs = graph->nvtxs;
+  ncon = graph->ncon;
+  xadj = graph->xadj;
+  nvwgt = graph->nvwgt;
+  adjncy = graph->adjncy;
+  adjwgt = graph->adjwgt;
+
+  cmap = graph->cmap;
+  match = idxset(nvtxs, UNMATCHED, idxwspacemalloc(ctrl, nvtxs));
+
+  perm = idxwspacemalloc(ctrl, nvtxs);
+  tperm = idxwspacemalloc(ctrl, nvtxs);
+  degrees = idxwspacemalloc(ctrl, nvtxs);
+
+  RandomPermute(nvtxs, tperm, 1);
+  avgdegree = 0.7*(xadj[nvtxs]/nvtxs);
+  for (i=0; i<nvtxs; i++) 
+    degrees[i] = (xadj[i+1]-xadj[i] > avgdegree ? avgdegree : xadj[i+1]-xadj[i]);
+  BucketSortKeysInc(nvtxs, avgdegree, degrees, tperm, perm);
+
+  cnvtxs = 0;
+
+  /* Take care any islands. Islands are matched with non-islands due to coarsening */
+  for (ii=0; ii<nvtxs; ii++) {
+    i = perm[ii];
+
+    if (match[i] == UNMATCHED) {  /* Unmatched */
+      if (xadj[i] < xadj[i+1])
+        break;
+
+      maxidx = i;
+      for (j=nvtxs-1; j>ii; j--) {
+        k = perm[j];
+        if (match[k] == UNMATCHED && xadj[k] < xadj[k+1]) {
+          maxidx = k;
+          break;
+        }
+      }
+
+      cmap[i] = cmap[maxidx] = cnvtxs++;
+      match[i] = maxidx;
+      match[maxidx] = i;
+    }
+  }
+
+  /* Continue with normal matching */
+  for (; ii<nvtxs; ii++) {
+    i = perm[ii];
+
+    if (match[i] == UNMATCHED) {  /* Unmatched */
+      maxidx = i;
+      maxwgt = -1;
+      vbal = 0.0;
+
+      /* Find a heavy-edge matching, subject to maxvwgt constraints */
+      for (j=xadj[i]; j<xadj[i+1]; j++) {
+        k = adjncy[j];
+        if (match[k] == UNMATCHED && AreAllVwgtsBelowFast(ncon, nvwgt+i*ncon, nvwgt+k*ncon, ctrl->nmaxvwgt)) {
+          if (maxidx != i)
+            vbal = BetterVBalance(ncon, norm, nvwgt+i*ncon, nvwgt+maxidx*ncon, nvwgt+k*ncon);
+
+          if (vbal > 0 || (vbal > -.01 && maxwgt < adjwgt[j])) {
+            maxwgt = adjwgt[j];
+            maxidx = k;
+          }
+        }
+      }
+
+      cmap[i] = cmap[maxidx] = cnvtxs++;
+      match[i] = maxidx;
+      match[maxidx] = i;
+    }
+  }
+
+  IFSET(ctrl->dbglvl, DBG_TIME, stoptimer(ctrl->MatchTmr));
+
+  idxwspacefree(ctrl, nvtxs);  /* degrees */
+  idxwspacefree(ctrl, nvtxs);  /* tperm */
+
+  CreateCoarseGraph(ctrl, graph, cnvtxs, match, perm);
+
+  idxwspacefree(ctrl, nvtxs);
+  idxwspacefree(ctrl, nvtxs);
+}
+
+
+
+
+
+/*************************************************************************
+* This function checks if v+u2 provides a better balance in the weight 
+* vector that v+u1
+**************************************************************************/
+float BetterVBalance(int ncon, int norm, float *vwgt, float *u1wgt, float *u2wgt)
+{
+  int i;
+  float sum1, sum2, max1, max2, min1, min2, diff1, diff2;
+
+  if (norm == -1) {
+    max1 = min1 = vwgt[0]+u1wgt[0];
+    max2 = min2 = vwgt[0]+u2wgt[0];
+    sum1 = vwgt[0]+u1wgt[0];
+    sum2 = vwgt[0]+u2wgt[0];
+
+    for (i=1; i<ncon; i++) {
+      if (max1 < vwgt[i]+u1wgt[i])
+        max1 = vwgt[i]+u1wgt[i];
+      if (min1 > vwgt[i]+u1wgt[i])
+        min1 = vwgt[i]+u1wgt[i];
+
+      if (max2 < vwgt[i]+u2wgt[i])
+        max2 = vwgt[i]+u2wgt[i];
+      if (min2 > vwgt[i]+u2wgt[i])
+        min2 = vwgt[i]+u2wgt[i];
+
+      sum1 += vwgt[i]+u1wgt[i];
+      sum2 += vwgt[i]+u2wgt[i];
+    }
+
+    if (sum1 == 0.0)
+      return 1;
+    else if (sum2 == 0.0)
+      return -1;
+    else
+      return ((max1-min1)/sum1) - ((max2-min2)/sum2);
+  }
+  else if (norm == 1) {
+    sum1 = sum2 = 0.0;
+    for (i=0; i<ncon; i++) {
+      sum1 += vwgt[i]+u1wgt[i];
+      sum2 += vwgt[i]+u2wgt[i];
+    }
+    sum1 = sum1/(1.0*ncon);
+    sum2 = sum2/(1.0*ncon);
+
+    diff1 = diff2 = 0.0;
+    for (i=0; i<ncon; i++) {
+      diff1 += fabs(sum1 - (vwgt[i]+u1wgt[i]));
+      diff2 += fabs(sum2 - (vwgt[i]+u2wgt[i]));
+    }
+
+    return diff1 - diff2;
+  }
+  else {
+    errexit("Unknown norm: %d\n", norm);
+  }
+  return 0.0;
+}
+
+
+/*************************************************************************
+* This function checks if the vertex weights of two vertices are below 
+* a given set of values
+**************************************************************************/
+int AreAllVwgtsBelowFast(int ncon, float *vwgt1, float *vwgt2, float limit)
+{
+  int i;
+
+  for (i=0; i<ncon; i++)
+    if (vwgt1[i] + vwgt2[i] > limit)
+      return 0;
+
+  return 1;
+}
+
Index: /inundation/pymetis/metis-4.0/Lib/mmd.c
===================================================================
--- /inundation/pymetis/metis-4.0/Lib/mmd.c	(revision 2051)
+++ /inundation/pymetis/metis-4.0/Lib/mmd.c	(revision 2051)
@@ -0,0 +1,593 @@
+/*
+ * mmd.c
+ *
+ * **************************************************************
+ * The following C function was developed from a FORTRAN subroutine
+ * in SPARSPAK written by Eleanor Chu, Alan George, Joseph Liu
+ * and Esmond Ng.
+ * 
+ * The FORTRAN-to-C transformation and modifications such as dynamic
+ * memory allocation and deallocation were performed by Chunguang
+ * Sun.
+ * ************************************************************** 
+ *
+ * Taken from SMMS, George 12/13/94
+ *
+ * The meaning of invperm, and perm vectors is different from that
+ * in genqmd_ of SparsPak
+ *
+ * $Id: mmd.c,v 1.1 1998/11/27 17:59:25 karypis Exp $
+ */
+
+#include <metis.h>
+
+
+/*************************************************************************
+*  genmmd  -- multiple minimum external degree
+*  purpose -- this routine implements the minimum degree
+*     algorithm. it makes use of the implicit representation
+*     of elimination graphs by quotient graphs, and the notion
+*     of indistinguishable nodes. It also implements the modifications
+*     by multiple elimination and minimum external degree.
+*     Caution -- the adjacency vector adjncy will be destroyed.
+*  Input parameters --
+*     neqns -- number of equations.
+*     (xadj, adjncy) -- the adjacency structure.
+*     delta  -- tolerance value for multiple elimination.
+*     maxint -- maximum machine representable (short) integer
+*               (any smaller estimate will do) for marking nodes.
+*  Output parameters --
+*     perm -- the minimum degree ordering.
+*     invp -- the inverse of perm.
+*     *ncsub -- an upper bound on the number of nonzero subscripts
+*               for the compressed storage scheme.
+*  Working parameters --
+*     head -- vector for head of degree lists.
+*     invp  -- used temporarily for degree forward link.
+*     perm  -- used temporarily for degree backward link.
+*     qsize -- vector for size of supernodes.
+*     list -- vector for temporary linked lists.
+*     marker -- a temporary marker vector.
+*  Subroutines used -- mmdelm, mmdint, mmdnum, mmdupd.
+**************************************************************************/
+void genmmd(int neqns, idxtype *xadj, idxtype *adjncy, idxtype *invp, idxtype *perm,
+     int delta, idxtype *head, idxtype *qsize, idxtype *list, idxtype *marker,
+     int maxint, int *ncsub)
+{
+    int  ehead, i, mdeg, mdlmt, mdeg_node, nextmd, num, tag;
+
+    if (neqns <= 0)  
+      return;
+
+    /* Adjust from C to Fortran */
+    xadj--; adjncy--; invp--; perm--; head--; qsize--; list--; marker--;
+
+    /* initialization for the minimum degree algorithm. */
+    *ncsub = 0;
+    mmdint(neqns, xadj, adjncy, head, invp, perm, qsize, list, marker);
+
+    /*  'num' counts the number of ordered nodes plus 1. */
+    num = 1;
+
+    /* eliminate all isolated nodes. */
+    nextmd = head[1];
+    while (nextmd > 0) {
+      mdeg_node = nextmd;
+      nextmd = invp[mdeg_node];
+      marker[mdeg_node] = maxint;
+      invp[mdeg_node] = -num;
+      num = num + 1;
+    }
+
+    /* search for node of the minimum degree. 'mdeg' is the current */
+    /* minimum degree; 'tag' is used to facilitate marking nodes.   */
+    if (num > neqns) 
+      goto n1000;
+    tag = 1;
+    head[1] = 0;
+    mdeg = 2;
+
+    /* infinite loop here ! */
+    while (1) {
+      while (head[mdeg] <= 0) 
+        mdeg++;
+
+      /* use value of 'delta' to set up 'mdlmt', which governs */
+      /* when a degree update is to be performed.              */
+      mdlmt = mdeg + delta;
+      ehead = 0;
+
+n500:
+      mdeg_node = head[mdeg];
+      while (mdeg_node <= 0) {
+        mdeg++;
+
+        if (mdeg > mdlmt) 
+          goto n900;
+        mdeg_node = head[mdeg];
+      };
+
+      /*  remove 'mdeg_node' from the degree structure. */
+      nextmd = invp[mdeg_node];
+      head[mdeg] = nextmd;
+      if (nextmd > 0)  
+        perm[nextmd] = -mdeg;
+      invp[mdeg_node] = -num;
+      *ncsub += mdeg + qsize[mdeg_node] - 2;
+      if ((num+qsize[mdeg_node]) > neqns)  
+        goto n1000;
+
+      /*  eliminate 'mdeg_node' and perform quotient graph */
+      /*  transformation. reset 'tag' value if necessary.    */
+      tag++;
+      if (tag >= maxint) {
+        tag = 1;
+        for (i = 1; i <= neqns; i++)
+          if (marker[i] < maxint)  
+            marker[i] = 0;
+      };
+
+      mmdelm(mdeg_node, xadj, adjncy, head, invp, perm, qsize, list, marker, maxint, tag);
+
+      num += qsize[mdeg_node];
+      list[mdeg_node] = ehead;
+      ehead = mdeg_node;
+      if (delta >= 0) 
+        goto n500;
+
+ n900:
+      /* update degrees of the nodes involved in the  */
+      /* minimum degree nodes elimination.            */
+      if (num > neqns)  
+        goto n1000;
+      mmdupd( ehead, neqns, xadj, adjncy, delta, &mdeg, head, invp, perm, qsize, list, marker, maxint, &tag);
+    }; /* end of -- while ( 1 ) -- */
+
+n1000:
+    mmdnum( neqns, perm, invp, qsize );
+
+    /* Adjust from Fortran back to C*/
+    xadj++; adjncy++; invp++; perm++; head++; qsize++; list++; marker++;
+}
+
+
+/**************************************************************************
+*           mmdelm ...... multiple minimum degree elimination
+* Purpose -- This routine eliminates the node mdeg_node of minimum degree
+*     from the adjacency structure, which is stored in the quotient
+*     graph format. It also transforms the quotient graph representation
+*     of the elimination graph.
+* Input parameters --
+*     mdeg_node -- node of minimum degree.
+*     maxint -- estimate of maximum representable (short) integer.
+*     tag    -- tag value.
+* Updated parameters --
+*     (xadj, adjncy) -- updated adjacency structure.
+*     (head, forward, backward) -- degree doubly linked structure.
+*     qsize -- size of supernode.
+*     marker -- marker vector.
+*     list -- temporary linked list of eliminated nabors.
+***************************************************************************/
+void mmdelm(int mdeg_node, idxtype *xadj, idxtype *adjncy, idxtype *head, idxtype *forward,
+     idxtype *backward, idxtype *qsize, idxtype *list, idxtype *marker, int maxint,int tag)
+{
+    int   element, i,   istop, istart, j,
+          jstop, jstart, link,
+          nabor, node, npv, nqnbrs, nxnode,
+          pvnode, rlmt, rloc, rnode, xqnbr;
+
+    /* find the reachable set of 'mdeg_node' and */
+    /* place it in the data structure.           */
+    marker[mdeg_node] = tag;
+    istart = xadj[mdeg_node];
+    istop = xadj[mdeg_node+1] - 1;
+
+    /* 'element' points to the beginning of the list of  */
+    /* eliminated nabors of 'mdeg_node', and 'rloc' gives the */
+    /* storage location for the next reachable node.   */
+    element = 0;
+    rloc = istart;
+    rlmt = istop;
+    for ( i = istart; i <= istop; i++ ) {
+        nabor = adjncy[i];
+        if ( nabor == 0 ) break;
+        if ( marker[nabor] < tag ) {
+           marker[nabor] = tag;
+           if ( forward[nabor] < 0 )  {
+              list[nabor] = element;
+              element = nabor;
+           } else {
+              adjncy[rloc] = nabor;
+              rloc++;
+           };
+        }; /* end of -- if -- */
+    }; /* end of -- for -- */
+
+  /* merge with reachable nodes from generalized elements. */
+  while ( element > 0 ) {
+      adjncy[rlmt] = -element;
+      link = element;
+
+n400:
+      jstart = xadj[link];
+      jstop = xadj[link+1] - 1;
+      for ( j = jstart; j <= jstop; j++ ) {
+          node = adjncy[j];
+          link = -node;
+          if ( node < 0 )  goto n400;
+          if ( node == 0 ) break;
+          if ((marker[node]<tag)&&(forward[node]>=0)) {
+             marker[node] = tag;
+             /*use storage from eliminated nodes if necessary.*/
+             while ( rloc >= rlmt ) {
+                   link = -adjncy[rlmt];
+                   rloc = xadj[link];
+                   rlmt = xadj[link+1] - 1;
+             };
+             adjncy[rloc] = node;
+             rloc++;
+          };
+      }; /* end of -- for ( j = jstart; -- */
+      element = list[element];
+    };  /* end of -- while ( element > 0 ) -- */
+    if ( rloc <= rlmt ) adjncy[rloc] = 0;
+    /* for each node in the reachable set, do the following. */
+    link = mdeg_node;
+
+n1100:
+    istart = xadj[link];
+    istop = xadj[link+1] - 1;
+    for ( i = istart; i <= istop; i++ ) {
+        rnode = adjncy[i];
+        link = -rnode;
+        if ( rnode < 0 ) goto n1100;
+        if ( rnode == 0 ) return;
+
+        /* 'rnode' is in the degree list structure. */
+        pvnode = backward[rnode];
+        if (( pvnode != 0 ) && ( pvnode != (-maxint) )) {
+           /* then remove 'rnode' from the structure. */
+           nxnode = forward[rnode];
+           if ( nxnode > 0 ) backward[nxnode] = pvnode;
+           if ( pvnode > 0 ) forward[pvnode] = nxnode;
+           npv = -pvnode;
+           if ( pvnode < 0 ) head[npv] = nxnode;
+        };
+
+        /* purge inactive quotient nabors of 'rnode'. */
+        jstart = xadj[rnode];
+        jstop = xadj[rnode+1] - 1;
+        xqnbr = jstart;
+        for ( j = jstart; j <= jstop; j++ ) {
+            nabor = adjncy[j];
+            if ( nabor == 0 ) break;
+            if ( marker[nabor] < tag ) {
+                adjncy[xqnbr] = nabor;
+                xqnbr++;
+            };
+        };
+
+        /* no active nabor after the purging. */
+        nqnbrs = xqnbr - jstart;
+        if ( nqnbrs <= 0 ) {
+           /* merge 'rnode' with 'mdeg_node'. */
+           qsize[mdeg_node] += qsize[rnode];
+           qsize[rnode] = 0;
+           marker[rnode] = maxint;
+           forward[rnode] = -mdeg_node;
+           backward[rnode] = -maxint;
+        } else {
+           /* flag 'rnode' for degree update, and  */
+           /* add 'mdeg_node' as a nabor of 'rnode'.      */
+           forward[rnode] = nqnbrs + 1;
+           backward[rnode] = 0;
+           adjncy[xqnbr] = mdeg_node;
+           xqnbr++;
+           if ( xqnbr <= jstop )  adjncy[xqnbr] = 0;
+        };
+      }; /* end of -- for ( i = istart; -- */
+      return;
+ }
+
+/***************************************************************************
+*    mmdint ---- mult minimum degree initialization
+*    purpose -- this routine performs initialization for the
+*       multiple elimination version of the minimum degree algorithm.
+*    input parameters --
+*       neqns  -- number of equations.
+*       (xadj, adjncy) -- adjacency structure.
+*    output parameters --
+*       (head, dfrow, backward) -- degree doubly linked structure.
+*       qsize -- size of supernode ( initialized to one).
+*       list -- linked list.
+*       marker -- marker vector.
+****************************************************************************/
+int  mmdint(int neqns, idxtype *xadj, idxtype *adjncy, idxtype *head, idxtype *forward,
+     idxtype *backward, idxtype *qsize, idxtype *list, idxtype *marker)
+{
+    int  fnode, ndeg, node;
+
+    for ( node = 1; node <= neqns; node++ ) {
+        head[node] = 0;
+        qsize[node] = 1;
+        marker[node] = 0;
+        list[node] = 0;
+    };
+
+    /* initialize the degree doubly linked lists. */
+    for ( node = 1; node <= neqns; node++ ) {
+        ndeg = xadj[node+1] - xadj[node]/* + 1*/;   /* george */
+        if (ndeg == 0)
+          ndeg = 1;
+        fnode = head[ndeg];
+        forward[node] = fnode;
+        head[ndeg] = node;
+        if ( fnode > 0 ) backward[fnode] = node;
+        backward[node] = -ndeg;
+    };
+    return 0;
+}
+
+/****************************************************************************
+* mmdnum --- multi minimum degree numbering
+* purpose -- this routine performs the final step in producing
+*    the permutation and inverse permutation vectors in the
+*    multiple elimination version of the minimum degree
+*    ordering algorithm.
+* input parameters --
+*     neqns -- number of equations.
+*     qsize -- size of supernodes at elimination.
+* updated parameters --
+*     invp -- inverse permutation vector. on input,
+*             if qsize[node] = 0, then node has been merged
+*             into the node -invp[node]; otherwise,
+*            -invp[node] is its inverse labelling.
+* output parameters --
+*     perm -- the permutation vector.
+****************************************************************************/
+void mmdnum(int neqns, idxtype *perm, idxtype *invp, idxtype *qsize)
+{
+  int father, nextf, node, nqsize, num, root;
+
+  for ( node = 1; node <= neqns; node++ ) {
+      nqsize = qsize[node];
+      if ( nqsize <= 0 ) perm[node] = invp[node];
+      if ( nqsize > 0 )  perm[node] = -invp[node];
+  };
+
+  /* for each node which has been merged, do the following. */
+  for ( node = 1; node <= neqns; node++ ) {
+      if ( perm[node] <= 0 )  {
+
+	 /* trace the merged tree until one which has not */
+         /* been merged, call it root.                    */
+         father = node;
+         while ( perm[father] <= 0 )
+            father = - perm[father];
+
+         /* number node after root. */
+         root = father;
+         num = perm[root] + 1;
+         invp[node] = -num;
+         perm[root] = num;
+
+         /* shorten the merged tree. */
+         father = node;
+         nextf = - perm[father];
+         while ( nextf > 0 ) {
+            perm[father] = -root;
+            father = nextf;
+            nextf = -perm[father];
+         };
+      };  /* end of -- if ( perm[node] <= 0 ) -- */
+  }; /* end of -- for ( node = 1; -- */
+
+  /* ready to compute perm. */
+  for ( node = 1; node <= neqns; node++ ) {
+        num = -invp[node];
+        invp[node] = num;
+        perm[num] = node;
+  };
+  return;
+}
+
+/****************************************************************************
+* mmdupd ---- multiple minimum degree update
+* purpose -- this routine updates the degrees of nodes after a
+*            multiple elimination step.
+* input parameters --
+*    ehead -- the beginning of the list of eliminated nodes
+*             (i.e., newly formed elements).
+*    neqns -- number of equations.
+*    (xadj, adjncy) -- adjacency structure.
+*    delta -- tolerance value for multiple elimination.
+*    maxint -- maximum machine representable (short) integer.
+* updated parameters --
+*    mdeg -- new minimum degree after degree update.
+*    (head, forward, backward) -- degree doubly linked structure.
+*    qsize -- size of supernode.
+*    list -- marker vector for degree update.
+*    *tag   -- tag value.
+****************************************************************************/
+void mmdupd(int ehead, int neqns, idxtype *xadj, idxtype *adjncy, int delta, int *mdeg,
+     idxtype *head, idxtype *forward, idxtype *backward, idxtype *qsize, idxtype *list,
+     idxtype *marker, int maxint,int *tag)
+{
+ int  deg, deg0, element, enode, fnode, i, iq2, istop,
+      istart, j, jstop, jstart, link, mdeg0, mtag, nabor,
+      node, q2head, qxhead;
+
+      mdeg0 = *mdeg + delta;
+      element = ehead;
+
+n100:
+      if ( element <= 0 ) return;
+
+      /* for each of the newly formed element, do the following. */
+      /* reset tag value if necessary.                           */
+      mtag = *tag + mdeg0;
+      if ( mtag >= maxint ) {
+         *tag = 1;
+         for ( i = 1; i <= neqns; i++ )
+             if ( marker[i] < maxint ) marker[i] = 0;
+         mtag = *tag + mdeg0;
+      };
+
+      /* create two linked lists from nodes associated with 'element': */
+      /* one with two nabors (q2head) in the adjacency structure, and the*/
+      /* other with more than two nabors (qxhead). also compute 'deg0',*/
+      /* number of nodes in this element.                              */
+      q2head = 0;
+      qxhead = 0;
+      deg0 = 0;
+      link =element;
+
+n400:
+      istart = xadj[link];
+      istop = xadj[link+1] - 1;
+      for ( i = istart; i <= istop; i++ ) {
+          enode = adjncy[i];
+          link = -enode;
+          if ( enode < 0 )  goto n400;
+          if ( enode == 0 ) break;
+          if ( qsize[enode] != 0 ) {
+             deg0 += qsize[enode];
+             marker[enode] = mtag;
+
+             /*'enode' requires a degree update*/
+             if ( backward[enode] == 0 ) {
+                /* place either in qxhead or q2head list. */
+                if ( forward[enode] != 2 ) {
+                     list[enode] = qxhead;
+                     qxhead = enode;
+                } else {
+                     list[enode] = q2head;
+                     q2head = enode;
+                };
+             };
+          }; /* enf of -- if ( qsize[enode] != 0 ) -- */
+      }; /* end of -- for ( i = istart; -- */
+
+      /* for each node in q2 list, do the following. */
+      enode = q2head;
+      iq2 = 1;
+
+n900:
+      if ( enode <= 0 ) goto n1500;
+      if ( backward[enode] != 0 ) goto n2200;
+      (*tag)++;
+      deg = deg0;
+
+      /* identify the other adjacent element nabor. */
+      istart = xadj[enode];
+      nabor = adjncy[istart];
+      if ( nabor == element ) nabor = adjncy[istart+1];
+      link = nabor;
+      if ( forward[nabor] >= 0 ) {
+           /* nabor is uneliminated, increase degree count. */
+           deg += qsize[nabor];
+           goto n2100;
+      };
+
+       /* the nabor is eliminated. for each node in the 2nd element */
+       /* do the following.                                         */
+n1000:
+       istart = xadj[link];
+       istop = xadj[link+1] - 1;
+       for ( i = istart; i <= istop; i++ ) {
+           node = adjncy[i];
+           link = -node;
+           if ( node != enode ) {
+                if ( node < 0 ) goto n1000;
+                if ( node == 0 )  goto n2100;
+                if ( qsize[node] != 0 ) {
+                     if ( marker[node] < *tag ) {
+                        /* 'node' is not yet considered. */
+                        marker[node] = *tag;
+                        deg += qsize[node];
+                     } else {
+                        if ( backward[node] == 0 ) {
+                             if ( forward[node] == 2 ) {
+                                /* 'node' is indistinguishable from 'enode'.*/
+                                /* merge them into a new supernode.         */
+                                qsize[enode] += qsize[node];
+                                qsize[node] = 0;
+                                marker[node] = maxint;
+                                forward[node] = -enode;
+                                backward[node] = -maxint;
+                             } else {
+                                /* 'node' is outmacthed by 'enode' */
+				if (backward[node]==0) backward[node] = -maxint;
+                             };
+                        }; /* end of -- if ( backward[node] == 0 ) -- */
+                    }; /* end of -- if ( marker[node] < *tag ) -- */
+                }; /* end of -- if ( qsize[node] != 0 ) -- */
+              }; /* end of -- if ( node != enode ) -- */
+          }; /* end of -- for ( i = istart; -- */
+          goto n2100;
+
+n1500:
+          /* for each 'enode' in the 'qx' list, do the following. */
+          enode = qxhead;
+          iq2 = 0;
+
+n1600:    if ( enode <= 0 )  goto n2300;
+          if ( backward[enode] != 0 )  goto n2200;
+          (*tag)++;
+          deg = deg0;
+
+          /*for each unmarked nabor of 'enode', do the following.*/
+          istart = xadj[enode];
+          istop = xadj[enode+1] - 1;
+          for ( i = istart; i <= istop; i++ ) {
+                nabor = adjncy[i];
+                if ( nabor == 0 ) break;
+                if ( marker[nabor] < *tag ) {
+                     marker[nabor] = *tag;
+                     link = nabor;
+                     if ( forward[nabor] >= 0 ) 
+                          /*if uneliminated, include it in deg count.*/
+                          deg += qsize[nabor];
+                     else {
+n1700:
+                          /* if eliminated, include unmarked nodes in this*/
+                          /* element into the degree count.             */
+                          jstart = xadj[link];
+                          jstop = xadj[link+1] - 1;
+                          for ( j = jstart; j <= jstop; j++ ) {
+                                node = adjncy[j];
+                                link = -node;
+                                if ( node < 0 ) goto n1700;
+                                if ( node == 0 ) break;
+                                if ( marker[node] < *tag ) {
+                                    marker[node] = *tag;
+                                    deg += qsize[node];
+                                };
+                          }; /* end of -- for ( j = jstart; -- */
+                     }; /* end of -- if ( forward[nabor] >= 0 ) -- */
+                  }; /* end of -- if ( marker[nabor] < *tag ) -- */
+          }; /* end of -- for ( i = istart; -- */
+
+n2100:
+          /* update external degree of 'enode' in degree structure, */
+          /* and '*mdeg' if necessary.                     */
+          deg = deg - qsize[enode] + 1;
+          fnode = head[deg];
+          forward[enode] = fnode;
+          backward[enode] = -deg;
+          if ( fnode > 0 ) backward[fnode] = enode;
+          head[deg] = enode;
+          if ( deg < *mdeg ) *mdeg = deg;
+
+n2200:
+          /* get next enode in current element. */
+          enode = list[enode];
+          if ( iq2 == 1 ) goto n900;
+          goto n1600;
+
+n2300:
+          /* get next element in the list. */
+          *tag = mtag;
+          element = list[element];
+          goto n100;
+    }
Index: /inundation/pymetis/metis-4.0/Lib/mpmetis.c
===================================================================
--- /inundation/pymetis/metis-4.0/Lib/mpmetis.c	(revision 2051)
+++ /inundation/pymetis/metis-4.0/Lib/mpmetis.c	(revision 2051)
@@ -0,0 +1,402 @@
+/*
+ * Copyright 1997, Regents of the University of Minnesota
+ *
+ * mpmetis.c
+ *
+ * This file contains the top level routines for the multilevel recursive
+ * bisection algorithm PMETIS.
+ *
+ * Started 7/24/97
+ * George
+ *
+ * $Id: mpmetis.c,v 1.4 1998/11/30 14:50:44 karypis Exp $
+ *
+ */
+
+#include <metis.h>
+
+
+
+/*************************************************************************
+* This function is the entry point for PWMETIS that accepts exact weights
+* for the target partitions
+**************************************************************************/
+void METIS_mCPartGraphRecursive(int *nvtxs, int *ncon, idxtype *xadj, idxtype *adjncy, 
+       idxtype *vwgt, idxtype *adjwgt, int *wgtflag, int *numflag, int *nparts, 
+       int *options, int *edgecut, idxtype *part)
+{
+  int i, j;
+  GraphType graph;
+  CtrlType ctrl;
+
+  if (*numflag == 1)
+    Change2CNumbering(*nvtxs, xadj, adjncy);
+
+  SetUpGraph(&graph, OP_PMETIS, *nvtxs, *ncon, xadj, adjncy, vwgt, adjwgt, *wgtflag);
+
+  if (options[0] == 0) {  /* Use the default parameters */
+    ctrl.CType  = McPMETIS_CTYPE;
+    ctrl.IType  = McPMETIS_ITYPE;
+    ctrl.RType  = McPMETIS_RTYPE;
+    ctrl.dbglvl = McPMETIS_DBGLVL;
+  }
+  else {
+    ctrl.CType  = options[OPTION_CTYPE];
+    ctrl.IType  = options[OPTION_ITYPE];
+    ctrl.RType  = options[OPTION_RTYPE];
+    ctrl.dbglvl = options[OPTION_DBGLVL];
+  }
+  ctrl.optype = OP_PMETIS;
+  ctrl.CoarsenTo = 100;
+
+  ctrl.nmaxvwgt = 1.5/(1.0*ctrl.CoarsenTo);
+
+  InitRandom(-1);
+
+  AllocateWorkSpace(&ctrl, &graph, *nparts);
+
+  IFSET(ctrl.dbglvl, DBG_TIME, InitTimers(&ctrl));
+  IFSET(ctrl.dbglvl, DBG_TIME, starttimer(ctrl.TotalTmr));
+
+  *edgecut = MCMlevelRecursiveBisection(&ctrl, &graph, *nparts, part, 1.000, 0);
+
+  IFSET(ctrl.dbglvl, DBG_TIME, stoptimer(ctrl.TotalTmr));
+  IFSET(ctrl.dbglvl, DBG_TIME, PrintTimers(&ctrl));
+
+  FreeWorkSpace(&ctrl, &graph);
+
+  if (*numflag == 1)
+    Change2FNumbering(*nvtxs, xadj, adjncy, part);
+}
+
+
+
+/*************************************************************************
+* This function is the entry point for PWMETIS that accepts exact weights
+* for the target partitions
+**************************************************************************/
+void METIS_mCHPartGraphRecursive(int *nvtxs, int *ncon, idxtype *xadj, idxtype *adjncy, 
+       idxtype *vwgt, idxtype *adjwgt, int *wgtflag, int *numflag, int *nparts, 
+       float *ubvec, int *options, int *edgecut, idxtype *part)
+{
+  int i, j;
+  GraphType graph;
+  CtrlType ctrl;
+  float *myubvec;
+
+  if (*numflag == 1)
+    Change2CNumbering(*nvtxs, xadj, adjncy);
+
+  SetUpGraph(&graph, OP_PMETIS, *nvtxs, *ncon, xadj, adjncy, vwgt, adjwgt, *wgtflag);
+
+  if (options[0] == 0) {  /* Use the default parameters */
+    ctrl.CType = PMETIS_CTYPE;
+    ctrl.IType = PMETIS_ITYPE;
+    ctrl.RType = PMETIS_RTYPE;
+    ctrl.dbglvl = PMETIS_DBGLVL;
+  }
+  else {
+    ctrl.CType = options[OPTION_CTYPE];
+    ctrl.IType = options[OPTION_ITYPE];
+    ctrl.RType = options[OPTION_RTYPE];
+    ctrl.dbglvl = options[OPTION_DBGLVL];
+  }
+  ctrl.optype = OP_PMETIS;
+  ctrl.CoarsenTo = 100;
+
+  ctrl.nmaxvwgt = 1.5/(1.0*ctrl.CoarsenTo);
+
+  myubvec = fmalloc(*ncon, "PWMETIS: mytpwgts");
+  scopy(*ncon, ubvec, myubvec);
+
+  InitRandom(-1);
+
+  AllocateWorkSpace(&ctrl, &graph, *nparts);
+
+  IFSET(ctrl.dbglvl, DBG_TIME, InitTimers(&ctrl));
+  IFSET(ctrl.dbglvl, DBG_TIME, starttimer(ctrl.TotalTmr));
+
+  *edgecut = MCHMlevelRecursiveBisection(&ctrl, &graph, *nparts, part, myubvec, 0);
+
+  IFSET(ctrl.dbglvl, DBG_TIME, stoptimer(ctrl.TotalTmr));
+  IFSET(ctrl.dbglvl, DBG_TIME, PrintTimers(&ctrl));
+
+  FreeWorkSpace(&ctrl, &graph);
+  GKfree(&myubvec, LTERM);
+
+  if (*numflag == 1)
+    Change2FNumbering(*nvtxs, xadj, adjncy, part);
+}
+
+
+
+/*************************************************************************
+* This function is the entry point for PWMETIS that accepts exact weights
+* for the target partitions
+**************************************************************************/
+void METIS_mCPartGraphRecursiveInternal(int *nvtxs, int *ncon, idxtype *xadj, idxtype *adjncy, 
+       float *nvwgt, idxtype *adjwgt, int *nparts, int *options, int *edgecut, idxtype *part)
+{
+  int i, j;
+  GraphType graph;
+  CtrlType ctrl;
+
+  SetUpGraph2(&graph, *nvtxs, *ncon, xadj, adjncy, nvwgt, adjwgt);
+
+  if (options[0] == 0) {  /* Use the default parameters */
+    ctrl.CType = PMETIS_CTYPE;
+    ctrl.IType = PMETIS_ITYPE;
+    ctrl.RType = PMETIS_RTYPE;
+    ctrl.dbglvl = PMETIS_DBGLVL;
+  }
+  else {
+    ctrl.CType = options[OPTION_CTYPE];
+    ctrl.IType = options[OPTION_ITYPE];
+    ctrl.RType = options[OPTION_RTYPE];
+    ctrl.dbglvl = options[OPTION_DBGLVL];
+  }
+  ctrl.optype = OP_PMETIS;
+  ctrl.CoarsenTo = 100;
+
+  ctrl.nmaxvwgt = 1.5/(1.0*ctrl.CoarsenTo);
+
+  InitRandom(-1);
+
+  AllocateWorkSpace(&ctrl, &graph, *nparts);
+
+  IFSET(ctrl.dbglvl, DBG_TIME, InitTimers(&ctrl));
+  IFSET(ctrl.dbglvl, DBG_TIME, starttimer(ctrl.TotalTmr));
+
+  *edgecut = MCMlevelRecursiveBisection(&ctrl, &graph, *nparts, part, 1.000, 0);
+
+  IFSET(ctrl.dbglvl, DBG_TIME, stoptimer(ctrl.TotalTmr));
+  IFSET(ctrl.dbglvl, DBG_TIME, PrintTimers(&ctrl));
+
+  FreeWorkSpace(&ctrl, &graph);
+
+}
+
+
+/*************************************************************************
+* This function is the entry point for PWMETIS that accepts exact weights
+* for the target partitions
+**************************************************************************/
+void METIS_mCHPartGraphRecursiveInternal(int *nvtxs, int *ncon, idxtype *xadj, idxtype *adjncy, 
+       float *nvwgt, idxtype *adjwgt, int *nparts, float *ubvec, int *options, int *edgecut, 
+       idxtype *part)
+{
+  int i, j;
+  GraphType graph;
+  CtrlType ctrl;
+  float *myubvec;
+
+  SetUpGraph2(&graph, *nvtxs, *ncon, xadj, adjncy, nvwgt, adjwgt);
+
+  if (options[0] == 0) {  /* Use the default parameters */
+    ctrl.CType = PMETIS_CTYPE;
+    ctrl.IType = PMETIS_ITYPE;
+    ctrl.RType = PMETIS_RTYPE;
+    ctrl.dbglvl = PMETIS_DBGLVL;
+  }
+  else {
+    ctrl.CType = options[OPTION_CTYPE];
+    ctrl.IType = options[OPTION_ITYPE];
+    ctrl.RType = options[OPTION_RTYPE];
+    ctrl.dbglvl = options[OPTION_DBGLVL];
+  }
+  ctrl.optype = OP_PMETIS;
+  ctrl.CoarsenTo = 100;
+
+  ctrl.nmaxvwgt = 1.5/(1.0*ctrl.CoarsenTo);
+
+  myubvec = fmalloc(*ncon, "PWMETIS: mytpwgts");
+  scopy(*ncon, ubvec, myubvec);
+
+  InitRandom(-1);
+
+  AllocateWorkSpace(&ctrl, &graph, *nparts);
+
+  IFSET(ctrl.dbglvl, DBG_TIME, InitTimers(&ctrl));
+  IFSET(ctrl.dbglvl, DBG_TIME, starttimer(ctrl.TotalTmr));
+
+  *edgecut = MCHMlevelRecursiveBisection(&ctrl, &graph, *nparts, part, myubvec, 0);
+
+  IFSET(ctrl.dbglvl, DBG_TIME, stoptimer(ctrl.TotalTmr));
+  IFSET(ctrl.dbglvl, DBG_TIME, PrintTimers(&ctrl));
+
+  FreeWorkSpace(&ctrl, &graph);
+  GKfree(&myubvec, LTERM);
+
+}
+
+
+
+
+/*************************************************************************
+* This function takes a graph and produces a bisection of it
+**************************************************************************/
+int MCMlevelRecursiveBisection(CtrlType *ctrl, GraphType *graph, int nparts, idxtype *part, 
+       float ubfactor, int fpart)
+{
+  int i, j, nvtxs, ncon, cut;
+  idxtype *label, *where;
+  GraphType lgraph, rgraph;
+  float tpwgts[2];
+
+  nvtxs = graph->nvtxs;
+  if (nvtxs == 0) {
+    printf("\t***Cannot bisect a graph with 0 vertices!\n\t***You are trying to partition a graph into too many parts!\n");
+    return 0;
+  }
+
+  /* Determine the weights of the partitions */
+  tpwgts[0] = 1.0*(nparts>>1)/(1.0*nparts);
+  tpwgts[1] = 1.0 - tpwgts[0];
+
+  MCMlevelEdgeBisection(ctrl, graph, tpwgts, ubfactor);
+  cut = graph->mincut;
+
+  label = graph->label;
+  where = graph->where;
+  for (i=0; i<nvtxs; i++)
+    part[label[i]] = where[i] + fpart;
+
+  if (nparts > 2) 
+    SplitGraphPart(ctrl, graph, &lgraph, &rgraph);
+
+  /* Free the memory of the top level graph */
+  GKfree(&graph->gdata, &graph->nvwgt, &graph->rdata, &graph->npwgts, &graph->label, LTERM);
+
+
+  /* Do the recursive call */
+  if (nparts > 3) {
+    cut += MCMlevelRecursiveBisection(ctrl, &lgraph, nparts/2, part, ubfactor, fpart);
+    cut += MCMlevelRecursiveBisection(ctrl, &rgraph, nparts-nparts/2, part, ubfactor, fpart+nparts/2);
+  }
+  else if (nparts == 3) {
+    cut += MCMlevelRecursiveBisection(ctrl, &rgraph, nparts-nparts/2, part, ubfactor, fpart+nparts/2);
+    GKfree(&lgraph.gdata, &lgraph.nvwgt, &lgraph.label, LTERM);
+  }
+
+  return cut;
+
+}
+
+
+
+/*************************************************************************
+* This function takes a graph and produces a bisection of it
+**************************************************************************/
+int MCHMlevelRecursiveBisection(CtrlType *ctrl, GraphType *graph, int nparts, idxtype *part, 
+      float *ubvec, int fpart)
+{
+  int i, j, nvtxs, ncon, cut;
+  idxtype *label, *where;
+  GraphType lgraph, rgraph;
+  float tpwgts[2], *npwgts, *lubvec, *rubvec;
+
+  lubvec = rubvec = NULL;
+
+  nvtxs = graph->nvtxs;
+  ncon = graph->ncon;
+  if (nvtxs == 0) {
+    printf("\t***Cannot bisect a graph with 0 vertices!\n\t***You are trying to partition a graph into too many parts!\n");
+    return 0;
+  }
+
+  /* Determine the weights of the partitions */
+  tpwgts[0] = 1.0*(nparts>>1)/(1.0*nparts);
+  tpwgts[1] = 1.0 - tpwgts[0];
+
+  /* For now, relax at the coarsest level only */
+  if (nparts == 2)
+    MCHMlevelEdgeBisection(ctrl, graph, tpwgts, ubvec);
+  else
+    MCMlevelEdgeBisection(ctrl, graph, tpwgts, 1.000);
+  cut = graph->mincut;
+
+  label = graph->label;
+  where = graph->where;
+  for (i=0; i<nvtxs; i++)
+    part[label[i]] = where[i] + fpart;
+
+  if (nparts > 2) {
+    /* Adjust the ubvecs before the split */
+    npwgts = graph->npwgts;
+    lubvec = fmalloc(ncon, "MCHMlevelRecursiveBisection");
+    rubvec = fmalloc(ncon, "MCHMlevelRecursiveBisection");
+
+    for (i=0; i<ncon; i++) {
+      lubvec[i] = ubvec[i]*tpwgts[0]/npwgts[i];
+      lubvec[i] = amax(lubvec[i], 1.01);
+
+      rubvec[i] = ubvec[i]*tpwgts[1]/npwgts[ncon+i];
+      rubvec[i] = amax(rubvec[i], 1.01);
+    }
+
+    SplitGraphPart(ctrl, graph, &lgraph, &rgraph);
+  }
+
+  /* Free the memory of the top level graph */
+  GKfree(&graph->gdata, &graph->nvwgt, &graph->rdata, &graph->npwgts, &graph->label, LTERM);
+
+
+  /* Do the recursive call */
+  if (nparts > 3) {
+    cut += MCHMlevelRecursiveBisection(ctrl, &lgraph, nparts/2, part, lubvec, fpart);
+    cut += MCHMlevelRecursiveBisection(ctrl, &rgraph, nparts-nparts/2, part, rubvec, fpart+nparts/2);
+  }
+  else if (nparts == 3) {
+    cut += MCHMlevelRecursiveBisection(ctrl, &rgraph, nparts-nparts/2, part, rubvec, fpart+nparts/2);
+    GKfree(&lgraph.gdata, &lgraph.nvwgt, &lgraph.label, LTERM);
+  }
+
+  GKfree(&lubvec, &rubvec, LTERM);
+
+  return cut;
+
+}
+
+
+
+
+/*************************************************************************
+* This function performs multilevel bisection
+**************************************************************************/
+void MCMlevelEdgeBisection(CtrlType *ctrl, GraphType *graph, float *tpwgts, float ubfactor)
+{
+  GraphType *cgraph;
+
+  cgraph = MCCoarsen2Way(ctrl, graph);
+
+  MocInit2WayPartition(ctrl, cgraph, tpwgts, ubfactor);
+
+  MocRefine2Way(ctrl, graph, cgraph, tpwgts, ubfactor); 
+
+}
+
+
+
+/*************************************************************************
+* This function performs multilevel bisection
+**************************************************************************/
+void MCHMlevelEdgeBisection(CtrlType *ctrl, GraphType *graph, float *tpwgts, float *ubvec)
+{
+  int i;
+  GraphType *cgraph;
+
+/*
+  for (i=0; i<graph->ncon; i++)
+    printf("%.4f ", ubvec[i]);
+  printf("\n");
+*/
+
+  cgraph = MCCoarsen2Way(ctrl, graph);
+
+  MocInit2WayPartition2(ctrl, cgraph, tpwgts, ubvec);
+
+  MocRefine2Way2(ctrl, graph, cgraph, tpwgts, ubvec); 
+
+}
+
+
Index: /inundation/pymetis/metis-4.0/Lib/mrefine.c
===================================================================
--- /inundation/pymetis/metis-4.0/Lib/mrefine.c	(revision 2051)
+++ /inundation/pymetis/metis-4.0/Lib/mrefine.c	(revision 2051)
@@ -0,0 +1,219 @@
+/*
+ * Copyright 1997, Regents of the University of Minnesota
+ *
+ * refine.c
+ *
+ * This file contains the driving routines for multilevel refinement
+ *
+ * Started 7/24/97
+ * George
+ *
+ * $Id: mrefine.c,v 1.2 1998/11/27 18:25:09 karypis Exp $
+ */
+
+#include <metis.h>
+
+
+/*************************************************************************
+* This function is the entry point of refinement
+**************************************************************************/
+void MocRefine2Way(CtrlType *ctrl, GraphType *orggraph, GraphType *graph, float *tpwgts, float ubfactor)
+{
+  int i;
+  float tubvec[MAXNCON];
+
+  for (i=0; i<graph->ncon; i++)
+    tubvec[i] = 1.0;
+
+  IFSET(ctrl->dbglvl, DBG_TIME, starttimer(ctrl->UncoarsenTmr));
+
+  /* Compute the parameters of the coarsest graph */
+  MocCompute2WayPartitionParams(ctrl, graph);
+
+  for (;;) {
+    ASSERT(CheckBnd(graph));
+
+    IFSET(ctrl->dbglvl, DBG_TIME, starttimer(ctrl->RefTmr));
+    switch (ctrl->RType) {
+      case RTYPE_FM:
+        MocBalance2Way(ctrl, graph, tpwgts, 1.03);
+        MocFM_2WayEdgeRefine(ctrl, graph, tpwgts, 8); 
+        break;
+      case 2:
+        MocBalance2Way(ctrl, graph, tpwgts, 1.03);
+        MocFM_2WayEdgeRefine2(ctrl, graph, tpwgts, tubvec, 8); 
+        break;
+      default:
+        errexit("Unknown refinement type: %d\n", ctrl->RType);
+    }
+    IFSET(ctrl->dbglvl, DBG_TIME, stoptimer(ctrl->RefTmr));
+
+    if (graph == orggraph)
+      break;
+
+    graph = graph->finer;
+    IFSET(ctrl->dbglvl, DBG_TIME, starttimer(ctrl->ProjectTmr));
+    MocProject2WayPartition(ctrl, graph);
+    IFSET(ctrl->dbglvl, DBG_TIME, stoptimer(ctrl->ProjectTmr));
+  }
+
+  MocBalance2Way(ctrl, graph, tpwgts, 1.01);
+  MocFM_2WayEdgeRefine(ctrl, graph, tpwgts, 8); 
+
+  IFSET(ctrl->dbglvl, DBG_TIME, stoptimer(ctrl->UncoarsenTmr));
+}
+
+
+/*************************************************************************
+* This function allocates memory for 2-way edge refinement
+**************************************************************************/
+void MocAllocate2WayPartitionMemory(CtrlType *ctrl, GraphType *graph)
+{
+  int nvtxs, ncon;
+
+  nvtxs = graph->nvtxs;
+  ncon = graph->ncon;
+
+  graph->rdata = idxmalloc(5*nvtxs, "Allocate2WayPartitionMemory: rdata");
+  graph->where		= graph->rdata;
+  graph->id		= graph->rdata + nvtxs;
+  graph->ed		= graph->rdata + 2*nvtxs;
+  graph->bndptr		= graph->rdata + 3*nvtxs;
+  graph->bndind		= graph->rdata + 4*nvtxs;
+
+  graph->npwgts 	= fmalloc(2*ncon, "npwgts");
+}
+
+
+/*************************************************************************
+* This function computes the initial id/ed 
+**************************************************************************/
+void MocCompute2WayPartitionParams(CtrlType *ctrl, GraphType *graph)
+{
+  int i, j, k, l, nvtxs, ncon, nbnd, mincut;
+  idxtype *xadj, *adjncy, *adjwgt;
+  float *nvwgt, *npwgts;
+  idxtype *id, *ed, *where;
+  idxtype *bndptr, *bndind;
+  int me, other;
+
+  nvtxs = graph->nvtxs;
+  ncon = graph->ncon;
+  xadj = graph->xadj;
+  nvwgt = graph->nvwgt;
+  adjncy = graph->adjncy;
+  adjwgt = graph->adjwgt;
+
+  where = graph->where;
+  npwgts = sset(2*ncon, 0.0, graph->npwgts);
+  id = idxset(nvtxs, 0, graph->id);
+  ed = idxset(nvtxs, 0, graph->ed);
+  bndptr = idxset(nvtxs, -1, graph->bndptr);
+  bndind = graph->bndind;
+
+
+  /*------------------------------------------------------------
+  / Compute now the id/ed degrees
+  /------------------------------------------------------------*/
+  nbnd = mincut = 0;
+  for (i=0; i<nvtxs; i++) {
+    ASSERT(where[i] >= 0 && where[i] <= 1);
+    me = where[i];
+    saxpy(ncon, 1.0, nvwgt+i*ncon, 1, npwgts+me*ncon, 1);
+
+    for (j=xadj[i]; j<xadj[i+1]; j++) {
+      if (me == where[adjncy[j]])
+        id[i] += adjwgt[j];
+      else
+        ed[i] += adjwgt[j];
+    }
+
+    if (ed[i] > 0 || xadj[i] == xadj[i+1]) {
+      mincut += ed[i];
+      bndptr[i] = nbnd;
+      bndind[nbnd++] = i;
+    }
+  }
+
+  graph->mincut = mincut/2;
+  graph->nbnd = nbnd;
+
+}
+
+
+
+/*************************************************************************
+* This function projects a partition, and at the same time computes the
+* parameters for refinement.
+**************************************************************************/
+void MocProject2WayPartition(CtrlType *ctrl, GraphType *graph)
+{
+  int i, j, k, nvtxs, nbnd, me;
+  idxtype *xadj, *adjncy, *adjwgt, *adjwgtsum;
+  idxtype *cmap, *where, *id, *ed, *bndptr, *bndind;
+  idxtype *cwhere, *cid, *ced, *cbndptr;
+  GraphType *cgraph;
+
+  cgraph = graph->coarser;
+  cwhere = cgraph->where;
+  cid = cgraph->id;
+  ced = cgraph->ed;
+  cbndptr = cgraph->bndptr;
+
+  nvtxs = graph->nvtxs;
+  cmap = graph->cmap;
+  xadj = graph->xadj;
+  adjncy = graph->adjncy;
+  adjwgt = graph->adjwgt;
+  adjwgtsum = graph->adjwgtsum;
+
+  MocAllocate2WayPartitionMemory(ctrl, graph);
+
+  where = graph->where;
+  id = idxset(nvtxs, 0, graph->id);
+  ed = idxset(nvtxs, 0, graph->ed);
+  bndptr = idxset(nvtxs, -1, graph->bndptr);
+  bndind = graph->bndind;
+
+
+  /* Go through and project partition and compute id/ed for the nodes */
+  for (i=0; i<nvtxs; i++) {
+    k = cmap[i];
+    where[i] = cwhere[k];
+    cmap[i] = cbndptr[k];
+  }
+
+  for (nbnd=0, i=0; i<nvtxs; i++) {
+    me = where[i];
+
+    id[i] = adjwgtsum[i];
+
+    if (xadj[i] == xadj[i+1]) {
+      bndptr[i] = nbnd;
+      bndind[nbnd++] = i;
+    }
+    else {
+      if (cmap[i] != -1) { /* If it is an interface node. Note that cmap[i] = cbndptr[cmap[i]] */
+        for (j=xadj[i]; j<xadj[i+1]; j++) {
+          if (me != where[adjncy[j]])
+            ed[i] += adjwgt[j];
+        }
+        id[i] -= ed[i];
+
+        if (ed[i] > 0 || xadj[i] == xadj[i+1]) {
+          bndptr[i] = nbnd;
+          bndind[nbnd++] = i;
+        }
+      }
+    }
+  }
+
+  graph->mincut = cgraph->mincut;
+  graph->nbnd = nbnd;
+  scopy(2*graph->ncon, cgraph->npwgts, graph->npwgts);
+
+  FreeGraph(graph->coarser);
+  graph->coarser = NULL;
+
+}
+
Index: /inundation/pymetis/metis-4.0/Lib/mrefine2.c
===================================================================
--- /inundation/pymetis/metis-4.0/Lib/mrefine2.c	(revision 2051)
+++ /inundation/pymetis/metis-4.0/Lib/mrefine2.c	(revision 2051)
@@ -0,0 +1,55 @@
+/*
+ * Copyright 1997, Regents of the University of Minnesota
+ *
+ * mrefine2.c
+ *
+ * This file contains the driving routines for multilevel refinement
+ *
+ * Started 7/24/97
+ * George
+ *
+ * $Id: mrefine2.c,v 1.1 1998/11/27 17:59:26 karypis Exp $
+ */
+
+#include <metis.h>
+
+
+/*************************************************************************
+* This function is the entry point of refinement
+**************************************************************************/
+void MocRefine2Way2(CtrlType *ctrl, GraphType *orggraph, GraphType *graph, float *tpwgts, 
+       float *ubvec)
+{
+
+  IFSET(ctrl->dbglvl, DBG_TIME, starttimer(ctrl->UncoarsenTmr));
+
+  /* Compute the parameters of the coarsest graph */
+  MocCompute2WayPartitionParams(ctrl, graph);
+
+  for (;;) {
+    ASSERT(CheckBnd(graph));
+
+    IFSET(ctrl->dbglvl, DBG_TIME, starttimer(ctrl->RefTmr));
+    switch (ctrl->RType) {
+      case RTYPE_FM:
+        MocBalance2Way2(ctrl, graph, tpwgts, ubvec);
+        MocFM_2WayEdgeRefine2(ctrl, graph, tpwgts, ubvec, 8); 
+        break;
+      default:
+        errexit("Unknown refinement type: %d\n", ctrl->RType);
+    }
+    IFSET(ctrl->dbglvl, DBG_TIME, stoptimer(ctrl->RefTmr));
+
+    if (graph == orggraph)
+      break;
+
+    graph = graph->finer;
+    IFSET(ctrl->dbglvl, DBG_TIME, starttimer(ctrl->ProjectTmr));
+    MocProject2WayPartition(ctrl, graph);
+    IFSET(ctrl->dbglvl, DBG_TIME, stoptimer(ctrl->ProjectTmr));
+  }
+
+  IFSET(ctrl->dbglvl, DBG_TIME, stoptimer(ctrl->UncoarsenTmr));
+}
+
+
Index: /inundation/pymetis/metis-4.0/Lib/mutil.c
===================================================================
--- /inundation/pymetis/metis-4.0/Lib/mutil.c	(revision 2051)
+++ /inundation/pymetis/metis-4.0/Lib/mutil.c	(revision 2051)
@@ -0,0 +1,101 @@
+/*
+ * mutil.c 
+ *
+ * This file contains various utility functions for the MOC portion of the
+ * code
+ *
+ * Started 2/15/98
+ * George
+ *
+ * $Id: mutil.c,v 1.1 1998/11/27 17:59:27 karypis Exp $
+ *
+ */
+
+#include <metis.h>
+
+
+/*************************************************************************
+* This function checks if the vertex weights of two vertices are below 
+* a given set of values
+**************************************************************************/
+int AreAllVwgtsBelow(int ncon, float alpha, float *vwgt1, float beta, float *vwgt2, float limit)
+{
+  int i;
+
+  for (i=0; i<ncon; i++)
+    if (alpha*vwgt1[i] + beta*vwgt2[i] > limit)
+      return 0;
+
+  return 1;
+}
+
+
+/*************************************************************************
+* This function checks if the vertex weights of two vertices are below 
+* a given set of values
+**************************************************************************/
+int AreAnyVwgtsBelow(int ncon, float alpha, float *vwgt1, float beta, float *vwgt2, float limit)
+{
+  int i;
+
+  for (i=0; i<ncon; i++)
+    if (alpha*vwgt1[i] + beta*vwgt2[i] < limit)
+      return 1;
+
+  return 0;
+}
+
+
+
+/*************************************************************************
+* This function checks if the vertex weights of two vertices are above 
+* a given set of values
+**************************************************************************/
+int AreAllVwgtsAbove(int ncon, float alpha, float *vwgt1, float beta, float *vwgt2, float limit)
+{
+  int i;
+
+  for (i=0; i<ncon; i++)
+    if (alpha*vwgt1[i] + beta*vwgt2[i] < limit)
+      return 0;
+
+  return 1;
+}
+
+
+/*************************************************************************
+* This function computes the load imbalance over all the constrains
+* For now assume that we just want balanced partitionings
+**************************************************************************/ 
+float ComputeLoadImbalance(int ncon, int nparts, float *npwgts, float *tpwgts)
+{
+  int i, j;
+  float max, lb=0.0;
+
+  for (i=0; i<ncon; i++) {
+    max = 0.0;
+    for (j=0; j<nparts; j++) {
+      if (npwgts[j*ncon+i] > max)
+        max = npwgts[j*ncon+i];
+    }
+    if (max*nparts > lb)
+      lb = max*nparts;
+  }
+
+  return lb;
+}
+
+/*************************************************************************
+* This function checks if the vertex weights of two vertices are below 
+* a given set of values
+**************************************************************************/
+int AreAllBelow(int ncon, float *v1, float *v2)
+{
+  int i;
+
+  for (i=0; i<ncon; i++)
+    if (v1[i] > v2[i])
+      return 0;
+
+  return 1;
+}
Index: /inundation/pymetis/metis-4.0/Lib/myqsort.c
===================================================================
--- /inundation/pymetis/metis-4.0/Lib/myqsort.c	(revision 2051)
+++ /inundation/pymetis/metis-4.0/Lib/myqsort.c	(revision 2051)
@@ -0,0 +1,547 @@
+/*
+ * Copyright 1997, Regents of the University of Minnesota
+ *
+ * myqsort.c
+ * 
+ * This file contains a fast idxtype increasing qsort algorithm.
+ * Addopted from TeX
+ * 
+ * Started 10/18/96
+ * George
+ * 
+ * $Id: myqsort.c,v 1.1 1998/11/27 17:59:27 karypis Exp $
+ */
+
+#include <metis.h>			/* only for type declarations */
+
+#define		THRESH		1	/* threshold for insertion */
+#define		MTHRESH		6	/* threshold for median */
+
+
+
+
+static void siqst(idxtype *, idxtype *);
+static void iiqst(int *, int *);
+static void keyiqst(KeyValueType *, KeyValueType *);
+static void keyvaliqst(KeyValueType *, KeyValueType *);
+
+
+/*************************************************************************
+* Entry point of idxtype increasing sort
+**************************************************************************/
+void iidxsort(int n, idxtype *base)
+{
+  register idxtype *i;
+  register idxtype *j;
+  register idxtype *lo;
+  register idxtype *hi;
+  register idxtype *min;
+  register idxtype c;
+  idxtype *max;
+
+  if (n <= 1)
+    return;
+
+  max = base + n;
+
+  if (n >= THRESH) {
+    siqst(base, max);
+    hi = base + THRESH;
+  }
+  else 
+    hi = max;
+
+  for (j = lo = base; lo++ < hi;) {
+    if (*j > *lo)
+      j = lo;
+  }
+  if (j != base) { /* swap j into place */
+    c = *base;
+    *base = *j;
+    *j = c;
+  }
+
+  for (min = base; (hi = min += 1) < max;) {
+    while (*(--hi) > *min);
+    if ((hi += 1) != min) {
+      for (lo = min + 1; --lo >= min;) {
+	c = *lo;
+	for (i = j = lo; (j -= 1) >= hi; i = j)
+	   *i = *j;
+	*i = c;
+      }
+    }
+  }
+}
+
+static void siqst(idxtype *base, idxtype *max)
+{
+  register idxtype *i;
+  register idxtype *j;
+  register idxtype *jj;
+  register idxtype *mid;
+  register int ii;
+  register idxtype c;
+  idxtype *tmp;
+  int lo;
+  int hi;
+
+  lo = max - base;		/* number of elements as idxtype */
+  do {
+    mid = base + ((unsigned) lo>>1);
+    if (lo >= MTHRESH) {
+      j = (*base > *mid ? base : mid);
+      tmp = max - 1;
+      if (*j > *tmp) {
+        j = (j == base ? mid : base); /* switch to first loser */
+        if (*j < *tmp)
+          j = tmp;
+      }
+
+      if (j != mid) {  /* SWAP */ 
+        c = *mid;
+        *mid = *j;
+        *j = c;
+      }
+    }
+
+    /* Semi-standard quicksort partitioning/swapping */
+    for (i = base, j = max - 1;;) {
+      while (i < mid && *i <= *mid)
+        i++;
+      while (j > mid) {
+        if (*mid <= *j) {
+          j--;
+          continue;
+        }
+        tmp = i + 1;	/* value of i after swap */
+        if (i == mid) 	/* j <-> mid, new mid is j */
+          mid = jj = j;
+        else 		/* i <-> j */
+          jj = j--;
+        goto swap;
+      }
+
+      if (i == mid) 
+	break;
+      else {		/* i <-> mid, new mid is i */
+        jj = mid;
+        tmp = mid = i;	/* value of i after swap */
+        j--;
+      }
+swap:
+      c = *i;
+      *i = *jj;
+      *jj = c;
+      i = tmp;
+    }
+
+    i = (j = mid) + 1;
+    if ((lo = j - base) <= (hi = max - i)) {
+      if (lo >= THRESH)
+        siqst(base, j);
+      base = i;
+      lo = hi;
+    }
+    else {
+      if (hi >= THRESH)
+        siqst(i, max);
+      max = j;
+    }
+  } while (lo >= THRESH);
+}
+
+
+
+
+
+/*************************************************************************
+* Entry point of int increasing sort
+**************************************************************************/
+void iintsort(int n, int *base)
+{
+  register int *i;
+  register int *j;
+  register int *lo;
+  register int *hi;
+  register int *min;
+  register int c;
+  int *max;
+
+  if (n <= 1)
+    return;
+
+  max = base + n;
+
+  if (n >= THRESH) {
+    iiqst(base, max);
+    hi = base + THRESH;
+  }
+  else 
+    hi = max;
+
+  for (j = lo = base; lo++ < hi;) {
+    if (*j > *lo)
+      j = lo;
+  }
+  if (j != base) { /* swap j into place */
+    c = *base;
+    *base = *j;
+    *j = c;
+  }
+
+  for (min = base; (hi = min += 1) < max;) {
+    while (*(--hi) > *min);
+    if ((hi += 1) != min) {
+      for (lo = min + 1; --lo >= min;) {
+	c = *lo;
+	for (i = j = lo; (j -= 1) >= hi; i = j)
+	   *i = *j;
+	*i = c;
+      }
+    }
+  }
+}
+
+
+static void iiqst(int *base, int *max)
+{
+  register int *i;
+  register int *j;
+  register int *jj;
+  register int *mid;
+  register int ii;
+  register int c;
+  int *tmp;
+  int lo;
+  int hi;
+
+  lo = max - base;		/* number of elements as ints */
+  do {
+    mid = base + ((unsigned) lo>>1);
+    if (lo >= MTHRESH) {
+      j = (*base > *mid ? base : mid);
+      tmp = max - 1;
+      if (*j > *tmp) {
+        j = (j == base ? mid : base); /* switch to first loser */
+        if (*j < *tmp)
+          j = tmp;
+      }
+
+      if (j != mid) {  /* SWAP */ 
+        c = *mid;
+        *mid = *j;
+        *j = c;
+      }
+    }
+
+    /* Semi-standard quicksort partitioning/swapping */
+    for (i = base, j = max - 1;;) {
+      while (i < mid && *i <= *mid)
+        i++;
+      while (j > mid) {
+        if (*mid <= *j) {
+          j--;
+          continue;
+        }
+        tmp = i + 1;	/* value of i after swap */
+        if (i == mid) 	/* j <-> mid, new mid is j */
+          mid = jj = j;
+        else 		/* i <-> j */
+          jj = j--;
+        goto swap;
+      }
+
+      if (i == mid) 
+	break;
+      else {		/* i <-> mid, new mid is i */
+        jj = mid;
+        tmp = mid = i;	/* value of i after swap */
+        j--;
+      }
+swap:
+      c = *i;
+      *i = *jj;
+      *jj = c;
+      i = tmp;
+    }
+
+    i = (j = mid) + 1;
+    if ((lo = j - base) <= (hi = max - i)) {
+      if (lo >= THRESH)
+        iiqst(base, j);
+      base = i;
+      lo = hi;
+    }
+    else {
+      if (hi >= THRESH)
+        iiqst(i, max);
+      max = j;
+    }
+  } while (lo >= THRESH);
+}
+
+
+
+
+
+/*************************************************************************
+* Entry point of KeyVal increasing sort, ONLY key part
+**************************************************************************/
+void ikeysort(int n, KeyValueType *base)
+{
+  register KeyValueType *i;
+  register KeyValueType *j;
+  register KeyValueType *lo;
+  register KeyValueType *hi;
+  register KeyValueType *min;
+  register KeyValueType c;
+  KeyValueType *max;
+
+  if (n <= 1)
+    return;
+
+  max = base + n;
+
+  if (n >= THRESH) {
+    keyiqst(base, max);
+    hi = base + THRESH;
+  }
+  else 
+    hi = max;
+
+  for (j = lo = base; lo++ < hi;) {
+    if (j->key > lo->key)
+      j = lo;
+  }
+  if (j != base) { /* swap j into place */
+    c = *base;
+    *base = *j;
+    *j = c;
+  }
+
+  for (min = base; (hi = min += 1) < max;) {
+    while ((--hi)->key > min->key);
+    if ((hi += 1) != min) {
+      for (lo = min + 1; --lo >= min;) {
+	c = *lo;
+	for (i = j = lo; (j -= 1) >= hi; i = j)
+	   *i = *j;
+	*i = c;
+      }
+    }
+  }
+
+  /* Sanity check */
+  { 
+    int i;
+    for (i=0; i<n-1; i++)
+      if (base[i].key > base[i+1].key)
+        printf("Something went wrong!\n");
+  }
+}
+
+
+static void keyiqst(KeyValueType *base, KeyValueType *max)
+{
+  register KeyValueType *i;
+  register KeyValueType *j;
+  register KeyValueType *jj;
+  register KeyValueType *mid;
+  register KeyValueType c;
+  KeyValueType *tmp;
+  int lo;
+  int hi;
+
+  lo = (max - base)>>1;		/* number of elements as KeyValueType */
+  do {
+    mid = base + ((unsigned) lo>>1);
+    if (lo >= MTHRESH) {
+      j = (base->key > mid->key ? base : mid);
+      tmp = max - 1;
+      if (j->key > tmp->key) {
+        j = (j == base ? mid : base); /* switch to first loser */
+        if (j->key < tmp->key)
+          j = tmp;
+      }
+
+      if (j != mid) {  /* SWAP */ 
+        c = *mid;
+        *mid = *j;
+        *j = c;
+      }
+    }
+
+    /* Semi-standard quicksort partitioning/swapping */
+    for (i = base, j = max - 1;;) {
+      while (i < mid && i->key <= mid->key)
+        i++;
+      while (j > mid) {
+        if (mid->key <= j->key) {
+          j--;
+          continue;
+        }
+        tmp = i + 1;	/* value of i after swap */
+        if (i == mid) 	/* j <-> mid, new mid is j */
+          mid = jj = j;
+        else 		/* i <-> j */
+          jj = j--;
+        goto swap;
+      }
+
+      if (i == mid) 
+	break;
+      else {		/* i <-> mid, new mid is i */
+        jj = mid;
+        tmp = mid = i;	/* value of i after swap */
+        j--;
+      }
+swap:
+      c = *i;
+      *i = *jj;
+      *jj = c;
+      i = tmp;
+    }
+
+    i = (j = mid) + 1;
+    if ((lo = (j - base)>>1) <= (hi = (max - i)>>1)) {
+      if (lo >= THRESH)
+        keyiqst(base, j);
+      base = i;
+      lo = hi;
+    }
+    else {
+      if (hi >= THRESH)
+        keyiqst(i, max);
+      max = j;
+    }
+  } while (lo >= THRESH);
+}
+
+
+
+
+/*************************************************************************
+* Entry point of KeyVal increasing sort, BOTH key and val part
+**************************************************************************/
+void ikeyvalsort(int n, KeyValueType *base)
+{
+  register KeyValueType *i;
+  register KeyValueType *j;
+  register KeyValueType *lo;
+  register KeyValueType *hi;
+  register KeyValueType *min;
+  register KeyValueType c;
+  KeyValueType *max;
+
+  if (n <= 1)
+    return;
+
+  max = base + n;
+
+  if (n >= THRESH) {
+    keyvaliqst(base, max);
+    hi = base + THRESH;
+  }
+  else 
+    hi = max;
+
+  for (j = lo = base; lo++ < hi;) {
+    if ((j->key > lo->key) || (j->key == lo->key && j->val > lo->val))
+      j = lo;
+  }
+  if (j != base) { /* swap j into place */
+    c = *base;
+    *base = *j;
+    *j = c;
+  }
+
+  for (min = base; (hi = min += 1) < max;) {
+    while ((--hi)->key > min->key || (hi->key == min->key && hi->val > min->val));
+    if ((hi += 1) != min) {
+      for (lo = min + 1; --lo >= min;) {
+	c = *lo;
+	for (i = j = lo; (j -= 1) >= hi; i = j)
+	   *i = *j;
+	*i = c;
+      }
+    }
+  }
+}
+
+
+static void keyvaliqst(KeyValueType *base, KeyValueType *max)
+{
+  register KeyValueType *i;
+  register KeyValueType *j;
+  register KeyValueType *jj;
+  register KeyValueType *mid;
+  register KeyValueType c;
+  KeyValueType *tmp;
+  int lo;
+  int hi;
+
+  lo = (max - base)>>1;		/* number of elements as KeyValueType */
+  do {
+    mid = base + ((unsigned) lo>>1);
+    if (lo >= MTHRESH) {
+      j = (base->key > mid->key || (base->key == mid->key && base->val > mid->val) ? base : mid);
+      tmp = max - 1;
+      if (j->key > tmp->key || (j->key == tmp->key && j->val > tmp->val)) {
+        j = (j == base ? mid : base); /* switch to first loser */
+        if (j->key < tmp->key || (j->key == tmp->key && j->val < tmp->val))
+          j = tmp;
+      }
+
+      if (j != mid) {  /* SWAP */ 
+        c = *mid;
+        *mid = *j;
+        *j = c;
+      }
+    }
+
+    /* Semi-standard quicksort partitioning/swapping */
+    for (i = base, j = max - 1;;) {
+      while (i < mid && (i->key < mid->key || (i->key == mid->key && i->val <= mid->val)))
+        i++;
+      while (j > mid) {
+        if (mid->key < j->key || (mid->key == j->key && mid->val <= j->val)) {
+          j--;
+          continue;
+        }
+        tmp = i + 1;	/* value of i after swap */
+        if (i == mid) 	/* j <-> mid, new mid is j */
+          mid = jj = j;
+        else 		/* i <-> j */
+          jj = j--;
+        goto swap;
+      }
+
+      if (i == mid) 
+	break;
+      else {		/* i <-> mid, new mid is i */
+        jj = mid;
+        tmp = mid = i;	/* value of i after swap */
+        j--;
+      }
+swap:
+      c = *i;
+      *i = *jj;
+      *jj = c;
+      i = tmp;
+    }
+
+    i = (j = mid) + 1;
+    if ((lo = (j - base)>>1) <= (hi = (max - i)>>1)) {
+      if (lo >= THRESH)
+        keyvaliqst(base, j);
+      base = i;
+      lo = hi;
+    }
+    else {
+      if (hi >= THRESH)
+        keyvaliqst(i, max);
+      max = j;
+    }
+  } while (lo >= THRESH);
+}
Index: /inundation/pymetis/metis-4.0/Lib/ometis.c
===================================================================
--- /inundation/pymetis/metis-4.0/Lib/ometis.c	(revision 2051)
+++ /inundation/pymetis/metis-4.0/Lib/ometis.c	(revision 2051)
@@ -0,0 +1,764 @@
+/*
+ * Copyright 1997, Regents of the University of Minnesota
+ *
+ * ometis.c
+ *
+ * This file contains the top level routines for the multilevel recursive
+ * bisection algorithm PMETIS.
+ *
+ * Started 7/24/97
+ * George
+ *
+ * $Id: ometis.c,v 1.1 1998/11/27 17:59:27 karypis Exp $
+ *
+ */
+
+#include <metis.h>
+
+
+/*************************************************************************
+* This function is the entry point for OEMETIS
+**************************************************************************/
+void METIS_EdgeND(int *nvtxs, idxtype *xadj, idxtype *adjncy, int *numflag, int *options, 
+                  idxtype *perm, idxtype *iperm) 
+{
+  int i, j;
+  GraphType graph;
+  CtrlType ctrl;
+
+  if (*numflag == 1)
+    Change2CNumbering(*nvtxs, xadj, adjncy);
+
+  SetUpGraph(&graph, OP_OEMETIS, *nvtxs, 1, xadj, adjncy, NULL, NULL, 0);
+
+  if (options[0] == 0) {  /* Use the default parameters */
+    ctrl.CType = OEMETIS_CTYPE;
+    ctrl.IType = OEMETIS_ITYPE;
+    ctrl.RType = OEMETIS_RTYPE;
+    ctrl.dbglvl = OEMETIS_DBGLVL;
+  }
+  else {
+    ctrl.CType = options[OPTION_CTYPE];
+    ctrl.IType = options[OPTION_ITYPE];
+    ctrl.RType = options[OPTION_RTYPE];
+    ctrl.dbglvl = options[OPTION_DBGLVL];
+  }
+  ctrl.oflags  = 0;
+  ctrl.pfactor = -1;
+  ctrl.nseps   = 1;
+
+  ctrl.optype = OP_OEMETIS;
+  ctrl.CoarsenTo = 20;
+  ctrl.maxvwgt = 1.5*(idxsum(*nvtxs, graph.vwgt)/ctrl.CoarsenTo);
+
+  InitRandom(-1);
+
+  AllocateWorkSpace(&ctrl, &graph, 2);
+
+  IFSET(ctrl.dbglvl, DBG_TIME, InitTimers(&ctrl));
+  IFSET(ctrl.dbglvl, DBG_TIME, starttimer(ctrl.TotalTmr));
+
+  MlevelNestedDissection(&ctrl, &graph, iperm, ORDER_UNBALANCE_FRACTION, *nvtxs);
+
+  IFSET(ctrl.dbglvl, DBG_TIME, stoptimer(ctrl.TotalTmr));
+  IFSET(ctrl.dbglvl, DBG_TIME, PrintTimers(&ctrl));
+
+  for (i=0; i<*nvtxs; i++)
+    perm[iperm[i]] = i;
+
+  FreeWorkSpace(&ctrl, &graph);
+
+  if (*numflag == 1)
+    Change2FNumberingOrder(*nvtxs, xadj, adjncy, perm, iperm);
+}
+
+
+/*************************************************************************
+* This function is the entry point for ONCMETIS
+**************************************************************************/
+void METIS_NodeND(int *nvtxs, idxtype *xadj, idxtype *adjncy, int *numflag, int *options, 
+                  idxtype *perm, idxtype *iperm) 
+{
+  int i, ii, j, l, wflag, nflag;
+  GraphType graph;
+  CtrlType ctrl;
+  idxtype *cptr, *cind, *piperm;
+
+  if (*numflag == 1)
+    Change2CNumbering(*nvtxs, xadj, adjncy);
+
+  if (options[0] == 0) {  /* Use the default parameters */
+    ctrl.CType   = ONMETIS_CTYPE;
+    ctrl.IType   = ONMETIS_ITYPE;
+    ctrl.RType   = ONMETIS_RTYPE;
+    ctrl.dbglvl  = ONMETIS_DBGLVL;
+    ctrl.oflags  = ONMETIS_OFLAGS;
+    ctrl.pfactor = ONMETIS_PFACTOR;
+    ctrl.nseps   = ONMETIS_NSEPS;
+  }
+  else {
+    ctrl.CType   = options[OPTION_CTYPE];
+    ctrl.IType   = options[OPTION_ITYPE];
+    ctrl.RType   = options[OPTION_RTYPE];
+    ctrl.dbglvl  = options[OPTION_DBGLVL];
+    ctrl.oflags  = options[OPTION_OFLAGS];
+    ctrl.pfactor = options[OPTION_PFACTOR];
+    ctrl.nseps   = options[OPTION_NSEPS];
+  }
+  if (ctrl.nseps < 1)
+    ctrl.nseps = 1;
+
+  ctrl.optype = OP_ONMETIS;
+  ctrl.CoarsenTo = 100;
+
+  IFSET(ctrl.dbglvl, DBG_TIME, InitTimers(&ctrl));
+  IFSET(ctrl.dbglvl, DBG_TIME, starttimer(ctrl.TotalTmr));
+
+  InitRandom(-1);
+
+  if (ctrl.pfactor > 0) { 
+    /*============================================================
+    * Prune the dense columns
+    ==============================================================*/
+    piperm = idxmalloc(*nvtxs, "ONMETIS: piperm");
+
+    PruneGraph(&ctrl, &graph, *nvtxs, xadj, adjncy, piperm, (float)(0.1*ctrl.pfactor));
+  }
+  else if (ctrl.oflags&OFLAG_COMPRESS) {
+    /*============================================================
+    * Compress the graph 
+    ==============================================================*/
+    cptr = idxmalloc(*nvtxs+1, "ONMETIS: cptr");
+    cind = idxmalloc(*nvtxs, "ONMETIS: cind");
+
+    CompressGraph(&ctrl, &graph, *nvtxs, xadj, adjncy, cptr, cind);
+
+    if (graph.nvtxs >= COMPRESSION_FRACTION*(*nvtxs)) {
+      ctrl.oflags--; /* We actually performed no compression */
+      GKfree(&cptr, &cind, LTERM);
+    }
+    else if (2*graph.nvtxs < *nvtxs && ctrl.nseps == 1)
+      ctrl.nseps = 2;
+  }
+  else {
+    SetUpGraph(&graph, OP_ONMETIS, *nvtxs, 1, xadj, adjncy, NULL, NULL, 0);
+  }
+
+
+  /*=============================================================
+  * Do the nested dissection ordering 
+  --=============================================================*/
+  ctrl.maxvwgt = 1.5*(idxsum(graph.nvtxs, graph.vwgt)/ctrl.CoarsenTo);
+  AllocateWorkSpace(&ctrl, &graph, 2);
+
+  if (ctrl.oflags&OFLAG_CCMP) 
+    MlevelNestedDissectionCC(&ctrl, &graph, iperm, ORDER_UNBALANCE_FRACTION, graph.nvtxs);
+  else
+    MlevelNestedDissection(&ctrl, &graph, iperm, ORDER_UNBALANCE_FRACTION, graph.nvtxs);
+
+  FreeWorkSpace(&ctrl, &graph);
+
+  if (ctrl.pfactor > 0) { /* Order any prunned vertices */
+    if (graph.nvtxs < *nvtxs) { 
+      idxcopy(graph.nvtxs, iperm, perm);  /* Use perm as an auxiliary array */
+      for (i=0; i<graph.nvtxs; i++)
+        iperm[piperm[i]] = perm[i];
+      for (i=graph.nvtxs; i<*nvtxs; i++)
+        iperm[piperm[i]] = i;
+    }
+
+    GKfree(&piperm, LTERM);
+  }
+  else if (ctrl.oflags&OFLAG_COMPRESS) { /* Uncompress the ordering */
+    if (graph.nvtxs < COMPRESSION_FRACTION*(*nvtxs)) { 
+      /* construct perm from iperm */
+      for (i=0; i<graph.nvtxs; i++)
+        perm[iperm[i]] = i; 
+      for (l=ii=0; ii<graph.nvtxs; ii++) {
+        i = perm[ii];
+        for (j=cptr[i]; j<cptr[i+1]; j++)
+          iperm[cind[j]] = l++;
+      }
+    }
+
+    GKfree(&cptr, &cind, LTERM);
+  }
+
+
+  for (i=0; i<*nvtxs; i++)
+    perm[iperm[i]] = i;
+
+  IFSET(ctrl.dbglvl, DBG_TIME, stoptimer(ctrl.TotalTmr));
+  IFSET(ctrl.dbglvl, DBG_TIME, PrintTimers(&ctrl));
+
+  if (*numflag == 1)
+    Change2FNumberingOrder(*nvtxs, xadj, adjncy, perm, iperm);
+
+}
+
+
+/*************************************************************************
+* This function is the entry point for ONWMETIS. It requires weights on the
+* vertices. It is for the case that the matrix has been pre-compressed.
+**************************************************************************/
+void METIS_NodeWND(int *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, int *numflag, 
+                   int *options, idxtype *perm, idxtype *iperm) 
+{
+  int i, j, tvwgt;
+  GraphType graph;
+  CtrlType ctrl;
+
+  if (*numflag == 1)
+    Change2CNumbering(*nvtxs, xadj, adjncy);
+
+  SetUpGraph(&graph, OP_ONMETIS, *nvtxs, 1, xadj, adjncy, vwgt, NULL, 2);
+
+  if (options[0] == 0) {  /* Use the default parameters */
+    ctrl.CType = ONMETIS_CTYPE;
+    ctrl.IType = ONMETIS_ITYPE;
+    ctrl.RType = ONMETIS_RTYPE;
+    ctrl.dbglvl = ONMETIS_DBGLVL;
+  }
+  else {
+    ctrl.CType = options[OPTION_CTYPE];
+    ctrl.IType = options[OPTION_ITYPE];
+    ctrl.RType = options[OPTION_RTYPE];
+    ctrl.dbglvl = options[OPTION_DBGLVL];
+  }
+
+  ctrl.oflags  = OFLAG_COMPRESS;
+  ctrl.pfactor = 0;
+  ctrl.nseps = 2;
+  ctrl.optype = OP_ONMETIS;
+  ctrl.CoarsenTo = 100;
+  ctrl.maxvwgt = 1.5*(idxsum(*nvtxs, graph.vwgt)/ctrl.CoarsenTo);
+
+  InitRandom(-1);
+
+  AllocateWorkSpace(&ctrl, &graph, 2);
+
+  IFSET(ctrl.dbglvl, DBG_TIME, InitTimers(&ctrl));
+  IFSET(ctrl.dbglvl, DBG_TIME, starttimer(ctrl.TotalTmr));
+
+  MlevelNestedDissection(&ctrl, &graph, iperm, ORDER_UNBALANCE_FRACTION, *nvtxs);
+
+  IFSET(ctrl.dbglvl, DBG_TIME, stoptimer(ctrl.TotalTmr));
+  IFSET(ctrl.dbglvl, DBG_TIME, PrintTimers(&ctrl));
+
+  for (i=0; i<*nvtxs; i++)
+    perm[iperm[i]] = i;
+
+  FreeWorkSpace(&ctrl, &graph);
+
+  if (*numflag == 1)
+    Change2FNumberingOrder(*nvtxs, xadj, adjncy, perm, iperm);
+}
+
+
+
+
+/*************************************************************************
+* This function takes a graph and produces a bisection of it
+**************************************************************************/
+void MlevelNestedDissection(CtrlType *ctrl, GraphType *graph, idxtype *order, float ubfactor, int lastvtx)
+{
+  int i, j, nvtxs, nbnd, tvwgt, tpwgts2[2];
+  idxtype *label, *bndind;
+  GraphType lgraph, rgraph;
+
+  nvtxs = graph->nvtxs;
+
+  /* Determine the weights of the partitions */
+  tvwgt = idxsum(nvtxs, graph->vwgt);
+  tpwgts2[0] = tvwgt/2;
+  tpwgts2[1] = tvwgt-tpwgts2[0];
+
+  switch (ctrl->optype) {
+    case OP_OEMETIS:
+      MlevelEdgeBisection(ctrl, graph, tpwgts2, ubfactor);
+
+      IFSET(ctrl->dbglvl, DBG_TIME, starttimer(ctrl->SepTmr));
+      ConstructMinCoverSeparator(ctrl, graph, ubfactor);
+      IFSET(ctrl->dbglvl, DBG_TIME, stoptimer(ctrl->SepTmr));
+
+      break;
+    case OP_ONMETIS:
+      MlevelNodeBisectionMultiple(ctrl, graph, tpwgts2, ubfactor);
+
+      IFSET(ctrl->dbglvl, DBG_SEPINFO, printf("Nvtxs: %6d, [%6d %6d %6d]\n", graph->nvtxs, graph->pwgts[0], graph->pwgts[1], graph->pwgts[2]));
+
+      break;
+  }
+
+  /* Order the nodes in the separator */
+  nbnd = graph->nbnd;
+  bndind = graph->bndind;
+  label = graph->label;
+  for (i=0; i<nbnd; i++) 
+    order[label[bndind[i]]] = --lastvtx;
+
+  SplitGraphOrder(ctrl, graph, &lgraph, &rgraph);
+
+  /* Free the memory of the top level graph */
+  GKfree(&graph->gdata, &graph->rdata, &graph->label, LTERM);
+
+  if (rgraph.nvtxs > MMDSWITCH) 
+    MlevelNestedDissection(ctrl, &rgraph, order, ubfactor, lastvtx);
+  else {
+    MMDOrder(ctrl, &rgraph, order, lastvtx); 
+    GKfree(&rgraph.gdata, &rgraph.rdata, &rgraph.label, LTERM);
+  }
+  if (lgraph.nvtxs > MMDSWITCH) 
+    MlevelNestedDissection(ctrl, &lgraph, order, ubfactor, lastvtx-rgraph.nvtxs);
+  else {
+    MMDOrder(ctrl, &lgraph, order, lastvtx-rgraph.nvtxs); 
+    GKfree(&lgraph.gdata, &lgraph.rdata, &lgraph.label, LTERM);
+  }
+}
+
+
+/*************************************************************************
+* This function takes a graph and produces a bisection of it
+**************************************************************************/
+void MlevelNestedDissectionCC(CtrlType *ctrl, GraphType *graph, idxtype *order, float ubfactor, int lastvtx)
+{
+  int i, j, nvtxs, nbnd, tvwgt, tpwgts2[2], nsgraphs, ncmps, rnvtxs;
+  idxtype *label, *bndind;
+  idxtype *cptr, *cind;
+  GraphType *sgraphs;
+
+  nvtxs = graph->nvtxs;
+
+  /* Determine the weights of the partitions */
+  tvwgt = idxsum(nvtxs, graph->vwgt);
+  tpwgts2[0] = tvwgt/2;
+  tpwgts2[1] = tvwgt-tpwgts2[0];
+
+  MlevelNodeBisectionMultiple(ctrl, graph, tpwgts2, ubfactor);
+  IFSET(ctrl->dbglvl, DBG_SEPINFO, printf("Nvtxs: %6d, [%6d %6d %6d]\n", graph->nvtxs, graph->pwgts[0], graph->pwgts[1], graph->pwgts[2]));
+
+  /* Order the nodes in the separator */
+  nbnd = graph->nbnd;
+  bndind = graph->bndind;
+  label = graph->label;
+  for (i=0; i<nbnd; i++) 
+    order[label[bndind[i]]] = --lastvtx;
+
+  cptr = idxmalloc(nvtxs, "MlevelNestedDissectionCC: cptr");
+  cind = idxmalloc(nvtxs, "MlevelNestedDissectionCC: cind");
+  ncmps = FindComponents(ctrl, graph, cptr, cind);
+
+/*
+  if (ncmps > 2)
+    printf("[%5d] has %3d components\n", nvtxs, ncmps);
+*/
+
+  sgraphs = (GraphType *)GKmalloc(ncmps*sizeof(GraphType), "MlevelNestedDissectionCC: sgraphs");
+
+  nsgraphs = SplitGraphOrderCC(ctrl, graph, sgraphs, ncmps, cptr, cind);
+
+  GKfree(&cptr, &cind, LTERM);
+
+  /* Free the memory of the top level graph */
+  GKfree(&graph->gdata, &graph->rdata, &graph->label, LTERM);
+
+  /* Go and process the subgraphs */
+  for (rnvtxs=i=0; i<nsgraphs; i++) {
+    if (sgraphs[i].adjwgt == NULL) {
+      MMDOrder(ctrl, sgraphs+i, order, lastvtx-rnvtxs);
+      GKfree(&sgraphs[i].gdata, &sgraphs[i].label, LTERM);
+    }
+    else {
+      MlevelNestedDissectionCC(ctrl, sgraphs+i, order, ubfactor, lastvtx-rnvtxs);
+    }
+    rnvtxs += sgraphs[i].nvtxs;
+  }
+
+  free(sgraphs);
+}
+
+
+
+/*************************************************************************
+* This function performs multilevel bisection. It performs multiple 
+* bisections and selects the best.
+**************************************************************************/
+void MlevelNodeBisectionMultiple(CtrlType *ctrl, GraphType *graph, int *tpwgts, float ubfactor)
+{
+  int i, nvtxs, cnvtxs, mincut, tmp;
+  GraphType *cgraph; 
+  idxtype *bestwhere;
+
+  if (ctrl->nseps == 1 || graph->nvtxs < (ctrl->oflags&OFLAG_COMPRESS ? 1000 : 2000)) {
+    MlevelNodeBisection(ctrl, graph, tpwgts, ubfactor);
+    return;
+  }
+
+  nvtxs = graph->nvtxs;
+
+  if (ctrl->oflags&OFLAG_COMPRESS) { /* Multiple separators at the original graph */
+    bestwhere = idxmalloc(nvtxs, "MlevelNodeBisection2: bestwhere");
+    mincut = nvtxs;
+
+    for (i=ctrl->nseps; i>0; i--) {
+      MlevelNodeBisection(ctrl, graph, tpwgts, ubfactor);
+
+      /* printf("%5d ", cgraph->mincut); */
+
+      if (graph->mincut < mincut) {
+        mincut = graph->mincut;
+        idxcopy(nvtxs, graph->where, bestwhere);
+      }
+
+      GKfree(&graph->rdata, LTERM);
+    
+      if (mincut == 0)
+        break;
+    }
+    /* printf("[%5d]\n", mincut); */
+
+    Allocate2WayNodePartitionMemory(ctrl, graph);
+    idxcopy(nvtxs, bestwhere, graph->where);
+    free(bestwhere);
+
+    Compute2WayNodePartitionParams(ctrl, graph);
+  }
+  else {  /* Coarsen it a bit */
+    ctrl->CoarsenTo = nvtxs-1;
+
+    cgraph = Coarsen2Way(ctrl, graph);
+
+    cnvtxs = cgraph->nvtxs;
+
+    bestwhere = idxmalloc(cnvtxs, "MlevelNodeBisection2: bestwhere");
+    mincut = nvtxs;
+
+    for (i=ctrl->nseps; i>0; i--) {
+      ctrl->CType += 20; /* This is a hack. Look at coarsen.c */
+      MlevelNodeBisection(ctrl, cgraph, tpwgts, ubfactor);
+
+      /* printf("%5d ", cgraph->mincut); */
+
+      if (cgraph->mincut < mincut) {
+        mincut = cgraph->mincut;
+        idxcopy(cnvtxs, cgraph->where, bestwhere);
+      }
+
+      GKfree(&cgraph->rdata, LTERM);
+    
+      if (mincut == 0)
+        break;
+    }
+    /* printf("[%5d]\n", mincut); */
+
+    Allocate2WayNodePartitionMemory(ctrl, cgraph);
+    idxcopy(cnvtxs, bestwhere, cgraph->where);
+    free(bestwhere);
+
+    Compute2WayNodePartitionParams(ctrl, cgraph);
+
+    Refine2WayNode(ctrl, graph, cgraph, ubfactor);
+  }
+
+}
+
+/*************************************************************************
+* This function performs multilevel bisection
+**************************************************************************/
+void MlevelNodeBisection(CtrlType *ctrl, GraphType *graph, int *tpwgts, float ubfactor)
+{
+  GraphType *cgraph;
+
+  ctrl->CoarsenTo = graph->nvtxs/8;
+  if (ctrl->CoarsenTo > 100)
+    ctrl->CoarsenTo = 100;
+  else if (ctrl->CoarsenTo < 40)
+    ctrl->CoarsenTo = 40;
+  ctrl->maxvwgt = 1.5*((tpwgts[0]+tpwgts[1])/ctrl->CoarsenTo);
+
+  cgraph = Coarsen2Way(ctrl, graph);
+
+  switch (ctrl->IType) {
+    case IPART_GGPKL:
+      Init2WayPartition(ctrl, cgraph, tpwgts, ubfactor);
+
+      IFSET(ctrl->dbglvl, DBG_TIME, starttimer(ctrl->SepTmr));
+
+      Compute2WayPartitionParams(ctrl, cgraph);
+      ConstructSeparator(ctrl, cgraph, ubfactor);
+
+      IFSET(ctrl->dbglvl, DBG_TIME, stoptimer(ctrl->SepTmr));
+      break;
+    case IPART_GGPKLNODE:
+      InitSeparator(ctrl, cgraph, ubfactor);
+      break;
+  }
+
+  Refine2WayNode(ctrl, graph, cgraph, ubfactor);
+
+}
+
+
+
+
+/*************************************************************************
+* This function takes a graph and a bisection and splits it into two graphs.
+* This function relies on the fact that adjwgt is all equal to 1.
+**************************************************************************/
+void SplitGraphOrder(CtrlType *ctrl, GraphType *graph, GraphType *lgraph, GraphType *rgraph)
+{
+  int i, ii, j, k, l, istart, iend, mypart, nvtxs, snvtxs[3], snedges[3];
+  idxtype *xadj, *vwgt, *adjncy, *adjwgt, *adjwgtsum, *label, *where, *bndptr, *bndind;
+  idxtype *sxadj[2], *svwgt[2], *sadjncy[2], *sadjwgt[2], *sadjwgtsum[2], *slabel[2];
+  idxtype *rename;
+  idxtype *auxadjncy, *auxadjwgt;
+
+  IFSET(ctrl->dbglvl, DBG_TIME, starttimer(ctrl->SplitTmr));
+
+  nvtxs = graph->nvtxs;
+  xadj = graph->xadj;
+  vwgt = graph->vwgt;
+  adjncy = graph->adjncy;
+  adjwgt = graph->adjwgt;
+  adjwgtsum = graph->adjwgtsum;
+  label = graph->label;
+  where = graph->where;
+  bndptr = graph->bndptr;
+  bndind = graph->bndind;
+  ASSERT(bndptr != NULL);
+
+  rename = idxwspacemalloc(ctrl, nvtxs);
+  
+  snvtxs[0] = snvtxs[1] = snvtxs[2] = snedges[0] = snedges[1] = snedges[2] = 0;
+  for (i=0; i<nvtxs; i++) {
+    k = where[i];
+    rename[i] = snvtxs[k]++;
+    snedges[k] += xadj[i+1]-xadj[i];
+  }
+
+  SetUpSplitGraph(graph, lgraph, snvtxs[0], snedges[0]);
+  sxadj[0] = lgraph->xadj;
+  svwgt[0] = lgraph->vwgt;
+  sadjwgtsum[0] = lgraph->adjwgtsum;
+  sadjncy[0] = lgraph->adjncy; 
+  sadjwgt[0] = lgraph->adjwgt; 
+  slabel[0] = lgraph->label;
+
+  SetUpSplitGraph(graph, rgraph, snvtxs[1], snedges[1]);
+  sxadj[1] = rgraph->xadj;
+  svwgt[1] = rgraph->vwgt;
+  sadjwgtsum[1] = rgraph->adjwgtsum;
+  sadjncy[1] = rgraph->adjncy; 
+  sadjwgt[1] = rgraph->adjwgt; 
+  slabel[1] = rgraph->label;
+
+  /* Go and use bndptr to also mark the boundary nodes in the two partitions */
+  for (ii=0; ii<graph->nbnd; ii++) {
+    i = bndind[ii];
+    for (j=xadj[i]; j<xadj[i+1]; j++)
+      bndptr[adjncy[j]] = 1;
+  }
+
+  snvtxs[0] = snvtxs[1] = snedges[0] = snedges[1] = 0;
+  sxadj[0][0] = sxadj[1][0] = 0;
+  for (i=0; i<nvtxs; i++) {
+    if ((mypart = where[i]) == 2)
+      continue;
+
+    istart = xadj[i];
+    iend = xadj[i+1];
+    if (bndptr[i] == -1) { /* This is an interior vertex */
+      auxadjncy = sadjncy[mypart] + snedges[mypart] - istart;
+      for(j=istart; j<iend; j++) 
+        auxadjncy[j] = adjncy[j];
+      snedges[mypart] += iend-istart;
+    }
+    else {
+      auxadjncy = sadjncy[mypart];
+      l = snedges[mypart];
+      for (j=istart; j<iend; j++) {
+        k = adjncy[j];
+        if (where[k] == mypart) 
+          auxadjncy[l++] = k;
+      }
+      snedges[mypart] = l;
+    }
+
+    svwgt[mypart][snvtxs[mypart]] = vwgt[i];
+    sadjwgtsum[mypart][snvtxs[mypart]] = snedges[mypart]-sxadj[mypart][snvtxs[mypart]];
+    slabel[mypart][snvtxs[mypart]] = label[i];
+    sxadj[mypart][++snvtxs[mypart]] = snedges[mypart];
+  }
+
+  for (mypart=0; mypart<2; mypart++) {
+    iend = snedges[mypart];
+    idxset(iend, 1, sadjwgt[mypart]);
+
+    auxadjncy = sadjncy[mypart];
+    for (i=0; i<iend; i++) 
+      auxadjncy[i] = rename[auxadjncy[i]];
+  }
+
+  lgraph->nvtxs = snvtxs[0];
+  lgraph->nedges = snedges[0];
+  rgraph->nvtxs = snvtxs[1];
+  rgraph->nedges = snedges[1];
+
+  IFSET(ctrl->dbglvl, DBG_TIME, stoptimer(ctrl->SplitTmr));
+
+  idxwspacefree(ctrl, nvtxs);
+
+}
+
+/*************************************************************************
+* This function uses MMD to order the graph. The vertices are numbered
+* from lastvtx downwards
+**************************************************************************/
+void MMDOrder(CtrlType *ctrl, GraphType *graph, idxtype *order, int lastvtx)
+{
+  int i, j, k, nvtxs, nofsub, firstvtx;
+  idxtype *xadj, *adjncy, *label;
+  idxtype *perm, *iperm, *head, *qsize, *list, *marker;
+
+  nvtxs = graph->nvtxs;
+  xadj = graph->xadj;
+  adjncy = graph->adjncy;
+
+  /* Relabel the vertices so that it starts from 1 */
+  k = xadj[nvtxs];
+  for (i=0; i<k; i++)
+    adjncy[i]++;
+  for (i=0; i<nvtxs+1; i++)
+    xadj[i]++;
+
+  perm = idxmalloc(6*(nvtxs+5), "MMDOrder: perm");
+  iperm = perm + nvtxs + 5;
+  head = iperm + nvtxs + 5;
+  qsize = head + nvtxs + 5;
+  list = qsize + nvtxs + 5;
+  marker = list + nvtxs + 5;
+
+  genmmd(nvtxs, xadj, adjncy, iperm, perm, 1, head, qsize, list, marker, MAXIDX, &nofsub);
+
+  label = graph->label;
+  firstvtx = lastvtx-nvtxs;
+  for (i=0; i<nvtxs; i++)
+    order[label[i]] = firstvtx+iperm[i]-1;
+
+  free(perm);
+
+  /* Relabel the vertices so that it starts from 0 */
+  for (i=0; i<nvtxs+1; i++)
+    xadj[i]--;
+  k = xadj[nvtxs];
+  for (i=0; i<k; i++)
+    adjncy[i]--;
+}
+
+
+/*************************************************************************
+* This function takes a graph and a bisection and splits it into two graphs.
+* It relies on the fact that adjwgt is all set to 1.
+**************************************************************************/
+int SplitGraphOrderCC(CtrlType *ctrl, GraphType *graph, GraphType *sgraphs, int ncmps, idxtype *cptr, idxtype *cind)
+{
+  int i, ii, iii, j, k, l, istart, iend, mypart, nvtxs, snvtxs, snedges;
+  idxtype *xadj, *vwgt, *adjncy, *adjwgt, *adjwgtsum, *label, *where, *bndptr, *bndind;
+  idxtype *sxadj, *svwgt, *sadjncy, *sadjwgt, *sadjwgtsum, *slabel;
+  idxtype *rename;
+  idxtype *auxadjncy, *auxadjwgt;
+
+  IFSET(ctrl->dbglvl, DBG_TIME, starttimer(ctrl->SplitTmr));
+
+  nvtxs = graph->nvtxs;
+  xadj = graph->xadj;
+  vwgt = graph->vwgt;
+  adjncy = graph->adjncy;
+  adjwgt = graph->adjwgt;
+  adjwgtsum = graph->adjwgtsum;
+  label = graph->label;
+  where = graph->where;
+  bndptr = graph->bndptr;
+  bndind = graph->bndind;
+  ASSERT(bndptr != NULL);
+
+  /* Go and use bndptr to also mark the boundary nodes in the two partitions */
+  for (ii=0; ii<graph->nbnd; ii++) {
+    i = bndind[ii];
+    for (j=xadj[i]; j<xadj[i+1]; j++)
+      bndptr[adjncy[j]] = 1;
+  }
+
+  rename = idxwspacemalloc(ctrl, nvtxs);
+  
+  /* Go and split the graph a component at a time */
+  for (iii=0; iii<ncmps; iii++) {
+    RandomPermute(cptr[iii+1]-cptr[iii], cind+cptr[iii], 0);
+    snvtxs = snedges = 0;
+    for (j=cptr[iii]; j<cptr[iii+1]; j++) {
+      i = cind[j];
+      rename[i] = snvtxs++;
+      snedges += xadj[i+1]-xadj[i];
+    }
+
+    SetUpSplitGraph(graph, sgraphs+iii, snvtxs, snedges);
+    sxadj = sgraphs[iii].xadj;
+    svwgt = sgraphs[iii].vwgt;
+    sadjwgtsum = sgraphs[iii].adjwgtsum;
+    sadjncy = sgraphs[iii].adjncy;
+    sadjwgt = sgraphs[iii].adjwgt;
+    slabel = sgraphs[iii].label;
+
+    snvtxs = snedges = sxadj[0] = 0;
+    for (ii=cptr[iii]; ii<cptr[iii+1]; ii++) {
+      i = cind[ii];
+
+      istart = xadj[i];
+      iend = xadj[i+1];
+      if (bndptr[i] == -1) { /* This is an interior vertex */
+        auxadjncy = sadjncy + snedges - istart;
+        auxadjwgt = sadjwgt + snedges - istart;
+        for(j=istart; j<iend; j++) 
+          auxadjncy[j] = adjncy[j];
+        snedges += iend-istart;
+      }
+      else {
+        l = snedges;
+        for (j=istart; j<iend; j++) {
+          k = adjncy[j];
+          if (where[k] != 2) 
+            sadjncy[l++] = k;
+        }
+        snedges = l;
+      }
+
+      svwgt[snvtxs] = vwgt[i];
+      sadjwgtsum[snvtxs] = snedges-sxadj[snvtxs];
+      slabel[snvtxs] = label[i];
+      sxadj[++snvtxs] = snedges;
+    }
+
+    idxset(snedges, 1, sadjwgt);
+    for (i=0; i<snedges; i++) 
+      sadjncy[i] = rename[sadjncy[i]];
+
+    sgraphs[iii].nvtxs = snvtxs;
+    sgraphs[iii].nedges = snedges;
+    sgraphs[iii].ncon = 1;
+
+    if (snvtxs < MMDSWITCH)
+      sgraphs[iii].adjwgt = NULL;  /* A marker to call MMD on the driver */
+  }
+
+  IFSET(ctrl->dbglvl, DBG_TIME, stoptimer(ctrl->SplitTmr));
+
+  idxwspacefree(ctrl, nvtxs);
+
+  return ncmps;
+
+}
+
+
+
+
+
Index: /inundation/pymetis/metis-4.0/Lib/parmetis.c
===================================================================
--- /inundation/pymetis/metis-4.0/Lib/parmetis.c	(revision 2051)
+++ /inundation/pymetis/metis-4.0/Lib/parmetis.c	(revision 2051)
@@ -0,0 +1,371 @@
+/*
+ * Copyright 1997, Regents of the University of Minnesota
+ *
+ * parmetis.c
+ *
+ * This file contains top level routines that are used by ParMETIS
+ *
+ * Started 10/14/97
+ * George
+ *
+ * $Id: parmetis.c,v 1.1 1998/11/27 17:59:27 karypis Exp $
+ *
+ */
+
+#include <metis.h>
+
+
+/*************************************************************************
+* This function is the entry point for KMETIS with seed specification
+* in options[7] 
+**************************************************************************/
+void METIS_PartGraphKway2(int *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, 
+                         idxtype *adjwgt, int *wgtflag, int *numflag, int *nparts, 
+                         int *options, int *edgecut, idxtype *part)
+{
+  int i;
+  float *tpwgts;
+
+  tpwgts = fmalloc(*nparts, "KMETIS: tpwgts");
+  for (i=0; i<*nparts; i++) 
+    tpwgts[i] = 1.0/(1.0*(*nparts));
+
+  METIS_WPartGraphKway2(nvtxs, xadj, adjncy, vwgt, adjwgt, wgtflag, numflag, nparts, 
+                       tpwgts, options, edgecut, part);
+
+  free(tpwgts);
+}
+
+
+/*************************************************************************
+* This function is the entry point for KWMETIS with seed specification
+* in options[7] 
+**************************************************************************/
+void METIS_WPartGraphKway2(int *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, 
+                          idxtype *adjwgt, int *wgtflag, int *numflag, int *nparts, 
+                          float *tpwgts, int *options, int *edgecut, idxtype *part)
+{
+  int i, j;
+  GraphType graph;
+  CtrlType ctrl;
+
+  if (*numflag == 1)
+    Change2CNumbering(*nvtxs, xadj, adjncy);
+
+  SetUpGraph(&graph, OP_KMETIS, *nvtxs, 1, xadj, adjncy, vwgt, adjwgt, *wgtflag);
+
+  if (options[0] == 0) {  /* Use the default parameters */
+    ctrl.CType = KMETIS_CTYPE;
+    ctrl.IType = KMETIS_ITYPE;
+    ctrl.RType = KMETIS_RTYPE;
+    ctrl.dbglvl = KMETIS_DBGLVL;
+  }
+  else {
+    ctrl.CType = options[OPTION_CTYPE];
+    ctrl.IType = options[OPTION_ITYPE];
+    ctrl.RType = options[OPTION_RTYPE];
+    ctrl.dbglvl = options[OPTION_DBGLVL];
+  }
+  ctrl.optype = OP_KMETIS;
+  ctrl.CoarsenTo = 20*(*nparts);
+  ctrl.maxvwgt = 1.5*((graph.vwgt ? idxsum(*nvtxs, graph.vwgt) : (*nvtxs))/ctrl.CoarsenTo);
+
+  InitRandom(options[7]);
+
+  AllocateWorkSpace(&ctrl, &graph, *nparts);
+
+  IFSET(ctrl.dbglvl, DBG_TIME, InitTimers(&ctrl));
+  IFSET(ctrl.dbglvl, DBG_TIME, starttimer(ctrl.TotalTmr));
+
+  *edgecut = MlevelKWayPartitioning(&ctrl, &graph, *nparts, part, tpwgts, 1.03);
+
+  IFSET(ctrl.dbglvl, DBG_TIME, stoptimer(ctrl.TotalTmr));
+  IFSET(ctrl.dbglvl, DBG_TIME, PrintTimers(&ctrl));
+
+  FreeWorkSpace(&ctrl, &graph);
+
+  if (*numflag == 1)
+    Change2FNumbering(*nvtxs, xadj, adjncy, part);
+}
+
+
+/*************************************************************************
+* This function is the entry point for the node ND code for ParMETIS
+**************************************************************************/
+void METIS_NodeNDP(int nvtxs, idxtype *xadj, idxtype *adjncy, int npes, 
+                   int *options, idxtype *perm, idxtype *iperm, idxtype *sizes) 
+{
+  int i, ii, j, l, wflag, nflag;
+  GraphType graph;
+  CtrlType ctrl;
+  idxtype *cptr, *cind;
+
+  if (options[0] == 0) {  /* Use the default parameters */
+    ctrl.CType   = ONMETIS_CTYPE;
+    ctrl.IType   = ONMETIS_ITYPE;
+    ctrl.RType   = ONMETIS_RTYPE;
+    ctrl.dbglvl  = ONMETIS_DBGLVL;
+    ctrl.oflags  = ONMETIS_OFLAGS;
+    ctrl.pfactor = ONMETIS_PFACTOR;
+    ctrl.nseps   = ONMETIS_NSEPS;
+  }
+  else {
+    ctrl.CType   = options[OPTION_CTYPE];
+    ctrl.IType   = options[OPTION_ITYPE];
+    ctrl.RType   = options[OPTION_RTYPE];
+    ctrl.dbglvl  = options[OPTION_DBGLVL];
+    ctrl.oflags  = options[OPTION_OFLAGS];
+    ctrl.pfactor = options[OPTION_PFACTOR];
+    ctrl.nseps   = options[OPTION_NSEPS];
+  }
+  if (ctrl.nseps < 1)
+    ctrl.nseps = 1;
+
+  ctrl.optype = OP_ONMETIS;
+  ctrl.CoarsenTo = 100;
+
+  IFSET(ctrl.dbglvl, DBG_TIME, InitTimers(&ctrl));
+  IFSET(ctrl.dbglvl, DBG_TIME, starttimer(ctrl.TotalTmr));
+
+  InitRandom(-1);
+
+  if (ctrl.oflags&OFLAG_COMPRESS) {
+    /*============================================================
+    * Compress the graph 
+    ==============================================================*/
+    cptr = idxmalloc(nvtxs+1, "ONMETIS: cptr");
+    cind = idxmalloc(nvtxs, "ONMETIS: cind");
+
+    CompressGraph(&ctrl, &graph, nvtxs, xadj, adjncy, cptr, cind);
+
+    if (graph.nvtxs >= COMPRESSION_FRACTION*(nvtxs)) {
+      ctrl.oflags--; /* We actually performed no compression */
+      GKfree(&cptr, &cind, LTERM);
+    }
+    else if (2*graph.nvtxs < nvtxs && ctrl.nseps == 1)
+      ctrl.nseps = 2;
+  }
+  else {
+    SetUpGraph(&graph, OP_ONMETIS, nvtxs, 1, xadj, adjncy, NULL, NULL, 0);
+  }
+
+
+  /*=============================================================
+  * Do the nested dissection ordering 
+  --=============================================================*/
+  ctrl.maxvwgt = 1.5*(idxsum(graph.nvtxs, graph.vwgt)/ctrl.CoarsenTo);
+  AllocateWorkSpace(&ctrl, &graph, 2);
+
+  idxset(2*npes-1, 0, sizes);
+  MlevelNestedDissectionP(&ctrl, &graph, iperm, graph.nvtxs, npes, 0, sizes);
+
+  FreeWorkSpace(&ctrl, &graph);
+
+  if (ctrl.oflags&OFLAG_COMPRESS) { /* Uncompress the ordering */
+    if (graph.nvtxs < COMPRESSION_FRACTION*(nvtxs)) { 
+      /* construct perm from iperm */
+      for (i=0; i<graph.nvtxs; i++)
+        perm[iperm[i]] = i; 
+      for (l=ii=0; ii<graph.nvtxs; ii++) {
+        i = perm[ii];
+        for (j=cptr[i]; j<cptr[i+1]; j++)
+          iperm[cind[j]] = l++;
+      }
+    }
+
+    GKfree(&cptr, &cind, LTERM);
+  }
+
+
+  for (i=0; i<nvtxs; i++)
+    perm[iperm[i]] = i;
+
+  IFSET(ctrl.dbglvl, DBG_TIME, stoptimer(ctrl.TotalTmr));
+  IFSET(ctrl.dbglvl, DBG_TIME, PrintTimers(&ctrl));
+
+}
+
+
+
+/*************************************************************************
+* This function takes a graph and produces a bisection of it
+**************************************************************************/
+void MlevelNestedDissectionP(CtrlType *ctrl, GraphType *graph, idxtype *order, int lastvtx, 
+                             int npes, int cpos, idxtype *sizes)
+{
+  int i, j, nvtxs, nbnd, tvwgt, tpwgts2[2];
+  idxtype *label, *bndind;
+  GraphType lgraph, rgraph;
+  float ubfactor;
+
+  nvtxs = graph->nvtxs;
+
+  if (nvtxs == 0) {
+    GKfree(&graph->gdata, &graph->rdata, &graph->label, LTERM);
+    return;
+  }
+
+  /* Determine the weights of the partitions */
+  tvwgt = idxsum(nvtxs, graph->vwgt);
+  tpwgts2[0] = tvwgt/2;
+  tpwgts2[1] = tvwgt-tpwgts2[0];
+
+  if (cpos >= npes-1) 
+    ubfactor = ORDER_UNBALANCE_FRACTION;
+  else 
+    ubfactor = 1.05;
+
+
+  MlevelNodeBisectionMultiple(ctrl, graph, tpwgts2, ubfactor);
+
+  IFSET(ctrl->dbglvl, DBG_SEPINFO, printf("Nvtxs: %6d, [%6d %6d %6d]\n", graph->nvtxs, graph->pwgts[0], graph->pwgts[1], graph->pwgts[2]));
+
+  if (cpos < npes-1) {
+    sizes[2*npes-2-cpos] = graph->pwgts[2];
+    sizes[2*npes-2-(2*cpos+1)] = graph->pwgts[1];
+    sizes[2*npes-2-(2*cpos+2)] = graph->pwgts[0];
+  }
+
+  /* Order the nodes in the separator */
+  nbnd = graph->nbnd;
+  bndind = graph->bndind;
+  label = graph->label;
+  for (i=0; i<nbnd; i++) 
+    order[label[bndind[i]]] = --lastvtx;
+
+  SplitGraphOrder(ctrl, graph, &lgraph, &rgraph);
+
+  /* Free the memory of the top level graph */
+  GKfree(&graph->gdata, &graph->rdata, &graph->label, LTERM);
+
+  if (rgraph.nvtxs > MMDSWITCH || 2*cpos+1 < npes-1) 
+    MlevelNestedDissectionP(ctrl, &rgraph, order, lastvtx, npes, 2*cpos+1, sizes);
+  else {
+    MMDOrder(ctrl, &rgraph, order, lastvtx); 
+    GKfree(&rgraph.gdata, &rgraph.rdata, &rgraph.label, LTERM);
+  }
+  if (lgraph.nvtxs > MMDSWITCH || 2*cpos+2 < npes-1) 
+    MlevelNestedDissectionP(ctrl, &lgraph, order, lastvtx-rgraph.nvtxs, npes, 2*cpos+2, sizes);
+  else {
+    MMDOrder(ctrl, &lgraph, order, lastvtx-rgraph.nvtxs); 
+    GKfree(&lgraph.gdata, &lgraph.rdata, &lgraph.label, LTERM);
+  }
+}
+
+
+
+
+/*************************************************************************
+* This function is the entry point for ONWMETIS. It requires weights on the
+* vertices. It is for the case that the matrix has been pre-compressed.
+**************************************************************************/
+void METIS_NodeComputeSeparator(int *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, 
+           idxtype *adjwgt, int *options, int *sepsize, idxtype *part) 
+{
+  int i, j, tvwgt, tpwgts[2];
+  GraphType graph;
+  CtrlType ctrl;
+
+  SetUpGraph(&graph, OP_ONMETIS, *nvtxs, 1, xadj, adjncy, vwgt, adjwgt, 3);
+  tvwgt = idxsum(*nvtxs, graph.vwgt);
+
+  if (options[0] == 0) {  /* Use the default parameters */
+    ctrl.CType = ONMETIS_CTYPE;
+    ctrl.IType = ONMETIS_ITYPE;
+    ctrl.RType = ONMETIS_RTYPE;
+    ctrl.dbglvl = ONMETIS_DBGLVL;
+  }
+  else {
+    ctrl.CType = options[OPTION_CTYPE];
+    ctrl.IType = options[OPTION_ITYPE];
+    ctrl.RType = options[OPTION_RTYPE];
+    ctrl.dbglvl = options[OPTION_DBGLVL];
+  }
+
+  ctrl.oflags  = 0;
+  ctrl.pfactor = 0;
+  ctrl.nseps = 1;
+  ctrl.optype = OP_ONMETIS;
+  ctrl.CoarsenTo = amin(100, *nvtxs-1);
+  ctrl.maxvwgt = 1.5*tvwgt/ctrl.CoarsenTo;
+
+  InitRandom(options[7]);
+
+  AllocateWorkSpace(&ctrl, &graph, 2);
+
+  /*============================================================
+   * Perform the bisection
+   *============================================================*/ 
+  tpwgts[0] = tvwgt/2;
+  tpwgts[1] = tvwgt-tpwgts[0];
+
+  MlevelNodeBisectionMultiple(&ctrl, &graph, tpwgts, 1.05);
+
+  *sepsize = graph.pwgts[2];
+  idxcopy(*nvtxs, graph.where, part);
+
+  GKfree(&graph.gdata, &graph.rdata, &graph.label, LTERM);
+
+
+  FreeWorkSpace(&ctrl, &graph);
+
+}
+
+
+
+/*************************************************************************
+* This function is the entry point for ONWMETIS. It requires weights on the
+* vertices. It is for the case that the matrix has been pre-compressed.
+**************************************************************************/
+void METIS_EdgeComputeSeparator(int *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, 
+           idxtype *adjwgt, int *options, int *sepsize, idxtype *part) 
+{
+  int i, j, tvwgt, tpwgts[2];
+  GraphType graph;
+  CtrlType ctrl;
+
+  SetUpGraph(&graph, OP_ONMETIS, *nvtxs, 1, xadj, adjncy, vwgt, adjwgt, 3);
+  tvwgt = idxsum(*nvtxs, graph.vwgt);
+
+  if (options[0] == 0) {  /* Use the default parameters */
+    ctrl.CType = ONMETIS_CTYPE;
+    ctrl.IType = ONMETIS_ITYPE;
+    ctrl.RType = ONMETIS_RTYPE;
+    ctrl.dbglvl = ONMETIS_DBGLVL;
+  }
+  else {
+    ctrl.CType = options[OPTION_CTYPE];
+    ctrl.IType = options[OPTION_ITYPE];
+    ctrl.RType = options[OPTION_RTYPE];
+    ctrl.dbglvl = options[OPTION_DBGLVL];
+  }
+
+  ctrl.oflags  = 0;
+  ctrl.pfactor = 0;
+  ctrl.nseps = 1;
+  ctrl.optype = OP_OEMETIS;
+  ctrl.CoarsenTo = amin(100, *nvtxs-1);
+  ctrl.maxvwgt = 1.5*tvwgt/ctrl.CoarsenTo;
+
+  InitRandom(options[7]);
+
+  AllocateWorkSpace(&ctrl, &graph, 2);
+
+  /*============================================================
+   * Perform the bisection
+   *============================================================*/ 
+  tpwgts[0] = tvwgt/2;
+  tpwgts[1] = tvwgt-tpwgts[0];
+
+  MlevelEdgeBisection(&ctrl, &graph, tpwgts, 1.05);
+  ConstructMinCoverSeparator(&ctrl, &graph, 1.05);
+
+  *sepsize = graph.pwgts[2];
+  idxcopy(*nvtxs, graph.where, part);
+
+  GKfree(&graph.gdata, &graph.rdata, &graph.label, LTERM);
+
+
+  FreeWorkSpace(&ctrl, &graph);
+
+}
Index: /inundation/pymetis/metis-4.0/Lib/pmetis.c
===================================================================
--- /inundation/pymetis/metis-4.0/Lib/pmetis.c	(revision 2051)
+++ /inundation/pymetis/metis-4.0/Lib/pmetis.c	(revision 2051)
@@ -0,0 +1,341 @@
+/*
+ * Copyright 1997, Regents of the University of Minnesota
+ *
+ * pmetis.c
+ *
+ * This file contains the top level routines for the multilevel recursive
+ * bisection algorithm PMETIS.
+ *
+ * Started 7/24/97
+ * George
+ *
+ * $Id: pmetis.c,v 1.1 1998/11/27 17:59:28 karypis Exp $
+ *
+ */
+
+#include <metis.h>
+
+
+/*************************************************************************
+* This function is the entry point for PMETIS
+**************************************************************************/
+void METIS_PartGraphRecursive(int *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, 
+                              idxtype *adjwgt, int *wgtflag, int *numflag, int *nparts, 
+                              int *options, int *edgecut, idxtype *part)
+{
+  int i;
+  float *tpwgts;
+
+  tpwgts = fmalloc(*nparts, "KMETIS: tpwgts");
+  for (i=0; i<*nparts; i++) 
+    tpwgts[i] = 1.0/(1.0*(*nparts));
+
+  METIS_WPartGraphRecursive(nvtxs, xadj, adjncy, vwgt, adjwgt, wgtflag, numflag, nparts, 
+                            tpwgts, options, edgecut, part);
+
+  free(tpwgts);
+}
+
+
+
+/*************************************************************************
+* This function is the entry point for PWMETIS that accepts exact weights
+* for the target partitions
+**************************************************************************/
+void METIS_WPartGraphRecursive(int *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, 
+                               idxtype *adjwgt, int *wgtflag, int *numflag, int *nparts, 
+                               float *tpwgts, int *options, int *edgecut, idxtype *part)
+{
+  int i, j;
+  GraphType graph;
+  CtrlType ctrl;
+  float *mytpwgts;
+
+  if (*numflag == 1)
+    Change2CNumbering(*nvtxs, xadj, adjncy);
+
+  SetUpGraph(&graph, OP_PMETIS, *nvtxs, 1, xadj, adjncy, vwgt, adjwgt, *wgtflag);
+
+  if (options[0] == 0) {  /* Use the default parameters */
+    ctrl.CType = PMETIS_CTYPE;
+    ctrl.IType = PMETIS_ITYPE;
+    ctrl.RType = PMETIS_RTYPE;
+    ctrl.dbglvl = PMETIS_DBGLVL;
+  }
+  else {
+    ctrl.CType = options[OPTION_CTYPE];
+    ctrl.IType = options[OPTION_ITYPE];
+    ctrl.RType = options[OPTION_RTYPE];
+    ctrl.dbglvl = options[OPTION_DBGLVL];
+  }
+  ctrl.optype = OP_PMETIS;
+  ctrl.CoarsenTo = 20;
+  ctrl.maxvwgt = 1.5*(idxsum(*nvtxs, graph.vwgt)/ctrl.CoarsenTo);
+
+  mytpwgts = fmalloc(*nparts, "PWMETIS: mytpwgts");
+  for (i=0; i<*nparts; i++) 
+    mytpwgts[i] = tpwgts[i];
+
+  InitRandom(-1);
+
+  AllocateWorkSpace(&ctrl, &graph, *nparts);
+
+  IFSET(ctrl.dbglvl, DBG_TIME, InitTimers(&ctrl));
+  IFSET(ctrl.dbglvl, DBG_TIME, starttimer(ctrl.TotalTmr));
+
+  *edgecut = MlevelRecursiveBisection(&ctrl, &graph, *nparts, part, mytpwgts, 1.000, 0);
+
+  IFSET(ctrl.dbglvl, DBG_TIME, stoptimer(ctrl.TotalTmr));
+  IFSET(ctrl.dbglvl, DBG_TIME, PrintTimers(&ctrl));
+
+  FreeWorkSpace(&ctrl, &graph);
+  free(mytpwgts);
+
+  if (*numflag == 1)
+    Change2FNumbering(*nvtxs, xadj, adjncy, part);
+}
+
+
+
+/*************************************************************************
+* This function takes a graph and produces a bisection of it
+**************************************************************************/
+int MlevelRecursiveBisection(CtrlType *ctrl, GraphType *graph, int nparts, idxtype *part, float *tpwgts, float ubfactor, int fpart)
+{
+  int i, j, nvtxs, cut, tvwgt, tpwgts2[2];
+  idxtype *label, *where;
+  GraphType lgraph, rgraph;
+  float wsum;
+
+  nvtxs = graph->nvtxs;
+  if (nvtxs == 0) {
+    printf("\t***Cannot bisect a graph with 0 vertices!\n\t***You are trying to partition a graph into too many parts!\n");
+    return 0;
+  }
+
+  /* Determine the weights of the partitions */
+  tvwgt = idxsum(nvtxs, graph->vwgt);
+  tpwgts2[0] = tvwgt*ssum(nparts/2, tpwgts);
+  tpwgts2[1] = tvwgt-tpwgts2[0];
+
+  MlevelEdgeBisection(ctrl, graph, tpwgts2, ubfactor);
+  cut = graph->mincut;
+
+  /* printf("%5d %5d %5d [%5d %f]\n", tpwgts2[0], tpwgts2[1], cut, tvwgt, ssum(nparts/2, tpwgts));*/
+
+  label = graph->label;
+  where = graph->where;
+  for (i=0; i<nvtxs; i++)
+    part[label[i]] = where[i] + fpart;
+
+  if (nparts > 2) {
+    SplitGraphPart(ctrl, graph, &lgraph, &rgraph);
+    /* printf("%d %d\n", lgraph.nvtxs, rgraph.nvtxs); */
+  }
+
+
+  /* Free the memory of the top level graph */
+  GKfree(&graph->gdata, &graph->rdata, &graph->label, LTERM);
+
+  /* Scale the fractions in the tpwgts according to the true weight */
+  wsum = ssum(nparts/2, tpwgts);
+  sscale(nparts/2, 1.0/wsum, tpwgts);
+  sscale(nparts-nparts/2, 1.0/(1.0-wsum), tpwgts+nparts/2);
+  /*
+  for (i=0; i<nparts; i++)
+    printf("%5.3f ", tpwgts[i]);
+  printf("[%5.3f]\n", wsum);
+  */
+
+  /* Do the recursive call */
+  if (nparts > 3) {
+    cut += MlevelRecursiveBisection(ctrl, &lgraph, nparts/2, part, tpwgts, ubfactor, fpart);
+    cut += MlevelRecursiveBisection(ctrl, &rgraph, nparts-nparts/2, part, tpwgts+nparts/2, ubfactor, fpart+nparts/2);
+  }
+  else if (nparts == 3) {
+    cut += MlevelRecursiveBisection(ctrl, &rgraph, nparts-nparts/2, part, tpwgts+nparts/2, ubfactor, fpart+nparts/2);
+    GKfree(&lgraph.gdata, &lgraph.label, LTERM);
+  }
+
+  return cut;
+
+}
+
+
+/*************************************************************************
+* This function performs multilevel bisection
+**************************************************************************/
+void MlevelEdgeBisection(CtrlType *ctrl, GraphType *graph, int *tpwgts, float ubfactor)
+{
+  GraphType *cgraph;
+
+  cgraph = Coarsen2Way(ctrl, graph);
+
+  Init2WayPartition(ctrl, cgraph, tpwgts, ubfactor);
+
+  Refine2Way(ctrl, graph, cgraph, tpwgts, ubfactor);
+
+/*
+  IsConnectedSubdomain(ctrl, graph, 0);
+  IsConnectedSubdomain(ctrl, graph, 1);
+*/
+}
+
+
+
+
+/*************************************************************************
+* This function takes a graph and a bisection and splits it into two graphs.
+**************************************************************************/
+void SplitGraphPart(CtrlType *ctrl, GraphType *graph, GraphType *lgraph, GraphType *rgraph)
+{
+  int i, j, k, kk, l, istart, iend, mypart, nvtxs, ncon, snvtxs[2], snedges[2], sum;
+  idxtype *xadj, *vwgt, *adjncy, *adjwgt, *adjwgtsum, *label, *where, *bndptr;
+  idxtype *sxadj[2], *svwgt[2], *sadjncy[2], *sadjwgt[2], *sadjwgtsum[2], *slabel[2];
+  idxtype *rename;
+  idxtype *auxadjncy, *auxadjwgt;
+  float *nvwgt, *snvwgt[2], *npwgts;
+
+
+  IFSET(ctrl->dbglvl, DBG_TIME, starttimer(ctrl->SplitTmr));
+
+  nvtxs = graph->nvtxs;
+  ncon = graph->ncon;
+  xadj = graph->xadj;
+  vwgt = graph->vwgt;
+  nvwgt = graph->nvwgt;
+  adjncy = graph->adjncy;
+  adjwgt = graph->adjwgt;
+  adjwgtsum = graph->adjwgtsum;
+  label = graph->label;
+  where = graph->where;
+  bndptr = graph->bndptr;
+  npwgts = graph->npwgts;
+
+  ASSERT(bndptr != NULL);
+
+  rename = idxwspacemalloc(ctrl, nvtxs);
+  
+  snvtxs[0] = snvtxs[1] = snedges[0] = snedges[1] = 0;
+  for (i=0; i<nvtxs; i++) {
+    k = where[i];
+    rename[i] = snvtxs[k]++;
+    snedges[k] += xadj[i+1]-xadj[i];
+  }
+
+  SetUpSplitGraph(graph, lgraph, snvtxs[0], snedges[0]);
+  sxadj[0] = lgraph->xadj;
+  svwgt[0] = lgraph->vwgt;
+  snvwgt[0] = lgraph->nvwgt;
+  sadjwgtsum[0] = lgraph->adjwgtsum;
+  sadjncy[0] = lgraph->adjncy; 	
+  sadjwgt[0] = lgraph->adjwgt; 
+  slabel[0] = lgraph->label;
+
+  SetUpSplitGraph(graph, rgraph, snvtxs[1], snedges[1]);
+  sxadj[1] = rgraph->xadj;
+  svwgt[1] = rgraph->vwgt;
+  snvwgt[1] = rgraph->nvwgt;
+  sadjwgtsum[1] = rgraph->adjwgtsum;
+  sadjncy[1] = rgraph->adjncy; 	
+  sadjwgt[1] = rgraph->adjwgt; 
+  slabel[1] = rgraph->label;
+
+  snvtxs[0] = snvtxs[1] = snedges[0] = snedges[1] = 0;
+  sxadj[0][0] = sxadj[1][0] = 0;
+  for (i=0; i<nvtxs; i++) {
+    mypart = where[i];
+    sum = adjwgtsum[i];
+
+    istart = xadj[i];
+    iend = xadj[i+1];
+    if (bndptr[i] == -1) { /* This is an interior vertex */
+      auxadjncy = sadjncy[mypart] + snedges[mypart] - istart;
+      auxadjwgt = sadjwgt[mypart] + snedges[mypart] - istart;
+      for(j=istart; j<iend; j++) {
+        auxadjncy[j] = adjncy[j];
+        auxadjwgt[j] = adjwgt[j]; 
+      }
+      snedges[mypart] += iend-istart;
+    }
+    else {
+      auxadjncy = sadjncy[mypart];
+      auxadjwgt = sadjwgt[mypart];
+      l = snedges[mypart];
+      for (j=istart; j<iend; j++) {
+        k = adjncy[j];
+        if (where[k] == mypart) {
+          auxadjncy[l] = k;
+          auxadjwgt[l++] = adjwgt[j]; 
+        }
+        else {
+          sum -= adjwgt[j];
+        }
+      }
+      snedges[mypart] = l;
+    }
+
+    if (ncon == 1)
+      svwgt[mypart][snvtxs[mypart]] = vwgt[i];
+    else {
+      for (kk=0; kk<ncon; kk++)
+        snvwgt[mypart][snvtxs[mypart]*ncon+kk] = nvwgt[i*ncon+kk]/npwgts[mypart*ncon+kk];
+    }
+
+    sadjwgtsum[mypart][snvtxs[mypart]] = sum;
+    slabel[mypart][snvtxs[mypart]] = label[i];
+    sxadj[mypart][++snvtxs[mypart]] = snedges[mypart];
+  }
+
+  for (mypart=0; mypart<2; mypart++) {
+    iend = sxadj[mypart][snvtxs[mypart]];
+    auxadjncy = sadjncy[mypart];
+    for (i=0; i<iend; i++) 
+      auxadjncy[i] = rename[auxadjncy[i]];
+  }
+
+  lgraph->nedges = snedges[0];
+  rgraph->nedges = snedges[1];
+
+  IFSET(ctrl->dbglvl, DBG_TIME, stoptimer(ctrl->SplitTmr));
+
+  idxwspacefree(ctrl, nvtxs);
+}
+
+
+/*************************************************************************
+* Setup the various arrays for the splitted graph
+**************************************************************************/
+void SetUpSplitGraph(GraphType *graph, GraphType *sgraph, int snvtxs, int snedges)
+{
+  InitGraph(sgraph);
+  sgraph->nvtxs = snvtxs;
+  sgraph->nedges = snedges;
+  sgraph->ncon = graph->ncon;
+
+  /* Allocate memory for the splitted graph */
+  if (graph->ncon == 1) {
+    sgraph->gdata = idxmalloc(4*snvtxs+1 + 2*snedges, "SetUpSplitGraph: gdata");
+
+    sgraph->xadj        = sgraph->gdata;
+    sgraph->vwgt        = sgraph->gdata + snvtxs+1;
+    sgraph->adjwgtsum   = sgraph->gdata + 2*snvtxs+1;
+    sgraph->cmap        = sgraph->gdata + 3*snvtxs+1;
+    sgraph->adjncy      = sgraph->gdata + 4*snvtxs+1;
+    sgraph->adjwgt      = sgraph->gdata + 4*snvtxs+1 + snedges;
+  }
+  else {
+    sgraph->gdata = idxmalloc(3*snvtxs+1 + 2*snedges, "SetUpSplitGraph: gdata");
+
+    sgraph->xadj        = sgraph->gdata;
+    sgraph->adjwgtsum   = sgraph->gdata + snvtxs+1;
+    sgraph->cmap        = sgraph->gdata + 2*snvtxs+1;
+    sgraph->adjncy      = sgraph->gdata + 3*snvtxs+1;
+    sgraph->adjwgt      = sgraph->gdata + 3*snvtxs+1 + snedges;
+
+    sgraph->nvwgt       = fmalloc(graph->ncon*snvtxs, "SetUpSplitGraph: nvwgt");
+  }
+
+  sgraph->label	= idxmalloc(snvtxs, "SetUpSplitGraph: sgraph->label");
+}
+
Index: /inundation/pymetis/metis-4.0/Lib/pqueue.c
===================================================================
--- /inundation/pymetis/metis-4.0/Lib/pqueue.c	(revision 2051)
+++ /inundation/pymetis/metis-4.0/Lib/pqueue.c	(revision 2051)
@@ -0,0 +1,579 @@
+/*
+ * Copyright 1997, Regents of the University of Minnesota
+ *
+ * pqueue.c
+ *
+ * This file contains functions for manipulating the bucket list
+ * representation of the gains associated with each vertex in a graph.
+ * These functions are used by the refinement algorithms
+ *
+ * Started 9/2/94
+ * George
+ *
+ * $Id: pqueue.c,v 1.1 1998/11/27 17:59:28 karypis Exp $
+ *
+ */
+
+#include <metis.h>
+
+
+/*************************************************************************
+* This function initializes the data structures of the priority queue
+**************************************************************************/
+void PQueueInit(CtrlType *ctrl, PQueueType *queue, int maxnodes, int maxgain)
+{
+  int i, j, ncore;
+
+  queue->nnodes = 0;
+  queue->maxnodes = maxnodes;
+
+  queue->buckets = NULL;
+  queue->nodes = NULL;
+  queue->heap = NULL;
+  queue->locator = NULL;
+
+  if (maxgain > PLUS_GAINSPAN || maxnodes < 500)
+    queue->type = 2;
+  else
+    queue->type = 1;
+
+  if (queue->type == 1) {
+    queue->pgainspan = amin(PLUS_GAINSPAN, maxgain);
+    queue->ngainspan = amin(NEG_GAINSPAN, maxgain);
+
+    j = queue->ngainspan+queue->pgainspan+1;
+
+    ncore = 2 + (sizeof(ListNodeType)/sizeof(idxtype))*maxnodes + (sizeof(ListNodeType *)/sizeof(idxtype))*j;
+
+    if (WspaceAvail(ctrl) > ncore) {
+      queue->nodes = (ListNodeType *)idxwspacemalloc(ctrl, (sizeof(ListNodeType)/sizeof(idxtype))*maxnodes);
+      queue->buckets = (ListNodeType **)idxwspacemalloc(ctrl, (sizeof(ListNodeType *)/sizeof(idxtype))*j);
+      queue->mustfree = 0;
+    }
+    else { /* Not enough memory in the wspace, allocate it */
+      queue->nodes = (ListNodeType *)idxmalloc((sizeof(ListNodeType)/sizeof(idxtype))*maxnodes, "PQueueInit: queue->nodes");
+      queue->buckets = (ListNodeType **)idxmalloc((sizeof(ListNodeType *)/sizeof(idxtype))*j, "PQueueInit: queue->buckets");
+      queue->mustfree = 1;
+    }
+
+    for (i=0; i<maxnodes; i++) 
+      queue->nodes[i].id = i;
+
+    for (i=0; i<j; i++)
+      queue->buckets[i] = NULL;
+
+    queue->buckets += queue->ngainspan;  /* Advance buckets by the ngainspan proper indexing */
+    queue->maxgain = -queue->ngainspan;
+  }
+  else {
+    queue->heap = (KeyValueType *)idxwspacemalloc(ctrl, (sizeof(KeyValueType)/sizeof(idxtype))*maxnodes);
+    queue->locator = idxwspacemalloc(ctrl, maxnodes);
+    idxset(maxnodes, -1, queue->locator);
+  }
+
+}
+
+
+/*************************************************************************
+* This function resets the buckets
+**************************************************************************/
+void PQueueReset(PQueueType *queue)
+{
+  int i, j;
+  queue->nnodes = 0;
+
+  if (queue->type == 1) {
+    queue->maxgain = -queue->ngainspan;
+
+    j = queue->ngainspan+queue->pgainspan+1;
+    queue->buckets -= queue->ngainspan;  
+    for (i=0; i<j; i++)
+      queue->buckets[i] = NULL;
+    queue->buckets += queue->ngainspan;  
+  }
+  else {
+    idxset(queue->maxnodes, -1, queue->locator);
+  }
+
+}
+
+
+/*************************************************************************
+* This function frees the buckets
+**************************************************************************/
+void PQueueFree(CtrlType *ctrl, PQueueType *queue)
+{
+
+  if (queue->type == 1) {
+    if (queue->mustfree) {
+      queue->buckets -= queue->ngainspan;  
+      GKfree(&queue->nodes, &queue->buckets, LTERM);
+    } 
+    else {
+      idxwspacefree(ctrl, sizeof(ListNodeType *)*(queue->ngainspan+queue->pgainspan+1)/sizeof(idxtype));
+      idxwspacefree(ctrl, sizeof(ListNodeType)*queue->maxnodes/sizeof(idxtype));
+    }
+  }
+  else {
+    idxwspacefree(ctrl, sizeof(KeyValueType)*queue->maxnodes/sizeof(idxtype));
+    idxwspacefree(ctrl, queue->maxnodes);
+  }
+
+  queue->maxnodes = 0;
+}
+
+
+/*************************************************************************
+* This function returns the number of nodes in the queue
+**************************************************************************/
+int PQueueGetSize(PQueueType *queue)
+{
+  return queue->nnodes;
+}
+
+
+/*************************************************************************
+* This function adds a node of certain gain into a partition
+**************************************************************************/
+int PQueueInsert(PQueueType *queue, int node, int gain)
+{
+  int i, j, k;
+  idxtype *locator;
+  ListNodeType *newnode;
+  KeyValueType *heap;
+
+  if (queue->type == 1) {
+    ASSERT(gain >= -queue->ngainspan && gain <= queue->pgainspan);
+
+    /* Allocate and add the node */
+    queue->nnodes++;
+    newnode = queue->nodes + node;
+
+    /* Attach this node in the doubly-linked list */
+    newnode->next = queue->buckets[gain];
+    newnode->prev = NULL;
+    if (newnode->next != NULL)
+      newnode->next->prev = newnode;
+    queue->buckets[gain] = newnode;
+
+    if (queue->maxgain < gain)
+      queue->maxgain = gain;
+  }
+  else {
+    ASSERT(CheckHeap(queue));
+
+    heap = queue->heap;
+    locator = queue->locator;
+
+    ASSERT(locator[node] == -1);
+
+    i = queue->nnodes++;
+    while (i > 0) {
+      j = (i-1)/2;
+      if (heap[j].key < gain) {
+        heap[i] = heap[j];
+        locator[heap[i].val] = i;
+        i = j;
+      }
+      else 
+        break;
+    }
+    ASSERT(i >= 0);
+    heap[i].key = gain;
+    heap[i].val = node;
+    locator[node] = i;
+
+    ASSERT(CheckHeap(queue));
+  }
+
+  return 0;
+}
+
+
+/*************************************************************************
+* This function deletes a node from a partition and reinserts it with
+* an updated gain
+**************************************************************************/
+int PQueueDelete(PQueueType *queue, int node, int gain)
+{
+  int i, j, newgain, oldgain;
+  idxtype *locator;
+  ListNodeType *newnode, **buckets;
+  KeyValueType *heap;
+
+  if (queue->type == 1) {
+    ASSERT(gain >= -queue->ngainspan && gain <= queue->pgainspan);
+    ASSERT(queue->nnodes > 0);
+
+    buckets = queue->buckets;
+    queue->nnodes--;
+    newnode = queue->nodes+node;
+
+    /* Remove newnode from the doubly-linked list */
+    if (newnode->prev != NULL)
+      newnode->prev->next = newnode->next;
+    else
+      buckets[gain] = newnode->next;
+    if (newnode->next != NULL)
+      newnode->next->prev = newnode->prev;
+
+    if (buckets[gain] == NULL && gain == queue->maxgain) {
+      if (queue->nnodes == 0) 
+        queue->maxgain = -queue->ngainspan;
+      else 
+        for (; buckets[queue->maxgain]==NULL; queue->maxgain--);
+    }
+  }
+  else { /* Heap Priority Queue */
+    heap = queue->heap;
+    locator = queue->locator;
+
+    ASSERT(locator[node] != -1);
+    ASSERT(heap[locator[node]].val == node);
+
+    ASSERT(CheckHeap(queue));
+
+    i = locator[node];
+    locator[node] = -1;
+
+    if (--queue->nnodes > 0 && heap[queue->nnodes].val != node) {
+      node = heap[queue->nnodes].val;
+      newgain = heap[queue->nnodes].key;
+      oldgain = heap[i].key;
+
+      if (oldgain < newgain) { /* Filter-up */
+        while (i > 0) {
+          j = (i-1)>>1;
+          if (heap[j].key < newgain) {
+            heap[i] = heap[j];
+            locator[heap[i].val] = i;
+            i = j;
+          }
+          else 
+            break;
+        }
+      }
+      else { /* Filter down */
+        while ((j=2*i+1) < queue->nnodes) {
+          if (heap[j].key > newgain) {
+            if (j+1 < queue->nnodes && heap[j+1].key > heap[j].key)
+              j = j+1;
+            heap[i] = heap[j];
+            locator[heap[i].val] = i;
+            i = j;
+          }
+          else if (j+1 < queue->nnodes && heap[j+1].key > newgain) {
+            j = j+1;
+            heap[i] = heap[j];
+            locator[heap[i].val] = i;
+            i = j;
+          }
+          else
+            break;
+        }
+      }
+
+      heap[i].key = newgain;
+      heap[i].val = node;
+      locator[node] = i;
+    }
+
+    ASSERT(CheckHeap(queue));
+  }
+
+  return 0;
+}
+
+
+
+/*************************************************************************
+* This function deletes a node from a partition and reinserts it with
+* an updated gain
+**************************************************************************/
+int PQueueUpdate(PQueueType *queue, int node, int oldgain, int newgain)
+{
+  int i, j;
+  idxtype *locator;
+  ListNodeType *newnode;
+  KeyValueType *heap;
+
+  if (oldgain == newgain) 
+    return 0;
+
+  if (queue->type == 1) {
+    /* First delete the node and then insert it */
+    PQueueDelete(queue, node, oldgain);
+    return PQueueInsert(queue, node, newgain);
+  }
+  else { /* Heap Priority Queue */
+    heap = queue->heap;
+    locator = queue->locator;
+
+    ASSERT(locator[node] != -1);
+    ASSERT(heap[locator[node]].val == node);
+    ASSERT(heap[locator[node]].key == oldgain);
+    ASSERT(CheckHeap(queue));
+
+    i = locator[node];
+
+    if (oldgain < newgain) { /* Filter-up */
+      while (i > 0) {
+        j = (i-1)>>1;
+        if (heap[j].key < newgain) {
+          heap[i] = heap[j];
+          locator[heap[i].val] = i;
+          i = j;
+        }
+        else 
+          break;
+      }
+    }
+    else { /* Filter down */
+      while ((j=2*i+1) < queue->nnodes) {
+        if (heap[j].key > newgain) {
+          if (j+1 < queue->nnodes && heap[j+1].key > heap[j].key)
+            j = j+1;
+          heap[i] = heap[j];
+          locator[heap[i].val] = i;
+          i = j;
+        }
+        else if (j+1 < queue->nnodes && heap[j+1].key > newgain) {
+          j = j+1;
+          heap[i] = heap[j];
+          locator[heap[i].val] = i;
+          i = j;
+        }
+        else
+          break;
+      }
+    }
+
+    heap[i].key = newgain;
+    heap[i].val = node;
+    locator[node] = i;
+
+    ASSERT(CheckHeap(queue));
+  }
+
+  return 0;
+}
+
+
+
+/*************************************************************************
+* This function deletes a node from a partition and reinserts it with
+* an updated gain
+**************************************************************************/
+void PQueueUpdateUp(PQueueType *queue, int node, int oldgain, int newgain)
+{
+  int i, j;
+  idxtype *locator;
+  ListNodeType *newnode, **buckets;
+  KeyValueType *heap;
+
+  if (oldgain == newgain) 
+    return;
+
+  if (queue->type == 1) {
+    ASSERT(oldgain >= -queue->ngainspan && oldgain <= queue->pgainspan);
+    ASSERT(newgain >= -queue->ngainspan && newgain <= queue->pgainspan);
+    ASSERT(queue->nnodes > 0);
+
+    buckets = queue->buckets;
+    newnode = queue->nodes+node;
+
+    /* First delete the node */
+    if (newnode->prev != NULL)
+      newnode->prev->next = newnode->next;
+    else
+      buckets[oldgain] = newnode->next;
+    if (newnode->next != NULL)
+      newnode->next->prev = newnode->prev;
+
+    /* Attach this node in the doubly-linked list */
+    newnode->next = buckets[newgain];
+    newnode->prev = NULL;
+    if (newnode->next != NULL)
+      newnode->next->prev = newnode;
+    buckets[newgain] = newnode;
+
+    if (queue->maxgain < newgain)
+      queue->maxgain = newgain;
+  }
+  else { /* Heap Priority Queue */
+    heap = queue->heap;
+    locator = queue->locator;
+
+    ASSERT(locator[node] != -1);
+    ASSERT(heap[locator[node]].val == node);
+    ASSERT(heap[locator[node]].key == oldgain);
+    ASSERT(CheckHeap(queue));
+
+
+    /* Here we are just filtering up since the newgain is greater than the oldgain */
+    i = locator[node];
+    while (i > 0) {
+      j = (i-1)>>1;
+      if (heap[j].key < newgain) {
+        heap[i] = heap[j];
+        locator[heap[i].val] = i;
+        i = j;
+      }
+      else 
+        break;
+    }
+
+    heap[i].key = newgain;
+    heap[i].val = node;
+    locator[node] = i;
+
+    ASSERT(CheckHeap(queue));
+  }
+
+}
+
+
+/*************************************************************************
+* This function returns the vertex with the largest gain from a partition
+* and removes the node from the bucket list
+**************************************************************************/
+int PQueueGetMax(PQueueType *queue)
+{
+  int vtx, i, j, gain, node;
+  idxtype *locator;
+  ListNodeType *tptr;
+  KeyValueType *heap;
+
+  if (queue->nnodes == 0)
+    return -1;
+
+  queue->nnodes--;
+
+  if (queue->type == 1) {
+    tptr = queue->buckets[queue->maxgain];
+    queue->buckets[queue->maxgain] = tptr->next;
+    if (tptr->next != NULL) {
+      tptr->next->prev = NULL;
+    }
+    else {
+      if (queue->nnodes == 0) {
+        queue->maxgain = -queue->ngainspan;
+      }
+      else 
+        for (; queue->buckets[queue->maxgain]==NULL; queue->maxgain--);
+    }
+
+    return tptr->id;
+  }
+  else {
+    heap = queue->heap;
+    locator = queue->locator;
+
+    vtx = heap[0].val;
+    locator[vtx] = -1;
+
+    if ((i = queue->nnodes) > 0) {
+      gain = heap[i].key;
+      node = heap[i].val;
+      i = 0;
+      while ((j=2*i+1) < queue->nnodes) {
+        if (heap[j].key > gain) {
+          if (j+1 < queue->nnodes && heap[j+1].key > heap[j].key)
+            j = j+1;
+          heap[i] = heap[j];
+          locator[heap[i].val] = i;
+          i = j;
+        }
+        else if (j+1 < queue->nnodes && heap[j+1].key > gain) {
+          j = j+1;
+          heap[i] = heap[j];
+          locator[heap[i].val] = i;
+          i = j;
+        }
+        else
+          break;
+      }
+
+      heap[i].key = gain;
+      heap[i].val = node;
+      locator[node] = i;
+    }
+
+    ASSERT(CheckHeap(queue));
+    return vtx;
+  }
+}
+      
+
+/*************************************************************************
+* This function returns the vertex with the largest gain from a partition
+**************************************************************************/
+int PQueueSeeMax(PQueueType *queue)
+{
+  int vtx;
+
+  if (queue->nnodes == 0)
+    return -1;
+
+  if (queue->type == 1) 
+    vtx = queue->buckets[queue->maxgain]->id;
+  else
+    vtx = queue->heap[0].val;
+
+  return vtx;
+}
+      
+
+/*************************************************************************
+* This function returns the vertex with the largest gain from a partition
+**************************************************************************/
+int PQueueGetKey(PQueueType *queue)
+{
+  int key;
+
+  if (queue->nnodes == 0)
+    return -1;
+
+  if (queue->type == 1) 
+    key = queue->maxgain;
+  else
+    key = queue->heap[0].key;
+
+  return key;
+}
+      
+
+
+
+/*************************************************************************
+* This functions checks the consistency of the heap
+**************************************************************************/
+int CheckHeap(PQueueType *queue)
+{
+  int i, j, nnodes;
+  idxtype *locator;
+  KeyValueType *heap;
+
+  heap = queue->heap;
+  locator = queue->locator;
+  nnodes = queue->nnodes;
+
+  if (nnodes == 0)
+    return 1;
+
+  ASSERT(locator[heap[0].val] == 0);
+  for (i=1; i<nnodes; i++) {
+    ASSERTP(locator[heap[i].val] == i, ("%d %d %d %d\n", nnodes, i, heap[i].val, locator[heap[i].val])); 
+    ASSERTP(heap[i].key <= heap[(i-1)/2].key, ("%d %d %d %d %d\n", i, (i-1)/2, nnodes, heap[i].key, heap[(i-1)/2].key));
+  }
+  for (i=1; i<nnodes; i++)
+    ASSERT(heap[i].key <= heap[0].key);
+
+  for (j=i=0; i<queue->maxnodes; i++) {
+    if (locator[i] != -1)
+      j++;
+  }
+  ASSERTP(j == nnodes, ("%d %d\n", j, nnodes));
+
+  return 1;
+}
Index: /inundation/pymetis/metis-4.0/Lib/proto.h
===================================================================
--- /inundation/pymetis/metis-4.0/Lib/proto.h	(revision 2051)
+++ /inundation/pymetis/metis-4.0/Lib/proto.h	(revision 2051)
@@ -0,0 +1,505 @@
+/*
+ * Copyright 1997, Regents of the University of Minnesota
+ *
+ * proto.h
+ *
+ * This file contains header files
+ *
+ * Started 10/19/95
+ * George
+ *
+ * $Id: proto.h,v 1.1 1998/11/27 17:59:28 karypis Exp $
+ *
+ */
+
+/* balance.c */
+void Balance2Way(CtrlType *, GraphType *, int *, float);
+void Bnd2WayBalance(CtrlType *, GraphType *, int *);
+void General2WayBalance(CtrlType *, GraphType *, int *);
+
+/* bucketsort.c */
+void BucketSortKeysInc(int, int, idxtype *, idxtype *, idxtype *);
+
+/* ccgraph.c */
+void CreateCoarseGraph(CtrlType *, GraphType *, int, idxtype *, idxtype *);
+void CreateCoarseGraphNoMask(CtrlType *, GraphType *, int, idxtype *, idxtype *);
+void CreateCoarseGraph_NVW(CtrlType *, GraphType *, int, idxtype *, idxtype *);
+GraphType *SetUpCoarseGraph(GraphType *, int, int);
+void ReAdjustMemory(GraphType *, GraphType *, int);
+
+/* coarsen.c */
+GraphType *Coarsen2Way(CtrlType *, GraphType *);
+
+/* compress.c */
+void CompressGraph(CtrlType *, GraphType *, int, idxtype *, idxtype *, idxtype *, idxtype *);
+void PruneGraph(CtrlType *, GraphType *, int, idxtype *, idxtype *, idxtype *, float);
+
+/* debug.c */
+int ComputeCut(GraphType *, idxtype *);
+int CheckBnd(GraphType *);
+int CheckBnd2(GraphType *);
+int CheckNodeBnd(GraphType *, int);
+int CheckRInfo(RInfoType *);
+int CheckNodePartitionParams(GraphType *);
+int IsSeparable(GraphType *);
+
+/* estmem.c */
+void METIS_EstimateMemory(int *, idxtype *, idxtype *, int *, int *, int *);
+void EstimateCFraction(int, idxtype *, idxtype *, float *, float *);
+int ComputeCoarseGraphSize(int, idxtype *, idxtype *, int, idxtype *, idxtype *, idxtype *);
+
+/* fm.c */
+void FM_2WayEdgeRefine(CtrlType *, GraphType *, int *, int);
+
+/* fortran.c */
+void Change2CNumbering(int, idxtype *, idxtype *);
+void Change2FNumbering(int, idxtype *, idxtype *, idxtype *);
+void Change2FNumbering2(int, idxtype *, idxtype *);
+void Change2FNumberingOrder(int, idxtype *, idxtype *, idxtype *, idxtype *);
+void ChangeMesh2CNumbering(int, idxtype *);
+void ChangeMesh2FNumbering(int, idxtype *, int, idxtype *, idxtype *);
+void ChangeMesh2FNumbering2(int, idxtype *, int, int, idxtype *, idxtype *);
+
+/* frename.c */
+void METIS_PARTGRAPHRECURSIVE(int *, idxtype *, idxtype *, idxtype *, idxtype *, int *, int *, int *, int *, int *, idxtype *); 
+void metis_partgraphrecursive(int *, idxtype *, idxtype *, idxtype *, idxtype *, int *, int *, int *, int *, int *, idxtype *); 
+void metis_partgraphrecursive_(int *, idxtype *, idxtype *, idxtype *, idxtype *, int *, int *, int *, int *, int *, idxtype *); 
+void metis_partgraphrecursive__(int *, idxtype *, idxtype *, idxtype *, idxtype *, int *, int *, int *, int *, int *, idxtype *); 
+void METIS_WPARTGRAPHRECURSIVE(int *, idxtype *, idxtype *, idxtype *, idxtype *, int *, int *, int *, float *, int *, int *, idxtype *); 
+void metis_wpartgraphrecursive(int *, idxtype *, idxtype *, idxtype *, idxtype *, int *, int *, int *, float *, int *, int *, idxtype *); 
+void metis_wpartgraphrecursive_(int *, idxtype *, idxtype *, idxtype *, idxtype *, int *, int *, int *, float *, int *, int *, idxtype *); 
+void metis_wpartgraphrecursive__(int *, idxtype *, idxtype *, idxtype *, idxtype *, int *, int *, int *, float *, int *, int *, idxtype *); 
+void METIS_PARTGRAPHKWAY(int *, idxtype *, idxtype *, idxtype *, idxtype *, int *, int *, int *, int *, int *, idxtype *); 
+void metis_partgraphkway(int *, idxtype *, idxtype *, idxtype *, idxtype *, int *, int *, int *, int *, int *, idxtype *); 
+void metis_partgraphkway_(int *, idxtype *, idxtype *, idxtype *, idxtype *, int *, int *, int *, int *, int *, idxtype *); 
+void metis_partgraphkway__(int *, idxtype *, idxtype *, idxtype *, idxtype *, int *, int *, int *, int *, int *, idxtype *); 
+void METIS_WPARTGRAPHKWAY(int *, idxtype *, idxtype *, idxtype *, idxtype *, int *, int *, int *, float *, int *, int *, idxtype *); 
+void metis_wpartgraphkway(int *, idxtype *, idxtype *, idxtype *, idxtype *, int *, int *, int *, float *, int *, int *, idxtype *); 
+void metis_wpartgraphkway_(int *, idxtype *, idxtype *, idxtype *, idxtype *, int *, int *, int *, float *, int *, int *, idxtype *); 
+void metis_wpartgraphkway__(int *, idxtype *, idxtype *, idxtype *, idxtype *, int *, int *, int *, float *, int *, int *, idxtype *); 
+void METIS_EDGEND(int *, idxtype *, idxtype *, int *, int *, idxtype *, idxtype *); 
+void metis_edgend(int *, idxtype *, idxtype *, int *, int *, idxtype *, idxtype *); 
+void metis_edgend_(int *, idxtype *, idxtype *, int *, int *, idxtype *, idxtype *); 
+void metis_edgend__(int *, idxtype *, idxtype *, int *, int *, idxtype *, idxtype *); 
+void METIS_NODEND(int *, idxtype *, idxtype *, int *, int *, idxtype *, idxtype *); 
+void metis_nodend(int *, idxtype *, idxtype *, int *, int *, idxtype *, idxtype *); 
+void metis_nodend_(int *, idxtype *, idxtype *, int *, int *, idxtype *, idxtype *); 
+void metis_nodend__(int *, idxtype *, idxtype *, int *, int *, idxtype *, idxtype *); 
+void METIS_NODEWND(int *, idxtype *, idxtype *, idxtype *, int *, int *, idxtype *, idxtype *); 
+void metis_nodewnd(int *, idxtype *, idxtype *, idxtype *, int *, int *, idxtype *, idxtype *); 
+void metis_nodewnd_(int *, idxtype *, idxtype *, idxtype *, int *, int *, idxtype *, idxtype *); 
+void metis_nodewnd__(int *, idxtype *, idxtype *, idxtype *, int *, int *, idxtype *, idxtype *); 
+void METIS_PARTMESHNODAL(int *, int *, idxtype *, int *, int *, int *, int *, idxtype *, idxtype *);
+void metis_partmeshnodal(int *, int *, idxtype *, int *, int *, int *, int *, idxtype *, idxtype *);
+void metis_partmeshnodal_(int *, int *, idxtype *, int *, int *, int *, int *, idxtype *, idxtype *);
+void metis_partmeshnodal__(int *, int *, idxtype *, int *, int *, int *, int *, idxtype *, idxtype *);
+void METIS_PARTMESHDUAL(int *, int *, idxtype *, int *, int *, int *, int *, idxtype *, idxtype *);
+void metis_partmeshdual(int *, int *, idxtype *, int *, int *, int *, int *, idxtype *, idxtype *);
+void metis_partmeshdual_(int *, int *, idxtype *, int *, int *, int *, int *, idxtype *, idxtype *);
+void metis_partmeshdual__(int *, int *, idxtype *, int *, int *, int *, int *, idxtype *, idxtype *);
+void METIS_MESHTONODAL(int *, int *, idxtype *, int *, int *, idxtype *, idxtype *);
+void metis_meshtonodal(int *, int *, idxtype *, int *, int *, idxtype *, idxtype *);
+void metis_meshtonodal_(int *, int *, idxtype *, int *, int *, idxtype *, idxtype *);
+void metis_meshtonodal__(int *, int *, idxtype *, int *, int *, idxtype *, idxtype *);
+void METIS_MESHTODUAL(int *, int *, idxtype *, int *, int *, idxtype *, idxtype *);
+void metis_meshtodual(int *, int *, idxtype *, int *, int *, idxtype *, idxtype *);
+void metis_meshtodual_(int *, int *, idxtype *, int *, int *, idxtype *, idxtype *);
+void metis_meshtodual__(int *, int *, idxtype *, int *, int *, idxtype *, idxtype *);
+void METIS_ESTIMATEMEMORY(int *, idxtype *, idxtype *, int *, int *, int *);
+void metis_estimatememory(int *, idxtype *, idxtype *, int *, int *, int *);
+void metis_estimatememory_(int *, idxtype *, idxtype *, int *, int *, int *);
+void metis_estimatememory__(int *, idxtype *, idxtype *, int *, int *, int *);
+void METIS_MCPARTGRAPHRECURSIVE(int *, int *, idxtype *, idxtype *, idxtype *, idxtype *, int *, int *, int *, int *, int *, idxtype *);
+void metis_mcpartgraphrecursive(int *, int *, idxtype *, idxtype *, idxtype *, idxtype *, int *, int *, int *, int *, int *, idxtype *);
+void metis_mcpartgraphrecursive_(int *, int *, idxtype *, idxtype *, idxtype *, idxtype *, int *, int *, int *, int *, int *, idxtype *);
+void metis_mcpartgraphrecursive__(int *, int *, idxtype *, idxtype *, idxtype *, idxtype *, int *, int *, int *, int *, int *, idxtype *);
+void METIS_MCPARTGRAPHKWAY(int *, int *, idxtype *, idxtype *, idxtype *, idxtype *, int *, int *, int *, float *, int *, int *, idxtype *);
+void metis_mcpartgraphkway(int *, int *, idxtype *, idxtype *, idxtype *, idxtype *, int *, int *, int *, float *, int *, int *, idxtype *);
+void metis_mcpartgraphkway_(int *, int *, idxtype *, idxtype *, idxtype *, idxtype *, int *, int *, int *, float *, int *, int *, idxtype *);
+void metis_mcpartgraphkway__(int *, int *, idxtype *, idxtype *, idxtype *, idxtype *, int *, int *, int *, float *, int *, int *, idxtype *);
+void METIS_PARTGRAPHVKWAY(int *, idxtype *, idxtype *, idxtype *, idxtype *, int *, int *, int *, int *, int *, idxtype *);
+void metis_partgraphvkway(int *, idxtype *, idxtype *, idxtype *, idxtype *, int *, int *, int *, int *, int *, idxtype *);
+void metis_partgraphvkway_(int *, idxtype *, idxtype *, idxtype *, idxtype *, int *, int *, int *, int *, int *, idxtype *);
+void metis_partgraphvkway__(int *, idxtype *, idxtype *, idxtype *, idxtype *, int *, int *, int *, int *, int *, idxtype *);
+void METIS_WPARTGRAPHVKWAY(int *, idxtype *, idxtype *, idxtype *, idxtype *, int *, int *, int *, float *, int *, int *, idxtype *);
+void metis_wpartgraphvkway(int *, idxtype *, idxtype *, idxtype *, idxtype *, int *, int *, int *, float *, int *, int *, idxtype *);
+void metis_wpartgraphvkway_(int *, idxtype *, idxtype *, idxtype *, idxtype *, int *, int *, int *, float *, int *, int *, idxtype *);
+void metis_wpartgraphvkway__(int *, idxtype *, idxtype *, idxtype *, idxtype *, int *, int *, int *, float *, int *, int *, idxtype *);
+
+/* graph.c */
+void SetUpGraph(GraphType *, int, int, int, idxtype *, idxtype *, idxtype *, idxtype *, int);
+void SetUpGraphKway(GraphType *, int, idxtype *, idxtype *);
+void SetUpGraph2(GraphType *, int, int, idxtype *, idxtype *, float *, idxtype *);
+void VolSetUpGraph(GraphType *, int, int, int, idxtype *, idxtype *, idxtype *, idxtype *, int);
+void RandomizeGraph(GraphType *);
+int IsConnectedSubdomain(CtrlType *, GraphType *, int, int);
+int IsConnected(CtrlType *, GraphType *, int);
+int IsConnected2(GraphType *, int);
+int FindComponents(CtrlType *, GraphType *, idxtype *, idxtype *);
+
+/* initpart.c */
+void Init2WayPartition(CtrlType *, GraphType *, int *, float);
+void InitSeparator(CtrlType *, GraphType *, float);
+void GrowBisection(CtrlType *, GraphType *, int *, float);
+void GrowBisectionNode(CtrlType *, GraphType *, float);
+void RandomBisection(CtrlType *, GraphType *, int *, float);
+
+/* kmetis.c */
+void METIS_PartGraphKway(int *, idxtype *, idxtype *, idxtype *, idxtype *, int *, int *, int *, int *, int *, idxtype *); 
+void METIS_WPartGraphKway(int *, idxtype *, idxtype *, idxtype *, idxtype *, int *, int *, int *, float *, int *, int *, idxtype *); 
+int MlevelKWayPartitioning(CtrlType *, GraphType *, int, idxtype *, float *, float);
+
+/* kvmetis.c */
+void METIS_PartGraphVKway(int *, idxtype *, idxtype *, idxtype *, idxtype *, int *, int *, int *, int *, int *, idxtype *);
+void METIS_WPartGraphVKway(int *, idxtype *, idxtype *, idxtype *, idxtype *, int *, int *, int *, float *, int *, int *, idxtype *);
+int MlevelVolKWayPartitioning(CtrlType *, GraphType *, int, idxtype *, float *, float);
+
+/* kwayfm.c */
+void Random_KWayEdgeRefine(CtrlType *, GraphType *, int, float *, float, int, int);
+void Greedy_KWayEdgeRefine(CtrlType *, GraphType *, int, float *, float, int);
+void Greedy_KWayEdgeBalance(CtrlType *, GraphType *, int, float *, float, int);
+
+/* kwayrefine.c */
+void RefineKWay(CtrlType *, GraphType *, GraphType *, int, float *, float);
+void AllocateKWayPartitionMemory(CtrlType *, GraphType *, int);
+void ComputeKWayPartitionParams(CtrlType *, GraphType *, int);
+void ProjectKWayPartition(CtrlType *, GraphType *, int);
+int IsBalanced(idxtype *, int, float *, float);
+void ComputeKWayBoundary(CtrlType *, GraphType *, int);
+void ComputeKWayBalanceBoundary(CtrlType *, GraphType *, int);
+
+/* kwayvolfm.c */
+void Random_KWayVolRefine(CtrlType *, GraphType *, int, float *, float, int, int);
+void Random_KWayVolRefineMConn(CtrlType *, GraphType *, int, float *, float, int, int);
+void Greedy_KWayVolBalance(CtrlType *, GraphType *, int, float *, float, int);
+void Greedy_KWayVolBalanceMConn(CtrlType *, GraphType *, int, float *, float, int);
+void KWayVolUpdate(CtrlType *, GraphType *, int, int, int, idxtype *, idxtype *, idxtype *);
+void ComputeKWayVolume(GraphType *, int, idxtype *, idxtype *, idxtype *);
+int ComputeVolume(GraphType *, idxtype *);
+void CheckVolKWayPartitionParams(CtrlType *, GraphType *, int);
+void ComputeVolSubDomainGraph(GraphType *, int, idxtype *, idxtype *);
+void EliminateVolSubDomainEdges(CtrlType *, GraphType *, int, float *);
+void EliminateVolComponents(CtrlType *, GraphType *, int, float *, float);
+
+/* kwayvolrefine.c */
+void RefineVolKWay(CtrlType *, GraphType *, GraphType *, int, float *, float);
+void AllocateVolKWayPartitionMemory(CtrlType *, GraphType *, int);
+void ComputeVolKWayPartitionParams(CtrlType *, GraphType *, int);
+void ComputeKWayVolGains(CtrlType *, GraphType *, int);
+void ProjectVolKWayPartition(CtrlType *, GraphType *, int);
+void ComputeVolKWayBoundary(CtrlType *, GraphType *, int);
+void ComputeVolKWayBalanceBoundary(CtrlType *, GraphType *, int);
+
+/* match.c */
+void Match_RM(CtrlType *, GraphType *);
+void Match_RM_NVW(CtrlType *, GraphType *);
+void Match_HEM(CtrlType *, GraphType *);
+void Match_SHEM(CtrlType *, GraphType *);
+
+/* mbalance.c */
+void MocBalance2Way(CtrlType *, GraphType *, float *, float);
+void MocGeneral2WayBalance(CtrlType *, GraphType *, float *, float);
+
+/* mbalance2.c */
+void MocBalance2Way2(CtrlType *, GraphType *, float *, float *);
+void MocGeneral2WayBalance2(CtrlType *, GraphType *, float *, float *);
+void SelectQueue3(int, float *, float *, int *, int *, PQueueType [MAXNCON][2], float *);
+
+/* mcoarsen.c */
+GraphType *MCCoarsen2Way(CtrlType *, GraphType *);
+
+/* memory.c */
+void AllocateWorkSpace(CtrlType *, GraphType *, int);
+void FreeWorkSpace(CtrlType *, GraphType *);
+int WspaceAvail(CtrlType *);
+idxtype *idxwspacemalloc(CtrlType *, int);
+void idxwspacefree(CtrlType *, int);
+float *fwspacemalloc(CtrlType *, int);
+void fwspacefree(CtrlType *, int);
+GraphType *CreateGraph(void);
+void InitGraph(GraphType *);
+void FreeGraph(GraphType *);
+
+/* mesh.c */
+void METIS_MeshToDual(int *, int *, idxtype *, int *, int *, idxtype *, idxtype *);
+void METIS_MeshToNodal(int *, int *, idxtype *, int *, int *, idxtype *, idxtype *);
+void GENDUALMETIS(int, int, int, idxtype *, idxtype *, idxtype *adjncy);
+void TRINODALMETIS(int, int, idxtype *, idxtype *, idxtype *adjncy);
+void TETNODALMETIS(int, int, idxtype *, idxtype *, idxtype *adjncy);
+void HEXNODALMETIS(int, int, idxtype *, idxtype *, idxtype *adjncy);
+void QUADNODALMETIS(int, int, idxtype *, idxtype *, idxtype *adjncy);
+
+/* meshpart.c */
+void METIS_PartMeshNodal(int *, int *, idxtype *, int *, int *, int *, int *, idxtype *, idxtype *);
+void METIS_PartMeshDual(int *, int *, idxtype *, int *, int *, int *, int *, idxtype *, idxtype *);
+
+/* mfm.c */
+void MocFM_2WayEdgeRefine(CtrlType *, GraphType *, float *, int);
+void SelectQueue(int, float *, float *, int *, int *, PQueueType [MAXNCON][2]);
+int BetterBalance(int, float *, float *, float *);
+float Compute2WayHLoadImbalance(int, float *, float *);
+void Compute2WayHLoadImbalanceVec(int, float *, float *, float *);
+
+/* mfm2.c */
+void MocFM_2WayEdgeRefine2(CtrlType *, GraphType *, float *, float *, int);
+void SelectQueue2(int, float *, float *, int *, int *, PQueueType [MAXNCON][2], float *);
+int IsBetter2wayBalance(int, float *, float *, float *);
+
+/* mincover.o */
+void MinCover(idxtype *, idxtype *, int, int, idxtype *, int *);
+int MinCover_Augment(idxtype *, idxtype *, int, idxtype *, idxtype *, idxtype *, int);
+void MinCover_Decompose(idxtype *, idxtype *, int, int, idxtype *, idxtype *, int *);
+void MinCover_ColDFS(idxtype *, idxtype *, int, idxtype *, idxtype *, int);
+void MinCover_RowDFS(idxtype *, idxtype *, int, idxtype *, idxtype *, int);
+
+/* minitpart.c */
+void MocInit2WayPartition(CtrlType *, GraphType *, float *, float);
+void MocGrowBisection(CtrlType *, GraphType *, float *, float);
+void MocRandomBisection(CtrlType *, GraphType *, float *, float);
+void MocInit2WayBalance(CtrlType *, GraphType *, float *);
+int SelectQueueoneWay(int, float *, float *, int, PQueueType [MAXNCON][2]);
+
+/* minitpart2.c */
+void MocInit2WayPartition2(CtrlType *, GraphType *, float *, float *);
+void MocGrowBisection2(CtrlType *, GraphType *, float *, float *);
+void MocGrowBisectionNew2(CtrlType *, GraphType *, float *, float *);
+void MocInit2WayBalance2(CtrlType *, GraphType *, float *, float *);
+int SelectQueueOneWay2(int, float *, PQueueType [MAXNCON][2], float *);
+
+/* mkmetis.c */
+void METIS_mCPartGraphKway(int *, int *, idxtype *, idxtype *, idxtype *, idxtype *, int *, int *, int *, float *, int *, int *, idxtype *);
+int MCMlevelKWayPartitioning(CtrlType *, GraphType *, int, idxtype *, float *);
+
+/* mkwayfmh.c */
+void MCRandom_KWayEdgeRefineHorizontal(CtrlType *, GraphType *, int, float *, int);
+void MCGreedy_KWayEdgeBalanceHorizontal(CtrlType *, GraphType *, int, float *, int);
+int AreAllHVwgtsBelow(int, float, float *, float, float *, float *);
+int AreAllHVwgtsAbove(int, float, float *, float, float *, float *);
+void ComputeHKWayLoadImbalance(int, int, float *, float *);
+int MocIsHBalanced(int, int, float *, float *);
+int IsHBalanceBetterFT(int, int, float *, float *, float *, float *);
+int IsHBalanceBetterTT(int, int, float *, float *, float *, float *);
+
+/* mkwayrefine.c */
+void MocRefineKWayHorizontal(CtrlType *, GraphType *, GraphType *, int, float *);
+void MocAllocateKWayPartitionMemory(CtrlType *, GraphType *, int);
+void MocComputeKWayPartitionParams(CtrlType *, GraphType *, int);
+void MocProjectKWayPartition(CtrlType *, GraphType *, int);
+void MocComputeKWayBalanceBoundary(CtrlType *, GraphType *, int);
+
+/* mmatch.c */
+void MCMatch_RM(CtrlType *, GraphType *);
+void MCMatch_HEM(CtrlType *, GraphType *);
+void MCMatch_SHEM(CtrlType *, GraphType *);
+void MCMatch_SHEBM(CtrlType *, GraphType *, int);
+void MCMatch_SBHEM(CtrlType *, GraphType *, int);
+float BetterVBalance(int, int, float *, float *, float *);
+int AreAllVwgtsBelowFast(int, float *, float *, float);
+
+/* mmd.c */
+void genmmd(int, idxtype *, idxtype *, idxtype *, idxtype *, int , idxtype *, idxtype *, idxtype *, idxtype *, int, int *);
+void mmdelm(int, idxtype *xadj, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, int, int);
+int  mmdint(int, idxtype *xadj, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *);
+void mmdnum(int, idxtype *, idxtype *, idxtype *);
+void mmdupd(int, int, idxtype *, idxtype *, int, int *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, int, int *tag);
+
+/* mpmetis.c */
+void METIS_mCPartGraphRecursive(int *, int *, idxtype *, idxtype *, idxtype *, idxtype *, int *, int *, int *, int *, int *, idxtype *);
+void METIS_mCHPartGraphRecursive(int *, int *, idxtype *, idxtype *, idxtype *, idxtype *, int *, int *, int *, float *, int *, int *, idxtype *);
+void METIS_mCPartGraphRecursiveInternal(int *, int *, idxtype *, idxtype *, float *, idxtype *, int *, int *, int *, idxtype *);
+void METIS_mCHPartGraphRecursiveInternal(int *, int *, idxtype *, idxtype *, float *, idxtype *, int *, float *, int *, int *, idxtype *);
+int MCMlevelRecursiveBisection(CtrlType *, GraphType *, int, idxtype *, float, int);
+int MCHMlevelRecursiveBisection(CtrlType *, GraphType *, int, idxtype *, float *, int);
+void MCMlevelEdgeBisection(CtrlType *, GraphType *, float *, float);
+void MCHMlevelEdgeBisection(CtrlType *, GraphType *, float *, float *);
+
+/* mrefine.c */
+void MocRefine2Way(CtrlType *, GraphType *, GraphType *, float *, float);
+void MocAllocate2WayPartitionMemory(CtrlType *, GraphType *);
+void MocCompute2WayPartitionParams(CtrlType *, GraphType *);
+void MocProject2WayPartition(CtrlType *, GraphType *);
+
+/* mrefine2.c */
+void MocRefine2Way2(CtrlType *, GraphType *, GraphType *, float *, float *);
+
+/* mutil.c */
+int AreAllVwgtsBelow(int, float, float *, float, float *, float);
+int AreAnyVwgtsBelow(int, float, float *, float, float *, float);
+int AreAllVwgtsAbove(int, float, float *, float, float *, float);
+float ComputeLoadImbalance(int, int, float *, float *);
+int AreAllBelow(int, float *, float *);
+
+/* myqsort.c */
+void iidxsort(int, idxtype *);
+void iintsort(int, int *);
+void ikeysort(int, KeyValueType *);
+void ikeyvalsort(int, KeyValueType *);
+
+/* ometis.c */
+void METIS_EdgeND(int *, idxtype *, idxtype *, int *, int *, idxtype *, idxtype *); 
+void METIS_NodeND(int *, idxtype *, idxtype *, int *, int *, idxtype *, idxtype *); 
+void METIS_NodeWND(int *, idxtype *, idxtype *, idxtype *, int *, int *, idxtype *, idxtype *); 
+void MlevelNestedDissection(CtrlType *, GraphType *, idxtype *, float, int);
+void MlevelNestedDissectionCC(CtrlType *, GraphType *, idxtype *, float, int);
+void MlevelNodeBisectionMultiple(CtrlType *, GraphType *, int *, float);
+void MlevelNodeBisection(CtrlType *, GraphType *, int *, float);
+void SplitGraphOrder(CtrlType *, GraphType *, GraphType *, GraphType *);
+void MMDOrder(CtrlType *, GraphType *, idxtype *, int);
+int SplitGraphOrderCC(CtrlType *, GraphType *, GraphType *, int, idxtype *, idxtype *);
+
+/* parmetis.c */
+void METIS_PartGraphKway2(int *, idxtype *, idxtype *, idxtype *, idxtype *, int *, int *, int *, int *, int *, idxtype *); 
+void METIS_WPartGraphKway2(int *, idxtype *, idxtype *, idxtype *, idxtype *, int *, int *, int *, float *, int *, int *, idxtype *); 
+void METIS_NodeNDP(int, idxtype *, idxtype *, int, int *, idxtype *, idxtype *, idxtype *);
+void MlevelNestedDissectionP(CtrlType *, GraphType *, idxtype *, int, int, int, idxtype *);
+void METIS_NodeComputeSeparator(int *, idxtype *, idxtype *, idxtype *, idxtype *, int *, int *, idxtype *); 
+void METIS_EdgeComputeSeparator(int *, idxtype *, idxtype *, idxtype *, idxtype *, int *, int *, idxtype *); 
+
+/* pmetis.c */
+void METIS_PartGraphRecursive(int *, idxtype *, idxtype *, idxtype *, idxtype *, int *, int *, int *, int *, int *, idxtype *); 
+void METIS_WPartGraphRecursive(int *, idxtype *, idxtype *, idxtype *, idxtype *, int *, int *, int *, float *, int *, int *, idxtype *); 
+int MlevelRecursiveBisection(CtrlType *, GraphType *, int, idxtype *, float *, float, int);
+void MlevelEdgeBisection(CtrlType *, GraphType *, int *, float);
+void SplitGraphPart(CtrlType *, GraphType *, GraphType *, GraphType *);
+void SetUpSplitGraph(GraphType *, GraphType *, int, int);
+
+/* pqueue.c */
+void PQueueInit(CtrlType *ctrl, PQueueType *, int, int);
+void PQueueReset(PQueueType *);
+void PQueueFree(CtrlType *ctrl, PQueueType *);
+int PQueueGetSize(PQueueType *);
+int PQueueInsert(PQueueType *, int, int);
+int PQueueDelete(PQueueType *, int, int);
+int PQueueUpdate(PQueueType *, int, int, int);
+void PQueueUpdateUp(PQueueType *, int, int, int);
+int PQueueGetMax(PQueueType *);
+int PQueueSeeMax(PQueueType *);
+int PQueueGetKey(PQueueType *);
+int CheckHeap(PQueueType *);
+
+/* refine.c */
+void Refine2Way(CtrlType *, GraphType *, GraphType *, int *, float ubfactor);
+void Allocate2WayPartitionMemory(CtrlType *, GraphType *);
+void Compute2WayPartitionParams(CtrlType *, GraphType *);
+void Project2WayPartition(CtrlType *, GraphType *);
+
+/* separator.c */
+void ConstructSeparator(CtrlType *, GraphType *, float);
+void ConstructMinCoverSeparator0(CtrlType *, GraphType *, float);
+void ConstructMinCoverSeparator(CtrlType *, GraphType *, float);
+
+/* sfm.c */
+void FM_2WayNodeRefine(CtrlType *, GraphType *, float, int);
+void FM_2WayNodeRefineEqWgt(CtrlType *, GraphType *, int);
+void FM_2WayNodeRefine_OneSided(CtrlType *, GraphType *, float, int);
+void FM_2WayNodeBalance(CtrlType *, GraphType *, float);
+int ComputeMaxNodeGain(int, idxtype *, idxtype *, idxtype *);
+
+/* srefine.c */
+void Refine2WayNode(CtrlType *, GraphType *, GraphType *, float);
+void Allocate2WayNodePartitionMemory(CtrlType *, GraphType *);
+void Compute2WayNodePartitionParams(CtrlType *, GraphType *);
+void Project2WayNodePartition(CtrlType *, GraphType *);
+
+/* stat.c */
+void ComputePartitionInfo(GraphType *, int, idxtype *);
+void ComputePartitionInfoBipartite(GraphType *, int, idxtype *);
+void ComputePartitionBalance(GraphType *, int, idxtype *, float *);
+float ComputeElementBalance(int, int, idxtype *);
+
+/* subdomains.c */
+void Random_KWayEdgeRefineMConn(CtrlType *, GraphType *, int, float *, float, int, int);
+void Greedy_KWayEdgeBalanceMConn(CtrlType *, GraphType *, int, float *, float, int);
+void PrintSubDomainGraph(GraphType *, int, idxtype *);
+void ComputeSubDomainGraph(GraphType *, int, idxtype *, idxtype *);
+void EliminateSubDomainEdges(CtrlType *, GraphType *, int, float *);
+void MoveGroupMConn(CtrlType *, GraphType *, idxtype *, idxtype *, int, int, int, idxtype *);
+void EliminateComponents(CtrlType *, GraphType *, int, float *, float);
+void MoveGroup(CtrlType *, GraphType *, int, int, int, idxtype *, idxtype *);
+
+/* timing.c */
+void InitTimers(CtrlType *);
+void PrintTimers(CtrlType *);
+double seconds(void);
+
+/* util.c */
+void errexit(char *,...);
+#ifndef DMALLOC
+int *imalloc(int, char *);
+idxtype *idxmalloc(int, char *);
+float *fmalloc(int, char *);
+int *ismalloc(int, int, char *);
+idxtype *idxsmalloc(int, idxtype, char *);
+void *GKmalloc(int, char *);
+#endif
+/*void GKfree(void **,...); */
+int *iset(int n, int val, int *x);
+idxtype *idxset(int n, idxtype val, idxtype *x);
+float *sset(int n, float val, float *x);
+int iamax(int, int *);
+int idxamax(int, idxtype *);
+int idxamax_strd(int, idxtype *, int);
+int samax(int, float *);
+int samax2(int, float *);
+int idxamin(int, idxtype *);
+int samin(int, float *);
+int idxsum(int, idxtype *);
+int idxsum_strd(int, idxtype *, int);
+void idxadd(int, idxtype *, idxtype *);
+int charsum(int, char *);
+int isum(int, int *);
+float ssum(int, float *);
+float ssum_strd(int n, float *x, int);
+void sscale(int n, float, float *x);
+float snorm2(int, float *);
+float sdot(int n, float *, float *);
+void saxpy(int, float, float *, int, float *, int);
+void RandomPermute(int, idxtype *, int);
+double drand48();
+void srand48(long);
+int ispow2(int);
+void InitRandom(int);
+int log2(int);
+
+
+
+
+
+
+
+
+
+
+/***************************************************************
+* Programs Directory
+****************************************************************/
+
+/* io.c */
+void ReadGraph(GraphType *, char *, int *);
+void WritePartition(char *, idxtype *, int, int);
+void WriteMeshPartition(char *, int, int, idxtype *, int, idxtype *);
+void WritePermutation(char *, idxtype *, int);
+int CheckGraph(GraphType *);
+idxtype *ReadMesh(char *, int *, int *, int *);
+void WriteGraph(char *, int, idxtype *, idxtype *);
+
+/* smbfactor.c */
+void ComputeFillIn(GraphType *, idxtype *);
+idxtype ComputeFillIn2(GraphType *, idxtype *);
+int smbfct(int, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, int *, idxtype *, idxtype *, int *);
+
+
+/***************************************************************
+* Test Directory
+****************************************************************/
+void Test_PartGraph(int, idxtype *, idxtype *);
+int VerifyPart(int, idxtype *, idxtype *, idxtype *, idxtype *, int, int, idxtype *);
+int VerifyWPart(int, idxtype *, idxtype *, idxtype *, idxtype *, int, float *, int, idxtype *);
+void Test_PartGraphV(int, idxtype *, idxtype *);
+int VerifyPartV(int, idxtype *, idxtype *, idxtype *, idxtype *, int, int, idxtype *);
+int VerifyWPartV(int, idxtype *, idxtype *, idxtype *, idxtype *, int, float *, int, idxtype *);
+void Test_PartGraphmC(int, idxtype *, idxtype *);
+int VerifyPartmC(int, int, idxtype *, idxtype *, idxtype *, idxtype *, int, float *, int, idxtype *);
+void Test_ND(int, idxtype *, idxtype *);
+int VerifyND(int, idxtype *, idxtype *);
+
Index: /inundation/pymetis/metis-4.0/Lib/refine.c
===================================================================
--- /inundation/pymetis/metis-4.0/Lib/refine.c	(revision 2051)
+++ /inundation/pymetis/metis-4.0/Lib/refine.c	(revision 2051)
@@ -0,0 +1,204 @@
+/*
+ * Copyright 1997, Regents of the University of Minnesota
+ *
+ * refine.c
+ *
+ * This file contains the driving routines for multilevel refinement
+ *
+ * Started 7/24/97
+ * George
+ *
+ * $Id: refine.c,v 1.1 1998/11/27 17:59:29 karypis Exp $
+ */
+
+#include <metis.h>
+
+
+/*************************************************************************
+* This function is the entry point of refinement
+**************************************************************************/
+void Refine2Way(CtrlType *ctrl, GraphType *orggraph, GraphType *graph, int *tpwgts, float ubfactor)
+{
+
+  IFSET(ctrl->dbglvl, DBG_TIME, starttimer(ctrl->UncoarsenTmr));
+
+  /* Compute the parameters of the coarsest graph */
+  Compute2WayPartitionParams(ctrl, graph);
+
+  for (;;) {
+    ASSERT(CheckBnd(graph));
+
+    IFSET(ctrl->dbglvl, DBG_TIME, starttimer(ctrl->RefTmr));
+    switch (ctrl->RType) {
+      case 1:
+        Balance2Way(ctrl, graph, tpwgts, ubfactor);
+        FM_2WayEdgeRefine(ctrl, graph, tpwgts, 8); 
+        break;
+      default:
+        errexit("Unknown refinement type: %d\n", ctrl->RType);
+    }
+    IFSET(ctrl->dbglvl, DBG_TIME, stoptimer(ctrl->RefTmr));
+
+    if (graph == orggraph)
+      break;
+
+    graph = graph->finer;
+    IFSET(ctrl->dbglvl, DBG_TIME, starttimer(ctrl->ProjectTmr));
+    Project2WayPartition(ctrl, graph);
+    IFSET(ctrl->dbglvl, DBG_TIME, stoptimer(ctrl->ProjectTmr));
+  }
+
+  IFSET(ctrl->dbglvl, DBG_TIME, stoptimer(ctrl->UncoarsenTmr));
+}
+
+
+/*************************************************************************
+* This function allocates memory for 2-way edge refinement
+**************************************************************************/
+void Allocate2WayPartitionMemory(CtrlType *ctrl, GraphType *graph)
+{
+  int nvtxs;
+
+  nvtxs = graph->nvtxs;
+
+  graph->rdata = idxmalloc(5*nvtxs+2, "Allocate2WayPartitionMemory: rdata");
+  graph->pwgts 		= graph->rdata;
+  graph->where		= graph->rdata + 2;
+  graph->id		= graph->rdata + nvtxs + 2;
+  graph->ed		= graph->rdata + 2*nvtxs + 2;
+  graph->bndptr		= graph->rdata + 3*nvtxs + 2;
+  graph->bndind		= graph->rdata + 4*nvtxs + 2;
+}
+
+
+/*************************************************************************
+* This function computes the initial id/ed 
+**************************************************************************/
+void Compute2WayPartitionParams(CtrlType *ctrl, GraphType *graph)
+{
+  int i, j, k, l, nvtxs, nbnd, mincut;
+  idxtype *xadj, *vwgt, *adjncy, *adjwgt, *pwgts;
+  idxtype *id, *ed, *where;
+  idxtype *bndptr, *bndind;
+  int me, other;
+
+  nvtxs = graph->nvtxs;
+  xadj = graph->xadj;
+  vwgt = graph->vwgt;
+  adjncy = graph->adjncy;
+  adjwgt = graph->adjwgt;
+
+  where = graph->where;
+  pwgts = idxset(2, 0, graph->pwgts);
+  id = idxset(nvtxs, 0, graph->id);
+  ed = idxset(nvtxs, 0, graph->ed);
+  bndptr = idxset(nvtxs, -1, graph->bndptr);
+  bndind = graph->bndind;
+
+
+  /*------------------------------------------------------------
+  / Compute now the id/ed degrees
+  /------------------------------------------------------------*/
+  nbnd = mincut = 0;
+  for (i=0; i<nvtxs; i++) {
+    ASSERT(where[i] >= 0 && where[i] <= 1);
+    me = where[i];
+    pwgts[me] += vwgt[i];
+
+    for (j=xadj[i]; j<xadj[i+1]; j++) {
+      if (me == where[adjncy[j]])
+        id[i] += adjwgt[j];
+      else
+        ed[i] += adjwgt[j];
+    }
+
+    if (ed[i] > 0 || xadj[i] == xadj[i+1]) {
+      mincut += ed[i];
+      bndptr[i] = nbnd;
+      bndind[nbnd++] = i;
+    }
+  }
+
+  graph->mincut = mincut/2;
+  graph->nbnd = nbnd;
+
+  ASSERT(pwgts[0]+pwgts[1] == idxsum(nvtxs, vwgt));
+}
+
+
+
+/*************************************************************************
+* This function projects a partition, and at the same time computes the
+* parameters for refinement.
+**************************************************************************/
+void Project2WayPartition(CtrlType *ctrl, GraphType *graph)
+{
+  int i, j, k, nvtxs, nbnd, me;
+  idxtype *xadj, *adjncy, *adjwgt, *adjwgtsum;
+  idxtype *cmap, *where, *id, *ed, *bndptr, *bndind;
+  idxtype *cwhere, *cid, *ced, *cbndptr;
+  GraphType *cgraph;
+
+  cgraph = graph->coarser;
+  cwhere = cgraph->where;
+  cid = cgraph->id;
+  ced = cgraph->ed;
+  cbndptr = cgraph->bndptr;
+
+  nvtxs = graph->nvtxs;
+  cmap = graph->cmap;
+  xadj = graph->xadj;
+  adjncy = graph->adjncy;
+  adjwgt = graph->adjwgt;
+  adjwgtsum = graph->adjwgtsum;
+
+  Allocate2WayPartitionMemory(ctrl, graph);
+
+  where = graph->where;
+  id = idxset(nvtxs, 0, graph->id);
+  ed = idxset(nvtxs, 0, graph->ed);
+  bndptr = idxset(nvtxs, -1, graph->bndptr);
+  bndind = graph->bndind;
+
+
+  /* Go through and project partition and compute id/ed for the nodes */
+  for (i=0; i<nvtxs; i++) {
+    k = cmap[i];
+    where[i] = cwhere[k];
+    cmap[i] = cbndptr[k];
+  }
+
+  for (nbnd=0, i=0; i<nvtxs; i++) {
+    me = where[i];
+
+    id[i] = adjwgtsum[i];
+
+    if (xadj[i] == xadj[i+1]) {
+      bndptr[i] = nbnd;
+      bndind[nbnd++] = i;
+    }
+    else {
+      if (cmap[i] != -1) { /* If it is an interface node. Note that cmap[i] = cbndptr[cmap[i]] */
+        for (j=xadj[i]; j<xadj[i+1]; j++) {
+          if (me != where[adjncy[j]])
+            ed[i] += adjwgt[j];
+        }
+        id[i] -= ed[i];
+
+        if (ed[i] > 0 || xadj[i] == xadj[i+1]) {
+          bndptr[i] = nbnd;
+          bndind[nbnd++] = i;
+        }
+      }
+    }
+  }
+
+  graph->mincut = cgraph->mincut;
+  graph->nbnd = nbnd;
+  idxcopy(2, cgraph->pwgts, graph->pwgts);
+
+  FreeGraph(graph->coarser);
+  graph->coarser = NULL;
+
+}
+
Index: /inundation/pymetis/metis-4.0/Lib/rename.h
===================================================================
--- /inundation/pymetis/metis-4.0/Lib/rename.h	(revision 2051)
+++ /inundation/pymetis/metis-4.0/Lib/rename.h	(revision 2051)
@@ -0,0 +1,418 @@
+/*
+ * Copyright 1997, Regents of the University of Minnesota
+ *
+ * rename.h
+ *
+ * This file contains header files
+ *
+ * Started 10/2/97
+ * George
+ *
+ * $Id: rename.h,v 1.1 1998/11/27 17:59:29 karypis Exp $
+ *
+ */
+
+/* balance.c */
+#define Balance2Way			__Balance2Way
+#define Bnd2WayBalance			__Bnd2WayBalance
+#define General2WayBalance		__General2WayBalance
+
+
+/* bucketsort.c */
+#define BucketSortKeysInc		__BucketSortKeysInc
+
+
+/* ccgraph.c */
+#define CreateCoarseGraph		__CreateCoarseGraph
+#define CreateCoarseGraphNoMask		__CreateCoarseGraphNoMask
+#define CreateCoarseGraph_NVW 		__CreateCoarseGraph_NVW
+#define SetUpCoarseGraph		__SetUpCoarseGraph
+#define ReAdjustMemory			__ReAdjustMemory
+
+
+/* coarsen.c */
+#define Coarsen2Way			__Coarsen2Way
+
+
+/* compress.c */
+#define CompressGraph			__CompressGraph
+#define PruneGraph			__PruneGraph
+
+
+/* debug.c */
+#define ComputeCut			__ComputeCut
+#define CheckBnd			__CheckBnd
+#define CheckBnd2			__CheckBnd2
+#define CheckNodeBnd			__CheckNodeBnd
+#define CheckRInfo			__CheckRInfo
+#define CheckNodePartitionParams	__CheckNodePartitionParams
+#define IsSeparable			__IsSeparable
+
+
+/* estmem.c */
+#define EstimateCFraction		__EstimateCFraction
+#define ComputeCoarseGraphSize		__ComputeCoarseGraphSize
+
+
+/* fm.c */
+#define FM_2WayEdgeRefine		__FM_2WayEdgeRefine
+
+
+/* fortran.c */
+#define Change2CNumbering		__Change2CNumbering
+#define Change2FNumbering		__Change2FNumbering
+#define Change2FNumbering2		__Change2FNumbering2
+#define Change2FNumberingOrder		__Change2FNumberingOrder
+#define ChangeMesh2CNumbering		__ChangeMesh2CNumbering
+#define ChangeMesh2FNumbering		__ChangeMesh2FNumbering
+#define ChangeMesh2FNumbering2		__ChangeMesh2FNumbering2
+
+
+/* graph.c */
+#define SetUpGraph			__SetUpGraph
+#define SetUpGraphKway 			__SetUpGraphKway
+#define SetUpGraph2			__SetUpGraph2
+#define VolSetUpGraph			__VolSetUpGraph
+#define RandomizeGraph			__RandomizeGraph
+#define IsConnectedSubdomain		__IsConnectedSubdomain
+#define IsConnected			__IsConnected
+#define IsConnected2			__IsConnected2
+#define FindComponents			__FindComponents
+
+
+/* initpart.c */
+#define Init2WayPartition		__Init2WayPartition
+#define InitSeparator			__InitSeparator
+#define GrowBisection			__GrowBisection
+#define GrowBisectionNode		__GrowBisectionNode
+#define RandomBisection			__RandomBisection
+
+
+/* kmetis.c */
+#define MlevelKWayPartitioning		__MlevelKWayPartitioning
+
+
+/* kvmetis.c */
+#define MlevelVolKWayPartitioning	__MlevelVolKWayPartitioning
+
+
+/* kwayfm.c */
+#define Random_KWayEdgeRefine		__Random_KWayEdgeRefine
+#define Greedy_KWayEdgeRefine		__Greedy_KWayEdgeRefine
+#define Greedy_KWayEdgeBalance		__Greedy_KWayEdgeBalance
+
+
+/* kwayrefine.c */
+#define RefineKWay			__RefineKWay
+#define AllocateKWayPartitionMemory	__AllocateKWayPartitionMemory
+#define ComputeKWayPartitionParams	__ComputeKWayPartitionParams
+#define ProjectKWayPartition		__ProjectKWayPartition
+#define IsBalanced			__IsBalanced
+#define ComputeKWayBoundary		__ComputeKWayBoundary
+#define ComputeKWayBalanceBoundary	__ComputeKWayBalanceBoundary
+
+
+/* kwayvolfm.c */
+#define Random_KWayVolRefine		__Random_KWayVolRefine
+#define Random_KWayVolRefineMConn	__Random_KWayVolRefineMConn
+#define Greedy_KWayVolBalance		__Greedy_KWayVolBalance
+#define Greedy_KWayVolBalanceMConn	__Greedy_KWayVolBalanceMConn
+#define KWayVolUpdate			__KWayVolUpdate
+#define ComputeKWayVolume		__ComputeKWayVolume
+#define ComputeVolume			__ComputeVolume
+#define CheckVolKWayPartitionParams	__CheckVolKWayPartitionParams
+#define ComputeVolSubDomainGraph	__ComputeVolSubDomainGraph
+#define EliminateVolSubDomainEdges	__EliminateVolSubDomainEdges
+
+
+/* kwayvolrefine.c */
+#define RefineVolKWay			__RefineVolKWay
+#define AllocateVolKWayPartitionMemory	__AllocateVolKWayPartitionMemory
+#define ComputeVolKWayPartitionParams	__ComputeVolKWayPartitionParams
+#define ComputeKWayVolGains		__ComputeKWayVolGains
+#define ProjectVolKWayPartition		__ProjectVolKWayPartition
+#define ComputeVolKWayBoundary		__ComputeVolKWayBoundary
+#define ComputeVolKWayBalanceBoundary	__ComputeVolKWayBalanceBoundary
+
+
+/* match.c */
+#define Match_RM			__Match_RM
+#define Match_RM_NVW			__Match_RM_NVW
+#define Match_HEM			__Match_HEM
+#define Match_SHEM			__Match_SHEM
+
+
+/* mbalance.c */
+#define MocBalance2Way			__MocBalance2Way
+#define MocGeneral2WayBalance		__MocGeneral2WayBalance
+
+
+/* mbalance2.c */
+#define MocBalance2Way2			__MocBalance2Way2
+#define MocGeneral2WayBalance2		__MocGeneral2WayBalance2
+#define SelectQueue3			__SelectQueue3
+
+
+/* mcoarsen.c */
+#define MCCoarsen2Way			__MCCoarsen2Way
+
+
+/* memory.c */
+#define AllocateWorkSpace		__AllocateWorkSpace
+#define FreeWorkSpace			__FreeWorkSpace
+#define WspaceAvail			__WspaceAvail
+#define idxwspacemalloc			__idxwspacemalloc
+#define idxwspacefree			__idxwspacefree
+#define fwspacemalloc			__fwspacemalloc
+#define CreateGraph			__CreateGraph
+#define InitGraph			__InitGraph
+#define FreeGraph			__FreeGraph
+
+
+/* mesh.c */
+#define TRIDUALMETIS			__TRIDUALMETIS
+#define TETDUALMETIS			__TETDUALMETIS
+#define HEXDUALMETIS			__HEXDUALMETIS
+#define TRINODALMETIS			__TRINODALMETIS
+#define TETNODALMETIS			__TETNODALMETIS
+#define HEXNODALMETIS			__HEXNODALMETIS
+
+
+/* mfm.c */
+#define MocFM_2WayEdgeRefine		__MocFM_2WayEdgeRefine
+#define SelectQueue			__SelectQueue
+#define BetterBalance			__BetterBalance
+#define Compute2WayHLoadImbalance	__Compute2WayHLoadImbalance
+#define Compute2WayHLoadImbalanceVec	__Compute2WayHLoadImbalanceVec
+
+
+/* mfm2.c */
+#define MocFM_2WayEdgeRefine2		__MocFM_2WayEdgeRefine2
+#define SelectQueue2			__SelectQueue2
+#define IsBetter2wayBalance		__IsBetter2wayBalance
+
+
+/* mincover.c */
+#define MinCover			__MinCover
+#define MinCover_Augment		__MinCover_Augment
+#define MinCover_Decompose		__MinCover_Decompose
+#define MinCover_ColDFS			__MinCover_ColDFS
+#define MinCover_RowDFS			__MinCover_RowDFS
+
+
+/* minitpart.c */
+#define MocInit2WayPartition		__MocInit2WayPartition
+#define MocGrowBisection		__MocGrowBisection
+#define MocRandomBisection		__MocRandomBisection
+#define MocInit2WayBalance		__MocInit2WayBalance
+#define SelectQueueoneWay		__SelectQueueoneWay
+
+
+/* minitpart2.c */
+#define MocInit2WayPartition2		__MocInit2WayPartition2
+#define MocGrowBisection2		__MocGrowBisection2
+#define MocGrowBisectionNew2		__MocGrowBisectionNew2
+#define MocInit2WayBalance2		__MocInit2WayBalance2
+#define SelectQueueOneWay2		__SelectQueueOneWay2
+
+
+/* mkmetis.c */
+#define MCMlevelKWayPartitioning	__MCMlevelKWayPartitioning
+
+
+/* mkwayfmh.c */
+#define MCRandom_KWayEdgeRefineHorizontal	__MCRandom_KWayEdgeRefineHorizontal
+#define MCGreedy_KWayEdgeBalanceHorizontal	__MCGreedy_KWayEdgeBalanceHorizontal
+#define AreAllHVwgtsBelow			__AreAllHVwgtsBelow
+#define AreAllHVwgtsAbove			__AreAllHVwgtsAbove
+#define ComputeHKWayLoadImbalance		__ComputeHKWayLoadImbalance
+#define MocIsHBalanced				__MocIsHBalanced
+#define IsHBalanceBetterFT			__IsHBalanceBetterFT
+#define IsHBalanceBetterTT			__IsHBalanceBetterTT
+
+
+/* mkwayrefine.c */
+#define MocRefineKWayHorizontal		__MocRefineKWayHorizontal
+#define MocAllocateKWayPartitionMemory	__MocAllocateKWayPartitionMemory
+#define MocComputeKWayPartitionParams	__MocComputeKWayPartitionParams
+#define MocProjectKWayPartition		__MocProjectKWayPartition
+#define MocComputeKWayBalanceBoundary	__MocComputeKWayBalanceBoundary
+
+
+/* mmatch.c */
+#define MCMatch_RM			__MCMatch_RM
+#define MCMatch_HEM			__MCMatch_HEM
+#define MCMatch_SHEM			__MCMatch_SHEM
+#define MCMatch_SHEBM			__MCMatch_SHEBM
+#define MCMatch_SBHEM			__MCMatch_SBHEM
+#define BetterVBalance			__BetterVBalance
+#define AreAllVwgtsBelowFast		__AreAllVwgtsBelowFast
+
+
+/* mmd.c */
+#define genmmd				__genmmd
+#define mmdelm				__mmdelm
+#define mmdint				__mmdint
+#define mmdnum				__mmdnum
+#define mmdupd				__mmdupd
+
+
+/* mpmetis.c */
+#define MCMlevelRecursiveBisection	__MCMlevelRecursiveBisection
+#define MCHMlevelRecursiveBisection	__MCHMlevelRecursiveBisection
+#define MCMlevelEdgeBisection		__MCMlevelEdgeBisection
+#define MCHMlevelEdgeBisection		__MCHMlevelEdgeBisection
+
+
+/* mrefine.c */
+#define MocRefine2Way			__MocRefine2Way
+#define MocAllocate2WayPartitionMemory	__MocAllocate2WayPartitionMemory
+#define MocCompute2WayPartitionParams	__MocCompute2WayPartitionParams
+#define MocProject2WayPartition		__MocProject2WayPartition
+
+
+/* mrefine2.c */
+#define MocRefine2Way2			__MocRefine2Way2
+
+
+/* mutil.c */
+#define AreAllVwgtsBelow		__AreAllVwgtsBelow
+#define AreAnyVwgtsBelow		__AreAnyVwgtsBelow
+#define AreAllVwgtsAbove		__AreAllVwgtsAbove
+#define ComputeLoadImbalance		__ComputeLoadImbalance
+#define AreAllBelow			__AreAllBelow
+
+
+/* myqsort.c */
+#define iidxsort			__iidxsort
+#define iintsort			__iintsort
+#define ikeysort			__ikeysort
+#define ikeyvalsort			__ikeyvalsort
+
+
+/* ometis.c */
+#define MlevelNestedDissection		__MlevelNestedDissection
+#define MlevelNestedDissectionCC	__MlevelNestedDissectionCC
+#define MlevelNodeBisectionMultiple	__MlevelNodeBisectionMultiple
+#define MlevelNodeBisection		__MlevelNodeBisection
+#define SplitGraphOrder			__SplitGraphOrder
+#define MMDOrder			__MMDOrder
+#define SplitGraphOrderCC		__SplitGraphOrderCC
+
+
+/* parmetis.c */
+#define MlevelNestedDissectionP		__MlevelNestedDissectionP
+
+
+/* pmetis.c */
+#define MlevelRecursiveBisection	__MlevelRecursiveBisection
+#define MlevelEdgeBisection		__MlevelEdgeBisection
+#define SplitGraphPart			__SplitGraphPart
+#define SetUpSplitGraph			__SetUpSplitGraph
+
+
+/* pqueue.c */
+#define PQueueInit			__PQueueInit
+#define PQueueReset			__PQueueReset
+#define PQueueFree			__PQueueFree
+#define PQueueInsert			__PQueueInsert
+#define PQueueDelete			__PQueueDelete
+#define PQueueUpdate			__PQueueUpdate
+#define PQueueUpdateUp			__PQueueUpdateUp
+#define PQueueGetMax			__PQueueGetMax
+#define PQueueSeeMax			__PQueueSeeMax
+#define CheckHeap			__CheckHeap
+
+
+/* refine.c */
+#define Refine2Way			__Refine2Way
+#define Allocate2WayPartitionMemory	__Allocate2WayPartitionMemory
+#define Compute2WayPartitionParams	__Compute2WayPartitionParams
+#define Project2WayPartition		__Project2WayPartition
+
+
+/* separator.c */
+#define ConstructSeparator		__ConstructSeparator
+#define ConstructMinCoverSeparator0	__ConstructMinCoverSeparator0
+#define ConstructMinCoverSeparator	__ConstructMinCoverSeparator
+
+
+/* sfm.c */
+#define FM_2WayNodeRefine		__FM_2WayNodeRefine
+#define FM_2WayNodeRefineEqWgt		__FM_2WayNodeRefineEqWgt
+#define FM_2WayNodeRefine_OneSided	__FM_2WayNodeRefine_OneSided
+#define FM_2WayNodeBalance		__FM_2WayNodeBalance
+#define ComputeMaxNodeGain		__ComputeMaxNodeGain
+
+
+/* srefine.c */
+#define Refine2WayNode			__Refine2WayNode
+#define Allocate2WayNodePartitionMemory	__Allocate2WayNodePartitionMemory
+#define Compute2WayNodePartitionParams	__Compute2WayNodePartitionParams
+#define Project2WayNodePartition	__Project2WayNodePartition
+
+
+/* stat.c */
+#define ComputePartitionInfo		__ComputePartitionInfo
+#define ComputePartitionBalance		__ComputePartitionBalance
+#define ComputeElementBalance		__ComputeElementBalance
+
+
+/* subdomains.c */
+#define Random_KWayEdgeRefineMConn	__Random_KWayEdgeRefineMConn
+#define Greedy_KWayEdgeBalanceMConn	__Greedy_KWayEdgeBalanceMConn
+#define PrintSubDomainGraph		__PrintSubDomainGraph
+#define ComputeSubDomainGraph		__ComputeSubDomainGraph
+#define EliminateSubDomainEdges		__EliminateSubDomainEdges
+#define MoveGroupMConn			__MoveGroupMConn
+#define EliminateComponents		__EliminateComponents
+#define MoveGroup			__MoveGroup
+
+
+/* timing.c */
+#define InitTimers			__InitTimers
+#define PrintTimers			__PrintTimers
+#define seconds				__seconds
+
+
+/* util.c */
+#define errexit				__errexit
+#define GKfree				__GKfree
+#ifndef DMALLOC
+#define imalloc				__imalloc
+#define idxmalloc			__idxmalloc
+#define fmalloc				__fmalloc
+#define ismalloc			__ismalloc
+#define idxsmalloc			__idxsmalloc
+#define GKmalloc			__GKmalloc
+#endif
+#define iset				__iset
+#define idxset				__idxset
+#define sset				__sset
+#define iamax				__iamax
+#define idxamax				__idxamax
+#define idxamax_strd			__idxamax_strd
+#define samax				__samax
+#define samax2				__samax2
+#define idxamin				__idxamin
+#define samin				__samin
+#define idxsum				__idxsum
+#define idxsum_strd			__idxsum_strd
+#define idxadd				__idxadd
+#define charsum				__charsum
+#define isum				__isum
+#define ssum				__ssum
+#define ssum_strd			__ssum_strd
+#define sscale				__sscale
+#define snorm2				__snorm2
+#define sdot				__sdot
+#define saxpy				__saxpy
+#define RandomPermute			__RandomPermute
+#define ispow2				__ispow2
+#define InitRandom			__InitRandom
+#define log2				__log2
+
+
+
+
+
Index: /inundation/pymetis/metis-4.0/Lib/separator.c
===================================================================
--- /inundation/pymetis/metis-4.0/Lib/separator.c	(revision 2051)
+++ /inundation/pymetis/metis-4.0/Lib/separator.c	(revision 2051)
@@ -0,0 +1,284 @@
+/*
+ * Copyright 1997, Regents of the University of Minnesota
+ *
+ * separator.c
+ *
+ * This file contains code for separator extraction
+ *
+ * Started 8/1/97
+ * George
+ *
+ * $Id: separator.c,v 1.1 1998/11/27 17:59:30 karypis Exp $
+ *
+ */
+
+#include <metis.h>
+
+/*************************************************************************
+* This function takes a bisection and constructs a minimum weight vertex 
+* separator out of it. It uses the node-based separator refinement for it.
+**************************************************************************/
+void ConstructSeparator(CtrlType *ctrl, GraphType *graph, float ubfactor)
+{
+  int i, j, k, nvtxs, nbnd;
+  idxtype *xadj, *where, *bndind;
+
+  nvtxs = graph->nvtxs;
+  xadj = graph->xadj;
+  nbnd = graph->nbnd;
+  bndind = graph->bndind;
+
+  where = idxcopy(nvtxs, graph->where, idxwspacemalloc(ctrl, nvtxs));
+
+  /* Put the nodes in the boundary into the separator */
+  for (i=0; i<nbnd; i++) {
+    j = bndind[i];
+    if (xadj[j+1]-xadj[j] > 0)  /* Ignore islands */
+      where[j] = 2;
+  }
+
+  GKfree(&graph->rdata, LTERM);
+  Allocate2WayNodePartitionMemory(ctrl, graph);
+  idxcopy(nvtxs, where, graph->where);
+  idxwspacefree(ctrl, nvtxs);
+
+  ASSERT(IsSeparable(graph));
+
+  Compute2WayNodePartitionParams(ctrl, graph);
+
+  ASSERT(CheckNodePartitionParams(graph));
+
+  FM_2WayNodeRefine(ctrl, graph, ubfactor, 8); 
+
+  ASSERT(IsSeparable(graph));
+}
+
+
+
+/*************************************************************************
+* This function takes a bisection and constructs a minimum weight vertex 
+* separator out of it. It uses an unweighted minimum-cover algorithm
+* followed by node-based separator refinement.
+**************************************************************************/
+void ConstructMinCoverSeparator0(CtrlType *ctrl, GraphType *graph, float ubfactor)
+{
+  int i, ii, j, jj, k, l, nvtxs, nbnd, bnvtxs[3], bnedges[2], csize;
+  idxtype *xadj, *adjncy, *bxadj, *badjncy;
+  idxtype *where, *bndind, *bndptr, *vmap, *ivmap, *cover;
+
+
+  nvtxs = graph->nvtxs;
+  xadj = graph->xadj;
+  adjncy = graph->adjncy;
+
+  nbnd = graph->nbnd;
+  bndind = graph->bndind;
+  bndptr = graph->bndptr;
+  where = graph->where;
+
+  vmap = idxwspacemalloc(ctrl, nvtxs);
+  ivmap = idxwspacemalloc(ctrl, nbnd);
+  cover = idxwspacemalloc(ctrl, nbnd);
+
+  if (nbnd > 0) {
+    /* Go through the boundary and determine the sizes of the bipartite graph */
+    bnvtxs[0] = bnvtxs[1] = bnedges[0] = bnedges[1] = 0;
+    for (i=0; i<nbnd; i++) {
+      j = bndind[i];
+      k = where[j];
+      if (xadj[j+1]-xadj[j] > 0) {
+        bnvtxs[k]++;
+        bnedges[k] += xadj[j+1]-xadj[j];
+      }
+    }
+
+    bnvtxs[2] = bnvtxs[0]+bnvtxs[1];
+    bnvtxs[1] = bnvtxs[0];
+    bnvtxs[0] = 0;
+
+    bxadj = idxmalloc(bnvtxs[2]+1, "ConstructMinCoverSeparator: bxadj");
+    badjncy = idxmalloc(bnedges[0]+bnedges[1]+1, "ConstructMinCoverSeparator: badjncy");
+
+    /* Construct the ivmap and vmap */
+    ASSERT(idxset(nvtxs, -1, vmap) == vmap);
+    for (i=0; i<nbnd; i++) {
+      j = bndind[i];
+      k = where[j];
+      if (xadj[j+1]-xadj[j] > 0) {
+        vmap[j] = bnvtxs[k];
+        ivmap[bnvtxs[k]++] = j;
+      }
+    }
+
+    /* OK, go through and put the vertices of each part starting from 0 */
+    bnvtxs[1] = bnvtxs[0];
+    bnvtxs[0] = 0;
+    bxadj[0] = l = 0;
+    for (k=0; k<2; k++) {
+      for (ii=0; ii<nbnd; ii++) {
+        i = bndind[ii];
+        if (where[i] == k && xadj[i] < xadj[i+1]) {
+          for (j=xadj[i]; j<xadj[i+1]; j++) {
+            jj = adjncy[j];
+            if (where[jj] != k) {
+              ASSERT(bndptr[jj] != -1); 
+              ASSERTP(vmap[jj] != -1, ("%d %d %d\n", jj, vmap[jj], graph->bndptr[jj]));
+              badjncy[l++] = vmap[jj];
+            }
+          }
+          bxadj[++bnvtxs[k]] = l;
+        }
+      }
+    }
+
+    ASSERT(l <= bnedges[0]+bnedges[1]);
+
+    MinCover(bxadj, badjncy, bnvtxs[0], bnvtxs[1], cover, &csize);
+
+    IFSET(ctrl->dbglvl, DBG_SEPINFO,
+      printf("Nvtxs: %6d, [%5d %5d], Cut: %6d, SS: [%6d %6d], Cover: %6d\n", nvtxs, graph->pwgts[0], graph->pwgts[1], graph->mincut, bnvtxs[0], bnvtxs[1]-bnvtxs[0], csize));
+
+    for (i=0; i<csize; i++) {
+      j = ivmap[cover[i]];
+      where[j] = 2;
+    }
+
+    GKfree(&bxadj, &badjncy, LTERM);
+
+    for (i=0; i<nbnd; i++)
+      bndptr[bndind[i]] = -1;
+    for (nbnd=i=0; i<nvtxs; i++) {
+      if (where[i] == 2) {
+        bndind[nbnd] = i;
+        bndptr[i] = nbnd++;
+      }
+    }
+  }
+  else {
+    IFSET(ctrl->dbglvl, DBG_SEPINFO,
+      printf("Nvtxs: %6d, [%5d %5d], Cut: %6d, SS: [%6d %6d], Cover: %6d\n", nvtxs, graph->pwgts[0], graph->pwgts[1], graph->mincut, 0, 0, 0));
+  }
+
+  idxwspacefree(ctrl, nvtxs);
+  idxwspacefree(ctrl, graph->nbnd);
+  idxwspacefree(ctrl, graph->nbnd);
+  graph->nbnd = nbnd;
+
+
+  ASSERT(IsSeparable(graph));
+}
+
+
+
+/*************************************************************************
+* This function takes a bisection and constructs a minimum weight vertex 
+* separator out of it. It uses an unweighted minimum-cover algorithm
+* followed by node-based separator refinement.
+**************************************************************************/
+void ConstructMinCoverSeparator(CtrlType *ctrl, GraphType *graph, float ubfactor)
+{
+  int i, ii, j, jj, k, l, nvtxs, nbnd, bnvtxs[3], bnedges[2], csize;
+  idxtype *xadj, *adjncy, *bxadj, *badjncy;
+  idxtype *where, *bndind, *bndptr, *vmap, *ivmap, *cover;
+
+
+  nvtxs = graph->nvtxs;
+  xadj = graph->xadj;
+  adjncy = graph->adjncy;
+
+  nbnd = graph->nbnd;
+  bndind = graph->bndind;
+  bndptr = graph->bndptr;
+  where = graph->where;
+
+  vmap = idxwspacemalloc(ctrl, nvtxs);
+  ivmap = idxwspacemalloc(ctrl, nbnd);
+  cover = idxwspacemalloc(ctrl, nbnd);
+
+  if (nbnd > 0) {
+    /* Go through the boundary and determine the sizes of the bipartite graph */
+    bnvtxs[0] = bnvtxs[1] = bnedges[0] = bnedges[1] = 0;
+    for (i=0; i<nbnd; i++) {
+      j = bndind[i];
+      k = where[j];
+      if (xadj[j+1]-xadj[j] > 0) {
+        bnvtxs[k]++;
+        bnedges[k] += xadj[j+1]-xadj[j];
+      }
+    }
+
+    bnvtxs[2] = bnvtxs[0]+bnvtxs[1];
+    bnvtxs[1] = bnvtxs[0];
+    bnvtxs[0] = 0;
+
+    bxadj = idxmalloc(bnvtxs[2]+1, "ConstructMinCoverSeparator: bxadj");
+    badjncy = idxmalloc(bnedges[0]+bnedges[1]+1, "ConstructMinCoverSeparator: badjncy");
+
+    /* Construct the ivmap and vmap */
+    ASSERT(idxset(nvtxs, -1, vmap) == vmap);
+    for (i=0; i<nbnd; i++) {
+      j = bndind[i];
+      k = where[j];
+      if (xadj[j+1]-xadj[j] > 0) {
+        vmap[j] = bnvtxs[k];
+        ivmap[bnvtxs[k]++] = j;
+      }
+    }
+
+    /* OK, go through and put the vertices of each part starting from 0 */
+    bnvtxs[1] = bnvtxs[0];
+    bnvtxs[0] = 0;
+    bxadj[0] = l = 0;
+    for (k=0; k<2; k++) {
+      for (ii=0; ii<nbnd; ii++) {
+        i = bndind[ii];
+        if (where[i] == k && xadj[i] < xadj[i+1]) {
+          for (j=xadj[i]; j<xadj[i+1]; j++) {
+            jj = adjncy[j];
+            if (where[jj] != k) {
+              ASSERT(bndptr[jj] != -1); 
+              ASSERTP(vmap[jj] != -1, ("%d %d %d\n", jj, vmap[jj], graph->bndptr[jj]));
+              badjncy[l++] = vmap[jj];
+            }
+          }
+          bxadj[++bnvtxs[k]] = l;
+        }
+      }
+    }
+
+    ASSERT(l <= bnedges[0]+bnedges[1]);
+
+    MinCover(bxadj, badjncy, bnvtxs[0], bnvtxs[1], cover, &csize);
+
+    IFSET(ctrl->dbglvl, DBG_SEPINFO,
+      printf("Nvtxs: %6d, [%5d %5d], Cut: %6d, SS: [%6d %6d], Cover: %6d\n", nvtxs, graph->pwgts[0], graph->pwgts[1], graph->mincut, bnvtxs[0], bnvtxs[1]-bnvtxs[0], csize));
+
+    for (i=0; i<csize; i++) {
+      j = ivmap[cover[i]];
+      where[j] = 2;
+    }
+
+    GKfree(&bxadj, &badjncy, LTERM);
+  }
+  else {
+    IFSET(ctrl->dbglvl, DBG_SEPINFO,
+      printf("Nvtxs: %6d, [%5d %5d], Cut: %6d, SS: [%6d %6d], Cover: %6d\n", nvtxs, graph->pwgts[0], graph->pwgts[1], graph->mincut, 0, 0, 0));
+  }
+
+  /* Prepare to refine the vertex separator */
+  idxcopy(nvtxs, graph->where, vmap);
+  GKfree(&graph->rdata, LTERM);
+
+  Allocate2WayNodePartitionMemory(ctrl, graph);
+  idxcopy(nvtxs, vmap, graph->where);
+  idxwspacefree(ctrl, nvtxs+2*graph->nbnd);
+
+  Compute2WayNodePartitionParams(ctrl, graph);
+
+  ASSERT(CheckNodePartitionParams(graph));
+
+  FM_2WayNodeRefine_OneSided(ctrl, graph, ubfactor, 6); 
+
+  ASSERT(IsSeparable(graph));
+}
+
Index: /inundation/pymetis/metis-4.0/Lib/sfm.c
===================================================================
--- /inundation/pymetis/metis-4.0/Lib/sfm.c	(revision 2051)
+++ /inundation/pymetis/metis-4.0/Lib/sfm.c	(revision 2051)
@@ -0,0 +1,1069 @@
+/*
+ * Copyright 1997, Regents of the University of Minnesota
+ *
+ * sfm.c
+ *
+ * This file contains code that implementes an FM-based separator refinement
+ *
+ * Started 8/1/97
+ * George
+ *
+ * $Id: sfm.c,v 1.1 1998/11/27 17:59:30 karypis Exp $
+ *
+ */
+
+#include <metis.h>
+
+
+/*************************************************************************
+* This function performs a node-based FM refinement 
+**************************************************************************/
+void FM_2WayNodeRefine(CtrlType *ctrl, GraphType *graph, float ubfactor, int npasses)
+{
+  int i, ii, j, k, jj, kk, nvtxs, nbnd, nswaps, nmind;
+  idxtype *xadj, *vwgt, *adjncy, *where, *pwgts, *edegrees, *bndind, *bndptr;
+  idxtype *mptr, *mind, *moved, *swaps, *perm;
+  PQueueType parts[2]; 
+  NRInfoType *rinfo;
+  int higain, oldgain, mincut, initcut, mincutorder;	
+  int pass, to, other, limit;
+  int badmaxpwgt, mindiff, newdiff;
+  int u[2], g[2];
+
+  nvtxs = graph->nvtxs;
+  xadj = graph->xadj;
+  adjncy = graph->adjncy;
+  vwgt = graph->vwgt;
+
+  bndind = graph->bndind;
+  bndptr = graph->bndptr;
+  where = graph->where;
+  pwgts = graph->pwgts;
+  rinfo = graph->nrinfo;
+
+
+  i = ComputeMaxNodeGain(nvtxs, xadj, adjncy, vwgt);
+  PQueueInit(ctrl, &parts[0], nvtxs, i);
+  PQueueInit(ctrl, &parts[1], nvtxs, i);
+
+  moved = idxwspacemalloc(ctrl, nvtxs);
+  swaps = idxwspacemalloc(ctrl, nvtxs);
+  mptr = idxwspacemalloc(ctrl, nvtxs+1);
+  mind = idxwspacemalloc(ctrl, nvtxs);
+  perm = idxwspacemalloc(ctrl, nvtxs);
+
+  IFSET(ctrl->dbglvl, DBG_REFINE,
+    printf("Partitions: [%6d %6d] Nv-Nb[%6d %6d]. ISep: %6d\n", pwgts[0], pwgts[1], graph->nvtxs, graph->nbnd, graph->mincut));
+
+  badmaxpwgt = (int)(ubfactor*(pwgts[0]+pwgts[1]+pwgts[2])/2);
+
+  for (pass=0; pass<npasses; pass++) {
+    idxset(nvtxs, -1, moved);
+    PQueueReset(&parts[0]);
+    PQueueReset(&parts[1]);
+
+    mincutorder = -1;
+    initcut = mincut = graph->mincut;
+    nbnd = graph->nbnd;
+
+    RandomPermute(nbnd, perm, 1);
+    for (ii=0; ii<nbnd; ii++) {
+      i = bndind[perm[ii]];
+      ASSERT(where[i] == 2);
+      PQueueInsert(&parts[0], i, vwgt[i]-rinfo[i].edegrees[1]);
+      PQueueInsert(&parts[1], i, vwgt[i]-rinfo[i].edegrees[0]);
+    }
+
+    ASSERT(CheckNodeBnd(graph, nbnd));
+    ASSERT(CheckNodePartitionParams(graph));
+
+    limit = (ctrl->oflags&OFLAG_COMPRESS ? amin(5*nbnd, 400) : amin(2*nbnd, 300));
+
+    /******************************************************
+    * Get into the FM loop
+    *******************************************************/
+    mptr[0] = nmind = 0;
+    mindiff = abs(pwgts[0]-pwgts[1]);
+    to = (pwgts[0] < pwgts[1] ? 0 : 1);
+    for (nswaps=0; nswaps<nvtxs; nswaps++) {
+      u[0] = PQueueSeeMax(&parts[0]);  
+      u[1] = PQueueSeeMax(&parts[1]);
+      if (u[0] != -1 && u[1] != -1) {
+        g[0] = vwgt[u[0]]-rinfo[u[0]].edegrees[1];
+        g[1] = vwgt[u[1]]-rinfo[u[1]].edegrees[0];
+
+        to = (g[0] > g[1] ? 0 : (g[0] < g[1] ? 1 : pass%2)); 
+        /* to = (g[0] > g[1] ? 0 : (g[0] < g[1] ? 1 : (pwgts[0] < pwgts[1] ? 0 : 1))); */
+
+        if (pwgts[to]+vwgt[u[to]] > badmaxpwgt) 
+          to = (to+1)%2;
+      }
+      else if (u[0] == -1 && u[1] == -1) {
+        break;
+      }
+      else if (u[0] != -1 && pwgts[0]+vwgt[u[0]] <= badmaxpwgt) {
+        to = 0;
+      }
+      else if (u[1] != -1 && pwgts[1]+vwgt[u[1]] <= badmaxpwgt) {
+        to = 1;
+      }
+      else
+        break;
+
+      other = (to+1)%2;
+
+      higain = PQueueGetMax(&parts[to]);
+      if (moved[higain] == -1) /* Delete if it was in the separator originally */
+        PQueueDelete(&parts[other], higain, vwgt[higain]-rinfo[higain].edegrees[to]);
+
+      ASSERT(bndptr[higain] != -1);
+
+      pwgts[2] -= (vwgt[higain]-rinfo[higain].edegrees[other]);
+
+      newdiff = abs(pwgts[to]+vwgt[higain] - (pwgts[other]-rinfo[higain].edegrees[other]));
+      if (pwgts[2] < mincut || (pwgts[2] == mincut && newdiff < mindiff)) {
+        mincut = pwgts[2];
+        mincutorder = nswaps;
+        mindiff = newdiff;
+      }
+      else {
+        if (nswaps - mincutorder > limit) {
+          pwgts[2] += (vwgt[higain]-rinfo[higain].edegrees[other]);
+          break; /* No further improvement, break out */
+        }
+      }
+
+      BNDDelete(nbnd, bndind, bndptr, higain);
+      pwgts[to] += vwgt[higain];
+      where[higain] = to;
+      moved[higain] = nswaps;
+      swaps[nswaps] = higain;  
+
+
+      /**********************************************************
+      * Update the degrees of the affected nodes
+      ***********************************************************/
+      for (j=xadj[higain]; j<xadj[higain+1]; j++) {
+        k = adjncy[j];
+        if (where[k] == 2) { /* For the in-separator vertices modify their edegree[to] */
+          oldgain = vwgt[k]-rinfo[k].edegrees[to];
+          rinfo[k].edegrees[to] += vwgt[higain];
+          if (moved[k] == -1 || moved[k] == -(2+other))
+            PQueueUpdate(&parts[other], k, oldgain, oldgain-vwgt[higain]);
+        }
+        else if (where[k] == other) { /* This vertex is pulled into the separator */
+          ASSERTP(bndptr[k] == -1, ("%d %d %d\n", k, bndptr[k], where[k]));
+          BNDInsert(nbnd, bndind, bndptr, k);
+
+          mind[nmind++] = k;  /* Keep track for rollback */
+          where[k] = 2;
+          pwgts[other] -= vwgt[k];
+
+          edegrees = rinfo[k].edegrees;
+          edegrees[0] = edegrees[1] = 0;
+          for (jj=xadj[k]; jj<xadj[k+1]; jj++) {
+            kk = adjncy[jj];
+            if (where[kk] != 2) 
+              edegrees[where[kk]] += vwgt[kk];
+            else {
+              oldgain = vwgt[kk]-rinfo[kk].edegrees[other];
+              rinfo[kk].edegrees[other] -= vwgt[k];
+              if (moved[kk] == -1 || moved[kk] == -(2+to))
+                PQueueUpdate(&parts[to], kk, oldgain, oldgain+vwgt[k]);
+            }
+          }
+
+          /* Insert the new vertex into the priority queue. Only one side! */
+          if (moved[k] == -1) {
+            PQueueInsert(&parts[to], k, vwgt[k]-edegrees[other]);
+            moved[k] = -(2+to);
+          }
+        }
+      }
+      mptr[nswaps+1] = nmind;
+
+      IFSET(ctrl->dbglvl, DBG_MOVEINFO,
+            printf("Moved %6d to %3d, Gain: %5d [%5d] [%4d %4d] \t[%5d %5d %5d]\n", higain, to, g[to], g[other], vwgt[u[to]], vwgt[u[other]], pwgts[0], pwgts[1], pwgts[2]));
+
+    }
+
+
+    /****************************************************************
+    * Roll back computation 
+    *****************************************************************/
+    for (nswaps--; nswaps>mincutorder; nswaps--) {
+      higain = swaps[nswaps];
+
+      ASSERT(CheckNodePartitionParams(graph));
+
+      to = where[higain];
+      other = (to+1)%2;
+      INC_DEC(pwgts[2], pwgts[to], vwgt[higain]);
+      where[higain] = 2;
+      BNDInsert(nbnd, bndind, bndptr, higain);
+
+      edegrees = rinfo[higain].edegrees;
+      edegrees[0] = edegrees[1] = 0;
+      for (j=xadj[higain]; j<xadj[higain+1]; j++) {
+        k = adjncy[j];
+        if (where[k] == 2) 
+          rinfo[k].edegrees[to] -= vwgt[higain];
+        else
+          edegrees[where[k]] += vwgt[k];
+      }
+
+      /* Push nodes out of the separator */
+      for (j=mptr[nswaps]; j<mptr[nswaps+1]; j++) {
+        k = mind[j];
+        ASSERT(where[k] == 2);
+        where[k] = other;
+        INC_DEC(pwgts[other], pwgts[2], vwgt[k]);
+        BNDDelete(nbnd, bndind, bndptr, k);
+        for (jj=xadj[k]; jj<xadj[k+1]; jj++) {
+          kk = adjncy[jj];
+          if (where[kk] == 2) 
+            rinfo[kk].edegrees[other] += vwgt[k];
+        }
+      }
+    }
+
+    ASSERT(mincut == pwgts[2]);
+
+    IFSET(ctrl->dbglvl, DBG_REFINE,
+      printf("\tMinimum sep: %6d at %5d, PWGTS: [%6d %6d], NBND: %6d\n", mincut, mincutorder, pwgts[0], pwgts[1], nbnd));
+
+    graph->mincut = mincut;
+    graph->nbnd = nbnd;
+
+    if (mincutorder == -1 || mincut >= initcut)
+      break;
+  }
+
+  PQueueFree(ctrl, &parts[0]);
+  PQueueFree(ctrl, &parts[1]);
+
+  idxwspacefree(ctrl, nvtxs+1);
+  idxwspacefree(ctrl, nvtxs);
+  idxwspacefree(ctrl, nvtxs);
+  idxwspacefree(ctrl, nvtxs);
+  idxwspacefree(ctrl, nvtxs);
+}
+
+
+/*************************************************************************
+* This function performs a node-based FM refinement 
+**************************************************************************/
+void FM_2WayNodeRefine2(CtrlType *ctrl, GraphType *graph, float ubfactor, int npasses)
+{
+  int i, ii, j, k, jj, kk, nvtxs, nbnd, nswaps, nmind;
+  idxtype *xadj, *vwgt, *adjncy, *where, *pwgts, *edegrees, *bndind, *bndptr;
+  idxtype *mptr, *mind, *moved, *swaps, *perm;
+  PQueueType parts[2]; 
+  NRInfoType *rinfo;
+  int higain, oldgain, mincut, initcut, mincutorder;	
+  int pass, to, other, limit;
+  int badmaxpwgt, mindiff, newdiff;
+  int u[2], g[2];
+
+  nvtxs = graph->nvtxs;
+  xadj = graph->xadj;
+  adjncy = graph->adjncy;
+  vwgt = graph->vwgt;
+
+  bndind = graph->bndind;
+  bndptr = graph->bndptr;
+  where = graph->where;
+  pwgts = graph->pwgts;
+  rinfo = graph->nrinfo;
+
+
+  i = ComputeMaxNodeGain(nvtxs, xadj, adjncy, vwgt);
+  PQueueInit(ctrl, &parts[0], nvtxs, i);
+  PQueueInit(ctrl, &parts[1], nvtxs, i);
+
+  moved = idxwspacemalloc(ctrl, nvtxs);
+  swaps = idxwspacemalloc(ctrl, nvtxs);
+  mptr = idxwspacemalloc(ctrl, nvtxs+1);
+  mind = idxwspacemalloc(ctrl, nvtxs);
+  perm = idxwspacemalloc(ctrl, nvtxs);
+
+  IFSET(ctrl->dbglvl, DBG_REFINE,
+    printf("Partitions: [%6d %6d] Nv-Nb[%6d %6d]. ISep: %6d\n", pwgts[0], pwgts[1], graph->nvtxs, graph->nbnd, graph->mincut));
+
+  badmaxpwgt = (int)(ubfactor*(pwgts[0]+pwgts[1]+pwgts[2])/2);
+
+  for (pass=0; pass<npasses; pass++) {
+    idxset(nvtxs, -1, moved);
+    PQueueReset(&parts[0]);
+    PQueueReset(&parts[1]);
+
+    mincutorder = -1;
+    initcut = mincut = graph->mincut;
+    nbnd = graph->nbnd;
+
+    RandomPermute(nbnd, perm, 1);
+    for (ii=0; ii<nbnd; ii++) {
+      i = bndind[perm[ii]];
+      ASSERT(where[i] == 2);
+      PQueueInsert(&parts[0], i, vwgt[i]-rinfo[i].edegrees[1]);
+      PQueueInsert(&parts[1], i, vwgt[i]-rinfo[i].edegrees[0]);
+    }
+
+    ASSERT(CheckNodeBnd(graph, nbnd));
+    ASSERT(CheckNodePartitionParams(graph));
+
+    limit = (ctrl->oflags&OFLAG_COMPRESS ? amin(5*nbnd, 400) : amin(2*nbnd, 300));
+
+    /******************************************************
+    * Get into the FM loop
+    *******************************************************/
+    mptr[0] = nmind = 0;
+    mindiff = abs(pwgts[0]-pwgts[1]);
+    to = (pwgts[0] < pwgts[1] ? 0 : 1);
+    for (nswaps=0; nswaps<nvtxs; nswaps++) {
+      badmaxpwgt = (int)(ubfactor*(pwgts[0]+pwgts[1]+pwgts[2]/2)/2);
+
+      u[0] = PQueueSeeMax(&parts[0]);  
+      u[1] = PQueueSeeMax(&parts[1]);
+      if (u[0] != -1 && u[1] != -1) {
+        g[0] = vwgt[u[0]]-rinfo[u[0]].edegrees[1];
+        g[1] = vwgt[u[1]]-rinfo[u[1]].edegrees[0];
+
+        to = (g[0] > g[1] ? 0 : (g[0] < g[1] ? 1 : pass%2)); 
+        /* to = (g[0] > g[1] ? 0 : (g[0] < g[1] ? 1 : (pwgts[0] < pwgts[1] ? 0 : 1))); */
+
+        if (pwgts[to]+vwgt[u[to]] > badmaxpwgt) 
+          to = (to+1)%2;
+      }
+      else if (u[0] == -1 && u[1] == -1) {
+        break;
+      }
+      else if (u[0] != -1 && pwgts[0]+vwgt[u[0]] <= badmaxpwgt) {
+        to = 0;
+      }
+      else if (u[1] != -1 && pwgts[1]+vwgt[u[1]] <= badmaxpwgt) {
+        to = 1;
+      }
+      else
+        break;
+
+      other = (to+1)%2;
+
+      higain = PQueueGetMax(&parts[to]);
+      if (moved[higain] == -1) /* Delete if it was in the separator originally */
+        PQueueDelete(&parts[other], higain, vwgt[higain]-rinfo[higain].edegrees[to]);
+
+      ASSERT(bndptr[higain] != -1);
+
+      pwgts[2] -= (vwgt[higain]-rinfo[higain].edegrees[other]);
+
+      newdiff = abs(pwgts[to]+vwgt[higain] - (pwgts[other]-rinfo[higain].edegrees[other]));
+      if (pwgts[2] < mincut || (pwgts[2] == mincut && newdiff < mindiff)) {
+        mincut = pwgts[2];
+        mincutorder = nswaps;
+        mindiff = newdiff;
+      }
+      else {
+        if (nswaps - mincutorder > limit) {
+          pwgts[2] += (vwgt[higain]-rinfo[higain].edegrees[other]);
+          break; /* No further improvement, break out */
+        }
+      }
+
+      BNDDelete(nbnd, bndind, bndptr, higain);
+      pwgts[to] += vwgt[higain];
+      where[higain] = to;
+      moved[higain] = nswaps;
+      swaps[nswaps] = higain;  
+
+
+      /**********************************************************
+      * Update the degrees of the affected nodes
+      ***********************************************************/
+      for (j=xadj[higain]; j<xadj[higain+1]; j++) {
+        k = adjncy[j];
+        if (where[k] == 2) { /* For the in-separator vertices modify their edegree[to] */
+          oldgain = vwgt[k]-rinfo[k].edegrees[to];
+          rinfo[k].edegrees[to] += vwgt[higain];
+          if (moved[k] == -1 || moved[k] == -(2+other))
+            PQueueUpdate(&parts[other], k, oldgain, oldgain-vwgt[higain]);
+        }
+        else if (where[k] == other) { /* This vertex is pulled into the separator */
+          ASSERTP(bndptr[k] == -1, ("%d %d %d\n", k, bndptr[k], where[k]));
+          BNDInsert(nbnd, bndind, bndptr, k);
+
+          mind[nmind++] = k;  /* Keep track for rollback */
+          where[k] = 2;
+          pwgts[other] -= vwgt[k];
+
+          edegrees = rinfo[k].edegrees;
+          edegrees[0] = edegrees[1] = 0;
+          for (jj=xadj[k]; jj<xadj[k+1]; jj++) {
+            kk = adjncy[jj];
+            if (where[kk] != 2) 
+              edegrees[where[kk]] += vwgt[kk];
+            else {
+              oldgain = vwgt[kk]-rinfo[kk].edegrees[other];
+              rinfo[kk].edegrees[other] -= vwgt[k];
+              if (moved[kk] == -1 || moved[kk] == -(2+to))
+                PQueueUpdate(&parts[to], kk, oldgain, oldgain+vwgt[k]);
+            }
+          }
+
+          /* Insert the new vertex into the priority queue. Only one side! */
+          if (moved[k] == -1) {
+            PQueueInsert(&parts[to], k, vwgt[k]-edegrees[other]);
+            moved[k] = -(2+to);
+          }
+        }
+      }
+      mptr[nswaps+1] = nmind;
+
+      IFSET(ctrl->dbglvl, DBG_MOVEINFO,
+            printf("Moved %6d to %3d, Gain: %5d [%5d] [%4d %4d] \t[%5d %5d %5d]\n", higain, to, g[to], g[other], vwgt[u[to]], vwgt[u[other]], pwgts[0], pwgts[1], pwgts[2]));
+
+    }
+
+
+    /****************************************************************
+    * Roll back computation 
+    *****************************************************************/
+    for (nswaps--; nswaps>mincutorder; nswaps--) {
+      higain = swaps[nswaps];
+
+      ASSERT(CheckNodePartitionParams(graph));
+
+      to = where[higain];
+      other = (to+1)%2;
+      INC_DEC(pwgts[2], pwgts[to], vwgt[higain]);
+      where[higain] = 2;
+      BNDInsert(nbnd, bndind, bndptr, higain);
+
+      edegrees = rinfo[higain].edegrees;
+      edegrees[0] = edegrees[1] = 0;
+      for (j=xadj[higain]; j<xadj[higain+1]; j++) {
+        k = adjncy[j];
+        if (where[k] == 2) 
+          rinfo[k].edegrees[to] -= vwgt[higain];
+        else
+          edegrees[where[k]] += vwgt[k];
+      }
+
+      /* Push nodes out of the separator */
+      for (j=mptr[nswaps]; j<mptr[nswaps+1]; j++) {
+        k = mind[j];
+        ASSERT(where[k] == 2);
+        where[k] = other;
+        INC_DEC(pwgts[other], pwgts[2], vwgt[k]);
+        BNDDelete(nbnd, bndind, bndptr, k);
+        for (jj=xadj[k]; jj<xadj[k+1]; jj++) {
+          kk = adjncy[jj];
+          if (where[kk] == 2) 
+            rinfo[kk].edegrees[other] += vwgt[k];
+        }
+      }
+    }
+
+    ASSERT(mincut == pwgts[2]);
+
+    IFSET(ctrl->dbglvl, DBG_REFINE,
+      printf("\tMinimum sep: %6d at %5d, PWGTS: [%6d %6d], NBND: %6d\n", mincut, mincutorder, pwgts[0], pwgts[1], nbnd));
+
+    graph->mincut = mincut;
+    graph->nbnd = nbnd;
+
+    if (mincutorder == -1 || mincut >= initcut)
+      break;
+  }
+
+  PQueueFree(ctrl, &parts[0]);
+  PQueueFree(ctrl, &parts[1]);
+
+  idxwspacefree(ctrl, nvtxs+1);
+  idxwspacefree(ctrl, nvtxs);
+  idxwspacefree(ctrl, nvtxs);
+  idxwspacefree(ctrl, nvtxs);
+  idxwspacefree(ctrl, nvtxs);
+}
+
+
+/*************************************************************************
+* This function performs a node-based FM refinement 
+**************************************************************************/
+void FM_2WayNodeRefineEqWgt(CtrlType *ctrl, GraphType *graph, int npasses)
+{
+  int i, ii, j, k, jj, kk, nvtxs, nbnd, nswaps, nmind;
+  idxtype *xadj, *vwgt, *adjncy, *where, *pwgts, *edegrees, *bndind, *bndptr;
+  idxtype *mptr, *mind, *moved, *swaps, *perm;
+  PQueueType parts[2]; 
+  NRInfoType *rinfo;
+  int higain, oldgain, mincut, initcut, mincutorder;	
+  int pass, to, other, limit;
+  int mindiff, newdiff;
+  int u[2], g[2];
+
+  nvtxs = graph->nvtxs;
+  xadj = graph->xadj;
+  adjncy = graph->adjncy;
+  vwgt = graph->vwgt;
+
+  bndind = graph->bndind;
+  bndptr = graph->bndptr;
+  where = graph->where;
+  pwgts = graph->pwgts;
+  rinfo = graph->nrinfo;
+
+
+  i = ComputeMaxNodeGain(nvtxs, xadj, adjncy, vwgt);
+  PQueueInit(ctrl, &parts[0], nvtxs, i);
+  PQueueInit(ctrl, &parts[1], nvtxs, i);
+
+  moved = idxwspacemalloc(ctrl, nvtxs);
+  swaps = idxwspacemalloc(ctrl, nvtxs);
+  mptr = idxwspacemalloc(ctrl, nvtxs+1);
+  mind = idxwspacemalloc(ctrl, nvtxs);
+  perm = idxwspacemalloc(ctrl, nvtxs);
+
+  IFSET(ctrl->dbglvl, DBG_REFINE,
+    printf("Partitions: [%6d %6d] Nv-Nb[%6d %6d]. ISep: %6d\n", pwgts[0], pwgts[1], graph->nvtxs, graph->nbnd, graph->mincut));
+
+  for (pass=0; pass<npasses; pass++) {
+    idxset(nvtxs, -1, moved);
+    PQueueReset(&parts[0]);
+    PQueueReset(&parts[1]);
+
+    mincutorder = -1;
+    initcut = mincut = graph->mincut;
+    nbnd = graph->nbnd;
+
+    RandomPermute(nbnd, perm, 1);
+    for (ii=0; ii<nbnd; ii++) {
+      i = bndind[perm[ii]];
+      ASSERT(where[i] == 2);
+      PQueueInsert(&parts[0], i, vwgt[i]-rinfo[i].edegrees[1]);
+      PQueueInsert(&parts[1], i, vwgt[i]-rinfo[i].edegrees[0]);
+    }
+
+    ASSERT(CheckNodeBnd(graph, nbnd));
+    ASSERT(CheckNodePartitionParams(graph));
+
+    limit = (ctrl->oflags&OFLAG_COMPRESS ? amin(5*nbnd, 400) : amin(2*nbnd, 300));
+
+    /******************************************************
+    * Get into the FM loop
+    *******************************************************/
+    mptr[0] = nmind = 0;
+    mindiff = abs(pwgts[0]-pwgts[1]);
+    to = (pwgts[0] < pwgts[1] ? 0 : 1);
+    for (nswaps=0; nswaps<nvtxs; nswaps++) {
+      to = (pwgts[0] < pwgts[1] ? 0 : 1);
+
+      if (pwgts[0] == pwgts[1]) {
+        u[0] = PQueueSeeMax(&parts[0]);  
+        u[1] = PQueueSeeMax(&parts[1]);
+        if (u[0] != -1 && u[1] != -1) {
+          g[0] = vwgt[u[0]]-rinfo[u[0]].edegrees[1];
+          g[1] = vwgt[u[1]]-rinfo[u[1]].edegrees[0];
+
+          to = (g[0] > g[1] ? 0 : (g[0] < g[1] ? 1 : pass%2)); 
+        }
+      }
+      other = (to+1)%2;
+
+      if ((higain = PQueueGetMax(&parts[to])) == -1)
+        break;
+
+      if (moved[higain] == -1) /* Delete if it was in the separator originally */
+        PQueueDelete(&parts[other], higain, vwgt[higain]-rinfo[higain].edegrees[to]);
+
+      ASSERT(bndptr[higain] != -1);
+
+      pwgts[2] -= (vwgt[higain]-rinfo[higain].edegrees[other]);
+
+      newdiff = abs(pwgts[to]+vwgt[higain] - (pwgts[other]-rinfo[higain].edegrees[other]));
+      if (pwgts[2] < mincut || (pwgts[2] == mincut && newdiff < mindiff)) {
+        mincut = pwgts[2];
+        mincutorder = nswaps;
+        mindiff = newdiff;
+      }
+      else {
+        if (nswaps - mincutorder > limit) {
+          pwgts[2] += (vwgt[higain]-rinfo[higain].edegrees[other]);
+          break; /* No further improvement, break out */
+        }
+      }
+
+      BNDDelete(nbnd, bndind, bndptr, higain);
+      pwgts[to] += vwgt[higain];
+      where[higain] = to;
+      moved[higain] = nswaps;
+      swaps[nswaps] = higain;  
+
+
+      /**********************************************************
+      * Update the degrees of the affected nodes
+      ***********************************************************/
+      for (j=xadj[higain]; j<xadj[higain+1]; j++) {
+        k = adjncy[j];
+        if (where[k] == 2) { /* For the in-separator vertices modify their edegree[to] */
+          oldgain = vwgt[k]-rinfo[k].edegrees[to];
+          rinfo[k].edegrees[to] += vwgt[higain];
+          if (moved[k] == -1 || moved[k] == -(2+other))
+            PQueueUpdate(&parts[other], k, oldgain, oldgain-vwgt[higain]);
+        }
+        else if (where[k] == other) { /* This vertex is pulled into the separator */
+          ASSERTP(bndptr[k] == -1, ("%d %d %d\n", k, bndptr[k], where[k]));
+          BNDInsert(nbnd, bndind, bndptr, k);
+
+          mind[nmind++] = k;  /* Keep track for rollback */
+          where[k] = 2;
+          pwgts[other] -= vwgt[k];
+
+          edegrees = rinfo[k].edegrees;
+          edegrees[0] = edegrees[1] = 0;
+          for (jj=xadj[k]; jj<xadj[k+1]; jj++) {
+            kk = adjncy[jj];
+            if (where[kk] != 2) 
+              edegrees[where[kk]] += vwgt[kk];
+            else {
+              oldgain = vwgt[kk]-rinfo[kk].edegrees[other];
+              rinfo[kk].edegrees[other] -= vwgt[k];
+              if (moved[kk] == -1 || moved[kk] == -(2+to))
+                PQueueUpdate(&parts[to], kk, oldgain, oldgain+vwgt[k]);
+            }
+          }
+
+          /* Insert the new vertex into the priority queue. Only one side! */
+          if (moved[k] == -1) {
+            PQueueInsert(&parts[to], k, vwgt[k]-edegrees[other]);
+            moved[k] = -(2+to);
+          }
+        }
+      }
+      mptr[nswaps+1] = nmind;
+
+      IFSET(ctrl->dbglvl, DBG_MOVEINFO,
+            printf("Moved %6d to %3d, Gain: %5d [%5d] [%4d %4d] \t[%5d %5d %5d]\n", higain, to, g[to], g[other], vwgt[u[to]], vwgt[u[other]], pwgts[0], pwgts[1], pwgts[2]));
+
+    }
+
+
+    /****************************************************************
+    * Roll back computation 
+    *****************************************************************/
+    for (nswaps--; nswaps>mincutorder; nswaps--) {
+      higain = swaps[nswaps];
+
+      ASSERT(CheckNodePartitionParams(graph));
+
+      to = where[higain];
+      other = (to+1)%2;
+      INC_DEC(pwgts[2], pwgts[to], vwgt[higain]);
+      where[higain] = 2;
+      BNDInsert(nbnd, bndind, bndptr, higain);
+
+      edegrees = rinfo[higain].edegrees;
+      edegrees[0] = edegrees[1] = 0;
+      for (j=xadj[higain]; j<xadj[higain+1]; j++) {
+        k = adjncy[j];
+        if (where[k] == 2) 
+          rinfo[k].edegrees[to] -= vwgt[higain];
+        else
+          edegrees[where[k]] += vwgt[k];
+      }
+
+      /* Push nodes out of the separator */
+      for (j=mptr[nswaps]; j<mptr[nswaps+1]; j++) {
+        k = mind[j];
+        ASSERT(where[k] == 2);
+        where[k] = other;
+        INC_DEC(pwgts[other], pwgts[2], vwgt[k]);
+        BNDDelete(nbnd, bndind, bndptr, k);
+        for (jj=xadj[k]; jj<xadj[k+1]; jj++) {
+          kk = adjncy[jj];
+          if (where[kk] == 2) 
+            rinfo[kk].edegrees[other] += vwgt[k];
+        }
+      }
+    }
+
+    ASSERT(mincut == pwgts[2]);
+
+    IFSET(ctrl->dbglvl, DBG_REFINE,
+      printf("\tMinimum sep: %6d at %5d, PWGTS: [%6d %6d], NBND: %6d\n", mincut, mincutorder, pwgts[0], pwgts[1], nbnd));
+
+    graph->mincut = mincut;
+    graph->nbnd = nbnd;
+
+    if (mincutorder == -1 || mincut >= initcut)
+      break;
+  }
+
+  PQueueFree(ctrl, &parts[0]);
+  PQueueFree(ctrl, &parts[1]);
+
+  idxwspacefree(ctrl, nvtxs+1);
+  idxwspacefree(ctrl, nvtxs);
+  idxwspacefree(ctrl, nvtxs);
+  idxwspacefree(ctrl, nvtxs);
+  idxwspacefree(ctrl, nvtxs);
+}
+
+
+/*************************************************************************
+* This function performs a node-based FM refinement. This is the 
+* one-way version 
+**************************************************************************/
+void FM_2WayNodeRefine_OneSided(CtrlType *ctrl, GraphType *graph, float ubfactor, int npasses)
+{
+  int i, ii, j, k, jj, kk, nvtxs, nbnd, nswaps, nmind;
+  idxtype *xadj, *vwgt, *adjncy, *where, *pwgts, *edegrees, *bndind, *bndptr;
+  idxtype *mptr, *mind, *swaps, *perm;
+  PQueueType parts; 
+  NRInfoType *rinfo;
+  int higain, oldgain, mincut, initcut, mincutorder;	
+  int pass, to, other, limit;
+  int badmaxpwgt, mindiff, newdiff;
+
+  nvtxs = graph->nvtxs;
+  xadj = graph->xadj;
+  adjncy = graph->adjncy;
+  vwgt = graph->vwgt;
+
+  bndind = graph->bndind;
+  bndptr = graph->bndptr;
+  where = graph->where;
+  pwgts = graph->pwgts;
+  rinfo = graph->nrinfo;
+
+  PQueueInit(ctrl, &parts, nvtxs, ComputeMaxNodeGain(nvtxs, xadj, adjncy, vwgt));
+
+  perm = idxwspacemalloc(ctrl, nvtxs);
+  swaps = idxwspacemalloc(ctrl, nvtxs);
+  mptr = idxwspacemalloc(ctrl, nvtxs);
+  mind = idxwspacemalloc(ctrl, nvtxs+1);
+
+  IFSET(ctrl->dbglvl, DBG_REFINE,
+    printf("Partitions-N1: [%6d %6d] Nv-Nb[%6d %6d]. ISep: %6d\n", pwgts[0], pwgts[1], graph->nvtxs, graph->nbnd, graph->mincut));
+
+  badmaxpwgt = (int)(ubfactor*(pwgts[0]+pwgts[1]+pwgts[2])/2);
+
+  to = (pwgts[0] < pwgts[1] ? 1 : 0);
+  for (pass=0; pass<npasses; pass++) {
+    other = to; 
+    to = (to+1)%2;
+
+    PQueueReset(&parts);
+
+    mincutorder = -1;
+    initcut = mincut = graph->mincut;
+    nbnd = graph->nbnd;
+
+    RandomPermute(nbnd, perm, 1);
+    for (ii=0; ii<nbnd; ii++) {
+      i = bndind[perm[ii]];
+      ASSERT(where[i] == 2);
+      PQueueInsert(&parts, i, vwgt[i]-rinfo[i].edegrees[other]);
+    }
+
+    ASSERT(CheckNodeBnd(graph, nbnd));
+    ASSERT(CheckNodePartitionParams(graph));
+
+    limit = (ctrl->oflags&OFLAG_COMPRESS ? amin(5*nbnd, 400) : amin(2*nbnd, 300));
+
+    /******************************************************
+    * Get into the FM loop
+    *******************************************************/
+    mptr[0] = nmind = 0;
+    mindiff = abs(pwgts[0]-pwgts[1]);
+    for (nswaps=0; nswaps<nvtxs; nswaps++) {
+
+      if ((higain = PQueueGetMax(&parts)) == -1)
+        break;
+
+      ASSERT(bndptr[higain] != -1);
+
+      if (pwgts[to]+vwgt[higain] > badmaxpwgt)
+        break;  /* No point going any further. Balance will be bad */
+
+      pwgts[2] -= (vwgt[higain]-rinfo[higain].edegrees[other]);
+
+      newdiff = abs(pwgts[to]+vwgt[higain] - (pwgts[other]-rinfo[higain].edegrees[other]));
+      if (pwgts[2] < mincut || (pwgts[2] == mincut && newdiff < mindiff)) {
+        mincut = pwgts[2];
+        mincutorder = nswaps;
+        mindiff = newdiff;
+      }
+      else {
+        if (nswaps - mincutorder > limit) {
+          pwgts[2] += (vwgt[higain]-rinfo[higain].edegrees[other]);
+          break; /* No further improvement, break out */
+        }
+      }
+
+      BNDDelete(nbnd, bndind, bndptr, higain);
+      pwgts[to] += vwgt[higain];
+      where[higain] = to;
+      swaps[nswaps] = higain;  
+
+
+      /**********************************************************
+      * Update the degrees of the affected nodes
+      ***********************************************************/
+      for (j=xadj[higain]; j<xadj[higain+1]; j++) {
+        k = adjncy[j];
+        if (where[k] == 2) { /* For the in-separator vertices modify their edegree[to] */
+          rinfo[k].edegrees[to] += vwgt[higain];
+        }
+        else if (where[k] == other) { /* This vertex is pulled into the separator */
+          ASSERTP(bndptr[k] == -1, ("%d %d %d\n", k, bndptr[k], where[k]));
+          BNDInsert(nbnd, bndind, bndptr, k);
+
+          mind[nmind++] = k;  /* Keep track for rollback */
+          where[k] = 2;
+          pwgts[other] -= vwgt[k];
+
+          edegrees = rinfo[k].edegrees;
+          edegrees[0] = edegrees[1] = 0;
+          for (jj=xadj[k]; jj<xadj[k+1]; jj++) {
+            kk = adjncy[jj];
+            if (where[kk] != 2) 
+              edegrees[where[kk]] += vwgt[kk];
+            else {
+              oldgain = vwgt[kk]-rinfo[kk].edegrees[other];
+              rinfo[kk].edegrees[other] -= vwgt[k];
+
+              /* Since the moves are one-sided this vertex has not been moved yet */
+              PQueueUpdateUp(&parts, kk, oldgain, oldgain+vwgt[k]); 
+            }
+          }
+
+          /* Insert the new vertex into the priority queue. Safe due to one-sided moves */
+          PQueueInsert(&parts, k, vwgt[k]-edegrees[other]);
+        }
+      }
+      mptr[nswaps+1] = nmind;
+
+
+      IFSET(ctrl->dbglvl, DBG_MOVEINFO,
+            printf("Moved %6d to %3d, Gain: %5d [%5d] \t[%5d %5d %5d] [%3d %2d]\n", 
+                       higain, to, (vwgt[higain]-rinfo[higain].edegrees[other]), vwgt[higain], pwgts[0], pwgts[1], pwgts[2], nswaps, limit));
+
+    }
+
+
+    /****************************************************************
+    * Roll back computation 
+    *****************************************************************/
+    for (nswaps--; nswaps>mincutorder; nswaps--) {
+      higain = swaps[nswaps];
+
+      ASSERT(CheckNodePartitionParams(graph));
+      ASSERT(where[higain] == to);
+
+      INC_DEC(pwgts[2], pwgts[to], vwgt[higain]);
+      where[higain] = 2;
+      BNDInsert(nbnd, bndind, bndptr, higain);
+
+      edegrees = rinfo[higain].edegrees;
+      edegrees[0] = edegrees[1] = 0;
+      for (j=xadj[higain]; j<xadj[higain+1]; j++) {
+        k = adjncy[j];
+        if (where[k] == 2) 
+          rinfo[k].edegrees[to] -= vwgt[higain];
+        else
+          edegrees[where[k]] += vwgt[k];
+      }
+
+      /* Push nodes out of the separator */
+      for (j=mptr[nswaps]; j<mptr[nswaps+1]; j++) {
+        k = mind[j];
+        ASSERT(where[k] == 2);
+        where[k] = other;
+        INC_DEC(pwgts[other], pwgts[2], vwgt[k]);
+        BNDDelete(nbnd, bndind, bndptr, k);
+        for (jj=xadj[k]; jj<xadj[k+1]; jj++) {
+          kk = adjncy[jj];
+          if (where[kk] == 2) 
+            rinfo[kk].edegrees[other] += vwgt[k];
+        }
+      }
+    }
+
+    ASSERT(mincut == pwgts[2]);
+
+    IFSET(ctrl->dbglvl, DBG_REFINE,
+      printf("\tMinimum sep: %6d at %5d, PWGTS: [%6d %6d], NBND: %6d\n", mincut, mincutorder, pwgts[0], pwgts[1], nbnd));
+
+    graph->mincut = mincut;
+    graph->nbnd = nbnd;
+
+    if (pass%2 == 1 && (mincutorder == -1 || mincut >= initcut))
+      break;
+  }
+
+  PQueueFree(ctrl, &parts);
+
+  idxwspacefree(ctrl, nvtxs+1);
+  idxwspacefree(ctrl, nvtxs);
+  idxwspacefree(ctrl, nvtxs);
+  idxwspacefree(ctrl, nvtxs);
+}
+
+
+
+/*************************************************************************
+* This function performs a node-based FM refinement 
+**************************************************************************/
+void FM_2WayNodeBalance(CtrlType *ctrl, GraphType *graph, float ubfactor)
+{
+  int i, ii, j, k, jj, kk, nvtxs, nbnd, nswaps;
+  idxtype *xadj, *vwgt, *adjncy, *where, *pwgts, *edegrees, *bndind, *bndptr;
+  idxtype *perm, *moved;
+  PQueueType parts; 
+  NRInfoType *rinfo;
+  int higain, oldgain;	
+  int pass, to, other;
+
+  nvtxs = graph->nvtxs;
+  xadj = graph->xadj;
+  adjncy = graph->adjncy;
+  vwgt = graph->vwgt;
+
+  bndind = graph->bndind;
+  bndptr = graph->bndptr;
+  where = graph->where;
+  pwgts = graph->pwgts;
+  rinfo = graph->nrinfo;
+
+  if (abs(pwgts[0]-pwgts[1]) < (int)((ubfactor-1.0)*(pwgts[0]+pwgts[1])))
+    return;
+  if (abs(pwgts[0]-pwgts[1]) < 3*idxsum(nvtxs, vwgt)/nvtxs)
+    return;
+
+  to = (pwgts[0] < pwgts[1] ? 0 : 1); 
+  other = (to+1)%2;
+
+  PQueueInit(ctrl, &parts, nvtxs, ComputeMaxNodeGain(nvtxs, xadj, adjncy, vwgt));
+
+  perm = idxwspacemalloc(ctrl, nvtxs);
+  moved = idxset(nvtxs, -1, idxwspacemalloc(ctrl, nvtxs));
+
+  IFSET(ctrl->dbglvl, DBG_REFINE,
+    printf("Partitions: [%6d %6d] Nv-Nb[%6d %6d]. ISep: %6d [B]\n", pwgts[0], pwgts[1], graph->nvtxs, graph->nbnd, graph->mincut));
+
+  nbnd = graph->nbnd;
+  RandomPermute(nbnd, perm, 1);
+  for (ii=0; ii<nbnd; ii++) {
+    i = bndind[perm[ii]];
+    ASSERT(where[i] == 2);
+    PQueueInsert(&parts, i, vwgt[i]-rinfo[i].edegrees[other]);
+  }
+
+  ASSERT(CheckNodeBnd(graph, nbnd));
+  ASSERT(CheckNodePartitionParams(graph));
+
+  /******************************************************
+  * Get into the FM loop
+  *******************************************************/
+  for (nswaps=0; nswaps<nvtxs; nswaps++) {
+    if ((higain = PQueueGetMax(&parts)) == -1)
+      break;
+
+    moved[higain] = 1;
+
+    if (pwgts[other] - rinfo[higain].edegrees[other] < (pwgts[0]+pwgts[1])/2) 
+      continue;
+#ifdef XXX
+    if (pwgts[other] - rinfo[higain].edegrees[other] < pwgts[to]+vwgt[higain]) 
+      break;
+#endif
+
+    ASSERT(bndptr[higain] != -1);
+
+    pwgts[2] -= (vwgt[higain]-rinfo[higain].edegrees[other]);
+
+    BNDDelete(nbnd, bndind, bndptr, higain);
+    pwgts[to] += vwgt[higain];
+    where[higain] = to;
+
+    IFSET(ctrl->dbglvl, DBG_MOVEINFO,
+          printf("Moved %6d to %3d, Gain: %3d, \t[%5d %5d %5d]\n", higain, to, vwgt[higain]-rinfo[higain].edegrees[other], pwgts[0], pwgts[1], pwgts[2]));
+
+
+    /**********************************************************
+    * Update the degrees of the affected nodes
+    ***********************************************************/
+    for (j=xadj[higain]; j<xadj[higain+1]; j++) {
+      k = adjncy[j];
+      if (where[k] == 2) { /* For the in-separator vertices modify their edegree[to] */
+        rinfo[k].edegrees[to] += vwgt[higain];
+      }
+      else if (where[k] == other) { /* This vertex is pulled into the separator */
+        ASSERTP(bndptr[k] == -1, ("%d %d %d\n", k, bndptr[k], where[k]));
+        BNDInsert(nbnd, bndind, bndptr, k);
+
+        where[k] = 2;
+        pwgts[other] -= vwgt[k];
+
+        edegrees = rinfo[k].edegrees;
+        edegrees[0] = edegrees[1] = 0;
+        for (jj=xadj[k]; jj<xadj[k+1]; jj++) {
+          kk = adjncy[jj];
+          if (where[kk] != 2) 
+            edegrees[where[kk]] += vwgt[kk];
+          else {
+            ASSERT(bndptr[kk] != -1);
+            oldgain = vwgt[kk]-rinfo[kk].edegrees[other];
+            rinfo[kk].edegrees[other] -= vwgt[k];
+
+            if (moved[kk] == -1)
+              PQueueUpdateUp(&parts, kk, oldgain, oldgain+vwgt[k]);
+          }
+        }
+
+        /* Insert the new vertex into the priority queue */
+        PQueueInsert(&parts, k, vwgt[k]-edegrees[other]);
+      }
+    }
+
+    if (pwgts[to] > pwgts[other])
+      break;
+  }
+
+  IFSET(ctrl->dbglvl, DBG_REFINE,
+    printf("\tBalanced sep: %6d at %4d, PWGTS: [%6d %6d], NBND: %6d\n", pwgts[2], nswaps, pwgts[0], pwgts[1], nbnd));
+
+  graph->mincut = pwgts[2];
+  graph->nbnd = nbnd;
+
+
+  PQueueFree(ctrl, &parts);
+
+  idxwspacefree(ctrl, nvtxs);
+  idxwspacefree(ctrl, nvtxs);
+}
+
+
+/*************************************************************************
+* This function computes the maximum possible gain for a vertex
+**************************************************************************/
+int ComputeMaxNodeGain(int nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt)
+{
+  int i, j, k, max;
+
+  max = 0;
+  for (j=xadj[0]; j<xadj[1]; j++)
+    max += vwgt[adjncy[j]];
+
+  for (i=1; i<nvtxs; i++) {
+    for (k=0, j=xadj[i]; j<xadj[i+1]; j++)
+      k += vwgt[adjncy[j]];
+    if (max < k)
+      max = k;
+  }
+
+  return max;
+}
+   
+
Index: /inundation/pymetis/metis-4.0/Lib/srefine.c
===================================================================
--- /inundation/pymetis/metis-4.0/Lib/srefine.c	(revision 2051)
+++ /inundation/pymetis/metis-4.0/Lib/srefine.c	(revision 2051)
@@ -0,0 +1,169 @@
+/*
+ * Copyright 1997, Regents of the University of Minnesota
+ *
+ * srefine.c
+ *
+ * This file contains code for the separator refinement algortihms
+ *
+ * Started 8/1/97
+ * George
+ *
+ * $Id: srefine.c,v 1.1 1998/11/27 17:59:30 karypis Exp $
+ *
+ */
+
+#include <metis.h>
+
+
+/*************************************************************************
+* This function is the entry point of the separator refinement
+**************************************************************************/
+void Refine2WayNode(CtrlType *ctrl, GraphType *orggraph, GraphType *graph, float ubfactor)
+{
+
+  IFSET(ctrl->dbglvl, DBG_TIME, starttimer(ctrl->UncoarsenTmr));
+
+  for (;;) {
+    IFSET(ctrl->dbglvl, DBG_TIME, starttimer(ctrl->RefTmr));
+    if (ctrl->RType != 15)
+      FM_2WayNodeBalance(ctrl, graph, ubfactor); 
+
+    switch (ctrl->RType) {
+      case 1:
+        FM_2WayNodeRefine(ctrl, graph, ubfactor, 8); 
+        break;
+      case 2:
+        FM_2WayNodeRefine_OneSided(ctrl, graph, ubfactor, 8); 
+        break;
+      case 3:
+        FM_2WayNodeRefine(ctrl, graph, ubfactor, 8); 
+        FM_2WayNodeRefine_OneSided(ctrl, graph, ubfactor, 8); 
+        break;
+      case 4:
+        FM_2WayNodeRefine_OneSided(ctrl, graph, ubfactor, 8); 
+        FM_2WayNodeRefine(ctrl, graph, ubfactor, 8); 
+        break;
+      case 5:
+        FM_2WayNodeRefineEqWgt(ctrl, graph, 8); 
+        break;
+    }
+    IFSET(ctrl->dbglvl, DBG_TIME, stoptimer(ctrl->RefTmr));
+
+    if (graph == orggraph) 
+      break;
+
+    graph = graph->finer;
+    IFSET(ctrl->dbglvl, DBG_TIME, starttimer(ctrl->ProjectTmr));
+    Project2WayNodePartition(ctrl, graph);
+    IFSET(ctrl->dbglvl, DBG_TIME, stoptimer(ctrl->ProjectTmr));
+  }
+
+  IFSET(ctrl->dbglvl, DBG_TIME, stoptimer(ctrl->UncoarsenTmr));
+}
+
+
+/*************************************************************************
+* This function allocates memory for 2-way edge refinement
+**************************************************************************/
+void Allocate2WayNodePartitionMemory(CtrlType *ctrl, GraphType *graph)
+{
+  int nvtxs, pad64;
+
+  nvtxs = graph->nvtxs;
+
+  pad64 = (3*nvtxs+3)%2;
+
+  graph->rdata = idxmalloc(3*nvtxs+3+(sizeof(NRInfoType)/sizeof(idxtype))*nvtxs+pad64, "Allocate2WayPartitionMemory: rdata");
+  graph->pwgts          = graph->rdata;
+  graph->where          = graph->rdata + 3;
+  graph->bndptr         = graph->rdata + nvtxs + 3;
+  graph->bndind         = graph->rdata + 2*nvtxs + 3;
+  graph->nrinfo         = (NRInfoType *)(graph->rdata + 3*nvtxs + 3 + pad64);
+}
+
+
+
+/*************************************************************************
+* This function computes the initial id/ed 
+**************************************************************************/
+void Compute2WayNodePartitionParams(CtrlType *ctrl, GraphType *graph)
+{
+  int i, j, k, l, nvtxs, nbnd;
+  idxtype *xadj, *adjncy, *adjwgt, *vwgt;
+  idxtype *where, *pwgts, *bndind, *bndptr, *edegrees;
+  NRInfoType *rinfo;
+  int me, other;
+
+  nvtxs = graph->nvtxs;
+  xadj = graph->xadj;
+  vwgt = graph->vwgt;
+  adjncy = graph->adjncy;
+  adjwgt = graph->adjwgt;
+
+  where = graph->where;
+  rinfo = graph->nrinfo;
+  pwgts = idxset(3, 0, graph->pwgts);
+  bndind = graph->bndind;
+  bndptr = idxset(nvtxs, -1, graph->bndptr);
+
+
+  /*------------------------------------------------------------
+  / Compute now the separator external degrees
+  /------------------------------------------------------------*/
+  nbnd = 0;
+  for (i=0; i<nvtxs; i++) {
+    me = where[i];
+    pwgts[me] += vwgt[i];
+
+    ASSERT(me >=0 && me <= 2);
+
+    if (me == 2) { /* If it is on the separator do some computations */
+      BNDInsert(nbnd, bndind, bndptr, i);
+
+      edegrees = rinfo[i].edegrees;
+      edegrees[0] = edegrees[1] = 0;
+
+      for (j=xadj[i]; j<xadj[i+1]; j++) {
+        other = where[adjncy[j]];
+        if (other != 2)
+          edegrees[other] += vwgt[adjncy[j]];
+      }
+    }
+  }
+
+  ASSERT(CheckNodeBnd(graph, nbnd));
+
+  graph->mincut = pwgts[2];
+  graph->nbnd = nbnd;
+}
+
+
+/*************************************************************************
+* This function computes the initial id/ed 
+**************************************************************************/
+void Project2WayNodePartition(CtrlType *ctrl, GraphType *graph)
+{
+  int i, j, nvtxs;
+  idxtype *cmap, *where, *cwhere;
+  GraphType *cgraph;
+
+  cgraph = graph->coarser;
+  cwhere = cgraph->where;
+
+  nvtxs = graph->nvtxs;
+  cmap = graph->cmap;
+
+  Allocate2WayNodePartitionMemory(ctrl, graph);
+  where = graph->where;
+  
+  /* Project the partition */
+  for (i=0; i<nvtxs; i++) {
+    where[i] = cwhere[cmap[i]];
+    ASSERTP(where[i] >= 0 && where[i] <= 2, ("%d %d %d %d\n", i, cmap[i], where[i], cwhere[cmap[i]]));
+  }
+
+  FreeGraph(graph->coarser);
+  graph->coarser = NULL;
+
+  Compute2WayNodePartitionParams(ctrl, graph);
+}
Index: /inundation/pymetis/metis-4.0/Lib/stat.c
===================================================================
--- /inundation/pymetis/metis-4.0/Lib/stat.c	(revision 2051)
+++ /inundation/pymetis/metis-4.0/Lib/stat.c	(revision 2051)
@@ -0,0 +1,287 @@
+/*
+ * Copyright 1997, Regents of the University of Minnesota
+ *
+ * stat.c
+ *
+ * This file computes various statistics
+ *
+ * Started 7/25/97
+ * George
+ *
+ * $Id: stat.c,v 1.1 1998/11/27 17:59:31 karypis Exp $
+ *
+ */
+
+#include <metis.h>
+
+
+/*************************************************************************
+* This function computes cuts and balance information
+**************************************************************************/
+void ComputePartitionInfo(GraphType *graph, int nparts, idxtype *where)
+{
+  int i, j, k, nvtxs, ncon, mustfree=0;
+  idxtype *xadj, *adjncy, *vwgt, *adjwgt, *kpwgts, *tmpptr;
+  idxtype *padjncy, *padjwgt, *padjcut;
+
+  nvtxs = graph->nvtxs;
+  ncon = graph->ncon;
+  xadj = graph->xadj;
+  adjncy = graph->adjncy;
+  vwgt = graph->vwgt;
+  adjwgt = graph->adjwgt;
+
+  if (vwgt == NULL) {
+    vwgt = graph->vwgt = idxsmalloc(nvtxs, 1, "vwgt");
+    mustfree = 1;
+  }
+  if (adjwgt == NULL) {
+    adjwgt = graph->adjwgt = idxsmalloc(xadj[nvtxs], 1, "adjwgt");
+    mustfree += 2;
+  }
+
+  printf("%d-way Cut: %5d, Vol: %5d, ", nparts, ComputeCut(graph, where), ComputeVolume(graph, where));
+
+  /* Compute balance information */
+  kpwgts = idxsmalloc(ncon*nparts, 0, "ComputePartitionInfo: kpwgts");
+
+  for (i=0; i<nvtxs; i++) {
+    for (j=0; j<ncon; j++) 
+      kpwgts[where[i]*ncon+j] += vwgt[i*ncon+j];
+  }
+
+  if (ncon == 1) {
+    printf("\tBalance: %5.3f out of %5.3f\n", 
+            1.0*nparts*kpwgts[idxamax(nparts, kpwgts)]/(1.0*idxsum(nparts, kpwgts)),
+            1.0*nparts*vwgt[idxamax(nvtxs, vwgt)]/(1.0*idxsum(nparts, kpwgts)));
+  }
+  else {
+    printf("\tBalance:");
+    for (j=0; j<ncon; j++) 
+      printf(" (%5.3f out of %5.3f)", 
+            1.0*nparts*kpwgts[ncon*idxamax_strd(nparts, kpwgts+j, ncon)+j]/(1.0*idxsum_strd(nparts, kpwgts+j, ncon)),
+            1.0*nparts*vwgt[ncon*idxamax_strd(nvtxs, vwgt+j, ncon)+j]/(1.0*idxsum_strd(nparts, kpwgts+j, ncon)));
+    printf("\n");
+  }
+
+
+  /* Compute p-adjncy information */
+  padjncy = idxsmalloc(nparts*nparts, 0, "ComputePartitionInfo: padjncy");
+  padjwgt = idxsmalloc(nparts*nparts, 0, "ComputePartitionInfo: padjwgt");
+  padjcut = idxsmalloc(nparts*nparts, 0, "ComputePartitionInfo: padjwgt");
+
+  idxset(nparts, 0, kpwgts);
+  for (i=0; i<nvtxs; i++) {
+    for (j=xadj[i]; j<xadj[i+1]; j++) {
+      if (where[i] != where[adjncy[j]]) {
+        padjncy[where[i]*nparts+where[adjncy[j]]] = 1;
+        padjcut[where[i]*nparts+where[adjncy[j]]] += adjwgt[j];
+        if (kpwgts[where[adjncy[j]]] == 0) {
+          padjwgt[where[i]*nparts+where[adjncy[j]]]++;
+          kpwgts[where[adjncy[j]]] = 1;
+        }
+      }
+    }
+    for (j=xadj[i]; j<xadj[i+1]; j++) 
+      kpwgts[where[adjncy[j]]] = 0;
+  }
+
+  for (i=0; i<nparts; i++)
+    kpwgts[i] = idxsum(nparts, padjncy+i*nparts);
+  printf("Min/Max/Avg/Bal # of adjacent     subdomains: %5d %5d %5.2f %7.3f\n",
+    kpwgts[idxamin(nparts, kpwgts)], kpwgts[idxamax(nparts, kpwgts)], 
+    1.0*idxsum(nparts, kpwgts)/(1.0*nparts), 
+    1.0*nparts*kpwgts[idxamax(nparts, kpwgts)]/(1.0*idxsum(nparts, kpwgts)));
+
+  for (i=0; i<nparts; i++)
+    kpwgts[i] = idxsum(nparts, padjcut+i*nparts);
+  printf("Min/Max/Avg/Bal # of adjacent subdomain cuts: %5d %5d %5d %7.3f\n",
+    kpwgts[idxamin(nparts, kpwgts)], kpwgts[idxamax(nparts, kpwgts)], idxsum(nparts, kpwgts)/nparts, 
+    1.0*nparts*kpwgts[idxamax(nparts, kpwgts)]/(1.0*idxsum(nparts, kpwgts)));
+
+  for (i=0; i<nparts; i++)
+    kpwgts[i] = idxsum(nparts, padjwgt+i*nparts);
+  printf("Min/Max/Avg/Bal/Frac # of interface    nodes: %5d %5d %5d %7.3f %7.3f\n",
+    kpwgts[idxamin(nparts, kpwgts)], kpwgts[idxamax(nparts, kpwgts)], idxsum(nparts, kpwgts)/nparts, 
+    1.0*nparts*kpwgts[idxamax(nparts, kpwgts)]/(1.0*idxsum(nparts, kpwgts)), 1.0*idxsum(nparts, kpwgts)/(1.0*nvtxs));
+
+  tmpptr = graph->where;
+  graph->where = where;
+  for (i=0; i<nparts; i++)
+    IsConnectedSubdomain(NULL, graph, i, 1);
+  graph->where = tmpptr;
+
+  if (mustfree == 1 || mustfree == 3) {
+    free(vwgt);
+    graph->vwgt = NULL;
+  }
+  if (mustfree == 2 || mustfree == 3) {
+    free(adjwgt);
+    graph->adjwgt = NULL;
+  }
+
+  GKfree(&kpwgts, &padjncy, &padjwgt, &padjcut, LTERM);
+}
+
+
+/*************************************************************************
+* This function computes cuts and balance information
+**************************************************************************/
+void ComputePartitionInfoBipartite(GraphType *graph, int nparts, idxtype *where)
+{
+  int i, j, k, nvtxs, ncon, mustfree=0;
+  idxtype *xadj, *adjncy, *vwgt, *vsize, *adjwgt, *kpwgts, *tmpptr;
+  idxtype *padjncy, *padjwgt, *padjcut;
+
+  nvtxs = graph->nvtxs;
+  ncon = graph->ncon;
+  xadj = graph->xadj;
+  adjncy = graph->adjncy;
+  vwgt = graph->vwgt;
+  vsize = graph->vsize;
+  adjwgt = graph->adjwgt;
+
+  if (vwgt == NULL) {
+    vwgt = graph->vwgt = idxsmalloc(nvtxs, 1, "vwgt");
+    mustfree = 1;
+  }
+  if (adjwgt == NULL) {
+    adjwgt = graph->adjwgt = idxsmalloc(xadj[nvtxs], 1, "adjwgt");
+    mustfree += 2;
+  }
+
+  printf("%d-way Cut: %5d, Vol: %5d, ", nparts, ComputeCut(graph, where), ComputeVolume(graph, where));
+
+  /* Compute balance information */
+  kpwgts = idxsmalloc(ncon*nparts, 0, "ComputePartitionInfo: kpwgts");
+
+  for (i=0; i<nvtxs; i++) {
+    for (j=0; j<ncon; j++) 
+      kpwgts[where[i]*ncon+j] += vwgt[i*ncon+j];
+  }
+
+  if (ncon == 1) {
+    printf("\tBalance: %5.3f out of %5.3f\n", 
+            1.0*nparts*kpwgts[idxamax(nparts, kpwgts)]/(1.0*idxsum(nparts, kpwgts)),
+            1.0*nparts*vwgt[idxamax(nvtxs, vwgt)]/(1.0*idxsum(nparts, kpwgts)));
+  }
+  else {
+    printf("\tBalance:");
+    for (j=0; j<ncon; j++) 
+      printf(" (%5.3f out of %5.3f)", 
+            1.0*nparts*kpwgts[ncon*idxamax_strd(nparts, kpwgts+j, ncon)+j]/(1.0*idxsum_strd(nparts, kpwgts+j, ncon)),
+            1.0*nparts*vwgt[ncon*idxamax_strd(nvtxs, vwgt+j, ncon)+j]/(1.0*idxsum_strd(nparts, kpwgts+j, ncon)));
+    printf("\n");
+  }
+
+
+  /* Compute p-adjncy information */
+  padjncy = idxsmalloc(nparts*nparts, 0, "ComputePartitionInfo: padjncy");
+  padjwgt = idxsmalloc(nparts*nparts, 0, "ComputePartitionInfo: padjwgt");
+  padjcut = idxsmalloc(nparts*nparts, 0, "ComputePartitionInfo: padjwgt");
+
+  idxset(nparts, 0, kpwgts);
+  for (i=0; i<nvtxs; i++) {
+    for (j=xadj[i]; j<xadj[i+1]; j++) {
+      if (where[i] != where[adjncy[j]]) {
+        padjncy[where[i]*nparts+where[adjncy[j]]] = 1;
+        padjcut[where[i]*nparts+where[adjncy[j]]] += adjwgt[j];
+        if (kpwgts[where[adjncy[j]]] == 0) {
+          padjwgt[where[i]*nparts+where[adjncy[j]]] += vsize[i];
+          kpwgts[where[adjncy[j]]] = 1;
+        }
+      }
+    }
+    for (j=xadj[i]; j<xadj[i+1]; j++) 
+      kpwgts[where[adjncy[j]]] = 0;
+  }
+
+  for (i=0; i<nparts; i++)
+    kpwgts[i] = idxsum(nparts, padjncy+i*nparts);
+  printf("Min/Max/Avg/Bal # of adjacent     subdomains: %5d %5d %5d %7.3f\n",
+    kpwgts[idxamin(nparts, kpwgts)], kpwgts[idxamax(nparts, kpwgts)], idxsum(nparts, kpwgts)/nparts, 
+    1.0*nparts*kpwgts[idxamax(nparts, kpwgts)]/(1.0*idxsum(nparts, kpwgts)));
+
+  for (i=0; i<nparts; i++)
+    kpwgts[i] = idxsum(nparts, padjcut+i*nparts);
+  printf("Min/Max/Avg/Bal # of adjacent subdomain cuts: %5d %5d %5d %7.3f\n",
+    kpwgts[idxamin(nparts, kpwgts)], kpwgts[idxamax(nparts, kpwgts)], idxsum(nparts, kpwgts)/nparts, 
+    1.0*nparts*kpwgts[idxamax(nparts, kpwgts)]/(1.0*idxsum(nparts, kpwgts)));
+
+  for (i=0; i<nparts; i++)
+    kpwgts[i] = idxsum(nparts, padjwgt+i*nparts);
+  printf("Min/Max/Avg/Bal/Frac # of interface    nodes: %5d %5d %5d %7.3f %7.3f\n",
+    kpwgts[idxamin(nparts, kpwgts)], kpwgts[idxamax(nparts, kpwgts)], idxsum(nparts, kpwgts)/nparts, 
+    1.0*nparts*kpwgts[idxamax(nparts, kpwgts)]/(1.0*idxsum(nparts, kpwgts)), 1.0*idxsum(nparts, kpwgts)/(1.0*nvtxs));
+
+
+  if (mustfree == 1 || mustfree == 3) {
+    free(vwgt);
+    graph->vwgt = NULL;
+  }
+  if (mustfree == 2 || mustfree == 3) {
+    free(adjwgt);
+    graph->adjwgt = NULL;
+  }
+
+  GKfree(&kpwgts, &padjncy, &padjwgt, &padjcut, LTERM);
+}
+
+
+
+/*************************************************************************
+* This function computes the balance of the partitioning
+**************************************************************************/
+void ComputePartitionBalance(GraphType *graph, int nparts, idxtype *where, float *ubvec)
+{
+  int i, j, nvtxs, ncon;
+  idxtype *kpwgts, *vwgt;
+  float balance;
+
+  nvtxs = graph->nvtxs;
+  ncon = graph->ncon;
+  vwgt = graph->vwgt;
+
+  kpwgts = idxsmalloc(nparts, 0, "ComputePartitionInfo: kpwgts");
+
+  if (vwgt == NULL) {
+    for (i=0; i<nvtxs; i++)
+      kpwgts[where[i]]++;
+    ubvec[0] = 1.0*nparts*kpwgts[idxamax(nparts, kpwgts)]/(1.0*nvtxs);
+  }
+  else {
+    for (j=0; j<ncon; j++) {
+      idxset(nparts, 0, kpwgts);
+      for (i=0; i<graph->nvtxs; i++)
+        kpwgts[where[i]] += vwgt[i*ncon+j];
+
+      ubvec[j] = 1.0*nparts*kpwgts[idxamax(nparts, kpwgts)]/(1.0*idxsum(nparts, kpwgts));
+    }
+  }
+
+  free(kpwgts);
+
+}
+
+
+/*************************************************************************
+* This function computes the balance of the element partitioning
+**************************************************************************/
+float ComputeElementBalance(int ne, int nparts, idxtype *where)
+{
+  int i;
+  idxtype *kpwgts;
+  float balance;
+
+  kpwgts = idxsmalloc(nparts, 0, "ComputeElementBalance: kpwgts");
+
+  for (i=0; i<ne; i++)
+    kpwgts[where[i]]++;
+
+  balance = 1.0*nparts*kpwgts[idxamax(nparts, kpwgts)]/(1.0*idxsum(nparts, kpwgts));
+
+  free(kpwgts);
+
+  return balance;
+
+}
Index: /inundation/pymetis/metis-4.0/Lib/struct.h
===================================================================
--- /inundation/pymetis/metis-4.0/Lib/struct.h	(revision 2051)
+++ /inundation/pymetis/metis-4.0/Lib/struct.h	(revision 2051)
@@ -0,0 +1,251 @@
+/*
+ * Copyright 1997, Regents of the University of Minnesota
+ *
+ * struct.h
+ *
+ * This file contains data structures for ILU routines.
+ *
+ * Started 9/26/95
+ * George
+ *
+ * $Id: struct.h,v 1.1 1998/11/27 17:59:31 karypis Exp $
+ */
+
+/* Undefine the following #define in order to use short int as the idxtype */
+#define IDXTYPE_INT
+
+/* Indexes are as long as integers for now */
+#ifdef IDXTYPE_INT
+typedef int idxtype;
+#else
+typedef short idxtype;
+#endif
+
+#define MAXIDX	(1<<8*sizeof(idxtype)-2)
+
+
+/*************************************************************************
+* The following data structure stores key-value pair
+**************************************************************************/
+struct KeyValueType {
+  idxtype key;
+  idxtype val;
+};
+
+typedef struct KeyValueType KeyValueType;
+
+
+/*************************************************************************
+* The following data structure will hold a node of a doubly-linked list.
+**************************************************************************/
+struct ListNodeType {
+  int id;                       	/* The id value of the node */
+  struct ListNodeType *prev, *next;     /* It's a doubly-linked list */
+};
+
+typedef struct ListNodeType ListNodeType;
+
+
+
+/*************************************************************************
+* The following data structure is used to store the buckets for the 
+* refinment algorithms
+**************************************************************************/
+struct PQueueType {
+  int type;                     /* The type of the representation used */
+  int nnodes;
+  int maxnodes;
+  int mustfree;
+
+  /* Linear array version of the data structures */
+  int pgainspan, ngainspan;     /* plus and negative gain span */
+  int maxgain;
+  ListNodeType *nodes;
+  ListNodeType **buckets;
+
+  /* Heap version of the data structure */
+  KeyValueType *heap;
+  idxtype *locator;
+};
+
+typedef struct PQueueType PQueueType;
+
+
+/*************************************************************************
+* The following data structure stores an edge
+**************************************************************************/
+struct edegreedef {
+  idxtype pid;
+  idxtype ed;
+};
+typedef struct edegreedef EDegreeType;
+
+
+/*************************************************************************
+* The following data structure stores an edge for vol
+**************************************************************************/
+struct vedegreedef {
+  idxtype pid;
+  idxtype ed, ned;
+  idxtype gv;
+};
+typedef struct vedegreedef VEDegreeType;
+
+
+/*************************************************************************
+* This data structure holds various working space data
+**************************************************************************/
+struct workspacedef {
+  idxtype *core;			/* Where pairs, indices, and degrees are coming from */
+  int maxcore, ccore;
+
+  EDegreeType *edegrees;
+  VEDegreeType *vedegrees;
+  int cdegree;
+
+  idxtype *auxcore;			/* This points to the memory of the edegrees */
+
+  idxtype *pmat;			/* An array of k^2 used for eliminating domain 
+                                           connectivity in k-way refinement */
+};
+
+typedef struct workspacedef WorkSpaceType;
+
+
+/*************************************************************************
+* The following data structure holds information on degrees for k-way
+* partition
+**************************************************************************/
+struct rinfodef {
+ int id, ed;            	/* ID/ED of nodes */
+ int ndegrees;          	/* The number of different ext-degrees */
+ EDegreeType *edegrees;     	/* List of edges */
+};
+
+typedef struct rinfodef RInfoType;
+
+
+/*************************************************************************
+* The following data structure holds information on degrees for k-way
+* vol-based partition
+**************************************************************************/
+struct vrinfodef {
+ int id, ed, nid;            	/* ID/ED of nodes */
+ int gv;            		/* IV/EV of nodes */
+ int ndegrees;          	/* The number of different ext-degrees */
+ VEDegreeType *edegrees;     	/* List of edges */
+};
+
+typedef struct vrinfodef VRInfoType;
+
+
+/*************************************************************************
+* The following data structure holds information on degrees for k-way
+* partition
+**************************************************************************/
+struct nrinfodef {
+ idxtype edegrees[2];  
+};
+
+typedef struct nrinfodef NRInfoType;
+
+
+/*************************************************************************
+* This data structure holds the input graph
+**************************************************************************/
+struct graphdef {
+  idxtype *gdata, *rdata;	/* Memory pools for graph and refinement data.
+                                   This is where memory is allocated and used
+                                   the rest of the fields in this structure */
+
+  int nvtxs, nedges;		/* The # of vertices and edges in the graph */
+  idxtype *xadj;		/* Pointers to the locally stored vertices */
+  idxtype *vwgt;		/* Vertex weights */
+  idxtype *vsize;		/* Vertex sizes for min-volume formulation */
+  idxtype *adjncy;		/* Array that stores the adjacency lists of nvtxs */
+  idxtype *adjwgt;		/* Array that stores the weights of the adjacency lists */
+
+  idxtype *adjwgtsum;		/* The sum of the adjacency weight of each vertex */
+
+  idxtype *label;
+
+  idxtype *cmap;
+
+  /* Partition parameters */
+  int mincut, minvol;
+  idxtype *where, *pwgts;
+  int nbnd;
+  idxtype *bndptr, *bndind;
+
+  /* Bisection refinement parameters */
+  idxtype *id, *ed;
+
+  /* K-way refinement parameters */
+  RInfoType *rinfo;
+
+  /* K-way volume refinement parameters */
+  VRInfoType *vrinfo;
+
+  /* Node refinement information */
+  NRInfoType *nrinfo;
+
+
+  /* Additional info needed by the MOC routines */
+  int ncon;			/* The # of constrains */ 
+  float *nvwgt;			/* Normalized vertex weights */
+  float *npwgts;		/* The normalized partition weights */
+
+  struct graphdef *coarser, *finer;
+};
+
+typedef struct graphdef GraphType;
+
+
+
+/*************************************************************************
+* The following data type implements a timer
+**************************************************************************/
+typedef double timer;
+
+
+/*************************************************************************
+* The following structure stores information used by Metis
+**************************************************************************/
+struct controldef {
+  int CoarsenTo;		/* The # of vertices in the coarsest graph */
+  int dbglvl;			/* Controls the debuging output of the program */
+  int CType;			/* The type of coarsening */
+  int IType;			/* The type of initial partitioning */
+  int RType;			/* The type of refinement */
+  int maxvwgt;			/* The maximum allowed weight for a vertex */
+  float nmaxvwgt;		/* The maximum allowed weight for a vertex for each constrain */
+  int optype;			/* Type of operation */
+  int pfactor;			/* .1*prunning factor */
+  int nseps;			/* The number of separators to be found during multiple bisections */
+  int oflags;
+
+  WorkSpaceType wspace;		/* Work Space Informations */
+
+  /* Various Timers */
+  timer TotalTmr, InitPartTmr, MatchTmr, ContractTmr, CoarsenTmr, UncoarsenTmr, 
+        SepTmr, RefTmr, ProjectTmr, SplitTmr, AuxTmr1, AuxTmr2, AuxTmr3, AuxTmr4, AuxTmr5, AuxTmr6;
+
+};
+
+typedef struct controldef CtrlType;
+
+
+/*************************************************************************
+* The following data structure stores max-partition weight info for 
+* Vertical MOC k-way refinement
+**************************************************************************/
+struct vpwgtdef {
+  float max[2][MAXNCON];
+  int imax[2][MAXNCON];
+};
+
+typedef struct vpwgtdef VPInfoType;
+
+
+
+
Index: /inundation/pymetis/metis-4.0/Lib/subdomains.c
===================================================================
--- /inundation/pymetis/metis-4.0/Lib/subdomains.c	(revision 2051)
+++ /inundation/pymetis/metis-4.0/Lib/subdomains.c	(revision 2051)
@@ -0,0 +1,1295 @@
+/*
+ * Copyright 1997, Regents of the University of Minnesota
+ *
+ * subdomains.c
+ *
+ * This file contains functions that deal with prunning the number of
+ * adjacent subdomains in KMETIS
+ *
+ * Started 7/15/98
+ * George
+ *
+ * $Id: subdomains.c,v 1.1 1998/11/27 17:59:32 karypis Exp $
+ *
+ */
+
+#include <metis.h>
+
+
+/*************************************************************************
+* This function performs k-way refinement
+**************************************************************************/
+void Random_KWayEdgeRefineMConn(CtrlType *ctrl, GraphType *graph, int nparts, float *tpwgts, float ubfactor, int npasses, int ffactor)
+{
+  int i, ii, iii, j, jj, k, l, pass, nvtxs, nmoves, nbnd, tvwgt, myndegrees; 
+  int from, me, to, oldcut, vwgt, gain;
+  int maxndoms, nadd;
+  idxtype *xadj, *adjncy, *adjwgt;
+  idxtype *where, *pwgts, *perm, *bndptr, *bndind, *minwgt, *maxwgt, *itpwgts;
+  idxtype *phtable, *pmat, *pmatptr, *ndoms;
+  EDegreeType *myedegrees;
+  RInfoType *myrinfo;
+
+  nvtxs = graph->nvtxs;
+  xadj = graph->xadj;
+  adjncy = graph->adjncy;
+  adjwgt = graph->adjwgt;
+
+  bndptr = graph->bndptr;
+  bndind = graph->bndind;
+
+  where = graph->where;
+  pwgts = graph->pwgts;
+
+  pmat = ctrl->wspace.pmat;
+  phtable = idxwspacemalloc(ctrl, nparts);
+  ndoms = idxwspacemalloc(ctrl, nparts);
+
+  ComputeSubDomainGraph(graph, nparts, pmat, ndoms);
+
+  /* Setup the weight intervals of the various subdomains */
+  minwgt =  idxwspacemalloc(ctrl, nparts);
+  maxwgt = idxwspacemalloc(ctrl, nparts);
+  itpwgts = idxwspacemalloc(ctrl, nparts);
+  tvwgt = idxsum(nparts, pwgts);
+  ASSERT(tvwgt == idxsum(nvtxs, graph->vwgt));
+
+  for (i=0; i<nparts; i++) {
+    itpwgts[i] = tpwgts[i]*tvwgt;
+    maxwgt[i] = tpwgts[i]*tvwgt*ubfactor;
+    minwgt[i] = tpwgts[i]*tvwgt*(1.0/ubfactor);
+  }
+
+  perm = idxwspacemalloc(ctrl, nvtxs);
+
+  IFSET(ctrl->dbglvl, DBG_REFINE,
+     printf("Partitions: [%6d %6d]-[%6d %6d], Balance: %5.3f, Nv-Nb[%6d %6d]. Cut: %6d\n",
+             pwgts[idxamin(nparts, pwgts)], pwgts[idxamax(nparts, pwgts)], minwgt[0], maxwgt[0], 
+             1.0*nparts*pwgts[idxamax(nparts, pwgts)]/tvwgt, graph->nvtxs, graph->nbnd,
+             graph->mincut));
+
+  for (pass=0; pass<npasses; pass++) {
+    ASSERT(ComputeCut(graph, where) == graph->mincut);
+
+    maxndoms = ndoms[idxamax(nparts, ndoms)];
+
+    oldcut = graph->mincut;
+    nbnd = graph->nbnd;
+
+    RandomPermute(nbnd, perm, 1);
+    for (nmoves=iii=0; iii<graph->nbnd; iii++) {
+      ii = perm[iii];
+      if (ii >= nbnd)
+        continue;
+      i = bndind[ii];
+
+      myrinfo = graph->rinfo+i;
+
+      if (myrinfo->ed >= myrinfo->id) { /* Total ED is too high */
+        from = where[i];
+        vwgt = graph->vwgt[i];
+
+        if (myrinfo->id > 0 && pwgts[from]-vwgt < minwgt[from]) 
+          continue;   /* This cannot be moved! */
+
+        myedegrees = myrinfo->edegrees;
+        myndegrees = myrinfo->ndegrees;
+
+        /* Determine the valid domains */
+        for (j=0; j<myndegrees; j++) {
+          to = myedegrees[j].pid;
+          phtable[to] = 1;
+          pmatptr = pmat + to*nparts;
+          for (nadd=0, k=0; k<myndegrees; k++) {
+            if (k == j)
+              continue;
+
+            l = myedegrees[k].pid;
+            if (pmatptr[l] == 0) {
+              if (ndoms[l] > maxndoms-1) {
+                phtable[to] = 0;
+                nadd = maxndoms;
+                break;
+              }
+              nadd++;
+            }
+          }
+          if (ndoms[to]+nadd > maxndoms)
+            phtable[to] = 0;
+          if (nadd == 0)
+            phtable[to] = 2;
+        }
+
+        /* Find the first valid move */
+        j = myrinfo->id;
+        for (k=0; k<myndegrees; k++) {
+          to = myedegrees[k].pid;
+          if (!phtable[to])
+            continue;
+          gain = myedegrees[k].ed-j; /* j = myrinfo->id. Allow good nodes to move */ 
+          if (pwgts[to]+vwgt <= maxwgt[to]+ffactor*gain && gain >= 0)  
+            break;
+        }
+        if (k == myndegrees)
+          continue;  /* break out if you did not find a candidate */
+
+        for (j=k+1; j<myndegrees; j++) {
+          to = myedegrees[j].pid;
+          if (!phtable[to])
+            continue;
+          if ((myedegrees[j].ed > myedegrees[k].ed && pwgts[to]+vwgt <= maxwgt[to]) ||
+              (myedegrees[j].ed == myedegrees[k].ed && 
+               itpwgts[myedegrees[k].pid]*pwgts[to] < itpwgts[to]*pwgts[myedegrees[k].pid]))
+            k = j;
+        }
+
+        to = myedegrees[k].pid;
+
+        j = 0;
+        if (myedegrees[k].ed-myrinfo->id > 0)
+          j = 1;
+        else if (myedegrees[k].ed-myrinfo->id == 0) {
+          if (/*(iii&7) == 0  ||*/ phtable[myedegrees[k].pid] == 2 || pwgts[from] >= maxwgt[from] || itpwgts[from]*(pwgts[to]+vwgt) < itpwgts[to]*pwgts[from])
+            j = 1;
+        }
+        if (j == 0)
+          continue;
+          
+        /*=====================================================================
+        * If we got here, we can now move the vertex from 'from' to 'to' 
+        *======================================================================*/
+        graph->mincut -= myedegrees[k].ed-myrinfo->id;
+
+        IFSET(ctrl->dbglvl, DBG_MOVEINFO, printf("\t\tMoving %6d to %3d. Gain: %4d. Cut: %6d\n", i, to, myedegrees[k].ed-myrinfo->id, graph->mincut));
+
+        /* Update pmat to reflect the move of 'i' */
+        pmat[from*nparts+to] += (myrinfo->id-myedegrees[k].ed);
+        pmat[to*nparts+from] += (myrinfo->id-myedegrees[k].ed);
+        if (pmat[from*nparts+to] == 0) {
+          ndoms[from]--;
+          if (ndoms[from]+1 == maxndoms)
+            maxndoms = ndoms[idxamax(nparts, ndoms)];
+        }
+        if (pmat[to*nparts+from] == 0) {
+          ndoms[to]--;
+          if (ndoms[to]+1 == maxndoms)
+            maxndoms = ndoms[idxamax(nparts, ndoms)];
+        }
+
+        /* Update where, weight, and ID/ED information of the vertex you moved */
+        where[i] = to;
+        INC_DEC(pwgts[to], pwgts[from], vwgt);
+        myrinfo->ed += myrinfo->id-myedegrees[k].ed;
+        SWAP(myrinfo->id, myedegrees[k].ed, j);
+        if (myedegrees[k].ed == 0) 
+          myedegrees[k] = myedegrees[--myrinfo->ndegrees];
+        else
+          myedegrees[k].pid = from;
+
+        if (myrinfo->ed-myrinfo->id < 0)
+          BNDDelete(nbnd, bndind, bndptr, i);
+
+        /* Update the degrees of adjacent vertices */
+        for (j=xadj[i]; j<xadj[i+1]; j++) {
+          ii = adjncy[j];
+          me = where[ii];
+
+          myrinfo = graph->rinfo+ii;
+          if (myrinfo->edegrees == NULL) {
+            myrinfo->edegrees = ctrl->wspace.edegrees+ctrl->wspace.cdegree;
+            ctrl->wspace.cdegree += xadj[ii+1]-xadj[ii];
+          }
+          myedegrees = myrinfo->edegrees;
+
+          ASSERT(CheckRInfo(myrinfo));
+
+          if (me == from) {
+            INC_DEC(myrinfo->ed, myrinfo->id, adjwgt[j]);
+
+            if (myrinfo->ed-myrinfo->id >= 0 && bndptr[ii] == -1)
+              BNDInsert(nbnd, bndind, bndptr, ii);
+          }
+          else if (me == to) {
+            INC_DEC(myrinfo->id, myrinfo->ed, adjwgt[j]);
+
+            if (myrinfo->ed-myrinfo->id < 0 && bndptr[ii] != -1)
+              BNDDelete(nbnd, bndind, bndptr, ii);
+          }
+
+          /* Remove contribution from the .ed of 'from' */
+          if (me != from) {
+            for (k=0; k<myrinfo->ndegrees; k++) {
+              if (myedegrees[k].pid == from) {
+                if (myedegrees[k].ed == adjwgt[j])
+                  myedegrees[k] = myedegrees[--myrinfo->ndegrees];
+                else
+                  myedegrees[k].ed -= adjwgt[j];
+                break;
+              }
+            }
+          }
+
+          /* Add contribution to the .ed of 'to' */
+          if (me != to) {
+            for (k=0; k<myrinfo->ndegrees; k++) {
+              if (myedegrees[k].pid == to) {
+                myedegrees[k].ed += adjwgt[j];
+                break;
+              }
+            }
+            if (k == myrinfo->ndegrees) {
+              myedegrees[myrinfo->ndegrees].pid = to;
+              myedegrees[myrinfo->ndegrees++].ed = adjwgt[j];
+            }
+          }
+
+          /* Update pmat to reflect the move of 'i' for domains other than 'from' and 'to' */
+          if (me != from && me != to) {
+            pmat[me*nparts+from] -= adjwgt[j];
+            pmat[from*nparts+me] -= adjwgt[j];
+            if (pmat[me*nparts+from] == 0) {
+              ndoms[me]--;
+              if (ndoms[me]+1 == maxndoms)
+                maxndoms = ndoms[idxamax(nparts, ndoms)];
+            }
+            if (pmat[from*nparts+me] == 0) {
+              ndoms[from]--;
+              if (ndoms[from]+1 == maxndoms)
+                maxndoms = ndoms[idxamax(nparts, ndoms)];
+            }
+
+            if (pmat[me*nparts+to] == 0) {
+              ndoms[me]++;
+              if (ndoms[me] > maxndoms) {
+                printf("You just increased the maxndoms: %d %d\n", ndoms[me], maxndoms);
+                maxndoms = ndoms[me];
+              }
+            }
+            if (pmat[to*nparts+me] == 0) {
+              ndoms[to]++;
+              if (ndoms[to] > maxndoms) {
+                printf("You just increased the maxndoms: %d %d\n", ndoms[to], maxndoms);
+                maxndoms = ndoms[to];
+              }
+            }
+            pmat[me*nparts+to] += adjwgt[j];
+            pmat[to*nparts+me] += adjwgt[j];
+          }
+
+          ASSERT(myrinfo->ndegrees <= xadj[ii+1]-xadj[ii]);
+          ASSERT(CheckRInfo(myrinfo));
+
+        }
+        nmoves++;
+      }
+    }
+
+    graph->nbnd = nbnd;
+
+    IFSET(ctrl->dbglvl, DBG_REFINE,
+       printf("\t[%6d %6d], Balance: %5.3f, Nb: %6d. Nmoves: %5d, Cut: %5d, Vol: %5d, %d\n",
+               pwgts[idxamin(nparts, pwgts)], pwgts[idxamax(nparts, pwgts)],
+               1.0*nparts*pwgts[idxamax(nparts, pwgts)]/tvwgt, graph->nbnd, nmoves, 
+               graph->mincut, ComputeVolume(graph, where), idxsum(nparts, ndoms)));
+
+    if (graph->mincut == oldcut)
+      break;
+  }
+
+  idxwspacefree(ctrl, nparts);
+  idxwspacefree(ctrl, nparts);
+  idxwspacefree(ctrl, nparts);
+  idxwspacefree(ctrl, nparts);
+  idxwspacefree(ctrl, nparts);
+  idxwspacefree(ctrl, nvtxs);
+}
+
+
+
+/*************************************************************************
+* This function performs k-way refinement
+**************************************************************************/
+void Greedy_KWayEdgeBalanceMConn(CtrlType *ctrl, GraphType *graph, int nparts, float *tpwgts, float ubfactor, int npasses)
+{
+  int i, ii, iii, j, jj, k, l, pass, nvtxs, nbnd, tvwgt, myndegrees, oldgain, gain, nmoves; 
+  int from, me, to, oldcut, vwgt, maxndoms, nadd;
+  idxtype *xadj, *adjncy, *adjwgt;
+  idxtype *where, *pwgts, *perm, *bndptr, *bndind, *minwgt, *maxwgt, *moved, *itpwgts;
+  idxtype *phtable, *pmat, *pmatptr, *ndoms;
+  EDegreeType *myedegrees;
+  RInfoType *myrinfo;
+  PQueueType queue;
+
+  nvtxs = graph->nvtxs;
+  xadj = graph->xadj;
+  adjncy = graph->adjncy;
+  adjwgt = graph->adjwgt;
+
+  bndind = graph->bndind;
+  bndptr = graph->bndptr;
+
+  where = graph->where;
+  pwgts = graph->pwgts;
+  
+  pmat = ctrl->wspace.pmat;
+  phtable = idxwspacemalloc(ctrl, nparts);
+  ndoms = idxwspacemalloc(ctrl, nparts);
+
+  ComputeSubDomainGraph(graph, nparts, pmat, ndoms);
+
+
+  /* Setup the weight intervals of the various subdomains */
+  minwgt =  idxwspacemalloc(ctrl, nparts);
+  maxwgt = idxwspacemalloc(ctrl, nparts);
+  itpwgts = idxwspacemalloc(ctrl, nparts);
+  tvwgt = idxsum(nparts, pwgts);
+  ASSERT(tvwgt == idxsum(nvtxs, graph->vwgt));
+
+  for (i=0; i<nparts; i++) {
+    itpwgts[i] = tpwgts[i]*tvwgt;
+    maxwgt[i] = tpwgts[i]*tvwgt*ubfactor;
+    minwgt[i] = tpwgts[i]*tvwgt*(1.0/ubfactor);
+  }
+
+  perm = idxwspacemalloc(ctrl, nvtxs);
+  moved = idxwspacemalloc(ctrl, nvtxs);
+
+  PQueueInit(ctrl, &queue, nvtxs, graph->adjwgtsum[idxamax(nvtxs, graph->adjwgtsum)]);
+
+  IFSET(ctrl->dbglvl, DBG_REFINE,
+     printf("Partitions: [%6d %6d]-[%6d %6d], Balance: %5.3f, Nv-Nb[%6d %6d]. Cut: %6d [B]\n",
+             pwgts[idxamin(nparts, pwgts)], pwgts[idxamax(nparts, pwgts)], minwgt[0], maxwgt[0], 
+             1.0*nparts*pwgts[idxamax(nparts, pwgts)]/tvwgt, graph->nvtxs, graph->nbnd,
+             graph->mincut));
+
+  for (pass=0; pass<npasses; pass++) {
+    ASSERT(ComputeCut(graph, where) == graph->mincut);
+
+    /* Check to see if things are out of balance, given the tolerance */
+    for (i=0; i<nparts; i++) {
+      if (pwgts[i] > maxwgt[i])
+        break;
+    }
+    if (i == nparts) /* Things are balanced. Return right away */
+      break;
+
+    PQueueReset(&queue);
+    idxset(nvtxs, -1, moved);
+
+    oldcut = graph->mincut;
+    nbnd = graph->nbnd;
+
+    RandomPermute(nbnd, perm, 1);
+    for (ii=0; ii<nbnd; ii++) {
+      i = bndind[perm[ii]];
+      PQueueInsert(&queue, i, graph->rinfo[i].ed - graph->rinfo[i].id);
+      moved[i] = 2;
+    }
+
+    maxndoms = ndoms[idxamax(nparts, ndoms)];
+
+    for (nmoves=0;;) {
+      if ((i = PQueueGetMax(&queue)) == -1) 
+        break;
+      moved[i] = 1;
+
+      myrinfo = graph->rinfo+i;
+      from = where[i];
+      vwgt = graph->vwgt[i];
+
+      if (pwgts[from]-vwgt < minwgt[from]) 
+        continue;   /* This cannot be moved! */
+
+      myedegrees = myrinfo->edegrees;
+      myndegrees = myrinfo->ndegrees;
+
+      /* Determine the valid domains */
+      for (j=0; j<myndegrees; j++) {
+        to = myedegrees[j].pid;
+        phtable[to] = 1;
+        pmatptr = pmat + to*nparts;
+        for (nadd=0, k=0; k<myndegrees; k++) {
+          if (k == j)
+            continue;
+
+          l = myedegrees[k].pid;
+          if (pmatptr[l] == 0) {
+            if (ndoms[l] > maxndoms-1) {
+              phtable[to] = 0;
+              nadd = maxndoms;
+              break;
+            }
+            nadd++;
+          }
+        }
+        if (ndoms[to]+nadd > maxndoms)
+          phtable[to] = 0;
+      }
+
+      for (k=0; k<myndegrees; k++) {
+        to = myedegrees[k].pid;
+        if (!phtable[to])
+          continue;
+        if (pwgts[to]+vwgt <= maxwgt[to] || itpwgts[from]*(pwgts[to]+vwgt) <= itpwgts[to]*pwgts[from]) 
+          break;
+      }
+      if (k == myndegrees)
+        continue;  /* break out if you did not find a candidate */
+
+      for (j=k+1; j<myndegrees; j++) {
+        to = myedegrees[j].pid;
+        if (!phtable[to])
+          continue;
+        if (itpwgts[myedegrees[k].pid]*pwgts[to] < itpwgts[to]*pwgts[myedegrees[k].pid]) 
+          k = j;
+      }
+
+      to = myedegrees[k].pid;
+
+      if (pwgts[from] < maxwgt[from] && pwgts[to] > minwgt[to] && myedegrees[k].ed-myrinfo->id < 0) 
+        continue;
+
+      /*=====================================================================
+      * If we got here, we can now move the vertex from 'from' to 'to' 
+      *======================================================================*/
+      graph->mincut -= myedegrees[k].ed-myrinfo->id;
+
+      IFSET(ctrl->dbglvl, DBG_MOVEINFO, printf("\t\tMoving %6d to %3d. Gain: %4d. Cut: %6d\n", i, to, myedegrees[k].ed-myrinfo->id, graph->mincut));
+
+      /* Update pmat to reflect the move of 'i' */
+      pmat[from*nparts+to] += (myrinfo->id-myedegrees[k].ed);
+      pmat[to*nparts+from] += (myrinfo->id-myedegrees[k].ed);
+      if (pmat[from*nparts+to] == 0) {
+        ndoms[from]--;
+        if (ndoms[from]+1 == maxndoms)
+          maxndoms = ndoms[idxamax(nparts, ndoms)];
+      }
+      if (pmat[to*nparts+from] == 0) {
+        ndoms[to]--;
+        if (ndoms[to]+1 == maxndoms)
+          maxndoms = ndoms[idxamax(nparts, ndoms)];
+      }
+
+
+      /* Update where, weight, and ID/ED information of the vertex you moved */
+      where[i] = to;
+      INC_DEC(pwgts[to], pwgts[from], vwgt);
+      myrinfo->ed += myrinfo->id-myedegrees[k].ed;
+      SWAP(myrinfo->id, myedegrees[k].ed, j);
+      if (myedegrees[k].ed == 0) 
+        myedegrees[k] = myedegrees[--myrinfo->ndegrees];
+      else
+        myedegrees[k].pid = from;
+
+      if (myrinfo->ed == 0)
+        BNDDelete(nbnd, bndind, bndptr, i);
+
+      /* Update the degrees of adjacent vertices */
+      for (j=xadj[i]; j<xadj[i+1]; j++) {
+        ii = adjncy[j];
+        me = where[ii];
+
+        myrinfo = graph->rinfo+ii;
+        if (myrinfo->edegrees == NULL) {
+          myrinfo->edegrees = ctrl->wspace.edegrees+ctrl->wspace.cdegree;
+          ctrl->wspace.cdegree += xadj[ii+1]-xadj[ii];
+        }
+        myedegrees = myrinfo->edegrees;
+
+        ASSERT(CheckRInfo(myrinfo));
+
+        oldgain = (myrinfo->ed-myrinfo->id);
+
+        if (me == from) {
+          INC_DEC(myrinfo->ed, myrinfo->id, adjwgt[j]);
+
+          if (myrinfo->ed > 0 && bndptr[ii] == -1)
+            BNDInsert(nbnd, bndind, bndptr, ii);
+        }
+        else if (me == to) {
+          INC_DEC(myrinfo->id, myrinfo->ed, adjwgt[j]);
+
+          if (myrinfo->ed == 0 && bndptr[ii] != -1)
+            BNDDelete(nbnd, bndind, bndptr, ii);
+        }
+
+        /* Remove contribution from the .ed of 'from' */
+        if (me != from) {
+          for (k=0; k<myrinfo->ndegrees; k++) {
+            if (myedegrees[k].pid == from) {
+              if (myedegrees[k].ed == adjwgt[j])
+                myedegrees[k] = myedegrees[--myrinfo->ndegrees];
+              else
+                myedegrees[k].ed -= adjwgt[j];
+              break;
+            }
+          }
+        }
+
+        /* Add contribution to the .ed of 'to' */
+        if (me != to) {
+          for (k=0; k<myrinfo->ndegrees; k++) {
+            if (myedegrees[k].pid == to) {
+              myedegrees[k].ed += adjwgt[j];
+              break;
+            }
+          }
+          if (k == myrinfo->ndegrees) {
+            myedegrees[myrinfo->ndegrees].pid = to;
+            myedegrees[myrinfo->ndegrees++].ed = adjwgt[j];
+          }
+        }
+
+        /* Update pmat to reflect the move of 'i' for domains other than 'from' and 'to' */
+        if (me != from && me != to) {
+          pmat[me*nparts+from] -= adjwgt[j];
+          pmat[from*nparts+me] -= adjwgt[j];
+          if (pmat[me*nparts+from] == 0) {
+            ndoms[me]--;
+            if (ndoms[me]+1 == maxndoms)
+              maxndoms = ndoms[idxamax(nparts, ndoms)];
+          }
+          if (pmat[from*nparts+me] == 0) {
+            ndoms[from]--;
+            if (ndoms[from]+1 == maxndoms)
+              maxndoms = ndoms[idxamax(nparts, ndoms)];
+          }
+
+          if (pmat[me*nparts+to] == 0) {
+            ndoms[me]++;
+            if (ndoms[me] > maxndoms) {
+              printf("You just increased the maxndoms: %d %d\n", ndoms[me], maxndoms);
+              maxndoms = ndoms[me];
+            }
+          }
+          if (pmat[to*nparts+me] == 0) {
+            ndoms[to]++;
+            if (ndoms[to] > maxndoms) {
+              printf("You just increased the maxndoms: %d %d\n", ndoms[to], maxndoms);
+              maxndoms = ndoms[to];
+            }
+          }
+          pmat[me*nparts+to] += adjwgt[j];
+          pmat[to*nparts+me] += adjwgt[j];
+        }
+
+        /* Update the queue */
+        if (me == to || me == from) { 
+          gain = myrinfo->ed-myrinfo->id;
+          if (moved[ii] == 2) {
+            if (myrinfo->ed > 0)
+              PQueueUpdate(&queue, ii, oldgain, gain);
+            else {
+              PQueueDelete(&queue, ii, oldgain);
+              moved[ii] = -1;
+            }
+          }
+          else if (moved[ii] == -1 && myrinfo->ed > 0) {
+            PQueueInsert(&queue, ii, gain);
+            moved[ii] = 2;
+          }
+        } 
+
+        ASSERT(myrinfo->ndegrees <= xadj[ii+1]-xadj[ii]);
+        ASSERT(CheckRInfo(myrinfo));
+      }
+      nmoves++;
+    }
+
+    graph->nbnd = nbnd;
+
+    IFSET(ctrl->dbglvl, DBG_REFINE,
+       printf("\t[%6d %6d], Balance: %5.3f, Nb: %6d. Nmoves: %5d, Cut: %6d, %d\n",
+               pwgts[idxamin(nparts, pwgts)], pwgts[idxamax(nparts, pwgts)],
+               1.0*nparts*pwgts[idxamax(nparts, pwgts)]/tvwgt, graph->nbnd, nmoves, graph->mincut,idxsum(nparts, ndoms)));
+  }
+
+  PQueueFree(ctrl, &queue);
+
+  idxwspacefree(ctrl, nparts);
+  idxwspacefree(ctrl, nparts);
+  idxwspacefree(ctrl, nparts);
+  idxwspacefree(ctrl, nparts);
+  idxwspacefree(ctrl, nparts);
+  idxwspacefree(ctrl, nvtxs);
+  idxwspacefree(ctrl, nvtxs);
+
+}
+
+
+
+
+/*************************************************************************
+* This function computes the subdomain graph
+**************************************************************************/
+void PrintSubDomainGraph(GraphType *graph, int nparts, idxtype *where)
+{
+  int i, j, k, me, nvtxs, total, max;
+  idxtype *xadj, *adjncy, *adjwgt, *pmat;
+
+  nvtxs = graph->nvtxs;
+  xadj = graph->xadj;
+  adjncy = graph->adjncy;
+  adjwgt = graph->adjwgt;
+
+  pmat = idxsmalloc(nparts*nparts, 0, "ComputeSubDomainGraph: pmat");
+
+  for (i=0; i<nvtxs; i++) {
+    me = where[i];
+    for (j=xadj[i]; j<xadj[i+1]; j++) {
+      k = adjncy[j];
+      if (where[k] != me) 
+        pmat[me*nparts+where[k]] += adjwgt[j];
+    }
+  }
+
+  /* printf("Subdomain Info\n"); */
+  total = max = 0;
+  for (i=0; i<nparts; i++) {
+    for (k=0, j=0; j<nparts; j++) {
+      if (pmat[i*nparts+j] > 0)
+        k++;
+    }
+    total += k;
+
+    if (k > max)
+      max = k;
+/*
+    printf("%2d -> %2d  ", i, k);
+    for (j=0; j<nparts; j++) {
+      if (pmat[i*nparts+j] > 0)
+        printf("[%2d %4d] ", j, pmat[i*nparts+j]);
+    }
+    printf("\n");
+*/
+  }
+  printf("Total adjacent subdomains: %d, Max: %d\n", total, max);
+
+  free(pmat);
+}
+
+
+
+/*************************************************************************
+* This function computes the subdomain graph
+**************************************************************************/
+void ComputeSubDomainGraph(GraphType *graph, int nparts, idxtype *pmat, idxtype *ndoms)
+{
+  int i, j, k, me, nvtxs, ndegrees;
+  idxtype *xadj, *adjncy, *adjwgt, *where;
+  RInfoType *rinfo;
+  EDegreeType *edegrees;
+
+  nvtxs = graph->nvtxs;
+  xadj = graph->xadj;
+  adjncy = graph->adjncy;
+  adjwgt = graph->adjwgt;
+  where = graph->where;
+  rinfo = graph->rinfo;
+
+  idxset(nparts*nparts, 0, pmat);
+
+  for (i=0; i<nvtxs; i++) {
+    if (rinfo[i].ed > 0) {
+      me = where[i];
+      ndegrees = rinfo[i].ndegrees;
+      edegrees = rinfo[i].edegrees;
+
+      k = me*nparts;
+      for (j=0; j<ndegrees; j++) 
+        pmat[k+edegrees[j].pid] += edegrees[j].ed;
+    }
+  }
+
+  for (i=0; i<nparts; i++) {
+    ndoms[i] = 0;
+    for (j=0; j<nparts; j++) {
+      if (pmat[i*nparts+j] > 0)
+        ndoms[i]++;
+    }
+  }
+
+}
+
+
+
+
+
+/*************************************************************************
+* This function computes the subdomain graph
+**************************************************************************/
+void EliminateSubDomainEdges(CtrlType *ctrl, GraphType *graph, int nparts, float *tpwgts)
+{
+  int i, ii, j, k, me, other, nvtxs, total, max, avg, totalout, nind, ncand, ncand2, target, target2, nadd;
+  int min, move, cpwgt, tvwgt;
+  idxtype *xadj, *adjncy, *vwgt, *adjwgt, *pwgts, *where, *maxpwgt, *pmat, *ndoms, *mypmat, *otherpmat, *ind;
+  KeyValueType *cand, *cand2;
+
+  nvtxs = graph->nvtxs;
+  xadj = graph->xadj;
+  adjncy = graph->adjncy;
+  vwgt = graph->vwgt;
+  adjwgt = graph->adjwgt;
+
+  where = graph->where;
+  pwgts = graph->pwgts;  /* We assume that this is properly initialized */
+
+  maxpwgt = idxwspacemalloc(ctrl, nparts);
+  ndoms = idxwspacemalloc(ctrl, nparts);
+  otherpmat = idxwspacemalloc(ctrl, nparts);
+  ind = idxwspacemalloc(ctrl, nvtxs);
+  pmat = ctrl->wspace.pmat;
+
+  cand = (KeyValueType *)GKmalloc(nparts*sizeof(KeyValueType), "EliminateSubDomainEdges: cand");
+  cand2 = (KeyValueType *)GKmalloc(nparts*sizeof(KeyValueType), "EliminateSubDomainEdges: cand");
+
+  /* Compute the pmat matrix and ndoms */
+  ComputeSubDomainGraph(graph, nparts, pmat, ndoms);
+
+
+  /* Compute the maximum allowed weight for each domain */
+  tvwgt = idxsum(nparts, pwgts);
+  for (i=0; i<nparts; i++)
+    maxpwgt[i] = 1.25*tpwgts[i]*tvwgt;
+
+
+  /* Get into the loop eliminating subdomain connections */
+  for (;;) {
+    total = idxsum(nparts, ndoms);
+    avg = total/nparts;
+    max = ndoms[idxamax(nparts, ndoms)];
+
+    /* printf("Adjacent Subdomain Stats: Total: %3d, Max: %3d, Avg: %3d [%5d]\n", total, max, avg, idxsum(nparts*nparts, pmat)); */
+
+    if (max < 1.4*avg)
+      break;
+
+    me = idxamax(nparts, ndoms);
+    mypmat = pmat + me*nparts;
+    totalout = idxsum(nparts, mypmat);
+
+    /*printf("Me: %d, TotalOut: %d,\n", me, totalout);*/
+
+    /* Sort the connections according to their cut */
+    for (ncand2=0, i=0; i<nparts; i++) {
+      if (mypmat[i] > 0) {
+        cand2[ncand2].key = mypmat[i];
+        cand2[ncand2++].val = i;
+      }
+    }
+    ikeysort(ncand2, cand2);
+
+    move = 0;
+    for (min=0; min<ncand2; min++) {
+      if (cand2[min].key > totalout/(2*ndoms[me])) 
+        break;
+
+      other = cand2[min].val;
+
+      /*printf("\tMinOut: %d to %d\n", mypmat[other], other);*/
+
+      idxset(nparts, 0, otherpmat);
+
+      /* Go and find the vertices in 'other' that are connected in 'me' */
+      for (nind=0, i=0; i<nvtxs; i++) {
+        if (where[i] == other) {
+          for (j=xadj[i]; j<xadj[i+1]; j++) {
+            if (where[adjncy[j]] == me) {
+              ind[nind++] = i;
+              break;
+            }
+          }
+        }
+      }
+
+      /* Go and construct the otherpmat to see where these nind vertices are connected to */
+      for (cpwgt=0, ii=0; ii<nind; ii++) {
+        i = ind[ii];
+        cpwgt += vwgt[i];
+
+        for (j=xadj[i]; j<xadj[i+1]; j++) 
+          otherpmat[where[adjncy[j]]] += adjwgt[j];
+      }
+      otherpmat[other] = 0;
+
+      for (ncand=0, i=0; i<nparts; i++) {
+        if (otherpmat[i] > 0) {
+          cand[ncand].key = -otherpmat[i];
+          cand[ncand++].val = i;
+        }
+      }
+      ikeysort(ncand, cand);
+
+      /* 
+       * Go through and the select the first domain that is common with 'me', and
+       * does not increase the ndoms[target] higher than my ndoms, subject to the
+       * maxpwgt constraint. Traversal is done from the mostly connected to the least.
+       */
+      target = target2 = -1;
+      for (i=0; i<ncand; i++) {
+        k = cand[i].val;
+
+        if (mypmat[k] > 0) {
+          if (pwgts[k] + cpwgt > maxpwgt[k])  /* Check if balance will go off */
+            continue;
+
+          for (j=0; j<nparts; j++) {
+            if (otherpmat[j] > 0 && ndoms[j] >= ndoms[me]-1 && pmat[nparts*j+k] == 0)
+              break;
+          }
+          if (j == nparts) { /* No bad second level effects */
+            for (nadd=0, j=0; j<nparts; j++) {
+              if (otherpmat[j] > 0 && pmat[nparts*k+j] == 0)
+                nadd++;
+            }
+
+            /*printf("\t\tto=%d, nadd=%d, %d\n", k, nadd, ndoms[k]);*/
+            if (target2 == -1 && ndoms[k]+nadd < ndoms[me]) {
+              target2 = k;
+            }
+            if (nadd == 0) {
+              target = k;
+              break;
+            }
+          }
+        }
+      }
+      if (target == -1 && target2 != -1)
+        target = target2;
+
+      if (target == -1) {
+        /* printf("\t\tCould not make the move\n");*/
+        continue;
+      }
+
+      /*printf("\t\tMoving to %d\n", target);*/
+
+      /* Update the partition weights */
+      INC_DEC(pwgts[target], pwgts[other], cpwgt);
+
+      MoveGroupMConn(ctrl, graph, ndoms, pmat, nparts, target, nind, ind);
+
+      move = 1;
+      break;
+    }
+
+    if (move == 0)
+      break;
+  }
+
+  idxwspacefree(ctrl, nparts);
+  idxwspacefree(ctrl, nparts);
+  idxwspacefree(ctrl, nparts);
+  idxwspacefree(ctrl, nvtxs);
+
+  GKfree(&cand, &cand2, LTERM);
+}
+
+
+/*************************************************************************
+* This function moves a collection of vertices and updates their rinfo
+**************************************************************************/
+void MoveGroupMConn(CtrlType *ctrl, GraphType *graph, idxtype *ndoms, idxtype *pmat,
+                    int nparts, int to, int nind, idxtype *ind)
+{
+  int i, ii, iii, j, jj, k, l, nvtxs, nbnd, myndegrees; 
+  int from, me;
+  idxtype *xadj, *adjncy, *adjwgt;
+  idxtype *where, *bndptr, *bndind;
+  EDegreeType *myedegrees;
+  RInfoType *myrinfo;
+
+  nvtxs = graph->nvtxs;
+  xadj = graph->xadj;
+  adjncy = graph->adjncy;
+  adjwgt = graph->adjwgt;
+
+  where = graph->where;
+  bndptr = graph->bndptr;
+  bndind = graph->bndind;
+
+  nbnd = graph->nbnd;
+
+  for (iii=0; iii<nind; iii++) {
+    i = ind[iii];
+    from = where[i];
+
+    myrinfo = graph->rinfo+i;
+    if (myrinfo->edegrees == NULL) {
+      myrinfo->edegrees = ctrl->wspace.edegrees+ctrl->wspace.cdegree;
+      ctrl->wspace.cdegree += xadj[i+1]-xadj[i];
+      myrinfo->ndegrees = 0;
+    }
+    myedegrees = myrinfo->edegrees;
+
+    /* find the location of 'to' in myrinfo or create it if it is not there */
+    for (k=0; k<myrinfo->ndegrees; k++) {
+      if (myedegrees[k].pid == to)
+        break;
+    }
+    if (k == myrinfo->ndegrees) {
+      myedegrees[k].pid = to;
+      myedegrees[k].ed = 0;
+      myrinfo->ndegrees++;
+    }
+
+    graph->mincut -= myedegrees[k].ed-myrinfo->id;
+
+    /* Update pmat to reflect the move of 'i' */
+    pmat[from*nparts+to] += (myrinfo->id-myedegrees[k].ed);
+    pmat[to*nparts+from] += (myrinfo->id-myedegrees[k].ed);
+    if (pmat[from*nparts+to] == 0) 
+      ndoms[from]--;
+    if (pmat[to*nparts+from] == 0) 
+      ndoms[to]--;
+
+    /* Update where, weight, and ID/ED information of the vertex you moved */
+    where[i] = to;
+    myrinfo->ed += myrinfo->id-myedegrees[k].ed;
+    SWAP(myrinfo->id, myedegrees[k].ed, j);
+    if (myedegrees[k].ed == 0) 
+      myedegrees[k] = myedegrees[--myrinfo->ndegrees];
+    else
+      myedegrees[k].pid = from;
+
+    if (myrinfo->ed-myrinfo->id < 0 && bndptr[i] != -1)
+      BNDDelete(nbnd, bndind, bndptr, i);
+
+    /* Update the degrees of adjacent vertices */
+    for (j=xadj[i]; j<xadj[i+1]; j++) {
+      ii = adjncy[j];
+      me = where[ii];
+
+      myrinfo = graph->rinfo+ii;
+      if (myrinfo->edegrees == NULL) {
+        myrinfo->edegrees = ctrl->wspace.edegrees+ctrl->wspace.cdegree;
+        ctrl->wspace.cdegree += xadj[ii+1]-xadj[ii];
+      }
+      myedegrees = myrinfo->edegrees;
+
+      ASSERT(CheckRInfo(myrinfo));
+
+      if (me == from) {
+        INC_DEC(myrinfo->ed, myrinfo->id, adjwgt[j]);
+
+        if (myrinfo->ed-myrinfo->id >= 0 && bndptr[ii] == -1)
+          BNDInsert(nbnd, bndind, bndptr, ii);
+      }
+      else if (me == to) {
+        INC_DEC(myrinfo->id, myrinfo->ed, adjwgt[j]);
+
+        if (myrinfo->ed-myrinfo->id < 0 && bndptr[ii] != -1)
+          BNDDelete(nbnd, bndind, bndptr, ii);
+      }
+
+      /* Remove contribution from the .ed of 'from' */
+      if (me != from) {
+        for (k=0; k<myrinfo->ndegrees; k++) {
+          if (myedegrees[k].pid == from) {
+            if (myedegrees[k].ed == adjwgt[j])
+              myedegrees[k] = myedegrees[--myrinfo->ndegrees];
+            else
+              myedegrees[k].ed -= adjwgt[j];
+            break;
+          }
+        }
+      }
+
+      /* Add contribution to the .ed of 'to' */
+      if (me != to) {
+        for (k=0; k<myrinfo->ndegrees; k++) {
+          if (myedegrees[k].pid == to) {
+            myedegrees[k].ed += adjwgt[j];
+            break;
+          }
+        }
+        if (k == myrinfo->ndegrees) {
+          myedegrees[myrinfo->ndegrees].pid = to;
+          myedegrees[myrinfo->ndegrees++].ed = adjwgt[j];
+        }
+      }
+
+      /* Update pmat to reflect the move of 'i' for domains other than 'from' and 'to' */
+      if (me != from && me != to) {
+        pmat[me*nparts+from] -= adjwgt[j];
+        pmat[from*nparts+me] -= adjwgt[j];
+        if (pmat[me*nparts+from] == 0) 
+          ndoms[me]--;
+        if (pmat[from*nparts+me] == 0) 
+          ndoms[from]--;
+
+        if (pmat[me*nparts+to] == 0) 
+          ndoms[me]++;
+        if (pmat[to*nparts+me] == 0) 
+          ndoms[to]++;
+
+        pmat[me*nparts+to] += adjwgt[j];
+        pmat[to*nparts+me] += adjwgt[j];
+      }
+
+      ASSERT(CheckRInfo(myrinfo));
+    }
+
+    ASSERT(CheckRInfo(graph->rinfo+i));
+  }
+
+  graph->nbnd = nbnd;
+
+}
+
+
+
+
+/*************************************************************************
+* This function finds all the connected components induced by the 
+* partitioning vector in wgraph->where and tries to push them around to 
+* remove some of them
+**************************************************************************/
+void EliminateComponents(CtrlType *ctrl, GraphType *graph, int nparts, float *tpwgts, float ubfactor)
+{
+  int i, ii, j, jj, k, me, nvtxs, tvwgt, first, last, nleft, ncmps, cwgt, other, target, deltawgt;
+  idxtype *xadj, *adjncy, *vwgt, *adjwgt, *where, *pwgts, *maxpwgt;
+  idxtype *cpvec, *touched, *perm, *todo, *cind, *cptr, *npcmps;
+
+  nvtxs = graph->nvtxs;
+  xadj = graph->xadj;
+  adjncy = graph->adjncy;
+  vwgt = graph->vwgt;
+  adjwgt = graph->adjwgt;
+
+  where = graph->where;
+  pwgts = graph->pwgts;
+
+  touched = idxset(nvtxs, 0, idxwspacemalloc(ctrl, nvtxs));
+  cptr = idxwspacemalloc(ctrl, nvtxs);
+  cind = idxwspacemalloc(ctrl, nvtxs);
+  perm = idxwspacemalloc(ctrl, nvtxs);
+  todo = idxwspacemalloc(ctrl, nvtxs);
+  maxpwgt = idxwspacemalloc(ctrl, nparts);
+  cpvec = idxwspacemalloc(ctrl, nparts);
+  npcmps = idxset(nparts, 0, idxwspacemalloc(ctrl, nparts));
+
+  for (i=0; i<nvtxs; i++) 
+    perm[i] = todo[i] = i;
+
+  /* Find the connected componends induced by the partition */
+  ncmps = -1;
+  first = last = 0;
+  nleft = nvtxs;
+  while (nleft > 0) {
+    if (first == last) { /* Find another starting vertex */
+      cptr[++ncmps] = first;
+      ASSERT(touched[todo[0]] == 0);
+      i = todo[0];
+      cind[last++] = i;
+      touched[i] = 1;
+      me = where[i];
+      npcmps[me]++;
+    }
+
+    i = cind[first++];
+    k = perm[i];
+    j = todo[k] = todo[--nleft];
+    perm[j] = k;
+
+    for (j=xadj[i]; j<xadj[i+1]; j++) {
+      k = adjncy[j];
+      if (where[k] == me && !touched[k]) {
+        cind[last++] = k;
+        touched[k] = 1;
+      }
+    }
+  }
+  cptr[++ncmps] = first;
+
+  /* printf("I found %d components, for this %d-way partition\n", ncmps, nparts); */
+
+  if (ncmps > nparts) { /* There are more components than processors */
+    /* First determine the max allowed load imbalance */
+    tvwgt = idxsum(nparts, pwgts);
+    for (i=0; i<nparts; i++)
+      maxpwgt[i] = ubfactor*tpwgts[i]*tvwgt;
+
+    deltawgt = 5;
+
+    for (i=0; i<ncmps; i++) {
+      me = where[cind[cptr[i]]];  /* Get the domain of this component */
+      if (npcmps[me] == 1)
+        continue;  /* Skip it because it is contigous */
+
+      /*printf("Trying to move %d from %d\n", i, me); */
+
+      /* Determine the weight of the block to be moved and abort if too high */
+      for (cwgt=0, j=cptr[i]; j<cptr[i+1]; j++) 
+        cwgt += vwgt[cind[j]];
+
+      if (cwgt > .30*pwgts[me])
+        continue;  /* Skip the component if it is over 30% of the weight */
+
+      /* Determine the connectivity */
+      idxset(nparts, 0, cpvec);
+      for (j=cptr[i]; j<cptr[i+1]; j++) {
+        ii = cind[j];
+        for (jj=xadj[ii]; jj<xadj[ii+1]; jj++) 
+          cpvec[where[adjncy[jj]]] += adjwgt[jj];
+      }
+      cpvec[me] = 0;
+
+      target = -1;
+      for (j=0; j<nparts; j++) {
+        if (cpvec[j] > 0 && (cwgt < deltawgt || pwgts[j] + cwgt < maxpwgt[j])) {
+          if (target == -1 || cpvec[target] < cpvec[j])
+            target = j;
+        }
+      }
+
+      /* printf("\tMoving it to %d [%d]\n", target, cpvec[target]);*/
+
+      if (target != -1) {
+        /* Assign all the vertices of 'me' to 'target' and update data structures */
+        INC_DEC(pwgts[target], pwgts[me], cwgt);
+        npcmps[me]--;
+
+        MoveGroup(ctrl, graph, nparts, target, i, cptr, cind);
+      }
+    }
+
+  }
+
+  idxwspacefree(ctrl, nparts);
+  idxwspacefree(ctrl, nparts);
+  idxwspacefree(ctrl, nparts);
+  idxwspacefree(ctrl, nvtxs);
+  idxwspacefree(ctrl, nvtxs);
+  idxwspacefree(ctrl, nvtxs);
+  idxwspacefree(ctrl, nvtxs);
+  idxwspacefree(ctrl, nvtxs);
+
+}
+
+
+/*************************************************************************
+* This function moves a collection of vertices and updates their rinfo
+**************************************************************************/
+void MoveGroup(CtrlType *ctrl, GraphType *graph, int nparts, int to, int gid, idxtype *ptr, idxtype *ind)
+{
+  int i, ii, iii, j, jj, k, l, nvtxs, nbnd, myndegrees; 
+  int from, me;
+  idxtype *xadj, *adjncy, *adjwgt;
+  idxtype *where, *bndptr, *bndind;
+  EDegreeType *myedegrees;
+  RInfoType *myrinfo;
+
+  nvtxs = graph->nvtxs;
+  xadj = graph->xadj;
+  adjncy = graph->adjncy;
+  adjwgt = graph->adjwgt;
+
+  where = graph->where;
+  bndptr = graph->bndptr;
+  bndind = graph->bndind;
+
+  nbnd = graph->nbnd;
+
+  for (iii=ptr[gid]; iii<ptr[gid+1]; iii++) {
+    i = ind[iii];
+    from = where[i];
+
+    myrinfo = graph->rinfo+i;
+    if (myrinfo->edegrees == NULL) {
+      myrinfo->edegrees = ctrl->wspace.edegrees+ctrl->wspace.cdegree;
+      ctrl->wspace.cdegree += xadj[i+1]-xadj[i];
+      myrinfo->ndegrees = 0;
+    }
+    myedegrees = myrinfo->edegrees;
+
+    /* find the location of 'to' in myrinfo or create it if it is not there */
+    for (k=0; k<myrinfo->ndegrees; k++) {
+      if (myedegrees[k].pid == to)
+        break;
+    }
+    if (k == myrinfo->ndegrees) {
+      myedegrees[k].pid = to;
+      myedegrees[k].ed = 0;
+      myrinfo->ndegrees++;
+    }
+
+    graph->mincut -= myedegrees[k].ed-myrinfo->id;
+
+
+    /* Update where, weight, and ID/ED information of the vertex you moved */
+    where[i] = to;
+    myrinfo->ed += myrinfo->id-myedegrees[k].ed;
+    SWAP(myrinfo->id, myedegrees[k].ed, j);
+    if (myedegrees[k].ed == 0) 
+      myedegrees[k] = myedegrees[--myrinfo->ndegrees];
+    else
+      myedegrees[k].pid = from;
+
+    if (myrinfo->ed-myrinfo->id < 0 && bndptr[i] != -1)
+      BNDDelete(nbnd, bndind, bndptr, i);
+
+    /* Update the degrees of adjacent vertices */
+    for (j=xadj[i]; j<xadj[i+1]; j++) {
+      ii = adjncy[j];
+      me = where[ii];
+
+      myrinfo = graph->rinfo+ii;
+      if (myrinfo->edegrees == NULL) {
+        myrinfo->edegrees = ctrl->wspace.edegrees+ctrl->wspace.cdegree;
+        ctrl->wspace.cdegree += xadj[ii+1]-xadj[ii];
+      }
+      myedegrees = myrinfo->edegrees;
+
+      ASSERT(CheckRInfo(myrinfo));
+
+      if (me == from) {
+        INC_DEC(myrinfo->ed, myrinfo->id, adjwgt[j]);
+
+        if (myrinfo->ed-myrinfo->id >= 0 && bndptr[ii] == -1)
+          BNDInsert(nbnd, bndind, bndptr, ii);
+      }
+      else if (me == to) {
+        INC_DEC(myrinfo->id, myrinfo->ed, adjwgt[j]);
+
+        if (myrinfo->ed-myrinfo->id < 0 && bndptr[ii] != -1)
+          BNDDelete(nbnd, bndind, bndptr, ii);
+      }
+
+      /* Remove contribution from the .ed of 'from' */
+      if (me != from) {
+        for (k=0; k<myrinfo->ndegrees; k++) {
+          if (myedegrees[k].pid == from) {
+            if (myedegrees[k].ed == adjwgt[j])
+              myedegrees[k] = myedegrees[--myrinfo->ndegrees];
+            else
+              myedegrees[k].ed -= adjwgt[j];
+            break;
+          }
+        }
+      }
+
+      /* Add contribution to the .ed of 'to' */
+      if (me != to) {
+        for (k=0; k<myrinfo->ndegrees; k++) {
+          if (myedegrees[k].pid == to) {
+            myedegrees[k].ed += adjwgt[j];
+            break;
+          }
+        }
+        if (k == myrinfo->ndegrees) {
+          myedegrees[myrinfo->ndegrees].pid = to;
+          myedegrees[myrinfo->ndegrees++].ed = adjwgt[j];
+        }
+      }
+
+      ASSERT(CheckRInfo(myrinfo));
+    }
+
+    ASSERT(CheckRInfo(graph->rinfo+i));
+  }
+
+  graph->nbnd = nbnd;
+
+}
+
Index: /inundation/pymetis/metis-4.0/Lib/timing.c
===================================================================
--- /inundation/pymetis/metis-4.0/Lib/timing.c	(revision 2051)
+++ /inundation/pymetis/metis-4.0/Lib/timing.c	(revision 2051)
@@ -0,0 +1,74 @@
+/*
+ * Copyright 1997, Regents of the University of Minnesota
+ *
+ * timing.c
+ *
+ * This file contains routines that deal with timing Metis
+ *
+ * Started 7/24/97
+ * George
+ *
+ * $Id: timing.c,v 1.1 1998/11/27 17:59:32 karypis Exp $
+ *
+ */
+
+#include <metis.h>
+
+
+/*************************************************************************
+* This function clears the timers
+**************************************************************************/
+void InitTimers(CtrlType *ctrl)
+{
+  cleartimer(ctrl->TotalTmr);
+  cleartimer(ctrl->InitPartTmr);
+  cleartimer(ctrl->MatchTmr);
+  cleartimer(ctrl->ContractTmr);
+  cleartimer(ctrl->CoarsenTmr);
+  cleartimer(ctrl->UncoarsenTmr);
+  cleartimer(ctrl->RefTmr);
+  cleartimer(ctrl->ProjectTmr);
+  cleartimer(ctrl->SplitTmr);
+  cleartimer(ctrl->SepTmr);
+  cleartimer(ctrl->AuxTmr1);
+  cleartimer(ctrl->AuxTmr2);
+  cleartimer(ctrl->AuxTmr3);
+  cleartimer(ctrl->AuxTmr4);
+  cleartimer(ctrl->AuxTmr5);
+  cleartimer(ctrl->AuxTmr6);
+}
+
+
+
+/*************************************************************************
+* This function prints the various timers
+**************************************************************************/
+void PrintTimers(CtrlType *ctrl)
+{
+  printf("\nTiming Information -------------------------------------------------");
+  printf("\n Multilevel: \t\t %7.3f", gettimer(ctrl->TotalTmr));
+  printf("\n     Coarsening: \t\t %7.3f", gettimer(ctrl->CoarsenTmr));
+  printf("\n            Matching: \t\t\t %7.3f", gettimer(ctrl->MatchTmr));
+  printf("\n            Contract: \t\t\t %7.3f", gettimer(ctrl->ContractTmr));
+  printf("\n     Initial Partition: \t %7.3f", gettimer(ctrl->InitPartTmr));
+  printf("\n   Construct Separator: \t %7.3f", gettimer(ctrl->SepTmr));
+  printf("\n     Uncoarsening: \t\t %7.3f", gettimer(ctrl->UncoarsenTmr));
+  printf("\n          Refinement: \t\t\t %7.3f", gettimer(ctrl->RefTmr));
+  printf("\n          Projection: \t\t\t %7.3f", gettimer(ctrl->ProjectTmr));
+  printf("\n     Splitting: \t\t %7.3f", gettimer(ctrl->SplitTmr));
+  printf("\n          AUX1: \t\t %7.3f", gettimer(ctrl->AuxTmr1));
+  printf("\n          AUX2: \t\t %7.3f", gettimer(ctrl->AuxTmr2));
+  printf("\n          AUX3: \t\t %7.3f", gettimer(ctrl->AuxTmr3));
+  printf("\n********************************************************************\n");
+}
+
+
+/*************************************************************************
+* This function returns the seconds
+**************************************************************************/
+double seconds(void)
+{
+  return((double) clock()/CLOCKS_PER_SEC);
+}
+
+
Index: /inundation/pymetis/metis-4.0/Lib/util.c
===================================================================
--- /inundation/pymetis/metis-4.0/Lib/util.c	(revision 2051)
+++ /inundation/pymetis/metis-4.0/Lib/util.c	(revision 2051)
@@ -0,0 +1,519 @@
+/*
+ * Copyright 1997, Regents of the University of Minnesota
+ *
+ * util.c
+ *
+ * This function contains various utility routines
+ *
+ * Started 9/28/95
+ * George
+ *
+ * $Id: util.c,v 1.1 1998/11/27 17:59:32 karypis Exp $
+ */
+
+#include <metis.h>
+
+
+/*************************************************************************
+* This function prints an error message and exits
+**************************************************************************/
+void errexit(char *f_str,...)
+{
+  va_list argp;
+  char out1[256], out2[256];
+
+  va_start(argp, f_str);
+  vsprintf(out1, f_str, argp);
+  va_end(argp);
+
+  sprintf(out2, "Error! %s", out1);
+
+  fprintf(stdout, out2);
+  fflush(stdout);
+
+  abort();
+}
+
+
+
+#ifndef DMALLOC
+/*************************************************************************
+* The following function allocates an array of integers
+**************************************************************************/
+int *imalloc(int n, char *msg)
+{
+  if (n == 0)
+    return NULL;
+
+  return (int *)GKmalloc(sizeof(int)*n, msg);
+}
+
+
+/*************************************************************************
+* The following function allocates an array of integers
+**************************************************************************/
+idxtype *idxmalloc(int n, char *msg)
+{
+  if (n == 0)
+    return NULL;
+
+  return (idxtype *)GKmalloc(sizeof(idxtype)*n, msg);
+}
+
+
+/*************************************************************************
+* The following function allocates an array of float 
+**************************************************************************/
+float *fmalloc(int n, char *msg)
+{
+  if (n == 0)
+    return NULL;
+
+  return (float *)GKmalloc(sizeof(float)*n, msg);
+}
+
+
+/*************************************************************************
+* The follwoing function allocates an array of integers
+**************************************************************************/
+int *ismalloc(int n, int ival, char *msg)
+{
+  if (n == 0)
+    return NULL;
+
+  return iset(n, ival, (int *)GKmalloc(sizeof(int)*n, msg));
+}
+
+
+
+/*************************************************************************
+* The follwoing function allocates an array of integers
+**************************************************************************/
+idxtype *idxsmalloc(int n, idxtype ival, char *msg)
+{
+  if (n == 0)
+    return NULL;
+
+  return idxset(n, ival, (idxtype *)GKmalloc(sizeof(idxtype)*n, msg));
+}
+
+
+/*************************************************************************
+* This function is my wrapper around malloc
+**************************************************************************/
+void *GKmalloc(int nbytes, char *msg)
+{
+  void *ptr;
+
+  if (nbytes == 0)
+    return NULL;
+
+  ptr = (void *)malloc(nbytes);
+  if (ptr == NULL) 
+    errexit("***Memory allocation failed for %s. Requested size: %d bytes", msg, nbytes);
+
+  return ptr;
+}
+#endif
+
+/*************************************************************************
+* This function is my wrapper around free, allows multiple pointers    
+**************************************************************************/
+void GKfree(void **ptr1,...)
+{
+  va_list plist;
+  void **ptr;
+
+  if (*ptr1 != NULL)
+    free(*ptr1);
+  *ptr1 = NULL;
+
+  va_start(plist, ptr1);
+
+  /* while ((int)(ptr = va_arg(plist, void **)) != -1) { */
+  while ((ptr = va_arg(plist, void **)) != LTERM) {
+    if (*ptr != NULL)
+      free(*ptr);
+    *ptr = NULL;
+  }
+
+  va_end(plist);
+}            
+
+
+/*************************************************************************
+* These functions set the values of a vector
+**************************************************************************/
+int *iset(int n, int val, int *x)
+{
+  int i;
+
+  for (i=0; i<n; i++)
+    x[i] = val;
+
+  return x;
+}
+
+
+/*************************************************************************
+* These functions set the values of a vector
+**************************************************************************/
+idxtype *idxset(int n, idxtype val, idxtype *x)
+{
+  int i;
+
+  for (i=0; i<n; i++)
+    x[i] = val;
+
+  return x;
+}
+
+
+/*************************************************************************
+* These functions set the values of a vector
+**************************************************************************/
+float *sset(int n, float val, float *x)
+{
+  int i;
+
+  for (i=0; i<n; i++)
+    x[i] = val;
+
+  return x;
+}
+
+
+
+/*************************************************************************
+* These functions return the index of the maximum element in a vector
+**************************************************************************/
+int iamax(int n, int *x)
+{
+  int i, max=0;
+
+  for (i=1; i<n; i++)
+    max = (x[i] > x[max] ? i : max);
+
+  return max;
+}
+
+
+/*************************************************************************
+* These functions return the index of the maximum element in a vector
+**************************************************************************/
+int idxamax(int n, idxtype *x)
+{
+  int i, max=0;
+
+  for (i=1; i<n; i++)
+    max = (x[i] > x[max] ? i : max);
+
+  return max;
+}
+
+/*************************************************************************
+* These functions return the index of the maximum element in a vector
+**************************************************************************/
+int idxamax_strd(int n, idxtype *x, int incx)
+{
+  int i, max=0;
+
+  n *= incx;
+  for (i=incx; i<n; i+=incx)
+    max = (x[i] > x[max] ? i : max);
+
+  return max/incx;
+}
+
+
+
+/*************************************************************************
+* These functions return the index of the maximum element in a vector
+**************************************************************************/
+int samax(int n, float *x)
+{
+  int i, max=0;
+
+  for (i=1; i<n; i++)
+    max = (x[i] > x[max] ? i : max);
+
+  return max;
+}
+
+/*************************************************************************
+* These functions return the index of the almost maximum element in a vector
+**************************************************************************/
+int samax2(int n, float *x)
+{
+  int i, max1, max2;
+
+  if (x[0] > x[1]) {
+    max1 = 0;
+    max2 = 1;
+  }
+  else {
+    max1 = 1;
+    max2 = 0;
+  }
+
+  for (i=2; i<n; i++) {
+    if (x[i] > x[max1]) {
+      max2 = max1;
+      max1 = i;
+    }
+    else if (x[i] > x[max2])
+      max2 = i;
+  }
+
+  return max2;
+}
+
+
+/*************************************************************************
+* These functions return the index of the minimum element in a vector
+**************************************************************************/
+int idxamin(int n, idxtype *x)
+{
+  int i, min=0;
+
+  for (i=1; i<n; i++)
+    min = (x[i] < x[min] ? i : min);
+
+  return min;
+}
+
+
+/*************************************************************************
+* These functions return the index of the minimum element in a vector
+**************************************************************************/
+int samin(int n, float *x)
+{
+  int i, min=0;
+
+  for (i=1; i<n; i++)
+    min = (x[i] < x[min] ? i : min);
+
+  return min;
+}
+
+
+/*************************************************************************
+* This function sums the entries in an array
+**************************************************************************/
+int idxsum(int n, idxtype *x)
+{
+  int i, sum = 0;
+
+  for (i=0; i<n; i++)
+    sum += x[i];
+
+  return sum;
+}
+
+
+/*************************************************************************
+* This function sums the entries in an array
+**************************************************************************/
+int idxsum_strd(int n, idxtype *x, int incx)
+{
+  int i, sum = 0;
+
+  for (i=0; i<n; i++, x+=incx) {
+    sum += *x;
+  }
+
+  return sum;
+}
+
+
+/*************************************************************************
+* This function sums the entries in an array
+**************************************************************************/
+void idxadd(int n, idxtype *x, idxtype *y)
+{
+  for (n--; n>=0; n--)
+    y[n] += x[n];
+}
+
+
+/*************************************************************************
+* This function sums the entries in an array
+**************************************************************************/
+int charsum(int n, char *x)
+{
+  int i, sum = 0;
+
+  for (i=0; i<n; i++)
+    sum += x[i];
+
+  return sum;
+}
+
+/*************************************************************************
+* This function sums the entries in an array
+**************************************************************************/
+int isum(int n, int *x)
+{
+  int i, sum = 0;
+
+  for (i=0; i<n; i++)
+    sum += x[i];
+
+  return sum;
+}
+
+/*************************************************************************
+* This function sums the entries in an array
+**************************************************************************/
+float ssum(int n, float *x)
+{
+  int i;
+  float sum = 0.0;
+
+  for (i=0; i<n; i++)
+    sum += x[i];
+
+  return sum;
+}
+
+/*************************************************************************
+* This function sums the entries in an array
+**************************************************************************/
+float ssum_strd(int n, float *x, int incx)
+{
+  int i;
+  float sum = 0.0;
+
+  for (i=0; i<n; i++, x+=incx)
+    sum += *x;
+
+  return sum;
+}
+
+/*************************************************************************
+* This function sums the entries in an array
+**************************************************************************/
+void sscale(int n, float alpha, float *x)
+{
+  int i;
+
+  for (i=0; i<n; i++)
+    x[i] *= alpha;
+}
+
+
+/*************************************************************************
+* This function computes a 2-norm
+**************************************************************************/
+float snorm2(int n, float *v)
+{
+  int i;
+  float partial = 0;
+ 
+  for (i = 0; i<n; i++)
+    partial += v[i] * v[i];
+
+  return sqrt(partial);
+}
+
+
+
+/*************************************************************************
+* This function computes a 2-norm
+**************************************************************************/
+float sdot(int n, float *x, float *y)
+{
+  int i;
+  float partial = 0;
+ 
+  for (i = 0; i<n; i++)
+    partial += x[i] * y[i];
+
+  return partial;
+}
+
+
+/*************************************************************************
+* This function computes a 2-norm
+**************************************************************************/
+void saxpy(int n, float alpha, float *x, int incx, float *y, int incy)
+{
+  int i;
+ 
+  for (i=0; i<n; i++, x+=incx, y+=incy) 
+    *y += alpha*(*x);
+}
+
+
+
+
+/*************************************************************************
+* This file randomly permutes the contents of an array.
+* flag == 0, don't initialize perm
+* flag == 1, set p[i] = i 
+**************************************************************************/
+void RandomPermute(int n, idxtype *p, int flag)
+{
+  int i, u, v;
+  idxtype tmp;
+
+  if (flag == 1) {
+    for (i=0; i<n; i++)
+      p[i] = i;
+  }
+
+  if (n <= 4)
+    return;
+
+  for (i=0; i<n; i+=16) {
+    u = RandomInRangeFast(n-4);
+    v = RandomInRangeFast(n-4);
+    SWAP(p[v], p[u], tmp);
+    SWAP(p[v+1], p[u+1], tmp);
+    SWAP(p[v+2], p[u+2], tmp);
+    SWAP(p[v+3], p[u+3], tmp);
+  }
+}
+
+
+
+/*************************************************************************
+* This function returns true if the a is a power of 2
+**************************************************************************/
+int ispow2(int a)
+{
+  for (; a%2 != 1; a = a>>1);
+  return (a > 1 ? 0 : 1);
+}
+
+
+/*************************************************************************
+* This function initializes the random number generator
+**************************************************************************/
+void InitRandom(int seed)
+{
+  if (seed == -1) {
+#ifndef __VC__
+    srand48(7654321L);  
+#endif
+    srand(4321);  
+  }
+  else {
+#ifndef __VC__
+    srand48(seed);  
+#endif
+    srand(seed);  
+  }
+}
+
+/*************************************************************************
+* This function returns the log2(x)
+**************************************************************************/
+int log2(int a)
+{
+  int i;
+
+  for (i=1; a > 1; i++, a = a>>1);
+  return i-1;
+}
+
Index: /inundation/pymetis/metis-4.0/Makefile
===================================================================
--- /inundation/pymetis/metis-4.0/Makefile	(revision 2051)
+++ /inundation/pymetis/metis-4.0/Makefile	(revision 2051)
@@ -0,0 +1,16 @@
+
+
+default:
+	(cd Lib ; make ) 
+	(cd Programs ; make ) 
+	(cd Test ; make ) 
+
+clean:
+	(cd Lib ; make clean )
+	(cd Programs ; make clean )
+	(cd Test ; make clean )
+
+realclean:
+	(cd Lib ; make realclean )
+	(cd Programs ; make realclean )
+	(cd Test ; make realclean )
Index: /inundation/pymetis/metis-4.0/Makefile.in
===================================================================
--- /inundation/pymetis/metis-4.0/Makefile.in	(revision 2051)
+++ /inundation/pymetis/metis-4.0/Makefile.in	(revision 2051)
@@ -0,0 +1,22 @@
+
+# Which compiler to use
+CC = cc
+
+# What optimization level to use
+OPTFLAGS = -O2 
+
+# What options to be used by the compiler
+COPTIONS = 
+
+# What options to be used by the loader
+LDOPTIONS = 
+
+# What archiving to use
+AR = ar rv
+
+# What to use for indexing the archive
+RANLIB = ranlib
+#RANLIB = ar -ts
+#RANLIB = 
+
+
Index: /inundation/pymetis/metis-4.0/Programs/Makefile
===================================================================
--- /inundation/pymetis/metis-4.0/Programs/Makefile	(revision 2051)
+++ /inundation/pymetis/metis-4.0/Programs/Makefile	(revision 2051)
@@ -0,0 +1,83 @@
+include ../Makefile.in
+
+BINDIR = ..
+
+INCLUDES = -I../Lib 
+CFLAGS = $(COPTIONS) $(OPTFLAGS) $(INCLUDES)
+
+LIBS = -lmetis -lm
+LD = $(CC) $(LDOPTIONS) -L. -L..
+METISLIB = ../libmetis.a
+
+
+
+PMETISOBJS = pmetis.o io.o 
+KMETISOBJS = kmetis.o io.o 
+OEMETISOBJS = oemetis.o io.o smbfactor.o
+ONMETISOBJS = onmetis.o io.o smbfactor.o
+MESH2DUALOBJ = mesh2dual.o io.o 
+MESH2NODALOBJ = mesh2nodal.o io.o 
+PARTDMESHOBJ = partdmesh.o io.o 
+PARTNMESHOBJ = partnmesh.o io.o 
+GRAPHCHKOBJ = graphchk.o io.o 
+
+
+.c.o:
+	$(CC) $(CFLAGS) -c $*.c
+
+default: $(BINDIR)/pmetis$(VERNUM) $(BINDIR)/kmetis$(VERNUM) \
+         $(BINDIR)/oemetis$(VERNUM) $(BINDIR)/onmetis$(VERNUM) $(BINDIR)/mesh2dual$(VERNUM) \
+         $(BINDIR)/mesh2nodal$(VERNUM) $(BINDIR)/partdmesh$(VERNUM) $(BINDIR)/partnmesh$(VERNUM) \
+         $(BINDIR)/graphchk$(VERNUM)
+
+$(BINDIR)/pmetis$(VERNUM): $(PMETISOBJS) $(METISLIB)
+	$(LD)  -o $@ $(PMETISOBJS) $(LIBS)
+	chmod 755 $@
+
+$(BINDIR)/kmetis$(VERNUM): $(KMETISOBJS) $(METISLIB)
+	$(LD)  -o $@ $(KMETISOBJS) $(LIBS)
+	chmod 755 $@
+
+$(BINDIR)/oemetis$(VERNUM): $(OEMETISOBJS) $(METISLIB)
+	$(LD)  -o $@ $(OEMETISOBJS) $(LIBS)
+	chmod 755 $@
+
+$(BINDIR)/onmetis$(VERNUM): $(ONMETISOBJS) $(METISLIB)
+	$(LD)  -o $@ $(ONMETISOBJS) $(LIBS)
+	chmod 755 $@
+
+$(BINDIR)/mesh2dual$(VERNUM): $(MESH2DUALOBJ) $(METISLIB)
+	$(LD)  -o $@ $(MESH2DUALOBJ) $(LIBS)
+	chmod 755 $@
+
+$(BINDIR)/mesh2nodal$(VERNUM): $(MESH2NODALOBJ) $(METISLIB)
+	$(LD)  -o $@ $(MESH2NODALOBJ) $(LIBS)
+	chmod 755 $@
+
+$(BINDIR)/partdmesh$(VERNUM): $(PARTDMESHOBJ) $(METISLIB)
+	$(LD)  -o $@ $(PARTDMESHOBJ) $(LIBS)
+	chmod 755 $@
+
+$(BINDIR)/partnmesh$(VERNUM): $(PARTNMESHOBJ) $(METISLIB)
+	$(LD)  -o $@ $(PARTNMESHOBJ) $(LIBS)
+	chmod 755 $@
+
+$(BINDIR)/graphchk$(VERNUM): $(GRAPHCHKOBJ) $(METISLIB)
+	$(LD)  -o $@ $(GRAPHCHKOBJ) $(LIBS)
+	chmod 755 $@
+
+
+clean:
+	rm -f *.o
+
+realclean:
+	rm -f *.o ;\
+        rm -f $(BINDIR)/pmetis$(VERNUM) ;\
+        rm -f $(BINDIR)/kmetis$(VERNUM) ;\
+        rm -f $(BINDIR)/oemetis$(VERNUM) ;\
+        rm -f $(BINDIR)/onmetis$(VERNUM) ;\
+        rm -f $(BINDIR)/mesh2dual$(VERNUM) ;\
+        rm -f $(BINDIR)/mesh2nodal$(VERNUM) ;\
+        rm -f $(BINDIR)/partdmesh$(VERNUM) ;\
+        rm -f $(BINDIR)/partnmesh$(VERNUM) ;\
+        rm -f $(BINDIR)/graphchk$(VERNUM)
Index: /inundation/pymetis/metis-4.0/Programs/graphchk.c
===================================================================
--- /inundation/pymetis/metis-4.0/Programs/graphchk.c	(revision 2051)
+++ /inundation/pymetis/metis-4.0/Programs/graphchk.c	(revision 2051)
@@ -0,0 +1,58 @@
+/*
+ * Copyright 1997, Regents of the University of Minnesota
+ *
+ * graphchk.c
+ *
+ * This file checks the validity of a graph
+ *
+ * Started 8/28/94
+ * George
+ *
+ * $Id: graphchk.c,v 1.1 1998/11/27 17:59:33 karypis Exp $
+ *
+ */
+
+#include <metis.h>
+
+
+
+/*************************************************************************
+* Let the game begin
+**************************************************************************/
+main(int argc, char *argv[])
+{
+  GraphType graph;
+  char filename[256];
+  int wgtflag;
+
+  if (argc != 2) {
+    printf("Usage: %s <GraphFile>\n", argv[0]);
+    exit(0);
+  }
+    
+  strcpy(filename, argv[1]);
+
+  ReadGraph(&graph, filename, &wgtflag);
+  if (graph.nvtxs == 0) {
+    printf("Empty graph!\n");
+    exit(0);
+  }
+
+  printf("**********************************************************************\n");
+  printf("%s", METISTITLE);
+  printf("Graph Information ---------------------------------------------------\n");
+  printf("  Name: %s, #Vertices: %d, #Edges: %d\n\n", filename, graph.nvtxs, graph.nedges/2);
+  printf("Checking Graph... ---------------------------------------------------\n");
+
+  if (CheckGraph(&graph))
+    printf("   The format of the graph is correct!\n");
+  else
+    printf("   The format of the graph is incorrect!\n");
+
+  printf("\n**********************************************************************\n");
+
+
+  GKfree(&graph.xadj, &graph.adjncy, &graph.vwgt, &graph.adjwgt, LTERM);
+}  
+
+
Index: /inundation/pymetis/metis-4.0/Programs/io.c
===================================================================
--- /inundation/pymetis/metis-4.0/Programs/io.c	(revision 2051)
+++ /inundation/pymetis/metis-4.0/Programs/io.c	(revision 2051)
@@ -0,0 +1,382 @@
+/*
+ * Copyright 1997, Regents of the University of Minnesota
+ *
+ * io.c
+ *
+ * This file contains routines related to I/O
+ *
+ * Started 8/28/94
+ * George
+ *
+ * $Id: io.c,v 1.1 1998/11/27 17:59:34 karypis Exp $
+ *
+ */
+
+#include <metis.h>
+
+
+
+/*************************************************************************
+* This function reads the spd matrix
+**************************************************************************/
+void ReadGraph(GraphType *graph, char *filename, int *wgtflag)
+{
+  int i, j, k, l, fmt, readew, readvw, ncon, edge, ewgt;
+  idxtype *xadj, *adjncy, *vwgt, *adjwgt;
+  char *line, *oldstr, *newstr;
+  FILE *fpin;
+
+  InitGraph(graph);
+
+  line = (char *)malloc(sizeof(char)*(MAXLINE+1));
+
+  if ((fpin = fopen(filename, "r")) == NULL) {
+    printf("Failed to open file %s\n", filename);
+    exit(0);
+  }
+
+  do {
+    fgets(line, MAXLINE, fpin);
+  } while (line[0] == '%' && !feof(fpin));
+
+  if (feof(fpin)) {
+    graph->nvtxs = 0;
+    free(line);
+    return;
+  }
+
+  fmt = ncon = 0;
+  sscanf(line, "%d %d %d %d", &(graph->nvtxs), &(graph->nedges), &fmt, &ncon);
+
+  readew = (fmt%10 > 0);
+  readvw = ((fmt/10)%10 > 0);
+  if (fmt >= 100) {
+    printf("Cannot read this type of file format!");
+    exit(0);
+  }
+
+
+  *wgtflag = 0;
+  if (readew)
+    *wgtflag += 1;
+  if (readvw)
+    *wgtflag += 2;
+
+  if (ncon > 0 && !readvw) {
+    printf("------------------------------------------------------------------------------\n");
+    printf("***  I detected an error in your input file  ***\n\n");
+    printf("You specified ncon=%d, but the fmt parameter does not specify vertex weights\n", ncon);
+    printf("Make sure that the fmt parameter is set to either 10 or 11.\n");
+    printf("------------------------------------------------------------------------------\n");
+    exit(0);
+  }
+
+  graph->nedges *=2;
+  ncon = graph->ncon = (ncon == 0 ? 1 : ncon);
+
+  /*printf("%d %d %d %d %d [%d %d]\n", fmt, fmt%10, (fmt/10)%10, ncon, graph->ncon, readew, readvw);*/
+
+  if (graph->nvtxs > MAXIDX) 
+    errexit("\nThe matrix is too big: %d [%d %d]\n", graph->nvtxs, MAXIDX, sizeof(idxtype));
+
+  xadj = graph->xadj = idxsmalloc(graph->nvtxs+1, 0, "ReadGraph: xadj");
+  adjncy = graph->adjncy = idxmalloc(graph->nedges, "ReadGraph: adjncy");
+
+  vwgt = graph->vwgt = (readvw ? idxmalloc(ncon*graph->nvtxs, "ReadGraph: vwgt") : NULL);
+  adjwgt = graph->adjwgt = (readew ? idxmalloc(graph->nedges, "ReadGraph: adjwgt") : NULL);
+
+  /* Start reading the graph file */
+  for (xadj[0]=0, k=0, i=0; i<graph->nvtxs; i++) {
+    do {
+      fgets(line, MAXLINE, fpin);
+    } while (line[0] == '%' && !feof(fpin));
+    oldstr = line;
+    newstr = NULL;
+
+    if (strlen(line) == MAXLINE) 
+      errexit("\nBuffer for fgets not big enough!\n");
+
+    if (readvw) {
+      for (l=0; l<ncon; l++) {
+        vwgt[i*ncon+l] = (int)strtol(oldstr, &newstr, 10);
+        oldstr = newstr;
+      }
+    }
+
+    for (;;) {
+      edge = (int)strtol(oldstr, &newstr, 10) -1;
+      oldstr = newstr;
+
+      if (readew) {
+        ewgt = (int)strtol(oldstr, &newstr, 10);
+        oldstr = newstr;
+      }
+
+      if (edge < 0)
+        break;
+
+      adjncy[k] = edge;
+      if (readew) 
+        adjwgt[k] = ewgt;
+      k++;
+    } 
+    xadj[i+1] = k;
+  }
+
+  fclose(fpin);
+
+  if (k != graph->nedges) {
+    printf("------------------------------------------------------------------------------\n");
+    printf("***  I detected an error in your input file  ***\n\n");
+    printf("In the first line of the file, you specified that the graph contained\n%d edges. However, I only found %d edges in the file.\n", graph->nedges/2, k/2);
+    if (2*k == graph->nedges) {
+      printf("\n *> I detected that you specified twice the number of edges that you have in\n");
+      printf("    the file. Remember that the number of edges specified in the first line\n");
+      printf("    counts each edge between vertices v and u only once.\n\n");
+    }
+    printf("Please specify the correct number of edges in the first line of the file.\n");
+    printf("------------------------------------------------------------------------------\n");
+    exit(0);
+  }
+
+  free(line);
+}
+
+
+
+/*************************************************************************
+* This function writes out the partition vector
+**************************************************************************/
+void WritePartition(char *fname, idxtype *part, int n, int nparts)
+{
+  FILE *fpout;
+  int i;
+  char filename[256];
+
+  sprintf(filename,"%s.part.%d",fname, nparts);
+
+  if ((fpout = fopen(filename, "w")) == NULL) 
+    errexit("Problems in opening the partition file: %s", filename);
+
+  for (i=0; i<n; i++)
+    fprintf(fpout,"%d\n",part[i]);
+
+  fclose(fpout);
+
+}
+
+
+/*************************************************************************
+* This function writes out the partition vectors for a mesh
+**************************************************************************/
+void WriteMeshPartition(char *fname, int nparts, int ne, idxtype *epart, int nn, idxtype *npart)
+{
+  FILE *fpout;
+  int i;
+  char filename[256];
+
+  sprintf(filename,"%s.epart.%d",fname, nparts);
+
+  if ((fpout = fopen(filename, "w")) == NULL) 
+    errexit("Problems in opening the partition file: %s", filename);
+
+  for (i=0; i<ne; i++)
+    fprintf(fpout,"%d\n", epart[i]);
+
+  fclose(fpout);
+
+  sprintf(filename,"%s.npart.%d",fname, nparts);
+
+  if ((fpout = fopen(filename, "w")) == NULL) 
+    errexit("Problems in opening the partition file: %s", filename);
+
+  for (i=0; i<nn; i++)
+    fprintf(fpout,"%d\n", npart[i]);
+
+  fclose(fpout);
+
+
+}
+
+
+
+/*************************************************************************
+* This function writes out the partition vector
+**************************************************************************/
+void WritePermutation(char *fname, idxtype *iperm, int n)
+{
+  FILE *fpout;
+  int i;
+  char filename[256];
+
+  sprintf(filename,"%s.iperm",fname);
+
+  if ((fpout = fopen(filename, "w")) == NULL) 
+    errexit("Problems in opening the permutation file: %s", filename);
+
+  for (i=0; i<n; i++)
+    fprintf(fpout,"%d\n", iperm[i]);
+
+  fclose(fpout);
+
+}
+
+
+
+/*************************************************************************
+* This function checks if a graph is valid
+**************************************************************************/
+int CheckGraph(GraphType *graph)
+{
+  int i, j, k, l, nvtxs, err=0;
+  idxtype *xadj, *adjncy, *adjwgt;
+
+  nvtxs = graph->nvtxs;
+  xadj = graph->xadj;
+  adjncy = graph->adjncy;
+  adjwgt = graph->adjwgt;
+
+
+  for (i=0; i<nvtxs; i++) {
+    for (j=xadj[i]; j<xadj[i+1]; j++) {
+      k = adjncy[j];
+
+      if (i == k) {
+        printf("Vertex %d contains a self-loop (i.e., diagonal entry in the matrix)!\n", i);
+        err++;
+      }
+      else {
+        for (l=xadj[k]; l<xadj[k+1]; l++) {
+          if (adjncy[l] == i) {
+            if (adjwgt != NULL && adjwgt[l] != adjwgt[j]) {
+              printf("Edges (%d %d) and (%d %d) do not have the same weight! %d %d\n", i,k,k,i, adjwgt[l], adjwgt[adjncy[j]]);
+              err++;
+            }
+            break;
+          }
+        }
+        if (l == xadj[k+1]) {
+          printf("Missing edge: (%d %d)!\n", k, i);
+          err++;
+        }
+      }
+    }
+  }
+
+  if (err > 0) 
+    printf("A total of %d errors exist in the input file. Correct them, and run again!\n", err);
+
+  return (err == 0 ? 1 : 0);
+}
+
+
+/*************************************************************************
+* This function reads the element node array of a mesh
+**************************************************************************/
+idxtype *ReadMesh(char *filename, int *ne, int *nn, int *etype)
+{
+  int i, j, k, esize;
+  idxtype *elmnts;
+  FILE *fpin;
+
+  if ((fpin = fopen(filename, "r")) == NULL) {
+    printf("Failed to open file %s\n", filename);
+    exit(0);
+  }
+
+  fscanf(fpin, "%d %d", ne, etype);
+
+  switch (*etype) {
+    case 1:
+      esize = 3;
+      break;
+    case 2:
+      esize = 4;
+      break;
+    case 3:
+      esize = 8;
+      break;
+    case 4:
+      esize = 4;
+      break;
+    default:
+      errexit("Unknown mesh-element type: %d\n", *etype);
+  }
+
+  elmnts = idxmalloc(esize*(*ne), "ReadMesh: elmnts");
+
+  for (j=esize*(*ne), i=0; i<j; i++) {
+    fscanf(fpin, "%d", elmnts+i);
+    elmnts[i]--;
+  }
+
+  fclose(fpin);
+
+  *nn = elmnts[idxamax(j, elmnts)]+1;
+
+  return elmnts;
+}
+
+
+/*************************************************************************
+* This function writes a graphs into a file 
+**************************************************************************/
+void WriteGraph(char *filename, int nvtxs, idxtype *xadj, idxtype *adjncy)
+{
+  int i, j;
+  FILE *fpout;
+
+  if ((fpout = fopen(filename, "w")) == NULL) {
+    printf("Failed to open file %s\n", filename);
+    exit(0);
+  }
+
+  fprintf(fpout, "%d %d", nvtxs, xadj[nvtxs]/2);
+
+  for (i=0; i<nvtxs; i++) {
+    fprintf(fpout, "\n");
+    for (j=xadj[i]; j<xadj[i+1]; j++)
+      fprintf(fpout, " %d", adjncy[j]+1);
+  }
+
+  fclose(fpout);
+}
+
+
+/*************************************************************************
+* This function writes a graphs into a file 
+**************************************************************************/
+void WriteMocGraph(GraphType *graph)
+{
+  int i, j, nvtxs, ncon;
+  idxtype *xadj, *adjncy;
+  float *nvwgt;
+  char filename[256];
+  FILE *fpout;
+
+  nvtxs = graph->nvtxs;
+  ncon = graph->ncon;
+  xadj = graph->xadj;
+  adjncy = graph->adjncy;
+  nvwgt = graph->nvwgt;
+
+  sprintf(filename, "moc.graph.%d.%d", nvtxs, ncon);
+
+  if ((fpout = fopen(filename, "w")) == NULL) {
+    printf("Failed to open file %s\n", filename);
+    exit(0);
+  }
+
+  fprintf(fpout, "%d %d 10 1 %d", nvtxs, xadj[nvtxs]/2, ncon);
+
+  for (i=0; i<nvtxs; i++) {
+    fprintf(fpout, "\n");
+    for (j=0; j<ncon; j++)
+      fprintf(fpout, "%d ", (int)((float)10e6*nvwgt[i*ncon+j]));
+
+    for (j=xadj[i]; j<xadj[i+1]; j++)
+      fprintf(fpout, " %d", adjncy[j]+1);
+  }
+
+  fclose(fpout);
+}
Index: /inundation/pymetis/metis-4.0/Programs/kmetis.c
===================================================================
--- /inundation/pymetis/metis-4.0/Programs/kmetis.c	(revision 2051)
+++ /inundation/pymetis/metis-4.0/Programs/kmetis.c	(revision 2051)
@@ -0,0 +1,105 @@
+/*
+ * Copyright 1997, Regents of the University of Minnesota
+ *
+ * kmetis.c
+ *
+ * This file contains the driving routine for kmetis
+ *
+ * Started 8/28/94
+ * George
+ *
+ * $Id: kmetis.c,v 1.1 1998/11/27 17:59:35 karypis Exp $
+ *
+ */
+
+#include <metis.h>
+
+
+
+/*************************************************************************
+* Let the game begin
+**************************************************************************/
+main(int argc, char *argv[])
+{
+  int i, nparts, options[10];
+  idxtype *part;
+  float rubvec[MAXNCON], lbvec[MAXNCON];
+  GraphType graph;
+  char filename[256];
+  int numflag = 0, wgtflag = 0, edgecut;
+  timer TOTALTmr, METISTmr, IOTmr;
+
+  if (argc != 3) {
+    printf("Usage: %s <GraphFile> <Nparts>\n",argv[0]);
+    exit(0);
+  }
+    
+  strcpy(filename, argv[1]);
+  nparts = atoi(argv[2]);
+
+  if (nparts < 2) {
+    printf("The number of partitions should be greater than 1!\n");
+    exit(0);
+  }
+
+  cleartimer(TOTALTmr);
+  cleartimer(METISTmr);
+  cleartimer(IOTmr);
+
+  starttimer(TOTALTmr);
+  starttimer(IOTmr);
+  ReadGraph(&graph, filename, &wgtflag);
+  if (graph.nvtxs <= 0) {
+    printf("Empty graph. Nothing to do.\n");
+    exit(0);
+  }
+  stoptimer(IOTmr);
+
+  printf("**********************************************************************\n");
+  printf("%s", METISTITLE);
+  printf("Graph Information ---------------------------------------------------\n");
+  printf("  Name: %s, #Vertices: %d, #Edges: %d, #Parts: %d\n", filename, graph.nvtxs, graph.nedges/2, nparts);
+  if (graph.ncon > 1)
+    printf("  Balancing Constraints: %d\n", graph.ncon);
+  printf("\nK-way Partitioning... -----------------------------------------------\n");
+
+  part = idxmalloc(graph.nvtxs, "main: part");
+  options[0] = 0;
+
+  starttimer(METISTmr);
+  if (graph.ncon == 1) {
+    METIS_PartGraphKway(&graph.nvtxs, graph.xadj, graph.adjncy, graph.vwgt, graph.adjwgt, 
+          &wgtflag, &numflag, &nparts, options, &edgecut, part);
+  }
+  else {
+    for (i=0; i<graph.ncon; i++)
+      rubvec[i] = HORIZONTAL_IMBALANCE;
+
+    METIS_mCPartGraphKway(&graph.nvtxs, &graph.ncon, graph.xadj, graph.adjncy, graph.vwgt, 
+          graph.adjwgt, &wgtflag, &numflag, &nparts, rubvec, options, &edgecut, part);
+  }
+  stoptimer(METISTmr);
+
+  ComputePartitionBalance(&graph, nparts, part, lbvec);
+
+  printf("  %d-way Edge-Cut: %7d, Balance: ", nparts, edgecut);
+  for (i=0; i<graph.ncon; i++)
+    printf("%5.2f ", lbvec[i]);
+  printf("\n");
+
+  starttimer(IOTmr);
+  WritePartition(filename, part, graph.nvtxs, nparts); 
+  stoptimer(IOTmr);
+  stoptimer(TOTALTmr);
+
+  printf("\nTiming Information --------------------------------------------------\n");
+  printf("  I/O:          \t\t %7.3f\n", gettimer(IOTmr));
+  printf("  Partitioning: \t\t %7.3f   (KMETIS time)\n", gettimer(METISTmr));
+  printf("  Total:        \t\t %7.3f\n", gettimer(TOTALTmr));
+  printf("**********************************************************************\n");
+
+
+  GKfree(&graph.xadj, &graph.adjncy, &graph.vwgt, &graph.adjwgt, &part, LTERM);
+}  
+
+
Index: /inundation/pymetis/metis-4.0/Programs/mesh2dual.c
===================================================================
--- /inundation/pymetis/metis-4.0/Programs/mesh2dual.c	(revision 2051)
+++ /inundation/pymetis/metis-4.0/Programs/mesh2dual.c	(revision 2051)
@@ -0,0 +1,72 @@
+/*
+ * Copyright 1997, Regents of the University of Minnesota
+ *
+ * mesh2dual.c
+ *
+ * This file reads in the element node connectivity array of a mesh and writes
+ * out its dual in the format suitable for Metis.
+ *
+ * Started 9/29/97
+ * George
+ *
+ * $Id: mesh2dual.c,v 1.1 1998/11/27 17:59:35 karypis Exp $
+ *
+ */
+
+#include <metis.h>
+
+
+
+/*************************************************************************
+* Let the game begin
+**************************************************************************/
+main(int argc, char *argv[])
+{
+  int i, j, ne, nn, etype, numflag=0;
+  idxtype *elmnts, *xadj, *adjncy;
+  timer IOTmr, DUALTmr;
+  char fileout[256], etypestr[4][5] = {"TRI", "TET", "HEX", "QUAD"};
+
+  if (argc != 2) {
+    printf("Usage: %s <meshfile>\n",argv[0]);
+    exit(0);
+  }
+
+  cleartimer(IOTmr);
+  cleartimer(DUALTmr);
+
+  starttimer(IOTmr);
+  elmnts = ReadMesh(argv[1], &ne, &nn, &etype);
+  stoptimer(IOTmr);
+
+  printf("**********************************************************************\n");
+  printf("%s", METISTITLE);
+  printf("Mesh Information ----------------------------------------------------\n");
+  printf("  Name: %s, #Elements: %d, #Nodes: %d, Etype: %s\n\n", argv[1], ne, nn, etypestr[etype-1]);
+  printf("Forming Dual Graph... -----------------------------------------------\n");
+
+  xadj = idxmalloc(ne+1, "main: xadj");
+  adjncy = idxmalloc(10*ne, "main: adjncy");
+
+  starttimer(DUALTmr);
+  METIS_MeshToDual(&ne, &nn, elmnts, &etype, &numflag, xadj, adjncy);
+  stoptimer(DUALTmr);
+
+  printf("  Dual Information: #Vertices: %d, #Edges: %d\n", ne, xadj[ne]/2);
+
+  sprintf(fileout, "%s.dgraph", argv[1]);
+  starttimer(IOTmr);
+  WriteGraph(fileout, ne, xadj, adjncy);
+  stoptimer(IOTmr);
+
+
+  printf("\nTiming Information --------------------------------------------------\n");
+  printf("  I/O:          \t\t %7.3f\n", gettimer(IOTmr));
+  printf("  Dual Creation:\t\t %7.3f\n", gettimer(DUALTmr));
+  printf("**********************************************************************\n");
+
+  GKfree(&elmnts, &xadj, &adjncy, LTERM);
+
+}
+
+
Index: /inundation/pymetis/metis-4.0/Programs/mesh2nodal.c
===================================================================
--- /inundation/pymetis/metis-4.0/Programs/mesh2nodal.c	(revision 2051)
+++ /inundation/pymetis/metis-4.0/Programs/mesh2nodal.c	(revision 2051)
@@ -0,0 +1,72 @@
+/*
+ * Copyright 1997, Regents of the University of Minnesota
+ *
+ * mesh2nodal.c
+ *
+ * This file reads in the element node connectivity array of a mesh and writes
+ * out its dual in the format suitable for Metis.
+ *
+ * Started 9/29/97
+ * George
+ *
+ * $Id: mesh2nodal.c,v 1.1 1998/11/27 17:59:35 karypis Exp $
+ *
+ */
+
+#include <metis.h>
+
+
+
+/*************************************************************************
+* Let the game begin
+**************************************************************************/
+main(int argc, char *argv[])
+{
+  int i, j, ne, nn, etype, numflag=0;
+  idxtype *elmnts, *xadj, *adjncy;
+  timer IOTmr, DUALTmr;
+  char fileout[256], etypestr[4][5] = {"TRI", "TET", "HEX", "QUAD"};
+
+  if (argc != 2) {
+    printf("Usage: %s <meshfile>\n",argv[0]);
+    exit(0);
+  }
+
+  cleartimer(IOTmr);
+  cleartimer(DUALTmr);
+
+  starttimer(IOTmr);
+  elmnts = ReadMesh(argv[1], &ne, &nn, &etype);
+  stoptimer(IOTmr);
+
+  printf("**********************************************************************\n");
+  printf("%s", METISTITLE);
+  printf("Mesh Information ----------------------------------------------------\n");
+  printf("  Name: %s, #Elements: %d, #Nodes: %d, Etype: %s\n\n", argv[1], ne, nn, etypestr[etype-1]);
+  printf("Forming Nodal Graph... ----------------------------------------------\n");
+
+  xadj = idxmalloc(nn+1, "main: xadj");
+  adjncy = idxmalloc(20*nn, "main: adjncy");
+
+  starttimer(DUALTmr);
+  METIS_MeshToNodal(&ne, &nn, elmnts, &etype, &numflag, xadj, adjncy);
+  stoptimer(DUALTmr);
+
+  printf("  Nodal Information: #Vertices: %d, #Edges: %d\n", nn, xadj[nn]/2);
+
+  sprintf(fileout, "%s.ngraph", argv[1]);
+  starttimer(IOTmr);
+  WriteGraph(fileout, nn, xadj, adjncy);
+  stoptimer(IOTmr);
+
+
+  printf("\nTiming Information --------------------------------------------------\n");
+  printf("  I/O:          \t\t %7.3f\n", gettimer(IOTmr));
+  printf("  Nodal Creation:\t\t %7.3f\n", gettimer(DUALTmr));
+  printf("**********************************************************************\n");
+
+  GKfree(&elmnts, &xadj, &adjncy, LTERM);
+
+}
+
+
Index: /inundation/pymetis/metis-4.0/Programs/oemetis.c
===================================================================
--- /inundation/pymetis/metis-4.0/Programs/oemetis.c	(revision 2051)
+++ /inundation/pymetis/metis-4.0/Programs/oemetis.c	(revision 2051)
@@ -0,0 +1,95 @@
+/*
+ * Copyright 1997, Regents of the University of Minnesota
+ *
+ * oemetis.c
+ *
+ * This file contains the driving routine for multilevel method
+ *
+ * Started 8/28/94
+ * George
+ *
+ * $Id: oemetis.c,v 1.1 1998/11/27 17:59:37 karypis Exp $
+ *
+ */
+
+#include <metis.h>
+
+
+
+/*************************************************************************
+* Let the game begin
+**************************************************************************/
+main(int argc, char *argv[])
+{
+  int i, options[10];
+  idxtype *perm, *iperm;
+  GraphType graph;
+  char filename[256];
+  int numflag = 0, wgtflag;
+  timer TOTALTmr, METISTmr, IOTmr, SMBTmr;
+
+
+  if (argc != 2) {
+    printf("Usage: %s <GraphFile>\n",argv[0]);
+    exit(0);
+  }
+    
+  strcpy(filename, argv[1]);
+
+  cleartimer(TOTALTmr);
+  cleartimer(METISTmr);
+  cleartimer(IOTmr);
+  cleartimer(SMBTmr);
+
+  starttimer(TOTALTmr);
+  starttimer(IOTmr);
+  ReadGraph(&graph, filename, &wgtflag);
+  if (graph.nvtxs <= 0) {
+    printf("Empty graph. Nothing to do.\n");
+    exit(0);
+  }
+  if (graph.ncon != 1) {
+    printf("Ordering can only be applied to graphs with one constraint.\n");
+    exit(0);
+  }
+  stoptimer(IOTmr);
+
+  /* Ordering does not use weights! */
+  GKfree(&graph.vwgt, &graph.adjwgt, LTERM);
+
+  printf("**********************************************************************\n");
+  printf("%s", METISTITLE);
+  printf("Graph Information ---------------------------------------------------\n");
+  printf("  Name: %s, #Vertices: %d, #Edges: %d\n\n", filename, graph.nvtxs, graph.nedges/2);
+  printf("Edge-Based Ordering... ----------------------------------------------\n");
+
+  perm = idxmalloc(graph.nvtxs, "main: perm");
+  iperm = idxmalloc(graph.nvtxs, "main: iperm");
+  options[0] = 0;
+
+  starttimer(METISTmr);
+  METIS_EdgeND(&graph.nvtxs, graph.xadj, graph.adjncy, &numflag, options, perm, iperm);
+  stoptimer(METISTmr);
+
+  starttimer(IOTmr);
+  WritePermutation(filename, iperm, graph.nvtxs); 
+  stoptimer(IOTmr);
+
+  starttimer(SMBTmr);
+  ComputeFillIn(&graph, iperm);
+  stoptimer(SMBTmr);
+
+  stoptimer(TOTALTmr);
+
+  printf("\nTiming Information --------------------------------------------------\n");
+  printf("  I/O:                     \t %7.3f\n", gettimer(IOTmr));
+  printf("  Ordering:                \t %7.3f   (OEMETIS time)\n", gettimer(METISTmr));
+  printf("  Symbolic Factorization:  \t %7.3f\n", gettimer(SMBTmr));
+  printf("  Total:                   \t %7.3f\n", gettimer(TOTALTmr));
+  printf("**********************************************************************\n");
+
+
+  GKfree(&graph.xadj, &graph.adjncy, &perm, &iperm, LTERM);
+}  
+
+
Index: /inundation/pymetis/metis-4.0/Programs/onmetis.c
===================================================================
--- /inundation/pymetis/metis-4.0/Programs/onmetis.c	(revision 2051)
+++ /inundation/pymetis/metis-4.0/Programs/onmetis.c	(revision 2051)
@@ -0,0 +1,95 @@
+/*
+ * Copyright 1997, Regents of the University of Minnesota
+ *
+ * onmetis.c
+ *
+ * This file contains the driving routine for multilevel method
+ *
+ * Started 8/28/94
+ * George
+ *
+ * $Id: onmetis.c,v 1.1 1998/11/27 17:59:38 karypis Exp $
+ *
+ */
+
+#include <metis.h>
+
+
+
+/*************************************************************************
+* Let the game begin
+**************************************************************************/
+main(int argc, char *argv[])
+{
+  int i, options[10];
+  idxtype *perm, *iperm;
+  GraphType graph;
+  char filename[256];
+  int numflag = 0, wgtflag;
+  timer TOTALTmr, METISTmr, IOTmr, SMBTmr;
+
+
+  if (argc != 2) {
+    printf("Usage: %s <GraphFile>\n",argv[0]);
+    exit(0);
+  }
+    
+  strcpy(filename, argv[1]);
+
+  cleartimer(TOTALTmr);
+  cleartimer(METISTmr);
+  cleartimer(IOTmr);
+  cleartimer(SMBTmr);
+
+  starttimer(TOTALTmr);
+  starttimer(IOTmr);
+  ReadGraph(&graph, filename, &wgtflag);
+  if (graph.nvtxs <= 0) {
+    printf("Empty graph. Nothing to do.\n");
+    exit(0);
+  }
+  if (graph.ncon != 1) {
+    printf("Ordering can only be applied to graphs with one constraint.\n");
+    exit(0);
+  }
+  stoptimer(IOTmr);
+
+  /* Ordering does not use weights! */
+  GKfree(&graph.vwgt, &graph.adjwgt, LTERM);
+
+  printf("**********************************************************************\n");
+  printf("%s", METISTITLE);
+  printf("Graph Information ---------------------------------------------------\n");
+  printf("  Name: %s, #Vertices: %d, #Edges: %d\n\n", filename, graph.nvtxs, graph.nedges/2);
+  printf("Node-Based Ordering... ----------------------------------------------\n");
+
+  perm = idxmalloc(graph.nvtxs, "main: perm");
+  iperm = idxmalloc(graph.nvtxs, "main: iperm");
+  options[0] = 0;
+
+  starttimer(METISTmr);
+  METIS_NodeND(&graph.nvtxs, graph.xadj, graph.adjncy, &numflag, options, perm, iperm);
+  stoptimer(METISTmr);
+
+  starttimer(IOTmr);
+  WritePermutation(filename, iperm, graph.nvtxs); 
+  stoptimer(IOTmr);
+
+  starttimer(SMBTmr);
+  ComputeFillIn(&graph, iperm);
+  stoptimer(SMBTmr);
+
+  stoptimer(TOTALTmr);
+
+  printf("\nTiming Information --------------------------------------------------\n");
+  printf("  I/O:                     \t %7.3f\n", gettimer(IOTmr));
+  printf("  Ordering:                \t %7.3f   (ONMETIS time)\n", gettimer(METISTmr));
+  printf("  Symbolic Factorization:  \t %7.3f\n", gettimer(SMBTmr));
+  printf("  Total:                   \t %7.3f\n", gettimer(TOTALTmr));
+  printf("**********************************************************************\n");
+
+
+  GKfree(&graph.xadj, &graph.adjncy, &perm, &iperm, LTERM);
+}  
+
+
Index: /inundation/pymetis/metis-4.0/Programs/partdmesh.c
===================================================================
--- /inundation/pymetis/metis-4.0/Programs/partdmesh.c	(revision 2051)
+++ /inundation/pymetis/metis-4.0/Programs/partdmesh.c	(revision 2051)
@@ -0,0 +1,93 @@
+/*
+ * Copyright 1997, Regents of the University of Minnesota
+ *
+ * partdmesh.c
+ *
+ * This file reads in the element node connectivity array of a mesh and 
+ * partitions both the elements and the nodes using KMETIS on the dual graph.
+ *
+ * Started 9/29/97
+ * George
+ *
+ * $Id: partdmesh.c,v 1.1 1998/11/27 17:59:38 karypis Exp $
+ *
+ */
+
+#include <metis.h>
+
+
+
+/*************************************************************************
+* Let the game begin
+**************************************************************************/
+main(int argc, char *argv[])
+{
+  int i, j, ne, nn, etype, numflag=0, nparts, edgecut;
+  idxtype *elmnts, *epart, *npart;
+  timer IOTmr, DUALTmr;
+  char etypestr[4][5] = {"TRI", "TET", "HEX", "QUAD"};
+  GraphType graph;
+
+  if (argc != 3) {
+    printf("Usage: %s <meshfile> <nparts>\n",argv[0]);
+    exit(0);
+  }
+
+  nparts = atoi(argv[2]);
+  if (nparts < 2) {
+    printf("nparts must be greater than one.\n");
+    exit(0);
+  }
+   
+  cleartimer(IOTmr);
+  cleartimer(DUALTmr);
+
+  starttimer(IOTmr);
+  elmnts = ReadMesh(argv[1], &ne, &nn, &etype);
+  stoptimer(IOTmr);
+
+  epart = idxmalloc(ne, "main: epart");
+  npart = idxmalloc(nn, "main: npart");
+
+  printf("**********************************************************************\n");
+  printf("%s", METISTITLE);
+  printf("Mesh Information ----------------------------------------------------\n");
+  printf("  Name: %s, #Elements: %d, #Nodes: %d, Etype: %s\n\n", argv[1], ne, nn, etypestr[etype-1]);
+  printf("Partitioning Dual Graph... ------------------------------------------\n");
+
+
+  starttimer(DUALTmr);
+  METIS_PartMeshDual(&ne, &nn, elmnts, &etype, &numflag, &nparts, &edgecut, epart, npart);
+  stoptimer(DUALTmr);
+
+  printf("  %d-way Edge-Cut: %7d, Balance: %5.2f\n", nparts, edgecut, ComputeElementBalance(ne, nparts, epart));
+
+  starttimer(IOTmr);
+  WriteMeshPartition(argv[1], nparts, ne, epart, nn, npart);
+  stoptimer(IOTmr);
+
+
+  printf("\nTiming Information --------------------------------------------------\n");
+  printf("  I/O:          \t\t %7.3f\n", gettimer(IOTmr));
+  printf("  Partitioning: \t\t %7.3f\n", gettimer(DUALTmr));
+  printf("**********************************************************************\n");
+
+/*
+  graph.nvtxs = nn;
+  graph.xadj = idxmalloc(nn+1, "xadj");
+  graph.vwgt = idxsmalloc(nn, 1, "vwgt");
+  graph.adjncy = idxmalloc(20*nn, "adjncy");
+  graph.adjwgt = idxsmalloc(20*nn, 1, "adjncy");
+
+  METIS_MeshToNodal(&ne, &nn, elmnts, &etype, &numflag, graph.xadj, graph.adjncy);
+
+  ComputePartitionInfo(&graph, nparts, npart);
+
+  GKfree(&graph.xadj, &graph.adjncy, &graph.vwgt, &graph.adjwgt, LTERM);
+*/
+
+  GKfree(&elmnts, &epart, &npart, LTERM);
+
+}
+
+
Index: /inundation/pymetis/metis-4.0/Programs/partnmesh.c
===================================================================
--- /inundation/pymetis/metis-4.0/Programs/partnmesh.c	(revision 2051)
+++ /inundation/pymetis/metis-4.0/Programs/partnmesh.c	(revision 2051)
@@ -0,0 +1,93 @@
+/*
+ * Copyright 1997, Regents of the University of Minnesota
+ *
+ * partnmesh.c
+ *
+ * This file reads in the element node connectivity array of a mesh and 
+ * partitions both the elements and the nodes using KMETIS on the dual graph.
+ *
+ * Started 9/29/97
+ * George
+ *
+ * $Id: partnmesh.c,v 1.1 1998/11/27 17:59:39 karypis Exp $
+ *
+ */
+
+#include <metis.h>
+
+
+
+/*************************************************************************
+* Let the game begin
+**************************************************************************/
+main(int argc, char *argv[])
+{
+  int i, j, ne, nn, etype, numflag=0, nparts, edgecut;
+  idxtype *elmnts, *epart, *npart;
+  timer IOTmr, DUALTmr;
+  char etypestr[4][5] = {"TRI", "TET", "HEX", "QUAD"};
+  GraphType graph;
+
+  if (argc != 3) {
+    printf("Usage: %s <meshfile> <nparts>\n",argv[0]);
+    exit(0);
+  }
+
+  nparts = atoi(argv[2]);
+  if (nparts < 2) {
+    printf("nparts must be greater than one.\n");
+    exit(0);
+  }
+   
+  cleartimer(IOTmr);
+  cleartimer(DUALTmr);
+
+  starttimer(IOTmr);
+  elmnts = ReadMesh(argv[1], &ne, &nn, &etype);
+  stoptimer(IOTmr);
+
+  epart = idxmalloc(ne, "main: epart");
+  npart = idxmalloc(nn, "main: npart");
+
+  printf("**********************************************************************\n");
+  printf("%s", METISTITLE);
+  printf("Mesh Information ----------------------------------------------------\n");
+  printf("  Name: %s, #Elements: %d, #Nodes: %d, Etype: %s\n\n", argv[1], ne, nn, etypestr[etype-1]);
+  printf("Partitioning Nodal Graph... -----------------------------------------\n");
+
+
+  starttimer(DUALTmr);
+  METIS_PartMeshNodal(&ne, &nn, elmnts, &etype, &numflag, &nparts, &edgecut, epart, npart);
+  stoptimer(DUALTmr);
+
+  printf("  %d-way Edge-Cut: %7d, Balance: %5.2f\n", nparts, edgecut, ComputeElementBalance(ne, nparts, epart));
+
+  starttimer(IOTmr);
+  WriteMeshPartition(argv[1], nparts, ne, epart, nn, npart);
+  stoptimer(IOTmr);
+
+
+  printf("\nTiming Information --------------------------------------------------\n");
+  printf("  I/O:          \t\t %7.3f\n", gettimer(IOTmr));
+  printf("  Partitioning: \t\t %7.3f\n", gettimer(DUALTmr));
+  printf("**********************************************************************\n");
+
+/*
+  graph.nvtxs = ne;
+  graph.xadj = idxmalloc(ne+1, "xadj");
+  graph.vwgt = idxsmalloc(ne, 1, "vwgt");
+  graph.adjncy = idxmalloc(10*ne, "adjncy");
+  graph.adjwgt = idxsmalloc(10*ne, 1, "adjncy");
+
+  METIS_MeshToDual(&ne, &nn, elmnts, &etype, &numflag, graph.xadj, graph.adjncy);
+
+  ComputePartitionInfo(&graph, nparts, epart);
+
+  GKfree(&graph.xadj, &graph.adjncy, &graph.vwgt, &graph.adjwgt, LTERM);
+*/
+
+  GKfree(&elmnts, &epart, &npart, LTERM);
+
+}
+
+
Index: /inundation/pymetis/metis-4.0/Programs/pmetis.c
===================================================================
--- /inundation/pymetis/metis-4.0/Programs/pmetis.c	(revision 2051)
+++ /inundation/pymetis/metis-4.0/Programs/pmetis.c	(revision 2051)
@@ -0,0 +1,105 @@
+/*
+ * Copyright 1997, Regents of the University of Minnesota
+ *
+ * pmetis.c
+ *
+ * This file contains the driving routine for multilevel method
+ *
+ * Started 8/28/94
+ * George
+ *
+ * $Id: pmetis.c,v 1.1 1998/11/27 17:59:39 karypis Exp $
+ *
+ */
+
+#include <metis.h>
+
+
+
+/*************************************************************************
+* Let the game begin
+**************************************************************************/
+main(int argc, char *argv[])
+{
+  int i, nparts, options[10];
+  idxtype *part;
+  float lbvec[MAXNCON];
+  GraphType graph;
+  char filename[256];
+  int numflag = 0, wgtflag = 0, edgecut;
+  timer TOTALTmr, METISTmr, IOTmr;
+
+
+  if (argc != 3) {
+    printf("Usage: %s <GraphFile> <Nparts>\n",argv[0]);
+    exit(0);
+  }
+    
+  strcpy(filename, argv[1]);
+  nparts = atoi(argv[2]);
+
+  if (nparts < 2) {
+    printf("The number of partitions should be greater than 1!\n");
+    exit(0);
+  }
+
+  cleartimer(TOTALTmr);
+  cleartimer(METISTmr);
+  cleartimer(IOTmr);
+
+  starttimer(TOTALTmr);
+  starttimer(IOTmr);
+  ReadGraph(&graph, filename, &wgtflag);
+  if (graph.nvtxs <= 0) {
+    printf("Empty graph. Nothing to do.\n");
+    exit(0);
+  }
+  stoptimer(IOTmr);
+
+  printf("**********************************************************************\n");
+  printf("%s", METISTITLE);
+  printf("Graph Information ---------------------------------------------------\n");
+  printf("  Name: %s, #Vertices: %d, #Edges: %d, #Parts: %d\n", filename, graph.nvtxs, graph.nedges/2, nparts);
+  if (graph.ncon > 1)
+    printf("  Balancing Constraints: %d\n", graph.ncon);
+  printf("\nRecursive Partitioning... -------------------------------------------\n");
+
+  part = idxmalloc(graph.nvtxs, "main: part");
+  options[0] = 0;
+
+  starttimer(METISTmr);
+  if (graph.ncon == 1) {
+    METIS_PartGraphRecursive(&graph.nvtxs, graph.xadj, graph.adjncy, graph.vwgt, graph.adjwgt, 
+          &wgtflag, &numflag, &nparts, options, &edgecut, part);
+  }
+  else {
+    METIS_mCPartGraphRecursive(&graph.nvtxs, &graph.ncon, graph.xadj, graph.adjncy, graph.vwgt, 
+          graph.adjwgt, &wgtflag, &numflag, &nparts, options, &edgecut, part);
+  }
+
+  stoptimer(METISTmr);
+
+  ComputePartitionBalance(&graph, nparts, part, lbvec);
+
+  printf("  %d-way Edge-Cut: %7d, Balance: ", nparts, edgecut);
+  for (i=0; i<graph.ncon; i++)
+    printf("%5.2f ", lbvec[i]);
+  printf("\n");
+
+
+  starttimer(IOTmr);
+  WritePartition(filename, part, graph.nvtxs, nparts); 
+  stoptimer(IOTmr);
+  stoptimer(TOTALTmr);
+
+  printf("\nTiming Information --------------------------------------------------\n");
+  printf("  I/O:          \t\t %7.3f\n", gettimer(IOTmr));
+  printf("  Partitioning: \t\t %7.3f   (PMETIS time)\n", gettimer(METISTmr));
+  printf("  Total:        \t\t %7.3f\n", gettimer(TOTALTmr));
+  printf("**********************************************************************\n");
+
+
+  GKfree(&graph.xadj, &graph.adjncy, &graph.vwgt, &graph.adjwgt, &part, LTERM);
+}  
+
+
Index: /inundation/pymetis/metis-4.0/Programs/smbfactor.c
===================================================================
--- /inundation/pymetis/metis-4.0/Programs/smbfactor.c	(revision 2051)
+++ /inundation/pymetis/metis-4.0/Programs/smbfactor.c	(revision 2051)
@@ -0,0 +1,385 @@
+/*
+ * Copyright 1997, Regents of the University of Minnesota
+ *
+ * smbfactor.c
+ *
+ * This file performs the symbolic factorization of a matrix
+ *
+ * Started 8/1/97
+ * George
+ *
+ * $Id: smbfactor.c,v 1.1 1998/11/27 17:59:40 karypis Exp $
+ *
+ */
+
+#include <metis.h>
+
+
+/*************************************************************************
+* This function sets up data structures for fill-in computations
+**************************************************************************/
+void ComputeFillIn(GraphType *graph, idxtype *iperm)
+{
+  int i, j, k, nvtxs, maxlnz, maxsub;
+  idxtype *xadj, *adjncy;
+  idxtype *perm, *xlnz, *xnzsub, *nzsub;
+  double opc;
+
+/*
+  printf("\nSymbolic factorization... --------------------------------------------\n");
+*/
+
+  nvtxs = graph->nvtxs;
+  xadj = graph->xadj;
+  adjncy = graph->adjncy;
+
+  maxsub = 4*xadj[nvtxs];
+
+  /* Relabel the vertices so that it starts from 1 */
+  k = xadj[nvtxs];
+  for (i=0; i<k; i++)
+    adjncy[i]++;
+  for (i=0; i<nvtxs+1; i++)
+    xadj[i]++;
+
+  /* Allocate the required memory */
+  perm = idxmalloc(nvtxs+1, "ComputeFillIn: perm");
+  xlnz = idxmalloc(nvtxs+1, "ComputeFillIn: xlnz");
+  xnzsub = idxmalloc(nvtxs+1, "ComputeFillIn: xnzsub");
+  nzsub = idxmalloc(maxsub, "ComputeFillIn: nzsub");
+
+  /* Construct perm from iperm and change the numbering of iperm */
+  for (i=0; i<nvtxs; i++)
+    perm[iperm[i]] = i;
+  for (i=0; i<nvtxs; i++) {
+    iperm[i]++;
+    perm[i]++;
+  }
+  
+  /*
+   * Call sparspak routine.
+   */
+  if (smbfct(nvtxs, xadj, adjncy, perm, iperm, xlnz, &maxlnz, xnzsub, nzsub, &maxsub)) {
+    free(nzsub);
+
+    maxsub = 4*maxsub; 
+    nzsub = idxmalloc(maxsub, "ComputeFillIn: nzsub");
+    if (smbfct(nvtxs, xadj, adjncy, perm, iperm, xlnz, &maxlnz, xnzsub, nzsub, &maxsub)) 
+      errexit("MAXSUB is too small!");
+  }
+
+  opc = 0;
+  for (i=0; i<nvtxs; i++)
+    xlnz[i]--;
+  for (i=0; i<nvtxs; i++)
+    opc += (xlnz[i+1]-xlnz[i])*(xlnz[i+1]-xlnz[i]) - (xlnz[i+1]-xlnz[i]);
+
+  printf("  Nonzeros: %d, \tOperation Count: %6.4le\n", maxlnz, opc);
+
+
+  GKfree(&perm, &xlnz, &xnzsub, &nzsub, LTERM);
+
+
+  /* Relabel the vertices so that it starts from 0 */
+  for (i=0; i<nvtxs; i++)
+    iperm[i]--;
+  for (i=0; i<nvtxs+1; i++)
+    xadj[i]--;
+  k = xadj[nvtxs];
+  for (i=0; i<k; i++)
+    adjncy[i]--;
+
+}
+
+
+
+/*************************************************************************
+* This function sets up data structures for fill-in computations
+**************************************************************************/
+idxtype ComputeFillIn2(GraphType *graph, idxtype *iperm)
+{
+  int i, j, k, nvtxs, maxlnz, maxsub;
+  idxtype *xadj, *adjncy;
+  idxtype *perm, *xlnz, *xnzsub, *nzsub;
+  double opc;
+
+  nvtxs = graph->nvtxs;
+  xadj = graph->xadj;
+  adjncy = graph->adjncy;
+
+  maxsub = 4*xadj[nvtxs];
+
+  /* Relabel the vertices so that it starts from 1 */
+  k = xadj[nvtxs];
+  for (i=0; i<k; i++)
+    adjncy[i]++;
+  for (i=0; i<nvtxs+1; i++)
+    xadj[i]++;
+
+  /* Allocate the required memory */
+  perm = idxmalloc(nvtxs+1, "ComputeFillIn: perm");
+  xlnz = idxmalloc(nvtxs+1, "ComputeFillIn: xlnz");
+  xnzsub = idxmalloc(nvtxs+1, "ComputeFillIn: xnzsub");
+  nzsub = idxmalloc(maxsub, "ComputeFillIn: nzsub");
+
+  /* Construct perm from iperm and change the numbering of iperm */
+  for (i=0; i<nvtxs; i++)
+    perm[iperm[i]] = i;
+  for (i=0; i<nvtxs; i++) {
+    iperm[i]++;
+    perm[i]++;
+  }
+  
+  /*
+   * Call sparspak routine.
+   */
+  if (smbfct(nvtxs, xadj, adjncy, perm, iperm, xlnz, &maxlnz, xnzsub, nzsub, &maxsub)) {
+    free(nzsub);
+
+    maxsub = 4*maxsub; 
+    nzsub = idxmalloc(maxsub, "ComputeFillIn: nzsub");
+    if (smbfct(nvtxs, xadj, adjncy, perm, iperm, xlnz, &maxlnz, xnzsub, nzsub, &maxsub)) 
+      errexit("MAXSUB is too small!");
+  }
+
+  opc = 0;
+  for (i=0; i<nvtxs; i++)
+    xlnz[i]--;
+  for (i=0; i<nvtxs; i++)
+    opc += (xlnz[i+1]-xlnz[i])*(xlnz[i+1]-xlnz[i]) - (xlnz[i+1]-xlnz[i]);
+
+
+  GKfree(&perm, &xlnz, &xnzsub, &nzsub, LTERM);
+
+
+  /* Relabel the vertices so that it starts from 0 */
+  for (i=0; i<nvtxs; i++)
+    iperm[i]--;
+  for (i=0; i<nvtxs+1; i++)
+    xadj[i]--;
+  k = xadj[nvtxs];
+  for (i=0; i<k; i++)
+    adjncy[i]--;
+
+  return maxlnz;
+
+}
+
+
+/*****************************************************************          
+**********     SMBFCT ..... SYMBOLIC FACTORIZATION       ********* 
+******************************************************************          
+*   PURPOSE - THIS ROUTINE PERFORMS SYMBOLIC FACTORIZATION               
+*   ON A PERMUTED LINEAR SYSTEM AND IT ALSO SETS UP THE               
+*   COMPRESSED DATA STRUCTURE FOR THE SYSTEM.                         
+*
+*   INPUT PARAMETERS -                                               
+*      NEQNS - NUMBER OF EQUATIONS.                                 
+*      (XADJ, ADJNCY) - THE ADJACENCY STRUCTURE.                   
+*      (PERM, INVP) - THE PERMUTATION VECTOR AND ITS INVERSE.     
+*
+*   UPDATED PARAMETERS -                                         
+*      MAXSUB - SIZE OF THE SUBSCRIPT ARRAY NZSUB.  ON RETURN,  
+*             IT CONTAINS THE NUMBER OF SUBSCRIPTS USED        
+*
+*   OUTPUT PARAMETERS -                                       
+*      XLNZ - INDEX INTO THE NONZERO STORAGE VECTOR LNZ.   
+*      (XNZSUB, NZSUB) - THE COMPRESSED SUBSCRIPT VECTORS. 
+*      MAXLNZ - THE NUMBER OF NONZEROS FOUND.             
+*
+*******************************************************************/
+int smbfct(int neqns, idxtype *xadj, idxtype *adjncy, idxtype *perm, idxtype *invp, idxtype *xlnz, 
+           int *maxlnz, idxtype *xnzsub, idxtype *nzsub, int *maxsub)
+{
+  /* Local variables */
+  int node, rchm, mrgk, lmax, i, j, k, m, nabor, nzbeg, nzend;
+  int kxsub, jstop, jstrt, mrkflg, inz, knz, flag;
+  idxtype *mrglnk, *marker, *rchlnk;
+
+  rchlnk = idxmalloc(neqns+1, "smbfct: rchlnk");
+  marker = idxsmalloc(neqns+1, 0, "smbfct: marker");
+  mrglnk = idxsmalloc(neqns+1, 0, "smbfct: mgrlnk");
+
+  /* Parameter adjustments */
+  --marker;
+  --mrglnk;
+  --rchlnk;
+  --nzsub;
+  --xnzsub;
+  --xlnz;
+  --invp;
+  --perm;
+  --adjncy;
+  --xadj;
+
+  /* Function Body */
+  flag = 0;
+  nzbeg = 1;
+  nzend = 0;
+  xlnz[1] = 1;
+
+  /* FOR EACH COLUMN KNZ COUNTS THE NUMBER OF NONZEROS IN COLUMN K ACCUMULATED IN RCHLNK. */
+  for (k = 1; k <= neqns; ++k) {
+    knz = 0;
+    mrgk = mrglnk[k];
+    mrkflg = 0;
+    marker[k] = k;
+    if (mrgk != 0) 
+      marker[k] = marker[mrgk];
+    xnzsub[k] = nzend;
+    node = perm[k];
+
+    if (xadj[node] >= xadj[node+1]) {
+      xlnz[k+1] = xlnz[k];
+      continue;
+    }
+
+    /* USE RCHLNK TO LINK THROUGH THE STRUCTURE OF A(*,K) BELOW DIAGONAL */
+    rchlnk[k] = neqns+1;
+    for (j=xadj[node]; j<xadj[node+1]; j++) {
+      nabor = invp[adjncy[j]];
+      if (nabor <= k) 
+        continue;
+      rchm = k;
+
+      do {
+        m = rchm;
+        rchm = rchlnk[m];
+      } while (rchm <= nabor); 
+
+      knz++;
+      rchlnk[m] = nabor;
+      rchlnk[nabor] = rchm;
+      if (marker[nabor] != marker[k]) 
+        mrkflg = 1;
+    }
+
+    /* TEST FOR MASS SYMBOLIC ELIMINATION */
+    lmax = 0;
+    if (mrkflg != 0 || mrgk == 0 || mrglnk[mrgk] != 0) 
+      goto L350;
+    xnzsub[k] = xnzsub[mrgk] + 1;
+    knz = xlnz[mrgk + 1] - (xlnz[mrgk] + 1);
+    goto L1400;
+
+
+    /* LINK THROUGH EACH COLUMN I THAT AFFECTS L(*,K) */
+L350:
+    i = k;
+    while ((i = mrglnk[i]) != 0) {
+      inz = xlnz[i+1] - (xlnz[i]+1);
+      jstrt = xnzsub[i] + 1;
+      jstop = xnzsub[i] + inz;
+
+      if (inz > lmax) { 
+        lmax = inz;
+        xnzsub[k] = jstrt;
+      }
+
+      /* MERGE STRUCTURE OF L(*,I) IN NZSUB INTO RCHLNK. */ 
+      rchm = k;
+      for (j = jstrt; j <= jstop; ++j) {
+        nabor = nzsub[j];
+        do {
+          m = rchm;
+          rchm = rchlnk[m];
+        } while (rchm < nabor);
+
+        if (rchm != nabor) {
+          knz++;
+          rchlnk[m] = nabor;
+          rchlnk[nabor] = rchm;
+          rchm = nabor;
+        }
+      }
+    }
+
+    /* CHECK IF SUBSCRIPTS DUPLICATE THOSE OF ANOTHER COLUMN */
+    if (knz == lmax) 
+      goto L1400;
+
+    /* OR IF TAIL OF K-1ST COLUMN MATCHES HEAD OF KTH */
+    if (nzbeg > nzend) 
+      goto L1200;
+
+    i = rchlnk[k];
+    for (jstrt = nzbeg; jstrt <= nzend; ++jstrt) {
+      if (nzsub[jstrt] < i) 
+        continue;
+
+      if (nzsub[jstrt] == i) 
+        goto L1000;
+      else 
+        goto L1200;
+    }
+    goto L1200;
+
+L1000:
+    xnzsub[k] = jstrt;
+    for (j = jstrt; j <= nzend; ++j) {
+      if (nzsub[j] != i) 
+        goto L1200;
+      
+      i = rchlnk[i];
+      if (i > neqns) 
+        goto L1400;
+    }
+    nzend = jstrt - 1;
+
+    /* COPY THE STRUCTURE OF L(*,K) FROM RCHLNK TO THE DATA STRUCTURE (XNZSUB, NZSUB) */
+L1200:
+    nzbeg = nzend + 1;
+    nzend += knz;
+
+    if (nzend > *maxsub) {
+      flag = 1; /* Out of memory */
+      break;
+    }
+
+    i = k;
+    for (j=nzbeg; j<=nzend; ++j) {
+      i = rchlnk[i];
+      nzsub[j] = i;
+      marker[i] = k;
+    }
+    xnzsub[k] = nzbeg;
+    marker[k] = k;
+
+    /*
+     * UPDATE THE VECTOR MRGLNK.  NOTE COLUMN L(*,K) JUST FOUND   
+     * IS REQUIRED TO DETERMINE COLUMN L(*,J), WHERE              
+     * L(J,K) IS THE FIRST NONZERO IN L(*,K) BELOW DIAGONAL.      
+     */
+L1400:
+    if (knz > 1) { 
+      kxsub = xnzsub[k];
+      i = nzsub[kxsub];
+      mrglnk[k] = mrglnk[i];
+      mrglnk[i] = k;
+    }
+
+    xlnz[k + 1] = xlnz[k] + knz;
+  }
+
+  if (flag == 0) {
+    *maxlnz = xlnz[neqns] - 1;
+    *maxsub = xnzsub[neqns];
+    xnzsub[neqns + 1] = xnzsub[neqns];
+  }
+
+  marker++;
+  mrglnk++;
+  rchlnk++;
+  nzsub++;
+  xnzsub++;
+  xlnz++;
+  invp++;
+  perm++;
+  adjncy++;
+  xadj++;
+  GKfree(&rchlnk, &mrglnk, &marker, LTERM);
+
+  return flag;
+  
+} 
+
Index: /inundation/pymetis/metis-4.0/Test/Makefile
===================================================================
--- /inundation/pymetis/metis-4.0/Test/Makefile	(revision 2051)
+++ /inundation/pymetis/metis-4.0/Test/Makefile	(revision 2051)
@@ -0,0 +1,31 @@
+include ../Makefile.in
+
+BINDIR = ../Graphs
+
+INCLUDES = -I../Lib 
+CFLAGS = $(COPTIONS) $(OPTFLAGS) $(INCLUDES)
+
+LIBS = -lmetis -lm
+LD = $(CC) $(LDOPTIONS) -L. -L..
+METISLIB = ../libmetis.a
+
+
+
+MTESTOBJS = mtest.o ../Programs/io.o 
+
+
+.c.o:
+	$(CC) $(CFLAGS) -c $*.c
+
+default: $(BINDIR)/mtest
+
+$(BINDIR)/mtest: $(MTESTOBJS) $(METISLIB)
+	$(LD)  -o $@ $(MTESTOBJS) $(LIBS)
+	chmod 755 $@
+
+clean:
+	rm -f *.o
+
+realclean:
+	rm -f *.o ;\
+        rm -f $(BINDIR)/mtest 
Index: /inundation/pymetis/metis-4.0/Test/mtest.c
===================================================================
--- /inundation/pymetis/metis-4.0/Test/mtest.c	(revision 2051)
+++ /inundation/pymetis/metis-4.0/Test/mtest.c	(revision 2051)
@@ -0,0 +1,1776 @@
+/*
+ * Copyright 1997, Regents of the University of Minnesota
+ *
+ * mtest.c
+ *
+ * This file is a comprehensive tester for all the graph partitioning/ordering
+ * routines of METIS
+ *
+ * Started 9/18/98
+ * George
+ *
+ * $Id: mtest.c,v 1.8 1998/09/20 17:36:14 karypis Exp $
+ *
+ */
+
+#include <metis.h>
+
+
+
+/*************************************************************************
+* Let the game begin
+**************************************************************************/
+main(int argc, char *argv[])
+{
+  int i, nparts, options[10];
+  idxtype *part;
+  float lbvec[MAXNCON], rubvec[MAXNCON];
+  GraphType graph;
+  int numflag = 0, wgtflag = 0, edgecut;
+
+
+  if (argc != 2) {
+    printf("Usage: %s <GraphFile>\n",argv[0]);
+    exit(0);
+  }
+    
+  ReadGraph(&graph, argv[1], &wgtflag);
+
+  printf("**********************************************************************\n");
+  printf("%s", METISTITLE);
+  printf("Graph Information ---------------------------------------------------\n");
+  printf("  Name: %s, #Vertices: %d, #Edges: %d\n", argv[1], graph.nvtxs, graph.nedges/2);
+
+  Test_PartGraph(graph.nvtxs, graph.xadj, graph.adjncy);
+
+  Test_PartGraphV(graph.nvtxs, graph.xadj, graph.adjncy);
+
+  Test_PartGraphmC(graph.nvtxs, graph.xadj, graph.adjncy);
+
+  Test_ND(graph.nvtxs, graph.xadj, graph.adjncy);
+
+  printf("\n---------------------------------------------------------------------\n");
+  printf(" Testing completed.\n");
+  printf("**********************************************************************\n");
+
+  GKfree(&graph.xadj, &graph.adjncy, &graph.vwgt, &graph.adjwgt, LTERM);
+}  
+
+
+
+/*************************************************************************
+* This function tests the regular graph partitioning routines
+**************************************************************************/
+void Test_PartGraph(int nvtxs, idxtype *xadj, idxtype *adjncy)
+{
+  int i, j, jj, k, tstnum, rcode;
+  int nparts, numflag, wgtflag, edgecut, options[10];
+  idxtype *part, *vwgt, *adjwgt;
+  float tpwgts[256];
+
+  vwgt = idxmalloc(nvtxs, "vwgt");
+  for (i=0; i<nvtxs; i++)
+    vwgt[i] = RandomInRange(10);
+
+  adjwgt = idxmalloc(xadj[nvtxs], "adjwgt");
+  for (i=0; i<nvtxs; i++) {
+    for (j=xadj[i]; j<xadj[i+1]; j++) {
+      k = adjncy[j];
+      if (i < k) {
+        adjwgt[j] = 1+RandomInRange(5);
+        for (jj=xadj[k]; jj<xadj[k+1]; jj++) {
+          if (adjncy[jj] == i) {
+            adjwgt[jj] = adjwgt[j];
+            break;
+          }
+        }
+      }
+    }
+  }
+
+
+  part = idxmalloc(nvtxs, "part");
+
+  tpwgts[0] = .1;
+  tpwgts[1] = .2;
+  tpwgts[2] = .3;
+  tpwgts[3] = .1;
+  tpwgts[4] = .05;
+  tpwgts[5] = .25;
+
+
+  /*===========================================================================*/
+  printf("\nTesting METIS_PartGraphRecursive ------------------------------------\n  ");
+  tstnum = 1;
+
+/**/
+  numflag = 0; wgtflag = 0; nparts = 20;
+  options[0] = 0;
+  METIS_PartGraphRecursive(&nvtxs, xadj, adjncy, NULL, NULL, &wgtflag, &numflag,
+                           &nparts, options, &edgecut, part);
+
+  if ((rcode = VerifyPart(nvtxs, xadj, adjncy, NULL, NULL, nparts, edgecut, part)) == 0)
+    printf("[%d:ok]", tstnum++);
+  else
+    printf("[%d:err-%d]", tstnum++, rcode);
+  fflush(stdout);
+
+
+/**/
+  numflag = 0; wgtflag = 1; nparts = 20;
+  options[0] = 0;
+  METIS_PartGraphRecursive(&nvtxs, xadj, adjncy, NULL, adjwgt, &wgtflag, &numflag,
+                           &nparts, options, &edgecut, part);
+
+  if ((rcode = VerifyPart(nvtxs, xadj, adjncy, NULL, adjwgt, nparts, edgecut, part)) == 0)
+    printf("[%d:ok]", tstnum++);
+  else
+    printf("[%d:err-%d]", tstnum++, rcode);
+  fflush(stdout);
+
+
+/**/
+  numflag = 0; wgtflag = 2; nparts = 20;
+  options[0] = 0;
+  METIS_PartGraphRecursive(&nvtxs, xadj, adjncy, vwgt, NULL, &wgtflag, &numflag,
+                           &nparts, options, &edgecut, part);
+
+  if ((rcode = VerifyPart(nvtxs, xadj, adjncy, vwgt, NULL, nparts, edgecut, part)) == 0)
+    printf("[%d:ok]", tstnum++);
+  else
+    printf("[%d:err-%d]", tstnum++, rcode);
+  fflush(stdout);
+
+
+/**/
+  numflag = 0; wgtflag = 3; nparts = 20;
+  options[0] = 0;
+  METIS_PartGraphRecursive(&nvtxs, xadj, adjncy, vwgt, adjwgt, &wgtflag, &numflag,
+                           &nparts, options, &edgecut, part);
+
+  if ((rcode = VerifyPart(nvtxs, xadj, adjncy, vwgt, adjwgt, nparts, edgecut, part)) == 0)
+    printf("[%d:ok]", tstnum++);
+  else
+    printf("[%d:err-%d]", tstnum++, rcode);
+  fflush(stdout);
+
+
+/**/
+  numflag = 0; wgtflag = 3; nparts = 20;
+  options[0] = 1; options[1] = 1; options[2] = 1; options[3] = 1; options[4] = 0;
+  METIS_PartGraphRecursive(&nvtxs, xadj, adjncy, vwgt, adjwgt, &wgtflag, &numflag,
+                           &nparts, options, &edgecut, part);
+
+  if ((rcode = VerifyPart(nvtxs, xadj, adjncy, vwgt, adjwgt, nparts, edgecut, part)) == 0)
+    printf("[%d:ok]", tstnum++);
+  else
+    printf("[%d:err-%d]", tstnum++, rcode);
+  fflush(stdout);
+
+
+/**/
+  numflag = 0; wgtflag = 3; nparts = 20;
+  options[0] = 1; options[1] = 2; options[2] = 1; options[3] = 1; options[4] = 0;
+  METIS_PartGraphRecursive(&nvtxs, xadj, adjncy, vwgt, adjwgt, &wgtflag, &numflag,
+                           &nparts, options, &edgecut, part);
+
+  if ((rcode = VerifyPart(nvtxs, xadj, adjncy, vwgt, adjwgt, nparts, edgecut, part)) == 0)
+    printf("[%d:ok]", tstnum++);
+  else
+    printf("[%d:err-%d]", tstnum++, rcode);
+  fflush(stdout);
+
+  printf("\n");
+
+
+ 
+  /*===========================================================================*/
+  printf("\nTesting METIS_WPartGraphRecursive -----------------------------------\n  ");
+  tstnum = 1;
+
+
+/**/
+  numflag = 0; wgtflag = 0; nparts = 6;
+  options[0] = 0;
+  METIS_WPartGraphRecursive(&nvtxs, xadj, adjncy, NULL, NULL, &wgtflag, &numflag,
+                           &nparts, tpwgts, options, &edgecut, part);
+
+  if ((rcode = VerifyWPart(nvtxs, xadj, adjncy, NULL, NULL, nparts, tpwgts, edgecut, part)) == 0)
+    printf("[%d:ok]", tstnum++);
+  else
+    printf("[%d:err-%d]", tstnum++, rcode);
+  fflush(stdout);
+
+
+/**/
+  numflag = 0; wgtflag = 1; nparts = 6;
+  options[0] = 0;
+  METIS_WPartGraphRecursive(&nvtxs, xadj, adjncy, NULL, adjwgt, &wgtflag, &numflag,
+                           &nparts, tpwgts, options, &edgecut, part);
+
+  if ((rcode = VerifyWPart(nvtxs, xadj, adjncy, NULL, adjwgt, nparts, tpwgts, edgecut, part)) == 0)
+    printf("[%d:ok]", tstnum++);
+  else
+    printf("[%d:err-%d]", tstnum++, rcode);
+  fflush(stdout);
+
+
+/**/
+  numflag = 0; wgtflag = 2; nparts = 6;
+  options[0] = 0;
+  METIS_WPartGraphRecursive(&nvtxs, xadj, adjncy, vwgt, NULL, &wgtflag, &numflag,
+                           &nparts, tpwgts, options, &edgecut, part);
+
+  if ((rcode = VerifyWPart(nvtxs, xadj, adjncy, vwgt, NULL, nparts, tpwgts, edgecut, part)) == 0)
+    printf("[%d:ok]", tstnum++);
+  else
+    printf("[%d:err-%d]", tstnum++, rcode);
+  fflush(stdout);
+
+
+/**/
+  numflag = 0; wgtflag = 3; nparts = 6;
+  options[0] = 0;
+  METIS_WPartGraphRecursive(&nvtxs, xadj, adjncy, vwgt, adjwgt, &wgtflag, &numflag,
+                           &nparts, tpwgts, options, &edgecut, part);
+
+  if ((rcode = VerifyWPart(nvtxs, xadj, adjncy, vwgt, adjwgt, nparts, tpwgts, edgecut, part)) == 0)
+    printf("[%d:ok]", tstnum++);
+  else
+    printf("[%d:err-%d]", tstnum++, rcode);
+  fflush(stdout);
+
+
+/**/
+  numflag = 0; wgtflag = 3; nparts = 6;
+  options[0] = 1; options[1] = 1; options[2] = 1; options[3] = 1; options[4] = 0;
+  METIS_WPartGraphRecursive(&nvtxs, xadj, adjncy, vwgt, adjwgt, &wgtflag, &numflag,
+                           &nparts, tpwgts, options, &edgecut, part);
+
+  if ((rcode = VerifyWPart(nvtxs, xadj, adjncy, vwgt, adjwgt, nparts, tpwgts, edgecut, part)) == 0)
+    printf("[%d:ok]", tstnum++);
+  else
+    printf("[%d:err-%d]", tstnum++, rcode);
+  fflush(stdout);
+
+
+/**/
+  numflag = 0; wgtflag = 3; nparts = 6;
+  options[0] = 1; options[1] = 2; options[2] = 1; options[3] = 1; options[4] = 0;
+  METIS_WPartGraphRecursive(&nvtxs, xadj, adjncy, vwgt, adjwgt, &wgtflag, &numflag,
+                           &nparts, tpwgts, options, &edgecut, part);
+
+  if ((rcode = VerifyWPart(nvtxs, xadj, adjncy, vwgt, adjwgt, nparts, tpwgts, edgecut, part)) == 0)
+    printf("[%d:ok]", tstnum++);
+  else
+    printf("[%d:err-%d]", tstnum++, rcode);
+  fflush(stdout);
+
+  printf("\n");
+
+
+
+  /*===========================================================================*/
+  printf("\nTesting METIS_PartGraphKway -----------------------------------------\n  ");
+  tstnum = 1;
+
+/**/
+  numflag = 0; wgtflag = 0; nparts = 20;
+  options[0] = 0;
+  METIS_PartGraphKway(&nvtxs, xadj, adjncy, NULL, NULL, &wgtflag, &numflag,
+                      &nparts, options, &edgecut, part);
+
+  if ((rcode = VerifyPart(nvtxs, xadj, adjncy, NULL, NULL, nparts, edgecut, part)) == 0)
+    printf("[%d:ok]", tstnum++);
+  else
+    printf("[%d:err-%d]", tstnum++, rcode);
+  fflush(stdout);
+
+
+/**/
+  numflag = 0; wgtflag = 1; nparts = 20;
+  options[0] = 0;
+  METIS_PartGraphKway(&nvtxs, xadj, adjncy, NULL, adjwgt, &wgtflag, &numflag,
+                      &nparts, options, &edgecut, part);
+
+  if ((rcode = VerifyPart(nvtxs, xadj, adjncy, NULL, adjwgt, nparts, edgecut, part)) == 0)
+    printf("[%d:ok]", tstnum++);
+  else
+    printf("[%d:err-%d]", tstnum++, rcode);
+  fflush(stdout);
+
+
+/**/
+  numflag = 0; wgtflag = 2; nparts = 20;
+  options[0] = 0;
+  METIS_PartGraphKway(&nvtxs, xadj, adjncy, vwgt, NULL, &wgtflag, &numflag,
+                      &nparts, options, &edgecut, part);
+
+  if ((rcode = VerifyPart(nvtxs, xadj, adjncy, vwgt, NULL, nparts, edgecut, part)) == 0)
+    printf("[%d:ok]", tstnum++);
+  else
+    printf("[%d:err-%d]", tstnum++, rcode);
+  fflush(stdout);
+
+
+/**/
+  numflag = 0; wgtflag = 3; nparts = 20;
+  options[0] = 0;
+  METIS_PartGraphKway(&nvtxs, xadj, adjncy, vwgt, adjwgt, &wgtflag, &numflag,
+                      &nparts, options, &edgecut, part);
+
+  if ((rcode = VerifyPart(nvtxs, xadj, adjncy, vwgt, adjwgt, nparts, edgecut, part)) == 0)
+    printf("[%d:ok]", tstnum++);
+  else
+    printf("[%d:err-%d]", tstnum++, rcode);
+  fflush(stdout);
+
+
+/**/
+  numflag = 0; wgtflag = 3; nparts = 20;
+  options[0] = 1; options[1] = 1; options[2] = 1; options[3] = 1; options[4] = 0;
+  METIS_PartGraphKway(&nvtxs, xadj, adjncy, vwgt, adjwgt, &wgtflag, &numflag,
+                      &nparts, options, &edgecut, part);
+
+  if ((rcode = VerifyPart(nvtxs, xadj, adjncy, vwgt, adjwgt, nparts, edgecut, part)) == 0)
+    printf("[%d:ok]", tstnum++);
+  else
+    printf("[%d:err-%d]", tstnum++, rcode);
+  fflush(stdout);
+
+
+/**/
+  numflag = 0; wgtflag = 3; nparts = 20;
+  options[0] = 1; options[1] = 2; options[2] = 1; options[3] = 1; options[4] = 0;
+  METIS_PartGraphKway(&nvtxs, xadj, adjncy, vwgt, adjwgt, &wgtflag, &numflag,
+                      &nparts, options, &edgecut, part);
+
+  if ((rcode = VerifyPart(nvtxs, xadj, adjncy, vwgt, adjwgt, nparts, edgecut, part)) == 0)
+    printf("[%d:ok]", tstnum++);
+  else
+    printf("[%d:err-%d]", tstnum++, rcode);
+  fflush(stdout);
+
+
+/**/
+  numflag = 0; wgtflag = 3; nparts = 20;
+  options[0] = 1; options[1] = 2; options[2] = 1; options[3] = 2; options[4] = 0;
+  METIS_PartGraphKway(&nvtxs, xadj, adjncy, vwgt, adjwgt, &wgtflag, &numflag,
+                      &nparts, options, &edgecut, part);
+
+  if ((rcode = VerifyPart(nvtxs, xadj, adjncy, vwgt, adjwgt, nparts, edgecut, part)) == 0)
+    printf("[%d:ok]", tstnum++);
+  else
+    printf("[%d:err-%d]", tstnum++, rcode);
+  fflush(stdout);
+
+
+/**/
+  numflag = 0; wgtflag = 3; nparts = 20;
+  options[0] = 1; options[1] = 2; options[2] = 1; options[3] = 3; options[4] = 0;
+  METIS_PartGraphKway(&nvtxs, xadj, adjncy, vwgt, adjwgt, &wgtflag, &numflag,
+                      &nparts, options, &edgecut, part);
+
+  if ((rcode = VerifyPart(nvtxs, xadj, adjncy, vwgt, adjwgt, nparts, edgecut, part)) == 0)
+    printf("[%d:ok]", tstnum++);
+  else
+    printf("[%d:err-%d]", tstnum++, rcode);
+  fflush(stdout);
+
+  printf("\n");
+
+
+ 
+  /*===========================================================================*/
+  printf("\nTesting METIS_WPartGraphKway ----------------------------------------\n  ");
+  tstnum = 1;
+
+
+/**/
+  numflag = 0; wgtflag = 0; nparts = 6;
+  options[0] = 0;
+  METIS_WPartGraphKway(&nvtxs, xadj, adjncy, NULL, NULL, &wgtflag, &numflag,
+                       &nparts, tpwgts, options, &edgecut, part);
+
+  if ((rcode = VerifyWPart(nvtxs, xadj, adjncy, NULL, NULL, nparts, tpwgts, edgecut, part)) == 0)
+    printf("[%d:ok]", tstnum++);
+  else
+    printf("[%d:err-%d]", tstnum++, rcode);
+  fflush(stdout);
+
+
+/**/
+  numflag = 0; wgtflag = 1; nparts = 6;
+  options[0] = 0;
+  METIS_WPartGraphKway(&nvtxs, xadj, adjncy, NULL, adjwgt, &wgtflag, &numflag,
+                       &nparts, tpwgts, options, &edgecut, part);
+
+  if ((rcode = VerifyWPart(nvtxs, xadj, adjncy, NULL, adjwgt, nparts, tpwgts, edgecut, part)) == 0)
+    printf("[%d:ok]", tstnum++);
+  else
+    printf("[%d:err-%d]", tstnum++, rcode);
+  fflush(stdout);
+
+
+/**/
+  numflag = 0; wgtflag = 2; nparts = 6;
+  options[0] = 0;
+  METIS_WPartGraphKway(&nvtxs, xadj, adjncy, vwgt, NULL, &wgtflag, &numflag,
+                       &nparts, tpwgts, options, &edgecut, part);
+
+  if ((rcode = VerifyWPart(nvtxs, xadj, adjncy, vwgt, NULL, nparts, tpwgts, edgecut, part)) == 0)
+    printf("[%d:ok]", tstnum++);
+  else
+    printf("[%d:err-%d]", tstnum++, rcode);
+  fflush(stdout);
+
+
+/**/
+  numflag = 0; wgtflag = 3; nparts = 6;
+  options[0] = 0;
+  METIS_WPartGraphKway(&nvtxs, xadj, adjncy, vwgt, adjwgt, &wgtflag, &numflag,
+                       &nparts, tpwgts, options, &edgecut, part);
+
+  if ((rcode = VerifyWPart(nvtxs, xadj, adjncy, vwgt, adjwgt, nparts, tpwgts, edgecut, part)) == 0)
+    printf("[%d:ok]", tstnum++);
+  else
+    printf("[%d:err-%d]", tstnum++, rcode);
+  fflush(stdout);
+
+
+/**/
+  numflag = 0; wgtflag = 3; nparts = 6;
+  options[0] = 1; options[1] = 1; options[2] = 1; options[3] = 1; options[4] = 0;
+  METIS_WPartGraphKway(&nvtxs, xadj, adjncy, vwgt, adjwgt, &wgtflag, &numflag,
+                       &nparts, tpwgts, options, &edgecut, part);
+
+  if ((rcode = VerifyWPart(nvtxs, xadj, adjncy, vwgt, adjwgt, nparts, tpwgts, edgecut, part)) == 0)
+    printf("[%d:ok]", tstnum++);
+  else
+    printf("[%d:err-%d]", tstnum++, rcode);
+  fflush(stdout);
+
+
+/**/
+  numflag = 0; wgtflag = 3; nparts = 6;
+  options[0] = 1; options[1] = 2; options[2] = 1; options[3] = 1; options[4] = 0;
+  METIS_WPartGraphKway(&nvtxs, xadj, adjncy, vwgt, adjwgt, &wgtflag, &numflag,
+                       &nparts, tpwgts, options, &edgecut, part);
+
+  if ((rcode = VerifyWPart(nvtxs, xadj, adjncy, vwgt, adjwgt, nparts, tpwgts, edgecut, part)) == 0)
+    printf("[%d:ok]", tstnum++);
+  else
+    printf("[%d:err-%d]", tstnum++, rcode);
+  fflush(stdout);
+
+
+/**/
+  numflag = 0; wgtflag = 3; nparts = 6;
+  options[0] = 1; options[1] = 2; options[2] = 1; options[3] = 2; options[4] = 0;
+  METIS_WPartGraphKway(&nvtxs, xadj, adjncy, vwgt, adjwgt, &wgtflag, &numflag,
+                       &nparts, tpwgts, options, &edgecut, part);
+
+  if ((rcode = VerifyWPart(nvtxs, xadj, adjncy, vwgt, adjwgt, nparts, tpwgts, edgecut, part)) == 0)
+    printf("[%d:ok]", tstnum++);
+  else
+    printf("[%d:err-%d]", tstnum++, rcode);
+  fflush(stdout);
+
+
+/**/
+  numflag = 0; wgtflag = 3; nparts = 6;
+  options[0] = 1; options[1] = 2; options[2] = 1; options[3] = 3; options[4] = 0;
+  METIS_WPartGraphKway(&nvtxs, xadj, adjncy, vwgt, adjwgt, &wgtflag, &numflag,
+                       &nparts, tpwgts, options, &edgecut, part);
+
+  if ((rcode = VerifyWPart(nvtxs, xadj, adjncy, vwgt, adjwgt, nparts, tpwgts, edgecut, part)) == 0)
+    printf("[%d:ok]", tstnum++);
+  else
+    printf("[%d:err-%d]", tstnum++, rcode);
+  fflush(stdout);
+
+  printf("\n");
+
+  GKfree(&vwgt, &adjwgt, &part, LTERM);
+}
+
+
+
+/*************************************************************************
+* This function verifies that the partitioning was computed correctly
+**************************************************************************/
+int VerifyPart(int nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, 
+               idxtype *adjwgt, int nparts, int edgecut, idxtype *part)
+{
+  int i, j, k, cut, vfree=0, efree=0, rcode=0;
+  idxtype *pwgts;
+
+  if (part[idxamax(nvtxs, part)] != nparts-1)
+    return 1;  /* the total number of partitions is different than nparts */
+
+  /* compute the cut and the pwgts */
+  if (vwgt == NULL) {
+    vfree = 1;
+    vwgt = idxsmalloc(nvtxs, 1, "vwgt");
+  }
+  if (adjwgt == NULL) {
+    efree = 1;
+    adjwgt = idxsmalloc(xadj[nvtxs], 1, "adjwgt");
+  }
+  pwgts = idxsmalloc(nparts, 0, "pwgts");
+
+  for (cut=0, i=0; i<nvtxs; i++) {
+    pwgts[part[i]] += vwgt[i];
+    for (j=xadj[i]; j<xadj[i+1]; j++) 
+      cut += (part[i] != part[adjncy[j]] ? adjwgt[j] : 0);
+  }
+
+  if (cut != 2*edgecut)
+    rcode = 2;
+
+  if (nparts*pwgts[idxamax(nparts, pwgts)] > 1.10*idxsum(nparts, pwgts))
+    rcode = 3;
+
+  if (vfree)
+    free(vwgt);
+
+  if (efree)
+    free(adjwgt);
+
+  free(pwgts);
+
+  MALLOC_CHECK(NULL);
+
+  return rcode;
+}
+
+
+/*************************************************************************
+* This function verifies that the partitioning was computed correctly
+**************************************************************************/
+int VerifyWPart(int nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, 
+                idxtype *adjwgt, int nparts, float *tpwgts, int edgecut, idxtype *part)
+{
+  int i, j, k, tvwgt, cut, vfree=0, efree=0, rcode=0;
+  idxtype *pwgts;
+
+  if (part[idxamax(nvtxs, part)] != nparts-1) 
+    return 1;  /* the total number of partitions is different than nparts */
+
+  /* compute the cut and the pwgts */
+  if (vwgt == NULL) {
+    vfree = 1;
+    vwgt = idxsmalloc(nvtxs, 1, "vwgt");
+  }
+  if (adjwgt == NULL) {
+    efree = 1;
+    adjwgt = idxsmalloc(xadj[nvtxs], 1, "adjwgt");
+  }
+  pwgts = idxsmalloc(nparts, 0, "pwgts");
+
+  for (cut=0, i=0; i<nvtxs; i++) {
+    pwgts[part[i]] += vwgt[i];
+    for (j=xadj[i]; j<xadj[i+1]; j++) 
+      cut += (part[i] != part[adjncy[j]] ? adjwgt[j] : 0);
+  }
+
+  if (cut != 2*edgecut)
+    rcode = 2;
+
+  tvwgt = idxsum(nparts, pwgts);
+  for (i=0; i<nparts; i++) {
+    if (pwgts[i] > 1.10*tpwgts[i]*tvwgt) {
+      rcode = 3;
+      break;
+    }
+  }
+
+  if (vfree)
+    free(vwgt);
+
+  if (efree)
+    free(adjwgt);
+
+  free(pwgts);
+
+  MALLOC_CHECK(NULL);
+
+  return rcode;
+}
+
+
+
+/*************************************************************************
+* This function tests the regular graph partitioning routines
+**************************************************************************/
+void Test_PartGraphV(int nvtxs, idxtype *xadj, idxtype *adjncy)
+{
+  int i, j, jj, k, tstnum, rcode;
+  int nparts, numflag, wgtflag, totalv, options[10];
+  idxtype *part, *vwgt, *vsize;
+  float tpwgts[256];
+
+  vwgt = idxmalloc(nvtxs, "vwgt");
+  for (i=0; i<nvtxs; i++)
+    vwgt[i] = RandomInRange(10);
+
+  vsize = idxmalloc(nvtxs, "vsize");
+  for (i=0; i<nvtxs; i++)
+    vsize[i] = RandomInRange(10);
+
+  part = idxmalloc(nvtxs, "part");
+
+  tpwgts[0] = .1;
+  tpwgts[1] = .2;
+  tpwgts[2] = .3;
+  tpwgts[3] = .1;
+  tpwgts[4] = .05;
+  tpwgts[5] = .25;
+
+
+  /*===========================================================================*/
+  printf("\nTesting METIS_PartGraphVKway ----------------------------------------\n  ");
+  tstnum = 1;
+
+/**/
+  numflag = 0; wgtflag = 0; nparts = 20;
+  options[0] = 0;
+  METIS_PartGraphVKway(&nvtxs, xadj, adjncy, NULL, NULL, &wgtflag, &numflag,
+                       &nparts, options, &totalv, part);
+
+  if ((rcode = VerifyPartV(nvtxs, xadj, adjncy, NULL, NULL, nparts, totalv, part)) == 0)
+    printf("[%d:ok]", tstnum++);
+  else
+    printf("[%d:err-%d]", tstnum++, rcode);
+  fflush(stdout);
+
+
+/**/
+  numflag = 0; wgtflag = 1; nparts = 20;
+  options[0] = 0;
+  METIS_PartGraphVKway(&nvtxs, xadj, adjncy, NULL, vsize, &wgtflag, &numflag,
+                       &nparts, options, &totalv, part);
+
+  if ((rcode = VerifyPartV(nvtxs, xadj, adjncy, NULL, vsize, nparts, totalv, part)) == 0)
+    printf("[%d:ok]", tstnum++);
+  else
+    printf("[%d:err-%d]", tstnum++, rcode);
+  fflush(stdout);
+
+
+/**/
+  numflag = 0; wgtflag = 2; nparts = 20;
+  options[0] = 0;
+  METIS_PartGraphVKway(&nvtxs, xadj, adjncy, vwgt, NULL, &wgtflag, &numflag,
+                       &nparts, options, &totalv, part);
+
+  if ((rcode = VerifyPartV(nvtxs, xadj, adjncy, vwgt, NULL, nparts, totalv, part)) == 0)
+    printf("[%d:ok]", tstnum++);
+  else
+    printf("[%d:err-%d]", tstnum++, rcode);
+  fflush(stdout);
+
+
+/**/
+  numflag = 0; wgtflag = 3; nparts = 20;
+  options[0] = 0;
+  METIS_PartGraphVKway(&nvtxs, xadj, adjncy, vwgt, vsize, &wgtflag, &numflag,
+                       &nparts, options, &totalv, part);
+
+  if ((rcode = VerifyPartV(nvtxs, xadj, adjncy, vwgt, vsize, nparts, totalv, part)) == 0)
+    printf("[%d:ok]", tstnum++);
+  else
+    printf("[%d:err-%d]", tstnum++, rcode);
+  fflush(stdout);
+
+
+/**/
+  numflag = 0; wgtflag = 3; nparts = 20;
+  options[0] = 1; options[1] = 1; options[2] = 1; options[3] = 1; options[4] = 0;
+  METIS_PartGraphVKway(&nvtxs, xadj, adjncy, vwgt, vsize, &wgtflag, &numflag,
+                       &nparts, options, &totalv, part);
+
+  if ((rcode = VerifyPartV(nvtxs, xadj, adjncy, vwgt, vsize, nparts, totalv, part)) == 0)
+    printf("[%d:ok]", tstnum++);
+  else
+    printf("[%d:err-%d]", tstnum++, rcode);
+  fflush(stdout);
+
+
+/**/
+  numflag = 0; wgtflag = 3; nparts = 20;
+  options[0] = 1; options[1] = 2; options[2] = 1; options[3] = 1; options[4] = 0;
+  METIS_PartGraphVKway(&nvtxs, xadj, adjncy, vwgt, vsize, &wgtflag, &numflag,
+                       &nparts, options, &totalv, part);
+
+  if ((rcode = VerifyPartV(nvtxs, xadj, adjncy, vwgt, vsize, nparts, totalv, part)) == 0)
+    printf("[%d:ok]", tstnum++);
+  else
+    printf("[%d:err-%d]", tstnum++, rcode);
+  fflush(stdout);
+
+
+/**/
+  numflag = 0; wgtflag = 3; nparts = 20;
+  options[0] = 1; options[1] = 3; options[2] = 1; options[3] = 3; options[4] = 0;
+  METIS_PartGraphVKway(&nvtxs, xadj, adjncy, vwgt, vsize, &wgtflag, &numflag,
+                       &nparts, options, &totalv, part);
+
+  if ((rcode = VerifyPartV(nvtxs, xadj, adjncy, vwgt, vsize, nparts, totalv, part)) == 0)
+    printf("[%d:ok]", tstnum++);
+  else
+    printf("[%d:err-%d]", tstnum++, rcode);
+  fflush(stdout);
+
+  printf("\n");
+
+
+ 
+  /*===========================================================================*/
+  printf("\nTesting METIS_WPartGraphVKway ---------------------------------------\n  ");
+  tstnum = 1;
+
+
+/**/
+  numflag = 0; wgtflag = 0; nparts = 6;
+  options[0] = 0;
+  METIS_WPartGraphVKway(&nvtxs, xadj, adjncy, NULL, NULL, &wgtflag, &numflag,
+                        &nparts, tpwgts, options, &totalv, part);
+
+  if ((rcode = VerifyWPartV(nvtxs, xadj, adjncy, NULL, NULL, nparts, tpwgts, totalv, part)) == 0)
+    printf("[%d:ok]", tstnum++);
+  else
+    printf("[%d:err-%d]", tstnum++, rcode);
+  fflush(stdout);
+
+
+/**/
+  numflag = 0; wgtflag = 1; nparts = 6;
+  options[0] = 0;
+  METIS_WPartGraphVKway(&nvtxs, xadj, adjncy, NULL, vsize, &wgtflag, &numflag,
+                        &nparts, tpwgts, options, &totalv, part);
+
+  if ((rcode = VerifyWPartV(nvtxs, xadj, adjncy, NULL, vsize, nparts, tpwgts, totalv, part)) == 0)
+    printf("[%d:ok]", tstnum++);
+  else
+    printf("[%d:err-%d]", tstnum++, rcode);
+  fflush(stdout);
+
+
+/**/
+  numflag = 0; wgtflag = 2; nparts = 6;
+  options[0] = 0;
+  METIS_WPartGraphVKway(&nvtxs, xadj, adjncy, vwgt, NULL, &wgtflag, &numflag,
+                        &nparts, tpwgts, options, &totalv, part);
+
+  if ((rcode = VerifyWPartV(nvtxs, xadj, adjncy, vwgt, NULL, nparts, tpwgts, totalv, part)) == 0)
+    printf("[%d:ok]", tstnum++);
+  else
+    printf("[%d:err-%d]", tstnum++, rcode);
+  fflush(stdout);
+
+
+/**/
+  numflag = 0; wgtflag = 3; nparts = 6;
+  options[0] = 0;
+  METIS_WPartGraphVKway(&nvtxs, xadj, adjncy, vwgt, vsize, &wgtflag, &numflag,
+                        &nparts, tpwgts, options, &totalv, part);
+
+  if ((rcode = VerifyWPartV(nvtxs, xadj, adjncy, vwgt, vsize, nparts, tpwgts, totalv, part)) == 0)
+    printf("[%d:ok]", tstnum++);
+  else
+    printf("[%d:err-%d]", tstnum++, rcode);
+  fflush(stdout);
+
+
+/**/
+  numflag = 0; wgtflag = 3; nparts = 6;
+  options[0] = 1; options[1] = 1; options[2] = 1; options[3] = 1; options[4] = 0;
+  METIS_WPartGraphVKway(&nvtxs, xadj, adjncy, vwgt, vsize, &wgtflag, &numflag,
+                        &nparts, tpwgts, options, &totalv, part);
+
+  if ((rcode = VerifyWPartV(nvtxs, xadj, adjncy, vwgt, vsize, nparts, tpwgts, totalv, part)) == 0)
+    printf("[%d:ok]", tstnum++);
+  else
+    printf("[%d:err-%d]", tstnum++, rcode);
+  fflush(stdout);
+
+
+/**/
+  numflag = 0; wgtflag = 3; nparts = 6;
+  options[0] = 1; options[1] = 2; options[2] = 1; options[3] = 1; options[4] = 0;
+  METIS_WPartGraphVKway(&nvtxs, xadj, adjncy, vwgt, vsize, &wgtflag, &numflag,
+                        &nparts, tpwgts, options, &totalv, part);
+
+  if ((rcode = VerifyWPartV(nvtxs, xadj, adjncy, vwgt, vsize, nparts, tpwgts, totalv, part)) == 0)
+    printf("[%d:ok]", tstnum++);
+  else
+    printf("[%d:err-%d]", tstnum++, rcode);
+  fflush(stdout);
+
+
+/**/
+  numflag = 0; wgtflag = 3; nparts = 6;
+  options[0] = 1; options[1] = 2; options[2] = 1; options[3] = 3; options[4] = 0;
+  METIS_WPartGraphVKway(&nvtxs, xadj, adjncy, vwgt, vsize, &wgtflag, &numflag,
+                        &nparts, tpwgts, options, &totalv, part);
+
+  if ((rcode = VerifyWPartV(nvtxs, xadj, adjncy, vwgt, vsize, nparts, tpwgts, totalv, part)) == 0)
+    printf("[%d:ok]", tstnum++);
+  else
+    printf("[%d:err-%d]", tstnum++, rcode);
+  fflush(stdout);
+
+  printf("\n");
+
+
+  GKfree(&vwgt, &vsize, &part, LTERM);
+}
+
+
+/*************************************************************************
+* This function verifies that the partitioning was computed correctly
+**************************************************************************/
+int VerifyPartV(int nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, 
+               idxtype *vsize, int nparts, int totalv, idxtype *part)
+{
+  int i, j, k, ttlv, vfree=0, efree=0, rcode=0;
+  idxtype *pwgts, *marker;
+
+  if (part[idxamax(nvtxs, part)] != nparts-1)
+    return 1;  /* the total number of partitions is different than nparts */
+
+  /* compute the cut and the pwgts */
+  if (vwgt == NULL) {
+    vfree = 1;
+    vwgt = idxsmalloc(nvtxs, 1, "vwgt");
+  }
+  if (vsize == NULL) {
+    efree = 1;
+    vsize = idxsmalloc(nvtxs, 1, "vsize");
+  }
+  pwgts = idxsmalloc(nparts, 0, "pwgts");
+
+  marker = idxsmalloc(nparts, -1, "htable");
+  for (ttlv=0, i=0; i<nvtxs; i++) {
+    pwgts[part[i]] += vwgt[i];
+    marker[part[i]] = i;
+    for (j=xadj[i]; j<xadj[i+1]; j++) {
+      if (marker[part[adjncy[j]]] != i) {
+        ttlv += vsize[i];
+        marker[part[adjncy[j]]] = i;
+      }
+    }
+  }
+
+  if (ttlv != totalv)
+    rcode = 2;
+
+  if (nparts*pwgts[idxamax(nparts, pwgts)] > 1.05*idxsum(nparts, pwgts))
+    rcode = 3;
+
+  if (vfree)
+    free(vwgt);
+
+  if (efree)
+    free(vsize);
+
+  free(pwgts);
+  free(marker);
+
+  MALLOC_CHECK(NULL);
+
+  return rcode;
+}
+
+
+/*************************************************************************
+* This function verifies that the partitioning was computed correctly
+**************************************************************************/
+int VerifyWPartV(int nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, 
+                idxtype *vsize, int nparts, float *tpwgts, int totalv, idxtype *part)
+{
+  int i, j, k, tvwgt, ttlv, vfree=0, efree=0, rcode=0;
+  idxtype *pwgts, *marker;
+
+  if (part[idxamax(nvtxs, part)] != nparts-1) 
+    return 1;  /* the total number of partitions is different than nparts */
+
+  /* compute the cut and the pwgts */
+  if (vwgt == NULL) {
+    vfree = 1;
+    vwgt = idxsmalloc(nvtxs, 1, "vwgt");
+  }
+  if (vsize == NULL) {
+    efree = 1;
+    vsize = idxsmalloc(nvtxs, 1, "vsize");
+  }
+  pwgts = idxsmalloc(nparts, 0, "pwgts");
+
+  marker = idxsmalloc(nparts, -1, "htable");
+  for (ttlv=0, i=0; i<nvtxs; i++) {
+    pwgts[part[i]] += vwgt[i];
+    marker[part[i]] = i;
+    for (j=xadj[i]; j<xadj[i+1]; j++) {
+      if (marker[part[adjncy[j]]] != i) {
+        ttlv += vsize[i];
+        marker[part[adjncy[j]]] = i;
+      }
+    }
+  }
+
+  if (ttlv != totalv)
+    rcode = 2;
+
+  tvwgt = idxsum(nparts, pwgts);
+  for (i=0; i<nparts; i++) {
+    if (pwgts[i] > 1.05*tpwgts[i]*tvwgt) {
+      rcode = 3;
+      break;
+    }
+  }
+
+  if (vfree)
+    free(vwgt);
+
+  if (efree)
+    free(vsize);
+
+  free(pwgts);
+  free(marker);
+
+  MALLOC_CHECK(NULL);
+
+  return rcode;
+}
+
+
+
+/*************************************************************************
+* This function tests the regular graph partitioning routines
+**************************************************************************/
+void Test_PartGraphmC(int nvtxs, idxtype *xadj, idxtype *adjncy)
+{
+  int i, j, jj, k, tstnum, rcode;
+  int nparts, ncon, numflag, wgtflag, edgecut, options[10];
+  idxtype *part, *vwgt, *adjwgt;
+  float ubvec[MAXNCON];
+
+  ncon = 3;
+
+  vwgt = idxmalloc(nvtxs*ncon, "vwgt");
+  for (i=0; i<ncon*nvtxs; i++)
+    vwgt[i] = RandomInRange(10);
+
+  adjwgt = idxmalloc(xadj[nvtxs], "adjwgt");
+  for (i=0; i<nvtxs; i++) {
+    for (j=xadj[i]; j<xadj[i+1]; j++) {
+      k = adjncy[j];
+      if (i < k) {
+        adjwgt[j] = 1+RandomInRange(5);
+        for (jj=xadj[k]; jj<xadj[k+1]; jj++) {
+          if (adjncy[jj] == i) {
+            adjwgt[jj] = adjwgt[j];
+            break;
+          }
+        }
+      }
+    }
+  }
+
+
+  part = idxmalloc(nvtxs, "part");
+
+
+
+  /*===========================================================================*/
+  printf("\nTesting METIS_mCPartGraphRecursive ----------------------------------\n  ");
+  tstnum = 1;
+
+/**/
+  numflag = 0; wgtflag = 0; nparts = 10;
+  ubvec[0] = 1.05; ubvec[1] = 1.05; ubvec[2] = 1.05;
+  options[0] = 0;
+  METIS_mCPartGraphRecursive(&nvtxs, &ncon, xadj, adjncy, vwgt, NULL, &wgtflag, &numflag,
+                             &nparts, options, &edgecut, part);
+
+  if ((rcode = VerifyPartmC(nvtxs, ncon, xadj, adjncy, vwgt, NULL, nparts, ubvec, edgecut, part)) == 0)
+    printf("[%d:ok]", tstnum++);
+  else
+    printf("[%d:err-%d]", tstnum++, rcode);
+  fflush(stdout);
+
+
+/**/
+  numflag = 0; wgtflag = 1; nparts = 10;
+  ubvec[0] = 1.05; ubvec[1] = 1.05; ubvec[2] = 1.05;
+  options[0] = 0;
+  METIS_mCPartGraphRecursive(&nvtxs, &ncon, xadj, adjncy, vwgt, adjwgt, &wgtflag, &numflag,
+                             &nparts, options, &edgecut, part);
+
+  if ((rcode = VerifyPartmC(nvtxs, ncon, xadj, adjncy, vwgt, adjwgt, nparts, ubvec, edgecut, part)) == 0)
+    printf("[%d:ok]", tstnum++);
+  else
+    printf("[%d:err-%d]", tstnum++, rcode);
+  fflush(stdout);
+
+
+/**/
+  numflag = 0; wgtflag = 1; nparts = 10;
+  ubvec[0] = 1.05; ubvec[1] = 1.05; ubvec[2] = 1.05;
+  options[0] = 1; options[1] = 1; options[2] = 1; options[3] = 1; options[4] = 0;
+  METIS_mCPartGraphRecursive(&nvtxs, &ncon, xadj, adjncy, vwgt, adjwgt, &wgtflag, &numflag,
+                             &nparts, options, &edgecut, part);
+
+  if ((rcode = VerifyPartmC(nvtxs, ncon, xadj, adjncy, vwgt, adjwgt, nparts, ubvec, edgecut, part)) == 0)
+    printf("[%d:ok]", tstnum++);
+  else
+    printf("[%d:err-%d]", tstnum++, rcode);
+  fflush(stdout);
+
+
+/**/
+  numflag = 0; wgtflag = 1; nparts = 10;
+  ubvec[0] = 1.05; ubvec[1] = 1.05; ubvec[2] = 1.05;
+  options[0] = 1; options[1] = 2; options[2] = 1; options[3] = 1; options[4] = 0;
+  METIS_mCPartGraphRecursive(&nvtxs, &ncon, xadj, adjncy, vwgt, adjwgt, &wgtflag, &numflag,
+                             &nparts, options, &edgecut, part);
+
+  if ((rcode = VerifyPartmC(nvtxs, ncon, xadj, adjncy, vwgt, adjwgt, nparts, ubvec, edgecut, part)) == 0)
+    printf("[%d:ok]", tstnum++);
+  else
+    printf("[%d:err-%d]", tstnum++, rcode);
+  fflush(stdout);
+
+
+/**/
+  numflag = 0; wgtflag = 1; nparts = 10;
+  ubvec[0] = 1.05; ubvec[1] = 1.05; ubvec[2] = 1.05;
+  options[0] = 1; options[1] = 3; options[2] = 1; options[3] = 1; options[4] = 0;
+  METIS_mCPartGraphRecursive(&nvtxs, &ncon, xadj, adjncy, vwgt, adjwgt, &wgtflag, &numflag,
+                             &nparts, options, &edgecut, part);
+
+  if ((rcode = VerifyPartmC(nvtxs, ncon, xadj, adjncy, vwgt, adjwgt, nparts, ubvec, edgecut, part)) == 0)
+    printf("[%d:ok]", tstnum++);
+  else
+    printf("[%d:err-%d]", tstnum++, rcode);
+  fflush(stdout);
+
+
+/**/
+  numflag = 0; wgtflag = 1; nparts = 10;
+  ubvec[0] = 1.05; ubvec[1] = 1.05; ubvec[2] = 1.05;
+  options[0] = 1; options[1] = 4; options[2] = 1; options[3] = 1; options[4] = 0;
+  METIS_mCPartGraphRecursive(&nvtxs, &ncon, xadj, adjncy, vwgt, adjwgt, &wgtflag, &numflag,
+                             &nparts, options, &edgecut, part);
+
+  if ((rcode = VerifyPartmC(nvtxs, ncon, xadj, adjncy, vwgt, adjwgt, nparts, ubvec, edgecut, part)) == 0)
+    printf("[%d:ok]", tstnum++);
+  else
+    printf("[%d:err-%d]", tstnum++, rcode);
+  fflush(stdout);
+
+
+/**/
+  numflag = 0; wgtflag = 1; nparts = 10;
+  ubvec[0] = 1.05; ubvec[1] = 1.05; ubvec[2] = 1.05;
+  options[0] = 1; options[1] = 5; options[2] = 1; options[3] = 1; options[4] = 0;
+  METIS_mCPartGraphRecursive(&nvtxs, &ncon, xadj, adjncy, vwgt, adjwgt, &wgtflag, &numflag,
+                             &nparts, options, &edgecut, part);
+
+  if ((rcode = VerifyPartmC(nvtxs, ncon, xadj, adjncy, vwgt, adjwgt, nparts, ubvec, edgecut, part)) == 0)
+    printf("[%d:ok]", tstnum++);
+  else
+    printf("[%d:err-%d]", tstnum++, rcode);
+  fflush(stdout);
+
+
+/**/
+  numflag = 0; wgtflag = 1; nparts = 10;
+  ubvec[0] = 1.05; ubvec[1] = 1.05; ubvec[2] = 1.05;
+  options[0] = 1; options[1] = 6; options[2] = 1; options[3] = 1; options[4] = 0;
+  METIS_mCPartGraphRecursive(&nvtxs, &ncon, xadj, adjncy, vwgt, adjwgt, &wgtflag, &numflag,
+                             &nparts, options, &edgecut, part);
+
+  if ((rcode = VerifyPartmC(nvtxs, ncon, xadj, adjncy, vwgt, adjwgt, nparts, ubvec, edgecut, part)) == 0)
+    printf("[%d:ok]", tstnum++);
+  else
+    printf("[%d:err-%d]", tstnum++, rcode);
+  fflush(stdout);
+
+
+/**/
+  numflag = 0; wgtflag = 1; nparts = 10;
+  ubvec[0] = 1.05; ubvec[1] = 1.05; ubvec[2] = 1.05;
+  options[0] = 1; options[1] = 7; options[2] = 1; options[3] = 1; options[4] = 0;
+  METIS_mCPartGraphRecursive(&nvtxs, &ncon, xadj, adjncy, vwgt, adjwgt, &wgtflag, &numflag,
+                             &nparts, options, &edgecut, part);
+
+  if ((rcode = VerifyPartmC(nvtxs, ncon, xadj, adjncy, vwgt, adjwgt, nparts, ubvec, edgecut, part)) == 0)
+    printf("[%d:ok]", tstnum++);
+  else
+    printf("[%d:err-%d]", tstnum++, rcode);
+  fflush(stdout);
+
+
+/**/
+  numflag = 0; wgtflag = 1; nparts = 10;
+  ubvec[0] = 1.05; ubvec[1] = 1.05; ubvec[2] = 1.05;
+  options[0] = 1; options[1] = 8; options[2] = 1; options[3] = 1; options[4] = 0;
+  METIS_mCPartGraphRecursive(&nvtxs, &ncon, xadj, adjncy, vwgt, adjwgt, &wgtflag, &numflag,
+                             &nparts, options, &edgecut, part);
+
+  if ((rcode = VerifyPartmC(nvtxs, ncon, xadj, adjncy, vwgt, adjwgt, nparts, ubvec, edgecut, part)) == 0)
+    printf("[%d:ok]", tstnum++);
+  else
+    printf("[%d:err-%d]", tstnum++, rcode);
+  fflush(stdout);
+
+  printf("\n  ");
+
+/**/
+  numflag = 0; wgtflag = 1; nparts = 10;
+  ubvec[0] = 1.05; ubvec[1] = 1.05; ubvec[2] = 1.05;
+  options[0] = 1; options[1] = 4; options[2] = 2; options[3] = 1; options[4] = 0;
+  METIS_mCPartGraphRecursive(&nvtxs, &ncon, xadj, adjncy, vwgt, adjwgt, &wgtflag, &numflag,
+                             &nparts, options, &edgecut, part);
+
+  if ((rcode = VerifyPartmC(nvtxs, ncon, xadj, adjncy, vwgt, adjwgt, nparts, ubvec, edgecut, part)) == 0)
+    printf("[%d:ok]", tstnum++);
+  else
+    printf("[%d:err-%d]", tstnum++, rcode);
+  fflush(stdout);
+
+
+/**/
+  numflag = 0; wgtflag = 1; nparts = 10;
+  ubvec[0] = 1.05; ubvec[1] = 1.05; ubvec[2] = 1.05;
+  options[0] = 1; options[1] = 3; options[2] = 2; options[3] = 1; options[4] = 0;
+  METIS_mCPartGraphRecursive(&nvtxs, &ncon, xadj, adjncy, vwgt, adjwgt, &wgtflag, &numflag,
+                             &nparts, options, &edgecut, part);
+
+  if ((rcode = VerifyPartmC(nvtxs, ncon, xadj, adjncy, vwgt, adjwgt, nparts, ubvec, edgecut, part)) == 0)
+    printf("[%d:ok]", tstnum++);
+  else
+    printf("[%d:err-%d]", tstnum++, rcode);
+  fflush(stdout);
+
+  printf("\n");
+
+
+
+  printf("\nTesting METIS_mCPartGraphKway ---------------------------------------\n  ");
+  tstnum = 1;
+
+/**/
+  numflag = 0; wgtflag = 0; nparts = 10;
+  ubvec[0] = 1.05; ubvec[1] = 1.05; ubvec[2] = 1.05;
+  options[0] = 0;
+  METIS_mCPartGraphKway(&nvtxs, &ncon, xadj, adjncy, vwgt, NULL, &wgtflag, &numflag,
+                        &nparts, ubvec, options, &edgecut, part);
+
+  if ((rcode = VerifyPartmC(nvtxs, ncon, xadj, adjncy, vwgt, NULL, nparts, ubvec, edgecut, part)) == 0)
+    printf("[%d:ok]", tstnum++);
+  else
+    printf("[%d:err-%d]", tstnum++, rcode);
+  fflush(stdout);
+
+
+/**/
+  numflag = 0; wgtflag = 1; nparts = 10;
+  ubvec[0] = 1.05; ubvec[1] = 1.05; ubvec[2] = 1.05;
+  options[0] = 0;
+  METIS_mCPartGraphKway(&nvtxs, &ncon, xadj, adjncy, vwgt, adjwgt, &wgtflag, &numflag,
+                        &nparts, ubvec, options, &edgecut, part);
+
+  if ((rcode = VerifyPartmC(nvtxs, ncon, xadj, adjncy, vwgt, adjwgt, nparts, ubvec, edgecut, part)) == 0)
+    printf("[%d:ok]", tstnum++);
+  else
+    printf("[%d:err-%d]", tstnum++, rcode);
+  fflush(stdout);
+
+
+/**/
+  numflag = 0; wgtflag = 1; nparts = 10;
+  ubvec[0] = 1.05; ubvec[1] = 1.05; ubvec[2] = 1.05;
+  options[0] = 1; options[1] = 1; options[2] = 1; options[3] = 1; options[4] = 0;
+  METIS_mCPartGraphKway(&nvtxs, &ncon, xadj, adjncy, vwgt, adjwgt, &wgtflag, &numflag,
+                        &nparts, ubvec, options, &edgecut, part);
+
+  if ((rcode = VerifyPartmC(nvtxs, ncon, xadj, adjncy, vwgt, adjwgt, nparts, ubvec, edgecut, part)) == 0)
+    printf("[%d:ok]", tstnum++);
+  else
+    printf("[%d:err-%d]", tstnum++, rcode);
+  fflush(stdout);
+
+
+/**/
+  numflag = 0; wgtflag = 1; nparts = 10;
+  ubvec[0] = 1.05; ubvec[1] = 1.05; ubvec[2] = 1.05;
+  options[0] = 1; options[1] = 2; options[2] = 1; options[3] = 1; options[4] = 0;
+  METIS_mCPartGraphKway(&nvtxs, &ncon, xadj, adjncy, vwgt, adjwgt, &wgtflag, &numflag,
+                        &nparts, ubvec, options, &edgecut, part);
+
+  if ((rcode = VerifyPartmC(nvtxs, ncon, xadj, adjncy, vwgt, adjwgt, nparts, ubvec, edgecut, part)) == 0)
+    printf("[%d:ok]", tstnum++);
+  else
+    printf("[%d:err-%d]", tstnum++, rcode);
+  fflush(stdout);
+
+
+/**/
+  numflag = 0; wgtflag = 1; nparts = 10;
+  ubvec[0] = 1.05; ubvec[1] = 1.05; ubvec[2] = 1.05;
+  options[0] = 1; options[1] = 3; options[2] = 1; options[3] = 1; options[4] = 0;
+  METIS_mCPartGraphKway(&nvtxs, &ncon, xadj, adjncy, vwgt, adjwgt, &wgtflag, &numflag,
+                        &nparts, ubvec, options, &edgecut, part);
+
+  if ((rcode = VerifyPartmC(nvtxs, ncon, xadj, adjncy, vwgt, adjwgt, nparts, ubvec, edgecut, part)) == 0)
+    printf("[%d:ok]", tstnum++);
+  else
+    printf("[%d:err-%d]", tstnum++, rcode);
+  fflush(stdout);
+
+
+/**/
+  numflag = 0; wgtflag = 1; nparts = 10;
+  ubvec[0] = 1.05; ubvec[1] = 1.05; ubvec[2] = 1.05;
+  options[0] = 1; options[1] = 4; options[2] = 1; options[3] = 1; options[4] = 0;
+  METIS_mCPartGraphKway(&nvtxs, &ncon, xadj, adjncy, vwgt, adjwgt, &wgtflag, &numflag,
+                        &nparts, ubvec, options, &edgecut, part);
+
+  if ((rcode = VerifyPartmC(nvtxs, ncon, xadj, adjncy, vwgt, adjwgt, nparts, ubvec, edgecut, part)) == 0)
+    printf("[%d:ok]", tstnum++);
+  else
+    printf("[%d:err-%d]", tstnum++, rcode);
+  fflush(stdout);
+
+
+/**/
+  numflag = 0; wgtflag = 1; nparts = 10;
+  ubvec[0] = 1.05; ubvec[1] = 1.05; ubvec[2] = 1.05;
+  options[0] = 1; options[1] = 5; options[2] = 1; options[3] = 1; options[4] = 0;
+  METIS_mCPartGraphKway(&nvtxs, &ncon, xadj, adjncy, vwgt, adjwgt, &wgtflag, &numflag,
+                        &nparts, ubvec, options, &edgecut, part);
+
+  if ((rcode = VerifyPartmC(nvtxs, ncon, xadj, adjncy, vwgt, adjwgt, nparts, ubvec, edgecut, part)) == 0)
+    printf("[%d:ok]", tstnum++);
+  else
+    printf("[%d:err-%d]", tstnum++, rcode);
+  fflush(stdout);
+
+
+/**/
+  numflag = 0; wgtflag = 1; nparts = 10;
+  ubvec[0] = 1.05; ubvec[1] = 1.05; ubvec[2] = 1.05;
+  options[0] = 1; options[1] = 6; options[2] = 1; options[3] = 1; options[4] = 0;
+  METIS_mCPartGraphKway(&nvtxs, &ncon, xadj, adjncy, vwgt, adjwgt, &wgtflag, &numflag,
+                        &nparts, ubvec, options, &edgecut, part);
+
+  if ((rcode = VerifyPartmC(nvtxs, ncon, xadj, adjncy, vwgt, adjwgt, nparts, ubvec, edgecut, part)) == 0)
+    printf("[%d:ok]", tstnum++);
+  else
+    printf("[%d:err-%d]", tstnum++, rcode);
+  fflush(stdout);
+
+
+/**/
+  numflag = 0; wgtflag = 1; nparts = 10;
+  ubvec[0] = 1.05; ubvec[1] = 1.05; ubvec[2] = 1.05;
+  options[0] = 1; options[1] = 7; options[2] = 1; options[3] = 1; options[4] = 0;
+  METIS_mCPartGraphKway(&nvtxs, &ncon, xadj, adjncy, vwgt, adjwgt, &wgtflag, &numflag,
+                        &nparts, ubvec, options, &edgecut, part);
+
+  if ((rcode = VerifyPartmC(nvtxs, ncon, xadj, adjncy, vwgt, adjwgt, nparts, ubvec, edgecut, part)) == 0)
+    printf("[%d:ok]", tstnum++);
+  else
+    printf("[%d:err-%d]", tstnum++, rcode);
+  fflush(stdout);
+
+
+/**/
+  numflag = 0; wgtflag = 1; nparts = 10;
+  ubvec[0] = 1.05; ubvec[1] = 1.05; ubvec[2] = 1.05;
+  options[0] = 1; options[1] = 8; options[2] = 1; options[3] = 1; options[4] = 0;
+  METIS_mCPartGraphKway(&nvtxs, &ncon, xadj, adjncy, vwgt, adjwgt, &wgtflag, &numflag,
+                        &nparts, ubvec, options, &edgecut, part);
+
+  if ((rcode = VerifyPartmC(nvtxs, ncon, xadj, adjncy, vwgt, adjwgt, nparts, ubvec, edgecut, part)) == 0)
+    printf("[%d:ok]", tstnum++);
+  else
+    printf("[%d:err-%d]", tstnum++, rcode);
+  fflush(stdout);
+
+  printf("\n  ");
+
+/**/
+  numflag = 0; wgtflag = 1; nparts = 10;
+  ubvec[0] = 1.05; ubvec[1] = 1.05; ubvec[2] = 1.05;
+  options[0] = 1; options[1] = 6; options[2] = 2; options[3] = 1; options[4] = 0;
+  METIS_mCPartGraphKway(&nvtxs, &ncon, xadj, adjncy, vwgt, adjwgt, &wgtflag, &numflag,
+                        &nparts, ubvec, options, &edgecut, part);
+
+  if ((rcode = VerifyPartmC(nvtxs, ncon, xadj, adjncy, vwgt, adjwgt, nparts, ubvec, edgecut, part)) == 0)
+    printf("[%d:ok]", tstnum++);
+  else
+    printf("[%d:err-%d]", tstnum++, rcode);
+  fflush(stdout);
+
+
+/**/
+  numflag = 0; wgtflag = 1; nparts = 10;
+  ubvec[0] = 1.05; ubvec[1] = 1.5; ubvec[2] = 1.05;
+  options[0] = 1; options[1] = 4; options[2] = 1; options[3] = 1; options[4] = 0;
+  METIS_mCPartGraphKway(&nvtxs, &ncon, xadj, adjncy, vwgt, adjwgt, &wgtflag, &numflag,
+                        &nparts, ubvec, options, &edgecut, part);
+
+  if ((rcode = VerifyPartmC(nvtxs, ncon, xadj, adjncy, vwgt, adjwgt, nparts, ubvec, edgecut, part)) == 0)
+    printf("[%d:ok]", tstnum++);
+  else
+    printf("[%d:err-%d]", tstnum++, rcode);
+  fflush(stdout);
+
+
+/**/
+  numflag = 0; wgtflag = 1; nparts = 10;
+  ubvec[0] = 1.05; ubvec[1] = 1.5; ubvec[2] = 1.5;
+  options[0] = 1; options[1] = 3; options[2] = 2; options[3] = 1; options[4] = 0;
+  METIS_mCPartGraphKway(&nvtxs, &ncon, xadj, adjncy, vwgt, adjwgt, &wgtflag, &numflag,
+                        &nparts, ubvec, options, &edgecut, part);
+
+  if ((rcode = VerifyPartmC(nvtxs, ncon, xadj, adjncy, vwgt, adjwgt, nparts, ubvec, edgecut, part)) == 0)
+    printf("[%d:ok]", tstnum++);
+  else
+    printf("[%d:err-%d]", tstnum++, rcode);
+  fflush(stdout);
+
+
+/**/
+  numflag = 0; wgtflag = 1; nparts = 10;
+  ubvec[0] = 2.05; ubvec[1] = 1.05; ubvec[2] = 1.05;
+  options[0] = 1; options[1] = 4; options[2] = 1; options[3] = 1; options[4] = 0;
+  METIS_mCPartGraphKway(&nvtxs, &ncon, xadj, adjncy, vwgt, adjwgt, &wgtflag, &numflag,
+                        &nparts, ubvec, options, &edgecut, part);
+
+  if ((rcode = VerifyPartmC(nvtxs, ncon, xadj, adjncy, vwgt, adjwgt, nparts, ubvec, edgecut, part)) == 0)
+    printf("[%d:ok]", tstnum++);
+  else
+    printf("[%d:err-%d]", tstnum++, rcode);
+  fflush(stdout);
+
+
+  printf("\n");
+
+  GKfree(&vwgt, &adjwgt, &part, LTERM);
+}
+
+
+
+/*************************************************************************
+* This function verifies that the partitioning was computed correctly
+**************************************************************************/
+int VerifyPartmC(int nvtxs, int ncon, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, 
+               idxtype *adjwgt, int nparts, float *ubvec, int edgecut, idxtype *part)
+{
+  int i, j, k, cut, efree=0, rcode=0;
+  idxtype *pwgts;
+  float lb;
+
+  if (part[idxamax(nvtxs, part)] != nparts-1)
+    return 1;  /* the total number of partitions is different than nparts */
+
+  if (adjwgt == NULL) {
+    efree = 1;
+    adjwgt = idxsmalloc(xadj[nvtxs], 1, "adjwgt");
+  }
+  pwgts = idxsmalloc(ncon*nparts, 0, "pwgts");
+
+  for (cut=0, i=0; i<nvtxs; i++) {
+    for (j=0; j<ncon; j++)
+      pwgts[part[i]*ncon+j] += vwgt[i*ncon+j];
+    for (j=xadj[i]; j<xadj[i+1]; j++) 
+      cut += (part[i] != part[adjncy[j]] ? adjwgt[j] : 0);
+  }
+
+  if (cut != 2*edgecut)
+    rcode = 2;
+
+/*
+printf("\n");
+for (i=0; i<nparts; i++) {
+  for (j=0; j<ncon; j++) 
+    printf("%5d ", pwgts[i*ncon+j]);
+  printf("\n");
+}
+printf("---------------------------------\n");
+for (j=0; j<ncon; j++) 
+  printf("%5d ", idxsum_strd(nparts, pwgts+j, ncon));
+printf("\n---------------------------------\n");
+for (j=0; j<ncon; j++) 
+  printf("%5d ", pwgts[ncon*idxamax_strd(nparts, pwgts+j, ncon)+j]);
+printf("\n%d %d\n", idxsum(ncon*nvtxs, vwgt), idxsum(ncon*nparts, pwgts));
+*/
+
+  for (i=0; i<ncon; i++) {
+    lb = 1.0*nparts*pwgts[ncon*idxamax_strd(nparts, pwgts+i, ncon)+i]/(1.0*idxsum_strd(nparts, pwgts+i, ncon));
+    /*printf("[%3.2f]", lb);*/
+    if (lb > ubvec[i])
+      rcode = 3;
+  }
+
+
+  if (efree)
+    free(adjwgt);
+
+  free(pwgts);
+
+  MALLOC_CHECK(NULL);
+
+  return rcode;
+}
+
+
+/*************************************************************************
+* This function tests the regular graph partitioning routines
+**************************************************************************/
+void Test_ND(int nvtxs, idxtype *xadj, idxtype *adjncy)
+{
+  int i, j, jj, k, tstnum, rcode;
+  int numflag, wgtflag, options[10];
+  idxtype *perm, *iperm, *vwgt;
+
+  vwgt = idxmalloc(nvtxs, "vwgt");
+  for (i=0; i<nvtxs; i++)
+    vwgt[i] = 1+RandomInRange(10);
+
+
+  perm = idxmalloc(nvtxs, "perm");
+  iperm = idxmalloc(nvtxs, "iperm");
+
+
+
+  /*===========================================================================*/
+  printf("\nTesting METIS_EdgeND ------------------------------------------------\n  ");
+  tstnum = 1;
+
+/**/
+  numflag = 0; 
+  options[0] = 0;
+  METIS_EdgeND(&nvtxs, xadj, adjncy, &numflag, options, perm, iperm);
+
+  if ((rcode = VerifyND(nvtxs, perm, iperm)) == 0)
+    printf("[%d:ok]", tstnum++);
+  else
+    printf("[%d:err-%d]", tstnum++, rcode);
+  fflush(stdout);
+
+
+/**/
+  numflag = 0; 
+  options[0] = 1; options[1] = 1; options[2] = 1; options[3] = 1; options[4] = 0;
+  METIS_EdgeND(&nvtxs, xadj, adjncy, &numflag, options, perm, iperm);
+
+  if ((rcode = VerifyND(nvtxs, perm, iperm)) == 0)
+    printf("[%d:ok]", tstnum++);
+  else
+    printf("[%d:err-%d]", tstnum++, rcode);
+  fflush(stdout);
+
+
+/**/
+  numflag = 0; 
+  options[0] = 1; options[1] = 2; options[2] = 1; options[3] = 1; options[4] = 0;
+  METIS_EdgeND(&nvtxs, xadj, adjncy, &numflag, options, perm, iperm);
+
+  if ((rcode = VerifyND(nvtxs, perm, iperm)) == 0)
+    printf("[%d:ok]", tstnum++);
+  else
+    printf("[%d:err-%d]", tstnum++, rcode);
+  fflush(stdout);
+
+  printf("\n");
+
+
+
+  /*===========================================================================*/
+  printf("\nTesting METIS_NodeND ------------------------------------------------\n  ");
+  tstnum = 1;
+
+/**/
+  numflag = 0; 
+  options[0] = 0;
+  METIS_NodeND(&nvtxs, xadj, adjncy, &numflag, options, perm, iperm);
+
+  if ((rcode = VerifyND(nvtxs, perm, iperm)) == 0)
+    printf("[%d:ok]", tstnum++);
+  else
+    printf("[%d:err-%d]", tstnum++, rcode);
+  fflush(stdout);
+
+
+/**/
+  numflag = 0; 
+  options[0] = 1; options[1] = 1; options[2] = 1; options[3] = 1; options[4] = 0;
+  options[5] = 0; options[6] = 0; options[7] = 1;
+  METIS_NodeND(&nvtxs, xadj, adjncy, &numflag, options, perm, iperm);
+
+  if ((rcode = VerifyND(nvtxs, perm, iperm)) == 0)
+    printf("[%d:ok]", tstnum++);
+  else
+    printf("[%d:err-%d]", tstnum++, rcode);
+  fflush(stdout);
+
+
+/**/
+  numflag = 0; 
+  options[0] = 1; options[1] = 2; options[2] = 1; options[3] = 1; options[4] = 0; 
+  options[5] = 0; options[6] = 0; options[7] = 1;
+  METIS_NodeND(&nvtxs, xadj, adjncy, &numflag, options, perm, iperm);
+
+  if ((rcode = VerifyND(nvtxs, perm, iperm)) == 0)
+    printf("[%d:ok]", tstnum++);
+  else
+    printf("[%d:err-%d]", tstnum++, rcode);
+  fflush(stdout);
+
+
+/**/
+  numflag = 0; 
+  options[0] = 1; options[1] = 3; options[2] = 1; options[3] = 1; options[4] = 0;
+  options[5] = 0; options[6] = 0; options[7] = 1;
+  METIS_NodeND(&nvtxs, xadj, adjncy, &numflag, options, perm, iperm);
+
+  if ((rcode = VerifyND(nvtxs, perm, iperm)) == 0)
+    printf("[%d:ok]", tstnum++);
+  else
+    printf("[%d:err-%d]", tstnum++, rcode);
+  fflush(stdout);
+
+
+/**/
+  numflag = 0; 
+  options[0] = 1; options[1] = 3; options[2] = 2; options[3] = 1; options[4] = 0;
+  options[5] = 0; options[6] = 0; options[7] = 1;
+  METIS_NodeND(&nvtxs, xadj, adjncy, &numflag, options, perm, iperm);
+
+  if ((rcode = VerifyND(nvtxs, perm, iperm)) == 0)
+    printf("[%d:ok]", tstnum++);
+  else
+    printf("[%d:err-%d]", tstnum++, rcode);
+  fflush(stdout);
+
+
+/**/
+  numflag = 0; 
+  options[0] = 1; options[1] = 3; options[2] = 1; options[3] = 2; options[4] = 0;
+  options[5] = 0; options[6] = 0; options[7] = 1;
+  METIS_NodeND(&nvtxs, xadj, adjncy, &numflag, options, perm, iperm);
+
+  if ((rcode = VerifyND(nvtxs, perm, iperm)) == 0)
+    printf("[%d:ok]", tstnum++);
+  else
+    printf("[%d:err-%d]", tstnum++, rcode);
+  fflush(stdout);
+
+
+/**/
+  numflag = 0; 
+  options[0] = 1; options[1] = 3; options[2] = 1; options[3] = 2; options[4] = 0;
+  options[5] = 1; options[6] = 0; options[7] = 1;
+  METIS_NodeND(&nvtxs, xadj, adjncy, &numflag, options, perm, iperm);
+
+  if ((rcode = VerifyND(nvtxs, perm, iperm)) == 0)
+    printf("[%d:ok]", tstnum++);
+  else
+    printf("[%d:err-%d]", tstnum++, rcode);
+  fflush(stdout);
+
+
+/**/
+  numflag = 0; 
+  options[0] = 1; options[1] = 3; options[2] = 1; options[3] = 2; options[4] = 0;
+  options[5] = 2; options[6] = 0; options[7] = 1;
+  METIS_NodeND(&nvtxs, xadj, adjncy, &numflag, options, perm, iperm);
+
+  if ((rcode = VerifyND(nvtxs, perm, iperm)) == 0)
+    printf("[%d:ok]", tstnum++);
+  else
+    printf("[%d:err-%d]", tstnum++, rcode);
+  fflush(stdout);
+
+
+/**/
+  numflag = 0; 
+  options[0] = 1; options[1] = 3; options[2] = 1; options[3] = 2; options[4] = 0;
+  options[5] = 3; options[6] = 0; options[7] = 1;
+  METIS_NodeND(&nvtxs, xadj, adjncy, &numflag, options, perm, iperm);
+
+  if ((rcode = VerifyND(nvtxs, perm, iperm)) == 0)
+    printf("[%d:ok]", tstnum++);
+  else
+    printf("[%d:err-%d]", tstnum++, rcode);
+  fflush(stdout);
+
+
+/**/
+  numflag = 0; 
+  options[0] = 1; options[1] = 3; options[2] = 1; options[3] = 2; options[4] = 0;
+  options[5] = 3; options[6] = 40; options[7] = 1;
+  METIS_NodeND(&nvtxs, xadj, adjncy, &numflag, options, perm, iperm);
+
+  if ((rcode = VerifyND(nvtxs, perm, iperm)) == 0)
+    printf("[%d:ok]", tstnum++);
+  else
+    printf("[%d:err-%d]", tstnum++, rcode);
+  fflush(stdout);
+
+  printf("\n  ");
+
+/**/
+  numflag = 0; 
+  options[0] = 1; options[1] = 3; options[2] = 1; options[3] = 2; options[4] = 0;
+  options[5] = 3; options[6] = 20; options[7] = 1;
+  METIS_NodeND(&nvtxs, xadj, adjncy, &numflag, options, perm, iperm);
+
+  if ((rcode = VerifyND(nvtxs, perm, iperm)) == 0)
+    printf("[%d:ok]", tstnum++);
+  else
+    printf("[%d:err-%d]", tstnum++, rcode);
+  fflush(stdout);
+
+
+/**/
+  numflag = 0; 
+  options[0] = 1; options[1] = 3; options[2] = 1; options[3] = 2; options[4] = 0;
+  options[5] = 3; options[6] = 20; options[7] = 2;
+  METIS_NodeND(&nvtxs, xadj, adjncy, &numflag, options, perm, iperm);
+
+  if ((rcode = VerifyND(nvtxs, perm, iperm)) == 0)
+    printf("[%d:ok]", tstnum++);
+  else
+    printf("[%d:err-%d]", tstnum++, rcode);
+  fflush(stdout);
+
+
+/**/
+  numflag = 0; 
+  options[0] = 1; options[1] = 3; options[2] = 1; options[3] = 2; options[4] = 0;
+  options[5] = 0; options[6] = 0; options[7] = 2;
+  METIS_NodeND(&nvtxs, xadj, adjncy, &numflag, options, perm, iperm);
+
+  if ((rcode = VerifyND(nvtxs, perm, iperm)) == 0)
+    printf("[%d:ok]", tstnum++);
+  else
+    printf("[%d:err-%d]", tstnum++, rcode);
+  fflush(stdout);
+
+  printf("\n");
+
+
+
+  /*===========================================================================*/
+  printf("\nTesting METIS_NodeWND -----------------------------------------------\n  ");
+  tstnum = 1;
+
+/**/
+  numflag = 0; 
+  options[0] = 0;
+  METIS_NodeWND(&nvtxs, xadj, adjncy, vwgt, &numflag, options, perm, iperm);
+
+  if ((rcode = VerifyND(nvtxs, perm, iperm)) == 0)
+    printf("[%d:ok]", tstnum++);
+  else
+    printf("[%d:err-%d]", tstnum++, rcode);
+  fflush(stdout);
+
+
+/**/
+  numflag = 0; 
+  options[0] = 1; options[1] = 1; options[2] = 1; options[3] = 1; options[4] = 0;
+  METIS_NodeWND(&nvtxs, xadj, adjncy, vwgt, &numflag, options, perm, iperm);
+
+  if ((rcode = VerifyND(nvtxs, perm, iperm)) == 0)
+    printf("[%d:ok]", tstnum++);
+  else
+    printf("[%d:err-%d]", tstnum++, rcode);
+  fflush(stdout);
+
+
+/**/
+  numflag = 0; 
+  options[0] = 1; options[1] = 2; options[2] = 1; options[3] = 1; options[4] = 0; 
+  METIS_NodeWND(&nvtxs, xadj, adjncy, vwgt, &numflag, options, perm, iperm);
+
+  if ((rcode = VerifyND(nvtxs, perm, iperm)) == 0)
+    printf("[%d:ok]", tstnum++);
+  else
+    printf("[%d:err-%d]", tstnum++, rcode);
+  fflush(stdout);
+
+
+/**/
+  numflag = 0; 
+  options[0] = 1; options[1] = 3; options[2] = 1; options[3] = 1; options[4] = 0;
+  METIS_NodeWND(&nvtxs, xadj, adjncy, vwgt, &numflag, options, perm, iperm);
+
+  if ((rcode = VerifyND(nvtxs, perm, iperm)) == 0)
+    printf("[%d:ok]", tstnum++);
+  else
+    printf("[%d:err-%d]", tstnum++, rcode);
+  fflush(stdout);
+
+
+/**/
+  numflag = 0; 
+  options[0] = 1; options[1] = 3; options[2] = 2; options[3] = 1; options[4] = 0;
+  METIS_NodeWND(&nvtxs, xadj, adjncy, vwgt, &numflag, options, perm, iperm);
+
+  if ((rcode = VerifyND(nvtxs, perm, iperm)) == 0)
+    printf("[%d:ok]", tstnum++);
+  else
+    printf("[%d:err-%d]", tstnum++, rcode);
+  fflush(stdout);
+
+
+/**/
+  numflag = 0; 
+  options[0] = 1; options[1] = 3; options[2] = 1; options[3] = 2; options[4] = 0;
+  METIS_NodeWND(&nvtxs, xadj, adjncy, vwgt, &numflag, options, perm, iperm);
+
+  if ((rcode = VerifyND(nvtxs, perm, iperm)) == 0)
+    printf("[%d:ok]", tstnum++);
+  else
+    printf("[%d:err-%d]", tstnum++, rcode);
+  fflush(stdout);
+
+  printf("\n");
+
+
+  GKfree(&vwgt, &perm, &iperm, LTERM);
+}
+
+
+
+/*************************************************************************
+* This function verifies that the partitioning was computed correctly
+**************************************************************************/
+int VerifyND(int nvtxs, idxtype *perm, idxtype *iperm)
+{
+  int i, j, k, rcode=0;
+
+  for (i=0; i<nvtxs; i++) {
+    if (i != perm[iperm[i]])
+      rcode = 1;
+  }
+
+  for (i=0; i<nvtxs; i++) {
+    if (i != iperm[perm[i]])
+      rcode = 2;
+  }
+
+  MALLOC_CHECK(NULL);
+
+  return rcode;
+}
+
+
Index: /inundation/pymetis/metis-4.0/VERSION
===================================================================
--- /inundation/pymetis/metis-4.0/VERSION	(revision 2051)
+++ /inundation/pymetis/metis-4.0/VERSION	(revision 2051)
@@ -0,0 +1,1 @@
+METIS 4.0.1	Mon Nov 30 10:27:29 CST 1998
Index: /inundation/pymetis/pymetis/bridge.h
===================================================================
--- /inundation/pymetis/pymetis/bridge.h	(revision 2051)
+++ /inundation/pymetis/pymetis/bridge.h	(revision 2051)
@@ -0,0 +1,1 @@
+void bridge_partMeshNodal(int *, int *, idxtype *, int *, int *, int *, int *, idxtype *, idxtype *);
Index: /inundation/pymetis/pymetis/get_module
===================================================================
--- /inundation/pymetis/pymetis/get_module	(revision 2051)
+++ /inundation/pymetis/pymetis/get_module	(revision 2051)
@@ -0,0 +1,12 @@
+#!/bin/bash
+
+cd build
+for X in $(ls -d lib.*)
+  do
+  cd ${X}
+  if [ -f metis.so ]
+      then
+      cp metis.so ../../../ -p
+      echo 'Found metis.so in ' ${X}
+  fi
+done
Index: /inundation/pymetis/pymetis/metis.c
===================================================================
--- /inundation/pymetis/pymetis/metis.c	(revision 2051)
+++ /inundation/pymetis/pymetis/metis.c	(revision 2051)
@@ -0,0 +1,84 @@
+#include <Python.h>
+#include <Numeric/arrayobject.h>
+
+/* This must be the same as the metis idxtype */
+typedef int idxtype;
+
+#include "bridge.h"
+
+static PyObject * metis_partMeshNodal(PyObject *, PyObject *);
+
+static PyMethodDef methods[] = {
+  {"partMeshNodal", metis_partMeshNodal, METH_VARARGS, "METIS_PartMeshNodal"},
+  {NULL, NULL, 0, NULL}
+};
+
+PyMODINIT_FUNC initmetis(void){
+  (void) Py_InitModule("metis", methods);
+
+  import_array();
+}
+
+/* Run the metis METIS_PartMeshNodal function
+ * expected args:
+ * ne: number of elements
+ * nn: number of nodes
+ * elmnts: element array
+ * etype: type of mesh elements:
+ ** 1 - triangle
+ ** 2 - tetrahedra
+ ** 3 - hexahedra
+ ** 4 - quadrilaterals
+ * nparts: number of partitions
+ * returns:
+ * edgecut: number of cut edges
+ * epart: partitioning of the elements
+ * npart: partitioning of the nodes.
+ */
+static PyObject * metis_partMeshNodal(PyObject * self, PyObject * args){
+  int ne;
+  int nn;
+  int etype;
+  int nparts;
+  int edgecut;
+  int numflag = 0; // The metis routine requires an int * for numflag.
+  int dims[1]; // PyArray_FromDimsAndData needs an int[] of array sizes.
+
+  PyObject * elements;
+  PyArrayObject * elem_arr;
+  PyArrayObject * epart_pyarr;
+  PyArrayObject * npart_pyarr;
+
+  /* These are all of the metis idxtype */
+  idxtype * epart;
+  idxtype * npart;
+  if(!PyArg_ParseTuple(args, "iiOii", &ne, &nn, &elements, &etype, &nparts))
+    return NULL;
+
+  elem_arr = (PyArrayObject *) PyArray_ContiguousFromObject(elements, PyArray_INT, 1, 1);
+
+  if(!elem_arr)
+    return NULL;
+
+  epart = (idxtype *)malloc(ne * sizeof(idxtype));
+  if(epart == NULL){
+    Py_DECREF(elem_arr);
+    return NULL;
+  }
+  npart = (idxtype *)malloc(nn * sizeof(idxtype));
+  if(npart == NULL){
+    free(epart);
+    Py_DECREF(elem_arr);
+    return NULL;
+  }
+  bridge_partMeshNodal(&ne, &nn, (idxtype *)elem_arr->data, &etype, &numflag, &nparts, &edgecut, epart, npart);
+
+  dims[0] = ne;
+  epart_pyarr = (PyArrayObject *)PyArray_FromDimsAndData(1, dims, PyArray_INT, (char *)epart);
+  dims[0] = nn;
+  npart_pyarr = (PyArrayObject *)PyArray_FromDimsAndData(1, dims, PyArray_INT, (char *)npart);
+
+  Py_DECREF(elem_arr);
+
+  return Py_BuildValue("iOO", edgecut, (PyObject *)epart_pyarr, (PyObject *)npart_pyarr);
+}
Index: /inundation/pymetis/pymetis/metis_bridge.c
===================================================================
--- /inundation/pymetis/pymetis/metis_bridge.c	(revision 2051)
+++ /inundation/pymetis/pymetis/metis_bridge.c	(revision 2051)
@@ -0,0 +1,9 @@
+/* Python.h and metis.h don't get along, so this is an ugly
+ * hack to make it work.
+ */
+
+#include <metis.h>
+
+void bridge_partMeshNodal(int * ne, int * nn, idxtype * elmnts, int * etype, int * numflag, int * nparts, int * edgecut, idxtype * epart, idxtype * npart){
+  METIS_PartMeshNodal(ne, nn, elmnts, etype, numflag, nparts, edgecut, epart, npart);
+}
Index: /inundation/pymetis/pymetis/setup.py
===================================================================
--- /inundation/pymetis/pymetis/setup.py	(revision 2051)
+++ /inundation/pymetis/pymetis/setup.py	(revision 2051)
@@ -0,0 +1,13 @@
+from distutils.core import setup, Extension;
+import os;
+
+metis = Extension('metis',
+                  sources = ['metis.c', 'metis_bridge.c'],
+                  include_dirs = ['..' + os.sep + os.environ['METIS_DIR'] + os.sep + 'Lib'],
+                  libraries = ['metis', 'm'],
+                  library_dirs = ['..' + os.sep + os.environ['METIS_DIR']]);
+
+setup(name = 'PyMetis',
+      version = '1.0',
+      description = 'Python interface to metis',
+      ext_modules = [metis]);
