#define VT_TPL	template <class T, class Allocator>
#define VT		vector<T, Allocator>

namespace ft {



/*********************************************
 * COPLIENS
 *********************************************/
// constructors ------------------------------
VT_TPL VT::
	vector( const Allocator & alloc )
	: _size(0)
	, _capacity(0)
	, _mem_ptr(NULL)
	, _allocator(alloc) {

	return;
}
VT_TPL VT::
	vector( size_type n, const T & val, const Allocator & alloc )
	: _size(0)
	, _capacity(0)
	, _mem_ptr(NULL)
	, _allocator(alloc) {

	assign(n, val);
	return;
}
VT_TPL template <class InputIterator> VT::
	vector(InputIterator first, InputIterator last, const Allocator & alloc)
	: _size(0)
	, _capacity(0)
	, _mem_ptr(NULL)
	, _allocator(alloc) {

	assign(first, last);
	return;
}
// copy constructor --------------------------
VT_TPL VT::
	vector( vector const & src )
	: _size(0)
	, _capacity(0)
	, _mem_ptr(NULL)
	, _allocator(src._allocator) {

	*this = src;
	return;
}
// destructors -------------------------------
VT_TPL VT::
	~vector() {

	clear();
	_allocator.deallocate(_mem_ptr, _capacity);
	return;
}
// operator= ---------------------------------
VT_TPL VT & VT::
	operator=( vector const & rhs ) {

	vector	new_vector;

	//Base::operator=(rhs);
	if ( this != &rhs )
	{
		new_vector.reserve(_capacity);
		new_vector.assign(rhs.begin(), rhs.end());
		swap(new_vector);
		//_size = rhs.size();
	}
	return *this;
}



/*************
 * iterators :
 *************/
// begin -------------------------------------
VT_TPL typename VT::iterator VT::
	begin() { return _mem_ptr; }
VT_TPL typename VT::const_iterator VT::
	begin() const { return _mem_ptr; }
// end ---------------------------------------
VT_TPL typename VT::iterator VT::
	end() { return &_mem_ptr[_size]; }
VT_TPL typename VT::const_iterator VT::
	end() const { return &_mem_ptr[_size]; }
// rbegin ------------------------------------
VT_TPL typename VT::reverse_iterator VT::
	rbegin() { return reverse_iterator(end()); }
VT_TPL typename VT::const_reverse_iterator VT::
	rbegin() const { return const_reverse_iterator(end()); }
// rend --------------------------------------
VT_TPL typename VT::reverse_iterator VT::
	rend() { return reverse_iterator(begin()); }
VT_TPL typename VT::const_reverse_iterator VT::
	rend() const { return const_reverse_iterator(begin()); }



/************
 * capacity :
 ************/
// size --------------------------------------
VT_TPL typename VT::size_type VT::
	size( ) const { return _size; }
// max_size ----------------------------------
VT_TPL typename VT::size_type VT::
	max_size() const { return (_allocator.max_size()); }
// resize ------------------------------------
VT_TPL void VT::
	resize(size_type n, value_type val) {

	if (n > _size)
	{
		if (n > _capacity)
			_increment_capacity(n);
		while (_size != n)
		{
			_allocator.construct(&_mem_ptr[_size], val);
			++_size;
		}
	}
	else if (n < _size)
	{
		while (_size != n)
			_allocator.destroy(&_mem_ptr[--_size]);
	}
}
// capacity ----------------------------------
VT_TPL typename VT::size_type VT::
	capacity() const { return _capacity; }
// empty -------------------------------------
VT_TPL bool VT::
	empty() const { return (_size == 0); }
// reserve -----------------------------------
VT_TPL void VT::
	reserve( size_type new_cap ) {

	value_type *	tmp_ptr;
	value_type *	old_ptr = _mem_ptr;
	iterator		first = begin();
	iterator		last = end();

	if (new_cap > _allocator.max_size())
		throw std::length_error("reserve: new_cap > max_size");
	if (_capacity == _allocator.max_size())
		throw std::length_error("reserve: capacity == max_size");
	if (new_cap <= _capacity)
		return ;

	_capacity = new_cap;
	tmp_ptr = _allocator.allocate(new_cap);

	_mem_ptr = tmp_ptr;
	if (old_ptr)
	{
		_size = 0;
		assign(first, last);
		_destroy(begin(), end());
		_allocator.deallocate(old_ptr, _capacity);
	}
}



/******************
 * element access :
 ******************/
// operator[] --------------------------------
VT_TPL typename VT::reference VT::
	operator[](size_type n) { return _mem_ptr[n]; }
VT_TPL typename VT::const_reference VT::
	operator[](size_type n) const { return _mem_ptr[n]; }
// at ----------------------------------------
VT_TPL typename VT::reference VT::
	at(size_type n) {

	if (n >= _size)
		throw std::out_of_range("vector out of range");
	return (_mem_ptr[n]);
}
VT_TPL typename VT::const_reference VT::
	at(size_type n) const {

	if (n >= _size)
		throw std::out_of_range("vector out of range");
	return (_mem_ptr[n]);
}
// front -------------------------------------
VT_TPL typename VT::reference VT::
	front() { return (*_mem_ptr); }
VT_TPL typename VT::const_reference VT::
	front() const { return (*_mem_ptr); }
// back --------------------------------------
VT_TPL typename VT::reference VT::
	back() { return (_mem_ptr[_size - 1]); }
VT_TPL typename VT::const_reference VT::
	back() const { return (_mem_ptr[_size - 1]); }



/*************
 * modifiers :
 *************/
// assign ------------------------------------
VT_TPL template <class InputIterator>
typename enable_if< !is_integral<InputIterator>::value,void >::type VT::
	assign( InputIterator first, InputIterator last) {

	InputIterator	tmp = first;
	unsigned int	range = 0;

	clear();

	while (tmp++ != last)
		range++;
	if (range >= _capacity)
		_increment_capacity(range);
	while (first != last)
	{
		_allocator.construct(&_mem_ptr[_size], *first);
		first++;
		_size++;
	}
}
VT_TPL void VT::
	assign( size_type n, const T & val ) {

	if (n > _allocator.max_size())
		throw std::length_error("assign: n > max_size");
	
	value_type *	tmp_ptr;

	_destroy(begin(), end());
	if (n > _capacity)
	{
		_capacity = n;
		tmp_ptr = _allocator.allocate(n);
		if (_mem_ptr)
			_allocator.deallocate(_mem_ptr, _capacity);
		_mem_ptr = tmp_ptr;
	}
	_size = n;
	while (n)
		_allocator.construct(&_mem_ptr[--n], val);
}
// push_back ---------------------------------
VT_TPL void VT::
	push_back( const value_type & element ) {

	if (_size >= _capacity)
		_increment_capacity(1);
	_allocator.construct(&_mem_ptr[_size], element);
	_size++;
}
// pop_back ----------------------------------
VT_TPL void VT::
	pop_back() { _allocator.destroy(end() - 1); _size--; }
// insert ------------------------------------
VT_TPL typename VT::iterator VT::
	insert(iterator position, const value_type& val) {

	difference_type	distance;
	iterator		it;

	if (_size + 1 > _capacity)
	{
		distance = position - begin();
		_increment_capacity(1);
		position = begin() + distance;
	}
	it = end();
	if (position != it)
	{   
		_allocator.construct(it, *(it - 1));
		while (it-- != position)
			*(it + 1) = *it;
		_allocator.destroy(position);
	}
	_allocator.construct(position, val);
	_size++;
	return (position);
}
VT_TPL void VT::
	insert(iterator position, size_type n, const value_type& val) {

	difference_type	distance;
	iterator		it_end;
	iterator		it;

	if (_size + n > _capacity)
	{
		distance = position - begin();
		_increment_capacity(n);
		position = begin() + distance;
	}

	it_end = end();
	if (position != it_end)
	{
		it = it_end;
		while (it + n != it_end && it != position)
		{
			it--;
			_allocator.construct(it + n, *it);
		}
		while (it != position)
		{
			it--;
			*(it + n) = *it;
		}
		_destroy(position, std::min(position + n, it_end));
	}

	for (size_type i = 0; i < n; i++, position++)
		_allocator.construct(position, val);
	_size += n;
}
VT_TPL template <class InputIterator>
typename enable_if< !is_integral<InputIterator>::value,void >::type VT::
	insert(iterator position, InputIterator first, InputIterator last) {

	difference_type	dist;
	difference_type	n;
	iterator		it_end;
	iterator		it;

	n = std::distance(first, last);
	if (_size + n > _capacity)
	{
		dist = position - begin();
		_increment_capacity(n);
		position = begin() + dist;
	}

	it_end = end();
	if (position != it_end)
	{
		it = it_end;
		while (it + n != it_end && it != position)
		{
			it--;
			_allocator.construct(it + n, *it);
		}
		while (it != position)
		{
			it--;
			*(it + n) = *it;
		}
		_destroy(position, std::min(position + n, it_end));
	}

	while (first != last)
	{
		_allocator.construct(position, *first);
		++position;
		++first;
	}

	_size += n;
}
// erase -------------------------------------
VT_TPL typename VT::iterator VT::
	erase(iterator position) {

	iterator	i = position;
	iterator	it_end = end() - 1;

	while (i != it_end)
	{   
		*i = *(i + 1);
		++i;
	}
	_allocator.destroy(it_end);
	_size -= 1;
	return (position);
}
VT_TPL typename VT::iterator VT::
	erase(iterator first, iterator last) {

	iterator		it_end = end();
	difference_type	diff = std::distance(first, last);

	if (diff <= 0)
		return (first);

	it_end = end();
	while (last != it_end)
	{
		*first = *last;
		first++;
		last++;
	}
	_destroy(it_end - diff, it_end);
	_size -= diff;

	return (first);
}
// swap --------------------------------------
VT_TPL void VT::
	swap(vector& x) {

	T*			tmp_mem_ptr;
	size_type	tmp_size;
	size_type	tmp_capacity;

	tmp_mem_ptr = x._mem_ptr;
	tmp_size = x._size;
	tmp_capacity = x._capacity;

	x._mem_ptr = _mem_ptr;
	x._size = _size;
	x._capacity = _capacity;

	_mem_ptr = tmp_mem_ptr;
	_size = tmp_size;
	_capacity = tmp_capacity;
}
// clear -------------------------------------
VT_TPL void VT::
	clear() { _destroy(begin(), end()); _size = 0; }



/*************
 * allocator :
 *************/
// get_allocator -----------------------------
VT_TPL typename VT::allocator_type VT::
	get_allocator() const { return (_allocator); }



/*********************************************
 * PRIVATE MEMBER FUNCTIONS
 *********************************************/
VT_TPL void VT::
	_destroy(iterator first, iterator last) {

	while (first != last)
	{
		_allocator.destroy(first);
		first++;
	}
}
VT_TPL void VT::
	_increment_capacity(size_type n) {

	size_type res;

	res = std::max(_size * 2, n);
	reserve(std::min(res, _allocator.max_size()));
}



/*********************************************
 * NESTED CLASS
 *********************************************/
//void	vector::Class::function() {}



/*********************************************
 * STATICS
 *********************************************/
//std::string const	vector::_bar = "bar";



/************************
 * non-member functions :
 ************************/
// operator == -------------------------------
VT_TPL
	bool operator== (const VT & lhs, const VT & rhs) {

	if (lhs.size() != rhs.size())
		return false;
	return ft::equal(lhs.begin(), lhs.end(), rhs.begin());
}
// operator < --------------------------------
VT_TPL
	bool operator<  (const VT & lhs, const VT & rhs) {

	return ft::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end());
}
// operator != -------------------------------
VT_TPL
	bool operator!= (const VT & lhs, const VT & rhs) { return !(lhs == rhs); }
