This is true for static and dynamic calls.                              
As each language becomes known to LE, the program mask is set.          
COBOL doesn't set anything.  C sets the decimal overflow and others.    
The program mask is never reset.  The mask is set upon the first        
calling of a routine.  So in your case, the COBOL main doesn't set      
the mask.  That's the rule for COBOL:  don't set the program mask.      
Your COBOL calls C the first time.  The mask is set.  Your C program    
returns to its caller the COBOL main.  The mask is still set.  Suppose  
the COBOL does an ADD which causes an overflow.  Since the program mask 
is on, an ABEND0CA is pending but LE handles it.  LE notices that it    
happened in COBOL and so bypasses the ABEND0CA.  You were,at this point,
led to believe that the program mask was shut off.  Not so.  Now your   
COBOL calls C a second time.  Since it's the second time, no program   
mask setting occurs.  C returns to COBOL.  Now COBOL calls Assembler.  
The assembler causes a decimal overflow.  LE can't handle the          
pending ABEND0CA since the condition happened in assembler.  The 0CA   
progresses and the job aborts.  Perhaps another way to look at         
this is:  as each language becomes known to LE, the mask is set.       
The mask is never cleared not even when a subroutine returns.          
Whenever an overflow occurs, LE sees in which language it occured      
and either ignores the overflow by continuing or honors the overflow   
by aborting.  COBOL ignores, C honors.  Assembler is not handled by    
LE. Asm uses the program mask, whatever it happens to be at the moment.
So you'll need to handle the program mask yourself for assembler.      
You can program for it in the Assembler (preserve it, clear it,        
execute your program, reset it); or you can program for it in          
the COBOL using the CALL "CEE3SPM".  The CEE3SPM has a PUSH,SET        
option to preserve and a POP to restore.