diff options
Diffstat (limited to 'src/3rdparty/adaptagrams/libavoid/tests/vertlineassertion.cpp')
| -rw-r--r-- | src/3rdparty/adaptagrams/libavoid/tests/vertlineassertion.cpp | 2214 |
1 files changed, 2214 insertions, 0 deletions
diff --git a/src/3rdparty/adaptagrams/libavoid/tests/vertlineassertion.cpp b/src/3rdparty/adaptagrams/libavoid/tests/vertlineassertion.cpp new file mode 100644 index 0000000..2609dd8 --- /dev/null +++ b/src/3rdparty/adaptagrams/libavoid/tests/vertlineassertion.cpp @@ -0,0 +1,2214 @@ +#include "libavoid/libavoid.h"
+using namespace Avoid;
+int main(void) {
+ Router *router = new Router(
+ PolyLineRouting | OrthogonalRouting);
+ router->setRoutingPenalty((PenaltyType)0, 50);
+ router->setRoutingPenalty((PenaltyType)1, 0);
+ router->setRoutingPenalty((PenaltyType)2, 0);
+ router->setRoutingPenalty((PenaltyType)3, 4000);
+ router->setRoutingPenalty((PenaltyType)4, 0);
+
+ Polygon poly2(4);
+ poly2.ps[0] = Point(129, 898);
+ poly2.ps[1] = Point(129, 918);
+ poly2.ps[2] = Point(109, 918);
+ poly2.ps[3] = Point(109, 898);
+ new ShapeRef(router, poly2, 2);
+
+ Polygon poly3(4);
+ poly3.ps[0] = Point(272, 951);
+ poly3.ps[1] = Point(272, 971);
+ poly3.ps[2] = Point(252, 971);
+ poly3.ps[3] = Point(252, 951);
+ new ShapeRef(router, poly3, 3);
+
+ Polygon poly4(4);
+ poly4.ps[0] = Point(139, 931);
+ poly4.ps[1] = Point(139, 971);
+ poly4.ps[2] = Point(99, 971);
+ poly4.ps[3] = Point(99, 931);
+ new ShapeRef(router, poly4, 4);
+
+ Polygon poly5(4);
+ poly5.ps[0] = Point(665, 212.5);
+ poly5.ps[1] = Point(665, 459.5);
+ poly5.ps[2] = Point(593, 459.5);
+ poly5.ps[3] = Point(593, 212.5);
+ new ShapeRef(router, poly5, 5);
+
+ Polygon poly6(4);
+ poly6.ps[0] = Point(518, 52);
+ poly6.ps[1] = Point(518, 96);
+ poly6.ps[2] = Point(398, 96);
+ poly6.ps[3] = Point(398, 52);
+ new ShapeRef(router, poly6, 6);
+
+ Polygon poly7(4);
+ poly7.ps[0] = Point(361, 899);
+ poly7.ps[1] = Point(361, 919);
+ poly7.ps[2] = Point(341, 919);
+ poly7.ps[3] = Point(341, 899);
+ new ShapeRef(router, poly7, 7);
+
+ Polygon poly8(4);
+ poly8.ps[0] = Point(470, 930);
+ poly8.ps[1] = Point(470, 950);
+ poly8.ps[2] = Point(450, 950);
+ poly8.ps[3] = Point(450, 930);
+ new ShapeRef(router, poly8, 8);
+
+ Polygon poly9(4);
+ poly9.ps[0] = Point(422, 930);
+ poly9.ps[1] = Point(422, 950);
+ poly9.ps[2] = Point(402, 950);
+ poly9.ps[3] = Point(402, 930);
+ new ShapeRef(router, poly9, 9);
+
+ Polygon poly10(4);
+ poly10.ps[0] = Point(414, 861);
+ poly10.ps[1] = Point(414, 881);
+ poly10.ps[2] = Point(394, 881);
+ poly10.ps[3] = Point(394, 861);
+ new ShapeRef(router, poly10, 10);
+
+ Polygon poly11(4);
+ poly11.ps[0] = Point(414, 840);
+ poly11.ps[1] = Point(414, 860);
+ poly11.ps[2] = Point(394, 860);
+ poly11.ps[3] = Point(394, 840);
+ new ShapeRef(router, poly11, 11);
+
+ Polygon poly12(4);
+ poly12.ps[0] = Point(302, 852);
+ poly12.ps[1] = Point(302, 872);
+ poly12.ps[2] = Point(282, 872);
+ poly12.ps[3] = Point(282, 852);
+ new ShapeRef(router, poly12, 12);
+
+ Polygon poly13(4);
+ poly13.ps[0] = Point(193, 852);
+ poly13.ps[1] = Point(193, 872);
+ poly13.ps[2] = Point(173, 872);
+ poly13.ps[3] = Point(173, 852);
+ new ShapeRef(router, poly13, 13);
+
+ Polygon poly14(4);
+ poly14.ps[0] = Point(541, 851);
+ poly14.ps[1] = Point(541, 871);
+ poly14.ps[2] = Point(521, 871);
+ poly14.ps[3] = Point(521, 851);
+ new ShapeRef(router, poly14, 14);
+
+ Polygon poly15(4);
+ poly15.ps[0] = Point(401, 739);
+ poly15.ps[1] = Point(401, 783);
+ poly15.ps[2] = Point(313, 783);
+ poly15.ps[3] = Point(313, 739);
+ new ShapeRef(router, poly15, 15);
+
+ Polygon poly16(4);
+ poly16.ps[0] = Point(466, 757);
+ poly16.ps[1] = Point(466, 777);
+ poly16.ps[2] = Point(446, 777);
+ poly16.ps[3] = Point(446, 757);
+ new ShapeRef(router, poly16, 16);
+
+ Polygon poly17(4);
+ poly17.ps[0] = Point(466, 688);
+ poly17.ps[1] = Point(466, 708);
+ poly17.ps[2] = Point(446, 708);
+ poly17.ps[3] = Point(446, 688);
+ new ShapeRef(router, poly17, 17);
+
+ Polygon poly18(4);
+ poly18.ps[0] = Point(467, 616);
+ poly18.ps[1] = Point(467, 636);
+ poly18.ps[2] = Point(447, 636);
+ poly18.ps[3] = Point(447, 616);
+ new ShapeRef(router, poly18, 18);
+
+ Polygon poly19(4);
+ poly19.ps[0] = Point(441, 471);
+ poly19.ps[1] = Point(441, 491);
+ poly19.ps[2] = Point(421, 491);
+ poly19.ps[3] = Point(421, 471);
+ new ShapeRef(router, poly19, 19);
+
+ Polygon poly20(4);
+ poly20.ps[0] = Point(359.5, 575);
+ poly20.ps[1] = Point(359.5, 619);
+ poly20.ps[2] = Point(196.5, 619);
+ poly20.ps[3] = Point(196.5, 575);
+ new ShapeRef(router, poly20, 20);
+
+ Polygon poly21(4);
+ poly21.ps[0] = Point(386, 437);
+ poly21.ps[1] = Point(386, 457);
+ poly21.ps[2] = Point(366, 457);
+ poly21.ps[3] = Point(366, 437);
+ new ShapeRef(router, poly21, 21);
+
+ Polygon poly22(4);
+ poly22.ps[0] = Point(466, 391);
+ poly22.ps[1] = Point(466, 411);
+ poly22.ps[2] = Point(446, 411);
+ poly22.ps[3] = Point(446, 391);
+ new ShapeRef(router, poly22, 22);
+
+ Polygon poly23(4);
+ poly23.ps[0] = Point(466, 325);
+ poly23.ps[1] = Point(466, 345);
+ poly23.ps[2] = Point(446, 345);
+ poly23.ps[3] = Point(446, 325);
+ new ShapeRef(router, poly23, 23);
+
+ Polygon poly24(4);
+ poly24.ps[0] = Point(413, 325);
+ poly24.ps[1] = Point(413, 345);
+ poly24.ps[2] = Point(393, 345);
+ poly24.ps[3] = Point(393, 325);
+ new ShapeRef(router, poly24, 24);
+
+ Polygon poly25(4);
+ poly25.ps[0] = Point(535, 182);
+ poly25.ps[1] = Point(535, 202);
+ poly25.ps[2] = Point(515, 202);
+ poly25.ps[3] = Point(515, 182);
+ new ShapeRef(router, poly25, 25);
+
+ Polygon poly26(4);
+ poly26.ps[0] = Point(466, 255);
+ poly26.ps[1] = Point(466, 275);
+ poly26.ps[2] = Point(446, 275);
+ poly26.ps[3] = Point(446, 255);
+ new ShapeRef(router, poly26, 26);
+
+ Polygon poly27(4);
+ poly27.ps[0] = Point(466, 160);
+ poly27.ps[1] = Point(466, 180);
+ poly27.ps[2] = Point(446, 180);
+ poly27.ps[3] = Point(446, 160);
+ new ShapeRef(router, poly27, 27);
+
+ Polygon poly28(4);
+ poly28.ps[0] = Point(386, 289);
+ poly28.ps[1] = Point(386, 309);
+ poly28.ps[2] = Point(366, 309);
+ poly28.ps[3] = Point(366, 289);
+ new ShapeRef(router, poly28, 28);
+
+ Polygon poly29(4);
+ poly29.ps[0] = Point(231, 270);
+ poly29.ps[1] = Point(231, 290);
+ poly29.ps[2] = Point(211, 290);
+ poly29.ps[3] = Point(211, 270);
+ new ShapeRef(router, poly29, 29);
+
+ Polygon poly30(4);
+ poly30.ps[0] = Point(231, 289);
+ poly30.ps[1] = Point(231, 309);
+ poly30.ps[2] = Point(211, 309);
+ poly30.ps[3] = Point(211, 289);
+ new ShapeRef(router, poly30, 30);
+
+ Polygon poly31(4);
+ poly31.ps[0] = Point(340, 256);
+ poly31.ps[1] = Point(340, 276);
+ poly31.ps[2] = Point(320, 276);
+ poly31.ps[3] = Point(320, 256);
+ new ShapeRef(router, poly31, 31);
+
+ Polygon poly32(4);
+ poly32.ps[0] = Point(290, 256);
+ poly32.ps[1] = Point(290, 276);
+ poly32.ps[2] = Point(270, 276);
+ poly32.ps[3] = Point(270, 256);
+ new ShapeRef(router, poly32, 32);
+
+ Polygon poly33(4);
+ poly33.ps[0] = Point(164, 251);
+ poly33.ps[1] = Point(164, 271);
+ poly33.ps[2] = Point(144, 271);
+ poly33.ps[3] = Point(144, 251);
+ new ShapeRef(router, poly33, 33);
+
+ Polygon poly34(4);
+ poly34.ps[0] = Point(231, 214);
+ poly34.ps[1] = Point(231, 234);
+ poly34.ps[2] = Point(211, 234);
+ poly34.ps[3] = Point(211, 214);
+ new ShapeRef(router, poly34, 34);
+
+ Polygon poly35(4);
+ poly35.ps[0] = Point(231, 195);
+ poly35.ps[1] = Point(231, 215);
+ poly35.ps[2] = Point(211, 215);
+ poly35.ps[3] = Point(211, 195);
+ new ShapeRef(router, poly35, 35);
+
+ Polygon poly36(4);
+ poly36.ps[0] = Point(299, 173);
+ poly36.ps[1] = Point(299, 193);
+ poly36.ps[2] = Point(279, 193);
+ poly36.ps[3] = Point(279, 173);
+ new ShapeRef(router, poly36, 36);
+
+ Polygon poly37(4);
+ poly37.ps[0] = Point(326, 141);
+ poly37.ps[1] = Point(326, 161);
+ poly37.ps[2] = Point(306, 161);
+ poly37.ps[3] = Point(306, 141);
+ new ShapeRef(router, poly37, 37);
+
+ Polygon poly38(4);
+ poly38.ps[0] = Point(326, 120);
+ poly38.ps[1] = Point(326, 140);
+ poly38.ps[2] = Point(306, 140);
+ poly38.ps[3] = Point(306, 120);
+ new ShapeRef(router, poly38, 38);
+
+ Polygon poly39(4);
+ poly39.ps[0] = Point(295.5, 39.5);
+ poly39.ps[1] = Point(295.5, 74.5);
+ poly39.ps[2] = Point(34.5, 74.5);
+ poly39.ps[3] = Point(34.5, 39.5);
+ new ShapeRef(router, poly39, 39);
+
+ Polygon poly40(4);
+ poly40.ps[0] = Point(245, 895);
+ poly40.ps[1] = Point(245, 915);
+ poly40.ps[2] = Point(225, 915);
+ poly40.ps[3] = Point(225, 895);
+ new ShapeRef(router, poly40, 40);
+
+ Polygon poly41(4);
+ poly41.ps[0] = Point(466, 543);
+ poly41.ps[1] = Point(466, 563);
+ poly41.ps[2] = Point(446, 563);
+ poly41.ps[3] = Point(446, 543);
+ new ShapeRef(router, poly41, 41);
+
+ Polygon poly42(4);
+ poly42.ps[0] = Point(231, 233);
+ poly42.ps[1] = Point(231, 253);
+ poly42.ps[2] = Point(211, 253);
+ poly42.ps[3] = Point(211, 233);
+ new ShapeRef(router, poly42, 42);
+
+ Polygon poly43(4);
+ poly43.ps[0] = Point(231, 308);
+ poly43.ps[1] = Point(231, 328);
+ poly43.ps[2] = Point(211, 328);
+ poly43.ps[3] = Point(211, 308);
+ new ShapeRef(router, poly43, 43);
+
+ Polygon poly44(4);
+ poly44.ps[0] = Point(164, 347);
+ poly44.ps[1] = Point(164, 367);
+ poly44.ps[2] = Point(144, 367);
+ poly44.ps[3] = Point(144, 347);
+ new ShapeRef(router, poly44, 44);
+
+ Polygon poly45(4);
+ poly45.ps[0] = Point(164, 373);
+ poly45.ps[1] = Point(164, 393);
+ poly45.ps[2] = Point(144, 393);
+ poly45.ps[3] = Point(144, 373);
+ new ShapeRef(router, poly45, 45);
+
+ Polygon poly46(4);
+ poly46.ps[0] = Point(274, 346);
+ poly46.ps[1] = Point(274, 366);
+ poly46.ps[2] = Point(254, 366);
+ poly46.ps[3] = Point(254, 346);
+ new ShapeRef(router, poly46, 46);
+
+ Polygon poly47(4);
+ poly47.ps[0] = Point(274, 372);
+ poly47.ps[1] = Point(274, 392);
+ poly47.ps[2] = Point(254, 392);
+ poly47.ps[3] = Point(254, 372);
+ new ShapeRef(router, poly47, 47);
+
+ Polygon poly48(4);
+ poly48.ps[0] = Point(594, 173);
+ poly48.ps[1] = Point(594, 213);
+ poly48.ps[2] = Point(554, 213);
+ poly48.ps[3] = Point(554, 173);
+ new ShapeRef(router, poly48, 48);
+
+ Polygon poly49(4);
+ poly49.ps[0] = Point(476, 121);
+ poly49.ps[1] = Point(476, 161);
+ poly49.ps[2] = Point(436, 161);
+ poly49.ps[3] = Point(436, 121);
+ new ShapeRef(router, poly49, 49);
+
+ Polygon poly50(4);
+ poly50.ps[0] = Point(476, 642);
+ poly50.ps[1] = Point(476, 682);
+ poly50.ps[2] = Point(436, 682);
+ poly50.ps[3] = Point(436, 642);
+ new ShapeRef(router, poly50, 50);
+
+ Polygon poly51(4);
+ poly51.ps[0] = Point(174, 206);
+ poly51.ps[1] = Point(174, 246);
+ poly51.ps[2] = Point(134, 246);
+ poly51.ps[3] = Point(134, 206);
+ new ShapeRef(router, poly51, 51);
+
+ Polygon poly52(4);
+ poly52.ps[0] = Point(174, 279);
+ poly52.ps[1] = Point(174, 319);
+ poly52.ps[2] = Point(134, 319);
+ poly52.ps[3] = Point(134, 279);
+ new ShapeRef(router, poly52, 52);
+
+ Polygon poly53(4);
+ poly53.ps[0] = Point(325, 426);
+ poly53.ps[1] = Point(325, 466);
+ poly53.ps[2] = Point(285, 466);
+ poly53.ps[3] = Point(285, 426);
+ new ShapeRef(router, poly53, 53);
+
+ Polygon poly54(4);
+ poly54.ps[0] = Point(325, 279);
+ poly54.ps[1] = Point(325, 319);
+ poly54.ps[2] = Point(285, 319);
+ poly54.ps[3] = Point(285, 279);
+ new ShapeRef(router, poly54, 54);
+
+ Polygon poly55(4);
+ poly55.ps[0] = Point(476, 208);
+ poly55.ps[1] = Point(476, 248);
+ poly55.ps[2] = Point(436, 248);
+ poly55.ps[3] = Point(436, 208);
+ new ShapeRef(router, poly55, 55);
+
+ Polygon poly56(4);
+ poly56.ps[0] = Point(476, 281);
+ poly56.ps[1] = Point(476, 321);
+ poly56.ps[2] = Point(436, 321);
+ poly56.ps[3] = Point(436, 281);
+ new ShapeRef(router, poly56, 56);
+
+ Polygon poly57(4);
+ poly57.ps[0] = Point(476, 714);
+ poly57.ps[1] = Point(476, 754);
+ poly57.ps[2] = Point(436, 754);
+ poly57.ps[3] = Point(436, 714);
+ new ShapeRef(router, poly57, 57);
+
+ Polygon poly58(4);
+ poly58.ps[0] = Point(476, 570);
+ poly58.ps[1] = Point(476, 610);
+ poly58.ps[2] = Point(436, 610);
+ poly58.ps[3] = Point(436, 570);
+ new ShapeRef(router, poly58, 58);
+
+ Polygon poly59(4);
+ poly59.ps[0] = Point(476, 498);
+ poly59.ps[1] = Point(476, 538);
+ poly59.ps[2] = Point(436, 538);
+ poly59.ps[3] = Point(436, 498);
+ new ShapeRef(router, poly59, 59);
+
+ Polygon poly60(4);
+ poly60.ps[0] = Point(620, 841);
+ poly60.ps[1] = Point(620, 881);
+ poly60.ps[2] = Point(580, 881);
+ poly60.ps[3] = Point(580, 841);
+ new ShapeRef(router, poly60, 60);
+
+ Polygon poly61(4);
+ poly61.ps[0] = Point(307, 884);
+ poly61.ps[1] = Point(307, 924);
+ poly61.ps[2] = Point(267, 924);
+ poly61.ps[3] = Point(267, 884);
+ new ShapeRef(router, poly61, 61);
+
+ Polygon poly62(4);
+ poly62.ps[0] = Point(543, 931);
+ poly62.ps[1] = Point(543, 971);
+ poly62.ps[2] = Point(503, 971);
+ poly62.ps[3] = Point(503, 931);
+ new ShapeRef(router, poly62, 62);
+
+ Polygon poly63(4);
+ poly63.ps[0] = Point(476, 841);
+ poly63.ps[1] = Point(476, 881);
+ poly63.ps[2] = Point(436, 881);
+ poly63.ps[3] = Point(436, 841);
+ new ShapeRef(router, poly63, 63);
+
+ Polygon poly64(4);
+ poly64.ps[0] = Point(371, 841);
+ poly64.ps[1] = Point(371, 881);
+ poly64.ps[2] = Point(331, 881);
+ poly64.ps[3] = Point(331, 841);
+ new ShapeRef(router, poly64, 64);
+
+ Polygon poly65(4);
+ poly65.ps[0] = Point(371, 798);
+ poly65.ps[1] = Point(371, 838);
+ poly65.ps[2] = Point(331, 838);
+ poly65.ps[3] = Point(331, 798);
+ new ShapeRef(router, poly65, 65);
+
+ Polygon poly66(4);
+ poly66.ps[0] = Point(139, 841);
+ poly66.ps[1] = Point(139, 881);
+ poly66.ps[2] = Point(99, 881);
+ poly66.ps[3] = Point(99, 841);
+ new ShapeRef(router, poly66, 66);
+
+ Polygon poly67(4);
+ poly67.ps[0] = Point(371, 931);
+ poly67.ps[1] = Point(371, 971);
+ poly67.ps[2] = Point(331, 971);
+ poly67.ps[3] = Point(331, 931);
+ new ShapeRef(router, poly67, 67);
+
+ Polygon poly68(4);
+ poly68.ps[0] = Point(258, 841);
+ poly68.ps[1] = Point(258, 881);
+ poly68.ps[2] = Point(218, 881);
+ poly68.ps[3] = Point(218, 841);
+ new ShapeRef(router, poly68, 68);
+
+ Polygon poly69(4);
+ poly69.ps[0] = Point(205, 884);
+ poly69.ps[1] = Point(205, 924);
+ poly69.ps[2] = Point(165, 924);
+ poly69.ps[3] = Point(165, 884);
+ new ShapeRef(router, poly69, 69);
+
+ Polygon poly70(4);
+ poly70.ps[0] = Point(476, 351);
+ poly70.ps[1] = Point(476, 391);
+ poly70.ps[2] = Point(436, 391);
+ poly70.ps[3] = Point(436, 351);
+ new ShapeRef(router, poly70, 70);
+
+ Polygon poly71(4);
+ poly71.ps[0] = Point(125, 336);
+ poly71.ps[1] = Point(125, 376);
+ poly71.ps[2] = Point(85, 376);
+ poly71.ps[3] = Point(85, 336);
+ new ShapeRef(router, poly71, 71);
+
+ Polygon poly72(4);
+ poly72.ps[0] = Point(232, 336);
+ poly72.ps[1] = Point(232, 376);
+ poly72.ps[2] = Point(192, 376);
+ poly72.ps[3] = Point(192, 336);
+ new ShapeRef(router, poly72, 72);
+
+ Polygon poly73(4);
+ poly73.ps[0] = Point(232, 362);
+ poly73.ps[1] = Point(232, 402);
+ poly73.ps[2] = Point(192, 402);
+ poly73.ps[3] = Point(192, 362);
+ new ShapeRef(router, poly73, 73);
+
+ Polygon poly74(4);
+ poly74.ps[0] = Point(125, 362);
+ poly74.ps[1] = Point(125, 402);
+ poly74.ps[2] = Point(85, 402);
+ poly74.ps[3] = Point(85, 362);
+ new ShapeRef(router, poly74, 74);
+
+ Polygon poly75(4);
+ poly75.ps[0] = Point(77.5, 716);
+ poly75.ps[1] = Point(77.5, 880);
+ poly75.ps[2] = Point(20.5, 880);
+ poly75.ps[3] = Point(20.5, 716);
+ new ShapeRef(router, poly75, 75);
+
+ Polygon poly76(4);
+ poly76.ps[0] = Point(187, 713);
+ poly76.ps[1] = Point(187, 733);
+ poly76.ps[2] = Point(167, 733);
+ poly76.ps[3] = Point(167, 713);
+ new ShapeRef(router, poly76, 76);
+
+ Polygon poly77(4);
+ poly77.ps[0] = Point(139, 714);
+ poly77.ps[1] = Point(139, 754);
+ poly77.ps[2] = Point(99, 754);
+ poly77.ps[3] = Point(99, 714);
+ new ShapeRef(router, poly77, 77);
+
+ Polygon poly78(4);
+ poly78.ps[0] = Point(422, 951);
+ poly78.ps[1] = Point(422, 971);
+ poly78.ps[2] = Point(402, 971);
+ poly78.ps[3] = Point(402, 951);
+ new ShapeRef(router, poly78, 78);
+
+ Polygon poly79(4);
+ poly79.ps[0] = Point(187, 734);
+ poly79.ps[1] = Point(187, 754);
+ poly79.ps[2] = Point(167, 754);
+ poly79.ps[3] = Point(167, 734);
+ new ShapeRef(router, poly79, 79);
+
+ Polygon poly80(4);
+ poly80.ps[0] = Point(470, 951);
+ poly80.ps[1] = Point(470, 971);
+ poly80.ps[2] = Point(450, 971);
+ poly80.ps[3] = Point(450, 951);
+ new ShapeRef(router, poly80, 80);
+
+ Polygon poly81(4);
+ poly81.ps[0] = Point(669.5, 899.5);
+ poly81.ps[1] = Point(669.5, 934.5);
+ poly81.ps[2] = Point(532.5, 934.5);
+ poly81.ps[3] = Point(532.5, 899.5);
+ new ShapeRef(router, poly81, 81);
+
+ Polygon poly82(4);
+ poly82.ps[0] = Point(491, 471);
+ poly82.ps[1] = Point(491, 491);
+ poly82.ps[2] = Point(471, 491);
+ poly82.ps[3] = Point(471, 471);
+ new ShapeRef(router, poly82, 82);
+
+ Polygon poly83(4);
+ poly83.ps[0] = Point(565, 512);
+ poly83.ps[1] = Point(565, 532);
+ poly83.ps[2] = Point(545, 532);
+ poly83.ps[3] = Point(545, 512);
+ new ShapeRef(router, poly83, 83);
+
+ Polygon poly84(4);
+ poly84.ps[0] = Point(538, 531);
+ poly84.ps[1] = Point(538, 551);
+ poly84.ps[2] = Point(518, 551);
+ poly84.ps[3] = Point(518, 531);
+ new ShapeRef(router, poly84, 84);
+
+ Polygon poly85(4);
+ poly85.ps[0] = Point(272, 782);
+ poly85.ps[1] = Point(272, 802);
+ poly85.ps[2] = Point(252, 802);
+ poly85.ps[3] = Point(252, 782);
+ new ShapeRef(router, poly85, 85);
+
+ Polygon poly86(4);
+ poly86.ps[0] = Point(515, 512);
+ poly86.ps[1] = Point(515, 532);
+ poly86.ps[2] = Point(495, 532);
+ poly86.ps[3] = Point(495, 512);
+ new ShapeRef(router, poly86, 86);
+
+ Polygon poly87(4);
+ poly87.ps[0] = Point(391, 534);
+ poly87.ps[1] = Point(391, 574);
+ poly87.ps[2] = Point(351, 574);
+ poly87.ps[3] = Point(351, 534);
+ new ShapeRef(router, poly87, 87);
+
+ Polygon poly88(4);
+ poly88.ps[0] = Point(420, 573);
+ poly88.ps[1] = Point(420, 593);
+ poly88.ps[2] = Point(400, 593);
+ poly88.ps[3] = Point(400, 573);
+ new ShapeRef(router, poly88, 88);
+
+ Polygon poly89(4);
+ poly89.ps[0] = Point(421, 509);
+ poly89.ps[1] = Point(421, 529);
+ poly89.ps[2] = Point(401, 529);
+ poly89.ps[3] = Point(401, 509);
+ new ShapeRef(router, poly89, 89);
+
+ Polygon poly90(4);
+ poly90.ps[0] = Point(476, 426);
+ poly90.ps[1] = Point(476, 466);
+ poly90.ps[2] = Point(436, 466);
+ poly90.ps[3] = Point(436, 426);
+ new ShapeRef(router, poly90, 90);
+
+ Polygon poly91(4);
+ poly91.ps[0] = Point(290, 970);
+ poly91.ps[1] = Point(290, 1010);
+ poly91.ps[2] = Point(234, 1010);
+ poly91.ps[3] = Point(234, 970);
+ new ShapeRef(router, poly91, 91);
+
+ Polygon poly92(4);
+ poly92.ps[0] = Point(85, 888);
+ poly92.ps[1] = Point(85, 928);
+ poly92.ps[2] = Point(29, 928);
+ poly92.ps[3] = Point(29, 888);
+ new ShapeRef(router, poly92, 92);
+
+ Polygon poly93(4);
+ poly93.ps[0] = Point(290, 991);
+ poly93.ps[1] = Point(290, 1031);
+ poly93.ps[2] = Point(234, 1031);
+ poly93.ps[3] = Point(234, 991);
+ new ShapeRef(router, poly93, 93);
+
+ Polygon poly94(4);
+ poly94.ps[0] = Point(317, 889);
+ poly94.ps[1] = Point(317, 929);
+ poly94.ps[2] = Point(261, 929);
+ poly94.ps[3] = Point(261, 889);
+ new ShapeRef(router, poly94, 94);
+
+ Polygon poly95(4);
+ poly95.ps[0] = Point(488, 870);
+ poly95.ps[1] = Point(488, 910);
+ poly95.ps[2] = Point(432, 910);
+ poly95.ps[3] = Point(432, 870);
+ new ShapeRef(router, poly95, 95);
+
+ Polygon poly96(4);
+ poly96.ps[0] = Point(440, 970);
+ poly96.ps[1] = Point(440, 1010);
+ poly96.ps[2] = Point(384, 1010);
+ poly96.ps[3] = Point(384, 970);
+ new ShapeRef(router, poly96, 96);
+
+ Polygon poly97(4);
+ poly97.ps[0] = Point(370, 851);
+ poly97.ps[1] = Point(370, 891);
+ poly97.ps[2] = Point(314, 891);
+ poly97.ps[3] = Point(314, 851);
+ new ShapeRef(router, poly97, 97);
+
+ Polygon poly98(4);
+ poly98.ps[0] = Point(494, 830);
+ poly98.ps[1] = Point(494, 870);
+ poly98.ps[2] = Point(438, 870);
+ poly98.ps[3] = Point(438, 830);
+ new ShapeRef(router, poly98, 98);
+
+ Polygon poly99(4);
+ poly99.ps[0] = Point(258, 842);
+ poly99.ps[1] = Point(258, 882);
+ poly99.ps[2] = Point(202, 882);
+ poly99.ps[3] = Point(202, 842);
+ new ShapeRef(router, poly99, 99);
+
+ Polygon poly100(4);
+ poly100.ps[0] = Point(211, 792);
+ poly100.ps[1] = Point(211, 832);
+ poly100.ps[2] = Point(155, 832);
+ poly100.ps[3] = Point(155, 792);
+ new ShapeRef(router, poly100, 100);
+
+ Polygon poly101(4);
+ poly101.ps[0] = Point(559, 791);
+ poly101.ps[1] = Point(559, 831);
+ poly101.ps[2] = Point(503, 831);
+ poly101.ps[3] = Point(503, 791);
+ new ShapeRef(router, poly101, 101);
+
+ Polygon poly102(4);
+ poly102.ps[0] = Point(546, 747);
+ poly102.ps[1] = Point(546, 787);
+ poly102.ps[2] = Point(490, 787);
+ poly102.ps[3] = Point(490, 747);
+ new ShapeRef(router, poly102, 102);
+
+ Polygon poly103(4);
+ poly103.ps[0] = Point(422, 678);
+ poly103.ps[1] = Point(422, 718);
+ poly103.ps[2] = Point(366, 718);
+ poly103.ps[3] = Point(366, 678);
+ new ShapeRef(router, poly103, 103);
+
+ Polygon poly104(4);
+ poly104.ps[0] = Point(423, 606);
+ poly104.ps[1] = Point(423, 646);
+ poly104.ps[2] = Point(367, 646);
+ poly104.ps[3] = Point(367, 606);
+ new ShapeRef(router, poly104, 104);
+
+ Polygon poly105(4);
+ poly105.ps[0] = Point(397, 461);
+ poly105.ps[1] = Point(397, 501);
+ poly105.ps[2] = Point(341, 501);
+ poly105.ps[3] = Point(341, 461);
+ new ShapeRef(router, poly105, 105);
+
+ Polygon poly106(4);
+ poly106.ps[0] = Point(404, 377);
+ poly106.ps[1] = Point(404, 417);
+ poly106.ps[2] = Point(348, 417);
+ poly106.ps[3] = Point(348, 377);
+ new ShapeRef(router, poly106, 106);
+
+ Polygon poly107(4);
+ poly107.ps[0] = Point(546, 381);
+ poly107.ps[1] = Point(546, 421);
+ poly107.ps[2] = Point(490, 421);
+ poly107.ps[3] = Point(490, 381);
+ new ShapeRef(router, poly107, 107);
+
+ Polygon poly108(4);
+ poly108.ps[0] = Point(546, 315);
+ poly108.ps[1] = Point(546, 355);
+ poly108.ps[2] = Point(490, 355);
+ poly108.ps[3] = Point(490, 315);
+ new ShapeRef(router, poly108, 108);
+
+ Polygon poly109(4);
+ poly109.ps[0] = Point(431, 365);
+ poly109.ps[1] = Point(431, 405);
+ poly109.ps[2] = Point(375, 405);
+ poly109.ps[3] = Point(375, 365);
+ new ShapeRef(router, poly109, 109);
+
+ Polygon poly110(4);
+ poly110.ps[0] = Point(553, 122);
+ poly110.ps[1] = Point(553, 162);
+ poly110.ps[2] = Point(497, 162);
+ poly110.ps[3] = Point(497, 122);
+ new ShapeRef(router, poly110, 110);
+
+ Polygon poly111(4);
+ poly111.ps[0] = Point(546, 245);
+ poly111.ps[1] = Point(546, 285);
+ poly111.ps[2] = Point(490, 285);
+ poly111.ps[3] = Point(490, 245);
+ new ShapeRef(router, poly111, 111);
+
+ Polygon poly112(4);
+ poly112.ps[0] = Point(422, 150);
+ poly112.ps[1] = Point(422, 190);
+ poly112.ps[2] = Point(366, 190);
+ poly112.ps[3] = Point(366, 150);
+ new ShapeRef(router, poly112, 112);
+
+ Polygon poly113(4);
+ poly113.ps[0] = Point(404, 229);
+ poly113.ps[1] = Point(404, 269);
+ poly113.ps[2] = Point(348, 269);
+ poly113.ps[3] = Point(348, 229);
+ new ShapeRef(router, poly113, 113);
+
+ Polygon poly114(4);
+ poly114.ps[0] = Point(249, 210);
+ poly114.ps[1] = Point(249, 250);
+ poly114.ps[2] = Point(193, 250);
+ poly114.ps[3] = Point(193, 210);
+ new ShapeRef(router, poly114, 114);
+
+ Polygon poly115(4);
+ poly115.ps[0] = Point(249, 229);
+ poly115.ps[1] = Point(249, 269);
+ poly115.ps[2] = Point(193, 269);
+ poly115.ps[3] = Point(193, 229);
+ new ShapeRef(router, poly115, 115);
+
+ Polygon poly116(4);
+ poly116.ps[0] = Point(420, 246);
+ poly116.ps[1] = Point(420, 286);
+ poly116.ps[2] = Point(364, 286);
+ poly116.ps[3] = Point(364, 246);
+ new ShapeRef(router, poly116, 116);
+
+ Polygon poly117(4);
+ poly117.ps[0] = Point(246, 246);
+ poly117.ps[1] = Point(246, 286);
+ poly117.ps[2] = Point(190, 286);
+ poly117.ps[3] = Point(190, 246);
+ new ShapeRef(router, poly117, 117);
+
+ Polygon poly118(4);
+ poly118.ps[0] = Point(120, 241);
+ poly118.ps[1] = Point(120, 281);
+ poly118.ps[2] = Point(64, 281);
+ poly118.ps[3] = Point(64, 241);
+ new ShapeRef(router, poly118, 118);
+
+ Polygon poly119(4);
+ poly119.ps[0] = Point(249, 154);
+ poly119.ps[1] = Point(249, 194);
+ poly119.ps[2] = Point(193, 194);
+ poly119.ps[3] = Point(193, 154);
+ new ShapeRef(router, poly119, 119);
+
+ Polygon poly120(4);
+ poly120.ps[0] = Point(249, 135);
+ poly120.ps[1] = Point(249, 175);
+ poly120.ps[2] = Point(193, 175);
+ poly120.ps[3] = Point(193, 135);
+ new ShapeRef(router, poly120, 120);
+
+ Polygon poly121(4);
+ poly121.ps[0] = Point(317, 213);
+ poly121.ps[1] = Point(317, 253);
+ poly121.ps[2] = Point(261, 253);
+ poly121.ps[3] = Point(261, 213);
+ new ShapeRef(router, poly121, 121);
+
+ Polygon poly122(4);
+ poly122.ps[0] = Point(344, 81);
+ poly122.ps[1] = Point(344, 121);
+ poly122.ps[2] = Point(288, 121);
+ poly122.ps[3] = Point(288, 81);
+ new ShapeRef(router, poly122, 122);
+
+ Polygon poly123(4);
+ poly123.ps[0] = Point(344, 160);
+ poly123.ps[1] = Point(344, 200);
+ poly123.ps[2] = Point(288, 200);
+ poly123.ps[3] = Point(288, 160);
+ new ShapeRef(router, poly123, 123);
+
+ Polygon poly124(4);
+ poly124.ps[0] = Point(263, 835);
+ poly124.ps[1] = Point(263, 875);
+ poly124.ps[2] = Point(207, 875);
+ poly124.ps[3] = Point(207, 835);
+ new ShapeRef(router, poly124, 124);
+
+ Polygon poly125(4);
+ poly125.ps[0] = Point(422, 533);
+ poly125.ps[1] = Point(422, 573);
+ poly125.ps[2] = Point(366, 573);
+ poly125.ps[3] = Point(366, 533);
+ new ShapeRef(router, poly125, 125);
+
+ Polygon poly126(4);
+ poly126.ps[0] = Point(249, 173);
+ poly126.ps[1] = Point(249, 213);
+ poly126.ps[2] = Point(193, 213);
+ poly126.ps[3] = Point(193, 173);
+ new ShapeRef(router, poly126, 126);
+
+ Polygon poly127(4);
+ poly127.ps[0] = Point(249, 248);
+ poly127.ps[1] = Point(249, 288);
+ poly127.ps[2] = Point(193, 288);
+ poly127.ps[3] = Point(193, 248);
+ new ShapeRef(router, poly127, 127);
+
+ Polygon poly128(4);
+ poly128.ps[0] = Point(182, 287);
+ poly128.ps[1] = Point(182, 327);
+ poly128.ps[2] = Point(126, 327);
+ poly128.ps[3] = Point(126, 287);
+ new ShapeRef(router, poly128, 128);
+
+ Polygon poly129(4);
+ poly129.ps[0] = Point(182, 413);
+ poly129.ps[1] = Point(182, 453);
+ poly129.ps[2] = Point(126, 453);
+ poly129.ps[3] = Point(126, 413);
+ new ShapeRef(router, poly129, 129);
+
+ Polygon poly130(4);
+ poly130.ps[0] = Point(292, 286);
+ poly130.ps[1] = Point(292, 326);
+ poly130.ps[2] = Point(236, 326);
+ poly130.ps[3] = Point(236, 286);
+ new ShapeRef(router, poly130, 130);
+
+ Polygon poly131(4);
+ poly131.ps[0] = Point(292, 412);
+ poly131.ps[1] = Point(292, 452);
+ poly131.ps[2] = Point(236, 452);
+ poly131.ps[3] = Point(236, 412);
+ new ShapeRef(router, poly131, 131);
+
+ Polygon poly132(4);
+ poly132.ps[0] = Point(205, 653);
+ poly132.ps[1] = Point(205, 693);
+ poly132.ps[2] = Point(149, 693);
+ poly132.ps[3] = Point(149, 653);
+ new ShapeRef(router, poly132, 132);
+
+ Polygon poly133(4);
+ poly133.ps[0] = Point(440, 891);
+ poly133.ps[1] = Point(440, 931);
+ poly133.ps[2] = Point(384, 931);
+ poly133.ps[3] = Point(384, 891);
+ new ShapeRef(router, poly133, 133);
+
+ Polygon poly134(4);
+ poly134.ps[0] = Point(205, 674);
+ poly134.ps[1] = Point(205, 714);
+ poly134.ps[2] = Point(149, 714);
+ poly134.ps[3] = Point(149, 674);
+ new ShapeRef(router, poly134, 134);
+
+ Polygon poly135(4);
+ poly135.ps[0] = Point(488, 991);
+ poly135.ps[1] = Point(488, 1031);
+ poly135.ps[2] = Point(432, 1031);
+ poly135.ps[3] = Point(432, 991);
+ new ShapeRef(router, poly135, 135);
+
+ Polygon poly136(4);
+ poly136.ps[0] = Point(571, 461);
+ poly136.ps[1] = Point(571, 501);
+ poly136.ps[2] = Point(515, 501);
+ poly136.ps[3] = Point(515, 461);
+ new ShapeRef(router, poly136, 136);
+
+ Polygon poly137(4);
+ poly137.ps[0] = Point(583, 452);
+ poly137.ps[1] = Point(583, 492);
+ poly137.ps[2] = Point(527, 492);
+ poly137.ps[3] = Point(527, 452);
+ new ShapeRef(router, poly137, 137);
+
+ Polygon poly138(4);
+ poly138.ps[0] = Point(556, 571);
+ poly138.ps[1] = Point(556, 611);
+ poly138.ps[2] = Point(500, 611);
+ poly138.ps[3] = Point(500, 571);
+ new ShapeRef(router, poly138, 138);
+
+ Polygon poly139(4);
+ poly139.ps[0] = Point(290, 722);
+ poly139.ps[1] = Point(290, 762);
+ poly139.ps[2] = Point(234, 762);
+ poly139.ps[3] = Point(234, 722);
+ new ShapeRef(router, poly139, 139);
+
+ Polygon poly140(4);
+ poly140.ps[0] = Point(595, 502);
+ poly140.ps[1] = Point(595, 542);
+ poly140.ps[2] = Point(539, 542);
+ poly140.ps[3] = Point(539, 502);
+ new ShapeRef(router, poly140, 140);
+
+ Polygon poly141(4);
+ poly141.ps[0] = Point(438, 613);
+ poly141.ps[1] = Point(438, 653);
+ poly141.ps[2] = Point(382, 653);
+ poly141.ps[3] = Point(382, 613);
+ new ShapeRef(router, poly141, 141);
+
+ Polygon poly142(4);
+ poly142.ps[0] = Point(439, 449);
+ poly142.ps[1] = Point(439, 489);
+ poly142.ps[2] = Point(383, 489);
+ poly142.ps[3] = Point(383, 449);
+ new ShapeRef(router, poly142, 142);
+
+ ConnRef *connRef143 = new ConnRef(router, 143);
+ ConnEnd srcPt143(Point(262, 940), 15);
+ connRef143->setSourceEndpoint(srcPt143);
+ ConnEnd dstPt143(Point(119, 951), 15);
+ connRef143->setDestEndpoint(dstPt143);
+ connRef143->setRoutingType((ConnType)2);
+
+ ConnRef *connRef144 = new ConnRef(router, 144);
+ ConnEnd srcPt144(Point(262, 940), 15);
+ connRef144->setSourceEndpoint(srcPt144);
+ ConnEnd dstPt144(Point(351, 951), 15);
+ connRef144->setDestEndpoint(dstPt144);
+ connRef144->setRoutingType((ConnType)2);
+
+ ConnRef *connRef145 = new ConnRef(router, 145);
+ ConnEnd srcPt145(Point(119, 908), 15);
+ connRef145->setSourceEndpoint(srcPt145);
+ ConnEnd dstPt145(Point(119, 951), 15);
+ connRef145->setDestEndpoint(dstPt145);
+ connRef145->setRoutingType((ConnType)2);
+
+ ConnRef *connRef146 = new ConnRef(router, 146);
+ ConnEnd srcPt146(Point(119, 908), 15);
+ connRef146->setSourceEndpoint(srcPt146);
+ ConnEnd dstPt146(Point(119, 861), 15);
+ connRef146->setDestEndpoint(dstPt146);
+ connRef146->setRoutingType((ConnType)2);
+
+ ConnRef *connRef147 = new ConnRef(router, 147);
+ ConnEnd srcPt147(Point(262, 961), 15);
+ connRef147->setSourceEndpoint(srcPt147);
+ ConnEnd dstPt147(Point(119, 951), 15);
+ connRef147->setDestEndpoint(dstPt147);
+ connRef147->setRoutingType((ConnType)2);
+
+ ConnRef *connRef148 = new ConnRef(router, 148);
+ ConnEnd srcPt148(Point(262, 961), 15);
+ connRef148->setSourceEndpoint(srcPt148);
+ ConnEnd dstPt148(Point(351, 951), 15);
+ connRef148->setDestEndpoint(dstPt148);
+ connRef148->setRoutingType((ConnType)2);
+
+ ConnRef *connRef149 = new ConnRef(router, 149);
+ ConnEnd srcPt149(Point(629, 336), 15);
+ connRef149->setSourceEndpoint(srcPt149);
+ ConnEnd dstPt149(Point(456, 446), 15);
+ connRef149->setDestEndpoint(dstPt149);
+ connRef149->setRoutingType((ConnType)2);
+
+ ConnRef *connRef150 = new ConnRef(router, 150);
+ ConnEnd srcPt150(Point(351, 909), 15);
+ connRef150->setSourceEndpoint(srcPt150);
+ ConnEnd dstPt150(Point(351, 951), 15);
+ connRef150->setDestEndpoint(dstPt150);
+ connRef150->setRoutingType((ConnType)2);
+
+ ConnRef *connRef151 = new ConnRef(router, 151);
+ ConnEnd srcPt151(Point(460, 940), 15);
+ connRef151->setSourceEndpoint(srcPt151);
+ ConnEnd dstPt151(Point(351, 951), 15);
+ connRef151->setDestEndpoint(dstPt151);
+ connRef151->setRoutingType((ConnType)2);
+
+ ConnRef *connRef152 = new ConnRef(router, 152);
+ ConnEnd srcPt152(Point(412, 940), 15);
+ connRef152->setSourceEndpoint(srcPt152);
+ ConnEnd dstPt152(Point(351, 951), 15);
+ connRef152->setDestEndpoint(dstPt152);
+ connRef152->setRoutingType((ConnType)2);
+
+ ConnRef *connRef153 = new ConnRef(router, 153);
+ ConnEnd srcPt153(Point(404, 871), 15);
+ connRef153->setSourceEndpoint(srcPt153);
+ ConnEnd dstPt153(Point(351, 861), 15);
+ connRef153->setDestEndpoint(dstPt153);
+ connRef153->setRoutingType((ConnType)2);
+
+ ConnRef *connRef154 = new ConnRef(router, 154);
+ ConnEnd srcPt154(Point(404, 850), 15);
+ connRef154->setSourceEndpoint(srcPt154);
+ ConnEnd dstPt154(Point(351, 861), 15);
+ connRef154->setDestEndpoint(dstPt154);
+ connRef154->setRoutingType((ConnType)2);
+
+ ConnRef *connRef155 = new ConnRef(router, 155);
+ ConnEnd srcPt155(Point(292, 862), 15);
+ connRef155->setSourceEndpoint(srcPt155);
+ ConnEnd dstPt155(Point(351, 818), 15);
+ connRef155->setDestEndpoint(dstPt155);
+ connRef155->setRoutingType((ConnType)2);
+
+ ConnRef *connRef156 = new ConnRef(router, 156);
+ ConnEnd srcPt156(Point(292, 862), 15);
+ connRef156->setSourceEndpoint(srcPt156);
+ ConnEnd dstPt156(Point(238, 861), 15);
+ connRef156->setDestEndpoint(dstPt156);
+ connRef156->setRoutingType((ConnType)2);
+
+ ConnRef *connRef157 = new ConnRef(router, 157);
+ ConnEnd srcPt157(Point(183, 862), 15);
+ connRef157->setSourceEndpoint(srcPt157);
+ ConnEnd dstPt157(Point(119, 861), 15);
+ connRef157->setDestEndpoint(dstPt157);
+ connRef157->setRoutingType((ConnType)2);
+
+ ConnRef *connRef158 = new ConnRef(router, 158);
+ ConnEnd srcPt158(Point(183, 862), 15);
+ connRef158->setSourceEndpoint(srcPt158);
+ ConnEnd dstPt158(Point(238, 861), 15);
+ connRef158->setDestEndpoint(dstPt158);
+ connRef158->setRoutingType((ConnType)2);
+
+ ConnRef *connRef159 = new ConnRef(router, 159);
+ ConnEnd srcPt159(Point(183, 862), 15);
+ connRef159->setSourceEndpoint(srcPt159);
+ ConnEnd dstPt159(Point(185, 904), 15);
+ connRef159->setDestEndpoint(dstPt159);
+ connRef159->setRoutingType((ConnType)2);
+
+ ConnRef *connRef160 = new ConnRef(router, 160);
+ ConnEnd srcPt160(Point(531, 861), 15);
+ connRef160->setSourceEndpoint(srcPt160);
+ ConnEnd dstPt160(Point(600, 861), 15);
+ connRef160->setDestEndpoint(dstPt160);
+ connRef160->setRoutingType((ConnType)2);
+
+ ConnRef *connRef161 = new ConnRef(router, 161);
+ ConnEnd srcPt161(Point(531, 861), 15);
+ connRef161->setSourceEndpoint(srcPt161);
+ ConnEnd dstPt161(Point(456, 861), 15);
+ connRef161->setDestEndpoint(dstPt161);
+ connRef161->setRoutingType((ConnType)2);
+
+ ConnRef *connRef162 = new ConnRef(router, 162);
+ ConnEnd srcPt162(Point(456, 767), 15);
+ connRef162->setSourceEndpoint(srcPt162);
+ ConnEnd dstPt162(Point(456, 861), 15);
+ connRef162->setDestEndpoint(dstPt162);
+ connRef162->setRoutingType((ConnType)2);
+
+ ConnRef *connRef163 = new ConnRef(router, 163);
+ ConnEnd srcPt163(Point(456, 698), 15);
+ connRef163->setSourceEndpoint(srcPt163);
+ ConnEnd dstPt163(Point(456, 662), 15);
+ connRef163->setDestEndpoint(dstPt163);
+ connRef163->setRoutingType((ConnType)2);
+
+ ConnRef *connRef164 = new ConnRef(router, 164);
+ ConnEnd srcPt164(Point(456, 698), 15);
+ connRef164->setSourceEndpoint(srcPt164);
+ ConnEnd dstPt164(Point(456, 734), 15);
+ connRef164->setDestEndpoint(dstPt164);
+ connRef164->setRoutingType((ConnType)2);
+
+ ConnRef *connRef165 = new ConnRef(router, 165);
+ ConnEnd srcPt165(Point(457, 626), 15);
+ connRef165->setSourceEndpoint(srcPt165);
+ ConnEnd dstPt165(Point(456, 662), 15);
+ connRef165->setDestEndpoint(dstPt165);
+ connRef165->setRoutingType((ConnType)2);
+
+ ConnRef *connRef166 = new ConnRef(router, 166);
+ ConnEnd srcPt166(Point(457, 626), 15);
+ connRef166->setSourceEndpoint(srcPt166);
+ ConnEnd dstPt166(Point(456, 590), 15);
+ connRef166->setDestEndpoint(dstPt166);
+ connRef166->setRoutingType((ConnType)2);
+
+ ConnRef *connRef167 = new ConnRef(router, 167);
+ ConnEnd srcPt167(Point(431, 481), 15);
+ connRef167->setSourceEndpoint(srcPt167);
+ ConnEnd dstPt167(Point(456, 518), 15);
+ connRef167->setDestEndpoint(dstPt167);
+ connRef167->setRoutingType((ConnType)2);
+
+ ConnRef *connRef168 = new ConnRef(router, 168);
+ ConnEnd srcPt168(Point(431, 481), 15);
+ connRef168->setSourceEndpoint(srcPt168);
+ ConnEnd dstPt168(Point(456, 446), 15);
+ connRef168->setDestEndpoint(dstPt168);
+ connRef168->setRoutingType((ConnType)2);
+
+ ConnRef *connRef169 = new ConnRef(router, 169);
+ ConnEnd srcPt169(Point(376, 447), 15);
+ connRef169->setSourceEndpoint(srcPt169);
+ ConnEnd dstPt169(Point(305, 446), 15);
+ connRef169->setDestEndpoint(dstPt169);
+ connRef169->setRoutingType((ConnType)2);
+
+ ConnRef *connRef170 = new ConnRef(router, 170);
+ ConnEnd srcPt170(Point(376, 447), 15);
+ connRef170->setSourceEndpoint(srcPt170);
+ ConnEnd dstPt170(Point(456, 446), 15);
+ connRef170->setDestEndpoint(dstPt170);
+ connRef170->setRoutingType((ConnType)2);
+
+ ConnRef *connRef171 = new ConnRef(router, 171);
+ ConnEnd srcPt171(Point(456, 401), 15);
+ connRef171->setSourceEndpoint(srcPt171);
+ ConnEnd dstPt171(Point(305, 446), 15);
+ connRef171->setDestEndpoint(dstPt171);
+ connRef171->setRoutingType((ConnType)2);
+
+ ConnRef *connRef172 = new ConnRef(router, 172);
+ ConnEnd srcPt172(Point(456, 401), 15);
+ connRef172->setSourceEndpoint(srcPt172);
+ ConnEnd dstPt172(Point(456, 371), 15);
+ connRef172->setDestEndpoint(dstPt172);
+ connRef172->setRoutingType((ConnType)2);
+
+ ConnRef *connRef173 = new ConnRef(router, 173);
+ ConnEnd srcPt173(Point(456, 401), 15);
+ connRef173->setSourceEndpoint(srcPt173);
+ ConnEnd dstPt173(Point(456, 446), 15);
+ connRef173->setDestEndpoint(dstPt173);
+ connRef173->setRoutingType((ConnType)2);
+
+ ConnRef *connRef174 = new ConnRef(router, 174);
+ ConnEnd srcPt174(Point(456, 335), 15);
+ connRef174->setSourceEndpoint(srcPt174);
+ ConnEnd dstPt174(Point(456, 371), 15);
+ connRef174->setDestEndpoint(dstPt174);
+ connRef174->setRoutingType((ConnType)2);
+
+ ConnRef *connRef175 = new ConnRef(router, 175);
+ ConnEnd srcPt175(Point(403, 335), 15);
+ connRef175->setSourceEndpoint(srcPt175);
+ ConnEnd dstPt175(Point(456, 301), 15);
+ connRef175->setDestEndpoint(dstPt175);
+ connRef175->setRoutingType((ConnType)2);
+
+ ConnRef *connRef176 = new ConnRef(router, 176);
+ ConnEnd srcPt176(Point(525, 192), 15);
+ connRef176->setSourceEndpoint(srcPt176);
+ ConnEnd dstPt176(Point(456, 228), 15);
+ connRef176->setDestEndpoint(dstPt176);
+ connRef176->setRoutingType((ConnType)2);
+
+ ConnRef *connRef177 = new ConnRef(router, 177);
+ ConnEnd srcPt177(Point(456, 265), 15);
+ connRef177->setSourceEndpoint(srcPt177);
+ ConnEnd dstPt177(Point(456, 228), 15);
+ connRef177->setDestEndpoint(dstPt177);
+ connRef177->setRoutingType((ConnType)2);
+
+ ConnRef *connRef178 = new ConnRef(router, 178);
+ ConnEnd srcPt178(Point(456, 265), 15);
+ connRef178->setSourceEndpoint(srcPt178);
+ ConnEnd dstPt178(Point(456, 301), 15);
+ connRef178->setDestEndpoint(dstPt178);
+ connRef178->setRoutingType((ConnType)2);
+
+ ConnRef *connRef179 = new ConnRef(router, 179);
+ ConnEnd srcPt179(Point(456, 170), 15);
+ connRef179->setSourceEndpoint(srcPt179);
+ ConnEnd dstPt179(Point(456, 141), 15);
+ connRef179->setDestEndpoint(dstPt179);
+ connRef179->setRoutingType((ConnType)2);
+
+ ConnRef *connRef180 = new ConnRef(router, 180);
+ ConnEnd srcPt180(Point(456, 170), 15);
+ connRef180->setSourceEndpoint(srcPt180);
+ ConnEnd dstPt180(Point(456, 228), 15);
+ connRef180->setDestEndpoint(dstPt180);
+ connRef180->setRoutingType((ConnType)2);
+
+ ConnRef *connRef181 = new ConnRef(router, 181);
+ ConnEnd srcPt181(Point(376, 299), 15);
+ connRef181->setSourceEndpoint(srcPt181);
+ ConnEnd dstPt181(Point(305, 299), 15);
+ connRef181->setDestEndpoint(dstPt181);
+ connRef181->setRoutingType((ConnType)2);
+
+ ConnRef *connRef182 = new ConnRef(router, 182);
+ ConnEnd srcPt182(Point(376, 299), 15);
+ connRef182->setSourceEndpoint(srcPt182);
+ ConnEnd dstPt182(Point(456, 301), 15);
+ connRef182->setDestEndpoint(dstPt182);
+ connRef182->setRoutingType((ConnType)2);
+
+ ConnRef *connRef183 = new ConnRef(router, 183);
+ ConnEnd srcPt183(Point(221, 280), 15);
+ connRef183->setSourceEndpoint(srcPt183);
+ ConnEnd dstPt183(Point(154, 299), 15);
+ connRef183->setDestEndpoint(dstPt183);
+ connRef183->setRoutingType((ConnType)2);
+
+ ConnRef *connRef184 = new ConnRef(router, 184);
+ ConnEnd srcPt184(Point(221, 280), 15);
+ connRef184->setSourceEndpoint(srcPt184);
+ ConnEnd dstPt184(Point(305, 299), 15);
+ connRef184->setDestEndpoint(dstPt184);
+ connRef184->setRoutingType((ConnType)2);
+
+ ConnRef *connRef185 = new ConnRef(router, 185);
+ ConnEnd srcPt185(Point(221, 299), 15);
+ connRef185->setSourceEndpoint(srcPt185);
+ ConnEnd dstPt185(Point(154, 299), 15);
+ connRef185->setDestEndpoint(dstPt185);
+ connRef185->setRoutingType((ConnType)2);
+
+ ConnRef *connRef186 = new ConnRef(router, 186);
+ ConnEnd srcPt186(Point(221, 299), 15);
+ connRef186->setSourceEndpoint(srcPt186);
+ ConnEnd dstPt186(Point(305, 299), 15);
+ connRef186->setDestEndpoint(dstPt186);
+ connRef186->setRoutingType((ConnType)2);
+
+ ConnRef *connRef187 = new ConnRef(router, 187);
+ ConnEnd srcPt187(Point(330, 266), 15);
+ connRef187->setSourceEndpoint(srcPt187);
+ ConnEnd dstPt187(Point(305, 299), 15);
+ connRef187->setDestEndpoint(dstPt187);
+ connRef187->setRoutingType((ConnType)2);
+
+ ConnRef *connRef188 = new ConnRef(router, 188);
+ ConnEnd srcPt188(Point(330, 266), 15);
+ connRef188->setSourceEndpoint(srcPt188);
+ ConnEnd dstPt188(Point(456, 228), 15);
+ connRef188->setDestEndpoint(dstPt188);
+ connRef188->setRoutingType((ConnType)2);
+
+ ConnRef *connRef189 = new ConnRef(router, 189);
+ ConnEnd srcPt189(Point(280, 266), 15);
+ connRef189->setSourceEndpoint(srcPt189);
+ ConnEnd dstPt189(Point(305, 299), 15);
+ connRef189->setDestEndpoint(dstPt189);
+ connRef189->setRoutingType((ConnType)2);
+
+ ConnRef *connRef190 = new ConnRef(router, 190);
+ ConnEnd srcPt190(Point(280, 266), 15);
+ connRef190->setSourceEndpoint(srcPt190);
+ ConnEnd dstPt190(Point(456, 228), 15);
+ connRef190->setDestEndpoint(dstPt190);
+ connRef190->setRoutingType((ConnType)2);
+
+ ConnRef *connRef191 = new ConnRef(router, 191);
+ ConnEnd srcPt191(Point(154, 261), 15);
+ connRef191->setSourceEndpoint(srcPt191);
+ ConnEnd dstPt191(Point(154, 226), 15);
+ connRef191->setDestEndpoint(dstPt191);
+ connRef191->setRoutingType((ConnType)2);
+
+ ConnRef *connRef192 = new ConnRef(router, 192);
+ ConnEnd srcPt192(Point(154, 261), 15);
+ connRef192->setSourceEndpoint(srcPt192);
+ ConnEnd dstPt192(Point(154, 299), 15);
+ connRef192->setDestEndpoint(dstPt192);
+ connRef192->setRoutingType((ConnType)2);
+
+ ConnRef *connRef193 = new ConnRef(router, 193);
+ ConnEnd srcPt193(Point(221, 224), 15);
+ connRef193->setSourceEndpoint(srcPt193);
+ ConnEnd dstPt193(Point(456, 228), 15);
+ connRef193->setDestEndpoint(dstPt193);
+ connRef193->setRoutingType((ConnType)2);
+
+ ConnRef *connRef194 = new ConnRef(router, 194);
+ ConnEnd srcPt194(Point(221, 205), 15);
+ connRef194->setSourceEndpoint(srcPt194);
+ ConnEnd dstPt194(Point(456, 228), 15);
+ connRef194->setDestEndpoint(dstPt194);
+ connRef194->setRoutingType((ConnType)2);
+
+ ConnRef *connRef195 = new ConnRef(router, 195);
+ ConnEnd srcPt195(Point(289, 183), 15);
+ connRef195->setSourceEndpoint(srcPt195);
+ ConnEnd dstPt195(Point(154, 226), 15);
+ connRef195->setDestEndpoint(dstPt195);
+ connRef195->setRoutingType((ConnType)2);
+
+ ConnRef *connRef196 = new ConnRef(router, 196);
+ ConnEnd srcPt196(Point(289, 183), 15);
+ connRef196->setSourceEndpoint(srcPt196);
+ ConnEnd dstPt196(Point(456, 228), 15);
+ connRef196->setDestEndpoint(dstPt196);
+ connRef196->setRoutingType((ConnType)2);
+
+ ConnRef *connRef197 = new ConnRef(router, 197);
+ ConnEnd srcPt197(Point(316, 151), 15);
+ connRef197->setSourceEndpoint(srcPt197);
+ ConnEnd dstPt197(Point(154, 226), 15);
+ connRef197->setDestEndpoint(dstPt197);
+ connRef197->setRoutingType((ConnType)2);
+
+ ConnRef *connRef198 = new ConnRef(router, 198);
+ ConnEnd srcPt198(Point(316, 130), 15);
+ connRef198->setSourceEndpoint(srcPt198);
+ ConnEnd dstPt198(Point(154, 226), 15);
+ connRef198->setDestEndpoint(dstPt198);
+ connRef198->setRoutingType((ConnType)2);
+
+ ConnRef *connRef199 = new ConnRef(router, 199);
+ ConnEnd srcPt199(Point(235, 905), 15);
+ connRef199->setSourceEndpoint(srcPt199);
+ ConnEnd dstPt199(Point(287, 904), 15);
+ connRef199->setDestEndpoint(dstPt199);
+ connRef199->setRoutingType((ConnType)2);
+
+ ConnRef *connRef200 = new ConnRef(router, 200);
+ ConnEnd srcPt200(Point(456, 553), 15);
+ connRef200->setSourceEndpoint(srcPt200);
+ ConnEnd dstPt200(Point(456, 590), 15);
+ connRef200->setDestEndpoint(dstPt200);
+ connRef200->setRoutingType((ConnType)2);
+
+ ConnRef *connRef201 = new ConnRef(router, 201);
+ ConnEnd srcPt201(Point(456, 553), 15);
+ connRef201->setSourceEndpoint(srcPt201);
+ ConnEnd dstPt201(Point(456, 518), 15);
+ connRef201->setDestEndpoint(dstPt201);
+ connRef201->setRoutingType((ConnType)2);
+
+ ConnRef *connRef202 = new ConnRef(router, 202);
+ ConnEnd srcPt202(Point(221, 243), 15);
+ connRef202->setSourceEndpoint(srcPt202);
+ ConnEnd dstPt202(Point(456, 228), 15);
+ connRef202->setDestEndpoint(dstPt202);
+ connRef202->setRoutingType((ConnType)2);
+
+ ConnRef *connRef203 = new ConnRef(router, 203);
+ ConnEnd srcPt203(Point(221, 318), 15);
+ connRef203->setSourceEndpoint(srcPt203);
+ ConnEnd dstPt203(Point(305, 299), 15);
+ connRef203->setDestEndpoint(dstPt203);
+ connRef203->setRoutingType((ConnType)2);
+
+ ConnRef *connRef204 = new ConnRef(router, 204);
+ ConnEnd srcPt204(Point(154, 357), 15);
+ connRef204->setSourceEndpoint(srcPt204);
+ ConnEnd dstPt204(Point(212, 356), 15);
+ connRef204->setDestEndpoint(dstPt204);
+ connRef204->setRoutingType((ConnType)2);
+
+ ConnRef *connRef205 = new ConnRef(router, 205);
+ ConnEnd srcPt205(Point(154, 383), 15);
+ connRef205->setSourceEndpoint(srcPt205);
+ ConnEnd dstPt205(Point(212, 382), 15);
+ connRef205->setDestEndpoint(dstPt205);
+ connRef205->setRoutingType((ConnType)2);
+
+ ConnRef *connRef206 = new ConnRef(router, 206);
+ ConnEnd srcPt206(Point(264, 356), 15);
+ connRef206->setSourceEndpoint(srcPt206);
+ ConnEnd dstPt206(Point(305, 299), 15);
+ connRef206->setDestEndpoint(dstPt206);
+ connRef206->setRoutingType((ConnType)2);
+
+ ConnRef *connRef207 = new ConnRef(router, 207);
+ ConnEnd srcPt207(Point(264, 382), 15);
+ connRef207->setSourceEndpoint(srcPt207);
+ ConnEnd dstPt207(Point(305, 299), 15);
+ connRef207->setDestEndpoint(dstPt207);
+ connRef207->setRoutingType((ConnType)2);
+
+ ConnRef *connRef208 = new ConnRef(router, 208);
+ ConnEnd srcPt208(Point(574, 193), 15);
+ connRef208->setSourceEndpoint(srcPt208);
+ ConnEnd dstPt208(Point(525, 192), 15);
+ connRef208->setDestEndpoint(dstPt208);
+ connRef208->setRoutingType((ConnType)2);
+
+ ConnRef *connRef209 = new ConnRef(router, 209);
+ ConnEnd srcPt209(Point(456, 141), 15);
+ connRef209->setSourceEndpoint(srcPt209);
+ ConnEnd dstPt209(Point(458, 74), 15);
+ connRef209->setDestEndpoint(dstPt209);
+ connRef209->setRoutingType((ConnType)2);
+
+ ConnRef *connRef210 = new ConnRef(router, 210);
+ ConnEnd srcPt210(Point(456, 662), 15);
+ connRef210->setSourceEndpoint(srcPt210);
+ ConnEnd dstPt210(Point(629, 336), 15);
+ connRef210->setDestEndpoint(dstPt210);
+ connRef210->setRoutingType((ConnType)2);
+
+ ConnRef *connRef211 = new ConnRef(router, 211);
+ ConnEnd srcPt211(Point(154, 226), 15);
+ connRef211->setSourceEndpoint(srcPt211);
+ ConnEnd dstPt211(Point(221, 243), 15);
+ connRef211->setDestEndpoint(dstPt211);
+ connRef211->setRoutingType((ConnType)2);
+
+ ConnRef *connRef212 = new ConnRef(router, 212);
+ ConnEnd srcPt212(Point(221, 318), 15);
+ connRef212->setSourceEndpoint(srcPt212);
+ ConnEnd dstPt212(Point(154, 299), 15);
+ connRef212->setDestEndpoint(dstPt212);
+ connRef212->setRoutingType((ConnType)2);
+
+ ConnRef *connRef213 = new ConnRef(router, 213);
+ ConnEnd srcPt213(Point(456, 228), 15);
+ connRef213->setSourceEndpoint(srcPt213);
+ ConnEnd dstPt213(Point(629, 336), 15);
+ connRef213->setDestEndpoint(dstPt213);
+ connRef213->setRoutingType((ConnType)2);
+
+ ConnRef *connRef214 = new ConnRef(router, 214);
+ ConnEnd srcPt214(Point(456, 734), 15);
+ connRef214->setSourceEndpoint(srcPt214);
+ ConnEnd dstPt214(Point(49, 798), 15);
+ connRef214->setDestEndpoint(dstPt214);
+ connRef214->setRoutingType((ConnType)2);
+
+ ConnRef *connRef215 = new ConnRef(router, 215);
+ ConnEnd srcPt215(Point(177, 744), 15);
+ connRef215->setSourceEndpoint(srcPt215);
+ ConnEnd dstPt215(Point(456, 734), 15);
+ connRef215->setDestEndpoint(dstPt215);
+ connRef215->setRoutingType((ConnType)2);
+
+ ConnRef *connRef216 = new ConnRef(router, 216);
+ ConnEnd srcPt216(Point(456, 590), 15);
+ connRef216->setSourceEndpoint(srcPt216);
+ ConnEnd dstPt216(Point(278, 597), 15);
+ connRef216->setDestEndpoint(dstPt216);
+ connRef216->setRoutingType((ConnType)2);
+
+ ConnRef *connRef217 = new ConnRef(router, 217);
+ ConnEnd srcPt217(Point(555, 522), 15);
+ connRef217->setSourceEndpoint(srcPt217);
+ ConnEnd dstPt217(Point(456, 590), 15);
+ connRef217->setDestEndpoint(dstPt217);
+ connRef217->setRoutingType((ConnType)2);
+
+ ConnRef *connRef218 = new ConnRef(router, 218);
+ ConnEnd srcPt218(Point(528, 541), 15);
+ connRef218->setSourceEndpoint(srcPt218);
+ ConnEnd dstPt218(Point(456, 590), 15);
+ connRef218->setDestEndpoint(dstPt218);
+ connRef218->setRoutingType((ConnType)2);
+
+ ConnRef *connRef219 = new ConnRef(router, 219);
+ ConnEnd srcPt219(Point(505, 522), 15);
+ connRef219->setSourceEndpoint(srcPt219);
+ ConnEnd dstPt219(Point(456, 590), 15);
+ connRef219->setDestEndpoint(dstPt219);
+ connRef219->setRoutingType((ConnType)2);
+
+ ConnRef *connRef220 = new ConnRef(router, 220);
+ ConnEnd srcPt220(Point(481, 481), 15);
+ connRef220->setSourceEndpoint(srcPt220);
+ ConnEnd dstPt220(Point(456, 518), 15);
+ connRef220->setDestEndpoint(dstPt220);
+ connRef220->setRoutingType((ConnType)2);
+
+ ConnRef *connRef221 = new ConnRef(router, 221);
+ ConnEnd srcPt221(Point(411, 519), 15);
+ connRef221->setSourceEndpoint(srcPt221);
+ ConnEnd dstPt221(Point(456, 518), 15);
+ connRef221->setDestEndpoint(dstPt221);
+ connRef221->setRoutingType((ConnType)2);
+
+ ConnRef *connRef222 = new ConnRef(router, 222);
+ ConnEnd srcPt222(Point(600, 861), 15);
+ connRef222->setSourceEndpoint(srcPt222);
+ ConnEnd dstPt222(Point(601, 917), 15);
+ connRef222->setDestEndpoint(dstPt222);
+ connRef222->setRoutingType((ConnType)2);
+
+ ConnRef *connRef223 = new ConnRef(router, 223);
+ ConnEnd srcPt223(Point(460, 940), 15);
+ connRef223->setSourceEndpoint(srcPt223);
+ ConnEnd dstPt223(Point(523, 951), 15);
+ connRef223->setDestEndpoint(dstPt223);
+ connRef223->setRoutingType((ConnType)2);
+
+ ConnRef *connRef224 = new ConnRef(router, 224);
+ ConnEnd srcPt224(Point(412, 940), 15);
+ connRef224->setSourceEndpoint(srcPt224);
+ ConnEnd dstPt224(Point(523, 951), 15);
+ connRef224->setDestEndpoint(dstPt224);
+ connRef224->setRoutingType((ConnType)2);
+
+ ConnRef *connRef225 = new ConnRef(router, 225);
+ ConnEnd srcPt225(Point(523, 951), 15);
+ connRef225->setSourceEndpoint(srcPt225);
+ ConnEnd dstPt225(Point(412, 961), 15);
+ connRef225->setDestEndpoint(dstPt225);
+ connRef225->setRoutingType((ConnType)2);
+
+ ConnRef *connRef226 = new ConnRef(router, 226);
+ ConnEnd srcPt226(Point(460, 961), 15);
+ connRef226->setSourceEndpoint(srcPt226);
+ ConnEnd dstPt226(Point(523, 951), 15);
+ connRef226->setDestEndpoint(dstPt226);
+ connRef226->setRoutingType((ConnType)2);
+
+ ConnRef *connRef227 = new ConnRef(router, 227);
+ ConnEnd srcPt227(Point(456, 861), 15);
+ connRef227->setSourceEndpoint(srcPt227);
+ ConnEnd dstPt227(Point(629, 336), 15);
+ connRef227->setDestEndpoint(dstPt227);
+ connRef227->setRoutingType((ConnType)2);
+
+ ConnRef *connRef228 = new ConnRef(router, 228);
+ ConnEnd srcPt228(Point(456, 861), 15);
+ connRef228->setSourceEndpoint(srcPt228);
+ ConnEnd dstPt228(Point(49, 798), 15);
+ connRef228->setDestEndpoint(dstPt228);
+ connRef228->setRoutingType((ConnType)2);
+
+ ConnRef *connRef229 = new ConnRef(router, 229);
+ ConnEnd srcPt229(Point(262, 792), 15);
+ connRef229->setSourceEndpoint(srcPt229);
+ ConnEnd dstPt229(Point(456, 861), 15);
+ connRef229->setDestEndpoint(dstPt229);
+ connRef229->setRoutingType((ConnType)2);
+
+ ConnRef *connRef230 = new ConnRef(router, 230);
+ ConnEnd srcPt230(Point(351, 861), 15);
+ connRef230->setSourceEndpoint(srcPt230);
+ ConnEnd dstPt230(Point(351, 909), 15);
+ connRef230->setDestEndpoint(dstPt230);
+ connRef230->setRoutingType((ConnType)2);
+
+ ConnRef *connRef231 = new ConnRef(router, 231);
+ ConnEnd srcPt231(Point(351, 818), 15);
+ connRef231->setSourceEndpoint(srcPt231);
+ ConnEnd dstPt231(Point(404, 871), 15);
+ connRef231->setDestEndpoint(dstPt231);
+ connRef231->setRoutingType((ConnType)2);
+
+ ConnRef *connRef232 = new ConnRef(router, 232);
+ ConnEnd srcPt232(Point(351, 818), 15);
+ connRef232->setSourceEndpoint(srcPt232);
+ ConnEnd dstPt232(Point(404, 850), 15);
+ connRef232->setDestEndpoint(dstPt232);
+ connRef232->setRoutingType((ConnType)2);
+
+ ConnRef *connRef233 = new ConnRef(router, 233);
+ ConnEnd srcPt233(Point(119, 861), 15);
+ connRef233->setSourceEndpoint(srcPt233);
+ ConnEnd dstPt233(Point(49, 798), 15);
+ connRef233->setDestEndpoint(dstPt233);
+ connRef233->setRoutingType((ConnType)2);
+
+ ConnRef *connRef234 = new ConnRef(router, 234);
+ ConnEnd srcPt234(Point(262, 792), 15);
+ connRef234->setSourceEndpoint(srcPt234);
+ ConnEnd dstPt234(Point(119, 861), 15);
+ connRef234->setDestEndpoint(dstPt234);
+ connRef234->setRoutingType((ConnType)2);
+
+ ConnRef *connRef235 = new ConnRef(router, 235);
+ ConnEnd srcPt235(Point(412, 961), 15);
+ connRef235->setSourceEndpoint(srcPt235);
+ ConnEnd dstPt235(Point(351, 951), 15);
+ connRef235->setDestEndpoint(dstPt235);
+ connRef235->setRoutingType((ConnType)2);
+
+ ConnRef *connRef236 = new ConnRef(router, 236);
+ ConnEnd srcPt236(Point(460, 961), 15);
+ connRef236->setSourceEndpoint(srcPt236);
+ ConnEnd dstPt236(Point(351, 951), 15);
+ connRef236->setDestEndpoint(dstPt236);
+ connRef236->setRoutingType((ConnType)2);
+
+ ConnRef *connRef237 = new ConnRef(router, 237);
+ ConnEnd srcPt237(Point(235, 905), 15);
+ connRef237->setSourceEndpoint(srcPt237);
+ ConnEnd dstPt237(Point(185, 904), 15);
+ connRef237->setDestEndpoint(dstPt237);
+ connRef237->setRoutingType((ConnType)2);
+
+ ConnRef *connRef238 = new ConnRef(router, 238);
+ ConnEnd srcPt238(Point(456, 371), 15);
+ connRef238->setSourceEndpoint(srcPt238);
+ ConnEnd dstPt238(Point(403, 335), 15);
+ connRef238->setDestEndpoint(dstPt238);
+ connRef238->setRoutingType((ConnType)2);
+
+ ConnRef *connRef239 = new ConnRef(router, 239);
+ ConnEnd srcPt239(Point(105, 356), 15);
+ connRef239->setSourceEndpoint(srcPt239);
+ ConnEnd dstPt239(Point(154, 357), 15);
+ connRef239->setDestEndpoint(dstPt239);
+ connRef239->setRoutingType((ConnType)2);
+
+ ConnRef *connRef240 = new ConnRef(router, 240);
+ ConnEnd srcPt240(Point(212, 356), 15);
+ connRef240->setSourceEndpoint(srcPt240);
+ ConnEnd dstPt240(Point(264, 356), 15);
+ connRef240->setDestEndpoint(dstPt240);
+ connRef240->setRoutingType((ConnType)2);
+
+ ConnRef *connRef241 = new ConnRef(router, 241);
+ ConnEnd srcPt241(Point(212, 382), 15);
+ connRef241->setSourceEndpoint(srcPt241);
+ ConnEnd dstPt241(Point(264, 382), 15);
+ connRef241->setDestEndpoint(dstPt241);
+ connRef241->setRoutingType((ConnType)2);
+
+ ConnRef *connRef242 = new ConnRef(router, 242);
+ ConnEnd srcPt242(Point(105, 382), 15);
+ connRef242->setSourceEndpoint(srcPt242);
+ ConnEnd dstPt242(Point(154, 383), 15);
+ connRef242->setDestEndpoint(dstPt242);
+ connRef242->setRoutingType((ConnType)2);
+
+ ConnRef *connRef243 = new ConnRef(router, 243);
+ ConnEnd srcPt243(Point(49, 798), 15);
+ connRef243->setSourceEndpoint(srcPt243);
+ ConnEnd dstPt243(Point(119, 734), 15);
+ connRef243->setDestEndpoint(dstPt243);
+ connRef243->setRoutingType((ConnType)2);
+
+ ConnRef *connRef244 = new ConnRef(router, 244);
+ ConnEnd srcPt244(Point(177, 723), 15);
+ connRef244->setSourceEndpoint(srcPt244);
+ ConnEnd dstPt244(Point(456, 734), 15);
+ connRef244->setDestEndpoint(dstPt244);
+ connRef244->setRoutingType((ConnType)2);
+
+ ConnRef *connRef245 = new ConnRef(router, 245);
+ ConnEnd srcPt245(Point(119, 734), 15);
+ connRef245->setSourceEndpoint(srcPt245);
+ ConnEnd dstPt245(Point(177, 723), 15);
+ connRef245->setDestEndpoint(dstPt245);
+ connRef245->setRoutingType((ConnType)2);
+
+ ConnRef *connRef246 = new ConnRef(router, 246);
+ ConnEnd srcPt246(Point(119, 734), 15);
+ connRef246->setSourceEndpoint(srcPt246);
+ ConnEnd dstPt246(Point(177, 744), 15);
+ connRef246->setDestEndpoint(dstPt246);
+ connRef246->setRoutingType((ConnType)2);
+
+ ConnRef *connRef247 = new ConnRef(router, 247);
+ ConnEnd srcPt247(Point(481, 481), 15);
+ connRef247->setSourceEndpoint(srcPt247);
+ ConnEnd dstPt247(Point(456, 446), 15);
+ connRef247->setDestEndpoint(dstPt247);
+ connRef247->setRoutingType((ConnType)2);
+
+ ConnRef *connRef248 = new ConnRef(router, 248);
+ ConnEnd srcPt248(Point(410, 583), 15);
+ connRef248->setSourceEndpoint(srcPt248);
+ ConnEnd dstPt248(Point(371, 554), 15);
+ connRef248->setDestEndpoint(dstPt248);
+ connRef248->setRoutingType((ConnType)2);
+
+ ConnRef *connRef249 = new ConnRef(router, 249);
+ ConnEnd srcPt249(Point(410, 583), 15);
+ connRef249->setSourceEndpoint(srcPt249);
+ ConnEnd dstPt249(Point(456, 590), 15);
+ connRef249->setDestEndpoint(dstPt249);
+ connRef249->setRoutingType((ConnType)2);
+
+ ConnRef *connRef250 = new ConnRef(router, 250);
+ ConnEnd srcPt250(Point(411, 519), 15);
+ connRef250->setSourceEndpoint(srcPt250);
+ ConnEnd dstPt250(Point(371, 554), 15);
+ connRef250->setDestEndpoint(dstPt250);
+ connRef250->setRoutingType((ConnType)2);
+
+ ConnRef *connRef251 = new ConnRef(router, 251);
+ ConnEnd srcPt251(Point(456, 446), 15);
+ connRef251->setSourceEndpoint(srcPt251);
+ ConnEnd dstPt251(Point(555, 522), 15);
+ connRef251->setDestEndpoint(dstPt251);
+ connRef251->setRoutingType((ConnType)2);
+
+ ConnRef *connRef252 = new ConnRef(router, 252);
+ ConnEnd srcPt252(Point(456, 446), 15);
+ connRef252->setSourceEndpoint(srcPt252);
+ ConnEnd dstPt252(Point(528, 541), 15);
+ connRef252->setDestEndpoint(dstPt252);
+ connRef252->setRoutingType((ConnType)2);
+
+ ConnRef *connRef253 = new ConnRef(router, 253);
+ ConnEnd srcPt253(Point(456, 446), 15);
+ connRef253->setSourceEndpoint(srcPt253);
+ ConnEnd dstPt253(Point(505, 522), 15);
+ connRef253->setDestEndpoint(dstPt253);
+ connRef253->setRoutingType((ConnType)2);
+
+ ConnRef *connRef254 = new ConnRef(router, 254);
+ ConnEnd srcPt254(Point(262, 990), 15);
+ connRef254->setSourceEndpoint(srcPt254);
+ ConnEnd dstPt254(Point(262, 940), 15);
+ connRef254->setDestEndpoint(dstPt254);
+ connRef254->setRoutingType((ConnType)2);
+
+ ConnRef *connRef255 = new ConnRef(router, 255);
+ ConnEnd srcPt255(Point(57, 908), 15);
+ connRef255->setSourceEndpoint(srcPt255);
+ ConnEnd dstPt255(Point(119, 908), 15);
+ connRef255->setDestEndpoint(dstPt255);
+ connRef255->setRoutingType((ConnType)2);
+
+ ConnRef *connRef256 = new ConnRef(router, 256);
+ ConnEnd srcPt256(Point(262, 1011), 15);
+ connRef256->setSourceEndpoint(srcPt256);
+ ConnEnd dstPt256(Point(262, 961), 15);
+ connRef256->setDestEndpoint(dstPt256);
+ connRef256->setRoutingType((ConnType)2);
+
+ ConnRef *connRef257 = new ConnRef(router, 257);
+ ConnEnd srcPt257(Point(289, 909), 15);
+ connRef257->setSourceEndpoint(srcPt257);
+ ConnEnd dstPt257(Point(351, 909), 15);
+ connRef257->setDestEndpoint(dstPt257);
+ connRef257->setRoutingType((ConnType)2);
+
+ ConnRef *connRef258 = new ConnRef(router, 258);
+ ConnEnd srcPt258(Point(460, 890), 15);
+ connRef258->setSourceEndpoint(srcPt258);
+ ConnEnd dstPt258(Point(460, 940), 15);
+ connRef258->setDestEndpoint(dstPt258);
+ connRef258->setRoutingType((ConnType)2);
+
+ ConnRef *connRef259 = new ConnRef(router, 259);
+ ConnEnd srcPt259(Point(412, 990), 15);
+ connRef259->setSourceEndpoint(srcPt259);
+ ConnEnd dstPt259(Point(412, 940), 15);
+ connRef259->setDestEndpoint(dstPt259);
+ connRef259->setRoutingType((ConnType)2);
+
+ ConnRef *connRef260 = new ConnRef(router, 260);
+ ConnEnd srcPt260(Point(342, 871), 15);
+ connRef260->setSourceEndpoint(srcPt260);
+ ConnEnd dstPt260(Point(404, 871), 15);
+ connRef260->setDestEndpoint(dstPt260);
+ connRef260->setRoutingType((ConnType)2);
+
+ ConnRef *connRef261 = new ConnRef(router, 261);
+ ConnEnd srcPt261(Point(466, 850), 15);
+ connRef261->setSourceEndpoint(srcPt261);
+ ConnEnd dstPt261(Point(404, 850), 15);
+ connRef261->setDestEndpoint(dstPt261);
+ connRef261->setRoutingType((ConnType)2);
+
+ ConnRef *connRef262 = new ConnRef(router, 262);
+ ConnEnd srcPt262(Point(230, 862), 15);
+ connRef262->setSourceEndpoint(srcPt262);
+ ConnEnd dstPt262(Point(292, 862), 15);
+ connRef262->setDestEndpoint(dstPt262);
+ connRef262->setRoutingType((ConnType)2);
+
+ ConnRef *connRef263 = new ConnRef(router, 263);
+ ConnEnd srcPt263(Point(183, 812), 15);
+ connRef263->setSourceEndpoint(srcPt263);
+ ConnEnd dstPt263(Point(183, 862), 15);
+ connRef263->setDestEndpoint(dstPt263);
+ connRef263->setRoutingType((ConnType)2);
+
+ ConnRef *connRef264 = new ConnRef(router, 264);
+ ConnEnd srcPt264(Point(531, 811), 15);
+ connRef264->setSourceEndpoint(srcPt264);
+ ConnEnd dstPt264(Point(531, 861), 15);
+ connRef264->setDestEndpoint(dstPt264);
+ connRef264->setRoutingType((ConnType)2);
+
+ ConnRef *connRef265 = new ConnRef(router, 265);
+ ConnEnd srcPt265(Point(518, 767), 15);
+ connRef265->setSourceEndpoint(srcPt265);
+ ConnEnd dstPt265(Point(456, 767), 15);
+ connRef265->setDestEndpoint(dstPt265);
+ connRef265->setRoutingType((ConnType)2);
+
+ ConnRef *connRef266 = new ConnRef(router, 266);
+ ConnEnd srcPt266(Point(394, 698), 15);
+ connRef266->setSourceEndpoint(srcPt266);
+ ConnEnd dstPt266(Point(456, 698), 15);
+ connRef266->setDestEndpoint(dstPt266);
+ connRef266->setRoutingType((ConnType)2);
+
+ ConnRef *connRef267 = new ConnRef(router, 267);
+ ConnEnd srcPt267(Point(395, 626), 15);
+ connRef267->setSourceEndpoint(srcPt267);
+ ConnEnd dstPt267(Point(457, 626), 15);
+ connRef267->setDestEndpoint(dstPt267);
+ connRef267->setRoutingType((ConnType)2);
+
+ ConnRef *connRef268 = new ConnRef(router, 268);
+ ConnEnd srcPt268(Point(369, 481), 15);
+ connRef268->setSourceEndpoint(srcPt268);
+ ConnEnd dstPt268(Point(431, 481), 15);
+ connRef268->setDestEndpoint(dstPt268);
+ connRef268->setRoutingType((ConnType)2);
+
+ ConnRef *connRef269 = new ConnRef(router, 269);
+ ConnEnd srcPt269(Point(376, 397), 15);
+ connRef269->setSourceEndpoint(srcPt269);
+ ConnEnd dstPt269(Point(376, 447), 15);
+ connRef269->setDestEndpoint(dstPt269);
+ connRef269->setRoutingType((ConnType)2);
+
+ ConnRef *connRef270 = new ConnRef(router, 270);
+ ConnEnd srcPt270(Point(518, 401), 15);
+ connRef270->setSourceEndpoint(srcPt270);
+ ConnEnd dstPt270(Point(456, 401), 15);
+ connRef270->setDestEndpoint(dstPt270);
+ connRef270->setRoutingType((ConnType)2);
+
+ ConnRef *connRef271 = new ConnRef(router, 271);
+ ConnEnd srcPt271(Point(518, 335), 15);
+ connRef271->setSourceEndpoint(srcPt271);
+ ConnEnd dstPt271(Point(456, 335), 15);
+ connRef271->setDestEndpoint(dstPt271);
+ connRef271->setRoutingType((ConnType)2);
+
+ ConnRef *connRef272 = new ConnRef(router, 272);
+ ConnEnd srcPt272(Point(403, 385), 15);
+ connRef272->setSourceEndpoint(srcPt272);
+ ConnEnd dstPt272(Point(403, 335), 15);
+ connRef272->setDestEndpoint(dstPt272);
+ connRef272->setRoutingType((ConnType)2);
+
+ ConnRef *connRef273 = new ConnRef(router, 273);
+ ConnEnd srcPt273(Point(525, 142), 15);
+ connRef273->setSourceEndpoint(srcPt273);
+ ConnEnd dstPt273(Point(525, 192), 15);
+ connRef273->setDestEndpoint(dstPt273);
+ connRef273->setRoutingType((ConnType)2);
+
+ ConnRef *connRef274 = new ConnRef(router, 274);
+ ConnEnd srcPt274(Point(518, 265), 15);
+ connRef274->setSourceEndpoint(srcPt274);
+ ConnEnd dstPt274(Point(456, 265), 15);
+ connRef274->setDestEndpoint(dstPt274);
+ connRef274->setRoutingType((ConnType)2);
+
+ ConnRef *connRef275 = new ConnRef(router, 275);
+ ConnEnd srcPt275(Point(394, 170), 15);
+ connRef275->setSourceEndpoint(srcPt275);
+ ConnEnd dstPt275(Point(456, 170), 15);
+ connRef275->setDestEndpoint(dstPt275);
+ connRef275->setRoutingType((ConnType)2);
+
+ ConnRef *connRef276 = new ConnRef(router, 276);
+ ConnEnd srcPt276(Point(376, 249), 15);
+ connRef276->setSourceEndpoint(srcPt276);
+ ConnEnd dstPt276(Point(376, 299), 15);
+ connRef276->setDestEndpoint(dstPt276);
+ connRef276->setRoutingType((ConnType)2);
+
+ ConnRef *connRef277 = new ConnRef(router, 277);
+ ConnEnd srcPt277(Point(221, 230), 15);
+ connRef277->setSourceEndpoint(srcPt277);
+ ConnEnd dstPt277(Point(221, 280), 15);
+ connRef277->setDestEndpoint(dstPt277);
+ connRef277->setRoutingType((ConnType)2);
+
+ ConnRef *connRef278 = new ConnRef(router, 278);
+ ConnEnd srcPt278(Point(221, 249), 15);
+ connRef278->setSourceEndpoint(srcPt278);
+ ConnEnd dstPt278(Point(221, 299), 15);
+ connRef278->setDestEndpoint(dstPt278);
+ connRef278->setRoutingType((ConnType)2);
+
+ ConnRef *connRef279 = new ConnRef(router, 279);
+ ConnEnd srcPt279(Point(392, 266), 15);
+ connRef279->setSourceEndpoint(srcPt279);
+ ConnEnd dstPt279(Point(330, 266), 15);
+ connRef279->setDestEndpoint(dstPt279);
+ connRef279->setRoutingType((ConnType)2);
+
+ ConnRef *connRef280 = new ConnRef(router, 280);
+ ConnEnd srcPt280(Point(218, 266), 15);
+ connRef280->setSourceEndpoint(srcPt280);
+ ConnEnd dstPt280(Point(280, 266), 15);
+ connRef280->setDestEndpoint(dstPt280);
+ connRef280->setRoutingType((ConnType)2);
+
+ ConnRef *connRef281 = new ConnRef(router, 281);
+ ConnEnd srcPt281(Point(92, 261), 15);
+ connRef281->setSourceEndpoint(srcPt281);
+ ConnEnd dstPt281(Point(154, 261), 15);
+ connRef281->setDestEndpoint(dstPt281);
+ connRef281->setRoutingType((ConnType)2);
+
+ ConnRef *connRef282 = new ConnRef(router, 282);
+ ConnEnd srcPt282(Point(221, 174), 15);
+ connRef282->setSourceEndpoint(srcPt282);
+ ConnEnd dstPt282(Point(221, 224), 15);
+ connRef282->setDestEndpoint(dstPt282);
+ connRef282->setRoutingType((ConnType)2);
+
+ ConnRef *connRef283 = new ConnRef(router, 283);
+ ConnEnd srcPt283(Point(221, 155), 15);
+ connRef283->setSourceEndpoint(srcPt283);
+ ConnEnd dstPt283(Point(221, 205), 15);
+ connRef283->setDestEndpoint(dstPt283);
+ connRef283->setRoutingType((ConnType)2);
+
+ ConnRef *connRef284 = new ConnRef(router, 284);
+ ConnEnd srcPt284(Point(289, 233), 15);
+ connRef284->setSourceEndpoint(srcPt284);
+ ConnEnd dstPt284(Point(289, 183), 15);
+ connRef284->setDestEndpoint(dstPt284);
+ connRef284->setRoutingType((ConnType)2);
+
+ ConnRef *connRef285 = new ConnRef(router, 285);
+ ConnEnd srcPt285(Point(316, 101), 15);
+ connRef285->setSourceEndpoint(srcPt285);
+ ConnEnd dstPt285(Point(316, 151), 15);
+ connRef285->setDestEndpoint(dstPt285);
+ connRef285->setRoutingType((ConnType)2);
+
+ ConnRef *connRef286 = new ConnRef(router, 286);
+ ConnEnd srcPt286(Point(316, 180), 15);
+ connRef286->setSourceEndpoint(srcPt286);
+ ConnEnd dstPt286(Point(316, 130), 15);
+ connRef286->setDestEndpoint(dstPt286);
+ connRef286->setRoutingType((ConnType)2);
+
+ ConnRef *connRef287 = new ConnRef(router, 287);
+ ConnEnd srcPt287(Point(235, 855), 15);
+ connRef287->setSourceEndpoint(srcPt287);
+ ConnEnd dstPt287(Point(235, 905), 15);
+ connRef287->setDestEndpoint(dstPt287);
+ connRef287->setRoutingType((ConnType)2);
+
+ ConnRef *connRef288 = new ConnRef(router, 288);
+ ConnEnd srcPt288(Point(394, 553), 15);
+ connRef288->setSourceEndpoint(srcPt288);
+ ConnEnd dstPt288(Point(456, 553), 15);
+ connRef288->setDestEndpoint(dstPt288);
+ connRef288->setRoutingType((ConnType)2);
+
+ ConnRef *connRef289 = new ConnRef(router, 289);
+ ConnEnd srcPt289(Point(221, 193), 15);
+ connRef289->setSourceEndpoint(srcPt289);
+ ConnEnd dstPt289(Point(221, 243), 15);
+ connRef289->setDestEndpoint(dstPt289);
+ connRef289->setRoutingType((ConnType)2);
+
+ ConnRef *connRef290 = new ConnRef(router, 290);
+ ConnEnd srcPt290(Point(221, 268), 15);
+ connRef290->setSourceEndpoint(srcPt290);
+ ConnEnd dstPt290(Point(221, 318), 15);
+ connRef290->setDestEndpoint(dstPt290);
+ connRef290->setRoutingType((ConnType)2);
+
+ ConnRef *connRef291 = new ConnRef(router, 291);
+ ConnEnd srcPt291(Point(154, 307), 15);
+ connRef291->setSourceEndpoint(srcPt291);
+ ConnEnd dstPt291(Point(154, 357), 15);
+ connRef291->setDestEndpoint(dstPt291);
+ connRef291->setRoutingType((ConnType)2);
+
+ ConnRef *connRef292 = new ConnRef(router, 292);
+ ConnEnd srcPt292(Point(154, 433), 15);
+ connRef292->setSourceEndpoint(srcPt292);
+ ConnEnd dstPt292(Point(154, 383), 15);
+ connRef292->setDestEndpoint(dstPt292);
+ connRef292->setRoutingType((ConnType)2);
+
+ ConnRef *connRef293 = new ConnRef(router, 293);
+ ConnEnd srcPt293(Point(264, 306), 15);
+ connRef293->setSourceEndpoint(srcPt293);
+ ConnEnd dstPt293(Point(264, 356), 15);
+ connRef293->setDestEndpoint(dstPt293);
+ connRef293->setRoutingType((ConnType)2);
+
+ ConnRef *connRef294 = new ConnRef(router, 294);
+ ConnEnd srcPt294(Point(264, 432), 15);
+ connRef294->setSourceEndpoint(srcPt294);
+ ConnEnd dstPt294(Point(264, 382), 15);
+ connRef294->setDestEndpoint(dstPt294);
+ connRef294->setRoutingType((ConnType)2);
+
+ ConnRef *connRef295 = new ConnRef(router, 295);
+ ConnEnd srcPt295(Point(177, 673), 15);
+ connRef295->setSourceEndpoint(srcPt295);
+ ConnEnd dstPt295(Point(177, 723), 15);
+ connRef295->setDestEndpoint(dstPt295);
+ connRef295->setRoutingType((ConnType)2);
+
+ ConnRef *connRef296 = new ConnRef(router, 296);
+ ConnEnd srcPt296(Point(412, 911), 15);
+ connRef296->setSourceEndpoint(srcPt296);
+ ConnEnd dstPt296(Point(412, 961), 15);
+ connRef296->setDestEndpoint(dstPt296);
+ connRef296->setRoutingType((ConnType)2);
+
+ ConnRef *connRef297 = new ConnRef(router, 297);
+ ConnEnd srcPt297(Point(177, 694), 15);
+ connRef297->setSourceEndpoint(srcPt297);
+ ConnEnd dstPt297(Point(177, 744), 15);
+ connRef297->setDestEndpoint(dstPt297);
+ connRef297->setRoutingType((ConnType)2);
+
+ ConnRef *connRef298 = new ConnRef(router, 298);
+ ConnEnd srcPt298(Point(460, 1011), 15);
+ connRef298->setSourceEndpoint(srcPt298);
+ ConnEnd dstPt298(Point(460, 961), 15);
+ connRef298->setDestEndpoint(dstPt298);
+ connRef298->setRoutingType((ConnType)2);
+
+ ConnRef *connRef299 = new ConnRef(router, 299);
+ ConnEnd srcPt299(Point(543, 481), 15);
+ connRef299->setSourceEndpoint(srcPt299);
+ ConnEnd dstPt299(Point(481, 481), 15);
+ connRef299->setDestEndpoint(dstPt299);
+ connRef299->setRoutingType((ConnType)2);
+
+ ConnRef *connRef300 = new ConnRef(router, 300);
+ ConnEnd srcPt300(Point(555, 472), 15);
+ connRef300->setSourceEndpoint(srcPt300);
+ ConnEnd dstPt300(Point(555, 522), 15);
+ connRef300->setDestEndpoint(dstPt300);
+ connRef300->setRoutingType((ConnType)2);
+
+ ConnRef *connRef301 = new ConnRef(router, 301);
+ ConnEnd srcPt301(Point(528, 591), 15);
+ connRef301->setSourceEndpoint(srcPt301);
+ ConnEnd dstPt301(Point(528, 541), 15);
+ connRef301->setDestEndpoint(dstPt301);
+ connRef301->setRoutingType((ConnType)2);
+
+ ConnRef *connRef302 = new ConnRef(router, 302);
+ ConnEnd srcPt302(Point(262, 742), 15);
+ connRef302->setSourceEndpoint(srcPt302);
+ ConnEnd dstPt302(Point(262, 792), 15);
+ connRef302->setDestEndpoint(dstPt302);
+ connRef302->setRoutingType((ConnType)2);
+
+ ConnRef *connRef303 = new ConnRef(router, 303);
+ ConnEnd srcPt303(Point(567, 522), 15);
+ connRef303->setSourceEndpoint(srcPt303);
+ ConnEnd dstPt303(Point(505, 522), 15);
+ connRef303->setDestEndpoint(dstPt303);
+ connRef303->setRoutingType((ConnType)2);
+
+ ConnRef *connRef304 = new ConnRef(router, 304);
+ ConnEnd srcPt304(Point(410, 633), 15);
+ connRef304->setSourceEndpoint(srcPt304);
+ ConnEnd dstPt304(Point(410, 583), 15);
+ connRef304->setDestEndpoint(dstPt304);
+ connRef304->setRoutingType((ConnType)2);
+
+ ConnRef *connRef305 = new ConnRef(router, 305);
+ ConnEnd srcPt305(Point(411, 469), 15);
+ connRef305->setSourceEndpoint(srcPt305);
+ ConnEnd dstPt305(Point(411, 519), 15);
+ connRef305->setDestEndpoint(dstPt305);
+ connRef305->setRoutingType((ConnType)2);
+
+ ConnRef *connRef306 = new ConnRef(router, 306);
+ ConnEnd srcPt306(Point(456, 861), 15);
+ connRef306->setSourceEndpoint(srcPt306);
+ ConnEnd dstPt306(Point(404, 871), 15);
+ connRef306->setDestEndpoint(dstPt306);
+ connRef306->setRoutingType((ConnType)2);
+
+ ConnRef *connRef307 = new ConnRef(router, 307);
+ ConnEnd srcPt307(Point(456, 861), 15);
+ connRef307->setSourceEndpoint(srcPt307);
+ ConnEnd dstPt307(Point(404, 850), 15);
+ connRef307->setDestEndpoint(dstPt307);
+ connRef307->setRoutingType((ConnType)2);
+
+ ConnRef *connRef308 = new ConnRef(router, 308);
+ ConnEnd srcPt308(Point(287, 904), 15);
+ connRef308->setSourceEndpoint(srcPt308);
+ ConnEnd dstPt308(Point(292, 862), 15);
+ connRef308->setDestEndpoint(dstPt308);
+ connRef308->setRoutingType((ConnType)2);
+
+ ConnRef *connRef309 = new ConnRef(router, 309);
+ ConnEnd srcPt309(Point(351, 861), 15);
+ connRef309->setSourceEndpoint(srcPt309);
+ ConnEnd dstPt309(Point(292, 862), 15);
+ connRef309->setDestEndpoint(dstPt309);
+ connRef309->setRoutingType((ConnType)2);
+
+ ConnRef *connRef310 = new ConnRef(router, 310);
+ ConnEnd srcPt310(Point(456, 734), 15);
+ connRef310->setSourceEndpoint(srcPt310);
+ ConnEnd dstPt310(Point(456, 767), 15);
+ connRef310->setDestEndpoint(dstPt310);
+ connRef310->setRoutingType((ConnType)2);
+
+ ConnRef *connRef311 = new ConnRef(router, 311);
+ ConnEnd srcPt311(Point(456, 301), 15);
+ connRef311->setSourceEndpoint(srcPt311);
+ ConnEnd dstPt311(Point(456, 335), 15);
+ connRef311->setDestEndpoint(dstPt311);
+ connRef311->setRoutingType((ConnType)2);
+
+ ConnRef *connRef312 = new ConnRef(router, 312);
+ ConnEnd srcPt312(Point(154, 226), 15);
+ connRef312->setSourceEndpoint(srcPt312);
+ ConnEnd dstPt312(Point(221, 224), 15);
+ connRef312->setDestEndpoint(dstPt312);
+ connRef312->setRoutingType((ConnType)2);
+
+ ConnRef *connRef313 = new ConnRef(router, 313);
+ ConnEnd srcPt313(Point(154, 226), 15);
+ connRef313->setSourceEndpoint(srcPt313);
+ ConnEnd dstPt313(Point(221, 205), 15);
+ connRef313->setDestEndpoint(dstPt313);
+ connRef313->setRoutingType((ConnType)2);
+
+ ConnRef *connRef314 = new ConnRef(router, 314);
+ ConnEnd srcPt314(Point(456, 141), 15);
+ connRef314->setSourceEndpoint(srcPt314);
+ ConnEnd dstPt314(Point(316, 151), 15);
+ connRef314->setDestEndpoint(dstPt314);
+ connRef314->setRoutingType((ConnType)2);
+
+ ConnRef *connRef315 = new ConnRef(router, 315);
+ ConnEnd srcPt315(Point(456, 141), 15);
+ connRef315->setSourceEndpoint(srcPt315);
+ ConnEnd dstPt315(Point(316, 130), 15);
+ connRef315->setDestEndpoint(dstPt315);
+ connRef315->setRoutingType((ConnType)2);
+
+ router->processTransaction();
+ router->outputDiagram("output/vertlineassertion");
+ delete router;
+ return 0;
+};
|