// operator <= -------------------------------
VT_TPL
	bool operator<= (const VT & lhs, const VT & rhs) { return !(lhs > rhs); }
// operator > --------------------------------
VT_TPL
	bool operator>  (const VT & lhs, const VT & rhs) { return (rhs < lhs); }
// operator >= -------------------------------
VT_TPL
	bool operator>= (const VT & lhs, const VT & rhs) { return !(lhs < rhs); }
// swap (vector) -------------------------------
VT_TPL
	void	swap (VT & lhs, VT & rhs) { lhs.swap(rhs); }

} // namespace ft

#undef VT
#undef VT_TPL
























































/////////////////////////////////////////////////////////////////:



/////////////////////////////////////////////////////////////////:








///////////////////////////////////////////////////////////////////





/////////////////////////////////////////////////////////////////:








//////////////////////////////////////////////////////:





/////////////////////////////////////////////////////////////:





///////////////////////////////////////////////////////////




// #define VT_TPL	template <class T, class Allocator>
// #define VT		vector<T, Allocator>
// 
// namespace ft {
// 
// 
// 
// /*********************************************
//  * COPLIENS
//  *********************************************/
// // constructors ------------------------------
// VT_TPL VT::
// 	vector( const Allocator & alloc )
// 	: _size(0)
// 	, _capacity(0)
// 	, _mem_ptr(NULL)
// 	, _allocator(alloc) {
// 
// 	return;
// }
// VT_TPL VT::
// 	vector( size_type n, const T & val, const Allocator & alloc )
// 	: _size(0)
// 	, _capacity(0)
// 	, _mem_ptr(NULL)
// 	, _allocator(alloc) {
// 
// 	assign(n, val);
// 	return;
// }
// VT_TPL template <class InputIterator> VT::
// 	vector(InputIterator first, InputIterator last, const Allocator & alloc)
// 	: _size(0)
// 	, _capacity(0)
// 	, _mem_ptr(NULL)
// 	, _allocator(alloc) {
// 
// 	assign(first, last);
// 	return;
// }
// // copy constructor --------------------------
// VT_TPL VT::
// 	vector( vector const & src )
// 	: _size(0)
// 	, _capacity(0)
// 	, _mem_ptr(NULL)
// 	, _allocator(src._allocator) {
// 
// 	*this = src;
// 	return;
// }
// // destructors -------------------------------
// VT_TPL VT::
// 	~vector() { return; }
// // operator= ---------------------------------
// VT_TPL VT & VT::
// 	operator=( vector const & rhs ) {
// 
// 	vector	new_vector;
// 
// 	//Base::operator=(rhs);
// 	if ( this != &rhs )
// 	{
// 		new_vector.reserve(_capacity);
// 		new_vector.assign(rhs.begin(), rhs.end());
// 		swap(new_vector);
// 		//_size = rhs.size();
// 	}
// 	return *this;
// }
// 
// 
// 
// /*************
//  * iterators :
//  *************/
// // begin -------------------------------------
// VT_TPL typename VT::iterator VT::
// 	begin() { return _mem_ptr; }
// VT_TPL typename VT::const_iterator VT::
// 	begin() const { return _mem_ptr; }
// // end ---------------------------------------
// VT_TPL typename VT::iterator VT::
// 	end() { return &_mem_ptr[_size]; }
// VT_TPL typename VT::const_iterator VT::
// 	end() const { return &_mem_ptr[_size]; }
// // rbegin ------------------------------------
// VT_TPL typename VT::reverse_iterator VT::
// 	rbegin() { return reverse_iterator(end()); }
// VT_TPL typename VT::const_reverse_iterator VT::
// 	rbegin() const { return const_reverse_iterator(end()); }
// // rend --------------------------------------
// VT_TPL typename VT::reverse_iterator VT::
// 	rend() { return reverse_iterator(begin()); }
// VT_TPL typename VT::const_reverse_iterator VT::
// 	rend() const { return const_reverse_iterator(begin()); }
// 
// 
// 
// /************
//  * capacity :
//  ************/
// // size --------------------------------------
// VT_TPL typename VT::size_type VT::
// 	size( ) const { return _size; }
// // max_size ----------------------------------
// VT_TPL typename VT::size_type VT::
// 	max_size() const { return (_allocator.max_size()); }
// // resize ------------------------------------
// VT_TPL void VT::
// 	resize(size_type n, value_type val) {
// 
// 	if (n > _size)
// 	{
// 		if (n > _capacity)
// 			_increment_capacity(n);
// 		while (_size != n)
// 		{
// 			_allocator.construct(&_mem_ptr[_size], val);
// 			++_size;
// 		}
// 	}
// 	else if (n < _size)
// 	{
// 		while (_size != n)
// 			_allocator.destroy(&_mem_ptr[--_size]);
// 	}
// }
// // capacity ----------------------------------
// VT_TPL typename VT::size_type VT::
// 	capacity() const { return _capacity; }
// // empty -------------------------------------
// VT_TPL bool VT::
// 	empty() const { return (_size == 0); }
// // reserve -----------------------------------
// VT_TPL void VT::
// 	reserve( size_type new_cap ) {
// 
// 	T*  new_arr;
// 	T*  old_arr = _mem_ptr;
// 
// 	if (new_cap > max_size())
// 		throw std::length_error("vector::reserve");
// 
// 	if (_capacity >= new_cap)
// 		return ;
// 	new_arr = _allocator.allocate(new_cap);
// 
// 	if (old_arr)
// 	{
// 		iterator first = begin();
// 		iterator last = end();
// 		_mem_ptr = new_arr;
// 		_size = 0;
// 		assign(first, last);
// 		_destroy(first, last);
// 		_allocator.deallocate(old_arr, _capacity);
// 	}
// 	else
// 		_mem_ptr = new_arr;
// 
// 	_capacity = new_cap;
// 
// 
// //	value_type *	tmp_ptr;
// //	value_type *	old_ptr = _mem_ptr;
// //	iterator		first = begin();
// //	iterator		last = end();
// //
// //	if (new_cap > _allocator.max_size())
// //		throw std::length_error("reserve: new_cap > max_size");
// //	if (_capacity == _allocator.max_size())
// //		throw std::length_error("reserve: capacity == max_size");
// //	if (new_cap <= _capacity)
// //		return ;
// //
// //	_capacity = new_cap;
// //	tmp_ptr = _allocator.allocate(new_cap);
// //
// //	if (_mem_ptr)
// //	{
// //		_mem_ptr = tmp_ptr;
// //		_size = 0;
// //		assign(first, last);
// //		_destroy(begin(), end());
// //		_allocator.deallocate(old_ptr, _capacity);
// //	}
// //	_mem_ptr = tmp_ptr;
// }
// 
// 
// 
// /******************
//  * element access :
//  ******************/
// // operator[] --------------------------------
// VT_TPL typename VT::reference VT::
// 	operator[](size_type n) { return _mem_ptr[n]; }
// VT_TPL typename VT::const_reference VT::
// 	operator[](size_type n) const { return _mem_ptr[n]; }
// // at ----------------------------------------
// VT_TPL typename VT::reference VT::
// 	at(size_type n) {
// 
// 	if (n >= _size)
// 		throw std::out_of_range("vector out of range");
// 	return (_mem_ptr[n]);
// }
// VT_TPL typename VT::const_reference VT::
// 	at(size_type n) const {
// 
// 	if (n >= _size)
// 		throw std::out_of_range("vector out of range");
// 	return (_mem_ptr[n]);
// }
// // front -------------------------------------
// VT_TPL typename VT::reference VT::
// 	front() { return (*_mem_ptr); }
// VT_TPL typename VT::const_reference VT::
// 	front() const { return (*_mem_ptr); }
// // back --------------------------------------
// VT_TPL typename VT::reference VT::
// 	back() { return (_mem_ptr[_size - 1]); }
// VT_TPL typename VT::const_reference VT::
// 	back() const { return (_mem_ptr[_size - 1]); }
// 
// 
// 
// /*************
//  * modifiers :
//  *************/
// // assign ------------------------------------
// VT_TPL template <class InputIterator>
// typename enable_if< !is_integral<InputIterator>::value,void >::type VT::
// 	assign( InputIterator first, InputIterator last) {
// 
// 	_assign(first, last, typename iterator_traits<InputIterator>::iterator_category());
// 
// //	InputIterator	tmp = first;
// //	unsigned int	range = 0;
// //
// //	clear();
// //
// //	while (tmp++ != last)
// //		range++;
// //	if (range >= _capacity)
// //		_increment_capacity(range);
// //	while (first != last)
// //	{
// //		_allocator.construct(&_mem_ptr[_size], *first);
// //		first++;
// //		_size++;
// //	}
// }
// VT_TPL
// template < typename InputIt >
// void    VT::
// _assign(InputIt first, InputIt last, std::input_iterator_tag)
// {   
// 	clear();
// 
// 	while (first != last)
// 	{   
// 		if (_size + 1 > _capacity)
// 			_increment_capacity(_size + 1);
// 		_allocator.construct(&_mem_ptr[_size], *first);
// 		++first;
// 		++_size;
// 	}
// }
// VT_TPL
// template < typename ForwardIt >
// void    VT::
// _assign(ForwardIt first, ForwardIt last, std::forward_iterator_tag)
// {
// 	clear();
// 
// 	difference_type diff = std::distance(first, last);
// 	if (diff < 0)
// 		throw std::logic_error("Wrong iterator order");
// 
// 	if (static_cast<size_type>(diff) > _capacity)
// 		_increment_capacity(diff);
// 
// 	while (first != last)
// 	{
// 		_allocator.construct(&_mem_ptr[_size], *first);
// 		++first;
// 		++_size;
// 	}
// }
// 
// 
// VT_TPL void VT::
// 	assign( size_type n, const T & val ) {
// 
// 	if (n > _allocator.max_size())
// 		throw std::length_error("assign: n > max_size");
// 	
// 	value_type *	tmp_ptr;
// 
// 	_destroy(begin(), end());
// 	if (n > _capacity)
// 	{
// 		_capacity = n;
// 		tmp_ptr = _allocator.allocate(n);
// 		if (_mem_ptr)
// 			_allocator.deallocate(_mem_ptr, _capacity);
// 		_mem_ptr = tmp_ptr;
// 	}
// 	_size = n;
// 	while (n)
// 		_allocator.construct(&_mem_ptr[--n], val);
// }
// // push_back ---------------------------------
// VT_TPL void VT::
// 	push_back( const value_type & element ) {
// 
// 	if (_size >= _capacity)
// 		_increment_capacity(1);
// 	_allocator.construct(&_mem_ptr[_size], element);
// 	_size++;
// }
// // pop_back ----------------------------------
// VT_TPL void VT::
// 	pop_back() { _allocator.destroy(end() - 1); _size--; }
// // insert ------------------------------------
// VT_TPL typename VT::iterator VT::
// 	insert(iterator pos, const value_type& value) {
// //	insert(iterator position, const value_type& val) {
// 
// 	if (_size + 1 > _capacity)
// 	{
// 		difference_type offset = pos - begin();
// 		_increment_capacity(_size + 1);
// 		pos = begin() + offset;
// 	}
// 
// 	iterator it_end = end();
// 	if (pos != it_end)
// 	{
// 		iterator i = it_end;
// 		--i;
// 		_allocator.construct(i + 1, *i);
// 		while (i != pos)
// 		{
// 			--i;
// 			*(i + 1) = *i;
// 		}
// 		_allocator.destroy(pos);
// 	}
// 	_allocator.construct(pos, value);
// 	_size += 1;
// 	return (pos);
// 
// 
// 
// //	difference_type	distance;
// //	iterator		it;
// //
// //	if (_size + 1 > _capacity)
// //	{
// //		distance = position - begin();
// //		_increment_capacity(1);
// //		position = begin() + distance;
// //	}
// //	it = end();
// //	if (position != it)
// //	{   
// //		_allocator.construct(it, *(it - 1));
// //		while (it-- != position)
// //			*(it + 1) = *it;
// //	}
// //	_allocator.destroy(position);
// //	_allocator.construct(position, val);
// //	_size++;
// //	return (position);
// }
// VT_TPL void VT::
// 	insert(iterator pos, size_type count, const value_type& value) {
// //	insert(iterator position, size_type n, const value_type& val) {
// 
// 	if (_size + count > _capacity)
// 	{
// 		difference_type offset = pos - begin();
// //		_auto_realloc(_size + count);
// 		_increment_capacity(count);
// 		pos = begin() + offset;
// 	}
// 
// 	iterator it_end = end();
// 	if (pos != it_end)
// 	{
// 		iterator i = it_end;
// 		while (i + count != it_end && i != pos)
// 		{
// 			--i;
// 			_allocator.construct(i + count, *i);
// 		}
// 		while (i != pos)
// 		{
// 			--i;
// 			*(i + count) = *i;
// 		}
// 	//	_destroy_objects(pos, std::min(pos + count, it_end));
// 		_destroy(pos, std::min(pos + count, it_end));
// 	}
// 
// 	iterator last = pos + count;
// 	while (pos != last)
// 	{
// 		_allocator.construct(pos, value);
// 		++pos;
// 	}
// 	_size += count;
// 
// //	difference_type	distance;
// //	iterator		it_end;
// //	iterator		it;
// //
// //	if (_size + n > _capacity)
// //	{
// //		distance = position - begin();
// //		_increment_capacity(n);
// //		position = begin() + distance;
// //	}
// //
// //	it_end = end();
// //	if (position != it_end)
// //	{
// //		it = it_end;
// //		while (it + n != it_end && it != position)
// //		{
// //			it--;
// //			_allocator.construct(it + n, *it);
// //		}
// //		while (it != position)
// //		{
// //			it--;
// //			*(it + n) = *it;
// //		}
// //		_destroy(position, std::min(position + n, it_end));
// //	}
// //
// //	for (size_type i = 0; i < n; i++, position++)
// //		_allocator.construct(position, val);
// //	_size += n;
// }
// VT_TPL template <class InputIterator>
// typename enable_if< !is_integral<InputIterator>::value,void >::type VT::
// 	insert(iterator position, InputIterator first, InputIterator last) {
// 
// 	difference_type	dist;
// 	difference_type	n;
// 	iterator		it_end;
// 	iterator		it;
// 
// 	n = std::distance(first, last);
// 	if (_size + n > _capacity)
// 	{
// 		dist = position - begin();
// 		_increment_capacity(n);
// 		position = begin() + dist;
// 	}
// 
// 	it_end = end();
// 	if (position != it_end)
// 	{
// 		it = it_end;
// 		while (it + n != it_end && it != position)
// 		{
// 			it--;
// 			_allocator.construct(it + n, *it);
// 		}
// 		while (it != position)
// 		{
// 			it--;
// 			*(it + n) = *it;
// 		}
// 		_destroy(position, std::min(position + n, it_end));
// 	}
// 
// 	while (first != last)
// 	{
// 		_allocator.construct(position, *first);
// 		++position;
// 		++first;
// 	}
// 
// 	_size += n;
// }
// // erase -------------------------------------
// VT_TPL typename VT::iterator VT::
// 	erase(iterator position) {
// 
// 	iterator	i = position;
// 	iterator	it_end = end() - 1;
// 
// 	while (i != it_end)
// 	{   
// 		*i = *(i + 1);
// 		++i;
// 	}
// 	_allocator.destroy(it_end);
// 	_size -= 1;
// 	return (position);
// }
// VT_TPL typename VT::iterator VT::
// 	erase(iterator first, iterator last) {
// 
// 	iterator		it_end = end();
// 	difference_type	diff = std::distance(first, last);
// 
// 	if (diff <= 0)
// 		return (first);
// 
// 	it_end = end();
// 	while (last != it_end)
// 	{
// 		*first = *last;
// 		first++;
// 		last++;
// 	}
// 	_destroy(it_end - diff, it_end);
// 	_size -= diff;
// 
// 	return (first);
// }
// // swap --------------------------------------
// VT_TPL void VT::
// 	swap(vector& x) {
// 
// 	T*			tmp_mem_ptr;
// 	size_type	tmp_size;
// 	size_type	tmp_capacity;
// 
// 	tmp_mem_ptr = x._mem_ptr;
// 	tmp_size = x._size;
// 	tmp_capacity = x._capacity;
// 
// 	x._mem_ptr = _mem_ptr;
// 	x._size = _size;
// 	x._capacity = _capacity;
// 
// 	_mem_ptr = tmp_mem_ptr;
// 	_size = tmp_size;
// 	_capacity = tmp_capacity;
// }
// // clear -------------------------------------
// VT_TPL void VT::
// 	clear() { _destroy(begin(), end()); _size = 0; }
// 
// 
// 
// /*************
//  * allocator :
//  *************/
// // get_allocator -----------------------------
// VT_TPL typename VT::allocator_type VT::
// 	get_allocator() const { return (_allocator); }
// 
// 
// 
// /*********************************************
//  * PRIVATE MEMBER FUNCTIONS
//  *********************************************/
// VT_TPL void VT::
// 	_destroy(iterator first, iterator last) {
// 
// 	while (first != last)
// 	{
// 		_allocator.destroy(first);
// 		first++;
// 	}
// }
// VT_TPL void VT::
// 	_increment_capacity(size_type min_new_cap) {
// //	_increment_capacity(size_type n) {
// 
// 	size_type   new_cap;
// 
// 	if (_capacity == max_size())
// 		throw std::length_error("vector::reserve");
// 	new_cap = std::min(max_size() / 2, _size) * 2;
// 	new_cap = std::max(new_cap, min_new_cap);
// 	reserve(new_cap);
// 
// 
// //	size_type res;
// //
// //	res = std::max(_size * 2, n);
// //	reserve(std::min(res, _allocator.max_size()));
// }
// 
// 
// 
// /*********************************************
//  * NESTED CLASS
//  *********************************************/
// //void	vector::Class::function() {}
// 
// 
// 
// /*********************************************
//  * STATICS
//  *********************************************/
// //std::string const	vector::_bar = "bar";
// 
// 
// 
// /************************
//  * non-member functions :
//  ************************/
// // operator == -------------------------------
// VT_TPL
// 	bool operator== (const VT & lhs, const VT & rhs) {
// 
// 	if (lhs.size() != rhs.size())
// 		return false;
// 	return ft::equal(lhs.begin(), lhs.end(), rhs.begin());
// }
// // operator < --------------------------------
// VT_TPL
// 	bool operator<  (const VT & lhs, const VT & rhs) {
// 
// 	return ft::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end());
// }
// // operator != -------------------------------
// VT_TPL
// 	bool operator!= (const VT & lhs, const VT & rhs) { return !(lhs == rhs); }
// // operator <= -------------------------------
// VT_TPL
// 	bool operator<= (const VT & lhs, const VT & rhs) { return !(lhs > rhs); }
// // operator > --------------------------------
// VT_TPL
// 	bool operator>  (const VT & lhs, const VT & rhs) { return (rhs < lhs); }
// // operator >= -------------------------------
// VT_TPL
// 	bool operator>= (const VT & lhs, const VT & rhs) { return !(lhs < rhs); }
// // swap (vector) -------------------------------
// VT_TPL
// 	void	swap (VT & lhs, VT & rhs) { lhs.swap(rhs); }
// 
// } // namespace ft
// 
// #undef VT
// #undef VT_TPL
//