00001
00002
00003 #if defined(_MSC_VER)
00004
00005 # pragma warning(disable:4786)
00006 #endif
00007
00008 #include <cassert>
00009
00010 #include "OsiIndexedVector.hpp"
00011 #include "OsiShallowPackedVector.hpp"
00012
00013 #ifdef NDEBUG
00014 #undef NDEBUG
00015 #endif
00016
00017
00018 void
00019 OsiIndexedVectorUnitTest()
00020 {
00021
00022 int i;
00023
00024 {
00025 OsiIndexedVector r;
00026 assert( r.indices_==NULL );
00027 assert( r.packedElements_==NULL );
00028 assert( r.elements_==NULL );
00029 assert( r.getNumElements()==0 );
00030 assert( r.capacity_==0);
00031 }
00032
00033
00034 const int ne = 4;
00035 int inx[ne] = { 1, 3, 4, 7 };
00036 double el[ne] = { 1.2, 3.4, 5.6, 7.8 };
00037 {
00038 OsiIndexedVector r;
00039 assert( r.getNumElements()==0 );
00040
00041
00042 r.setVector( ne, inx, el );
00043 assert( r.getNumElements()==ne );
00044 for ( i=0; i<ne; i++ ) {
00045 assert( r.getIndices()[i] == inx[i] );
00046 assert( r[inx[i]] == el[i] );
00047 assert( r.getElements()[i] == el[i] );
00048 }
00049 assert ( r.getMaxIndex()==7 );
00050 assert ( r.getMinIndex()==1 );
00051
00052
00053 const int ne2 = 5;
00054 int inx2[ne2] = { 2, 4, 8, 14, 3 };
00055 double el2[ne2] = { 2.2, 4.4, 6.6, 8.8, 3.3 };
00056
00057 r.setVector(ne2,inx2,el2);
00058
00059 assert( r.getNumElements()==ne2 );
00060
00061 assert( r.getIndices()[0]==inx2[0] );
00062 assert( r.getElements()[0]==el2[0] );
00063
00064 assert( r.getIndices()[1]==inx2[1] );
00065 assert( r.getElements()[1]==el2[1] );
00066
00067 assert( r.getIndices()[2]==inx2[2] );
00068 assert( r.getElements()[2]==el2[2] );
00069
00070 assert( r.getIndices()[3]==inx2[3] );
00071 assert( r.getElements()[3]==el2[3] );
00072
00073 assert( r.getIndices()[4]==inx2[4] );
00074 assert( r.getElements()[4]==el2[4] );
00075
00076 assert ( r.getMaxIndex()==14 );
00077 assert ( r.getMinIndex()==2 );
00078 assert ( r.getMaxIndex()==14 );
00079 assert ( r.getMinIndex()==2 );
00080 {
00081 bool errorThrown = false;
00082 try {
00083 r.duplicateIndex();
00084 }
00085 catch (CoinError e) {
00086 errorThrown = true;
00087 }
00088 assert( !errorThrown );
00089 }
00090
00091 OsiIndexedVector r1(ne2,inx2,el2);
00092 assert( r == r1 );
00093 }
00094 OsiIndexedVector r;
00095
00096
00097
00098 {
00099 const int ne3 = 4;
00100 int inx3[ne3] = { 2, 4, 2, 3 };
00101 double el3[ne3] = { 2.2, 4.4, 8.8, 6.6 };
00102 bool errorThrown = false;
00103 try {
00104 r.setVector(ne3,inx3,el3);
00105 }
00106 catch (CoinError e) {
00107 errorThrown = true;
00108 }
00109 assert( errorThrown );
00110
00111 }
00112
00113
00114
00115 {
00116 OsiIndexedVector r;
00117 const int ne = 3;
00118 int inx[ne] = { 1, 2, 3 };
00119 double el[ne] = { 2.2, 4.4, 8.8};
00120 r.setVector(ne,inx,el);
00121 int c = r.capacity();
00122 int max = r.getMaxIndex();
00123 int min = r.getMinIndex();
00124
00125 r.swap(0,2);
00126 assert( r.getIndices()[0]==3 );
00127 assert( r.getIndices()[1]==2 );
00128 assert( r.getIndices()[2]==1 );
00129 assert( r.getElements()[0]==8.8 );
00130 assert( r.getElements()[1]==4.4 );
00131 assert( r.getElements()[2]==2.2 );
00132 assert( r.getMaxIndex() == max );
00133 assert( r.getMinIndex() == min );
00134 assert( r.capacity() == c );
00135
00136
00137 OsiIndexedVector s;
00138 const int nes = 4;
00139 int inxs[nes] = { 11, 12, 13, 14 };
00140 double els[nes] = { .122, 14.4, 18.8, 19.9};
00141 s.setVector(nes,inxs,els);
00142 r.append(s);
00143 assert( r.getNumElements()==7 );
00144 assert( r.getIndices()[0]==3 );
00145 assert( r.getIndices()[1]==2 );
00146 assert( r.getIndices()[2]==1 );
00147 assert( r.getIndices()[3]==11 );
00148 assert( r.getIndices()[4]==12 );
00149 assert( r.getIndices()[5]==13 );
00150 assert( r.getIndices()[6]==14 );
00151 assert( r.getElements()[0]==8.8 );
00152 assert( r.getElements()[1]==4.4 );
00153 assert( r.getElements()[2]==2.2 );
00154 assert( r.getElements()[3]==.122 );
00155 assert( r.getElements()[4]==14.4 );
00156 assert( r.getElements()[5]==18.8 );
00157 assert( r.getElements()[6]==19.9 );
00158 assert( r.getMaxIndex() == 14 );
00159 assert( r.getMinIndex() == 1 );
00160
00161
00162 c = r.capacity();
00163 r.truncate(4);
00164
00165 assert( r.getNumElements()==3 );
00166 assert( r.getIndices()[0]==3 );
00167 assert( r.getIndices()[1]==2 );
00168 assert( r.getIndices()[2]==1 );
00169 assert( r.getElements()[0]==8.8 );
00170 assert( r.getElements()[1]==4.4 );
00171 assert( r.getElements()[2]==2.2 );
00172 assert( r.getMaxIndex() == 3 );
00173 assert( r.getMinIndex() == 1 );
00174 assert( r.capacity() == c );
00175 }
00176
00177
00178 {
00179 OsiIndexedVector r,r2;
00180 const int ne = 3;
00181 int inx[ne] = { 1, 2, 3 };
00182 double el[ne] = { 2.2, 4.4, 8.8};
00183 double els[4] = { 0.0,2.2, 4.4, 8.8};
00184 r.setVector(ne,inx,el);
00185 r2.borrowVector(4,ne,inx,els);
00186 assert (r==r2);
00187 r2.returnVector();
00188 assert (!r2.capacity());
00189 assert (!r2.getNumElements());
00190 assert (!r2.denseVector());
00191 assert (!r2.getIndices());
00192 }
00193
00194
00195 {
00196 OsiIndexedVector rhs;
00197 {
00198 OsiIndexedVector r;
00199 {
00200 OsiIndexedVector rC1(r);
00201 assert( 0==r.getNumElements() );
00202 assert( 0==rC1.getNumElements() );
00203
00204
00205 r.setVector( ne, inx, el );
00206
00207 assert( ne==r.getNumElements() );
00208 assert( 0==rC1.getNumElements() );
00209 }
00210
00211 OsiIndexedVector rC2(r);
00212
00213 assert( ne==r.getNumElements() );
00214 assert( ne==rC2.getNumElements() );
00215
00216 for ( i=0; i<ne; i++ ) {
00217 assert( r.getIndices()[i] == rC2.getIndices()[i] );
00218 assert( r[r.getIndices()[i]] == rC2.getElements()[i]);
00219 assert( r.getElements()[i] == rC2.getElements()[i] );
00220 }
00221
00222 rhs=rC2;
00223 }
00224
00225 assert( rhs.getNumElements()==ne );
00226
00227 for ( i=0; i<ne; i++ ) {
00228 assert( inx[i] == rhs.getIndices()[i] );
00229 assert( el[i] == rhs.getElements()[i] );
00230 }
00231 }
00232
00233
00234 {
00235 OsiIndexedVector v1,v2;
00236 assert( v1==v2 );
00237 assert( v2==v1 );
00238 assert( v1==v1 );
00239 assert( !(v1!=v2) );
00240 assert( v1.isEquivalent(v2) );
00241 assert( v2.isEquivalent(v1) );
00242 assert( v1.isEquivalent(v1) );
00243
00244 v1.setVector( ne, inx, el );
00245 assert ( !(v1==v2) );
00246 assert ( v1!=v2 );
00247 assert( !v1.isEquivalent(v2) );
00248
00249 OsiIndexedVector v3(v1);
00250 assert( v3==v1 );
00251 assert( v3!=v2 );
00252 assert( v1.isEquivalent(v3) );
00253 assert( v3.isEquivalent(v1) );
00254
00255 OsiIndexedVector v4(v2);
00256 assert( v4!=v1 );
00257 assert( v4==v2 );
00258 }
00259
00260 {
00261
00262 const int ne = 4;
00263 int inx[ne] = { 1, 4, 0, 2 };
00264 double el[ne] = { 10., 40., 1., 20. };
00265 OsiIndexedVector r;
00266 r.setVector(ne,inx,el);
00267
00268
00269 r.sort();
00270 for ( i=1; i<ne; i++ ) assert( r.getIndices()[i-1] < r.getIndices()[i] );
00271
00272 }
00273 {
00274
00275 const int ne = 4;
00276 int inx[ne] = { 1, 4, 0, 2 };
00277 double el[ne] = { 10., 40., 1., 50. };
00278 OsiIndexedVector r;
00279 bool errorThrown = false;
00280 try {
00281 assert( r[1]==0. );
00282 }
00283 catch (CoinError e) {
00284 errorThrown = true;
00285 }
00286 assert( errorThrown );
00287
00288 r.setVector(ne,inx,el);
00289
00290 errorThrown = false;
00291 try {
00292 assert( r[-1]==0. );
00293 }
00294 catch (CoinError e) {
00295 errorThrown = true;
00296 }
00297 assert( errorThrown );
00298
00299 assert( r[ 0]==1. );
00300 assert( r[ 1]==10.);
00301 assert( r[ 2]==50.);
00302 assert( r[ 3]==0. );
00303 assert( r[ 4]==40.);
00304 errorThrown = false;
00305 try {
00306 assert( r[5]==0. );
00307 }
00308 catch (CoinError e) {
00309 errorThrown = true;
00310 }
00311 assert( errorThrown );
00312
00313 assert( r.isExistingIndex(2) );
00314 assert( !r.isExistingIndex(3) );
00315
00316 assert ( r.getMaxIndex()==4 );
00317 assert ( r.getMinIndex()==0 );
00318 }
00319
00320
00321
00322 {
00323 OsiIndexedVector nullVec;
00324 assert( nullVec.getMaxIndex() ==
00325 INT_MIN );
00326 assert( nullVec.getMinIndex() ==
00327 INT_MAX );
00328 }
00329
00330
00331 {
00332 const int ne = 4;
00333 int inx1[ne] = { 1, 3, 4, 7 };
00334 double el1[ne] = { 1.2, 3.4, 5.6, 7.8 };
00335 int inx2[ne] = { 7, 4, 3, 1 };
00336 double el2[ne] = { 7.8+.5, 5.6+.5, 3.4+.5, 1.2+.5 };
00337 OsiIndexedVector v1,v2;
00338 v1.setVector(ne,inx1,el1);
00339 v2.setVector(ne,inx2,el2);
00340 assert( !v1.isEquivalent(v2) );
00341 assert( v1.isEquivalent(v2,OsiAbsFltEq(.6)) );
00342 assert( v1.isEquivalent(v2,OsiRelFltEq(.6)) );
00343 }
00344
00345 {
00346
00347 OsiIndexedVector v1,v2;
00348 assert( v1.capacity()==0 );
00349 v1.reserve(6);
00350 assert( v1.capacity()==6 );
00351 assert( v1.getNumElements()==0 );
00352 v2=v1;
00353 assert( v2.capacity() == 6 );
00354 assert( v2.getNumElements()==0 );
00355 assert( v2==v1 );
00356 v1.setVector(0,NULL,NULL);
00357 assert( v1.capacity()==6 );
00358 assert( v1.getNumElements()==0 );
00359 assert( v2==v1 );
00360 v2=v1;
00361 assert( v2.capacity() == 6 );
00362 assert( v2.getNumElements()==0 );
00363 assert( v2==v1 );
00364
00365 const int ne = 2;
00366 int inx[ne] = { 1, 3 };
00367 double el[ne] = { 1.2, 3.4 };
00368 v1.setVector(ne,inx,el);
00369 assert( v1.capacity()==6 );
00370 assert( v1.getNumElements()==2 );
00371 v2=v1;
00372 assert( v2.capacity()==6 );
00373 assert( v2.getNumElements()==2 );
00374 assert( v2==v1 );
00375
00376 const int ne1 = 5;
00377 int inx1[ne1] = { 1, 3, 4, 5, 6 };
00378 double el1[ne1] = { 1.2, 3.4, 5., 6., 7. };
00379 v1.setVector(ne1,inx1,el1);
00380 assert( v1.capacity()==7 );
00381 assert( v1.getNumElements()==5 );
00382 v2=v1;
00383 assert( v2.capacity()==7 );
00384 assert( v2.getNumElements()==5 );
00385 assert( v2==v1 );
00386
00387 const int ne2 = 8;
00388 int inx2[ne2] = { 1, 3, 4, 5, 6, 7, 8, 9 };
00389 double el2[ne2] = { 1.2, 3.4, 5., 6., 7., 8., 9., 10. };
00390 v1.setVector(ne2,inx2,el2);
00391 assert( v1.capacity()==10 );
00392 assert( v1.getNumElements()==8 );
00393 v2=v1;
00394 assert( v2.getNumElements()==8 );
00395 assert( v2==v1 );
00396
00397 v1.setVector(ne1,inx1,el1);
00398 assert( v1.capacity()==10 );
00399 assert( v1.getNumElements()==5 );
00400 v2=v1;
00401 assert( v2.capacity()==10 );
00402 assert( v2.getNumElements()==5 );
00403 assert( v2==v1 );
00404
00405 v1.reserve(7);
00406 assert( v1.capacity()==10 );
00407 assert( v1.getNumElements()==5 );
00408 v2=v1;
00409 assert( v2.capacity()==10 );
00410 assert( v2.getNumElements()==5 );
00411 assert( v2==v1 );
00412
00413 }
00414
00415
00416 {
00417 OsiIndexedVector v1;
00418 assert( v1.getNumElements()==0 );
00419 assert( v1.capacity()==0 );
00420
00421 assert( !v1.isExistingIndex(1) );
00422 v1.insert(1,1.);
00423 assert( v1.getNumElements()==1 );
00424 assert( v1.capacity()==2 );
00425 assert( v1.getIndices()[0] == 1 );
00426 assert( v1.getElements()[0] == 1. );
00427 assert( v1.isExistingIndex(1) );
00428
00429 assert( !v1.isExistingIndex(10) );
00430 v1.insert(10,10.);
00431 assert( v1.getNumElements()==2 );
00432 assert( v1.capacity()==11 );
00433 assert( v1.getIndices()[1] == 10 );
00434 assert( v1.getElements()[1] == 10. );
00435 assert( v1.isExistingIndex(1) );
00436 assert( v1.isExistingIndex(10) );
00437
00438 assert( !v1.isExistingIndex(20) );
00439 v1.insert(20,20.);
00440 assert( v1.getNumElements()==3 );
00441 assert( v1.capacity()==21 );
00442 assert( v1.getIndices()[2] == 20 );
00443 assert( v1.getElements()[2] == 20. );
00444 assert( v1.isExistingIndex(20) );
00445
00446 assert( !v1.isExistingIndex(30) );
00447 v1.insert(30,30.);
00448 assert( v1.getNumElements()==4 );
00449 assert( v1.capacity()==31 );
00450 assert( v1.getIndices()[3] == 30 );
00451 assert( v1.getElements()[3] == 30. );
00452 assert( v1.isExistingIndex(30) );
00453
00454 assert( !v1.isExistingIndex(40) );
00455 v1.insert(40,40.);
00456 assert( v1.getNumElements()==5 );
00457 assert( v1.capacity()==41 );
00458 assert( v1.getIndices()[4] == 40 );
00459 assert( v1.getElements()[4] == 40. );
00460 assert( v1.isExistingIndex(40) );
00461
00462 assert( !v1.isExistingIndex(50) );
00463 v1.insert(50,50.);
00464 assert( v1.getNumElements()==6 );
00465 assert( v1.capacity()==51 );
00466 assert( v1.getIndices()[5] == 50 );
00467 assert( v1.getElements()[5] == 50. );
00468 assert( v1.isExistingIndex(50) );
00469
00470 OsiIndexedVector v2;
00471 const int ne1 = 3;
00472 int inx1[ne1] = { 1, 3, 4 };
00473 double el1[ne1] = { 1.2, 3.4, 5. };
00474 v2.setVector(ne1,inx1,el1);
00475 assert( v2.getNumElements()==3 );
00476 assert( v2.capacity()==5 );
00477
00478
00479 assert(v2.clean(3.0)==2);
00480 assert(v2.denseVector()[1]==0.0);
00481
00482
00483
00484
00485 v2.checkClean();
00486 assert( v2.getNumElements()==2 );
00487
00488
00489 assert(v2.clean(10.0)==0);
00490 v2.checkClear();
00491
00492 }
00493
00494 {
00495
00496 OsiIndexedVector v2;
00497 const int ne1 = 3;
00498 int inx1[ne1] = { 1, 3, 4 };
00499 v2.setConstant(ne1,inx1,3.14);
00500 assert( v2.getNumElements()==3 );
00501 assert( v2.capacity()==5 );
00502 assert( v2.getIndices()[0]==1 );
00503 assert( v2.getElements()[0]==3.14 );
00504 assert( v2.getIndices()[1]==3 );
00505 assert( v2.getElements()[1]==3.14 );
00506 assert( v2.getIndices()[2]==4 );
00507 assert( v2.getElements()[2]==3.14 );
00508
00509 assert( v2[3] == 3.14 );
00510
00511 OsiIndexedVector v2X(ne1,inx1,3.14);
00512 assert( v2 == v2X );
00513
00514 }
00515
00516 {
00517
00518 OsiIndexedVector v2;
00519 const int ne2 = 3;
00520 double el2[ne2] = { 1., 3., 4. };
00521 v2.setFull(ne2,el2);
00522 assert( v2.getNumElements()==3 );
00523 assert( v2.capacity()==3 );
00524 assert( v2.getIndices()[0]==0 );
00525 assert( v2.getElements()[0]==1. );
00526 assert( v2.getIndices()[1]==1 );
00527 assert( v2.getElements()[1]==3. );
00528 assert( v2.getIndices()[2]==2 );
00529 assert( v2.getElements()[2]==4. );
00530
00531 assert( v2[1] == 3. );
00532
00533 OsiIndexedVector v2X(ne2,el2);
00534 assert( v2 == v2X );
00535
00536 v2.setFull(0,el2);
00537 assert( v2[2] == 0. );
00538 }
00539
00540
00541 #if 0
00542
00543
00544 {
00545 const int ne = 4;
00546 int inx1[ne] = { 1, 3, 4, 7 };
00547 double el1[ne] = { 1.2, 3.4, 5.6, 7.8 };
00548 OsiIndexedVector v1;
00549 v1.set(-ne,inx1,el1);
00550 }
00551 #endif
00552
00553
00554
00555
00556 {
00557 OsiIndexedVector s;
00558 assert( s.sum() == 0 );
00559
00560 s.insert(25,45.);
00561 assert(s.sum()==45.);
00562
00563 const int ne1 = 5;
00564 int inx1[ne1] = { 10, 3, 4, 7, 5 };
00565 double el1[ne1] = { 1., 5., 6., 2., 9. };
00566 s.setVector(ne1,inx1,el1);
00567
00568 assert(s.sum()==1.+5.+6.+2.+9.);
00569 }
00570
00571
00572 {
00573
00574 const int ne1 = 2;
00575 int inx1[ne1] = { 1, 4 };
00576 double el1[ne1] = { 1., 6. };
00577 OsiIndexedVector v1(ne1,inx1,el1);
00578
00579
00580 const int ne2 = 3;
00581 int inx2[ne2] = { 1, 2, 4 };
00582 double el2[ne2] = { 1., 7., 4.};
00583 OsiIndexedVector v2(ne2,inx2,el2);
00584
00585
00586 OsiIndexedVector ratio = v1 / v2;
00587
00588
00589
00590
00591
00592
00593
00594
00595
00596
00597
00598 ratio.sortDecrElement();
00599
00600
00601 assert( ratio.getNumElements() == 2);
00602 double temp = 1.0 ;
00603 temp /= 1.0 ;
00604 assert( ratio.getElements()[1] == temp );
00605 temp = 6.0 ;
00606 temp /= 4.0 ;
00607 assert( ratio.getElements()[0] == temp );
00608
00609
00610 assert( v1[ ratio.getIndices()[1] ] == 1.0 );
00611 assert( v1[ ratio.getIndices()[0] ] == 6.0 );
00612
00613
00614 assert( v2[ ratio.getIndices()[1] ] == 1.0 );
00615 assert( v2[ ratio.getIndices()[0] ] == 4.0 );
00616 }
00617
00618
00619 {
00620 const int ne = 4;
00621 int inx[ne] = { 1, 4, 0, 2 };
00622 double el[ne] = { 10., 40., 1., 50. };
00623 OsiIndexedVector std(ne,inx,el);
00624 OsiShallowPackedVector * spvP = new OsiShallowPackedVector(ne,inx,el);
00625 OsiIndexedVector pv(*spvP);
00626 assert( pv == std );
00627 assert( pv.isEquivalent(std) );
00628 delete spvP;
00629 assert( pv == std );
00630 assert( pv.isEquivalent(std) );
00631 pv.sortIncrElement();
00632 assert( pv != std );
00633 assert( pv.isEquivalent(std) );
00634 }
00635
00636
00637 {
00638 const int ne = 4;
00639 int inx[ne] = { 1, 4, 0, 2 };
00640 double el[ne] = { 10., 40., 1., 50. };
00641 OsiIndexedVector std(ne,inx,el);
00642 OsiShallowPackedVector * spvP = new OsiShallowPackedVector(ne,inx,el);
00643 OsiIndexedVector pv;
00644 pv = *spvP;
00645 assert( pv == std );
00646 assert( pv.isEquivalent(std) );
00647 delete spvP;
00648 assert( pv == std );
00649 assert( pv.isEquivalent(std) );
00650 pv.sortIncrElement();
00651 assert( pv != std );
00652 assert( pv.isEquivalent(std) );
00653 }
00654
00655 {
00656
00657
00658 const int ne = 4;
00659 int inx[ne] = { 1, 4, 0, 2 };
00660 double el[ne] = { 10., 40., 1., 50. };
00661 OsiIndexedVector r(ne,inx,el);
00662
00663 assert( r.getIndices()[0]== 1 );
00664 assert( r.getElements()[0]==10. );
00665 assert( r.getIndices()[1]== 4 );
00666 assert( r.getElements()[1]==40. );
00667 assert( r.getIndices()[2]== 0 );
00668 assert( r.getElements()[2]== 1. );
00669 assert( r.getIndices()[3]== 2 );
00670 assert( r.getElements()[3]==50. );
00671
00672 assert( r[ 0]==1. );
00673 assert( r[ 1]==10.);
00674 assert( r[ 2]==50.);
00675 assert( r[ 3]==0. );
00676 assert( r[ 4]==40.);
00677
00678 r.sortIncrElement();
00679
00680 assert( r.getIndices()[0]== 0 );
00681 assert( r.getElements()[0]== 1. );
00682 assert( r.getIndices()[1]== 1 );
00683 assert( r.getElements()[1]==10. );
00684 assert( r.getIndices()[2]== 4 );
00685 assert( r.getElements()[2]==40. );
00686 assert( r.getIndices()[3]== 2 );
00687 assert( r.getElements()[3]==50. );
00688
00689 assert( r[ 0]==1. );
00690 assert( r[ 1]==10.);
00691 assert( r[ 2]==50.);
00692 assert( r[ 3]==0. );
00693 assert( r[ 4]==40.);
00694
00695 OsiIndexedVector r1;
00696 r1=r;
00697 assert( r==r1 );
00698 assert( r.isEquivalent(r1) );
00699 r.sortDecrElement();
00700 assert( r!=r1 );
00701 assert( r.isEquivalent(r1) );
00702
00703 OsiIndexedVector add = r + r1;
00704 assert( add[0] == 1.+ 1. );
00705 assert( add[1] == 10.+10. );
00706 assert( add[2] == 50.+50. );
00707 assert( add[3] == 0.+ 0. );
00708 assert( add[4] == 40.+40. );
00709
00710 assert( r.sum() == 10.+40.+1.+50. );
00711 }
00712
00713 }
00714
00715
00716