00401340 <__ZN1AC1EOS_>:
	A(A& arg); 	// copy
	A& operator=(A&& other);
	void modify();
};

A::A(A&& arg): member(std::move(arg.member)) // the expression "arg.member" is lvalue
  401340:	53                   	push   ebx
  401341:	83 ec 28             	sub    esp,0x28
  401344:	8b 5c 24 30          	mov    ebx,DWORD PTR [esp+0x30]
	_CharT*
	_M_clone(const _Alloc&, size_type __res = 0);
      };

      // Use empty-base optimization: http://www.cantrip.org/emptyopt.html
      struct _Alloc_hider : _Alloc
  401348:	8b 03                	mov    eax,DWORD PTR [ebx]
      : _M_dataplus(__str._M_dataplus)
      {
#if _GLIBCXX_FULLY_DYNAMIC_STRING == 0
	__str._M_data(_S_empty_rep()._M_refdata());
#else
	__str._M_data(_S_construct(size_type(), _CharT(), get_allocator()));
  40134a:	c7 44 24 04 00 00 00 	mov    DWORD PTR [esp+0x4],0x0
  401351:	00 
  401352:	c7 04 24 00 00 00 00 	mov    DWORD PTR [esp],0x0
	_CharT*
	_M_clone(const _Alloc&, size_type __res = 0);
      };

      // Use empty-base optimization: http://www.cantrip.org/emptyopt.html
      struct _Alloc_hider : _Alloc
  401359:	89 01                	mov    DWORD PTR [ecx],eax
      : _M_dataplus(__str._M_dataplus)
      {
#if _GLIBCXX_FULLY_DYNAMIC_STRING == 0
	__str._M_data(_S_empty_rep()._M_refdata());
#else
	__str._M_data(_S_construct(size_type(), _CharT(), get_allocator()));
  40135b:	8d 44 24 1f          	lea    eax,[esp+0x1f]
  40135f:	89 44 24 08          	mov    DWORD PTR [esp+0x8],eax
  401363:	e8 a0 01 00 00       	call   401508 <__ZNSs12_S_constructEjcRKSaIcE>
      _M_data() const _GLIBCXX_NOEXCEPT
      { return  _M_dataplus._M_p; }

      _CharT*
      _M_data(_CharT* __p) _GLIBCXX_NOEXCEPT
      { return (_M_dataplus._M_p = __p); }
  401368:	89 03                	mov    DWORD PTR [ebx],eax
{} 
  40136a:	83 c4 28             	add    esp,0x28
  40136d:	5b                   	pop    ebx
  40136e:	c2 04 00             	ret    0x4
  401371:	90                   	nop
  401372:	8d b4 26 00 00 00 00 	lea    esi,[esi+eiz*1+0x0]
  401379:	8d bc 27 00 00 00 00 	lea    edi,[edi+eiz*1+0x0]

00401380 <__ZN1AC1ERS_>:

A::A(A& arg): member(arg.member) // cpy
  401380:	55                   	push   ebp
  401381:	89 e5                	mov    ebp,esp
{} 
  401383:	c9                   	leave  
};

A::A(A&& arg): member(std::move(arg.member)) // the expression "arg.member" is lvalue
{} 

A::A(A& arg): member(arg.member) // cpy
  401384:	e9 87 01 00 00       	jmp    401510 <__ZNSsC1ERKSs>
  401389:	90                   	nop
  40138a:	8d b6 00 00 00 00    	lea    esi,[esi+0x0]

00401390 <__ZN1AaSEOS_>:
{} 

