===============================================================================
001047d0 <cnd_broadcast>:                                                                 
#include <threads.h>                                                                      
#include <errno.h>                                                                        
                                                                                          
int                                                                                       
cnd_broadcast(cnd_t *cond)                                                                
{                                                                                         
  1047d0:   55                      push   %ebp                                           <== NOT EXECUTED
  1047d1:   89 e5                   mov    %esp,%ebp                                      <== NOT EXECUTED
  1047d3:   83 ec 18                sub    $0x18,%esp                                     <== NOT EXECUTED
                                                                                          
    _Condition_Broadcast(cond);                                                           
  1047d6:   8b 45 08                mov    0x8(%ebp),%eax                                 <== NOT EXECUTED
  1047d9:   89 04 24                mov    %eax,(%esp)                                    <== NOT EXECUTED
  1047dc:   e8 af 1e 00 00          call   106690 <_Condition_Broadcast>                  <== NOT EXECUTED
    return (thrd_success);                                                                
}                                                                                         
  1047e1:   89 ec                   mov    %ebp,%esp                                      
  1047e3:   b8 04 00 00 00          mov    $0x4,%eax                                      
  1047e8:   5d                      pop    %ebp                                           
  1047e9:   c3                      ret                                                   
  1047ea:   90                      nop                                                   
  1047eb:   90                      nop                                                   
  1047ec:   90                      nop                                                   
  1047ed:   90                      nop                                                   
  1047ee:   90                      nop                                                   
  1047ef:   90                      nop                                                   
                                                                                          
===============================================================================
00105400 <mtx_unlock>:                                                                    
    }                                                                                     
}                                                                                         
                                                                                          
int                                                                                       
mtx_unlock(mtx_t *mtx)                                                                    
{                                                                                         
  105400:   55                      push   %ebp                                           <== NOT EXECUTED
  105401:   89 e5                   mov    %esp,%ebp                                      <== NOT EXECUTED
  105403:   83 ec 18                sub    $0x18,%esp                                     <== NOT EXECUTED
                                                                                          
    _Mutex_recursive_Release(mtx);                                                        
  105406:   8b 45 08                mov    0x8(%ebp),%eax                                 <== NOT EXECUTED
  105409:   89 04 24                mov    %eax,(%esp)                                    <== NOT EXECUTED
  10540c:   e8 ff 2f 00 00          call   108410 <_Mutex_recursive_Release>              <== NOT EXECUTED
    return (thrd_success);                                                                
}                                                                                         
  105411:   89 ec                   mov    %ebp,%esp                                      
  105413:   b8 04 00 00 00          mov    $0x4,%eax                                      
  105418:   5d                      pop    %ebp                                           
  105419:   c3                      ret                                                   
  10541a:   90                      nop                                                   
  10541b:   90                      nop                                                   
  10541c:   90                      nop                                                   
  10541d:   90                      nop                                                   
  10541e:   90                      nop                                                   
  10541f:   90                      nop                                                   
                                                                                          
===============================================================================
00104ad0 <thrd_join>:                                                                     
}                                                                                         
                                                                                          
int                                                                                       
thrd_join(thrd_t thr, int *res)                                                           
{                                                                                         
  104ad0:   55                      push   %ebp                                           
  104ad1:   89 e5                   mov    %esp,%ebp                                      
  104ad3:   83 ec 28                sub    $0x28,%esp                                     
  104ad6:   89 5d fc                mov    %ebx,-0x4(%ebp)                                
    void *value_ptr;                                                                      
                                                                                          
    if (pthread_join(thr, &value_ptr) != 0)                                               
  104ad9:   8d 45 f4                lea    -0xc(%ebp),%eax                                
{                                                                                         
  104adc:   8b 5d 0c                mov    0xc(%ebp),%ebx                                 
    if (pthread_join(thr, &value_ptr) != 0)                                               
  104adf:   89 44 24 04             mov    %eax,0x4(%esp)                                 
  104ae3:   8b 45 08                mov    0x8(%ebp),%eax                                 
  104ae6:   89 04 24                mov    %eax,(%esp)                                    
  104ae9:   e8 32 10 00 00          call   105b20 <pthread_join>                          
  104aee:   85 c0                   test   %eax,%eax                                      
  104af0:   75 1e                   jne    104b10 <thrd_join+0x40>                        <== NEVER TAKEN
        return (thrd_error);                                                              
    if (res != NULL)                                                                      
  104af2:   85 db                   test   %ebx,%ebx                                      
  104af4:   74 2a                   je     104b20 <thrd_join+0x50>                        <== NEVER TAKEN
        *res = (intptr_t)value_ptr;                                                       
  104af6:   8b 45 f4                mov    -0xc(%ebp),%eax                                
  104af9:   89 03                   mov    %eax,(%ebx)                                    
    return (thrd_success);                                                                
}                                                                                         
  104afb:   8b 5d fc                mov    -0x4(%ebp),%ebx                                
  104afe:   89 ec                   mov    %ebp,%esp                                      
  104b00:   5d                      pop    %ebp                                           
    return (thrd_success);                                                                
  104b01:   b8 04 00 00 00          mov    $0x4,%eax                                      
}                                                                                         
  104b06:   c3                      ret                                                   
  104b07:   8d b4 26 00 00 00 00    lea    0x0(%esi,%eiz,1),%esi                          
  104b0e:   66 90                   xchg   %ax,%ax                                        
  104b10:   8b 5d fc                mov    -0x4(%ebp),%ebx                                <== NOT EXECUTED
  104b13:   89 ec                   mov    %ebp,%esp                                      <== NOT EXECUTED
        return (thrd_error);                                                              
  104b15:   b8 02 00 00 00          mov    $0x2,%eax                                      <== NOT EXECUTED
}                                                                                         
  104b1a:   5d                      pop    %ebp                                           <== NOT EXECUTED
  104b1b:   c3                      ret                                                   <== NOT EXECUTED
  104b1c:   8d 74 26 00             lea    0x0(%esi,%eiz,1),%esi                          <== NOT EXECUTED
  104b20:   8b 5d fc                mov    -0x4(%ebp),%ebx                                <== NOT EXECUTED
  104b23:   89 ec                   mov    %ebp,%esp                                      <== NOT EXECUTED
    return (thrd_success);                                                                
  104b25:   b8 04 00 00 00          mov    $0x4,%eax                                      <== NOT EXECUTED
}                                                                                         
  104b2a:   5d                      pop    %ebp                                           <== NOT EXECUTED
  104b2b:   c3                      ret                                                   <== NOT EXECUTED
  104b2c:   90                      nop                                                   
  104b2d:   90                      nop                                                   
  104b2e:   90                      nop                                                   
  104b2f:   90                      nop