diff options
Diffstat (limited to 'src/3rdparty/adaptagrams/libcola/tests/rectclustershapecontainment.cpp')
| -rw-r--r-- | src/3rdparty/adaptagrams/libcola/tests/rectclustershapecontainment.cpp | 2173 |
1 files changed, 2173 insertions, 0 deletions
diff --git a/src/3rdparty/adaptagrams/libcola/tests/rectclustershapecontainment.cpp b/src/3rdparty/adaptagrams/libcola/tests/rectclustershapecontainment.cpp new file mode 100644 index 0000000..3c3d704 --- /dev/null +++ b/src/3rdparty/adaptagrams/libcola/tests/rectclustershapecontainment.cpp @@ -0,0 +1,2173 @@ +#include <vector> +#include "libcola/cola.h" +using namespace cola; +int main(void) { + CompoundConstraints ccs; + std::vector<Edge> es; + double defaultEdgeLength=40; + std::vector<vpsc::Rectangle*> rs; + vpsc::Rectangle *rect = nullptr; + + rect = new vpsc::Rectangle(478, 488, 399, 409); + rs.push_back(rect); + + rect = new vpsc::Rectangle(284, 294, 938, 948); + rs.push_back(rect); + + rect = new vpsc::Rectangle(141, 151, 906, 916); + rs.push_back(rect); + + rect = new vpsc::Rectangle(284, 294, 959, 969); + rs.push_back(rect); + + rect = new vpsc::Rectangle(131, 161, 938, 968); + rs.push_back(rect); + + rect = new vpsc::Rectangle(550, 762, 155.5, 522.5); + rs.push_back(rect); + + rect = new vpsc::Rectangle(430, 540, -6, 158); + rs.push_back(rect); + + rect = new vpsc::Rectangle(373, 383, 907, 917); + rs.push_back(rect); + + rect = new vpsc::Rectangle(482, 492, 938, 948); + rs.push_back(rect); + + rect = new vpsc::Rectangle(434, 444, 938, 948); + rs.push_back(rect); + + rect = new vpsc::Rectangle(426, 436, 869, 879); + rs.push_back(rect); + + rect = new vpsc::Rectangle(426, 436, 848, 858); + rs.push_back(rect); + + rect = new vpsc::Rectangle(314, 324, 860, 870); + rs.push_back(rect); + + rect = new vpsc::Rectangle(205, 215, 860, 870); + rs.push_back(rect); + + rect = new vpsc::Rectangle(553, 563, 859, 869); + rs.push_back(rect); + + rect = new vpsc::Rectangle(345, 423, 746, 780); + rs.push_back(rect); + + rect = new vpsc::Rectangle(478, 488, 765, 775); + rs.push_back(rect); + + rect = new vpsc::Rectangle(-34.5, 162.5, 723, 877); + rs.push_back(rect); + + rect = new vpsc::Rectangle(478, 488, 696, 706); + rs.push_back(rect); + + rect = new vpsc::Rectangle(478, 488, 624, 634); + rs.push_back(rect); + + rect = new vpsc::Rectangle(453, 463, 479, 489); + rs.push_back(rect); + + rect = new vpsc::Rectangle(154.5, 457.5, 574, 624); + rs.push_back(rect); + + rect = new vpsc::Rectangle(398, 408, 445, 455); + rs.push_back(rect); + + rect = new vpsc::Rectangle(453, 463, 331, 341); + rs.push_back(rect); + + rect = new vpsc::Rectangle(403, 413, 331, 341); + rs.push_back(rect); + + rect = new vpsc::Rectangle(547, 557, 191, 201); + rs.push_back(rect); + + rect = new vpsc::Rectangle(478, 488, 260, 270); + rs.push_back(rect); + + rect = new vpsc::Rectangle(478, 488, 168, 178); + rs.push_back(rect); + + rect = new vpsc::Rectangle(380, 390, 297, 307); + rs.push_back(rect); + + rect = new vpsc::Rectangle(228, 238, 286, 296); + rs.push_back(rect); + + rect = new vpsc::Rectangle(228, 238, 307, 317); + rs.push_back(rect); + + rect = new vpsc::Rectangle(352, 362, 259, 269); + rs.push_back(rect); + + rect = new vpsc::Rectangle(302, 312, 259, 269); + rs.push_back(rect); + + rect = new vpsc::Rectangle(176, 186, 259, 269); + rs.push_back(rect); + + rect = new vpsc::Rectangle(228, 238, 234, 244); + rs.push_back(rect); + + rect = new vpsc::Rectangle(228, 238, 213, 223); + rs.push_back(rect); + + rect = new vpsc::Rectangle(311, 321, 181, 191); + rs.push_back(rect); + + rect = new vpsc::Rectangle(338, 348, 149, 159); + rs.push_back(rect); + + rect = new vpsc::Rectangle(338, 348, 128, 138); + rs.push_back(rect); + + rect = new vpsc::Rectangle(40.5, 291.5, 45.5, 70.5); + rs.push_back(rect); + + rect = new vpsc::Rectangle(257, 267, 903, 913); + rs.push_back(rect); + + rect = new vpsc::Rectangle(478, 488, 551, 561); + rs.push_back(rect); + + rect = new vpsc::Rectangle(276, 286, 213, 223); + rs.push_back(rect); + + rect = new vpsc::Rectangle(276, 286, 286, 296); + rs.push_back(rect); + + rect = new vpsc::Rectangle(176, 186, 355, 365); + rs.push_back(rect); + + rect = new vpsc::Rectangle(176, 186, 381, 391); + rs.push_back(rect); + + rect = new vpsc::Rectangle(286, 296, 354, 364); + rs.push_back(rect); + + rect = new vpsc::Rectangle(286, 296, 380, 390); + rs.push_back(rect); + + rect = new vpsc::Rectangle(586, 616, 180, 210); + rs.push_back(rect); + + rect = new vpsc::Rectangle(468, 498, 128, 158); + rs.push_back(rect); + + rect = new vpsc::Rectangle(468, 498, 649, 679); + rs.push_back(rect); + + rect = new vpsc::Rectangle(166, 196, 213, 243); + rs.push_back(rect); + + rect = new vpsc::Rectangle(166, 196, 286, 316); + rs.push_back(rect); + + rect = new vpsc::Rectangle(317, 347, 433, 463); + rs.push_back(rect); + + rect = new vpsc::Rectangle(317, 347, 286, 316); + rs.push_back(rect); + + rect = new vpsc::Rectangle(468, 498, 215, 245); + rs.push_back(rect); + + rect = new vpsc::Rectangle(468, 498, 288, 318); + rs.push_back(rect); + + rect = new vpsc::Rectangle(468, 498, 721, 751); + rs.push_back(rect); + + rect = new vpsc::Rectangle(468, 498, 577, 607); + rs.push_back(rect); + + rect = new vpsc::Rectangle(468, 498, 505, 535); + rs.push_back(rect); + + rect = new vpsc::Rectangle(612, 642, 848, 878); + rs.push_back(rect); + + rect = new vpsc::Rectangle(299, 329, 891, 921); + rs.push_back(rect); + + rect = new vpsc::Rectangle(535, 565, 938, 968); + rs.push_back(rect); + + rect = new vpsc::Rectangle(468, 498, 848, 878); + rs.push_back(rect); + + rect = new vpsc::Rectangle(363, 393, 848, 878); + rs.push_back(rect); + + rect = new vpsc::Rectangle(131, 161, 848, 878); + rs.push_back(rect); + + rect = new vpsc::Rectangle(363, 393, 938, 968); + rs.push_back(rect); + + rect = new vpsc::Rectangle(250, 280, 848, 878); + rs.push_back(rect); + + rect = new vpsc::Rectangle(197, 227, 891, 921); + rs.push_back(rect); + + rect = new vpsc::Rectangle(468, 498, 358, 388); + rs.push_back(rect); + + rect = new vpsc::Rectangle(117, 147, 344, 374); + rs.push_back(rect); + + rect = new vpsc::Rectangle(224, 254, 344, 374); + rs.push_back(rect); + + rect = new vpsc::Rectangle(224, 254, 370, 400); + rs.push_back(rect); + + rect = new vpsc::Rectangle(117, 147, 370, 400); + rs.push_back(rect); + + rect = new vpsc::Rectangle(363, 393, 805, 835); + rs.push_back(rect); + + rect = new vpsc::Rectangle(181, 227, 711, 741); + rs.push_back(rect); + + rect = new vpsc::Rectangle(131, 161, 721, 751); + rs.push_back(rect); + + rect = new vpsc::Rectangle(434, 444, 959, 969); + rs.push_back(rect); + + rect = new vpsc::Rectangle(199, 209, 742, 752); + rs.push_back(rect); + + rect = new vpsc::Rectangle(482, 492, 959, 969); + rs.push_back(rect); + + rect = new vpsc::Rectangle(565.5, 692.5, 842.5, 997.5); + rs.push_back(rect); + + rect = new vpsc::Rectangle(503, 513, 479, 489); + rs.push_back(rect); + + rect = new vpsc::Rectangle(577, 587, 520, 530); + rs.push_back(rect); + + rect = new vpsc::Rectangle(550, 560, 539, 549); + rs.push_back(rect); + + rect = new vpsc::Rectangle(284, 294, 790, 800); + rs.push_back(rect); + + rect = new vpsc::Rectangle(527, 537, 520, 530); + rs.push_back(rect); + + rect = new vpsc::Rectangle(383, 413, 541, 571); + rs.push_back(rect); + + rect = new vpsc::Rectangle(432, 442, 581, 591); + rs.push_back(rect); + + rect = new vpsc::Rectangle(433, 443, 517, 527); + rs.push_back(rect); + + rect = new vpsc::Rectangle(468, 498, 433, 463); + rs.push_back(rect); + + rect = new vpsc::Rectangle(91, 101, 906, 916); + rs.push_back(rect); + + rect = new vpsc::Rectangle(503, 513, 331, 341); + rs.push_back(rect); + + rect = new vpsc::Rectangle(276, 286, 234, 244); + rs.push_back(rect); + + rect = new vpsc::Rectangle(276, 286, 307, 317); + rs.push_back(rect); + + rect = new vpsc::Rectangle(522, 568, 389, 419); + rs.push_back(rect); + + rect = new vpsc::Rectangle(266, 312, 878, 908); + rs.push_back(rect); + + rect = new vpsc::Rectangle(185, 231, 896, 926); + rs.push_back(rect); + + rect = new vpsc::Rectangle(266, 312, 899, 929); + rs.push_back(rect); + + rect = new vpsc::Rectangle(417, 463, 897, 927); + rs.push_back(rect); + + rect = new vpsc::Rectangle(464, 510, 878, 908); + rs.push_back(rect); + + rect = new vpsc::Rectangle(416, 462, 878, 908); + rs.push_back(rect); + + rect = new vpsc::Rectangle(470, 516, 859, 889); + rs.push_back(rect); + + rect = new vpsc::Rectangle(470, 516, 838, 868); + rs.push_back(rect); + + rect = new vpsc::Rectangle(358, 404, 850, 880); + rs.push_back(rect); + + rect = new vpsc::Rectangle(187, 233, 800, 830); + rs.push_back(rect); + + rect = new vpsc::Rectangle(535, 581, 799, 829); + rs.push_back(rect); + + rect = new vpsc::Rectangle(522, 568, 755, 785); + rs.push_back(rect); + + rect = new vpsc::Rectangle(522, 568, 686, 716); + rs.push_back(rect); + + rect = new vpsc::Rectangle(522, 568, 614, 644); + rs.push_back(rect); + + rect = new vpsc::Rectangle(497, 543, 469, 499); + rs.push_back(rect); + + rect = new vpsc::Rectangle(380, 426, 385, 415); + rs.push_back(rect); + + rect = new vpsc::Rectangle(497, 543, 321, 351); + rs.push_back(rect); + + rect = new vpsc::Rectangle(385, 431, 271, 301); + rs.push_back(rect); + + rect = new vpsc::Rectangle(529, 575, 131, 161); + rs.push_back(rect); + + rect = new vpsc::Rectangle(522, 568, 250, 280); + rs.push_back(rect); + + rect = new vpsc::Rectangle(522, 568, 158, 188); + rs.push_back(rect); + + rect = new vpsc::Rectangle(362, 408, 237, 267); + rs.push_back(rect); + + rect = new vpsc::Rectangle(210, 256, 226, 256); + rs.push_back(rect); + + rect = new vpsc::Rectangle(210, 256, 247, 277); + rs.push_back(rect); + + rect = new vpsc::Rectangle(396, 442, 249, 279); + rs.push_back(rect); + + rect = new vpsc::Rectangle(346, 392, 249, 279); + rs.push_back(rect); + + rect = new vpsc::Rectangle(220, 266, 249, 279); + rs.push_back(rect); + + rect = new vpsc::Rectangle(210, 256, 174, 204); + rs.push_back(rect); + + rect = new vpsc::Rectangle(210, 256, 153, 183); + rs.push_back(rect); + + rect = new vpsc::Rectangle(293, 339, 121, 151); + rs.push_back(rect); + + rect = new vpsc::Rectangle(320, 366, 89, 119); + rs.push_back(rect); + + rect = new vpsc::Rectangle(320, 366, 68, 98); + rs.push_back(rect); + + rect = new vpsc::Rectangle(239, 285, 843, 873); + rs.push_back(rect); + + rect = new vpsc::Rectangle(522, 568, 541, 571); + rs.push_back(rect); + + rect = new vpsc::Rectangle(258, 304, 153, 183); + rs.push_back(rect); + + rect = new vpsc::Rectangle(258, 304, 226, 256); + rs.push_back(rect); + + rect = new vpsc::Rectangle(158, 204, 295, 325); + rs.push_back(rect); + + rect = new vpsc::Rectangle(158, 204, 321, 351); + rs.push_back(rect); + + rect = new vpsc::Rectangle(268, 314, 294, 324); + rs.push_back(rect); + + rect = new vpsc::Rectangle(268, 314, 320, 350); + rs.push_back(rect); + + rect = new vpsc::Rectangle(416, 462, 899, 929); + rs.push_back(rect); + + rect = new vpsc::Rectangle(181, 227, 682, 712); + rs.push_back(rect); + + rect = new vpsc::Rectangle(464, 510, 899, 929); + rs.push_back(rect); + + rect = new vpsc::Rectangle(547, 593, 469, 499); + rs.push_back(rect); + + rect = new vpsc::Rectangle(559, 605, 460, 490); + rs.push_back(rect); + + rect = new vpsc::Rectangle(532, 578, 479, 509); + rs.push_back(rect); + + rect = new vpsc::Rectangle(266, 312, 730, 760); + rs.push_back(rect); + + rect = new vpsc::Rectangle(571, 617, 510, 540); + rs.push_back(rect); + + rect = new vpsc::Rectangle(414, 460, 521, 551); + rs.push_back(rect); + + rect = new vpsc::Rectangle(415, 461, 457, 487); + rs.push_back(rect); + + rect = new vpsc::Rectangle(73, 119, 846, 876); + rs.push_back(rect); + + rect = new vpsc::Rectangle(547, 593, 321, 351); + rs.push_back(rect); + + rect = new vpsc::Rectangle(258, 304, 174, 204); + rs.push_back(rect); + + rect = new vpsc::Rectangle(258, 304, 247, 277); + rs.push_back(rect); + + rect = new vpsc::Rectangle(550.5, 600.5, 304.5, 334.5); + rs.push_back(rect); + + rect = new vpsc::Rectangle(550.5, 600.5, 344.5, 374.5); + rs.push_back(rect); + + rect = new vpsc::Rectangle(621.5, 651.5, 473, 523); + rs.push_back(rect); + + rect = new vpsc::Rectangle(661.5, 691.5, 473, 523); + rs.push_back(rect); + + rect = new vpsc::Rectangle(470.5, 500.5, 108.5, 158.5); + rs.push_back(rect); + + rect = new vpsc::Rectangle(113, 163, 765.5, 795.5); + rs.push_back(rect); + + rect = new vpsc::Rectangle(113, 163, 805.5, 835.5); + rs.push_back(rect); + + rect = new vpsc::Rectangle(408, 458, 584.5, 614.5); + rs.push_back(rect); + + rect = new vpsc::Rectangle(614.5, 644.5, 843, 893); + rs.push_back(rect); + + AlignmentConstraint *alignment140664475503328 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664475503328->addShape(0, 0); + alignment140664475503328->addShape(16, 0); + alignment140664475503328->addShape(18, 0); + alignment140664475503328->addShape(19, 0); + alignment140664475503328->addShape(26, 0); + alignment140664475503328->addShape(27, 0); + alignment140664475503328->addShape(41, 0); + alignment140664475503328->addShape(49, 0); + alignment140664475503328->addShape(50, 0); + alignment140664475503328->addShape(55, 0); + alignment140664475503328->addShape(56, 0); + alignment140664475503328->addShape(57, 0); + alignment140664475503328->addShape(58, 0); + alignment140664475503328->addShape(59, 0); + alignment140664475503328->addShape(63, 0); + alignment140664475503328->addShape(69, 0); + alignment140664475503328->addShape(89, 0); + ccs.push_back(alignment140664475503328); + + AlignmentConstraint *alignment140664481097440 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664481097440->addShape(1, 0); + alignment140664481097440->addShape(3, 0); + alignment140664481097440->addShape(46, 0); + alignment140664481097440->addShape(47, 0); + alignment140664481097440->addShape(84, 0); + ccs.push_back(alignment140664481097440); + + AlignmentConstraint *alignment140664483416688 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664483416688->addShape(2, 0); + alignment140664483416688->addShape(4, 0); + alignment140664483416688->addShape(65, 0); + alignment140664483416688->addShape(76, 0); + ccs.push_back(alignment140664483416688); + + AlignmentConstraint *alignment140664481096784 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664481096784->addShape(3, 0); + alignment140664481096784->addShape(46, 0); + alignment140664481096784->addShape(47, 0); + alignment140664481096784->addShape(84, 0); + ccs.push_back(alignment140664481096784); + + AlignmentConstraint *alignment140664475503952 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664475503952->addShape(4, 0); + alignment140664475503952->addShape(65, 0); + alignment140664475503952->addShape(76, 0); + ccs.push_back(alignment140664475503952); + + AlignmentConstraint *alignment140664475504304 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664475504304->addShape(7, 0); + alignment140664475504304->addShape(64, 0); + alignment140664475504304->addShape(66, 0); + alignment140664475504304->addShape(74, 0); + ccs.push_back(alignment140664475504304); + + AlignmentConstraint *alignment140664475504496 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664475504496->addShape(8, 0); + alignment140664475504496->addShape(79, 0); + ccs.push_back(alignment140664475504496); + + AlignmentConstraint *alignment140664475504720 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664475504720->addShape(9, 0); + alignment140664475504720->addShape(77, 0); + alignment140664475504720->addShape(87, 0); + alignment140664475504720->addShape(88, 0); + ccs.push_back(alignment140664475504720); + + AlignmentConstraint *alignment140664483418000 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664483418000->addShape(10, 0); + alignment140664483418000->addShape(11, 0); + ccs.push_back(alignment140664483418000); + + AlignmentConstraint *alignment140664483418368 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664483418368->addShape(11, 0); + ccs.push_back(alignment140664483418368); + + AlignmentConstraint *alignment140664483418496 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664483418496->addShape(12, 0); + ccs.push_back(alignment140664483418496); + + AlignmentConstraint *alignment140664483418656 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664483418656->addShape(13, 0); + alignment140664483418656->addShape(68, 0); + ccs.push_back(alignment140664483418656); + + AlignmentConstraint *alignment140664483418880 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664483418880->addShape(14, 0); + ccs.push_back(alignment140664483418880); + + AlignmentConstraint *alignment140664483419008 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664483419008->addShape(16, 0); + alignment140664483419008->addShape(18, 0); + alignment140664483419008->addShape(19, 0); + alignment140664483419008->addShape(26, 0); + alignment140664483419008->addShape(27, 0); + alignment140664483419008->addShape(41, 0); + alignment140664483419008->addShape(49, 0); + alignment140664483419008->addShape(50, 0); + alignment140664483419008->addShape(55, 0); + alignment140664483419008->addShape(56, 0); + alignment140664483419008->addShape(57, 0); + alignment140664483419008->addShape(58, 0); + alignment140664483419008->addShape(59, 0); + alignment140664483419008->addShape(63, 0); + alignment140664483419008->addShape(69, 0); + alignment140664483419008->addShape(89, 0); + ccs.push_back(alignment140664483419008); + + AlignmentConstraint *alignment140664476991552 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664476991552->addShape(18, 0); + alignment140664476991552->addShape(19, 0); + alignment140664476991552->addShape(26, 0); + alignment140664476991552->addShape(27, 0); + alignment140664476991552->addShape(41, 0); + alignment140664476991552->addShape(49, 0); + alignment140664476991552->addShape(50, 0); + alignment140664476991552->addShape(55, 0); + alignment140664476991552->addShape(56, 0); + alignment140664476991552->addShape(57, 0); + alignment140664476991552->addShape(58, 0); + alignment140664476991552->addShape(59, 0); + alignment140664476991552->addShape(63, 0); + alignment140664476991552->addShape(69, 0); + alignment140664476991552->addShape(89, 0); + ccs.push_back(alignment140664476991552); + + AlignmentConstraint *alignment140664476992272 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664476992272->addShape(19, 0); + alignment140664476992272->addShape(26, 0); + alignment140664476992272->addShape(27, 0); + alignment140664476992272->addShape(41, 0); + alignment140664476992272->addShape(49, 0); + alignment140664476992272->addShape(50, 0); + alignment140664476992272->addShape(55, 0); + alignment140664476992272->addShape(56, 0); + alignment140664476992272->addShape(57, 0); + alignment140664476992272->addShape(58, 0); + alignment140664476992272->addShape(59, 0); + alignment140664476992272->addShape(63, 0); + alignment140664476992272->addShape(69, 0); + alignment140664476992272->addShape(89, 0); + ccs.push_back(alignment140664476992272); + + AlignmentConstraint *alignment140664476992960 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664476992960->addShape(20, 0); + alignment140664476992960->addShape(23, 0); + ccs.push_back(alignment140664476992960); + + AlignmentConstraint *alignment140664476993456 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664476993456->addShape(22, 0); + ccs.push_back(alignment140664476993456); + + AlignmentConstraint *alignment140664476993584 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664476993584->addShape(23, 0); + ccs.push_back(alignment140664476993584); + + AlignmentConstraint *alignment140664476993744 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664476993744->addShape(24, 0); + ccs.push_back(alignment140664476993744); + + AlignmentConstraint *alignment140664476993904 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664476993904->addShape(25, 0); + alignment140664476993904->addShape(62, 0); + ccs.push_back(alignment140664476993904); + + AlignmentConstraint *alignment140664476994128 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664476994128->addShape(26, 0); + alignment140664476994128->addShape(27, 0); + alignment140664476994128->addShape(41, 0); + alignment140664476994128->addShape(49, 0); + alignment140664476994128->addShape(50, 0); + alignment140664476994128->addShape(55, 0); + alignment140664476994128->addShape(56, 0); + alignment140664476994128->addShape(57, 0); + alignment140664476994128->addShape(58, 0); + alignment140664476994128->addShape(59, 0); + alignment140664476994128->addShape(63, 0); + alignment140664476994128->addShape(69, 0); + alignment140664476994128->addShape(89, 0); + ccs.push_back(alignment140664476994128); + + AlignmentConstraint *alignment140664476994608 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664476994608->addShape(27, 0); + alignment140664476994608->addShape(41, 0); + alignment140664476994608->addShape(49, 0); + alignment140664476994608->addShape(50, 0); + alignment140664476994608->addShape(55, 0); + alignment140664476994608->addShape(56, 0); + alignment140664476994608->addShape(57, 0); + alignment140664476994608->addShape(58, 0); + alignment140664476994608->addShape(59, 0); + alignment140664476994608->addShape(63, 0); + alignment140664476994608->addShape(69, 0); + alignment140664476994608->addShape(89, 0); + ccs.push_back(alignment140664476994608); + + AlignmentConstraint *alignment140664476995232 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664476995232->addShape(28, 0); + ccs.push_back(alignment140664476995232); + + AlignmentConstraint *alignment140664476995392 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664476995392->addShape(29, 0); + alignment140664476995392->addShape(30, 0); + alignment140664476995392->addShape(34, 0); + alignment140664476995392->addShape(35, 0); + ccs.push_back(alignment140664476995392); + + AlignmentConstraint *alignment140664476995616 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664476995616->addShape(30, 0); + alignment140664476995616->addShape(34, 0); + alignment140664476995616->addShape(35, 0); + ccs.push_back(alignment140664476995616); + + AlignmentConstraint *alignment140664476995888 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664476995888->addShape(31, 0); + ccs.push_back(alignment140664476995888); + + AlignmentConstraint *alignment140664476996016 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664476996016->addShape(32, 0); + ccs.push_back(alignment140664476996016); + + AlignmentConstraint *alignment140664476996176 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664476996176->addShape(33, 0); + alignment140664476996176->addShape(44, 0); + alignment140664476996176->addShape(45, 0); + alignment140664476996176->addShape(51, 0); + alignment140664476996176->addShape(52, 0); + ccs.push_back(alignment140664476996176); + + AlignmentConstraint *alignment140664476996480 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664476996480->addShape(34, 0); + alignment140664476996480->addShape(35, 0); + ccs.push_back(alignment140664476996480); + + AlignmentConstraint *alignment140664476996704 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664476996704->addShape(35, 0); + ccs.push_back(alignment140664476996704); + + AlignmentConstraint *alignment140664476996832 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664476996832->addShape(36, 0); + alignment140664476996832->addShape(61, 0); + ccs.push_back(alignment140664476996832); + + AlignmentConstraint *alignment140664476997056 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664476997056->addShape(37, 0); + alignment140664476997056->addShape(38, 0); + ccs.push_back(alignment140664476997056); + + AlignmentConstraint *alignment140664476993184 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664476993184->addShape(38, 0); + ccs.push_back(alignment140664476993184); + + AlignmentConstraint *alignment140664476993312 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664476993312->addShape(40, 0); + ccs.push_back(alignment140664476993312); + + AlignmentConstraint *alignment140664476997808 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664476997808->addShape(41, 0); + alignment140664476997808->addShape(49, 0); + alignment140664476997808->addShape(50, 0); + alignment140664476997808->addShape(55, 0); + alignment140664476997808->addShape(56, 0); + alignment140664476997808->addShape(57, 0); + alignment140664476997808->addShape(58, 0); + alignment140664476997808->addShape(59, 0); + alignment140664476997808->addShape(63, 0); + alignment140664476997808->addShape(69, 0); + alignment140664476997808->addShape(89, 0); + ccs.push_back(alignment140664476997808); + + AlignmentConstraint *alignment140664476998480 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664476998480->addShape(42, 0); + alignment140664476998480->addShape(43, 0); + alignment140664476998480->addShape(92, 0); + alignment140664476998480->addShape(93, 0); + ccs.push_back(alignment140664476998480); + + AlignmentConstraint *alignment140664476998704 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664476998704->addShape(43, 0); + alignment140664476998704->addShape(92, 0); + alignment140664476998704->addShape(93, 0); + ccs.push_back(alignment140664476998704); + + AlignmentConstraint *alignment140664476998976 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664476998976->addShape(44, 0); + alignment140664476998976->addShape(45, 0); + alignment140664476998976->addShape(51, 0); + alignment140664476998976->addShape(52, 0); + ccs.push_back(alignment140664476998976); + + AlignmentConstraint *alignment140664476999216 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664476999216->addShape(45, 0); + alignment140664476999216->addShape(51, 0); + alignment140664476999216->addShape(52, 0); + ccs.push_back(alignment140664476999216); + + AlignmentConstraint *alignment140664476999488 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664476999488->addShape(46, 0); + alignment140664476999488->addShape(47, 0); + alignment140664476999488->addShape(84, 0); + ccs.push_back(alignment140664476999488); + + AlignmentConstraint *alignment140664476999728 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664476999728->addShape(47, 0); + alignment140664476999728->addShape(84, 0); + ccs.push_back(alignment140664476999728); + + AlignmentConstraint *alignment140664476999920 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664476999920->addShape(48, 0); + ccs.push_back(alignment140664476999920); + + AlignmentConstraint *alignment140664477000048 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664477000048->addShape(49, 0); + alignment140664477000048->addShape(50, 0); + alignment140664477000048->addShape(55, 0); + alignment140664477000048->addShape(56, 0); + alignment140664477000048->addShape(57, 0); + alignment140664477000048->addShape(58, 0); + alignment140664477000048->addShape(59, 0); + alignment140664477000048->addShape(63, 0); + alignment140664477000048->addShape(69, 0); + alignment140664477000048->addShape(89, 0); + ccs.push_back(alignment140664477000048); + + AlignmentConstraint *alignment140664477000656 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664477000656->addShape(50, 0); + alignment140664477000656->addShape(55, 0); + alignment140664477000656->addShape(56, 0); + alignment140664477000656->addShape(57, 0); + alignment140664477000656->addShape(58, 0); + alignment140664477000656->addShape(59, 0); + alignment140664477000656->addShape(63, 0); + alignment140664477000656->addShape(69, 0); + alignment140664477000656->addShape(89, 0); + ccs.push_back(alignment140664477000656); + + AlignmentConstraint *alignment140664477001184 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664477001184->addShape(51, 0); + alignment140664477001184->addShape(52, 0); + ccs.push_back(alignment140664477001184); + + AlignmentConstraint *alignment140664477001408 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664477001408->addShape(52, 0); + ccs.push_back(alignment140664477001408); + + AlignmentConstraint *alignment140664477001536 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664477001536->addShape(53, 0); + alignment140664477001536->addShape(54, 0); + ccs.push_back(alignment140664477001536); + + AlignmentConstraint *alignment140664477001760 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664477001760->addShape(54, 0); + ccs.push_back(alignment140664477001760); + + AlignmentConstraint *alignment140664477001888 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664477001888->addShape(55, 0); + alignment140664477001888->addShape(56, 0); + alignment140664477001888->addShape(57, 0); + alignment140664477001888->addShape(58, 0); + alignment140664477001888->addShape(59, 0); + alignment140664477001888->addShape(63, 0); + alignment140664477001888->addShape(69, 0); + alignment140664477001888->addShape(89, 0); + ccs.push_back(alignment140664477001888); + + AlignmentConstraint *alignment140664477002240 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664477002240->addShape(56, 0); + alignment140664477002240->addShape(57, 0); + alignment140664477002240->addShape(58, 0); + alignment140664477002240->addShape(59, 0); + alignment140664477002240->addShape(63, 0); + alignment140664477002240->addShape(69, 0); + alignment140664477002240->addShape(89, 0); + ccs.push_back(alignment140664477002240); + + AlignmentConstraint *alignment140664477002640 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664477002640->addShape(57, 0); + alignment140664477002640->addShape(58, 0); + alignment140664477002640->addShape(59, 0); + alignment140664477002640->addShape(63, 0); + alignment140664477002640->addShape(69, 0); + alignment140664477002640->addShape(89, 0); + ccs.push_back(alignment140664477002640); + + AlignmentConstraint *alignment140664477003008 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664477003008->addShape(58, 0); + alignment140664477003008->addShape(59, 0); + alignment140664477003008->addShape(63, 0); + alignment140664477003008->addShape(69, 0); + alignment140664477003008->addShape(89, 0); + ccs.push_back(alignment140664477003008); + + AlignmentConstraint *alignment140664477003344 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664477003344->addShape(59, 0); + alignment140664477003344->addShape(63, 0); + alignment140664477003344->addShape(69, 0); + alignment140664477003344->addShape(89, 0); + ccs.push_back(alignment140664477003344); + + AlignmentConstraint *alignment140664477003568 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664477003568->addShape(60, 0); + ccs.push_back(alignment140664477003568); + + AlignmentConstraint *alignment140664477003728 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664477003728->addShape(61, 0); + ccs.push_back(alignment140664477003728); + + AlignmentConstraint *alignment140664477003888 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664477003888->addShape(62, 0); + ccs.push_back(alignment140664477003888); + + AlignmentConstraint *alignment140664477004048 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664477004048->addShape(63, 0); + alignment140664477004048->addShape(69, 0); + alignment140664477004048->addShape(89, 0); + ccs.push_back(alignment140664477004048); + + AlignmentConstraint *alignment140664477004320 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664477004320->addShape(64, 0); + alignment140664477004320->addShape(66, 0); + alignment140664477004320->addShape(74, 0); + ccs.push_back(alignment140664477004320); + + AlignmentConstraint *alignment140664477004560 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664477004560->addShape(65, 0); + alignment140664477004560->addShape(76, 0); + ccs.push_back(alignment140664477004560); + + AlignmentConstraint *alignment140664477004752 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664477004752->addShape(66, 0); + alignment140664477004752->addShape(74, 0); + ccs.push_back(alignment140664477004752); + + AlignmentConstraint *alignment140664477004944 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664477004944->addShape(67, 0); + ccs.push_back(alignment140664477004944); + + AlignmentConstraint *alignment140664477005072 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664477005072->addShape(68, 0); + ccs.push_back(alignment140664477005072); + + AlignmentConstraint *alignment140664477005232 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664477005232->addShape(69, 0); + alignment140664477005232->addShape(89, 0); + ccs.push_back(alignment140664477005232); + + AlignmentConstraint *alignment140664477005456 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664477005456->addShape(70, 0); + alignment140664477005456->addShape(73, 0); + ccs.push_back(alignment140664477005456); + + AlignmentConstraint *alignment140664477005648 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664477005648->addShape(71, 0); + alignment140664477005648->addShape(72, 0); + ccs.push_back(alignment140664477005648); + + AlignmentConstraint *alignment140664476997248 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664476997248->addShape(72, 0); + ccs.push_back(alignment140664476997248); + + AlignmentConstraint *alignment140664476997376 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664476997376->addShape(73, 0); + ccs.push_back(alignment140664476997376); + + AlignmentConstraint *alignment140664476997536 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664476997536->addShape(74, 0); + ccs.push_back(alignment140664476997536); + + AlignmentConstraint *alignment140664475640112 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664475640112->addShape(76, 0); + ccs.push_back(alignment140664475640112); + + AlignmentConstraint *alignment140664475640272 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664475640272->addShape(77, 0); + alignment140664475640272->addShape(87, 0); + alignment140664475640272->addShape(88, 0); + ccs.push_back(alignment140664475640272); + + AlignmentConstraint *alignment140664475640544 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664475640544->addShape(78, 0); + ccs.push_back(alignment140664475640544); + + AlignmentConstraint *alignment140664475640672 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664475640672->addShape(79, 0); + ccs.push_back(alignment140664475640672); + + AlignmentConstraint *alignment140664475640832 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664475640832->addShape(81, 0); + alignment140664475640832->addShape(91, 0); + ccs.push_back(alignment140664475640832); + + AlignmentConstraint *alignment140664475641056 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664475641056->addShape(82, 0); + ccs.push_back(alignment140664475641056); + + AlignmentConstraint *alignment140664475641184 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664475641184->addShape(83, 0); + ccs.push_back(alignment140664475641184); + + AlignmentConstraint *alignment140664475641344 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664475641344->addShape(84, 0); + ccs.push_back(alignment140664475641344); + + AlignmentConstraint *alignment140664475641504 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664475641504->addShape(85, 0); + ccs.push_back(alignment140664475641504); + + AlignmentConstraint *alignment140664475641664 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664475641664->addShape(86, 0); + ccs.push_back(alignment140664475641664); + + AlignmentConstraint *alignment140664475641824 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664475641824->addShape(87, 0); + alignment140664475641824->addShape(88, 0); + ccs.push_back(alignment140664475641824); + + AlignmentConstraint *alignment140664475642048 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664475642048->addShape(88, 0); + ccs.push_back(alignment140664475642048); + + AlignmentConstraint *alignment140664475642176 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664475642176->addShape(89, 0); + ccs.push_back(alignment140664475642176); + + AlignmentConstraint *alignment140664475642336 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664475642336->addShape(90, 0); + ccs.push_back(alignment140664475642336); + + AlignmentConstraint *alignment140664475642496 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664475642496->addShape(91, 0); + ccs.push_back(alignment140664475642496); + + AlignmentConstraint *alignment140664475642656 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664475642656->addShape(92, 0); + alignment140664475642656->addShape(93, 0); + ccs.push_back(alignment140664475642656); + + AlignmentConstraint *alignment140664475642880 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664475642880->addShape(93, 0); + ccs.push_back(alignment140664475642880); + + SeparationConstraint *separation140664475644192 = new SeparationConstraint(vpsc::XDIM, alignment140664475642336, alignment140664476997376, 36, false); + ccs.push_back(separation140664475644192); + + SeparationConstraint *separation140664481097840 = new SeparationConstraint(vpsc::XDIM, alignment140664476997376, alignment140664475640112, 14, false); + ccs.push_back(separation140664481097840); + + SeparationConstraint *separation140664476990640 = new SeparationConstraint(vpsc::XDIM, alignment140664475640112, alignment140664477001408, 35, false); + ccs.push_back(separation140664476990640); + + SeparationConstraint *separation140664481098032 = new SeparationConstraint(vpsc::XDIM, alignment140664477001408, alignment140664475640544, 23, false); + ccs.push_back(separation140664481098032); + + SeparationConstraint *separation140664481098176 = new SeparationConstraint(vpsc::XDIM, alignment140664475640544, alignment140664483418656, 7, false); + ccs.push_back(separation140664481098176); + + SeparationConstraint *separation140664481098320 = new SeparationConstraint(vpsc::XDIM, alignment140664477005072, alignment140664476996704, 21, false); + ccs.push_back(separation140664481098320); + + SeparationConstraint *separation140664481098496 = new SeparationConstraint(vpsc::XDIM, alignment140664476996704, alignment140664476997248, 6, false); + ccs.push_back(separation140664481098496); + + SeparationConstraint *separation140664481098672 = new SeparationConstraint(vpsc::XDIM, alignment140664476997248, alignment140664476993312, 23, false); + ccs.push_back(separation140664481098672); + + SeparationConstraint *separation140664476989584 = new SeparationConstraint(vpsc::XDIM, alignment140664476993312, alignment140664477004944, 3, false); + ccs.push_back(separation140664476989584); + + SeparationConstraint *separation140664476989760 = new SeparationConstraint(vpsc::XDIM, alignment140664477004944, alignment140664475642880, 16, false); + ccs.push_back(separation140664476989760); + + SeparationConstraint *separation140664476989936 = new SeparationConstraint(vpsc::XDIM, alignment140664475642880, alignment140664475641344, 8, false); + ccs.push_back(separation140664476989936); + + SeparationConstraint *separation140664476990112 = new SeparationConstraint(vpsc::XDIM, alignment140664476999488, alignment140664476996016, 16.6667, false); + ccs.push_back(separation140664476990112); + + SeparationConstraint *separation140664476990288 = new SeparationConstraint(vpsc::XDIM, alignment140664476996016, alignment140664477003728, 7, false); + ccs.push_back(separation140664476990288); + + SeparationConstraint *separation140664476990464 = new SeparationConstraint(vpsc::XDIM, alignment140664476996832, alignment140664483418496, 4, false); + ccs.push_back(separation140664476990464); + + SeparationConstraint *separation140664475645632 = new SeparationConstraint(vpsc::XDIM, alignment140664483418496, alignment140664477001760, 13, false); + ccs.push_back(separation140664475645632); + + SeparationConstraint *separation140664475645808 = new SeparationConstraint(vpsc::XDIM, alignment140664477001760, alignment140664476993184, 11, false); + ccs.push_back(separation140664475645808); + + SeparationConstraint *separation140664475645984 = new SeparationConstraint(vpsc::XDIM, alignment140664476993184, alignment140664476995888, 14, false); + ccs.push_back(separation140664475645984); + + SeparationConstraint *separation140664475646160 = new SeparationConstraint(vpsc::XDIM, alignment140664476995888, alignment140664476997536, 21, false); + ccs.push_back(separation140664475646160); + + SeparationConstraint *separation140664475646336 = new SeparationConstraint(vpsc::XDIM, alignment140664476997536, alignment140664476995232, 7, false); + ccs.push_back(separation140664475646336); + + SeparationConstraint *separation140664475646512 = new SeparationConstraint(vpsc::XDIM, alignment140664476995232, alignment140664475641664, 13, false); + ccs.push_back(separation140664475646512); + + SeparationConstraint *separation140664475646688 = new SeparationConstraint(vpsc::XDIM, alignment140664475641664, alignment140664476993456, 5, false); + ccs.push_back(separation140664475646688); + + SeparationConstraint *separation140664475646864 = new SeparationConstraint(vpsc::XDIM, alignment140664476993456, alignment140664476993744, 5, false); + ccs.push_back(separation140664475646864); + + SeparationConstraint *separation140664475647040 = new SeparationConstraint(vpsc::XDIM, alignment140664476993744, alignment140664483418368, 23, false); + ccs.push_back(separation140664475647040); + + SeparationConstraint *separation140664475647216 = new SeparationConstraint(vpsc::XDIM, alignment140664483418368, alignment140664475641824, 6.5, false); + ccs.push_back(separation140664475647216); + + SeparationConstraint *separation140664475647392 = new SeparationConstraint(vpsc::XDIM, alignment140664475504720, alignment140664476993584, 19.75, false); + ccs.push_back(separation140664475647392); + + SeparationConstraint *separation140664475647568 = new SeparationConstraint(vpsc::XDIM, alignment140664476993584, alignment140664475642176, 25, false); + ccs.push_back(separation140664475647568); + + SeparationConstraint *separation140664475647744 = new SeparationConstraint(vpsc::XDIM, alignment140664475642176, alignment140664475640672, 4, false); + ccs.push_back(separation140664475647744); + + SeparationConstraint *separation140664475647920 = new SeparationConstraint(vpsc::XDIM, alignment140664475640672, alignment140664475642496, 21, false); + ccs.push_back(separation140664475647920); + + SeparationConstraint *separation140664475648096 = new SeparationConstraint(vpsc::XDIM, alignment140664475642496, alignment140664475641504, 24, false); + ccs.push_back(separation140664475648096); + + SeparationConstraint *separation140664475648272 = new SeparationConstraint(vpsc::XDIM, alignment140664475641504, alignment140664477003888, 18, false); + ccs.push_back(separation140664475648272); + + SeparationConstraint *separation140664475648448 = new SeparationConstraint(vpsc::XDIM, alignment140664476993904, alignment140664475641184, 4, false); + ccs.push_back(separation140664475648448); + + SeparationConstraint *separation140664475648624 = new SeparationConstraint(vpsc::XDIM, alignment140664475641184, alignment140664483418880, 3, false); + ccs.push_back(separation140664475648624); + + SeparationConstraint *separation140664475648800 = new SeparationConstraint(vpsc::XDIM, alignment140664483418880, alignment140664475641056, 24, false); + ccs.push_back(separation140664475648800); + + SeparationConstraint *separation140664475648976 = new SeparationConstraint(vpsc::XDIM, alignment140664475641056, alignment140664476999920, 19, false); + ccs.push_back(separation140664475648976); + + SeparationConstraint *separation140664475649152 = new SeparationConstraint(vpsc::XDIM, alignment140664476999920, alignment140664477003568, 26, false); + ccs.push_back(separation140664475649152); + + AlignmentConstraint *alignment140664475649328 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475649328->addShape(0, 0); + ccs.push_back(alignment140664475649328); + + AlignmentConstraint *alignment140664475649488 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475649488->addShape(1, 0); + alignment140664475649488->addShape(8, 0); + alignment140664475649488->addShape(9, 0); + ccs.push_back(alignment140664475649488); + + AlignmentConstraint *alignment140664475649760 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475649760->addShape(2, 0); + alignment140664475649760->addShape(7, 0); + alignment140664475649760->addShape(90, 0); + ccs.push_back(alignment140664475649760); + + AlignmentConstraint *alignment140664475650000 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475650000->addShape(3, 0); + alignment140664475650000->addShape(77, 0); + alignment140664475650000->addShape(79, 0); + ccs.push_back(alignment140664475650000); + + AlignmentConstraint *alignment140664475650240 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475650240->addShape(4, 0); + alignment140664475650240->addShape(62, 0); + alignment140664475650240->addShape(66, 0); + ccs.push_back(alignment140664475650240); + + AlignmentConstraint *alignment140664475650480 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475650480->addShape(7, 0); + alignment140664475650480->addShape(90, 0); + ccs.push_back(alignment140664475650480); + + AlignmentConstraint *alignment140664475650672 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475650672->addShape(8, 0); + alignment140664475650672->addShape(9, 0); + ccs.push_back(alignment140664475650672); + + AlignmentConstraint *alignment140664475650864 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475650864->addShape(9, 0); + ccs.push_back(alignment140664475650864); + + AlignmentConstraint *alignment140664475639072 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475639072->addShape(10, 0); + ccs.push_back(alignment140664475639072); + + AlignmentConstraint *alignment140664475639232 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475639232->addShape(11, 0); + ccs.push_back(alignment140664475639232); + + AlignmentConstraint *alignment140664475639392 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475639392->addShape(12, 0); + alignment140664475639392->addShape(13, 0); + alignment140664475639392->addShape(14, 0); + alignment140664475639392->addShape(60, 0); + alignment140664475639392->addShape(63, 0); + alignment140664475639392->addShape(64, 0); + alignment140664475639392->addShape(65, 0); + alignment140664475639392->addShape(67, 0); + ccs.push_back(alignment140664475639392); + + AlignmentConstraint *alignment140664475639872 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475639872->addShape(13, 0); + alignment140664475639872->addShape(14, 0); + alignment140664475639872->addShape(60, 0); + alignment140664475639872->addShape(63, 0); + alignment140664475639872->addShape(64, 0); + alignment140664475639872->addShape(65, 0); + alignment140664475639872->addShape(67, 0); + ccs.push_back(alignment140664475639872); + + AlignmentConstraint *alignment140664475653264 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475653264->addShape(14, 0); + alignment140664475653264->addShape(60, 0); + alignment140664475653264->addShape(63, 0); + alignment140664475653264->addShape(64, 0); + alignment140664475653264->addShape(65, 0); + alignment140664475653264->addShape(67, 0); + ccs.push_back(alignment140664475653264); + + AlignmentConstraint *alignment140664475653632 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475653632->addShape(16, 0); + ccs.push_back(alignment140664475653632); + + AlignmentConstraint *alignment140664475653792 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475653792->addShape(18, 0); + ccs.push_back(alignment140664475653792); + + AlignmentConstraint *alignment140664475653952 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475653952->addShape(19, 0); + ccs.push_back(alignment140664475653952); + + AlignmentConstraint *alignment140664475654112 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475654112->addShape(20, 0); + alignment140664475654112->addShape(81, 0); + ccs.push_back(alignment140664475654112); + + AlignmentConstraint *alignment140664475654336 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475654336->addShape(22, 0); + alignment140664475654336->addShape(53, 0); + alignment140664475654336->addShape(89, 0); + ccs.push_back(alignment140664475654336); + + AlignmentConstraint *alignment140664475654528 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475654528->addShape(23, 0); + alignment140664475654528->addShape(24, 0); + alignment140664475654528->addShape(91, 0); + ccs.push_back(alignment140664475654528); + + AlignmentConstraint *alignment140664475654720 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475654720->addShape(24, 0); + alignment140664475654720->addShape(91, 0); + ccs.push_back(alignment140664475654720); + + AlignmentConstraint *alignment140664475654912 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475654912->addShape(25, 0); + alignment140664475654912->addShape(48, 0); + ccs.push_back(alignment140664475654912); + + AlignmentConstraint *alignment140664475655104 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475655104->addShape(26, 0); + alignment140664475655104->addShape(31, 0); + alignment140664475655104->addShape(32, 0); + alignment140664475655104->addShape(33, 0); + ccs.push_back(alignment140664475655104); + + AlignmentConstraint *alignment140664475655344 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475655344->addShape(27, 0); + ccs.push_back(alignment140664475655344); + + AlignmentConstraint *alignment140664475655504 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475655504->addShape(28, 0); + alignment140664475655504->addShape(52, 0); + alignment140664475655504->addShape(54, 0); + alignment140664475655504->addShape(56, 0); + ccs.push_back(alignment140664475655504); + + AlignmentConstraint *alignment140664475655776 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475655776->addShape(29, 0); + alignment140664475655776->addShape(43, 0); + ccs.push_back(alignment140664475655776); + + AlignmentConstraint *alignment140664475656000 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475656000->addShape(30, 0); + alignment140664475656000->addShape(93, 0); + ccs.push_back(alignment140664475656000); + + AlignmentConstraint *alignment140664475656192 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475656192->addShape(31, 0); + alignment140664475656192->addShape(32, 0); + alignment140664475656192->addShape(33, 0); + ccs.push_back(alignment140664475656192); + + AlignmentConstraint *alignment140664475656432 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475656432->addShape(32, 0); + alignment140664475656432->addShape(33, 0); + ccs.push_back(alignment140664475656432); + + AlignmentConstraint *alignment140664475656624 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475656624->addShape(33, 0); + ccs.push_back(alignment140664475656624); + + AlignmentConstraint *alignment140664475656752 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475656752->addShape(34, 0); + alignment140664475656752->addShape(92, 0); + ccs.push_back(alignment140664475656752); + + AlignmentConstraint *alignment140664475656976 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475656976->addShape(35, 0); + alignment140664475656976->addShape(42, 0); + ccs.push_back(alignment140664475656976); + + AlignmentConstraint *alignment140664475657168 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475657168->addShape(36, 0); + ccs.push_back(alignment140664475657168); + + AlignmentConstraint *alignment140664475657296 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475657296->addShape(37, 0); + ccs.push_back(alignment140664475657296); + + AlignmentConstraint *alignment140664475657456 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475657456->addShape(38, 0); + ccs.push_back(alignment140664475657456); + + AlignmentConstraint *alignment140664475657616 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475657616->addShape(40, 0); + alignment140664475657616->addShape(61, 0); + alignment140664475657616->addShape(68, 0); + ccs.push_back(alignment140664475657616); + + AlignmentConstraint *alignment140664475657888 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475657888->addShape(41, 0); + alignment140664475657888->addShape(86, 0); + ccs.push_back(alignment140664475657888); + + AlignmentConstraint *alignment140664475658080 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475658080->addShape(42, 0); + ccs.push_back(alignment140664475658080); + + AlignmentConstraint *alignment140664475658208 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475658208->addShape(43, 0); + ccs.push_back(alignment140664475658208); + + AlignmentConstraint *alignment140664475658368 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475658368->addShape(44, 0); + alignment140664475658368->addShape(46, 0); + alignment140664475658368->addShape(70, 0); + alignment140664475658368->addShape(71, 0); + ccs.push_back(alignment140664475658368); + + AlignmentConstraint *alignment140664475658640 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475658640->addShape(45, 0); + alignment140664475658640->addShape(47, 0); + alignment140664475658640->addShape(72, 0); + alignment140664475658640->addShape(73, 0); + ccs.push_back(alignment140664475658640); + + AlignmentConstraint *alignment140664475658912 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475658912->addShape(46, 0); + alignment140664475658912->addShape(70, 0); + alignment140664475658912->addShape(71, 0); + ccs.push_back(alignment140664475658912); + + AlignmentConstraint *alignment140664475659184 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475659184->addShape(47, 0); + alignment140664475659184->addShape(72, 0); + alignment140664475659184->addShape(73, 0); + ccs.push_back(alignment140664475659184); + + AlignmentConstraint *alignment140664475659424 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475659424->addShape(48, 0); + ccs.push_back(alignment140664475659424); + + AlignmentConstraint *alignment140664475659552 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475659552->addShape(49, 0); + ccs.push_back(alignment140664475659552); + + AlignmentConstraint *alignment140664475659712 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475659712->addShape(50, 0); + ccs.push_back(alignment140664475659712); + + AlignmentConstraint *alignment140664475659872 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475659872->addShape(51, 0); + alignment140664475659872->addShape(55, 0); + ccs.push_back(alignment140664475659872); + + AlignmentConstraint *alignment140664475660096 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475660096->addShape(52, 0); + alignment140664475660096->addShape(54, 0); + alignment140664475660096->addShape(56, 0); + ccs.push_back(alignment140664475660096); + + AlignmentConstraint *alignment140664475660336 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475660336->addShape(53, 0); + alignment140664475660336->addShape(89, 0); + ccs.push_back(alignment140664475660336); + + AlignmentConstraint *alignment140664475660528 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475660528->addShape(54, 0); + alignment140664475660528->addShape(56, 0); + ccs.push_back(alignment140664475660528); + + AlignmentConstraint *alignment140664475660720 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475660720->addShape(55, 0); + ccs.push_back(alignment140664475660720); + + AlignmentConstraint *alignment140664475660848 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475660848->addShape(56, 0); + ccs.push_back(alignment140664475660848); + + AlignmentConstraint *alignment140664475661008 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475661008->addShape(57, 0); + alignment140664475661008->addShape(76, 0); + ccs.push_back(alignment140664475661008); + + AlignmentConstraint *alignment140664475661232 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475661232->addShape(58, 0); + ccs.push_back(alignment140664475661232); + + AlignmentConstraint *alignment140664475661360 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475661360->addShape(59, 0); + alignment140664475661360->addShape(88, 0); + ccs.push_back(alignment140664475661360); + + AlignmentConstraint *alignment140664475661584 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475661584->addShape(60, 0); + alignment140664475661584->addShape(63, 0); + alignment140664475661584->addShape(64, 0); + alignment140664475661584->addShape(65, 0); + alignment140664475661584->addShape(67, 0); + ccs.push_back(alignment140664475661584); + + AlignmentConstraint *alignment140664475661936 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475661936->addShape(61, 0); + alignment140664475661936->addShape(68, 0); + ccs.push_back(alignment140664475661936); + + AlignmentConstraint *alignment140664475662160 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475662160->addShape(62, 0); + alignment140664475662160->addShape(66, 0); + ccs.push_back(alignment140664475662160); + + AlignmentConstraint *alignment140664475662352 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475662352->addShape(63, 0); + alignment140664475662352->addShape(64, 0); + alignment140664475662352->addShape(65, 0); + alignment140664475662352->addShape(67, 0); + ccs.push_back(alignment140664475662352); + + AlignmentConstraint *alignment140664475662544 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475662544->addShape(64, 0); + alignment140664475662544->addShape(65, 0); + alignment140664475662544->addShape(67, 0); + ccs.push_back(alignment140664475662544); + + AlignmentConstraint *alignment140664475662816 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475662816->addShape(65, 0); + alignment140664475662816->addShape(67, 0); + ccs.push_back(alignment140664475662816); + + AlignmentConstraint *alignment140664475663008 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475663008->addShape(66, 0); + ccs.push_back(alignment140664475663008); + + AlignmentConstraint *alignment140664475663136 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475663136->addShape(67, 0); + ccs.push_back(alignment140664475663136); + + AlignmentConstraint *alignment140664475663296 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475663296->addShape(68, 0); + ccs.push_back(alignment140664475663296); + + AlignmentConstraint *alignment140664475663456 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475663456->addShape(69, 0); + ccs.push_back(alignment140664475663456); + + AlignmentConstraint *alignment140664475663616 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475663616->addShape(70, 0); + alignment140664475663616->addShape(71, 0); + ccs.push_back(alignment140664475663616); + + AlignmentConstraint *alignment140664475663840 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475663840->addShape(71, 0); + ccs.push_back(alignment140664475663840); + + AlignmentConstraint *alignment140664475663968 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475663968->addShape(72, 0); + alignment140664475663968->addShape(73, 0); + ccs.push_back(alignment140664475663968); + + AlignmentConstraint *alignment140664475664192 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475664192->addShape(73, 0); + ccs.push_back(alignment140664475664192); + + AlignmentConstraint *alignment140664475664320 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475664320->addShape(74, 0); + ccs.push_back(alignment140664475664320); + + AlignmentConstraint *alignment140664475664480 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475664480->addShape(76, 0); + ccs.push_back(alignment140664475664480); + + AlignmentConstraint *alignment140664475664640 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475664640->addShape(77, 0); + alignment140664475664640->addShape(79, 0); + ccs.push_back(alignment140664475664640); + + AlignmentConstraint *alignment140664475664864 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475664864->addShape(78, 0); + ccs.push_back(alignment140664475664864); + + AlignmentConstraint *alignment140664475664992 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475664992->addShape(79, 0); + ccs.push_back(alignment140664475664992); + + AlignmentConstraint *alignment140664475665152 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475665152->addShape(81, 0); + ccs.push_back(alignment140664475665152); + + AlignmentConstraint *alignment140664475665312 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475665312->addShape(82, 0); + alignment140664475665312->addShape(85, 0); + ccs.push_back(alignment140664475665312); + + AlignmentConstraint *alignment140664475665536 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475665536->addShape(83, 0); + ccs.push_back(alignment140664475665536); + + AlignmentConstraint *alignment140664475665664 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475665664->addShape(84, 0); + ccs.push_back(alignment140664475665664); + + AlignmentConstraint *alignment140664475665824 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475665824->addShape(85, 0); + ccs.push_back(alignment140664475665824); + + AlignmentConstraint *alignment140664475665984 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475665984->addShape(86, 0); + ccs.push_back(alignment140664475665984); + + AlignmentConstraint *alignment140664475666144 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475666144->addShape(87, 0); + ccs.push_back(alignment140664475666144); + + AlignmentConstraint *alignment140664475666304 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475666304->addShape(88, 0); + ccs.push_back(alignment140664475666304); + + AlignmentConstraint *alignment140664475666464 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475666464->addShape(89, 0); + ccs.push_back(alignment140664475666464); + + AlignmentConstraint *alignment140664475666624 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475666624->addShape(90, 0); + ccs.push_back(alignment140664475666624); + + AlignmentConstraint *alignment140664475666784 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475666784->addShape(91, 0); + ccs.push_back(alignment140664475666784); + + AlignmentConstraint *alignment140664475666944 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475666944->addShape(92, 0); + ccs.push_back(alignment140664475666944); + + AlignmentConstraint *alignment140664475667104 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475667104->addShape(93, 0); + ccs.push_back(alignment140664475667104); + + SeparationConstraint *separation140664475667264 = new SeparationConstraint(vpsc::YDIM, alignment140664475657456, alignment140664475659552, 10, false); + ccs.push_back(separation140664475667264); + + SeparationConstraint *separation140664475667440 = new SeparationConstraint(vpsc::YDIM, alignment140664475659552, alignment140664475657296, 11, false); + ccs.push_back(separation140664475667440); + + SeparationConstraint *separation140664475667616 = new SeparationConstraint(vpsc::YDIM, alignment140664475657296, alignment140664475655344, 19, false); + ccs.push_back(separation140664475667616); + + SeparationConstraint *separation140664475667792 = new SeparationConstraint(vpsc::YDIM, alignment140664475655344, alignment140664475657168, 13, false); + ccs.push_back(separation140664475667792); + + SeparationConstraint *separation140664475667968 = new SeparationConstraint(vpsc::YDIM, alignment140664475657168, alignment140664475659424, 9, false); + ccs.push_back(separation140664475667968); + + SeparationConstraint *separation140664475668144 = new SeparationConstraint(vpsc::YDIM, alignment140664475654912, alignment140664475658080, 22.5, false); + ccs.push_back(separation140664475668144); + + SeparationConstraint *separation140664475668320 = new SeparationConstraint(vpsc::YDIM, alignment140664475658080, alignment140664475659872, 11, false); + ccs.push_back(separation140664475668320); + + SeparationConstraint *separation140664475668496 = new SeparationConstraint(vpsc::YDIM, alignment140664475660720, alignment140664475666944, 9, false); + ccs.push_back(separation140664475668496); + + SeparationConstraint *separation140664475668672 = new SeparationConstraint(vpsc::YDIM, alignment140664475666944, alignment140664475656624, 25, false); + ccs.push_back(separation140664475668672); + + SeparationConstraint *separation140664475668848 = new SeparationConstraint(vpsc::YDIM, alignment140664475655104, alignment140664475658208, 26.75, false); + ccs.push_back(separation140664475668848); + + SeparationConstraint *separation140664475669024 = new SeparationConstraint(vpsc::YDIM, alignment140664475658208, alignment140664475660096, 10.6667, false); + ccs.push_back(separation140664475669024); + + SeparationConstraint *separation140664475669200 = new SeparationConstraint(vpsc::YDIM, alignment140664475660848, alignment140664475667104, 9, false); + ccs.push_back(separation140664475669200); + + SeparationConstraint *separation140664475669376 = new SeparationConstraint(vpsc::YDIM, alignment140664475667104, alignment140664475666784, 24, false); + ccs.push_back(separation140664475669376); + + SeparationConstraint *separation140664475669552 = new SeparationConstraint(vpsc::YDIM, alignment140664475666784, alignment140664475663840, 23, false); + ccs.push_back(separation140664475669552); + + SeparationConstraint *separation140664475669728 = new SeparationConstraint(vpsc::YDIM, alignment140664475658368, alignment140664475663456, 13.75, false); + ccs.push_back(separation140664475669728); + + SeparationConstraint *separation140664475669904 = new SeparationConstraint(vpsc::YDIM, alignment140664475663456, alignment140664475664192, 12, false); + ccs.push_back(separation140664475669904); + + SeparationConstraint *separation140664475670080 = new SeparationConstraint(vpsc::YDIM, alignment140664475658640, alignment140664475649328, 18.75, false); + ccs.push_back(separation140664475670080); + + SeparationConstraint *separation140664475670256 = new SeparationConstraint(vpsc::YDIM, alignment140664475649328, alignment140664475666464, 44, false); + ccs.push_back(separation140664475670256); + + SeparationConstraint *separation140664475670432 = new SeparationConstraint(vpsc::YDIM, alignment140664475654336, alignment140664475665152, 35.3333, false); + ccs.push_back(separation140664475670432); + + SeparationConstraint *separation140664475670608 = new SeparationConstraint(vpsc::YDIM, alignment140664475665152, alignment140664475661360, 37, false); + ccs.push_back(separation140664475670608); + + SeparationConstraint *separation140664475670784 = new SeparationConstraint(vpsc::YDIM, alignment140664475666304, alignment140664475665824, 3, false); + ccs.push_back(separation140664475670784); + + SeparationConstraint *separation140664475670960 = new SeparationConstraint(vpsc::YDIM, alignment140664475665824, alignment140664475665536, 19, false); + ccs.push_back(separation140664475670960); + + SeparationConstraint *separation140664475671136 = new SeparationConstraint(vpsc::YDIM, alignment140664475665536, alignment140664475665984, 12, false); + ccs.push_back(separation140664475671136); + + SeparationConstraint *separation140664475671312 = new SeparationConstraint(vpsc::YDIM, alignment140664475665984, alignment140664475666144, 30, false); + ccs.push_back(separation140664475671312); + + SeparationConstraint *separation140664475671488 = new SeparationConstraint(vpsc::YDIM, alignment140664475666144, alignment140664475661232, 6, false); + ccs.push_back(separation140664475671488); + + SeparationConstraint *separation140664475671664 = new SeparationConstraint(vpsc::YDIM, alignment140664475661232, alignment140664475653952, 37, false); + ccs.push_back(separation140664475671664); + + SeparationConstraint *separation140664475508000 = new SeparationConstraint(vpsc::YDIM, alignment140664475653952, alignment140664475659712, 35, false); + ccs.push_back(separation140664475508000); + + SeparationConstraint *separation140664475508176 = new SeparationConstraint(vpsc::YDIM, alignment140664475659712, alignment140664475653792, 37, false); + ccs.push_back(separation140664475508176); + + SeparationConstraint *separation140664475508352 = new SeparationConstraint(vpsc::YDIM, alignment140664475653792, alignment140664475664480, 35, false); + ccs.push_back(separation140664475508352); + + SeparationConstraint *separation140664475508528 = new SeparationConstraint(vpsc::YDIM, alignment140664475664480, alignment140664475664864, 11, false); + ccs.push_back(separation140664475508528); + + SeparationConstraint *separation140664475508704 = new SeparationConstraint(vpsc::YDIM, alignment140664475664864, alignment140664475653632, 23, false); + ccs.push_back(separation140664475508704); + + SeparationConstraint *separation140664475508880 = new SeparationConstraint(vpsc::YDIM, alignment140664475653632, alignment140664475665664, 25, false); + ccs.push_back(separation140664475508880); + + SeparationConstraint *separation140664475509056 = new SeparationConstraint(vpsc::YDIM, alignment140664475665664, alignment140664475664320, 25, false); + ccs.push_back(separation140664475509056); + + SeparationConstraint *separation140664475509232 = new SeparationConstraint(vpsc::YDIM, alignment140664475664320, alignment140664475639232, 33, false); + ccs.push_back(separation140664475509232); + + SeparationConstraint *separation140664475509408 = new SeparationConstraint(vpsc::YDIM, alignment140664475639232, alignment140664475663136, 10, false); + ccs.push_back(separation140664475509408); + + SeparationConstraint *separation140664475509584 = new SeparationConstraint(vpsc::YDIM, alignment140664475639392, alignment140664475639072, 10.375, false); + ccs.push_back(separation140664475509584); + + SeparationConstraint *separation140664475509760 = new SeparationConstraint(vpsc::YDIM, alignment140664475639072, alignment140664475663296, 32, false); + ccs.push_back(separation140664475509760); + + SeparationConstraint *separation140664475509936 = new SeparationConstraint(vpsc::YDIM, alignment140664475657616, alignment140664475666624, 4.33333, false); + ccs.push_back(separation140664475509936); + + SeparationConstraint *separation140664475510112 = new SeparationConstraint(vpsc::YDIM, alignment140664475650480, alignment140664475650864, 31.5, false); + ccs.push_back(separation140664475510112); + + SeparationConstraint *separation140664475510288 = new SeparationConstraint(vpsc::YDIM, alignment140664475650864, alignment140664475663008, 10, false); + ccs.push_back(separation140664475510288); + + SeparationConstraint *separation140664475510464 = new SeparationConstraint(vpsc::YDIM, alignment140664475663008, alignment140664475664992, 11, false); + ccs.push_back(separation140664475510464); + + AlignmentConstraint *alignment140664475511088 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664475511088->addShape(75, 0); + alignment140664475511088->addShape(75, 0); + ccs.push_back(alignment140664475511088); + + SeparationConstraint *separation140664475511312 = new SeparationConstraint(vpsc::YDIM, 75, 75, -50, true); + ccs.push_back(separation140664475511312); + + AlignmentConstraint *alignment140664475511456 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475511456->addShape(0, 0); + alignment140664475511456->addShape(94, 0); + ccs.push_back(alignment140664475511456); + + SeparationConstraint *separation140664475511680 = new SeparationConstraint(vpsc::XDIM, 0, 94, 62, true); + ccs.push_back(separation140664475511680); + + AlignmentConstraint *alignment140664475511824 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664475511824->addShape(1, 0); + alignment140664475511824->addShape(95, 0); + ccs.push_back(alignment140664475511824); + + SeparationConstraint *separation140664475512048 = new SeparationConstraint(vpsc::YDIM, 1, 95, -50, true); + ccs.push_back(separation140664475512048); + + AlignmentConstraint *alignment140664475512192 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475512192->addShape(2, 0); + alignment140664475512192->addShape(96, 0); + ccs.push_back(alignment140664475512192); + + SeparationConstraint *separation140664475512416 = new SeparationConstraint(vpsc::XDIM, 2, 96, 62, true); + ccs.push_back(separation140664475512416); + + AlignmentConstraint *alignment140664475512560 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664475512560->addShape(3, 0); + alignment140664475512560->addShape(97, 0); + ccs.push_back(alignment140664475512560); + + SeparationConstraint *separation140664475512784 = new SeparationConstraint(vpsc::YDIM, 3, 97, -50, true); + ccs.push_back(separation140664475512784); + + AlignmentConstraint *alignment140664475650992 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475650992->addShape(7, 0); + alignment140664475650992->addShape(98, 0); + ccs.push_back(alignment140664475650992); + + SeparationConstraint *separation140664475651216 = new SeparationConstraint(vpsc::XDIM, 7, 98, 62, true); + ccs.push_back(separation140664475651216); + + AlignmentConstraint *alignment140664475651360 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664475651360->addShape(8, 0); + alignment140664475651360->addShape(99, 0); + ccs.push_back(alignment140664475651360); + + SeparationConstraint *separation140664475651584 = new SeparationConstraint(vpsc::YDIM, 8, 99, -50, true); + ccs.push_back(separation140664475651584); + + AlignmentConstraint *alignment140664475651728 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664475651728->addShape(9, 0); + alignment140664475651728->addShape(100, 0); + ccs.push_back(alignment140664475651728); + + SeparationConstraint *separation140664475651952 = new SeparationConstraint(vpsc::YDIM, 9, 100, -50, true); + ccs.push_back(separation140664475651952); + + AlignmentConstraint *alignment140664475652096 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475652096->addShape(10, 0); + alignment140664475652096->addShape(101, 0); + ccs.push_back(alignment140664475652096); + + SeparationConstraint *separation140664475652320 = new SeparationConstraint(vpsc::XDIM, 10, 101, 62, true); + ccs.push_back(separation140664475652320); + + AlignmentConstraint *alignment140664475652464 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475652464->addShape(11, 0); + alignment140664475652464->addShape(102, 0); + ccs.push_back(alignment140664475652464); + + SeparationConstraint *separation140664475652688 = new SeparationConstraint(vpsc::XDIM, 11, 102, 62, true); + ccs.push_back(separation140664475652688); + + AlignmentConstraint *alignment140664475652832 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475652832->addShape(12, 0); + alignment140664475652832->addShape(103, 0); + ccs.push_back(alignment140664475652832); + + SeparationConstraint *separation140664475517040 = new SeparationConstraint(vpsc::XDIM, 12, 103, 62, true); + ccs.push_back(separation140664475517040); + + AlignmentConstraint *alignment140664475517184 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664475517184->addShape(13, 0); + alignment140664475517184->addShape(104, 0); + ccs.push_back(alignment140664475517184); + + SeparationConstraint *separation140664475517408 = new SeparationConstraint(vpsc::YDIM, 13, 104, -50, true); + ccs.push_back(separation140664475517408); + + AlignmentConstraint *alignment140664475517552 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664475517552->addShape(14, 0); + alignment140664475517552->addShape(105, 0); + ccs.push_back(alignment140664475517552); + + SeparationConstraint *separation140664475517776 = new SeparationConstraint(vpsc::YDIM, 14, 105, -50, true); + ccs.push_back(separation140664475517776); + + AlignmentConstraint *alignment140664475517920 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475517920->addShape(16, 0); + alignment140664475517920->addShape(106, 0); + ccs.push_back(alignment140664475517920); + + SeparationConstraint *separation140664475518144 = new SeparationConstraint(vpsc::XDIM, 16, 106, 62, true); + ccs.push_back(separation140664475518144); + + AlignmentConstraint *alignment140664475518288 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475518288->addShape(18, 0); + alignment140664475518288->addShape(107, 0); + ccs.push_back(alignment140664475518288); + + SeparationConstraint *separation140664475518512 = new SeparationConstraint(vpsc::XDIM, 18, 107, 62, true); + ccs.push_back(separation140664475518512); + + AlignmentConstraint *alignment140664475518656 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475518656->addShape(19, 0); + alignment140664475518656->addShape(108, 0); + ccs.push_back(alignment140664475518656); + + SeparationConstraint *separation140664475518880 = new SeparationConstraint(vpsc::XDIM, 19, 108, 62, true); + ccs.push_back(separation140664475518880); + + AlignmentConstraint *alignment140664475519024 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475519024->addShape(20, 0); + alignment140664475519024->addShape(109, 0); + ccs.push_back(alignment140664475519024); + + SeparationConstraint *separation140664475519248 = new SeparationConstraint(vpsc::XDIM, 20, 109, 62, true); + ccs.push_back(separation140664475519248); + + AlignmentConstraint *alignment140664475519392 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664475519392->addShape(22, 0); + alignment140664475519392->addShape(110, 0); + ccs.push_back(alignment140664475519392); + + SeparationConstraint *separation140664475519616 = new SeparationConstraint(vpsc::YDIM, 22, 110, -50, true); + ccs.push_back(separation140664475519616); + + AlignmentConstraint *alignment140664475519760 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475519760->addShape(23, 0); + alignment140664475519760->addShape(111, 0); + ccs.push_back(alignment140664475519760); + + SeparationConstraint *separation140664475519984 = new SeparationConstraint(vpsc::XDIM, 23, 111, 62, true); + ccs.push_back(separation140664475519984); + + AlignmentConstraint *alignment140664475520128 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664475520128->addShape(24, 0); + alignment140664475520128->addShape(112, 0); + ccs.push_back(alignment140664475520128); + + SeparationConstraint *separation140664475520352 = new SeparationConstraint(vpsc::YDIM, 24, 112, -50, true); + ccs.push_back(separation140664475520352); + + AlignmentConstraint *alignment140664475520496 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664475520496->addShape(25, 0); + alignment140664475520496->addShape(113, 0); + ccs.push_back(alignment140664475520496); + + SeparationConstraint *separation140664475520720 = new SeparationConstraint(vpsc::YDIM, 25, 113, -50, true); + ccs.push_back(separation140664475520720); + + AlignmentConstraint *alignment140664475520864 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475520864->addShape(26, 0); + alignment140664475520864->addShape(114, 0); + ccs.push_back(alignment140664475520864); + + SeparationConstraint *separation140664475521088 = new SeparationConstraint(vpsc::XDIM, 26, 114, 62, true); + ccs.push_back(separation140664475521088); + + AlignmentConstraint *alignment140664475521232 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475521232->addShape(27, 0); + alignment140664475521232->addShape(115, 0); + ccs.push_back(alignment140664475521232); + + SeparationConstraint *separation140664475521456 = new SeparationConstraint(vpsc::XDIM, 27, 115, 62, true); + ccs.push_back(separation140664475521456); + + AlignmentConstraint *alignment140664475521600 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664475521600->addShape(28, 0); + alignment140664475521600->addShape(116, 0); + ccs.push_back(alignment140664475521600); + + SeparationConstraint *separation140664475521824 = new SeparationConstraint(vpsc::YDIM, 28, 116, -50, true); + ccs.push_back(separation140664475521824); + + AlignmentConstraint *alignment140664475521968 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664475521968->addShape(29, 0); + alignment140664475521968->addShape(117, 0); + ccs.push_back(alignment140664475521968); + + SeparationConstraint *separation140664475522192 = new SeparationConstraint(vpsc::YDIM, 29, 117, -50, true); + ccs.push_back(separation140664475522192); + + AlignmentConstraint *alignment140664475522336 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664475522336->addShape(30, 0); + alignment140664475522336->addShape(118, 0); + ccs.push_back(alignment140664475522336); + + SeparationConstraint *separation140664475522560 = new SeparationConstraint(vpsc::YDIM, 30, 118, -50, true); + ccs.push_back(separation140664475522560); + + AlignmentConstraint *alignment140664475522704 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475522704->addShape(31, 0); + alignment140664475522704->addShape(119, 0); + ccs.push_back(alignment140664475522704); + + SeparationConstraint *separation140664475522928 = new SeparationConstraint(vpsc::XDIM, 31, 119, 62, true); + ccs.push_back(separation140664475522928); + + AlignmentConstraint *alignment140664475523072 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475523072->addShape(32, 0); + alignment140664475523072->addShape(120, 0); + ccs.push_back(alignment140664475523072); + + SeparationConstraint *separation140664475523296 = new SeparationConstraint(vpsc::XDIM, 32, 120, 62, true); + ccs.push_back(separation140664475523296); + + AlignmentConstraint *alignment140664475523440 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475523440->addShape(33, 0); + alignment140664475523440->addShape(121, 0); + ccs.push_back(alignment140664475523440); + + SeparationConstraint *separation140664475523664 = new SeparationConstraint(vpsc::XDIM, 33, 121, 62, true); + ccs.push_back(separation140664475523664); + + AlignmentConstraint *alignment140664475523808 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664475523808->addShape(34, 0); + alignment140664475523808->addShape(122, 0); + ccs.push_back(alignment140664475523808); + + SeparationConstraint *separation140664475524032 = new SeparationConstraint(vpsc::YDIM, 34, 122, -50, true); + ccs.push_back(separation140664475524032); + + AlignmentConstraint *alignment140664475524176 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664475524176->addShape(35, 0); + alignment140664475524176->addShape(123, 0); + ccs.push_back(alignment140664475524176); + + SeparationConstraint *separation140664475524400 = new SeparationConstraint(vpsc::YDIM, 35, 123, -50, true); + ccs.push_back(separation140664475524400); + + AlignmentConstraint *alignment140664475524544 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664475524544->addShape(36, 0); + alignment140664475524544->addShape(124, 0); + ccs.push_back(alignment140664475524544); + + SeparationConstraint *separation140664475524768 = new SeparationConstraint(vpsc::YDIM, 36, 124, -50, true); + ccs.push_back(separation140664475524768); + + AlignmentConstraint *alignment140664475524912 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664475524912->addShape(37, 0); + alignment140664475524912->addShape(125, 0); + ccs.push_back(alignment140664475524912); + + SeparationConstraint *separation140664475525136 = new SeparationConstraint(vpsc::YDIM, 37, 125, -50, true); + ccs.push_back(separation140664475525136); + + AlignmentConstraint *alignment140664475525280 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664475525280->addShape(38, 0); + alignment140664475525280->addShape(126, 0); + ccs.push_back(alignment140664475525280); + + SeparationConstraint *separation140664475525504 = new SeparationConstraint(vpsc::YDIM, 38, 126, -50, true); + ccs.push_back(separation140664475525504); + + AlignmentConstraint *alignment140664475525648 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664475525648->addShape(40, 0); + alignment140664475525648->addShape(127, 0); + ccs.push_back(alignment140664475525648); + + SeparationConstraint *separation140664475525872 = new SeparationConstraint(vpsc::YDIM, 40, 127, -50, true); + ccs.push_back(separation140664475525872); + + AlignmentConstraint *alignment140664475526016 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475526016->addShape(41, 0); + alignment140664475526016->addShape(128, 0); + ccs.push_back(alignment140664475526016); + + SeparationConstraint *separation140664475526240 = new SeparationConstraint(vpsc::XDIM, 41, 128, 62, true); + ccs.push_back(separation140664475526240); + + AlignmentConstraint *alignment140664475526384 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664475526384->addShape(42, 0); + alignment140664475526384->addShape(129, 0); + ccs.push_back(alignment140664475526384); + + SeparationConstraint *separation140664475526608 = new SeparationConstraint(vpsc::YDIM, 42, 129, -50, true); + ccs.push_back(separation140664475526608); + + AlignmentConstraint *alignment140664475526752 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664475526752->addShape(43, 0); + alignment140664475526752->addShape(130, 0); + ccs.push_back(alignment140664475526752); + + SeparationConstraint *separation140664475526976 = new SeparationConstraint(vpsc::YDIM, 43, 130, -50, true); + ccs.push_back(separation140664475526976); + + AlignmentConstraint *alignment140664475527120 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664475527120->addShape(44, 0); + alignment140664475527120->addShape(131, 0); + ccs.push_back(alignment140664475527120); + + SeparationConstraint *separation140664475527344 = new SeparationConstraint(vpsc::YDIM, 44, 131, -50, true); + ccs.push_back(separation140664475527344); + + AlignmentConstraint *alignment140664475527488 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664475527488->addShape(45, 0); + alignment140664475527488->addShape(132, 0); + ccs.push_back(alignment140664475527488); + + SeparationConstraint *separation140664475527712 = new SeparationConstraint(vpsc::YDIM, 45, 132, -50, true); + ccs.push_back(separation140664475527712); + + AlignmentConstraint *alignment140664475527856 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664475527856->addShape(46, 0); + alignment140664475527856->addShape(133, 0); + ccs.push_back(alignment140664475527856); + + SeparationConstraint *separation140664475528080 = new SeparationConstraint(vpsc::YDIM, 46, 133, -50, true); + ccs.push_back(separation140664475528080); + + AlignmentConstraint *alignment140664475528224 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664475528224->addShape(47, 0); + alignment140664475528224->addShape(134, 0); + ccs.push_back(alignment140664475528224); + + SeparationConstraint *separation140664475528448 = new SeparationConstraint(vpsc::YDIM, 47, 134, -50, true); + ccs.push_back(separation140664475528448); + + AlignmentConstraint *alignment140664475528592 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664475528592->addShape(77, 0); + alignment140664475528592->addShape(135, 0); + ccs.push_back(alignment140664475528592); + + SeparationConstraint *separation140664475528816 = new SeparationConstraint(vpsc::YDIM, 77, 135, -50, true); + ccs.push_back(separation140664475528816); + + AlignmentConstraint *alignment140664475528960 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664475528960->addShape(78, 0); + alignment140664475528960->addShape(136, 0); + ccs.push_back(alignment140664475528960); + + SeparationConstraint *separation140664475529184 = new SeparationConstraint(vpsc::YDIM, 78, 136, -50, true); + ccs.push_back(separation140664475529184); + + AlignmentConstraint *alignment140664475529328 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664475529328->addShape(79, 0); + alignment140664475529328->addShape(137, 0); + ccs.push_back(alignment140664475529328); + + SeparationConstraint *separation140664475529552 = new SeparationConstraint(vpsc::YDIM, 79, 137, -50, true); + ccs.push_back(separation140664475529552); + + AlignmentConstraint *alignment140664475529696 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475529696->addShape(81, 0); + alignment140664475529696->addShape(138, 0); + ccs.push_back(alignment140664475529696); + + SeparationConstraint *separation140664475529920 = new SeparationConstraint(vpsc::XDIM, 81, 138, 62, true); + ccs.push_back(separation140664475529920); + + AlignmentConstraint *alignment140664475530064 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664475530064->addShape(82, 0); + alignment140664475530064->addShape(139, 0); + ccs.push_back(alignment140664475530064); + + SeparationConstraint *separation140664475530288 = new SeparationConstraint(vpsc::YDIM, 82, 139, -50, true); + ccs.push_back(separation140664475530288); + + AlignmentConstraint *alignment140664475530432 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664475530432->addShape(83, 0); + alignment140664475530432->addShape(140, 0); + ccs.push_back(alignment140664475530432); + + SeparationConstraint *separation140664475530656 = new SeparationConstraint(vpsc::YDIM, 83, 140, -50, true); + ccs.push_back(separation140664475530656); + + AlignmentConstraint *alignment140664475530800 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664475530800->addShape(84, 0); + alignment140664475530800->addShape(141, 0); + ccs.push_back(alignment140664475530800); + + SeparationConstraint *separation140664475531024 = new SeparationConstraint(vpsc::YDIM, 84, 141, -50, true); + ccs.push_back(separation140664475531024); + + AlignmentConstraint *alignment140664475531168 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475531168->addShape(85, 0); + alignment140664475531168->addShape(142, 0); + ccs.push_back(alignment140664475531168); + + SeparationConstraint *separation140664475531392 = new SeparationConstraint(vpsc::XDIM, 85, 142, 62, true); + ccs.push_back(separation140664475531392); + + AlignmentConstraint *alignment140664475531536 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664475531536->addShape(87, 0); + alignment140664475531536->addShape(143, 0); + ccs.push_back(alignment140664475531536); + + SeparationConstraint *separation140664475531760 = new SeparationConstraint(vpsc::YDIM, 87, 143, -50, true); + ccs.push_back(separation140664475531760); + + AlignmentConstraint *alignment140664475531904 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664475531904->addShape(88, 0); + alignment140664475531904->addShape(144, 0); + ccs.push_back(alignment140664475531904); + + SeparationConstraint *separation140664475532128 = new SeparationConstraint(vpsc::YDIM, 88, 144, -50, true); + ccs.push_back(separation140664475532128); + + AlignmentConstraint *alignment140664475532272 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664475532272->addShape(90, 0); + alignment140664475532272->addShape(145, 0); + ccs.push_back(alignment140664475532272); + + SeparationConstraint *separation140664475532496 = new SeparationConstraint(vpsc::YDIM, 90, 145, -50, true); + ccs.push_back(separation140664475532496); + + AlignmentConstraint *alignment140664475532640 = new AlignmentConstraint(vpsc::YDIM, 0); + alignment140664475532640->addShape(91, 0); + alignment140664475532640->addShape(146, 0); + ccs.push_back(alignment140664475532640); + + SeparationConstraint *separation140664475532864 = new SeparationConstraint(vpsc::XDIM, 91, 146, 62, true); + ccs.push_back(separation140664475532864); + + AlignmentConstraint *alignment140664475533008 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664475533008->addShape(92, 0); + alignment140664475533008->addShape(147, 0); + ccs.push_back(alignment140664475533008); + + SeparationConstraint *separation140664475533232 = new SeparationConstraint(vpsc::YDIM, 92, 147, -50, true); + ccs.push_back(separation140664475533232); + + AlignmentConstraint *alignment140664475533376 = new AlignmentConstraint(vpsc::XDIM, 0); + alignment140664475533376->addShape(93, 0); + alignment140664475533376->addShape(148, 0); + ccs.push_back(alignment140664475533376); + + SeparationConstraint *separation140664475533600 = new SeparationConstraint(vpsc::YDIM, 93, 148, -50, true); + ccs.push_back(separation140664475533600); + + RootCluster *cluster140664475533920 = new RootCluster(); + + RectangularCluster *cluster140664475534416 = new RectangularCluster(5); + cluster140664475534416->addChildNode(149); + cluster140664475534416->addChildNode(150); + cluster140664475534416->addChildNode(151); + cluster140664475534416->addChildNode(152); + cluster140664475533920->addChildCluster(cluster140664475534416); + + RectangularCluster *cluster140664475535040 = new RectangularCluster(6); + cluster140664475535040->addChildNode(153); + cluster140664475533920->addChildCluster(cluster140664475535040); + + RectangularCluster *cluster140664475535648 = new RectangularCluster(15); + cluster140664475533920->addChildCluster(cluster140664475535648); + + RectangularCluster *cluster140664475535952 = new RectangularCluster(17); + cluster140664475535952->addChildNode(154); + cluster140664475535952->addChildNode(155); + cluster140664475533920->addChildCluster(cluster140664475535952); + + RectangularCluster *cluster140664475536320 = new RectangularCluster(21); + cluster140664475536320->addChildNode(156); + cluster140664475533920->addChildCluster(cluster140664475536320); + + RectangularCluster *cluster140664475536720 = new RectangularCluster(39); + cluster140664475533920->addChildCluster(cluster140664475536720); + + RectangularCluster *cluster140664475537056 = new RectangularCluster(80); + cluster140664475537056->addChildNode(157); + cluster140664475533920->addChildCluster(cluster140664475537056); + + ConstrainedFDLayout alg(rs, es, defaultEdgeLength); + alg.setAvoidNodeOverlaps(true); + alg.setClusterHierarchy(cluster140664475533920); + alg.setConstraints(ccs); + alg.makeFeasible(); + + alg.outputInstanceToSVG("test-rectclustershapecontainment"); + //alg.run(); + alg.freeAssociatedObjects(); + + return 0; +}; |