A& A::operator=(A&& other) 
{
  401390:	53                   	push   ebx
  401391:	89 cb                	mov    ebx,ecx
  401393:	83 ec 18             	sub    esp,0x18
      // PR 58265, this should be noexcept.
      basic_string&
      operator=(basic_string&& __str)
      {
	// NB: DR 1204.
	this->swap(__str);
  401396:	8b 44 24 20          	mov    eax,DWORD PTR [esp+0x20]
  40139a:	89 04 24             	mov    DWORD PTR [esp],eax
  40139d:	e8 76 01 00 00       	call   401518 <__ZNSs4swapERSs>
  4013a2:	83 ec 04             	sub    esp,0x4
   	member = std::move(other.member);
   	return *this;
}
  4013a5:	89 d8                	mov    eax,ebx
  4013a7:	83 c4 18             	add    esp,0x18
  4013aa:	5b                   	pop    ebx
  4013ab:	c2 04 00             	ret    0x4
  4013ae:	66 90                	xchg   ax,ax

004013b0 <__ZN1A6modifyEv>:

void A::modify()
{
  4013b0:	83 ec 1c             	sub    esp,0x1c
       */
      basic_string&
      append(const _CharT* __s)
      {
	__glibcxx_requires_string(__s);
	return this->append(__s, traits_type::length(__s));
  4013b3:	c7 44 24 04 01 00 00 	mov    DWORD PTR [esp+0x4],0x1
  4013ba:	00 
  4013bb:	c7 04 24 24 c0 40 00 	mov    DWORD PTR [esp],0x40c024
  4013c2:	e8 59 01 00 00       	call   401520 <__ZNSs6appendEPKcj>
  4013c7:	83 ec 08             	sub    esp,0x8
	member += "1";
}
  4013ca:	83 c4 1c             	add    esp,0x1c
  4013cd:	c3                   	ret    
  4013ce:	66 90                	xchg   ax,ax

004013d0 <__Z11fingingDoryv>:

A* fingingDory()
{
  4013d0:	55                   	push   ebp
  4013d1:	89 e5                	mov    ebp,esp
  4013d3:	83 ec 68             	sub    esp,0x68
  4013d6:	8d 45 f8             	lea    eax,[ebp-0x8]
  4013d9:	89 65 dc             	mov    DWORD PTR [ebp-0x24],esp
  4013dc:	c7 45 cc 00 15 40 00 	mov    DWORD PTR [ebp-0x34],0x401500
  4013e3:	c7 45 d0 14 aa 40 00 	mov    DWORD PTR [ebp-0x30],0x40aa14
  4013ea:	c7 45 d8 b1 14 40 00 	mov    DWORD PTR [ebp-0x28],0x4014b1
  4013f1:	89 45 d4             	mov    DWORD PTR [ebp-0x2c],eax
  4013f4:	8d 45 b4             	lea    eax,[ebp-0x4c]
  4013f7:	89 04 24             	mov    DWORD PTR [esp],eax
  4013fa:	e8 71 0f 00 00       	call   402370 <__Unwind_SjLj_Register>
using namespace std;

class A {
	string member;
public:
	A(): member("Dory"){};
  4013ff:	8d 45 f3             	lea    eax,[ebp-0xd]
  401402:	8d 4d f4             	lea    ecx,[ebp-0xc]
  401405:	c7 04 24 26 c0 40 00 	mov    DWORD PTR [esp],0x40c026
  40140c:	89 44 24 04          	mov    DWORD PTR [esp+0x4],eax
  401410:	c7 45 b8 ff ff ff ff 	mov    DWORD PTR [ebp-0x48],0xffffffff
  401417:	e8 0c 01 00 00       	call   401528 <__ZNSsC1EPKcRKSaIcE>
  40141c:	8d 4d f4             	lea    ecx,[ebp-0xc]
  40141f:	83 ec 08             	sub    esp,0x8
  401422:	c7 44 24 04 01 00 00 	mov    DWORD PTR [esp+0x4],0x1
  401429:	00 
  40142a:	c7 04 24 24 c0 40 00 	mov    DWORD PTR [esp],0x40c024
  401431:	c7 45 b8 01 00 00 00 	mov    DWORD PTR [ebp-0x48],0x1
  401438:	e8 e3 00 00 00       	call   401520 <__ZNSs6appendEPKcj>
  40143d:	83 ec 08             	sub    esp,0x8

A* fingingDory()
{
	A dory; 
	dory.modify();
	A *copydory = new A(dory);
  401440:	c7 04 24 04 00 00 00 	mov    DWORD PTR [esp],0x4
  401447:	e8 e4 00 00 00       	call   401530 <__Znwj>
};

A::A(A&& arg): member(std::move(arg.member)) // the expression "arg.member" is lvalue
{} 

A::A(A& arg): member(arg.member) // cpy
  40144c:	8d 55 f4             	lea    edx,[ebp-0xc]

A* fingingDory()
{
	A dory; 
	dory.modify();
	A *copydory = new A(dory);
  40144f:	89 45 b0             	mov    DWORD PTR [ebp-0x50],eax
};

A::A(A&& arg): member(std::move(arg.member)) // the expression "arg.member" is lvalue
{} 

A::A(A& arg): member(arg.member) // cpy
  401452:	89 c1                	mov    ecx,eax
  401454:	89 14 24             	mov    DWORD PTR [esp],edx
  401457:	c7 45 b8 02 00 00 00 	mov    DWORD PTR [ebp-0x48],0x2
  40145e:	e8 ad 00 00 00       	call   401510 <__ZNSsC1ERKSs>
      // Data Members (private):
      mutable _Alloc_hider	_M_dataplus;

      _CharT*
      _M_data() const _GLIBCXX_NOEXCEPT
      { return  _M_dataplus._M_p; }
  401463:	8b 4d f4             	mov    ecx,DWORD PTR [ebp-0xc]
  401466:	83 ec 04             	sub    esp,0x4
  // __exchange_and_add_dispatch
  // __atomic_add_dispatch
#ifdef _GLIBCXX_ATOMIC_BUILTINS
  static inline _Atomic_word 
  __exchange_and_add(volatile _Atomic_word* __mem, int __val)
  { return __atomic_fetch_add(__mem, __val, __ATOMIC_ACQ_REL); }
  401469:	b8 ff ff ff ff       	mov    eax,0xffffffff
  40146e:	f0 0f c1 41 fc       	lock xadd DWORD PTR [ecx-0x4],eax
	  if (__builtin_expect(this != &_S_empty_rep(), false))
#endif
	    {
	      // Be race-detector-friendly.  For more info see bits/c++config.
	      _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&this->_M_refcount);
	      if (__gnu_cxx::__exchange_and_add_dispatch(&this->_M_refcount,
  401473:	85 c0                	test   eax,eax
  401475:	7e 19                	jle    401490 <__Z11fingingDoryv+0xc0>
  401477:	8d 45 b4             	lea    eax,[ebp-0x4c]
  40147a:	89 04 24             	mov    DWORD PTR [esp],eax
  40147d:	e8 5e 10 00 00       	call   4024e0 <__Unwind_SjLj_Unregister>
{
	A dory; 
	dory.modify();
	A *copydory = new A(dory);
	return 	copydory;
}
  401482:	8b 45 b0             	mov    eax,DWORD PTR [ebp-0x50]
  401485:	c9                   	leave  
  401486:	c3                   	ret