<s> import sys <EOL> mswindows = ( sys . platform == "<STR_LIT:win32>" ) <EOL> import os <EOL> import types <EOL> import traceback <EOL> import gc <EOL> class CalledProcessError ( Exception ) : <EOL> def __init__ ( self , returncode , cmd ) : <EOL> self . returncode = returncode <EOL> self . cmd = cmd <EOL> def __str__ ( self ) : <EOL> return "<STR_LIT>" % ( self . cmd , self . returncode ) <EOL> if mswindows : <EOL> import threading <EOL> import msvcrt <EOL> if <NUM_LIT:0> : <EOL> import pywintypes <EOL> from win32api import GetStdHandle , STD_INPUT_HANDLE , STD_OUTPUT_HANDLE , STD_ERROR_HANDLE <EOL> from win32api import GetCurrentProcess , DuplicateHandle , GetModuleFileName , GetVersion <EOL> from win32con import DUPLICATE_SAME_ACCESS , SW_HIDE <EOL> from win32pipe import CreatePipe <EOL> from win32process import CreateProcess , STARTUPINFO , GetExitCodeProcess , STARTF_USESTDHANDLES , STARTF_USESHOWWINDOW , CREATE_NEW_CONSOLE <EOL> from win32event import WaitForSingleObject , INFINITE , WAIT_OBJECT_0 <EOL> else : <EOL> from _subprocess import * <EOL> class STARTUPINFO : <EOL> dwFlags = <NUM_LIT:0> <EOL> hStdInput = None <EOL> hStdOutput = None <EOL> hStdError = None <EOL> wShowWindow = <NUM_LIT:0> <EOL> class pywintypes : <EOL> error = IOError <EOL> else : <EOL> import select <EOL> import errno <EOL> import fcntl <EOL> import pickle <EOL> __all__ = [ "<STR_LIT>" , "<STR_LIT>" , "<STR_LIT>" , "<STR_LIT>" , "<STR_LIT>" , "<STR_LIT>" ] <EOL> try : <EOL> MAXFD = os . sysconf ( "<STR_LIT>" ) <EOL> except : <EOL> MAXFD = <NUM_LIT> <EOL> try : <EOL> False <EOL> except NameError : <EOL> False = <NUM_LIT:0> <EOL> True = <NUM_LIT:1> <EOL> _active = [ ] <EOL> def _cleanup ( ) : <EOL> for inst in _active [ : ] : <EOL> if inst . poll ( _deadstate = sys . maxint ) >= <NUM_LIT:0> : <EOL> try : <EOL> _active . remove ( inst ) <EOL> except ValueError : <EOL> pass <EOL> PIPE = - <NUM_LIT:1> <EOL> STDOUT = - <NUM_LIT:2> <EOL> def call ( * popenargs , ** kwargs ) : <EOL> return Popen ( * popenargs , ** kwargs ) . wait ( ) <EOL> def check_call ( * popenargs , ** kwargs ) : <EOL> retcode = call ( * popenargs , ** kwargs ) <EOL> cmd = kwargs . get ( "<STR_LIT:args>" ) <EOL> if cmd is None : <EOL> cmd = popenargs [ <NUM_LIT:0> ] <EOL> if retcode : <EOL> raise CalledProcessError ( retcode , cmd ) <EOL> return retcode <EOL> def list2cmdline ( seq ) : <EOL> result = [ ] <EOL> needquote = False <EOL> for arg in seq : <EOL> bs_buf = [ ] <EOL> if result : <EOL> result . append ( '<STR_LIT:U+0020>' ) <EOL> needquote = ( "<STR_LIT:U+0020>" in arg ) or ( "<STR_LIT:\t>" in arg ) or arg == "<STR_LIT>" <EOL> if needquote : <EOL> result . append ( '<STR_LIT:">' ) <EOL> for c in arg : <EOL> if c == '<STR_LIT:\\>' : <EOL> bs_buf . append ( c ) <EOL> elif c == '<STR_LIT:">' : <EOL> result . append ( '<STR_LIT:\\>' * len ( bs_buf ) * <NUM_LIT:2> ) <EOL> bs_buf = [ ] <EOL> result . append ( '<STR_LIT>' ) <EOL> else : <EOL> if bs_buf : <EOL> result . extend ( bs_buf ) <EOL> bs_buf = [ ] <EOL> result . append ( c ) <EOL> if bs_buf : <EOL> result . extend ( bs_buf ) <EOL> if needquote : <EOL> result . extend ( bs_buf ) <EOL> result . append ( '<STR_LIT:">' ) <EOL> return '<STR_LIT>' . join ( result ) <EOL> class Popen ( object ) : <EOL> def __init__ ( self , args , bufsize = <NUM_LIT:0> , executable = None , <EOL> stdin = None , stdout = None , stderr = None , <EOL> preexec_fn = None , close_fds = False , shell = False , <EOL> cwd = None , env = None , universal_newlines = False , <EOL> startupinfo = None , creationflags = <NUM_LIT:0> ) : <EOL> _cleanup ( ) <EOL> self . _child_created = False <EOL> if not isinstance ( bufsize , ( int , long ) ) : <EOL> raise TypeError ( "<STR_LIT>" ) <EOL> if mswindows : <EOL> if preexec_fn is not None : <EOL> raise ValueError ( "<STR_LIT>" ) <EOL> if close_fds : <EOL> raise ValueError ( "<STR_LIT>" ) <EOL> else : <EOL> if startupinfo is not None : <EOL> raise ValueError ( "<STR_LIT>" ) <EOL> if creationflags != <NUM_LIT:0> : <EOL> raise ValueError ( "<STR_LIT>" ) <EOL> self . stdin = None <EOL> self . stdout = None <EOL> self . stderr = None <EOL> self . pid = None <EOL> self . returncode = None <EOL> self . universal_newlines = universal_newlines <EOL> ( p2cread , p2cwrite , <EOL> c2pread , c2pwrite , <EOL> errread , errwrite ) = self . _get_handles ( stdin , stdout , stderr ) <EOL> self . _execute_child ( args , executable , preexec_fn , close_fds , <EOL> cwd , env , universal_newlines , <EOL> startupinfo , creationflags , shell , <EOL> p2cread , p2cwrite , <EOL> c2pread , c2pwrite , <EOL> errread , errwrite ) <EOL> if mswindows : <EOL> if stdin is None and p2cwrite is not None : <EOL> os . close ( p2cwrite ) <EOL> p2cwrite = None <EOL> if stdout is None and c2pread is not None : <EOL> os . close ( c2pread ) <EOL> c2pread = None <EOL> if stderr is None and errread is not None : <EOL> os . close ( errread ) <EOL> errread = None <EOL> if p2cwrite : <EOL> self . stdin = os . fdopen ( p2cwrite , '<STR_LIT:wb>' , bufsize ) <EOL> if c2pread : <EOL> if universal_newlines : <EOL> self . stdout = os . fdopen ( c2pread , '<STR_LIT>' , bufsize ) <EOL> else : <EOL> self . stdout = os . fdopen ( c2pread , '<STR_LIT:rb>' , bufsize ) <EOL> if errread : <EOL> if universal_newlines : <EOL> self . stderr = os . fdopen ( errread , '<STR_LIT>' , bufsize ) <EOL> else : <EOL> self . stderr = os . fdopen ( errread , '<STR_LIT:rb>' , bufsize ) <EOL> def _translate_newlines ( self , data ) : <EOL> data = data . replace ( "<STR_LIT:\r\n>" , "<STR_LIT:\n>" ) <EOL> data = data . replace ( "<STR_LIT:\r>" , "<STR_LIT:\n>" ) <EOL> return data <EOL> def __del__ ( self , sys = sys ) : <EOL> if not self . _child_created : <EOL> return <EOL> self . poll ( _deadstate = sys . maxint ) <EOL> if self . returncode is None and _active is not None : <EOL> _active . append ( self ) <EOL> def communicate ( self , input = None ) : <EOL> if [ self . stdin , self . stdout , self . stderr ] . count ( None ) >= <NUM_LIT:2> : <EOL> stdout = None <EOL> stderr = None <EOL> if self . stdin : <EOL> if input : <EOL> self . stdin . write ( input ) <EOL> self . stdin . close ( ) <EOL> elif self . stdout : <EOL> stdout = self . stdout . read ( ) <EOL> elif self . stderr : <EOL> stderr = self . stderr . read ( ) <EOL> self . wait ( ) <EOL> return ( stdout , stderr ) <EOL> return self . _communicate ( input ) <EOL> if mswindows : <EOL> def _get_handles ( self , stdin , stdout , stderr ) : <EOL> if stdin is None and stdout is None and stderr is None : <EOL> return ( None , None , None , None , None , None ) <EOL> p2cread , p2cwrite = None , None <EOL> c2pread , c2pwrite = None , None <EOL> errread , errwrite = None , None <EOL> if stdin is None : <EOL> p2cread = GetStdHandle ( STD_INPUT_HANDLE ) <EOL> if p2cread is not None : <EOL> pass <EOL> elif stdin is None or stdin == PIPE : <EOL> p2cread , p2cwrite = CreatePipe ( None , <NUM_LIT:0> ) <EOL> p2cwrite = p2cwrite . Detach ( ) <EOL> p2cwrite = msvcrt . open_osfhandle ( p2cwrite , <NUM_LIT:0> ) <EOL> elif isinstance ( stdin , int ) : <EOL> p2cread = msvcrt . get_osfhandle ( stdin ) <EOL> else : <EOL> p2cread = msvcrt . get_osfhandle ( stdin . fileno ( ) ) <EOL> p2cread = self . _make_inheritable ( p2cread ) <EOL> if stdout is None : <EOL> c2pwrite = GetStdHandle ( STD_OUTPUT_HANDLE ) <EOL> if c2pwrite is not None : <EOL> pass <EOL> elif stdout is None or stdout == PIPE : <EOL> c2pread , c2pwrite = CreatePipe ( None , <NUM_LIT:0> ) <EOL> c2pread = c2pread . Detach ( ) <EOL> c2pread = msvcrt . open_osfhandle ( c2pread , <NUM_LIT:0> ) <EOL> elif isinstance ( stdout , int ) : <EOL> c2pwrite = msvcrt . get_osfhandle ( stdout ) <EOL> else : <EOL> c2pwrite = msvcrt . get_osfhandle ( stdout . fileno ( ) ) <EOL> c2pwrite = self . _make_inheritable ( c2pwrite ) <EOL> if stderr is None : <EOL> errwrite = GetStdHandle ( STD_ERROR_HANDLE ) <EOL> if errwrite is not None : <EOL> pass <EOL> elif stderr is None or stderr == PIPE : <EOL> errread , errwrite = CreatePipe ( None , <NUM_LIT:0> ) <EOL> errread = errread . Detach ( ) <EOL> errread = msvcrt . open_osfhandle ( errread , <NUM_LIT:0> ) <EOL> elif stderr == STDOUT : <EOL> errwrite = c2pwrite <EOL> elif isinstance ( stderr , int ) : <EOL> errwrite = msvcrt . get_osfhandle ( stderr ) <EOL> else : <EOL> errwrite = msvcrt . get_osfhandle ( stderr . fileno ( ) ) <EOL> errwrite = self . _make_inheritable ( errwrite ) <EOL> return ( p2cread , p2cwrite , <EOL> c2pread , c2pwrite , <EOL> errread , errwrite ) <EOL> def _make_inheritable ( self , handle ) : <EOL> return DuplicateHandle ( GetCurrentProcess ( ) , handle , GetCurrentProcess ( ) , <NUM_LIT:0> , <NUM_LIT:1> , DUPLICATE_SAME_ACCESS ) <EOL> def _find_w9xpopen ( self ) : <EOL> w9xpopen = os . path . join ( os . path . dirname ( GetModuleFileName ( <NUM_LIT:0> ) ) , "<STR_LIT>" ) <EOL> if not os . path . exists ( w9xpopen ) : <EOL> w9xpopen = os . path . join ( os . path . dirname ( sys . exec_prefix ) , "<STR_LIT>" ) <EOL> if not os . path . exists ( w9xpopen ) : <EOL> raise RuntimeError ( "<STR_LIT>" ) <EOL> return w9xpopen <EOL> def _execute_child ( self , args , executable , preexec_fn , close_fds , <EOL> cwd , env , universal_newlines , <EOL> startupinfo , creationflags , shell , <EOL> p2cread , p2cwrite , <EOL> c2pread , c2pwrite , <EOL> errread , errwrite ) : <EOL> if not isinstance ( args , types . StringTypes ) : <EOL> args = list2cmdline ( args ) <EOL> if startupinfo is None : <EOL> startupinfo = STARTUPINFO ( ) <EOL> if None not in ( p2cread , c2pwrite , errwrite ) : <EOL> startupinfo . dwFlags |= STARTF_USESTDHANDLES <EOL> startupinfo . hStdInput = p2cread <EOL> startupinfo . hStdOutput = c2pwrite <EOL> startupinfo . hStdError = errwrite <EOL> if shell : <EOL> startupinfo . dwFlags |= STARTF_USESHOWWINDOW <EOL> startupinfo . wShowWindow = SW_HIDE <EOL> comspec = os . environ . get ( "<STR_LIT>" , "<STR_LIT>" ) <EOL> args = comspec + "<STR_LIT>" + args <EOL> if ( GetVersion ( ) >= <NUM_LIT> L or <EOL> os . path . basename ( comspec ) . lower ( ) == "<STR_LIT>" ) : <EOL> w9xpopen = self . _find_w9xpopen ( ) <EOL> args = '<STR_LIT>' % ( w9xpopen , args ) <EOL> creationflags |= CREATE_NEW_CONSOLE <EOL> try : <EOL> hp , ht , pid , tid = CreateProcess ( executable , args , None , None , <NUM_LIT:1> , creationflags , env , cwd , startupinfo ) <EOL> except pywintypes . error , e : <EOL> raise WindowsError ( * e . args ) <EOL> self . _child_created = True <EOL> self . _handle = hp <EOL> self . pid = pid <EOL> ht . Close ( ) <EOL> if p2cread is not None : <EOL> p2cread . Close ( ) <EOL> if c2pwrite is not None : <EOL> c2pwrite . Close ( ) <EOL> if errwrite is not None : <EOL> errwrite . Close ( ) <EOL> def poll ( self , _deadstate = None ) : <EOL> if self . returncode is None : <EOL> if WaitForSingleObject ( self . _handle , <NUM_LIT:0> ) == WAIT_OBJECT_0 : <EOL> self . returncode = GetExitCodeProcess ( self . _handle ) <EOL> return self . returncode <EOL> def wait ( self ) : <EOL> if self . returncode is None : <EOL> obj = WaitForSingleObject ( self . _handle , INFINITE ) <EOL> self . returncode = GetExitCodeProcess ( self . _handle ) <EOL> return self . returncode <EOL> def _readerthread ( self , fh , buffer ) : <EOL> buffer . append ( fh . read ( ) ) <EOL> def _communicate ( self , input ) : <EOL> stdout = None <EOL> stderr = None <EOL> if self . stdout : <EOL> stdout = [ ] <EOL> stdout_thread = threading . Thread ( target = self . _readerthread , args = ( self . stdout , stdout ) ) <EOL> stdout_thread . setDaemon ( True ) <EOL> stdout_thread . start ( ) <EOL> if self . stderr : <EOL> stderr = [ ] <EOL> stderr_thread = threading . Thread ( target = self . _readerthread , args = ( self . stderr , stderr ) ) <EOL> stderr_thread . setDaemon ( True ) <EOL> stderr_thread . start ( ) <EOL> if self . stdin : <EOL> if input is not None : <EOL> self . stdin . write ( input ) <EOL> self . stdin . close ( ) <EOL> if self . stdout : <EOL> stdout_thread . join ( ) <EOL> if self . stderr : <EOL> stderr_thread . join ( ) <EOL> if stdout is not None : <EOL> stdout = stdout [ <NUM_LIT:0> ] <EOL> if stderr is not None : <EOL> stderr = stderr [ <NUM_LIT:0> ] <EOL> if self . universal_newlines and hasattr ( file , '<STR_LIT>' ) : <EOL> if stdout : <EOL> stdout = self . _translate_newlines ( stdout ) <EOL> if stderr : <EOL> stderr = self . _translate_newlines ( stderr ) <EOL> self . wait ( ) <EOL> return ( stdout , stderr ) <EOL> else : <EOL> def _get_handles ( self , stdin , stdout , stderr ) : <EOL> p2cread , p2cwrite = None , None <EOL> c2pread , c2pwrite = None , None <EOL> errread , errwrite = None , None <EOL> if stdin is None : <EOL> pass <EOL> elif stdin == PIPE : <EOL> p2cread , p2cwrite = os . pipe ( ) <EOL> elif isinstance ( stdin , int ) : <EOL> p2cread = stdin <EOL> else : <EOL> p2cread = stdin . fileno ( ) <EOL> if stdout is None : <EOL> pass <EOL> elif stdout == PIPE : <EOL> c2pread , c2pwrite = os . pipe ( ) <EOL> elif isinstance ( stdout , int ) : <EOL> c2pwrite = stdout <EOL> else : <EOL> c2pwrite = stdout . fileno ( ) <EOL> if stderr is None : <EOL> pass <EOL> elif stderr == PIPE : <EOL> errread , errwrite = os . pipe ( ) <EOL> elif stderr == STDOUT : <EOL> errwrite = c2pwrite <EOL> elif isinstance ( stderr , int ) : <EOL> errwrite = stderr <EOL> else : <EOL> errwrite = stderr . fileno ( ) <EOL> return ( p2cread , p2cwrite , c2pread , c2pwrite , errread , errwrite ) <EOL> def _set_cloexec_flag ( self , fd ) : <EOL> try : <EOL> cloexec_flag = fcntl . FD_CLOEXEC <EOL> except AttributeError : <EOL> cloexec_flag = <NUM_LIT:1> <EOL> old = fcntl . fcntl ( fd , fcntl . F_GETFD ) <EOL> fcntl . fcntl ( fd , fcntl . F_SETFD , old | cloexec_flag ) <EOL> def _close_fds ( self , but ) : <EOL> for i in xrange ( <NUM_LIT:3> , MAXFD ) : <EOL> if i == but : <EOL> continue <EOL> try : <EOL> os . close ( i ) <EOL> except : <EOL> pass <EOL> def _execute_child ( self , args , executable , preexec_fn , close_fds , <EOL> cwd , env , universal_newlines , startupinfo , creationflags , shell , <EOL> p2cread , p2cwrite , c2pread , c2pwrite , errread , errwrite ) : <EOL> if isinstance ( args , types . StringTypes ) : <EOL> args = [ args ] <EOL> else : <EOL> args = list ( args ) <EOL> if shell : <EOL> args = [ "<STR_LIT>" , "<STR_LIT:-c>" ] + args <EOL> if executable is None : <EOL> executable = args [ <NUM_LIT:0> ] <EOL> errpipe_read , errpipe_write = os . pipe ( ) <EOL> self . _set_cloexec_flag ( errpipe_write ) <EOL> gc_was_enabled = gc . isenabled ( ) <EOL> gc . disable ( ) <EOL> try : <EOL> self . pid = os . fork ( ) <EOL> except : <EOL> if gc_was_enabled : <EOL> gc . enable ( ) <EOL> raise <EOL> self . _child_created = True <EOL> if self . pid == <NUM_LIT:0> : <EOL> try : <EOL> if p2cwrite : <EOL> os . close ( p2cwrite ) <EOL> if c2pread : <EOL> os . close ( c2pread ) <EOL> if errread : <EOL> os . close ( errread ) <EOL> os . close ( errpipe_read ) <EOL> if p2cread : <EOL> os . dup2 ( p2cread , <NUM_LIT:0> ) <EOL> if c2pwrite : <EOL> os . dup2 ( c2pwrite , <NUM_LIT:1> ) <EOL> if errwrite : <EOL> os . dup2 ( errwrite , <NUM_LIT:2> ) <EOL> if p2cread and p2cread not in ( <NUM_LIT:0> , ) : <EOL> os . close ( p2cread ) <EOL> if c2pwrite and c2pwrite not in ( p2cread , <NUM_LIT:1> ) : <EOL> os . close ( c2pwrite ) <EOL> if errwrite and errwrite not in ( p2cread , c2pwrite , <NUM_LIT:2> ) : <EOL> os . close ( errwrite ) <EOL> if close_fds : <EOL> self . _close_fds ( but = errpipe_write ) <EOL> if cwd is not None : <EOL> os . chdir ( cwd ) <EOL> if preexec_fn : <EOL> apply ( preexec_fn ) <EOL> if env is None : <EOL> os . execvp ( executable , args ) <EOL> else : <EOL> os . execvpe ( executable , args , env ) <EOL> except : <EOL> exc_type , exc_value , tb = sys . exc_info ( ) <EOL> exc_lines = traceback . format_exception ( exc_type , exc_value , tb ) <EOL> exc_value . child_traceback = '<STR_LIT>' . join ( exc_lines ) <EOL> os . write ( errpipe_write , pickle . dumps ( exc_value ) ) <EOL> os . _exit ( <NUM_LIT:255> ) <EOL> if gc_was_enabled : <EOL> gc . enable ( ) <EOL> os . close ( errpipe_write ) <EOL> if p2cread and p2cwrite : <EOL> os . close ( p2cread ) <EOL> if c2pwrite and c2pread : <EOL> os . close ( c2pwrite ) <EOL> if errwrite and errread : <EOL> os . close ( errwrite ) <EOL> data = os . read ( errpipe_read , <NUM_LIT> ) <EOL> os . close ( errpipe_read ) <EOL> if data != "<STR_LIT>" : <EOL> os . waitpid ( self . pid , <NUM_LIT:0> ) <EOL> child_exception = pickle . loads ( data ) <EOL> raise child_exception <EOL> def _handle_exitstatus ( self , sts ) : <EOL> if os . WIFSIGNALED ( sts ) : <EOL> self . returncode = - os . WTERMSIG ( sts ) <EOL> elif os . WIFEXITED ( sts ) : <EOL> self . returncode = os . WEXITSTATUS ( sts ) <EOL> else : <EOL> raise RuntimeError ( "<STR_LIT>" ) <EOL> def poll ( self , _deadstate = None ) : <EOL> if self . returncode is None : <EOL> try : <EOL> pid , sts = os . waitpid ( self . pid , os . WNOHANG ) <EOL> if pid == self . pid : <EOL> self . _handle_exitstatus ( sts ) <EOL> except os . error : <EOL> if _deadstate is not None : <EOL> self . returncode = _deadstate <EOL> return self . returncode <EOL> def wait ( self ) : <EOL> if self . returncode is None : <EOL> pid , sts = os . waitpid ( self . pid , <NUM_LIT:0> ) <EOL> self . _handle_exitstatus ( sts ) <EOL> return self . returncode <EOL> def _communicate ( self , input ) : <EOL> read_set = [ ] <EOL> write_set = [ ] <EOL> stdout = None <EOL> stderr = None <EOL> if self . stdin : <EOL> self . stdin . flush ( ) <EOL> if input : <EOL> write_set . append ( self . stdin ) <EOL> else : <EOL> self . stdin . close ( ) <EOL> if self . stdout : <EOL> read_set . append ( self . stdout ) <EOL> stdout = [ ] <EOL> if self . stderr : <EOL> read_set . append ( self . stderr ) <EOL> stderr = [ ] <EOL> input_offset = <NUM_LIT:0> <EOL> while read_set or write_set : <EOL> rlist , wlist , xlist = select . select ( read_set , write_set , [ ] ) <EOL> if self . stdin in wlist : <EOL> bytes_written = os . write ( self . stdin . fileno ( ) , buffer ( input , input_offset , <NUM_LIT> ) ) <EOL> input_offset += bytes_written <EOL> if input_offset >= len ( input ) : <EOL> self . stdin . close ( ) <EOL> write_set . remove ( self . stdin ) <EOL> if self . stdout in rlist : <EOL> data = os . read ( self . stdout . fileno ( ) , <NUM_LIT> ) <EOL> if data == "<STR_LIT>" : <EOL> self . stdout . close ( ) <EOL> read_set . remove ( self . stdout ) <EOL> stdout . append ( data ) <EOL> if self . stderr in rlist : <EOL> data = os . read ( self . stderr . fileno ( ) , <NUM_LIT> ) <EOL> if data == "<STR_LIT>" : <EOL> self . stderr . close ( ) <EOL> read_set . remove ( self . stderr ) <EOL> stderr . append ( data ) <EOL> if stdout is not None : <EOL> stdout = '<STR_LIT>' . join ( stdout ) <EOL> if stderr is not None : <EOL> stderr = '<STR_LIT>' . join ( stderr ) <EOL> if self . universal_newlines and hasattr ( file , '<STR_LIT>' ) : <EOL> if stdout : <EOL> stdout = self . _translate_newlines ( stdout ) <EOL> if stderr : <EOL> stderr = self . _translate_newlines ( stderr ) <EOL> self . wait ( ) <EOL> return ( stdout , stderr ) </s>
