00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043
00044
00045
00046
00047
00048
00049
00050
00051
00052
00053
00054
00055
00056
00057
00058
00059
00060
00061 #ifndef __GLIBCPP_INTERNAL_DEQUE_TCC
00062 #define __GLIBCPP_INTERNAL_DEQUE_TCC
00063
00064 namespace std
00065 {
00066 template <typename _Tp, typename _Alloc>
00067 deque<_Tp,_Alloc>&
00068 deque<_Tp,_Alloc>::
00069 operator=(const deque& __x)
00070 {
00071 const size_type __len = size();
00072 if (&__x != this)
00073 {
00074 if (__len >= __x.size())
00075 erase(copy(__x.begin(), __x.end(), _M_start), _M_finish);
00076 else
00077 {
00078 const_iterator __mid = __x.begin() + difference_type(__len);
00079 copy(__x.begin(), __mid, _M_start);
00080 insert(_M_finish, __mid, __x.end());
00081 }
00082 }
00083 return *this;
00084 }
00085
00086 template <typename _Tp, typename _Alloc>
00087 typename deque<_Tp,_Alloc>::iterator
00088 deque<_Tp,_Alloc>::
00089 insert(iterator position, const value_type& __x)
00090 {
00091 if (position._M_cur == _M_start._M_cur)
00092 {
00093 push_front(__x);
00094 return _M_start;
00095 }
00096 else if (position._M_cur == _M_finish._M_cur)
00097 {
00098 push_back(__x);
00099 iterator __tmp = _M_finish;
00100 --__tmp;
00101 return __tmp;
00102 }
00103 else
00104 return _M_insert_aux(position, __x);
00105 }
00106
00107 template <typename _Tp, typename _Alloc>
00108 typename deque<_Tp,_Alloc>::iterator
00109 deque<_Tp,_Alloc>::
00110 erase(iterator __position)
00111 {
00112 iterator __next = __position;
00113 ++__next;
00114 size_type __index = __position - _M_start;
00115 if (__index < (size() >> 1))
00116 {
00117 copy_backward(_M_start, __position, __next);
00118 pop_front();
00119 }
00120 else
00121 {
00122 copy(__next, _M_finish, __position);
00123 pop_back();
00124 }
00125 return _M_start + __index;
00126 }
00127
00128 template <typename _Tp, typename _Alloc>
00129 typename deque<_Tp,_Alloc>::iterator
00130 deque<_Tp,_Alloc>::
00131 erase(iterator __first, iterator __last)
00132 {
00133 if (__first == _M_start && __last == _M_finish)
00134 {
00135 clear();
00136 return _M_finish;
00137 }
00138 else
00139 {
00140 difference_type __n = __last - __first;
00141 difference_type __elems_before = __first - _M_start;
00142 if (static_cast<size_type>(__elems_before) < (size() - __n) / 2)
00143 {
00144 copy_backward(_M_start, __first, __last);
00145 iterator __new_start = _M_start + __n;
00146 _Destroy(_M_start, __new_start);
00147 _M_destroy_nodes(_M_start._M_node, __new_start._M_node);
00148 _M_start = __new_start;
00149 }
00150 else
00151 {
00152 copy(__last, _M_finish, __first);
00153 iterator __new_finish = _M_finish - __n;
00154 _Destroy(__new_finish, _M_finish);
00155 _M_destroy_nodes(__new_finish._M_node + 1, _M_finish._M_node + 1);
00156 _M_finish = __new_finish;
00157 }
00158 return _M_start + __elems_before;
00159 }
00160 }
00161
00162 template <typename _Tp, typename _Alloc>
00163 void
00164 deque<_Tp,_Alloc>::
00165 clear()
00166 {
00167 for (_Map_pointer __node = _M_start._M_node + 1;
00168 __node < _M_finish._M_node;
00169 ++__node)
00170 {
00171 _Destroy(*__node, *__node + _S_buffer_size());
00172 _M_deallocate_node(*__node);
00173 }
00174
00175 if (_M_start._M_node != _M_finish._M_node)
00176 {
00177 _Destroy(_M_start._M_cur, _M_start._M_last);
00178 _Destroy(_M_finish._M_first, _M_finish._M_cur);
00179 _M_deallocate_node(_M_finish._M_first);
00180 }
00181 else
00182 _Destroy(_M_start._M_cur, _M_finish._M_cur);
00183
00184 _M_finish = _M_start;
00185 }
00186
00187 template <typename _Tp, class _Alloc>
00188 template <typename _InputIter>
00189 void
00190 deque<_Tp,_Alloc>
00191 ::_M_assign_aux(_InputIter __first, _InputIter __last, input_iterator_tag)
00192 {
00193 iterator __cur = begin();
00194 for ( ; __first != __last && __cur != end(); ++__cur, ++__first)
00195 *__cur = *__first;
00196 if (__first == __last)
00197 erase(__cur, end());
00198 else
00199 insert(end(), __first, __last);
00200 }
00201
00202 template <typename _Tp, typename _Alloc>
00203 void
00204 deque<_Tp,_Alloc>::
00205 _M_fill_insert(iterator __pos, size_type __n, const value_type& __x)
00206 {
00207 if (__pos._M_cur == _M_start._M_cur)
00208 {
00209 iterator __new_start = _M_reserve_elements_at_front(__n);
00210 try
00211 {
00212 uninitialized_fill(__new_start, _M_start, __x);
00213 _M_start = __new_start;
00214 }
00215 catch(...)
00216 {
00217 _M_destroy_nodes(__new_start._M_node, _M_start._M_node);
00218 __throw_exception_again;
00219 }
00220 }
00221 else if (__pos._M_cur == _M_finish._M_cur)
00222 {
00223 iterator __new_finish = _M_reserve_elements_at_back(__n);
00224 try
00225 {
00226 uninitialized_fill(_M_finish, __new_finish, __x);
00227 _M_finish = __new_finish;
00228 }
00229 catch(...)
00230 {
00231 _M_destroy_nodes(_M_finish._M_node + 1, __new_finish._M_node + 1);
00232 __throw_exception_again;
00233 }
00234 }
00235 else
00236 _M_insert_aux(__pos, __n, __x);
00237 }
00238
00239 template <typename _Tp, typename _Alloc>
00240 void
00241 deque<_Tp,_Alloc>::
00242 _M_fill_initialize(const value_type& __value)
00243 {
00244 _Map_pointer __cur;
00245 try
00246 {
00247 for (__cur = _M_start._M_node; __cur < _M_finish._M_node; ++__cur)
00248 uninitialized_fill(*__cur, *__cur + _S_buffer_size(), __value);
00249 uninitialized_fill(_M_finish._M_first, _M_finish._M_cur, __value);
00250 }
00251 catch(...)
00252 {
00253 _Destroy(_M_start, iterator(*__cur, __cur));
00254 __throw_exception_again;
00255 }
00256 }
00257
00258 template <typename _Tp, typename _Alloc>
00259 template <typename _InputIterator>
00260 void
00261 deque<_Tp,_Alloc>::
00262 _M_range_initialize(_InputIterator __first, _InputIterator __last,
00263 input_iterator_tag)
00264 {
00265 _M_initialize_map(0);
00266 try
00267 {
00268 for ( ; __first != __last; ++__first)
00269 push_back(*__first);
00270 }
00271 catch(...)
00272 {
00273 clear();
00274 __throw_exception_again;
00275 }
00276 }
00277
00278 template <typename _Tp, typename _Alloc>
00279 template <typename _ForwardIterator>
00280 void
00281 deque<_Tp,_Alloc>::
00282 _M_range_initialize(_ForwardIterator __first, _ForwardIterator __last,
00283 forward_iterator_tag)
00284 {
00285 size_type __n = distance(__first, __last);
00286 _M_initialize_map(__n);
00287
00288 _Map_pointer __cur_node;
00289 try
00290 {
00291 for (__cur_node = _M_start._M_node;
00292 __cur_node < _M_finish._M_node;
00293 ++__cur_node)
00294 {
00295 _ForwardIterator __mid = __first;
00296 advance(__mid, _S_buffer_size());
00297 uninitialized_copy(__first, __mid, *__cur_node);
00298 __first = __mid;
00299 }
00300 uninitialized_copy(__first, __last, _M_finish._M_first);
00301 }
00302 catch(...)
00303 {
00304 _Destroy(_M_start, iterator(*__cur_node, __cur_node));
00305 __throw_exception_again;
00306 }
00307 }
00308
00309
00310 template <typename _Tp, typename _Alloc>
00311 void
00312 deque<_Tp,_Alloc>::
00313 _M_push_back_aux(const value_type& __t)
00314 {
00315 value_type __t_copy = __t;
00316 _M_reserve_map_at_back();
00317 *(_M_finish._M_node + 1) = _M_allocate_node();
00318 try
00319 {
00320 _Construct(_M_finish._M_cur, __t_copy);
00321 _M_finish._M_set_node(_M_finish._M_node + 1);
00322 _M_finish._M_cur = _M_finish._M_first;
00323 }
00324 catch(...)
00325 {
00326 _M_deallocate_node(*(_M_finish._M_node + 1));
00327 __throw_exception_again;
00328 }
00329 }
00330
00331 #ifdef _GLIBCPP_DEPRECATED
00332
00333 template <typename _Tp, typename _Alloc>
00334 void
00335 deque<_Tp,_Alloc>::
00336 _M_push_back_aux()
00337 {
00338 _M_reserve_map_at_back();
00339 *(_M_finish._M_node + 1) = _M_allocate_node();
00340 try
00341 {
00342 _Construct(_M_finish._M_cur);
00343 _M_finish._M_set_node(_M_finish._M_node + 1);
00344 _M_finish._M_cur = _M_finish._M_first;
00345 }
00346 catch(...)
00347 {
00348 _M_deallocate_node(*(_M_finish._M_node + 1));
00349 __throw_exception_again;
00350 }
00351 }
00352 #endif
00353
00354
00355 template <typename _Tp, typename _Alloc>
00356 void
00357 deque<_Tp,_Alloc>::
00358 _M_push_front_aux(const value_type& __t)
00359 {
00360 value_type __t_copy = __t;
00361 _M_reserve_map_at_front();
00362 *(_M_start._M_node - 1) = _M_allocate_node();
00363 try
00364 {
00365 _M_start._M_set_node(_M_start._M_node - 1);
00366 _M_start._M_cur = _M_start._M_last - 1;
00367 _Construct(_M_start._M_cur, __t_copy);
00368 }
00369 catch(...)
00370 {
00371 ++_M_start;
00372 _M_deallocate_node(*(_M_start._M_node - 1));
00373 __throw_exception_again;
00374 }
00375 }
00376
00377 #ifdef _GLIBCPP_DEPRECATED
00378
00379 template <typename _Tp, typename _Alloc>
00380 void
00381 deque<_Tp,_Alloc>::
00382 _M_push_front_aux()
00383 {
00384 _M_reserve_map_at_front();
00385 *(_M_start._M_node - 1) = _M_allocate_node();
00386 try
00387 {
00388 _M_start._M_set_node(_M_start._M_node - 1);
00389 _M_start._M_cur = _M_start._M_last - 1;
00390 _Construct(_M_start._M_cur);
00391 }
00392 catch(...)
00393 {
00394 ++_M_start;
00395 _M_deallocate_node(*(_M_start._M_node - 1));
00396 __throw_exception_again;
00397 }
00398 }
00399 #endif
00400
00401
00402 template <typename _Tp, typename _Alloc>
00403 void deque<_Tp,_Alloc>::
00404 _M_pop_back_aux()
00405 {
00406 _M_deallocate_node(_M_finish._M_first);
00407 _M_finish._M_set_node(_M_finish._M_node - 1);
00408 _M_finish._M_cur = _M_finish._M_last - 1;
00409 _Destroy(_M_finish._M_cur);
00410 }
00411
00412
00413
00414
00415
00416 template <typename _Tp, typename _Alloc>
00417 void deque<_Tp,_Alloc>::
00418 _M_pop_front_aux()
00419 {
00420 _Destroy(_M_start._M_cur);
00421 _M_deallocate_node(_M_start._M_first);
00422 _M_start._M_set_node(_M_start._M_node + 1);
00423 _M_start._M_cur = _M_start._M_first;
00424 }
00425
00426 template <typename _Tp, typename _Alloc>
00427 template <typename _InputIterator>
00428 void
00429 deque<_Tp,_Alloc>::
00430 _M_range_insert_aux(iterator __pos,
00431 _InputIterator __first, _InputIterator __last,
00432 input_iterator_tag)
00433 {
00434 copy(__first, __last, inserter(*this, __pos));
00435 }
00436
00437 template <typename _Tp, typename _Alloc>
00438 template <typename _ForwardIterator>
00439 void
00440 deque<_Tp,_Alloc>::
00441 _M_range_insert_aux(iterator __pos,
00442 _ForwardIterator __first, _ForwardIterator __last,
00443 forward_iterator_tag)
00444 {
00445 size_type __n = distance(__first, __last);
00446 if (__pos._M_cur == _M_start._M_cur)
00447 {
00448 iterator __new_start = _M_reserve_elements_at_front(__n);
00449 try
00450 {
00451 uninitialized_copy(__first, __last, __new_start);
00452 _M_start = __new_start;
00453 }
00454 catch(...)
00455 {
00456 _M_destroy_nodes(__new_start._M_node, _M_start._M_node);
00457 __throw_exception_again;
00458 }
00459 }
00460 else if (__pos._M_cur == _M_finish._M_cur)
00461 {
00462 iterator __new_finish = _M_reserve_elements_at_back(__n);
00463 try
00464 {
00465 uninitialized_copy(__first, __last, _M_finish);
00466 _M_finish = __new_finish;
00467 }
00468 catch(...)
00469 {
00470 _M_destroy_nodes(_M_finish._M_node + 1, __new_finish._M_node + 1);
00471 __throw_exception_again;
00472 }
00473 }
00474 else
00475 _M_insert_aux(__pos, __first, __last, __n);
00476 }
00477
00478 template <typename _Tp, typename _Alloc>
00479 typename deque<_Tp, _Alloc>::iterator
00480 deque<_Tp,_Alloc>::
00481 _M_insert_aux(iterator __pos, const value_type& __x)
00482 {
00483 difference_type __index = __pos - _M_start;
00484 value_type __x_copy = __x;
00485 if (static_cast<size_type>(__index) < size() / 2)
00486 {
00487 push_front(front());
00488 iterator __front1 = _M_start;
00489 ++__front1;
00490 iterator __front2 = __front1;
00491 ++__front2;
00492 __pos = _M_start + __index;
00493 iterator __pos1 = __pos;
00494 ++__pos1;
00495 copy(__front2, __pos1, __front1);
00496 }
00497 else
00498 {
00499 push_back(back());
00500 iterator __back1 = _M_finish;
00501 --__back1;
00502 iterator __back2 = __back1;
00503 --__back2;
00504 __pos = _M_start + __index;
00505 copy_backward(__pos, __back2, __back1);
00506 }
00507 *__pos = __x_copy;
00508 return __pos;
00509 }
00510
00511 #ifdef _GLIBCPP_DEPRECATED
00512
00513
00514
00515
00516 template <typename _Tp, typename _Alloc>
00517 typename deque<_Tp,_Alloc>::iterator
00518 deque<_Tp,_Alloc>::
00519 _M_insert_aux(iterator __pos)
00520 {
00521 difference_type __index = __pos - _M_start;
00522 if (static_cast<size_type>(__index) < size() / 2)
00523 {
00524 push_front(front());
00525 iterator __front1 = _M_start;
00526 ++__front1;
00527 iterator __front2 = __front1;
00528 ++__front2;
00529 __pos = _M_start + __index;
00530 iterator __pos1 = __pos;
00531 ++__pos1;
00532 copy(__front2, __pos1, __front1);
00533 }
00534 else
00535 {
00536 push_back(back());
00537 iterator __back1 = _M_finish;
00538 --__back1;
00539 iterator __back2 = __back1;
00540 --__back2;
00541 __pos = _M_start + __index;
00542 copy_backward(__pos, __back2, __back1);
00543 }
00544 *__pos = value_type();
00545 return __pos;
00546 }
00547 #endif
00548
00549 template <typename _Tp, typename _Alloc>
00550 void
00551 deque<_Tp,_Alloc>::
00552 _M_insert_aux(iterator __pos, size_type __n, const value_type& __x)
00553 {
00554 const difference_type __elems_before = __pos - _M_start;
00555 size_type __length = this->size();
00556 value_type __x_copy = __x;
00557 if (__elems_before < difference_type(__length / 2))
00558 {
00559 iterator __new_start = _M_reserve_elements_at_front(__n);
00560 iterator __old_start = _M_start;
00561 __pos = _M_start + __elems_before;
00562 try
00563 {
00564 if (__elems_before >= difference_type(__n))
00565 {
00566 iterator __start_n = _M_start + difference_type(__n);
00567 uninitialized_copy(_M_start, __start_n, __new_start);
00568 _M_start = __new_start;
00569 copy(__start_n, __pos, __old_start);
00570 fill(__pos - difference_type(__n), __pos, __x_copy);
00571 }
00572 else
00573 {
00574 __uninitialized_copy_fill(_M_start, __pos, __new_start,
00575 _M_start, __x_copy);
00576 _M_start = __new_start;
00577 fill(__old_start, __pos, __x_copy);
00578 }
00579 }
00580 catch(...)
00581 {
00582 _M_destroy_nodes(__new_start._M_node, _M_start._M_node);
00583 __throw_exception_again;
00584 }
00585 }
00586 else
00587 {
00588 iterator __new_finish = _M_reserve_elements_at_back(__n);
00589 iterator __old_finish = _M_finish;
00590 const difference_type __elems_after =
00591 difference_type(__length) - __elems_before;
00592 __pos = _M_finish - __elems_after;
00593 try
00594 {
00595 if (__elems_after > difference_type(__n))
00596 {
00597 iterator __finish_n = _M_finish - difference_type(__n);
00598 uninitialized_copy(__finish_n, _M_finish, _M_finish);
00599 _M_finish = __new_finish;
00600 copy_backward(__pos, __finish_n, __old_finish);
00601 fill(__pos, __pos + difference_type(__n), __x_copy);
00602 }
00603 else
00604 {
00605 __uninitialized_fill_copy(_M_finish, __pos + difference_type(__n),
00606 __x_copy, __pos, _M_finish);
00607 _M_finish = __new_finish;
00608 fill(__pos, __old_finish, __x_copy);
00609 }
00610 }
00611 catch(...)
00612 {
00613 _M_destroy_nodes(_M_finish._M_node + 1, __new_finish._M_node + 1);
00614 __throw_exception_again;
00615 }
00616 }
00617 }
00618
00619 template <typename _Tp, typename _Alloc>
00620 template <typename _ForwardIterator>
00621 void
00622 deque<_Tp,_Alloc>::
00623 _M_insert_aux(iterator __pos,
00624 _ForwardIterator __first, _ForwardIterator __last,
00625 size_type __n)
00626 {
00627 const difference_type __elemsbefore = __pos - _M_start;
00628 size_type __length = size();
00629 if (static_cast<size_type>(__elemsbefore) < __length / 2)
00630 {
00631 iterator __new_start = _M_reserve_elements_at_front(__n);
00632 iterator __old_start = _M_start;
00633 __pos = _M_start + __elemsbefore;
00634 try
00635 {
00636 if (__elemsbefore >= difference_type(__n))
00637 {
00638 iterator __start_n = _M_start + difference_type(__n);
00639 uninitialized_copy(_M_start, __start_n, __new_start);
00640 _M_start = __new_start;
00641 copy(__start_n, __pos, __old_start);
00642 copy(__first, __last, __pos - difference_type(__n));
00643 }
00644 else
00645 {
00646 _ForwardIterator __mid = __first;
00647 advance(__mid, difference_type(__n) - __elemsbefore);
00648 __uninitialized_copy_copy(_M_start, __pos, __first, __mid,
00649 __new_start);
00650 _M_start = __new_start;
00651 copy(__mid, __last, __old_start);
00652 }
00653 }
00654 catch(...)
00655 {
00656 _M_destroy_nodes(__new_start._M_node, _M_start._M_node);
00657 __throw_exception_again;
00658 }
00659 }
00660 else
00661 {
00662 iterator __new_finish = _M_reserve_elements_at_back(__n);
00663 iterator __old_finish = _M_finish;
00664 const difference_type __elemsafter =
00665 difference_type(__length) - __elemsbefore;
00666 __pos = _M_finish - __elemsafter;
00667 try
00668 {
00669 if (__elemsafter > difference_type(__n))
00670 {
00671 iterator __finish_n = _M_finish - difference_type(__n);
00672 uninitialized_copy(__finish_n, _M_finish, _M_finish);
00673 _M_finish = __new_finish;
00674 copy_backward(__pos, __finish_n, __old_finish);
00675 copy(__first, __last, __pos);
00676 }
00677 else
00678 {
00679 _ForwardIterator __mid = __first;
00680 advance(__mid, __elemsafter);
00681 __uninitialized_copy_copy(__mid, __last, __pos,
00682 _M_finish, _M_finish);
00683 _M_finish = __new_finish;
00684 copy(__first, __mid, __pos);
00685 }
00686 }
00687 catch(...)
00688 {
00689 _M_destroy_nodes(_M_finish._M_node + 1, __new_finish._M_node + 1);
00690 __throw_exception_again;
00691 }
00692 }
00693 }
00694
00695 template <typename _Tp, typename _Alloc>
00696 void
00697 deque<_Tp,_Alloc>::
00698 _M_new_elements_at_front(size_type __new_elems)
00699 {
00700 size_type __new_nodes
00701 = (__new_elems + _S_buffer_size() - 1) / _S_buffer_size();
00702 _M_reserve_map_at_front(__new_nodes);
00703 size_type __i;
00704 try
00705 {
00706 for (__i = 1; __i <= __new_nodes; ++__i)
00707 *(_M_start._M_node - __i) = _M_allocate_node();
00708 }
00709 catch(...)
00710 {
00711 for (size_type __j = 1; __j < __i; ++__j)
00712 _M_deallocate_node(*(_M_start._M_node - __j));
00713 __throw_exception_again;
00714 }
00715 }
00716
00717 template <typename _Tp, typename _Alloc>
00718 void
00719 deque<_Tp,_Alloc>::
00720 _M_new_elements_at_back(size_type __new_elems)
00721 {
00722 size_type __new_nodes
00723 = (__new_elems + _S_buffer_size() - 1) / _S_buffer_size();
00724 _M_reserve_map_at_back(__new_nodes);
00725 size_type __i;
00726 try
00727 {
00728 for (__i = 1; __i <= __new_nodes; ++__i)
00729 *(_M_finish._M_node + __i) = _M_allocate_node();
00730 }
00731 catch(...)
00732 {
00733 for (size_type __j = 1; __j < __i; ++__j)
00734 _M_deallocate_node(*(_M_finish._M_node + __j));
00735 __throw_exception_again;
00736 }
00737 }
00738
00739 template <typename _Tp, typename _Alloc>
00740 void
00741 deque<_Tp,_Alloc>::
00742 _M_reallocate_map(size_type __nodes_to_add, bool __add_at_front)
00743 {
00744 size_type __old_num_nodes = _M_finish._M_node - _M_start._M_node + 1;
00745 size_type __new_num_nodes = __old_num_nodes + __nodes_to_add;
00746
00747 _Map_pointer __new_nstart;
00748 if (_M_map_size > 2 * __new_num_nodes)
00749 {
00750 __new_nstart = _M_map + (_M_map_size - __new_num_nodes) / 2
00751 + (__add_at_front ? __nodes_to_add : 0);
00752 if (__new_nstart < _M_start._M_node)
00753 copy(_M_start._M_node, _M_finish._M_node + 1, __new_nstart);
00754 else
00755 copy_backward(_M_start._M_node, _M_finish._M_node + 1,
00756 __new_nstart + __old_num_nodes);
00757 }
00758 else
00759 {
00760 size_type __new_map_size =
00761 _M_map_size + max(_M_map_size, __nodes_to_add) + 2;
00762
00763 _Map_pointer __new_map = _M_allocate_map(__new_map_size);
00764 __new_nstart = __new_map + (__new_map_size - __new_num_nodes) / 2
00765 + (__add_at_front ? __nodes_to_add : 0);
00766 copy(_M_start._M_node, _M_finish._M_node + 1, __new_nstart);
00767 _M_deallocate_map(_M_map, _M_map_size);
00768
00769 _M_map = __new_map;
00770 _M_map_size = __new_map_size;
00771 }
00772
00773 _M_start._M_set_node(__new_nstart);
00774 _M_finish._M_set_node(__new_nstart + __old_num_nodes - 1);
00775 }
00776 }
00777
00778 #endif
00779