[SCM] jackd2/master: Sync to upstream r4089

adiknoth-guest at users.alioth.debian.org adiknoth-guest at users.alioth.debian.org
Mon Nov 22 19:00:52 UTC 2010


The following commit has been merged in the master branch:
commit 4531f91f4b4bc4df07c518fb9205bb6dc2bce9eb
Author: Adrian Knoth <adi at drcomp.erfurt.thur.de>
Date:   Mon Nov 22 18:45:09 2010 +0100

    Sync to upstream r4089

diff --git a/debian/patches/0000_sync_upstream_vcs.patch b/debian/patches/0000_sync_upstream_vcs.patch
new file mode 100644
index 0000000..6d813b5
--- /dev/null
+++ b/debian/patches/0000_sync_upstream_vcs.patch
@@ -0,0 +1,25292 @@
+From: Adrian Knoth <adi at drcomp.erfurt.thur.de>
+Description: Sync with upstream SVN trunk revision 4089
+Last-Update: 2010-11-22
+Forwarded: not-needed
+
+--- a/ChangeLog
++++ b/ChangeLog
+@@ -31,7 +31,38 @@
+ 
+ ---------------------------
+   Jackdmp changes log
+----------------------------
++---------------------------
++
++2010-11-17 Stephane Letz  <letz at grame.fr>
++
++	* ALSA backend : suspend/resume handling (jack1 r4075).
++	* Correct dummy driver.
++
++2010-11-05 Stephane Letz  <letz at grame.fr>
++
++	* In jackdmp.cpp, jackctl_setup_signals moved before jackctl_server_start. 
++	* Correct symbols export in backends on OSX.
++
++2010-11-03 Stephane Letz  <letz at grame.fr>
++
++	* Improve backend error handling: fatal error returned by Read/Write now cause a Process failure (so a thread exit for blocking backends). Recoverable ones (XRuns..) are now treated internally in ALSA, FreeBob and FFADO backends.
++
++2010-10-30 Stephane Letz  <letz at grame.fr>
++
++	* Correct JackServer::Open to avoid a race when control API is used on OSX. 
++
++2010-10-29 Stephane Letz  <letz at grame.fr>
++
++	* Correct lsp.c code.
++	* Add note about unique port-name requirement.
++
++2010-09-08 Stephane Letz  <letz at grame.fr>
++
++	* Sync JackAlsaDriver::alsa_driver_check_card_type with JACK1 backend.
++
++2010-08-30 Stephane Letz  <letz at grame.fr>
++
++	* Version 1.9.7 started.
+ 
+ 2010-08-25 Stephane Letz  <letz at grame.fr>
+ 
+--- a/common/JackAPI.cpp
++++ b/common/JackAPI.cpp
+@@ -108,8 +108,8 @@
+             JackPortConnectCallback
+             connect_callback, void *arg);
+     EXPORT int jack_set_port_rename_callback (jack_client_t *,
+-				    JackPortRenameCallback
+-				    rename_callback, void *arg);
++                                    JackPortRenameCallback
++                                    rename_callback, void *arg);
+     EXPORT int jack_set_graph_order_callback (jack_client_t *,
+             JackGraphOrderCallback graph_callback,
+             void *);
+@@ -217,7 +217,7 @@
+     EXPORT int jack_client_create_thread (jack_client_t* client,
+                                           pthread_t *thread,
+                                           int priority,
+-                                          int realtime, 	// boolean
++                                          int realtime,         // boolean
+                                           thread_routine routine,
+                                           void *arg);
+     EXPORT int jack_drop_real_time_scheduling (pthread_t thread);
+@@ -1686,7 +1686,7 @@
+ EXPORT int jack_client_create_thread(jack_client_t* client,
+                                      pthread_t *thread,
+                                      int priority,
+-                                     int realtime,  	/* boolean */
++                                     int realtime,      /* boolean */
+                                      thread_routine routine,
+                                      void *arg)
+ {
+@@ -1766,8 +1766,8 @@
+         return 0;
+     } else {
+         jack_status_t my_status;
+-        if (status == NULL)		/* no status from caller? */
+-            status = &my_status;	/* use local status word */
++        if (status == NULL)             /* no status from caller? */
++            status = &my_status;        /* use local status word */
+         *status = (jack_status_t)0;
+         return client->InternalClientHandle(client_name, status);
+     }
+@@ -1786,8 +1786,8 @@
+         jack_varargs_t va;
+         jack_status_t my_status;
+ 
+-        if (status == NULL)			/* no status from caller? */
+-            status = &my_status;	/* use local status word */
++        if (status == NULL)                     /* no status from caller? */
++            status = &my_status;        /* use local status word */
+         *status = (jack_status_t)0;
+ 
+         /* validate parameters */
+@@ -1859,3 +1859,129 @@
+         free(ptr);
+     }
+ }
++
++// session.h
++EXPORT int jack_set_session_callback(jack_client_t* ext_client, JackSessionCallback session_callback, void* arg)
++{
++#ifdef __CLIENTDEBUG__
++    JackGlobals::CheckContext("jack_set_session_callback");
++#endif
++    JackClient* client = (JackClient*)ext_client;
++    jack_log("jack_set_session_callback ext_client %x client %x ", ext_client, client);
++    if (client == NULL) {
++        jack_error("jack_set_session_callback called with a NULL client");
++        return -1;
++    } else {
++        return client->SetSessionCallback(session_callback, arg);
++    }
++}
++
++EXPORT jack_session_command_t *jack_session_notify(jack_client_t* ext_client, const char* target, jack_session_event_type_t ev_type, const char *path) 
++{
++#ifdef __CLIENTDEBUG__
++    JackGlobals::CheckContext("jack_session_notify");
++#endif
++    JackClient* client = (JackClient*)ext_client;
++    jack_log("jack_session_notify ext_client %x client %x ", ext_client, client);
++    if (client == NULL) {
++        jack_error("jack_session_notify called with a NULL client");
++        return NULL;
++    } else {
++        return client->SessionNotify(target, ev_type, path);
++    }
++}
++
++EXPORT int jack_session_reply(jack_client_t *ext_client, jack_session_event_t *event)
++{
++#ifdef __CLIENTDEBUG__
++    JackGlobals::CheckContext("jack_session_reply");
++#endif
++    JackClient* client = (JackClient*)ext_client;
++    jack_log("jack_session_reply ext_client %x client %x ", ext_client, client);
++    if (client == NULL) {
++        jack_error("jack_session_reply called with a NULL client");
++        return -1;
++    } else {
++        return client->SessionReply(event);
++    }
++}
++
++EXPORT void jack_session_event_free(jack_session_event_t* ev)
++{
++    if (ev) {
++        if (ev->session_dir)
++            free((void *)ev->session_dir);
++        if (ev->client_uuid)
++            free((void *)ev->client_uuid);
++        if (ev->command_line)
++            free(ev->command_line);
++        free(ev);
++    }
++}
++
++EXPORT char *jack_get_uuid_for_client_name( jack_client_t *ext_client, const char *client_name )
++{
++#ifdef __CLIENTDEBUG__
++    JackGlobals::CheckContext("jack_get_uuid_for_client_name");
++#endif
++    JackClient* client = (JackClient*)ext_client;
++    jack_log("jack_get_uuid_for_client_name ext_client %x client %x ", ext_client, client);
++    if (client == NULL) {
++        jack_error("jack_get_uuid_for_client_name called with a NULL client");
++        return NULL;
++    } else {
++        return client->GetUUIDForClientName(client_name);
++    }
++}
++
++EXPORT char *jack_get_client_name_by_uuid( jack_client_t *ext_client, const char *client_uuid )
++{
++#ifdef __CLIENTDEBUG__
++    JackGlobals::CheckContext("jack_get_client_name_by_uuid");
++#endif
++    JackClient* client = (JackClient*)ext_client;
++    jack_log("jack_get_uuid_for_client_name ext_client %x client %x ", ext_client, client);
++    if (client == NULL) {
++        jack_error("jack_get_client_name_by_uuid called with a NULL client");
++        return NULL;
++    } else {
++        return client->GetClientNameForUUID(client_uuid);
++    }
++}
++
++EXPORT int jack_reserve_client_name( jack_client_t *ext_client, const char *name, const char *uuid )
++{
++#ifdef __CLIENTDEBUG__
++    JackGlobals::CheckContext("jack_reserve_client_name");
++#endif
++    JackClient* client = (JackClient*)ext_client;
++    jack_log("jack_reserve_client_name ext_client %x client %x ", ext_client, client);
++    if (client == NULL) {
++        jack_error("jack_reserve_client_name called with a NULL client");
++        return -1;
++    } else {
++        return client->ReserveClientName(name, uuid);
++    }
++}
++
++EXPORT void jack_session_commands_free( jack_session_command_t *cmds )
++{
++    if (!cmds)
++        return;
++
++    int i=0;
++    while(1) {
++        if (cmds[i].client_name)
++            free ((char *)cmds[i].client_name);
++        if (cmds[i].command)
++            free ((char *)cmds[i].command);
++        if (cmds[i].uuid)
++            free ((char *)cmds[i].uuid);
++        else
++            break;
++
++        i += 1;
++    }
++
++    free(cmds);
++}
+--- a/common/JackAudioDriver.cpp
++++ b/common/JackAudioDriver.cpp
+@@ -195,7 +195,7 @@
+         ProcessGraphAsync();
+     }
+             
+-     // Keep end cycle time
++    // Keep end cycle time
+     JackDriver::CycleTakeEndTime();
+     WaitUntilNextCycle();
+     return 0;
+@@ -215,14 +215,14 @@
+ {
+     // Read input buffers for the current cycle
+     if (Read() < 0) {   
+-        jack_error("JackAudioDriver::ProcessAsync: read error, skip cycle");
+-        return 0;   // Skip cycle, but continue processing...
++        jack_error("JackAudioDriver::ProcessAsync: read error, stopping...");
++        return -1;   
+     }
+ 
+     // Write output buffers from the previous cycle
+     if (Write() < 0) {
+-        jack_error("JackAudioDriver::ProcessAsync: write error, skip cycle");
+-        return 0;   // Skip cycle, but continue processing...
++        jack_error("JackAudioDriver::ProcessAsync: write error, stopping...");
++        return -1;   
+     }
+ 
+     if (fIsMaster) {
+@@ -244,9 +244,9 @@
+ int JackAudioDriver::ProcessSync()
+ {
+     // Read input buffers for the current cycle
+-    if (Read() < 0) { 
+-        jack_error("JackAudioDriver::ProcessSync: read error, skip cycle");
+-        return 0;   // Skip cycle, but continue processing...
++    if (Read() < 0) {   
++        jack_error("JackAudioDriver::ProcessSync: read error, stopping...");
++        return -1;   
+     }
+ 
+     if (fIsMaster) {
+@@ -255,10 +255,10 @@
+         fGraphManager->ResumeRefNum(&fClientControl, fSynchroTable);
+     }
+     
+-    // Write output buffers for the current cycle
+-    if (Write() < 0) { 
+-        jack_error("JackAudioDriver::ProcessSync: write error, skip cycle");
+-        return 0;   // Skip cycle, but continue processing...
++    // Write output buffers from the current cycle
++    if (Write() < 0) {
++        jack_error("JackAudioDriver::ProcessSync: write error, stopping...");
++        return -1;   
+     }
+     
+     // Keep end cycle time
+@@ -270,10 +270,10 @@
+ {
+     // fBeginDateUst is set in the "low level" layer, fEndDateUst is from previous cycle
+     if (!fEngine->Process(fBeginDateUst, fEndDateUst)) 
+-        jack_error("JackAudioDriver::ProcessAsync Process error");
++        jack_error("JackAudioDriver::ProcessGraphAsync: Process error");
+     fGraphManager->ResumeRefNum(&fClientControl, fSynchroTable);
+     if (ProcessSlaves() < 0)
+-        jack_error("JackAudioDriver::ProcessAsync ProcessSlaves error");
++        jack_error("JackAudioDriver::ProcessGraphAsync: ProcessSlaves error");
+ }
+ 
+ void JackAudioDriver::ProcessGraphSync()
+@@ -282,11 +282,11 @@
+     if (fEngine->Process(fBeginDateUst, fEndDateUst)) { 
+         fGraphManager->ResumeRefNum(&fClientControl, fSynchroTable);
+         if (ProcessSlaves() < 0)
+-            jack_error("JackAudioDriver::ProcessSync ProcessSlaves error, engine may now behave abnormally!!");
++            jack_error("JackAudioDriver::ProcessGraphSync: ProcessSlaves error, engine may now behave abnormally!!");
+         if (fGraphManager->SuspendRefNum(&fClientControl, fSynchroTable, DRIVER_TIMEOUT_FACTOR * fEngineControl->fTimeOutUsecs) < 0)
+-            jack_error("JackAudioDriver::ProcessSync SuspendRefNum error, engine may now behave abnormally!!");
++            jack_error("JackAudioDriver::ProcessGraphSync: SuspendRefNum error, engine may now behave abnormally!!");
+     } else { // Graph not finished: do not activate it
+-        jack_error("JackAudioDriver::ProcessSync: error");
++        jack_error("JackAudioDriver::ProcessGraphSync: Process error");
+     }
+ }
+ 
+--- a/common/JackChannel.h
++++ b/common/JackChannel.h
+@@ -21,6 +21,7 @@
+ #define __JackChannel__
+ 
+ #include "types.h"
++#include "session.h"
+ 
+ namespace Jack
+ {
+@@ -49,7 +50,7 @@
+         {}
+ 
+         // Open the Server/Client connection
+-        virtual int Open(const char* server_name, const char* name, char* name_res, JackClient* obj, jack_options_t options, jack_status_t* status)
++        virtual int Open(const char* server_name, const char* name, int uuid, char* name_res, JackClient* obj, jack_options_t options, jack_status_t* status)
+         {
+             return 0;
+         }
+@@ -73,9 +74,9 @@
+             return -1;
+         }
+ 
+-        virtual void ClientCheck(const char* name, char* name_res, int protocol, int options, int* status, int* result)
++        virtual void ClientCheck(const char* name, int uuid, char* name_res, int protocol, int options, int* status, int* result)
+         {}
+-        virtual void ClientOpen(const char* name, int pid, int* shared_engine, int* shared_client, int* shared_graph, int* result)
++        virtual void ClientOpen(const char* name, int pid, int uuid, int* shared_engine, int* shared_client, int* shared_graph, int* result)
+         {}
+         virtual void ClientOpen(const char* name, int* ref, JackEngineControl** shared_engine, JackGraphManager** shared_manager, JackClientInterface* client, int* result)
+         {}
+@@ -120,12 +121,31 @@
+         virtual void InternalClientHandle(int refnum, const char* client_name, int* status, int* int_ref, int* result)
+         {}
+ 
+-        virtual void InternalClientLoad(int refnum, const char* client_name, const char* so_name, const char* objet_data, int options, int* status, int* int_ref, int* result)
++        virtual void InternalClientLoad(int refnum, const char* client_name, const char* so_name, const char* objet_data, int options, int* status, int* int_ref, int uuid, int* result)
+         {}
+ 
+         virtual void InternalClientUnload(int refnum, int int_ref, int* status, int* result)
+         {}
+         
++        virtual void SessionNotify(int refnum, const char* target, jack_session_event_type_t type, const char *path, jack_session_command_t **result)
++        {}
++
++        virtual void SessionReply(int refnum, int *result)
++        {}
++
++        virtual void GetUUIDForClientName(int refnum, const char *client_name, char *uuid_res, int *result)
++        {}
++
++        virtual void GetClientNameForUUID(int refnum, const char *uuid, char *name_res, int *result)
++        {}
++
++        virtual void ReserveClientName(int refnum, const char *client_name, const char *uuid, int *result)
++        {}
++
++        virtual bool IsChannelThread()
++        { 
++            return false; 
++        }
+ };
+ 
+ }
+--- a/common/JackClient.cpp
++++ b/common/JackClient.cpp
+@@ -112,9 +112,9 @@
+ }
+ 
+ /*!
+-	In "async" mode, the server does not synchronize itself on the output drivers, thus it would never "consume" the activations.
+-	The synchronization primitives for drivers are setup in "flush" mode that to not keep unneeded activations.
+-	Drivers synchro are setup in "flush" mode if server is "async" and NOT freewheel.
++        In "async" mode, the server does not synchronize itself on the output drivers, thus it would never "consume" the activations.
++        The synchronization primitives for drivers are setup in "flush" mode that to not keep unneeded activations.
++        Drivers synchro are setup in "flush" mode if server is "async" and NOT freewheel.
+ */
+ void JackClient::SetupDriverSync(bool freewheel)
+ {
+@@ -170,7 +170,7 @@
+ 
+             case kAddClient:
+                 jack_log("JackClient::kAddClient fName = %s name = %s", GetClientControl()->fName, name);
+-                if (fClientRegistration && strcmp(GetClientControl()->fName, name) != 0) {	// Don't call the callback for the registering client itself
++                if (fClientRegistration && strcmp(GetClientControl()->fName, name) != 0) {      // Don't call the callback for the registering client itself
+                     fClientRegistration(name, 1, fClientRegistrationArg);
+                 }
+                 break;
+@@ -272,6 +272,23 @@
+                     fInfoShutdown = NULL;
+                 }
+                 break;
++
++            case kSessionCallback:
++                jack_log("JackClient::kSessionCallback");
++                if (fSession) {
++                    jack_session_event_t *event = (jack_session_event_t *) malloc( sizeof(jack_session_event_t) );
++                    char uuid_buf[JACK_UUID_SIZE];
++                    event->type = (jack_session_event_type_t) value1;
++                    event->session_dir = strdup( message );
++                    event->command_line = NULL;
++                    event->flags = (jack_session_flags_t) 0;
++                    snprintf( uuid_buf, sizeof(uuid_buf), "%d", GetClientControl()->fSessionID );
++                    event->client_uuid = strdup( uuid_buf );
++                    fImmediateSessionReply = false;
++                    fSession(event, fSessionArg);
++                    res = (fImmediateSessionReply) ? 1 : 2;
++                }
++                break;
+         }
+     }
+ 
+@@ -280,7 +297,7 @@
+ 
+ /*!
+ \brief We need to start thread before activating in the server, otherwise the FW driver
+-	   connected to the client may not be activated.
++           connected to the client may not be activated.
+ */
+ int JackClient::Activate()
+ {
+@@ -410,7 +427,7 @@
+     while (true) { 
+         CycleWaitAux();
+         CycleSignalAux(CallProcessCallback());  
+-	}
++        }
+ }
+ 
+ inline jack_nframes_t JackClient::CycleWaitAux()
+@@ -981,6 +998,19 @@
+     }
+ }
+ 
++int JackClient::SetSessionCallback(JackSessionCallback callback, void *arg)
++{
++    if (IsActive()) {
++        jack_error("You cannot set callbacks on an active client");
++        return -1;
++    } else {
++        GetClientControl()->fCallback[kSessionCallback] = (callback != NULL);
++        fSessionArg = arg;
++        fSession = callback;
++        return 0;
++    }
++}
++
+ //------------------
+ // Internal clients
+ //------------------
+@@ -1027,9 +1057,8 @@
+         return 0;
+     }
+ 
+-    int int_ref = 0;
+-    int result = -1;
+-    fChannel->InternalClientLoad(GetClientControl()->fRefNum, client_name, va->load_name, va->load_init, options, (int*)status, &int_ref, &result);
++    int int_ref, result = -1;
++    fChannel->InternalClientLoad(GetClientControl()->fRefNum, client_name, va->load_name, va->load_init, options, (int*)status, &int_ref, -1, &result);
+     return int_ref;
+ }
+ 
+@@ -1039,6 +1068,71 @@
+     fChannel->InternalClientUnload(GetClientControl()->fRefNum, ref, (int*)status, &result);
+ }
+ 
++//------------------
++// Session API
++//------------------
++
++jack_session_command_t *JackClient::SessionNotify( const char* target, jack_session_event_type_t type, const char* path )
++{
++    jack_session_command_t *res;
++    fChannel->SessionNotify( GetClientControl()->fRefNum, target, type, path, &res );
++    return res;
++}
++
++int JackClient::SessionReply( jack_session_event_t *ev )
++{
++    if (ev->command_line) {
++        strncpy( GetClientControl()->fSessionCommand, ev->command_line, sizeof(GetClientControl()->fSessionCommand) );
++    } else {
++        GetClientControl()->fSessionCommand[0] = '\0';
++    }
++
++    GetClientControl()->fSessionFlags = ev->flags;
++
++    jack_log( "JackClient::SessionReply... we are here" );
++    if (fChannel->IsChannelThread()) {
++        jack_log( "JackClient::SessionReply... in callback reply" );
++        fImmediateSessionReply = true;
++        return 0;
++    }
++
++    jack_log( "JackClient::SessionReply... out of cb" );
++
++    int res;
++    fChannel->SessionReply( GetClientControl()->fRefNum, &res);
++    return res;
++}
++
++char* JackClient::GetUUIDForClientName(const char* client_name)
++{
++    char uuid_res[JACK_UUID_SIZE];
++    int result = -1;
++    fChannel->GetUUIDForClientName( GetClientControl()->fRefNum, client_name, uuid_res, &result);
++
++    if (result)
++        return NULL;
++
++    return strdup(uuid_res);
++}
++
++char* JackClient::GetClientNameForUUID(const char* uuid)
++{
++    char name_res[JACK_CLIENT_NAME_SIZE + 1];
++    int result = -1;
++    fChannel->GetClientNameForUUID(GetClientControl()->fRefNum, uuid, name_res, &result);
++
++    if (result)
++        return NULL;
++
++    return strdup(name_res);
++}
++
++int JackClient::ReserveClientName(const char *name, const char* uuid)
++{
++    int result = -1;
++    fChannel->ReserveClientName( GetClientControl()->fRefNum, name, uuid, &result);
++    return result;
++}
+ 
+ } // end of namespace
+ 
+--- a/common/JackClient.h
++++ b/common/JackClient.h
+@@ -28,6 +28,7 @@
+ #include "JackPlatformPlug.h"
+ #include "JackChannel.h"
+ #include "types.h"
++#include "session.h"
+ #include "varargs.h"
+ #include <list>
+ 
+@@ -66,6 +67,7 @@
+         JackTimebaseCallback fTimebase;
+         JackSyncCallback fSync;
+         JackThreadCallback fThreadFun;
++        JackSessionCallback fSession;
+ 
+         void* fProcessArg;
+         void* fGraphOrderArg;
+@@ -83,12 +85,15 @@
+         void* fTimebaseArg;
+         void* fSyncArg;
+         void* fThreadFunArg;
++        void* fSessionArg;
+         char fServerName[64];
+ 
+         JackThread fThread;    /*! Thread to execute the Process function */
+         detail::JackClientChannelInterface* fChannel;
+         JackSynchro* fSynchroTable;
+         std::list<jack_port_id_t> fPortList;
++
++        bool fImmediateSessionReply;
+   
+         int StartThread();
+         void SetupDriverSync(bool freewheel);
+@@ -118,7 +123,7 @@
+         JackClient(JackSynchro* table);
+         virtual ~JackClient();
+ 
+-        virtual int Open(const char* server_name, const char* name, jack_options_t options, jack_status_t* status) = 0;
++        virtual int Open(const char* server_name, const char* name, int uuid, jack_options_t options, jack_status_t* status) = 0;
+         virtual int Close();
+ 
+         virtual JackGraphManager* GetGraphManager() const = 0;
+@@ -173,6 +178,7 @@
+         virtual int SetPortRegistrationCallback(JackPortRegistrationCallback callback, void* arg);
+         virtual int SetPortConnectCallback(JackPortConnectCallback callback, void *arg);
+         virtual int SetPortRenameCallback(JackPortRenameCallback callback, void *arg);
++        virtual int SetSessionCallback(JackSessionCallback callback, void *arg);
+ 
+         // Internal clients
+         virtual char* GetInternalClientName(int ref);
+@@ -184,6 +190,13 @@
+         void CycleSignal(int status);
+         int SetProcessThread(JackThreadCallback fun, void *arg);
+ 
++        // Session api
++        virtual jack_session_command_t *SessionNotify(const char *target, jack_session_event_type_t type, const char *path);
++        virtual int SessionReply(jack_session_event_t *ev);
++char* GetUUIDForClientName(const char* client_name);
++char* GetClientNameForUUID(const char* uuid);
++int ReserveClientName(const char *name, const char* uuid);
++
+         // JackRunnableInterface interface
+         bool Init();
+         bool Execute();
+--- a/common/JackClientControl.h
++++ b/common/JackClientControl.h
+@@ -26,6 +26,8 @@
+ #include "JackSynchro.h"
+ #include "JackNotification.h"
+ 
++#include "jack/session.h"
++
+ namespace Jack
+ {
+ 
+@@ -44,22 +46,26 @@
+     int fPID;
+     bool fActive;
+ 
+-    JackClientControl(const char* name, int pid, int refnum)
++    int fSessionID;
++    char fSessionCommand[JACK_SESSION_COMMAND_SIZE];
++    jack_session_flags_t fSessionFlags;
++
++    JackClientControl(const char* name, int pid, int refnum, int uuid)
+     {
+-        Init(name, pid, refnum);
++        Init(name, pid, refnum, uuid);
+     }
+ 
+     JackClientControl(const char* name)
+     {
+-        Init(name, 0, -1);
++        Init(name, 0, -1, -1);
+     }
+ 
+     JackClientControl()
+     {
+-        Init("", 0, -1);
++        Init("", 0, -1, -1);
+     }
+ 
+-    void Init(const char* name, int pid, int refnum)
++    void Init(const char* name, int pid, int refnum, int uuid)
+     {
+         strcpy(fName, name);
+         for (int i = 0; i < kMaxNotification; i++)
+@@ -77,6 +83,8 @@
+         fTransportSync = false;
+         fTransportTimebase = false;
+         fActive = false;
++
++        fSessionID = uuid;
+     }
+ 
+ } POST_PACKED_STRUCTURE;
+--- a/common/JackConstants.h
++++ b/common/JackConstants.h
+@@ -24,7 +24,7 @@
+ #include "config.h"
+ #endif
+ 
+-#define VERSION "1.9.6"
++#define VERSION "1.9.7"
+ 
+ #define BUFFER_SIZE_MAX 8192
+ 
+@@ -33,6 +33,8 @@
+ 
+ #define JACK_CLIENT_NAME_SIZE 64
+ #define JACK_MESSAGE_SIZE 256
++#define JACK_UUID_SIZE 32
++#define JACK_SESSION_COMMAND_SIZE 256
+ 
+ #ifndef PORT_NUM
+ #define PORT_NUM 2048
+@@ -71,6 +73,7 @@
+ #define FREEWHEEL_DRIVER_TIMEOUT 10     // in sec
+ #define DRIVER_TIMEOUT_FACTOR    10     
+ 
++
+ #define NO_PORT   0xFFFE
+ 
+ #define EMPTY   0xFFFD
+--- a/common/JackControlAPI.cpp
++++ b/common/JackControlAPI.cpp
+@@ -450,21 +450,21 @@
+ jackctl_setup_signals(
+     unsigned int flags)
+ {
+-	if ((waitEvent = CreateEvent(NULL, FALSE, FALSE, NULL)) == NULL) {
++        if ((waitEvent = CreateEvent(NULL, FALSE, FALSE, NULL)) == NULL) {
+         jack_error("CreateEvent fails err = %ld", GetLastError());
+         return 0;
+     }
+ 
+-	(void) signal(SIGINT, do_nothing_handler);
++        (void) signal(SIGINT, do_nothing_handler);
+     (void) signal(SIGABRT, do_nothing_handler);
+     (void) signal(SIGTERM, do_nothing_handler);
+ 
+-	return (sigset_t)waitEvent;
++        return (sigset_t)waitEvent;
+ }
+ 
+ void jackctl_wait_signals(sigset_t signals)
+ {
+-	if (WaitForSingleObject(waitEvent, INFINITE) != WAIT_OBJECT_0) {
++        if (WaitForSingleObject(waitEvent, INFINITE) != WAIT_OBJECT_0) {
+         jack_error("WaitForSingleObject fails err = %ld", GetLastError());
+     }
+ }
+@@ -1179,7 +1179,7 @@
+ {
+     int status;
+     if (server_ptr->engine != NULL) {
+-        server_ptr->engine->InternalClientLoad(internal->desc_ptr->name, internal->desc_ptr->name, internal->set_parameters, JackNullOption, &internal->refnum, &status);
++        server_ptr->engine->InternalClientLoad(internal->desc_ptr->name, internal->desc_ptr->name, internal->set_parameters, JackNullOption, &internal->refnum, -1, &status);
+         return (internal->refnum > 0);
+     } else {
+         return false;
+--- a/common/JackDebugClient.cpp
++++ b/common/JackDebugClient.cpp
+@@ -36,8 +36,8 @@
+ 
+ JackDebugClient::JackDebugClient(JackClient * client)
+ {
+-    fTotalPortNumber = 1;	// The total number of port opened and maybe closed. Historical view.
+-    fOpenPortNumber = 0;	// The current number of opened port.
++    fTotalPortNumber = 1;       // The total number of port opened and maybe closed. Historical view.
++    fOpenPortNumber = 0;        // The current number of opened port.
+     fIsActivated = 0;
+     fIsDeactivated = 0;
+     fIsClosed = 0;
+@@ -78,9 +78,9 @@
+     delete fClient;
+ }
+ 
+-int JackDebugClient::Open(const char* server_name, const char* name, jack_options_t options, jack_status_t* status)
++int JackDebugClient::Open(const char* server_name, const char* name, int uuid, jack_options_t options, jack_status_t* status)
+ {
+-    int res = fClient->Open(server_name, name, options, status);
++    int res = fClient->Open(server_name, name, uuid, options, status);
+     char provstr[256];
+     char buffer[256];
+     time_t curtime;
+@@ -210,8 +210,8 @@
+     int res = fClient->PortUnRegister(port_index);
+     fOpenPortNumber--;
+     int i;
+-    for (i = (fTotalPortNumber - 1); i >= 0; i--) {	// We search the record into the history
+-        if (fPortList[i].idport == port_index) {		// We found the last record
++    for (i = (fTotalPortNumber - 1); i >= 0; i--) {     // We search the record into the history
++        if (fPortList[i].idport == port_index) {                // We found the last record
+             if (fPortList[i].IsUnregistered != 0)
+                 *fStream << "!!! ERROR !!! : '" << fClientName << "' id deregistering port '" << fPortList[i].name << "' that have already been unregistered !" << endl;
+             fPortList[i].IsUnregistered++;
+@@ -233,8 +233,8 @@
+         *fStream << "!!! ERROR !!! Trying to connect a port ( " << src << " to " << dst << ") while the client has not been activated !" << endl;
+     int i;
+     int res = fClient->PortConnect( src, dst);
+-    for (i = (fTotalPortNumber - 1); i >= 0; i--) {	// We search the record into the history
+-        if (strcmp(fPortList[i].name, src) == 0) {	// We found the last record in sources
++    for (i = (fTotalPortNumber - 1); i >= 0; i--) {     // We search the record into the history
++        if (strcmp(fPortList[i].name, src) == 0) {      // We found the last record in sources
+             if (fPortList[i].IsUnregistered != 0)
+                 *fStream << "!!! ERROR !!! Connecting port " << src << " previoulsy unregistered !" << endl;
+             fPortList[i].IsConnected++;
+@@ -293,8 +293,8 @@
+         *fStream << "!!! ERROR !!! : Trying to disconnect port  " << src << " while that client has not been activated !" << endl;
+     int res = fClient->PortDisconnect(src);
+     int i;
+-    for (i = (fTotalPortNumber - 1); i >= 0; i--) {		// We search the record into the history
+-        if (fPortList[i].idport == src) {				// We found the record in sources
++    for (i = (fTotalPortNumber - 1); i >= 0; i--) {             // We search the record into the history
++        if (fPortList[i].idport == src) {                               // We found the record in sources
+             if (fPortList[i].IsUnregistered != 0)
+                 *fStream << "!!! ERROR !!! : Disconnecting port  " << src << " previoulsy unregistered !" << endl;
+             fPortList[i].IsConnected--;
+--- a/common/JackDebugClient.h
++++ b/common/JackDebugClient.h
+@@ -53,8 +53,8 @@
+         JackClient* fClient;
+         std::ofstream* fStream;
+         PortFollower fPortList[MAX_PORT_HISTORY]; // Arbitrary value... To be tuned...
+-        int fTotalPortNumber;	// The total number of port opened and maybe closed. Historical view.
+-        int fOpenPortNumber;	// The current number of opened port.
++        int fTotalPortNumber;   // The total number of port opened and maybe closed. Historical view.
++        int fOpenPortNumber;    // The current number of opened port.
+         int fIsActivated;
+         int fIsDeactivated;
+         int fIsClosed;
+@@ -68,7 +68,7 @@
+         JackDebugClient(JackClient* fTheClient);
+         virtual ~JackDebugClient();
+ 
+-        virtual int Open(const char* server_name, const char* name, jack_options_t options, jack_status_t* status);
++        virtual int Open(const char* server_name, const char* name, int uuid, jack_options_t options, jack_status_t* status);
+         int Close();
+ 
+         virtual JackGraphManager* GetGraphManager() const;
+--- a/common/JackDriverLoader.cpp
++++ b/common/JackDriverLoader.cpp
+@@ -32,7 +32,7 @@
+ 
+ jack_driver_desc_t * jackctl_driver_get_desc(jackctl_driver_t * driver);
+ 
+-SERVER_EXPORT void jack_print_driver_options (jack_driver_desc_t* desc, FILE* file)
++EXPORT void jack_print_driver_options (jack_driver_desc_t* desc, FILE* file)
+ {
+     unsigned long i;
+     char arg_default[JACK_DRIVER_PARAM_STRING_MAX + 1];
+@@ -75,7 +75,7 @@
+     fprintf (file, "%s\n", desc->params[param].long_desc);
+ }
+ 
+-SERVER_EXPORT void jack_free_driver_params(JSList * driver_params)
++EXPORT void jack_free_driver_params(JSList * driver_params)
+ {
+     JSList *node_ptr = driver_params;
+     JSList *next_node_ptr;
+@@ -228,7 +228,7 @@
+     return 0;
+ }
+ 
+-SERVER_EXPORT int
++EXPORT int
+ jackctl_parse_driver_params (jackctl_driver *driver_ptr, int argc, char* argv[])
+ {
+     struct option * long_options;
+@@ -436,17 +436,17 @@
+ 
+ #ifdef WIN32
+     if ((so_get_descriptor == NULL) && (dlerr = GetLastError()) != 0) {
+-        jack_log("jack_get_descriptor : dll is not a driver, err = %ld", dlerr);
++        jack_error("jack_get_descriptor : dll is not a driver, err = %ld", dlerr);
+ #else
+     if ((so_get_descriptor == NULL) && (dlerr = dlerror ()) != NULL) {
+-        jack_log("jack_get_descriptor err = %s", dlerr);
++        jack_error("jack_get_descriptor err = %s", dlerr);
+ #endif
+ 
+         UnloadDriverModule(dlhandle);
+         free(filename);
+         return NULL;
+     }
+-
++  
+     if ((descriptor = so_get_descriptor ()) == NULL) {
+         jack_error("driver from '%s' returned NULL descriptor", filename);
+         UnloadDriverModule(dlhandle);
+@@ -467,7 +467,7 @@
+     /* check it doesn't exist already */
+     for (node = drivers; node; node = jack_slist_next (node)) {
+         other_descriptor = (jack_driver_desc_t *) node->data;
+-
++    
+         if (strcmp(descriptor->name, other_descriptor->name) == 0) {
+             jack_error("the drivers in '%s' and '%s' both have the name '%s'; using the first",
+                        other_descriptor->file, filename, other_descriptor->name);
+@@ -563,6 +563,8 @@
+         desc = jack_get_descriptor (drivers, filedata.cFileName, "driver_get_descriptor");
+         if (desc) {
+             driver_list = jack_slist_append (driver_list, desc);
++        } else {
++            jack_error ("jack_get_descriptor returns null for \'%s\'", filedata.cFileName);
+         }
+ 
+     } while (FindNextFile(file, &filedata));
+@@ -601,7 +603,7 @@
+     }
+ 
+     while ((dir_entry = readdir(dir_stream))) {
+-
++    
+         /* check the filename is of the right format */
+         if (strncmp ("jack_", dir_entry->d_name, 5) != 0) {
+             continue;
+@@ -617,8 +619,11 @@
+         }
+ 
+         desc = jack_get_descriptor (drivers, dir_entry->d_name, "driver_get_descriptor");
++         
+         if (desc) {
+             driver_list = jack_slist_append (driver_list, desc);
++        } else {
++            jack_error ("jack_get_descriptor returns null for \'%s\'", dir_entry->d_name);
+         }
+     }
+ 
+@@ -687,6 +692,8 @@
+         desc = jack_get_descriptor (internals, filedata.cFileName, "jack_get_descriptor");
+         if (desc) {
+             driver_list = jack_slist_append (driver_list, desc);
++        } else {
++            jack_error ("jack_get_descriptor returns null for \'%s\'", filedata.cFileName);
+         }
+ 
+     } while (FindNextFile(file, &filedata));
+@@ -743,6 +750,8 @@
+         desc = jack_get_descriptor (internals, dir_entry->d_name, "jack_get_descriptor");
+         if (desc) {
+             driver_list = jack_slist_append (driver_list, desc);
++        } else {
++            jack_error ("jack_get_descriptor returns null for \'%s\'", dir_entry->d_name);
+         }
+     }
+ 
+--- a/common/JackDriverLoader.h
++++ b/common/JackDriverLoader.h
+@@ -68,9 +68,9 @@
+ JSList * jack_drivers_load (JSList * drivers);
+ JSList * jack_internals_load (JSList * internals);
+ 
+-SERVER_EXPORT int jackctl_parse_driver_params (jackctl_driver * driver_ptr, int argc, char* argv[]);
+-SERVER_EXPORT void jack_free_driver_params(JSList * param_ptr);
+-SERVER_EXPORT void jack_print_driver_options(jack_driver_desc_t* desc, FILE* file);
++EXPORT int jackctl_parse_driver_params (jackctl_driver * driver_ptr, int argc, char* argv[]);
++EXPORT void jack_free_driver_params(JSList * param_ptr);
++EXPORT void jack_print_driver_options(jack_driver_desc_t* desc, FILE* file);
+ 
+ #endif
+ 
+--- a/common/JackDummyDriver.cpp
++++ b/common/JackDummyDriver.cpp
+@@ -56,6 +56,12 @@
+         fEngineControl->fPeriod = 0;
+         fEngineControl->fComputation = 500 * 1000;
+         fEngineControl->fConstraint = 500 * 1000;
++        int buffer_size = (fWaitTime * fEngineControl->fSampleRate) / 1000000.0f;
++        if (buffer_size > BUFFER_SIZE_MAX) {
++            buffer_size = BUFFER_SIZE_MAX;
++            jack_error("Buffer size set to %d ", BUFFER_SIZE_MAX);
++        }
++        SetBufferSize(buffer_size);
+         return 0;
+     } else {
+         return -1;
+--- a/common/JackEngine.cpp
++++ b/common/JackEngine.cpp
+@@ -44,12 +44,15 @@
+     fEngineControl = control;
+     for (int i = 0; i < CLIENT_NUM; i++)
+         fClientTable[i] = NULL;
++    fLastSwitchUsecs = 0;
++    fMaxUUID = 0;
++    fSessionPendingReplies = 0;
++    fSessionTransaction = NULL;
++    fSessionResult = NULL;
+ }
+ 
+ JackEngine::~JackEngine()
+-{
+-    jack_log("JackEngine::~JackEngine");
+-}
++{}
+ 
+ int JackEngine::Open()
+ {
+@@ -134,7 +137,7 @@
+ void JackEngine::ProcessNext(jack_time_t cur_cycle_begin)
+ {
+     fLastSwitchUsecs = cur_cycle_begin;
+-    if (fGraphManager->RunNextGraph())	// True if the graph actually switched to a new state
++    if (fGraphManager->RunNextGraph())  // True if the graph actually switched to a new state
+         fChannel.Notify(ALL_CLIENTS, kGraphOrderCallback, 0);
+     fSignal.Signal();                   // Signal for threads waiting for next cycle
+ }
+@@ -386,7 +389,7 @@
+ // Client management
+ //-------------------
+ 
+-int JackEngine::ClientCheck(const char* name, char* name_res, int protocol, int options, int* status)
++int JackEngine::ClientCheck(const char* name, int uuid, char* name_res, int protocol, int options, int* status)
+ {
+     // Clear status
+     *status = 0;
+@@ -400,7 +403,11 @@
+         return -1;
+     }
+ 
+-    if (ClientCheckName(name)) {
++    std::map<int,std::string>::iterator res = fReservationMap.find(uuid);
++
++    if (res != fReservationMap.end()) {
++        strncpy( name_res, res->second.c_str(), JACK_CLIENT_NAME_SIZE );
++    } else if (ClientCheckName(name)) {
+ 
+         *status |= JackNameNotUnique;
+ 
+@@ -426,7 +433,7 @@
+ 
+     if (length > JACK_CLIENT_NAME_SIZE - 4) {
+         jack_error("%s exists and is too long to make unique", name);
+-        return true;		/* failure */
++        return true;            /* failure */
+     }
+ 
+     /*  generate a unique name by appending "-01".."-99" */
+@@ -460,9 +467,32 @@
+             return true;
+     }
+ 
++    for (std::map<int,std::string>::iterator i=fReservationMap.begin(); i!=fReservationMap.end(); i++) {
++        if (i->second == name)
++            return true;
++    }
++
+     return false;
+ }
+ 
++int JackEngine::GetNewUUID()
++{
++    return fMaxUUID++;
++}
++
++void JackEngine::EnsureUUID(int uuid)
++{
++    if (uuid > fMaxUUID)
++        fMaxUUID = uuid+1;
++
++    for (int i = 0; i < CLIENT_NUM; i++) {
++        JackClientInterface* client = fClientTable[i];
++        if (client && (client->GetClientControl()->fSessionID==uuid)) {
++            client->GetClientControl()->fSessionID = GetNewUUID();
++        }
++    }
++}
++
+ int JackEngine::GetClientPID(const char* name)
+ {
+     for (int i = 0; i < CLIENT_NUM; i++) {
+@@ -486,9 +516,26 @@
+ }
+ 
+ // Used for external clients
+-int JackEngine::ClientExternalOpen(const char* name, int pid, int* ref, int* shared_engine, int* shared_client, int* shared_graph_manager)
++int JackEngine::ClientExternalOpen(const char* name, int pid, int uuid, int* ref, int* shared_engine, int* shared_client, int* shared_graph_manager)
+ {
+-    jack_log("JackEngine::ClientExternalOpen: name = %s ", name);
++    char real_name[JACK_CLIENT_NAME_SIZE+1];
++
++    if (uuid < 0) {
++        uuid = GetNewUUID();
++        strncpy( real_name, name, JACK_CLIENT_NAME_SIZE );
++    } else {
++        std::map<int,std::string>::iterator res = fReservationMap.find(uuid);
++        if (res != fReservationMap.end()) {
++            strncpy( real_name, res->second.c_str(), JACK_CLIENT_NAME_SIZE );
++            fReservationMap.erase(uuid);
++        } else {
++            strncpy( real_name, name, JACK_CLIENT_NAME_SIZE );
++        }
++
++        EnsureUUID(uuid);
++    }
++
++    jack_log("JackEngine::ClientExternalOpen: uuid=%d, name = %s ", uuid, real_name);
+ 
+     int refnum = AllocateRefnum();
+     if (refnum < 0) {
+@@ -498,12 +545,12 @@
+ 
+     JackExternalClient* client = new JackExternalClient();
+ 
+-    if (!fSynchroTable[refnum].Allocate(name, fEngineControl->fServerName, 0)) {
++    if (!fSynchroTable[refnum].Allocate(real_name, fEngineControl->fServerName, 0)) {
+         jack_error("Cannot allocate synchro");
+         goto error;
+     }
+ 
+-    if (client->Open(name, pid, refnum, shared_client) < 0) {
++    if (client->Open(real_name, pid, refnum, uuid, shared_client) < 0) {
+         jack_error("Cannot open client");
+         goto error;
+     }
+@@ -516,7 +563,7 @@
+ 
+     fClientTable[refnum] = client;
+ 
+-    if (NotifyAddClient(client, name, refnum) < 0) {
++    if (NotifyAddClient(client, real_name, refnum) < 0) {
+         jack_error("Cannot notify add client");
+         goto error;
+     }
+@@ -863,5 +910,135 @@
+     return 0;
+ }
+ 
++void JackEngine::SessionNotify(int refnum, const char *target, jack_session_event_type_t type, const char *path, JackChannelTransaction *socket)
++{
++    if (fSessionPendingReplies != 0) {
++        JackSessionNotifyResult res(-1);
++        res.Write(socket);
++        jack_log("JackEngine::SessionNotify ... busy");
++        return;
++    }
++
++    for (int i = 0; i < CLIENT_NUM; i++) {
++        JackClientInterface* client = fClientTable[i];
++        if (client && (client->GetClientControl()->fSessionID < 0)) {
++            client->GetClientControl()->fSessionID = GetNewUUID();
++        }
++    }
++    fSessionResult = new JackSessionNotifyResult();
++
++    for (int i = 0; i < CLIENT_NUM; i++) {
++        JackClientInterface* client = fClientTable[i];
++        if (client && client->GetClientControl()->fCallback[kSessionCallback]) {
++
++            // check if this is a notification to a specific client.
++            if (target!=NULL && strlen(target)!=0) {
++                if (strcmp(target, client->GetClientControl()->fName)) {
++                    continue;
++                }
++            }
++
++            char path_buf[JACK_PORT_NAME_SIZE];
++            snprintf( path_buf, sizeof(path_buf), "%s%s%c", path, client->GetClientControl()->fName, DIR_SEPARATOR );
++            
++            int res = JackTools::MkDir(path_buf);
++            if (res) 
++                jack_error( "JackEngine::SessionNotify: can not create session directory '%s'", path_buf );
++        
++            int result = client->ClientNotify(i, client->GetClientControl()->fName, kSessionCallback, true, path_buf, (int) type, 0);
++
++            if (result == 2) {
++                fSessionPendingReplies += 1;
++            } else if (result == 1) {
++                char uuid_buf[JACK_UUID_SIZE];
++                snprintf( uuid_buf, sizeof(uuid_buf), "%d", client->GetClientControl()->fSessionID );
++                fSessionResult->fCommandList.push_back( JackSessionCommand( uuid_buf, 
++                                                                            client->GetClientControl()->fName,
++                                                                            client->GetClientControl()->fSessionCommand, 
++                                                                            client->GetClientControl()->fSessionFlags ));
++            }
++        }
++    }
++
++    if (fSessionPendingReplies == 0) {
++        fSessionResult->Write(socket);
++        delete fSessionResult;
++        fSessionResult = NULL;
++    } else {
++        fSessionTransaction = socket;
++    }
++}
++
++void JackEngine::SessionReply(int refnum)
++{
++    JackClientInterface* client = fClientTable[refnum];
++    char uuid_buf[JACK_UUID_SIZE];
++    snprintf( uuid_buf, sizeof(uuid_buf), "%d", client->GetClientControl()->fSessionID );
++    fSessionResult->fCommandList.push_back( JackSessionCommand( uuid_buf, 
++                                                                client->GetClientControl()->fName,
++                                                                client->GetClientControl()->fSessionCommand, 
++                                                                client->GetClientControl()->fSessionFlags ));
++    fSessionPendingReplies -= 1;
++
++    if (fSessionPendingReplies == 0) {
++        fSessionResult->Write(fSessionTransaction);
++        delete fSessionResult;
++        fSessionResult = NULL;
++    }
++}
++
++void JackEngine::GetUUIDForClientName(const char *client_name, char *uuid_res, int *result)
++{
++    for (int i = 0; i < CLIENT_NUM; i++) {
++        JackClientInterface* client = fClientTable[i];
++
++        if (client && (strcmp(client_name, client->GetClientControl()->fName)==0)) {
++            snprintf(uuid_res, JACK_UUID_SIZE, "%d", client->GetClientControl()->fSessionID);
++            *result = 0;
++            return;
++        }
++    }
++    // did not find name.
++    *result = -1;
++    return;
++}
++
++void JackEngine::GetClientNameForUUID(const char *uuid, char *name_res, int *result)
++{
++    for (int i = 0; i < CLIENT_NUM; i++) {
++        JackClientInterface* client = fClientTable[i];
++
++        if (!client)
++            continue;
++
++        char uuid_buf[JACK_UUID_SIZE];
++        snprintf(uuid_buf, JACK_UUID_SIZE, "%d", client->GetClientControl()->fSessionID);
++
++        if (strcmp(uuid,uuid_buf) == 0) {
++            strncpy(name_res, client->GetClientControl()->fName, JACK_CLIENT_NAME_SIZE);
++            *result = 0;
++            return;
++        }
++    }
++    // did not find uuid.
++    *result = -1;
++    return;
++}
++
++void JackEngine::ReserveClientName(const char *name, const char *uuid, int *result)
++{
++    jack_log( "JackEngine::ReserveClientName ( name = %s, uuid = %s )", name, uuid );
++
++    if (ClientCheckName(name)) {
++        *result = -1;
++        jack_log( "name already taken" );
++        return;
++    }
++
++    EnsureUUID(atoi(uuid));
++    fReservationMap[atoi(uuid)] = name;
++    *result = 0;
++}
++
+ } // end of namespace
+ 
+--- a/common/JackEngine.h
++++ b/common/JackEngine.h
+@@ -26,6 +26,7 @@
+ #include "JackMutex.h"
+ #include "JackTransportEngine.h"
+ #include "JackPlatformPlug.h"
++#include <map>
+ 
+ namespace Jack
+ {
+@@ -41,7 +42,7 @@
+ class SERVER_EXPORT JackEngine : public JackLockAble
+ {
+     friend class JackLockedEngine;
+-    
++
+     private:
+ 
+         JackGraphManager* fGraphManager;
+@@ -52,6 +53,12 @@
+         JackProcessSync fSignal;
+         jack_time_t fLastSwitchUsecs;
+ 
++        int fSessionPendingReplies;
++        JackChannelTransaction *fSessionTransaction;
++        JackSessionNotifyResult *fSessionResult;
++        std::map<int,std::string> fReservationMap;
++        int fMaxUUID;
++
+         int ClientCloseAux(int refnum, JackClientInterface* client, bool wait);
+         void CheckXRun(jack_time_t callback_usecs);
+ 
+@@ -69,12 +76,15 @@
+ 
+         void NotifyClient(int refnum, int event, int sync, const char*  message, int value1, int value2);
+         void NotifyClients(int event, int sync, const char*  message,  int value1, int value2);
+-    
++
+         void NotifyPortRegistation(jack_port_id_t port_index, bool onoff);
+         void NotifyPortConnect(jack_port_id_t src, jack_port_id_t dst, bool onoff);
+         void NotifyPortRename(jack_port_id_t src, const char* old_name);
+         void NotifyActivate(int refnum);
+-        
++
++        int GetNewUUID();
++        void EnsureUUID(int uuid);
++
+         bool CheckClient(int refnum)
+         {
+             return (refnum >= 0 && refnum < CLIENT_NUM && fClientTable[refnum] != NULL);
+@@ -87,10 +97,10 @@
+ 
+         int Open();
+         int Close();
+-  
++
+         // Client management
+-        int ClientCheck(const char* name, char* name_res, int protocol, int options, int* status);
+-        int ClientExternalOpen(const char* name, int pid, int* ref, int* shared_engine, int* shared_client, int* shared_graph_manager);
++        int ClientCheck(const char* name, int uuid, char* name_res, int protocol, int options, int* status);
++        int ClientExternalOpen(const char* name, int pid, int uuid, int* ref, int* shared_engine, int* shared_client, int* shared_graph_manager);
+         int ClientInternalOpen(const char* name, int* ref, JackEngineControl** shared_engine, JackGraphManager** shared_manager, JackClientInterface* client, bool wait);
+ 
+         int ClientExternalClose(int refnum);
+@@ -98,10 +108,10 @@
+ 
+         int ClientActivate(int refnum, bool is_real_time);
+         int ClientDeactivate(int refnum);
+-    
++
+         int GetClientPID(const char* name);
+         int GetClientRefNum(const char* name);
+-    
++
+         // Internal client management
+         int GetInternalClientName(int int_ref, char* name_res);
+         int InternalClientHandle(const char* client_name, int* status, int* int_ref);
+@@ -116,7 +126,7 @@
+ 
+         int PortConnect(int refnum, jack_port_id_t src, jack_port_id_t dst);
+         int PortDisconnect(int refnum, jack_port_id_t src, jack_port_id_t dst);
+-        
++
+         int PortRename(int refnum, jack_port_id_t port, const char* name);
+ 
+         // Graph
+@@ -131,6 +141,13 @@
+         void NotifySampleRate(jack_nframes_t sample_rate);
+         void NotifyFreewheel(bool onoff);
+         void NotifyQuit();
++
++        void SessionNotify( int refnum, const char *target, jack_session_event_type_t type, const char *path, JackChannelTransaction *socket );
++        void SessionReply( int refnum );
++
++        void GetUUIDForClientName(const char *client_name, char *uuid_res, int *result);
++        void GetClientNameForUUID(const char *uuid, char *name_res, int *result);
++        void ReserveClientName(const char *name, const char *uuid, int *result);
+ };
+ 
+ 
+--- a/common/JackError.cpp
++++ b/common/JackError.cpp
+@@ -33,7 +33,7 @@
+             && jack_tls_set(JackGlobals::fKeyLogFunction, (void*)log_function));
+ }
+ 
+-SERVER_EXPORT int set_threaded_log_function()
++EXPORT int set_threaded_log_function()
+ {
+     return change_thread_log_function(JackMessageBufferAdd);
+ }
+@@ -88,7 +88,7 @@
+     log_function(level, buffer);
+ }
+ 
+-SERVER_EXPORT void jack_error(const char *fmt, ...)
++EXPORT void jack_error(const char *fmt, ...)
+ {
+ 	va_list ap;
+ 	va_start(ap, fmt);
+@@ -96,7 +96,7 @@
+ 	va_end(ap);
+ }
+ 
+-SERVER_EXPORT void jack_info(const char *fmt, ...)
++EXPORT void jack_info(const char *fmt, ...)
+ {
+ 	va_list ap;
+ 	va_start(ap, fmt);
+@@ -104,7 +104,7 @@
+ 	va_end(ap);
+ }
+ 
+-SERVER_EXPORT void jack_log(const char *fmt,...)
++EXPORT void jack_log(const char *fmt,...)
+ {
+ 	if (JackGlobals::fVerbose) {
+ 		va_list ap;
+@@ -114,23 +114,23 @@
+ 	}
+ }
+ 
+-SERVER_EXPORT void default_jack_error_callback(const char *desc)
++EXPORT void default_jack_error_callback(const char *desc)
+ {
+     fprintf(stderr, "%s\n", desc);
+     fflush(stderr);
+ }
+ 
+-SERVER_EXPORT void default_jack_info_callback(const char *desc)
++EXPORT void default_jack_info_callback(const char *desc)
+ {
+     fprintf(stdout, "%s\n", desc);
+     fflush(stdout);
+ }
+ 
+-SERVER_EXPORT void silent_jack_error_callback(const char *desc)
++EXPORT void silent_jack_error_callback(const char *desc)
+ {}
+ 
+-SERVER_EXPORT void silent_jack_info_callback(const char *desc)
++EXPORT void silent_jack_info_callback(const char *desc)
+ {}
+ 
+-SERVER_EXPORT void (*jack_error_callback)(const char *desc) = &default_jack_error_callback;
+-SERVER_EXPORT void (*jack_info_callback)(const char *desc) = &default_jack_info_callback;
++EXPORT void (*jack_error_callback)(const char *desc) = &default_jack_error_callback;
++EXPORT void (*jack_info_callback)(const char *desc) = &default_jack_info_callback;
+--- a/common/JackError.h
++++ b/common/JackError.h
+@@ -35,27 +35,27 @@
+ #define LOG_LEVEL_INFO   1
+ #define LOG_LEVEL_ERROR  2
+ 
+-    SERVER_EXPORT void jack_error(const char *fmt, ...);
++    EXPORT void jack_error(const char *fmt, ...);
+ 
+-    SERVER_EXPORT void jack_info(const char *fmt, ...);
++    EXPORT void jack_info(const char *fmt, ...);
+ 
+     // like jack_info() but only if verbose mode is enabled
+-    SERVER_EXPORT void jack_log(const char *fmt, ...);
++    EXPORT void jack_log(const char *fmt, ...);
+ 
+-    SERVER_EXPORT extern void (*jack_error_callback)(const char *desc);
+-    SERVER_EXPORT extern void (*jack_info_callback)(const char *desc);
++    EXPORT extern void (*jack_error_callback)(const char *desc);
++    EXPORT extern void (*jack_info_callback)(const char *desc);
+     
+-    SERVER_EXPORT extern void default_jack_error_callback(const char *desc);
+-    SERVER_EXPORT extern void default_jack_info_callback(const char *desc);
++    EXPORT extern void default_jack_error_callback(const char *desc);
++    EXPORT extern void default_jack_info_callback(const char *desc);
+     
+-    SERVER_EXPORT extern void silent_jack_error_callback(const char *desc);
+-    SERVER_EXPORT extern void silent_jack_info_callback(const char *desc);
++    EXPORT extern void silent_jack_error_callback(const char *desc);
++    EXPORT extern void silent_jack_info_callback(const char *desc);
+ 
+     typedef void (* jack_log_function_t)(int level, const char *message);
+ 
+     void jack_log_function(int level, const char *message);
+    
+-    SERVER_EXPORT int set_threaded_log_function();
++    EXPORT int set_threaded_log_function();
+ 
+ #ifdef __cplusplus
+ }
+--- a/common/JackExternalClient.cpp
++++ b/common/JackExternalClient.cpp
+@@ -41,7 +41,7 @@
+     return result;
+ }
+ 
+-int JackExternalClient::Open(const char* name, int pid, int refnum, int* shared_client)
++int JackExternalClient::Open(const char* name, int pid, int refnum, int uuid, int* shared_client)
+ {
+     try {
+ 
+@@ -53,7 +53,7 @@
+         // Use "placement new" to allocate object in shared memory
+         JackShmMemAble* shared_mem = static_cast<JackShmMemAble*>(JackShmMem::operator new(sizeof(JackClientControl)));
+         shared_mem->Init();
+-        fClientControl = new(shared_mem) JackClientControl(name, pid, refnum);
++        fClientControl = new(shared_mem) JackClientControl(name, pid, refnum, uuid);
+       
+         if (!fClientControl) {
+             jack_error("Cannot allocate client shared memory segment");
+--- a/common/JackExternalClient.h
++++ b/common/JackExternalClient.h
+@@ -39,14 +39,14 @@
+     private:
+ 
+         JackNotifyChannel fChannel;   /*! Server/client communication channel */
+-        JackClientControl*	fClientControl;     /*! Client control in shared memory     */
++        JackClientControl*      fClientControl;     /*! Client control in shared memory     */
+ 
+     public:
+ 
+         JackExternalClient();
+         virtual ~JackExternalClient();
+ 
+-        int Open(const char* name, int pid, int refnum, int* shared_client);
++        int Open(const char* name, int pid, int refnum, int uuid, int* shared_client);
+         int Close();
+ 
+         int ClientNotify(int refnum, const char* name, int notify, int sync, const char* message, int value1, int value2);
+--- a/common/JackInternalClient.cpp
++++ b/common/JackInternalClient.cpp
+@@ -63,7 +63,7 @@
+     delete fChannel;
+ }
+ 
+-int JackInternalClient::Open(const char* server_name, const char* name, jack_options_t options, jack_status_t* status)
++int JackInternalClient::Open(const char* server_name, const char* name, int uuid, jack_options_t options, jack_status_t* status)
+ {
+     int result;
+     char name_res[JACK_CLIENT_NAME_SIZE + 1];
+@@ -71,7 +71,7 @@
+ 
+     strncpy(fServerName, server_name, sizeof(fServerName));
+ 
+-    fChannel->ClientCheck(name, name_res, JACK_PROTOCOL_VERSION, (int)options, (int*)status, &result);
++    fChannel->ClientCheck(name, uuid, name_res, JACK_PROTOCOL_VERSION, (int)options, (int*)status, &result);
+     if (result < 0) {
+         int status1 = *status;
+         if (status1 & JackVersionError)
+@@ -198,11 +198,11 @@
+         UnloadJackModule(fHandle);
+ }
+ 
+-int JackLoadableInternalClient1::Open(const char* server_name, const char* name, jack_options_t options, jack_status_t* status)
++int JackLoadableInternalClient1::Open(const char* server_name, const char* name, int uuid, jack_options_t options, jack_status_t* status)
+ {
+     int res = -1;
+     
+-    if (JackInternalClient::Open(server_name, name, options, status) == 0) {
++    if (JackInternalClient::Open(server_name, name, uuid, options, status) == 0) {
+         if (fInitialize((jack_client_t*)this, fObjectData) == 0) {
+             res = 0;
+         } else {
+@@ -214,11 +214,11 @@
+     return res;
+ }
+ 
+-int JackLoadableInternalClient2::Open(const char* server_name, const char* name, jack_options_t options, jack_status_t* status)
++int JackLoadableInternalClient2::Open(const char* server_name, const char* name, int uuid, jack_options_t options, jack_status_t* status)
+ {
+     int res = -1;
+     
+-    if (JackInternalClient::Open(server_name, name, options, status) == 0) {
++    if (JackInternalClient::Open(server_name, name, uuid, options, status) == 0) {
+         if (fInitialize((jack_client_t*)this, fParameters) == 0) {
+             res = 0;
+         } else {
+--- a/common/JackInternalClient.h
++++ b/common/JackInternalClient.h
+@@ -46,14 +46,14 @@
+         JackInternalClient(JackServer* server, JackSynchro* table);
+         virtual ~JackInternalClient();
+ 
+-        int Open(const char* server_name, const char* name, jack_options_t options, jack_status_t* status);
++        int Open(const char* server_name, const char* name, int uuid, jack_options_t options, jack_status_t* status);
+ 
+         JackGraphManager* GetGraphManager() const;
+         JackEngineControl* GetEngineControl() const;
+         JackClientControl* GetClientControl() const;
+ 
+-        static JackGraphManager* fGraphManager;		/*! Shared memory Port manager */
+-        static JackEngineControl* fEngineControl;	/*! Shared engine cotrol */
++        static JackGraphManager* fGraphManager;         /*! Shared memory Port manager */
++        static JackEngineControl* fEngineControl;       /*! Shared engine cotrol */
+ };
+ 
+ /*!
+@@ -100,7 +100,7 @@
+         {}
+ 
+         int Init(const char* so_name);
+-        int Open(const char* server_name, const char* name, jack_options_t options, jack_status_t* status);
++        int Open(const char* server_name, const char* name, int uuid, jack_options_t options, jack_status_t* status);
+ 
+ };
+ 
+@@ -119,7 +119,7 @@
+         {}
+ 
+         int Init(const char* so_name);
+-        int Open(const char* server_name, const char* name, jack_options_t options, jack_status_t* status);
++        int Open(const char* server_name, const char* name, int uuid, jack_options_t options, jack_status_t* status);
+ 
+ };
+ 
+--- a/common/JackInternalClientChannel.h
++++ b/common/JackInternalClientChannel.h
+@@ -50,9 +50,9 @@
+             return 0;
+         }
+ 
+-        void ClientCheck(const char* name, char* name_res, int protocol, int options, int* status, int* result)
++        void ClientCheck(const char* name, int uuid, char* name_res, int protocol, int options, int* status, int* result)
+         {
+-            *result = fEngine->ClientCheck(name, name_res, protocol, options, status);
++            *result = fEngine->ClientCheck(name, uuid, name_res, protocol, options, status);
+         }
+         void ClientOpen(const char* name, int* ref, JackEngineControl** shared_engine, JackGraphManager** shared_manager, JackClientInterface* client, int* result)
+         {
+@@ -112,6 +112,11 @@
+             *result = fServer->SetFreewheel(onoff);
+         }
+ 
++        void SessionNotify( int refnum, const char *target, jack_session_event_type_t type, const char *path, jack_session_command_t **result )
++        {
++            *result = NULL;
++        }
++
+         void ReleaseTimebase(int refnum, int* result)
+         {
+             *result = fServer->ReleaseTimebase(refnum);
+@@ -132,9 +137,9 @@
+             *result = fEngine->InternalClientHandle(client_name, status, int_ref);
+         }
+ 
+-        void InternalClientLoad(int refnum, const char* client_name, const char* so_name, const char* objet_data, int options, int* status, int* int_ref, int* result)
++        void InternalClientLoad(int refnum, const char* client_name, const char* so_name, const char* objet_data, int options, int* status, int* int_ref, int uuid, int* result)
+         {
+-            *result = fServer->InternalClientLoad(client_name, so_name, objet_data, options, int_ref, status);	
++            *result = fServer->InternalClientLoad(client_name, so_name, objet_data, options, int_ref, uuid, status);    
+         }
+ 
+         void InternalClientUnload(int refnum, int int_ref, int* status, int* result)
+--- a/common/JackLibAPI.cpp
++++ b/common/JackLibAPI.cpp
+@@ -57,7 +57,7 @@
+ 
+ jack_client_t* jack_client_new_aux(const char* client_name, jack_options_t options, jack_status_t* status)
+ {
+-    jack_varargs_t va;		/* variable arguments */
++    jack_varargs_t va;          /* variable arguments */
+     jack_status_t my_status;
+     JackClient* client;
+  
+@@ -68,8 +68,8 @@
+ 
+     jack_log("jack_client_new %s", client_name);
+    
+-    if (status == NULL)			/* no status from caller? */
+-        status = &my_status;	/* use local status word */
++    if (status == NULL)         /* no status from caller? */
++        status = &my_status;    /* use local status word */
+     *status = (jack_status_t)0;
+ 
+     /* validate parameters */
+@@ -96,7 +96,7 @@
+         client = new JackLibClient(GetSynchroTable());
+     }
+ 
+-    int res = client->Open(va.server_name, client_name, options, status);
++    int res = client->Open(va.server_name, client_name, va.session_id, options, status);
+     if (res < 0) {
+         delete client;
+         JackLibGlobals::Destroy(); // jack library destruction
+@@ -149,7 +149,7 @@
+         client = new JackLibClient(GetSynchroTable());
+     }
+ 
+-    int res = client->Open(va.server_name, client_name, options, status);
++    int res = client->Open(va.server_name, client_name, va.session_id, options, status);
+     if (res < 0) {
+         delete client;
+         JackLibGlobals::Destroy(); // jack library destruction
+--- a/common/JackLibClient.cpp
++++ b/common/JackLibClient.cpp
+@@ -67,7 +67,7 @@
+     delete fChannel;
+ }
+ 
+-int JackLibClient::Open(const char* server_name, const char* name, jack_options_t options, jack_status_t* status)
++int JackLibClient::Open(const char* server_name, const char* name, int uuid, jack_options_t options, jack_status_t* status)
+ {
+     int shared_engine, shared_client, shared_graph, result;
+     jack_log("JackLibClient::Open name = %s", name);
+@@ -76,7 +76,7 @@
+ 
+     // Open server/client channel
+     char name_res[JACK_CLIENT_NAME_SIZE + 1];
+-    if (fChannel->Open(server_name, name, name_res, this, options, status) < 0) {
++    if (fChannel->Open(server_name, name, uuid, name_res, this, options, status) < 0) {
+         jack_error("Cannot connect to the server");
+         goto error;
+     }
+@@ -88,7 +88,7 @@
+     }
+ 
+     // Require new client
+-    fChannel->ClientOpen(name_res, JackTools::GetPID(), &shared_engine, &shared_client, &shared_graph, &result);
++    fChannel->ClientOpen(name_res, JackTools::GetPID(), uuid, &shared_engine, &shared_client, &shared_graph, &result);
+     if (result < 0) {
+         jack_error("Cannot open %s client", name_res);
+         goto error;
+--- a/common/JackLibClient.h
++++ b/common/JackLibClient.h
+@@ -37,14 +37,14 @@
+ 
+     private:
+ 
+-        JackShmReadWritePtr1<JackClientControl>	fClientControl;	/*! Shared client control */
++        JackShmReadWritePtr1<JackClientControl> fClientControl; /*! Shared client control */
+ 
+     public:
+ 
+         JackLibClient(JackSynchro* table);
+         virtual ~JackLibClient();
+ 
+-        int Open(const char* server_name, const char* name, jack_options_t options, jack_status_t* status);
++        int Open(const char* server_name, const char* name, int uuid, jack_options_t options, jack_status_t* status);
+ 
+         int ClientNotifyImp(int refnum, const char* name, int notify, int sync, const char* message, int value1, int value2);
+ 
+--- a/common/JackLockedEngine.h
++++ b/common/JackLockedEngine.h
+@@ -96,18 +96,18 @@
+         }
+     
+         // Client management
+-        int ClientCheck(const char* name, char* name_res, int protocol, int options, int* status)
++        int ClientCheck(const char* name, int uuid, char* name_res, int protocol, int options, int* status)
+         {
+             TRY_CALL
+             JackLock lock(&fEngine);
+-            return fEngine.ClientCheck(name, name_res, protocol, options, status);
++            return fEngine.ClientCheck(name, uuid, name_res, protocol, options, status);
+             CATCH_EXCEPTION_RETURN
+         }
+-        int ClientExternalOpen(const char* name, int pid, int* ref, int* shared_engine, int* shared_client, int* shared_graph_manager)
++        int ClientExternalOpen(const char* name, int pid, int uuid, int* ref, int* shared_engine, int* shared_client, int* shared_graph_manager)
+         {
+             TRY_CALL
+             JackLock lock(&fEngine);
+-            return fEngine.ClientExternalOpen(name, pid, ref, shared_engine, shared_client, shared_graph_manager);
++            return fEngine.ClientExternalOpen(name, pid, uuid, ref, shared_engine, shared_client, shared_graph_manager);
+             CATCH_EXCEPTION_RETURN
+         }
+         int ClientInternalOpen(const char* name, int* ref, JackEngineControl** shared_engine, JackGraphManager** shared_manager, JackClientInterface* client, bool wait)
+@@ -306,7 +306,44 @@
+             return fEngine.NotifyQuit();
+             CATCH_EXCEPTION
+         }
++
++        void SessionNotify(int refnum, const char* target, jack_session_event_type_t type, const char *path, JackChannelTransaction *socket)
++        {
++            TRY_CALL
++            JackLock lock(&fEngine);
++            fEngine.SessionNotify(refnum, target, type, path, socket);
++            CATCH_EXCEPTION
++        }
++ 
++        void SessionReply(int refnum)
++        {
++            TRY_CALL
++            JackLock lock(&fEngine);
++            fEngine.SessionReply(refnum);
++            CATCH_EXCEPTION
++        }
+  
++        void GetUUIDForClientName(const char *client_name, char *uuid_res, int *result)
++        {
++            TRY_CALL
++            JackLock lock(&fEngine);
++            fEngine.GetUUIDForClientName(client_name, uuid_res, result);
++            CATCH_EXCEPTION
++        }
++        void GetClientNameForUUID(const char *uuid, char *name_res, int *result)
++        {
++            TRY_CALL
++            JackLock lock(&fEngine);
++            fEngine.GetClientNameForUUID(uuid, name_res, result);
++            CATCH_EXCEPTION
++        }
++        void ReserveClientName(const char *name, const char *uuid, int *result)
++        {
++            TRY_CALL
++            JackLock lock(&fEngine);
++            fEngine.ReserveClientName(name, uuid, result);
++            CATCH_EXCEPTION
++        }
+ };
+ 
+ } // end of namespace
+--- a/common/JackNetOneDriver.cpp
++++ b/common/JackNetOneDriver.cpp
+@@ -54,36 +54,36 @@
+     {
+         jack_log ( "JackNetOneDriver::JackNetOneDriver port %d", port );
+ 
+-#ifdef WIN32
+-    WSADATA wsa;
+-    int rc = WSAStartup(MAKEWORD(2,0),&wsa);
+-#endif
+-
+-	netjack_init( & (this->netj),
+-		NULL, // client
+-                name,
+-                capture_ports,
+-                playback_ports,
+-                midi_input_ports,
+-                midi_output_ports,
+-                sample_rate,
+-                period_size,
+-                port,
+-                transport_sync,
+-                resample_factor,
+-                0,
+-                bitdepth,
+-		use_autoconfig,
+-		latency,
+-		redundancy,
+-		dont_htonl_floats,
+-		always_deadline,
+-		jitter_val);
++    #ifdef WIN32
++        WSADATA wsa;
++        int rc = WSAStartup(MAKEWORD(2,0),&wsa);
++    #endif
++
++        netjack_init( & (this->netj),
++            NULL, // client
++                    name,
++                    capture_ports,
++                    playback_ports,
++                    midi_input_ports,
++                    midi_output_ports,
++                    sample_rate,
++                    period_size,
++                    port,
++                    transport_sync,
++                    resample_factor,
++                    0,
++                    bitdepth,
++            use_autoconfig,
++            latency,
++            redundancy,
++            dont_htonl_floats,
++            always_deadline,
++            jitter_val);
+     }
+ 
+     JackNetOneDriver::~JackNetOneDriver()
+     {
+-	// No destructor yet.
++        // No destructor yet.
+     }
+ 
+ //open, close, attach and detach------------------------------------------------------
+@@ -135,49 +135,49 @@
+ 
+     int JackNetOneDriver::AllocPorts()
+     {
+-	jack_port_id_t port_id;
+-	char buf[64];
+-	unsigned int chn;
++        jack_port_id_t port_id;
++        char buf[64];
++        unsigned int chn;
+ 
+-	//if (netj.handle_transport_sync)
+-	//    jack_set_sync_callback(netj.client, (JackSyncCallback) net_driver_sync_cb, NULL);
++        //if (netj.handle_transport_sync)
++        //    jack_set_sync_callback(netj.client, (JackSyncCallback) net_driver_sync_cb, NULL);
+ 
+-	for (chn = 0; chn < netj.capture_channels_audio; chn++) {
+-	    snprintf (buf, sizeof(buf) - 1, "system:capture_%u", chn + 1);
++        for (chn = 0; chn < netj.capture_channels_audio; chn++) {
++            snprintf (buf, sizeof(buf) - 1, "system:capture_%u", chn + 1);
+ 
+-            if ( ( port_id = fGraphManager->AllocatePort ( fClientControl.fRefNum, buf, JACK_DEFAULT_AUDIO_TYPE,
+-                             CaptureDriverFlags, fEngineControl->fBufferSize ) ) == NO_PORT )
+-            {
+-                jack_error ( "driver: cannot register port for %s", buf );
+-                return -1;
+-            }
+-            //port = fGraphManager->GetPort ( port_id );
++                if ( ( port_id = fGraphManager->AllocatePort ( fClientControl.fRefNum, buf, JACK_DEFAULT_AUDIO_TYPE,
++                                 CaptureDriverFlags, fEngineControl->fBufferSize ) ) == NO_PORT )
++                {
++                    jack_error ( "driver: cannot register port for %s", buf );
++                    return -1;
++                }
++                //port = fGraphManager->GetPort ( port_id );
+ 
+-	    netj.capture_ports =
+-		jack_slist_append (netj.capture_ports, (void *)(intptr_t)port_id);
++            netj.capture_ports =
++            jack_slist_append (netj.capture_ports, (void *)(intptr_t)port_id);
+ 
+-	    if( netj.bitdepth == CELT_MODE ) {
+-#if HAVE_CELT
+-#if HAVE_CELT_API_0_7
+-	    celt_int32 lookahead;
+-	    CELTMode *celt_mode = celt_mode_create( netj.sample_rate, netj.period_size, NULL );
+-	    netj.capture_srcs = jack_slist_append(netj.capture_srcs, celt_decoder_create( celt_mode, 1, NULL ) );
+-#else
+-	    celt_int32_t lookahead;
+-	    CELTMode *celt_mode = celt_mode_create( netj.sample_rate, 1, netj.period_size, NULL );
+-	    netj.capture_srcs = jack_slist_append(netj.capture_srcs, celt_decoder_create( celt_mode ) );
+-#endif
+-	    celt_mode_info( celt_mode, CELT_GET_LOOKAHEAD, &lookahead );
+-	    netj.codec_latency = 2*lookahead;
+-#endif
+-	    } else {
+-#if HAVE_SAMPLERATE
+-		netj.capture_srcs = jack_slist_append(netj.capture_srcs, (void *)src_new(SRC_LINEAR, 1, NULL));
+-#endif
+-	    }
+-	}
+-	for (chn = netj.capture_channels_audio; chn < netj.capture_channels; chn++) {
+-	    snprintf (buf, sizeof(buf) - 1, "system:capture_%u", chn + 1);
++            if( netj.bitdepth == CELT_MODE ) {
++    #if HAVE_CELT
++    #if HAVE_CELT_API_0_7
++            celt_int32 lookahead;
++            CELTMode *celt_mode = celt_mode_create( netj.sample_rate, netj.period_size, NULL );
++            netj.capture_srcs = jack_slist_append(netj.capture_srcs, celt_decoder_create( celt_mode, 1, NULL ) );
++    #else
++            celt_int32_t lookahead;
++            CELTMode *celt_mode = celt_mode_create( netj.sample_rate, 1, netj.period_size, NULL );
++            netj.capture_srcs = jack_slist_append(netj.capture_srcs, celt_decoder_create( celt_mode ) );
++    #endif
++            celt_mode_info( celt_mode, CELT_GET_LOOKAHEAD, &lookahead );
++            netj.codec_latency = 2*lookahead;
++    #endif
++            } else {
++    #if HAVE_SAMPLERATE
++            netj.capture_srcs = jack_slist_append(netj.capture_srcs, (void *)src_new(SRC_LINEAR, 1, NULL));
++    #endif
++            }
++        }
++        for (chn = netj.capture_channels_audio; chn < netj.capture_channels; chn++) {
++            snprintf (buf, sizeof(buf) - 1, "system:capture_%u", chn + 1);
+ 
+             if ( ( port_id = fGraphManager->AllocatePort ( fClientControl.fRefNum, buf, JACK_DEFAULT_MIDI_TYPE,
+                              CaptureDriverFlags, fEngineControl->fBufferSize ) ) == NO_PORT )
+@@ -187,12 +187,12 @@
+             }
+             //port = fGraphManager->GetPort ( port_id );
+ 
+-	    netj.capture_ports =
+-		jack_slist_append (netj.capture_ports, (void *)(intptr_t)port_id);
+-	}
++            netj.capture_ports =
++            jack_slist_append (netj.capture_ports, (void *)(intptr_t)port_id);
++        }
+ 
+-	for (chn = 0; chn < netj.playback_channels_audio; chn++) {
+-	    snprintf (buf, sizeof(buf) - 1, "system:playback_%u", chn + 1);
++        for (chn = 0; chn < netj.playback_channels_audio; chn++) {
++            snprintf (buf, sizeof(buf) - 1, "system:playback_%u", chn + 1);
+ 
+             if ( ( port_id = fGraphManager->AllocatePort ( fClientControl.fRefNum, buf, JACK_DEFAULT_AUDIO_TYPE,
+                              PlaybackDriverFlags, fEngineControl->fBufferSize ) ) == NO_PORT )
+@@ -202,27 +202,27 @@
+             }
+             //port = fGraphManager->GetPort ( port_id );
+ 
+-	    netj.playback_ports =
+-		jack_slist_append (netj.playback_ports, (void *)(intptr_t)port_id);
++            netj.playback_ports =
++            jack_slist_append (netj.playback_ports, (void *)(intptr_t)port_id);
+ 
+-	    if( netj.bitdepth == CELT_MODE ) {
+-#if HAVE_CELT
+-#if HAVE_CELT_API_0_7
+-	    CELTMode *celt_mode = celt_mode_create( netj.sample_rate, netj.period_size, NULL );
+-	    netj.playback_srcs = jack_slist_append(netj.playback_srcs, celt_encoder_create( celt_mode, 1, NULL ) );
+-#else
+-	    CELTMode *celt_mode = celt_mode_create( netj.sample_rate, 1, netj.period_size, NULL );
+-	    netj.playback_srcs = jack_slist_append(netj.playback_srcs, celt_encoder_create( celt_mode ) );
+-#endif
+-#endif
+-	    } else {
+-#if HAVE_SAMPLERATE
+-		netj.playback_srcs = jack_slist_append(netj.playback_srcs, (void *)src_new(SRC_LINEAR, 1, NULL));
+-#endif
+-	    }
+-	}
+-	for (chn = netj.playback_channels_audio; chn < netj.playback_channels; chn++) {
+-	    snprintf (buf, sizeof(buf) - 1, "system:playback_%u", chn + 1);
++            if( netj.bitdepth == CELT_MODE ) {
++    #if HAVE_CELT
++    #if HAVE_CELT_API_0_7
++            CELTMode *celt_mode = celt_mode_create( netj.sample_rate, netj.period_size, NULL );
++            netj.playback_srcs = jack_slist_append(netj.playback_srcs, celt_encoder_create( celt_mode, 1, NULL ) );
++    #else
++            CELTMode *celt_mode = celt_mode_create( netj.sample_rate, 1, netj.period_size, NULL );
++            netj.playback_srcs = jack_slist_append(netj.playback_srcs, celt_encoder_create( celt_mode ) );
++    #endif
++    #endif
++            } else {
++    #if HAVE_SAMPLERATE
++            netj.playback_srcs = jack_slist_append(netj.playback_srcs, (void *)src_new(SRC_LINEAR, 1, NULL));
++    #endif
++            }
++        }
++        for (chn = netj.playback_channels_audio; chn < netj.playback_channels; chn++) {
++            snprintf (buf, sizeof(buf) - 1, "system:playback_%u", chn + 1);
+ 
+             if ( ( port_id = fGraphManager->AllocatePort ( fClientControl.fRefNum, buf, JACK_DEFAULT_MIDI_TYPE,
+                              PlaybackDriverFlags, fEngineControl->fBufferSize ) ) == NO_PORT )
+@@ -232,10 +232,10 @@
+             }
+             //port = fGraphManager->GetPort ( port_id );
+ 
+-	    netj.playback_ports =
+-		jack_slist_append (netj.playback_ports, (void *)(intptr_t)port_id);
+-	}
+-	return 0;
++            netj.playback_ports =
++                jack_slist_append (netj.playback_ports, (void *)(intptr_t)port_id);
++        }
++        return 0;
+     }
+ 
+ //init and restart--------------------------------------------------------------------
+@@ -243,16 +243,16 @@
+     {
+         jack_log ( "JackNetOneDriver::Init()" );
+ 
+-	if( global_packcache != NULL ) {
+-	    FreePorts();
+-	    netjack_release( &netj );
+-	}
++        if( global_packcache != NULL ) {
++            FreePorts();
++            netjack_release( &netj );
++        }
+ 
+         //display some additional infos
+         jack_info ( "NetOne driver started" );
+-	if( netjack_startup( &netj ) ) {
+-	    return false;
+-	}
++        if( netjack_startup( &netj ) ) {
++            return false;
++        }
+ 
+         //register jack ports
+         if ( AllocPorts() != 0 )
+@@ -261,7 +261,6 @@
+             return false;
+         }
+ 
+-
+         //monitor
+         //driver parametering
+         JackAudioDriver::SetBufferSize ( netj.period_size );
+@@ -281,161 +280,160 @@
+ //driver processes--------------------------------------------------------------------
+     int JackNetOneDriver::Read()
+     {
+-	int delay;
+-	delay = netjack_wait( &netj );
+-	if( delay ) {
+-	    NotifyXRun(fBeginDateUst, (float) delay);
+-	    jack_error( "netxruns... duration: %dms", delay/1000 );
+-	}
++        int delay;
++        delay = netjack_wait( &netj );
++        if( delay ) {
++            NotifyXRun(fBeginDateUst, (float) delay);
++            jack_error( "netxruns... duration: %dms", delay/1000 );
++        }
+ 
+-	if( (netj.num_lost_packets * netj.period_size / netj.sample_rate) > 2 )
+-        JackTools::ThrowJackNetException();
++        if( (netj.num_lost_packets * netj.period_size / netj.sample_rate) > 2 )
++            JackTools::ThrowJackNetException();
+ 
+-	//netjack_read( &netj, netj.period_size );
++        //netjack_read( &netj, netj.period_size );
+         JackDriver::CycleTakeBeginTime();
+ 
+-	jack_position_t local_trans_pos;
+-	jack_transport_state_t local_trans_state;
++        jack_position_t local_trans_pos;
++        jack_transport_state_t local_trans_state;
+ 
+-	unsigned int *packet_buf, *packet_bufX;
++        unsigned int *packet_buf, *packet_bufX;
+ 
+-	if( ! netj.packet_data_valid ) {
++        if( ! netj.packet_data_valid ) {
+             jack_log( "data not valid" );
+-	    render_payload_to_jack_ports (netj.bitdepth, NULL, netj.net_period_down, netj.capture_ports, netj.capture_srcs, netj.period_size, netj.dont_htonl_floats );
+-	    return 0;
+-	}
+-	packet_buf = netj.rx_buf;
++            render_payload_to_jack_ports (netj.bitdepth, NULL, netj.net_period_down, netj.capture_ports, netj.capture_srcs, netj.period_size, netj.dont_htonl_floats );
++            return 0;
++        }
++        packet_buf = netj.rx_buf;
+ 
+-	jacknet_packet_header *pkthdr = (jacknet_packet_header *)packet_buf;
++        jacknet_packet_header *pkthdr = (jacknet_packet_header *)packet_buf;
+ 
+-	packet_bufX = packet_buf + sizeof(jacknet_packet_header) / sizeof(jack_default_audio_sample_t);
++        packet_bufX = packet_buf + sizeof(jacknet_packet_header) / sizeof(jack_default_audio_sample_t);
+ 
+-	netj.reply_port = pkthdr->reply_port;
+-	netj.latency = pkthdr->latency;
++        netj.reply_port = pkthdr->reply_port;
++        netj.latency = pkthdr->latency;
+ 
+-	// Special handling for latency=0
+-	if( netj.latency == 0 )
+-	    netj.resync_threshold = 0;
+-	else
+-	    netj.resync_threshold = MIN( 15, pkthdr->latency-1 );
++        // Special handling for latency=0
++        if( netj.latency == 0 )
++            netj.resync_threshold = 0;
++        else
++            netj.resync_threshold = MIN( 15, pkthdr->latency-1 );
+ 
+-	// check whether, we should handle the transport sync stuff, or leave trnasports untouched.
+-	if (netj.handle_transport_sync) {
+-#if 1
+-	    unsigned int compensated_tranport_pos = (pkthdr->transport_frame + (pkthdr->latency * netj.period_size) + netj.codec_latency);
++        // check whether, we should handle the transport sync stuff, or leave trnasports untouched.
++        if (netj.handle_transport_sync) {
++    #if 1
++            unsigned int compensated_tranport_pos = (pkthdr->transport_frame + (pkthdr->latency * netj.period_size) + netj.codec_latency);
+ 
+-	    // read local transport info....
+-	    //local_trans_state = jack_transport_query(netj.client, &local_trans_pos);
++            // read local transport info....
++            //local_trans_state = jack_transport_query(netj.client, &local_trans_pos);
+ 
+             local_trans_state = fEngineControl->fTransport.Query ( &local_trans_pos );
+ 
+-	    // Now check if we have to start or stop local transport to sync to remote...
+-	    switch (pkthdr->transport_state) {
+-		case JackTransportStarting:
+-		    // the master transport is starting... so we set our reply to the sync_callback;
+-		    if (local_trans_state == JackTransportStopped) {
+-			fEngineControl->fTransport.SetCommand ( TransportCommandStart );
+-			//jack_transport_start(netj.client);
+-			//last_transport_state = JackTransportStopped;
+-			netj.sync_state = 0;
+-			jack_info("locally stopped... starting...");
+-		    }
+-
+-		    if (local_trans_pos.frame != compensated_tranport_pos)
+-		    {
+-			jack_position_t new_pos = local_trans_pos;
+-			new_pos.frame = compensated_tranport_pos + 2*netj.period_size;
+-			new_pos.valid = (jack_position_bits_t) 0;
+-
+-
+-			fEngineControl->fTransport.RequestNewPos ( &new_pos );
+-			//jack_transport_locate(netj.client, compensated_tranport_pos);
+-			//last_transport_state = JackTransportRolling;
+-			netj.sync_state = 0;
+-			jack_info("starting locate to %d", compensated_tranport_pos );
+-		    }
+-		    break;
+-		case JackTransportStopped:
+-		    netj.sync_state = 1;
+-		    if (local_trans_pos.frame != (pkthdr->transport_frame)) {
+-			jack_position_t new_pos = local_trans_pos;
+-			new_pos.frame = pkthdr->transport_frame;
+-			new_pos.valid = (jack_position_bits_t)0;
+-			fEngineControl->fTransport.RequestNewPos ( &new_pos );
+-			//jack_transport_locate(netj.client, (pkthdr->transport_frame));
+-			jack_info("transport is stopped locate to %d", pkthdr->transport_frame);
+-		    }
+-		    if (local_trans_state != JackTransportStopped)
+-			//jack_transport_stop(netj.client);
+-			fEngineControl->fTransport.SetCommand ( TransportCommandStop );
+-		    break;
+-		case JackTransportRolling:
+-		    netj.sync_state = 1;
+-//		    if(local_trans_pos.frame != (pkthdr->transport_frame + (pkthdr->latency) * netj.period_size)) {
+-//		        jack_transport_locate(netj.client, (pkthdr->transport_frame + (pkthdr->latency + 2) * netj.period_size));
+-//			jack_info("running locate to %d", pkthdr->transport_frame + (pkthdr->latency)*netj.period_size);
+-//		    		}
+-		    if (local_trans_state != JackTransportRolling)
+-			fEngineControl->fTransport.SetState ( JackTransportRolling );
+-
+-		    break;
+-
+-		case JackTransportLooping:
+-		    break;
+-	    }
++            // Now check if we have to start or stop local transport to sync to remote...
++            switch (pkthdr->transport_state) {
++            case JackTransportStarting:
++                // the master transport is starting... so we set our reply to the sync_callback;
++                if (local_trans_state == JackTransportStopped) {
++                    fEngineControl->fTransport.SetCommand ( TransportCommandStart );
++                    //jack_transport_start(netj.client);
++                    //last_transport_state = JackTransportStopped;
++                    netj.sync_state = 0;
++                    jack_info("locally stopped... starting...");
++                }
++
++                if (local_trans_pos.frame != compensated_tranport_pos)
++                {
++                    jack_position_t new_pos = local_trans_pos;
++                    new_pos.frame = compensated_tranport_pos + 2*netj.period_size;
++                    new_pos.valid = (jack_position_bits_t) 0;
++
++
++                    fEngineControl->fTransport.RequestNewPos ( &new_pos );
++                    //jack_transport_locate(netj.client, compensated_tranport_pos);
++                    //last_transport_state = JackTransportRolling;
++                    netj.sync_state = 0;
++                    jack_info("starting locate to %d", compensated_tranport_pos );
++                }
++                break;
++            case JackTransportStopped:
++                netj.sync_state = 1;
++                if (local_trans_pos.frame != (pkthdr->transport_frame)) {
++                    jack_position_t new_pos = local_trans_pos;
++                    new_pos.frame = pkthdr->transport_frame;
++                    new_pos.valid = (jack_position_bits_t)0;
++                    fEngineControl->fTransport.RequestNewPos ( &new_pos );
++                    //jack_transport_locate(netj.client, (pkthdr->transport_frame));
++                    jack_info("transport is stopped locate to %d", pkthdr->transport_frame);
++                }
++                if (local_trans_state != JackTransportStopped)
++                    //jack_transport_stop(netj.client);
++                    fEngineControl->fTransport.SetCommand ( TransportCommandStop );
++                break;
++            case JackTransportRolling:
++                netj.sync_state = 1;
++    //		    if(local_trans_pos.frame != (pkthdr->transport_frame + (pkthdr->latency) * netj.period_size)) {
++    //		        jack_transport_locate(netj.client, (pkthdr->transport_frame + (pkthdr->latency + 2) * netj.period_size));
++    //			jack_info("running locate to %d", pkthdr->transport_frame + (pkthdr->latency)*netj.period_size);
++    //		    		}
++                if (local_trans_state != JackTransportRolling)
++                fEngineControl->fTransport.SetState ( JackTransportRolling );
++
++                break;
++
++            case JackTransportLooping:
++                break;
++            }
+ #endif
+-	}
++        }
+ 
+-	render_payload_to_jack_ports (netj.bitdepth, packet_bufX, netj.net_period_down, netj.capture_ports, netj.capture_srcs, netj.period_size, netj.dont_htonl_floats );
+-	packet_cache_release_packet(global_packcache, netj.expected_framecnt );
+-	return 0;
++        render_payload_to_jack_ports (netj.bitdepth, packet_bufX, netj.net_period_down, netj.capture_ports, netj.capture_srcs, netj.period_size, netj.dont_htonl_floats );
++        packet_cache_release_packet(global_packcache, netj.expected_framecnt );
++        return 0;
+     }
+ 
+     int JackNetOneDriver::Write()
+     {
+-	int syncstate = netj.sync_state | ((fEngineControl->fTransport.GetState() == JackTransportNetStarting) ? 1 : 0 );
+-	uint32_t *packet_buf, *packet_bufX;
++        int syncstate = netj.sync_state | ((fEngineControl->fTransport.GetState() == JackTransportNetStarting) ? 1 : 0 );
++        uint32_t *packet_buf, *packet_bufX;
+ 
+-	int packet_size = get_sample_size(netj.bitdepth) * netj.playback_channels * netj.net_period_up + sizeof(jacknet_packet_header);
+-	jacknet_packet_header *pkthdr;
+-
+-	packet_buf = (uint32_t *) alloca(packet_size);
+-	pkthdr = (jacknet_packet_header *)packet_buf;
+-
+-	if( netj.running_free ) {
+-	    return 0;
+-	}
++        int packet_size = get_sample_size(netj.bitdepth) * netj.playback_channels * netj.net_period_up + sizeof(jacknet_packet_header);
++        jacknet_packet_header *pkthdr;
+ 
+-	// offset packet_bufX by the packetheader.
+-	packet_bufX = packet_buf + sizeof(jacknet_packet_header) / sizeof(jack_default_audio_sample_t);
++        packet_buf = (uint32_t *) alloca(packet_size);
++        pkthdr = (jacknet_packet_header *)packet_buf;
+ 
+-	pkthdr->sync_state = syncstate;;
+-	pkthdr->latency = netj.time_to_deadline;
+-	//printf( "time to deadline = %d  goodness=%d\n", (int)netj.time_to_deadline, netj.deadline_goodness );
+-	pkthdr->framecnt = netj.expected_framecnt;
++        if( netj.running_free ) {
++            return 0;
++        }
+ 
++        // offset packet_bufX by the packetheader.
++        packet_bufX = packet_buf + sizeof(jacknet_packet_header) / sizeof(jack_default_audio_sample_t);
+ 
+-	render_jack_ports_to_payload(netj.bitdepth, netj.playback_ports, netj.playback_srcs, netj.period_size, packet_bufX, netj.net_period_up, netj.dont_htonl_floats );
++        pkthdr->sync_state = syncstate;;
++        pkthdr->latency = netj.time_to_deadline;
++        //printf( "time to deadline = %d  goodness=%d\n", (int)netj.time_to_deadline, netj.deadline_goodness );
++        pkthdr->framecnt = netj.expected_framecnt;
+ 
+-	packet_header_hton(pkthdr);
+-	if (netj.srcaddress_valid)
+-	{
+-	    unsigned int r;
+-
+-#ifdef __APPLE__
+-	    static const int flag = 0;
+-#else
+-	    static const int flag = 0;
+-#endif
++        render_jack_ports_to_payload(netj.bitdepth, netj.playback_ports, netj.playback_srcs, netj.period_size, packet_bufX, netj.net_period_up, netj.dont_htonl_floats );
+ 
+-	    if (netj.reply_port)
+-		netj.syncsource_address.sin_port = htons(netj.reply_port);
++        packet_header_hton(pkthdr);
++        if (netj.srcaddress_valid)
++        {
++            unsigned int r;
+ 
+-	    for( r=0; r<netj.redundancy; r++ )
+-		netjack_sendto(netj.sockfd, (char *)packet_buf, packet_size,
+-			flag, (struct sockaddr*)&(netj.syncsource_address), sizeof(struct sockaddr_in), netj.mtu);
+-	}
+-	return 0;
++    #ifdef __APPLE__
++            static const int flag = 0;
++    #else
++            static const int flag = 0;
++    #endif
++
++            if (netj.reply_port)
++            netj.syncsource_address.sin_port = htons(netj.reply_port);
++
++            for( r=0; r<netj.redundancy; r++ )
++            netjack_sendto(netj.sockfd, (char *)packet_buf, packet_size,
++                flag, (struct sockaddr*)&(netj.syncsource_address), sizeof(struct sockaddr_in), netj.mtu);
++        }
++        return 0;
+     }
+ 
+ void
+@@ -444,21 +442,21 @@
+     JSList *node = netj.capture_ports;
+ 
+     while( node != NULL ) {
+-	JSList *this_node = node;
+-	jack_port_id_t port_id = (jack_port_id_t)(intptr_t) node->data;
+-	node = jack_slist_remove_link( node, this_node );
+-	jack_slist_free_1( this_node );
+-	fGraphManager->ReleasePort( fClientControl.fRefNum, port_id );
++        JSList *this_node = node;
++        jack_port_id_t port_id = (jack_port_id_t)(intptr_t) node->data;
++        node = jack_slist_remove_link( node, this_node );
++        jack_slist_free_1( this_node );
++        fGraphManager->ReleasePort( fClientControl.fRefNum, port_id );
+     }
+     netj.capture_ports = NULL;
+ 
+     node = netj.playback_ports;
+     while( node != NULL ) {
+-	JSList *this_node = node;
+-	jack_port_id_t port_id = (jack_port_id_t)(intptr_t) node->data;
+-	node = jack_slist_remove_link( node, this_node );
+-	jack_slist_free_1( this_node );
+-	fGraphManager->ReleasePort( fClientControl.fRefNum, port_id );
++        JSList *this_node = node;
++        jack_port_id_t port_id = (jack_port_id_t)(intptr_t) node->data;
++        node = jack_slist_remove_link( node, this_node );
++        jack_slist_free_1( this_node );
++        fGraphManager->ReleasePort( fClientControl.fRefNum, port_id );
+     }
+     netj.playback_ports = NULL;
+ 
+@@ -523,7 +521,7 @@
+     uint32_t *packet_bufX = (uint32_t *)packet_payload;
+ 
+     if( !packet_payload )
+-	return;
++        return;
+ 
+     while (node != NULL)
+     {
+@@ -532,9 +530,8 @@
+ #if HAVE_SAMPLERATE
+         SRC_DATA src;
+ #endif
+-
+-	jack_port_id_t port_id = (jack_port_id_t)(intptr_t) node->data;
+-	JackPort *port = fGraphManager->GetPort( port_id );
++        jack_port_id_t port_id = (jack_port_id_t)(intptr_t) node->data;
++        JackPort *port = fGraphManager->GetPort( port_id );
+ 
+         jack_default_audio_sample_t* buf =
+             (jack_default_audio_sample_t*)fGraphManager->GetBuffer(port_id, fEngineControl->fBufferSize);
+@@ -569,19 +566,19 @@
+             else
+ #endif
+             {
+-		if( dont_htonl_floats )
+-		{
+-		    memcpy( buf, packet_bufX, net_period_down*sizeof(jack_default_audio_sample_t));
+-		}
+-		else
+-		{
+-		    for (i = 0; i < net_period_down; i++)
+-		    {
+-			val.i = packet_bufX[i];
+-			val.i = ntohl (val.i);
+-			buf[i] = val.f;
+-		    }
+-		}
++                if( dont_htonl_floats )
++                {
++                    memcpy( buf, packet_bufX, net_period_down*sizeof(jack_default_audio_sample_t));
++                }
++                else
++                {
++                    for (i = 0; i < net_period_down; i++)
++                    {
++                        val.i = packet_bufX[i];
++                        val.i = ntohl (val.i);
++                        buf[i] = val.f;
++                    }
++                }
+             }
+         }
+         else if (strncmp (porttype, JACK_DEFAULT_MIDI_TYPE, jack_port_type_size()) == 0)
+@@ -616,8 +613,8 @@
+ #endif
+         unsigned int i;
+         int_float_t val;
+-	jack_port_id_t port_id = (jack_port_id_t)(intptr_t) node->data;
+-	JackPort *port = fGraphManager->GetPort( port_id );
++        jack_port_id_t port_id = (jack_port_id_t)(intptr_t) node->data;
++        JackPort *port = fGraphManager->GetPort( port_id );
+ 
+         jack_default_audio_sample_t* buf =
+             (jack_default_audio_sample_t*)fGraphManager->GetBuffer(port_id, fEngineControl->fBufferSize);
+@@ -652,19 +649,19 @@
+             else
+ #endif
+             {
+-		if( dont_htonl_floats )
+-		{
+-		    memcpy( packet_bufX, buf, net_period_up*sizeof(jack_default_audio_sample_t) );
+-		}
+-		else
+-		{
+-		    for (i = 0; i < net_period_up; i++)
+-		    {
+-			val.f = buf[i];
+-			val.i = htonl (val.i);
+-			packet_bufX[i] = val.i;
+-		    }
+-		}
++                if( dont_htonl_floats )
++                {
++                    memcpy( packet_bufX, buf, net_period_up*sizeof(jack_default_audio_sample_t) );
++                }
++                else
++                {
++                    for (i = 0; i < net_period_up; i++)
++                    {
++                        val.f = buf[i];
++                        val.i = htonl (val.i);
++                        packet_bufX[i] = val.i;
++                    }
++                }
+             }
+         }
+         else if (strncmp(porttype, JACK_DEFAULT_MIDI_TYPE, jack_port_type_size()) == 0)
+@@ -694,26 +691,24 @@
+ 
+     while (node != NULL)
+     {
+-	jack_port_id_t port_id = (jack_port_id_t) (intptr_t)node->data;
+-	JackPort *port = fGraphManager->GetPort( port_id );
++        jack_port_id_t port_id = (jack_port_id_t) (intptr_t)node->data;
++        JackPort *port = fGraphManager->GetPort( port_id );
+ 
+         jack_default_audio_sample_t* buf =
+             (jack_default_audio_sample_t*)fGraphManager->GetBuffer(port_id, fEngineControl->fBufferSize);
+ 
+         const char *portname = port->GetType();
+ 
+-
+         if (strncmp(portname, JACK_DEFAULT_AUDIO_TYPE, jack_port_type_size()) == 0)
+         {
+             // audio port, decode celt data.
++            CELTDecoder *decoder = (CELTDecoder *)src_node->data;
++            if( !packet_payload )
++                celt_decode_float( decoder, NULL, net_period_down, buf );
++            else
++                celt_decode_float( decoder, packet_bufX, net_period_down, buf );
+ 
+-	    CELTDecoder *decoder = (CELTDecoder *)src_node->data;
+-	    if( !packet_payload )
+-		celt_decode_float( decoder, NULL, net_period_down, buf );
+-	    else
+-		celt_decode_float( decoder, packet_bufX, net_period_down, buf );
+-
+-	    src_node = jack_slist_next (src_node);
++            src_node = jack_slist_next (src_node);
+         }
+         else if (strncmp(portname, JACK_DEFAULT_MIDI_TYPE, jack_port_type_size()) == 0)
+         {
+@@ -722,7 +717,7 @@
+             unsigned int buffer_size_uint32 = net_period_down / 2;
+             uint32_t * buffer_uint32 = (uint32_t*) packet_bufX;
+ 	    if( packet_payload )
+-		decode_midi_buffer (buffer_uint32, buffer_size_uint32, buf);
++            decode_midi_buffer (buffer_uint32, buffer_size_uint32, buf);
+         }
+         packet_bufX = (packet_bufX + net_period_down);
+         node = jack_slist_next (node);
+@@ -741,8 +736,8 @@
+ 
+     while (node != NULL)
+     {
+-	jack_port_id_t port_id = (jack_port_id_t) (intptr_t) node->data;
+-	JackPort *port = fGraphManager->GetPort( port_id );
++        jack_port_id_t port_id = (jack_port_id_t) (intptr_t) node->data;
++        JackPort *port = fGraphManager->GetPort( port_id );
+ 
+         jack_default_audio_sample_t* buf =
+             (jack_default_audio_sample_t*)fGraphManager->GetBuffer(port_id, fEngineControl->fBufferSize);
+@@ -800,8 +795,6 @@
+         render_jack_ports_to_payload_float (playback_ports, playback_srcs, nframes, packet_payload, net_period_up, dont_htonl_floats);
+ }
+ 
+-
+-
+ //driver loader-----------------------------------------------------------------------
+ 
+ #ifdef __cplusplus
+@@ -982,28 +975,26 @@
+ 
+         SERVER_EXPORT Jack::JackDriverClientInterface* driver_initialize ( Jack::JackLockedEngine* engine, Jack::JackSynchro* table, const JSList* params )
+         {
+-    jack_nframes_t sample_rate = 48000;
+-    jack_nframes_t resample_factor = 1;
+-    jack_nframes_t period_size = 1024;
+-    unsigned int capture_ports = 2;
+-    unsigned int playback_ports = 2;
+-    unsigned int capture_ports_midi = 1;
+-    unsigned int playback_ports_midi = 1;
+-    unsigned int listen_port = 3000;
+-    unsigned int resample_factor_up = 0;
+-    unsigned int bitdepth = 0;
+-    unsigned int handle_transport_sync = 1;
+-    unsigned int use_autoconfig = 1;
+-    unsigned int latency = 5;
+-    unsigned int redundancy = 1;
+-    unsigned int mtu = 1400;
+-    int dont_htonl_floats = 0;
+-    int always_deadline = 0;
+-    int jitter_val = 0;
+-    const JSList * node;
+-    const jack_driver_param_t * param;
+-
+-
++            jack_nframes_t sample_rate = 48000;
++            jack_nframes_t resample_factor = 1;
++            jack_nframes_t period_size = 1024;
++            unsigned int capture_ports = 2;
++            unsigned int playback_ports = 2;
++            unsigned int capture_ports_midi = 1;
++            unsigned int playback_ports_midi = 1;
++            unsigned int listen_port = 3000;
++            unsigned int bitdepth = 0;
++            unsigned int handle_transport_sync = 1;
++            unsigned int use_autoconfig = 1;
++            unsigned int latency = 5;
++            unsigned int redundancy = 1;
++            unsigned int mtu = 1400;
++            unsigned int resample_factor_up = 1;
++            int dont_htonl_floats = 0;
++            int always_deadline = 0;
++            int jitter_val = 0;
++            const JSList * node;
++            const jack_driver_param_t * param;
+ 
+             for ( node = params; node; node = jack_slist_next ( node ) )
+             {
+@@ -1102,7 +1093,6 @@
+ 
+             try
+             {
+-
+                 Jack::JackDriverClientInterface* driver =
+                     new Jack::JackWaitThreadedDriver (
+                     new Jack::JackNetOneDriver ( "system", "net_pcm", engine, table, listen_port, mtu,
+--- a/common/JackNotification.h
++++ b/common/JackNotification.h
+@@ -45,6 +45,7 @@
+     kRealTimeCallback = 14,
+     kShutDownCallback = 15,
+     kQUIT = 16,
++    kSessionCallback = 17,
+     kMaxNotification
+ };
+ 
+--- a/common/JackRequest.h
++++ b/common/JackRequest.h
+@@ -26,6 +26,7 @@
+ #include "types.h"
+ #include <string.h>
+ #include <stdio.h>
++#include <list>
+ 
+ namespace Jack
+ {
+@@ -65,7 +66,12 @@
+         kInternalClientLoad = 29,
+         kInternalClientUnload = 30,
+         kPortRename = 31,
+-        kNotification = 32
++        kNotification = 32,
++        kSessionNotify = 33,
++        kSessionReply  = 34,
++        kGetClientByUUID = 35,
++        kReserveClientName = 36,
++        kGetUUIDByClient = 37
+     };
+ 
+     RequestType fType;
+@@ -98,7 +104,7 @@
+ struct JackResult
+ {
+ 
+-    int	fResult;
++    int fResult;
+ 
+     JackResult(): fResult( -1)
+     {}
+@@ -129,31 +135,34 @@
+     char fName[JACK_CLIENT_NAME_SIZE + 1];
+     int fProtocol;
+     int fOptions;
++    int fUUID;
+ 
+     JackClientCheckRequest()
+     {}
+-    JackClientCheckRequest(const char* name, int protocol, int options)
+-        : JackRequest(JackRequest::kClientCheck), fProtocol(protocol), fOptions(options)
++    JackClientCheckRequest(const char* name, int protocol, int options, int uuid)
++        : JackRequest(JackRequest::kClientCheck), fProtocol(protocol), fOptions(options), fUUID(uuid)
+     {
+         snprintf(fName, sizeof(fName), "%s", name);
+     }
+ 
+     int Read(JackChannelTransaction* trans)
+     {
+-        CheckRes(trans->Read(&fName, JACK_CLIENT_NAME_SIZE + 1));
++        CheckRes(trans->Read(&fName, sizeof(fName)));
+         CheckRes(trans->Read(&fProtocol, sizeof(int)));
+-        return trans->Read(&fOptions, sizeof(int));
++        CheckRes(trans->Read(&fOptions, sizeof(int)));
++        return trans->Read(&fUUID, sizeof(int));
+     }
+ 
+     int Write(JackChannelTransaction* trans)
+     {
+         CheckRes(JackRequest::Write(trans));
+-        CheckRes(trans->Write(&fName, JACK_CLIENT_NAME_SIZE + 1));
++        CheckRes(trans->Write(&fName,  sizeof(fName)));
+         CheckRes(trans->Write(&fProtocol, sizeof(int)));
+-        return trans->Write(&fOptions, sizeof(int));
++        CheckRes(trans->Write(&fOptions, sizeof(int)));
++        return trans->Write(&fUUID, sizeof(int));
+     }
+     
+-} POST_PACKED_STRUCTURE;
++};
+ 
+ /*!
+ \brief CheckClient result.
+@@ -176,7 +185,7 @@
+     int Read(JackChannelTransaction* trans)
+     {
+         CheckRes(JackResult::Read(trans));
+-        CheckRes(trans->Read(&fName, JACK_CLIENT_NAME_SIZE + 1));
++        CheckRes(trans->Read(&fName, sizeof(fName)));
+         CheckRes(trans->Read(&fStatus, sizeof(int)));
+         return 0;
+     }
+@@ -184,12 +193,12 @@
+     int Write(JackChannelTransaction* trans)
+     {
+         CheckRes(JackResult::Write(trans));
+-        CheckRes(trans->Write(&fName, JACK_CLIENT_NAME_SIZE + 1));
++        CheckRes(trans->Write(&fName, sizeof(fName)));
+         CheckRes(trans->Write(&fStatus, sizeof(int)));
+         return 0;
+     }
+     
+-} POST_PACKED_STRUCTURE;
++};
+ 
+ /*!
+ \brief NewClient request.
+@@ -199,30 +208,34 @@
+ {
+ 
+     int fPID;
++    int fUUID;
+     char fName[JACK_CLIENT_NAME_SIZE + 1];
+-
++ 
+     JackClientOpenRequest()
+     {}
+-    JackClientOpenRequest(const char* name, int pid): JackRequest(JackRequest::kClientOpen)
++    JackClientOpenRequest(const char* name, int pid, int uuid): JackRequest(JackRequest::kClientOpen)
+     {
+         snprintf(fName, sizeof(fName), "%s", name);
+         fPID = pid;
++        fUUID = uuid;
+     }
+ 
+     int Read(JackChannelTransaction* trans)
+     {
+         CheckRes(trans->Read(&fPID, sizeof(int)));
+-        return trans->Read(&fName, JACK_CLIENT_NAME_SIZE + 1);
++        CheckRes(trans->Read(&fUUID, sizeof(int)));
++        return trans->Read(&fName,  sizeof(fName));
+     }
+ 
+     int Write(JackChannelTransaction* trans)
+     {
+         CheckRes(JackRequest::Write(trans));
+         CheckRes(trans->Write(&fPID, sizeof(int)));
+-        return trans->Write(&fName, JACK_CLIENT_NAME_SIZE + 1);
++        CheckRes(trans->Write(&fUUID, sizeof(int)));
++        return trans->Write(&fName,  sizeof(fName));
+     }
+     
+-} POST_PACKED_STRUCTURE;
++};
+ 
+ /*!
+ \brief NewClient result.
+@@ -260,7 +273,7 @@
+         return 0;
+     }
+     
+-} POST_PACKED_STRUCTURE;
++};
+ 
+ /*!
+ \brief CloseClient request.
+@@ -287,7 +300,7 @@
+         return trans->Write(&fRefNum, sizeof(int));
+     }
+     
+-} POST_PACKED_STRUCTURE;
++};
+ 
+ /*!
+ \brief Activate request.
+@@ -318,7 +331,7 @@
+         return trans->Write(&fIsRealTime, sizeof(int));
+     }
+ 
+-} POST_PACKED_STRUCTURE;
++};
+ 
+ /*!
+ \brief Deactivate request.
+@@ -345,7 +358,7 @@
+         return trans->Write(&fRefNum, sizeof(int));
+     }
+ 
+-} POST_PACKED_STRUCTURE;
++};
+ 
+ /*!
+ \brief PortRegister request.
+@@ -372,8 +385,8 @@
+     int Read(JackChannelTransaction* trans)
+     {
+         CheckRes(trans->Read(&fRefNum, sizeof(int)));
+-        CheckRes(trans->Read(&fName, JACK_PORT_NAME_SIZE + 1));
+-        CheckRes(trans->Read(&fPortType, JACK_PORT_TYPE_SIZE + 1));
++        CheckRes(trans->Read(&fName, sizeof(fName)));
++        CheckRes(trans->Read(&fPortType, sizeof(fPortType)));
+         CheckRes(trans->Read(&fFlags, sizeof(unsigned int)));
+         CheckRes(trans->Read(&fBufferSize, sizeof(unsigned int)));
+         return 0;
+@@ -383,14 +396,14 @@
+     {
+         CheckRes(JackRequest::Write(trans));
+         CheckRes(trans->Write(&fRefNum, sizeof(int)));
+-        CheckRes(trans->Write(&fName, JACK_PORT_NAME_SIZE + 1));
+-        CheckRes(trans->Write(&fPortType, JACK_PORT_TYPE_SIZE + 1));
++        CheckRes(trans->Write(&fName, sizeof(fName)));
++        CheckRes(trans->Write(&fPortType, sizeof(fPortType)));
+         CheckRes(trans->Write(&fFlags, sizeof(unsigned int)));
+         CheckRes(trans->Write(&fBufferSize, sizeof(unsigned int)));
+         return 0;
+     }
+     
+-} POST_PACKED_STRUCTURE;
++};
+ 
+ /*!
+ \brief PortRegister result.
+@@ -416,7 +429,7 @@
+         return trans->Write(&fPortIndex, sizeof(jack_port_id_t));
+     }
+     
+-} POST_PACKED_STRUCTURE;
++};
+ 
+ /*!
+ \brief PortUnregister request.
+@@ -449,7 +462,7 @@
+         return 0;
+     }
+     
+-} POST_PACKED_STRUCTURE;
++};
+ 
+ /*!
+ \brief PortConnectName request.
+@@ -474,8 +487,8 @@
+     int Read(JackChannelTransaction* trans)
+     {
+         CheckRes(trans->Read(&fRefNum, sizeof(int)));
+-        CheckRes(trans->Read(&fSrc, JACK_PORT_NAME_SIZE + 1));
+-        CheckRes(trans->Read(&fDst, JACK_PORT_NAME_SIZE + 1));
++        CheckRes(trans->Read(&fSrc, sizeof(fSrc)));
++        CheckRes(trans->Read(&fDst, sizeof(fDst)));
+         return 0;
+ 
+     }
+@@ -484,12 +497,12 @@
+     {
+         CheckRes(JackRequest::Write(trans));
+         CheckRes(trans->Write(&fRefNum, sizeof(int)));
+-        CheckRes(trans->Write(&fSrc, JACK_PORT_NAME_SIZE + 1));
+-        CheckRes(trans->Write(&fDst, JACK_PORT_NAME_SIZE + 1));
++        CheckRes(trans->Write(&fSrc, sizeof(fSrc)));
++        CheckRes(trans->Write(&fDst, sizeof(fDst)));
+         return 0;
+     }
+     
+-} POST_PACKED_STRUCTURE;
++};
+ 
+ /*!
+ \brief PortDisconnectName request.
+@@ -514,8 +527,8 @@
+     int Read(JackChannelTransaction* trans)
+     {
+         CheckRes(trans->Read(&fRefNum, sizeof(int)));
+-        CheckRes(trans->Read(&fSrc, JACK_PORT_NAME_SIZE + 1));
+-        CheckRes(trans->Read(&fDst, JACK_PORT_NAME_SIZE + 1));
++        CheckRes(trans->Read(&fSrc, sizeof(fSrc)));
++        CheckRes(trans->Read(&fDst, sizeof(fDst)));
+         return 0;
+     }
+ 
+@@ -523,12 +536,12 @@
+     {
+         CheckRes(JackRequest::Write(trans));
+         CheckRes(trans->Write(&fRefNum, sizeof(int)));
+-        CheckRes(trans->Write(&fSrc, JACK_PORT_NAME_SIZE + 1));
+-        CheckRes(trans->Write(&fDst, JACK_PORT_NAME_SIZE + 1));
++        CheckRes(trans->Write(&fSrc, sizeof(fSrc)));
++        CheckRes(trans->Write(&fDst, sizeof(fDst)));
+         return 0;
+     }
+     
+-} POST_PACKED_STRUCTURE;
++};
+ 
+ /*!
+ \brief PortConnect request.
+@@ -564,7 +577,7 @@
+         return 0;
+     }
+     
+-} POST_PACKED_STRUCTURE;
++};
+ 
+ /*!
+ \brief PortDisconnect request.
+@@ -598,10 +611,9 @@
+         CheckRes(trans->Write(&fSrc, sizeof(jack_port_id_t)));
+         CheckRes(trans->Write(&fDst, sizeof(jack_port_id_t)));
+         return 0;
+-
+     }
+     
+-} POST_PACKED_STRUCTURE;
++};
+ 
+ /*!
+ \brief PortRename request.
+@@ -626,7 +638,7 @@
+     {
+         CheckRes(trans->Read(&fRefNum, sizeof(int)));
+         CheckRes(trans->Read(&fPort, sizeof(jack_port_id_t)));
+-        CheckRes(trans->Read(&fName, JACK_PORT_NAME_SIZE + 1));
++        CheckRes(trans->Read(&fName, sizeof(fName)));
+         return 0;
+     }
+ 
+@@ -635,12 +647,12 @@
+         CheckRes(JackRequest::Write(trans));
+         CheckRes(trans->Write(&fRefNum, sizeof(int)));
+         CheckRes(trans->Write(&fPort, sizeof(jack_port_id_t)));
+-        CheckRes(trans->Write(&fName, JACK_PORT_NAME_SIZE + 1));
++        CheckRes(trans->Write(&fName, sizeof(fName)));
+         return 0;
+ 
+     }
+     
+-} POST_PACKED_STRUCTURE;
++};
+ 
+ /*!
+ \brief SetBufferSize request.
+@@ -668,7 +680,7 @@
+         return trans->Write(&fBufferSize, sizeof(jack_nframes_t));
+     }
+     
+-} POST_PACKED_STRUCTURE;
++};
+ 
+ /*!
+ \brief SetFreeWheel request.
+@@ -696,7 +708,7 @@
+         return trans->Write(&fOnOff, sizeof(int));
+     }
+     
+-} POST_PACKED_STRUCTURE;
++};
+ 
+ /*!
+ \brief ReleaseTimebase request.
+@@ -724,7 +736,7 @@
+         return trans->Write(&fRefNum, sizeof(int));
+     }
+     
+-} POST_PACKED_STRUCTURE;
++};
+ 
+ /*!
+ \brief SetTimebaseCallback request.
+@@ -755,7 +767,7 @@
+         return trans->Write(&fConditionnal, sizeof(int));
+     }
+     
+-} POST_PACKED_STRUCTURE;
++};
+ 
+ /*!
+ \brief GetInternalClientName request.
+@@ -786,7 +798,7 @@
+         return trans->Write(&fIntRefNum, sizeof(int));
+     }
+     
+-} POST_PACKED_STRUCTURE;
++};
+ 
+ /*!
+ \brief GetInternalClient result.
+@@ -808,18 +820,18 @@
+     int Read(JackChannelTransaction* trans)
+     {
+         CheckRes(JackResult::Read(trans));
+-        CheckRes(trans->Read(&fName, JACK_CLIENT_NAME_SIZE + 1));
++        CheckRes(trans->Read(&fName,  sizeof(fName)));
+         return 0;
+     }
+ 
+     int Write(JackChannelTransaction* trans)
+     {
+         CheckRes(JackResult::Write(trans));
+-        CheckRes(trans->Write(&fName, JACK_CLIENT_NAME_SIZE + 1));
++        CheckRes(trans->Write(&fName,  sizeof(fName)));
+         return 0;
+     }
+     
+-} POST_PACKED_STRUCTURE;
++};
+ 
+ /*!
+ \brief InternalClientHandle request.
+@@ -842,17 +854,17 @@
+     int Read(JackChannelTransaction* trans)
+     {
+         CheckRes(trans->Read(&fRefNum, sizeof(int)));
+-        return trans->Read(&fName, JACK_CLIENT_NAME_SIZE + 1);
++        return trans->Read(&fName,  sizeof(fName));
+     }
+ 
+     int Write(JackChannelTransaction* trans)
+     {
+         CheckRes(JackRequest::Write(trans));
+         CheckRes(trans->Write(&fRefNum, sizeof(int)));
+-        return trans->Write(&fName, JACK_CLIENT_NAME_SIZE + 1);
++        return trans->Write(&fName,  sizeof(fName));
+     }
+     
+-} POST_PACKED_STRUCTURE;
++};
+ 
+ /*!
+ \brief InternalClientHandle result.
+@@ -886,7 +898,7 @@
+         return 0;
+     }
+     
+-} POST_PACKED_STRUCTURE;
++};
+ 
+ /*!
+ \brief InternalClientLoad request.
+@@ -904,23 +916,26 @@
+     char fDllName[MAX_PATH + 1];
+     char fLoadInitName[JACK_LOAD_INIT_LIMIT + 1];
+     int fOptions;
++    int fUUID;
+ 
+     JackInternalClientLoadRequest()
+     {}
+-    JackInternalClientLoadRequest(int refnum, const char* client_name, const char* so_name, const char* objet_data, int options)
+-            : JackRequest(JackRequest::kInternalClientLoad), fRefNum(refnum), fOptions(options)
++    JackInternalClientLoadRequest(int refnum, const char* client_name, const char* so_name, const char* objet_data, int options, int uuid )
++            : JackRequest(JackRequest::kInternalClientLoad), fRefNum(refnum), fOptions(options), fUUID(uuid)
+     {
+         snprintf(fName, sizeof(fName), "%s", client_name);
+         snprintf(fDllName, sizeof(fDllName), "%s", so_name);
+         snprintf(fLoadInitName, sizeof(fLoadInitName), "%s", objet_data);
++        snprintf(fLoadInitName, sizeof(fLoadInitName), "%s", objet_data);
+     }
+ 
+     int Read(JackChannelTransaction* trans)
+     {
+         CheckRes(trans->Read(&fRefNum, sizeof(int)));
+-        CheckRes(trans->Read(&fName, JACK_CLIENT_NAME_SIZE + 1));
+-        CheckRes(trans->Read(&fDllName, MAX_PATH + 1));
+-        CheckRes(trans->Read(&fLoadInitName, JACK_LOAD_INIT_LIMIT + 1));
++        CheckRes(trans->Read(&fName,  sizeof(fName)));
++        CheckRes(trans->Read(&fDllName, sizeof(fDllName)));
++        CheckRes(trans->Read(&fLoadInitName, sizeof(fLoadInitName)));
++        CheckRes(trans->Read(&fUUID, sizeof(int)));
+         return trans->Read(&fOptions, sizeof(int));
+     }
+ 
+@@ -928,13 +943,14 @@
+     {
+         CheckRes(JackRequest::Write(trans));
+         CheckRes(trans->Write(&fRefNum, sizeof(int)));
+-        CheckRes(trans->Write(&fName, JACK_CLIENT_NAME_SIZE + 1));
+-        CheckRes(trans->Write(&fDllName, MAX_PATH + 1));
+-        CheckRes(trans->Write(&fLoadInitName, JACK_LOAD_INIT_LIMIT + 1));
++        CheckRes(trans->Write(&fName,  sizeof(fName)));
++        CheckRes(trans->Write(&fDllName, sizeof(fDllName)));
++        CheckRes(trans->Write(&fLoadInitName, sizeof(fLoadInitName)));
++        CheckRes(trans->Write(&fUUID, sizeof(int)));
+         return trans->Write(&fOptions, sizeof(int));
+     }
+     
+-} POST_PACKED_STRUCTURE;
++};
+ 
+ /*!
+ \brief InternalClientLoad result.
+@@ -968,7 +984,7 @@
+         return 0;
+     }
+     
+-} POST_PACKED_STRUCTURE;
++};
+ 
+ /*!
+ \brief InternalClientUnload request.
+@@ -998,7 +1014,7 @@
+         CheckRes(trans->Write(&fRefNum, sizeof(int)));
+         return trans->Write(&fIntRefNum, sizeof(int));
+     }
+-} POST_PACKED_STRUCTURE;
++};
+ 
+ /*!
+ \brief InternalClientLoad result.
+@@ -1029,7 +1045,7 @@
+         return 0;
+     }
+     
+-} POST_PACKED_STRUCTURE;
++};
+ 
+ /*!
+ \brief ClientNotification request.
+@@ -1065,7 +1081,292 @@
+         return 0;
+     }
+ 
+-} POST_PACKED_STRUCTURE;
++};
++
++struct JackSessionCommand
++{
++    char fUUID[JACK_UUID_SIZE];
++    char fClientName[JACK_CLIENT_NAME_SIZE+1];
++    char fCommand[JACK_SESSION_COMMAND_SIZE];
++    jack_session_flags_t fFlags;
++
++    JackSessionCommand()
++    {}
++
++    JackSessionCommand( const char *uuid, const char *clientname, const char *command, jack_session_flags_t flags )
++    {
++        strncpy( fUUID, uuid, sizeof(fUUID));
++        strncpy( fClientName, clientname, sizeof(fClientName));
++        strncpy( fCommand, command, sizeof(fCommand));
++        fFlags = flags;
++    }
++};
++
++struct JackSessionNotifyResult : public JackResult
++{
++
++    std::list<JackSessionCommand> fCommandList;
++
++    JackSessionNotifyResult(): JackResult()
++    {}
++    JackSessionNotifyResult(int32_t result)
++            : JackResult(result)
++    {}
++
++    int Read(JackChannelTransaction* trans)
++    {
++        CheckRes(JackResult::Read(trans));
++        while(1) {
++            JackSessionCommand buffer;
++
++            CheckRes(trans->Read(buffer.fUUID, sizeof(buffer.fUUID)));
++            if (buffer.fUUID[0] == '\0')
++                break;
++
++            CheckRes(trans->Read(buffer.fClientName, sizeof(buffer.fClientName)));
++            CheckRes(trans->Read(buffer.fCommand, sizeof(buffer.fCommand)));
++            CheckRes(trans->Read(&(buffer.fFlags), sizeof(buffer.fFlags)));
++
++            fCommandList.push_back(buffer);
++        }
++        return 0;
++    }
++
++    int Write(JackChannelTransaction* trans)
++    {
++        char terminator[JACK_UUID_SIZE];
++        terminator[0] = '\0';
++
++        CheckRes(JackResult::Write(trans));
++        for (std::list<JackSessionCommand>::iterator i=fCommandList.begin(); i!=fCommandList.end(); i++) {
++            CheckRes(trans->Write(i->fUUID, sizeof(i->fUUID)));
++            CheckRes(trans->Write(i->fClientName, sizeof(i->fClientName)));
++            CheckRes(trans->Write(i->fCommand, sizeof(i->fCommand)));
++            CheckRes(trans->Write(&(i->fFlags), sizeof(i->fFlags)));
++        }
++        CheckRes(trans->Write(terminator, sizeof(terminator)));
++        return 0;
++    }
++    
++};
++
++/*!
++\brief SessionNotify request.
++*/
++
++struct JackSessionNotifyRequest : public JackRequest
++{
++    char fPath[JACK_MESSAGE_SIZE + 1];
++    char fDst[JACK_CLIENT_NAME_SIZE + 1];
++    jack_session_event_type_t  fEventType;
++    int  fRefNum;
++
++    JackSessionNotifyRequest()
++    {}
++    JackSessionNotifyRequest(int refnum, const char *path, jack_session_event_type_t type, const char *dst)
++            : JackRequest(JackRequest::kSessionNotify), fEventType(type), fRefNum(refnum)
++    {
++        snprintf(fPath, sizeof(fPath), "%s", path);
++        if (dst)
++            snprintf(fDst, sizeof(fDst), "%s", dst);
++        else
++            fDst[0] = '\0';
++    }
++
++    int Read(JackChannelTransaction* trans)
++    {
++        CheckRes(trans->Read(&fRefNum, sizeof(fRefNum)));
++        CheckRes(trans->Read(&fPath, sizeof(fPath)));
++        CheckRes(trans->Read(&fDst, sizeof(fDst)));
++        CheckRes(trans->Read(&fEventType, sizeof(fEventType)));
++        return 0;
++    }
++
++    int Write(JackChannelTransaction* trans)
++    {
++        CheckRes(JackRequest::Write(trans));
++        CheckRes(trans->Write(&fRefNum, sizeof(fRefNum)));
++        CheckRes(trans->Write(&fPath, sizeof(fPath)));
++        CheckRes(trans->Write(&fDst, sizeof(fDst)));
++        CheckRes(trans->Write(&fEventType, sizeof(fEventType)));
++        return 0;
++    }
++
++};
++
++struct JackSessionReplyRequest : public JackRequest
++{
++    int fRefNum;
++
++    JackSessionReplyRequest()
++    {}
++
++    JackSessionReplyRequest(int refnum)
++            : JackRequest(JackRequest::kSessionReply), fRefNum(refnum)
++    {}
++
++    int Read(JackChannelTransaction* trans)
++    {
++        CheckRes(trans->Read(&fRefNum, sizeof(fRefNum)));
++        return 0;
++    }
++
++    int Write(JackChannelTransaction* trans)
++    {
++        CheckRes(JackRequest::Write(trans));
++        CheckRes(trans->Write(&fRefNum, sizeof(fRefNum)));
++        return 0;
++    }
++
++};
++
++struct JackClientNameResult : public JackResult
++{
++    char fName[JACK_CLIENT_NAME_SIZE + 1];
++
++    JackClientNameResult(): JackResult()
++    {}
++    JackClientNameResult(int32_t result, const char* name)
++            : JackResult(result)
++    {
++        snprintf(fName, sizeof(fName), "%s", name);
++    }
++
++    int Read(JackChannelTransaction* trans)
++    {
++        CheckRes(JackResult::Read(trans));
++        CheckRes(trans->Read(&fName, sizeof(fName)));
++        return 0;
++    }
++
++    int Write(JackChannelTransaction* trans)
++    {
++        CheckRes(JackResult::Write(trans));
++        CheckRes(trans->Write(&fName, sizeof(fName)));
++        return 0;
++    }
++    
++};
++
++struct JackUUIDResult : public JackResult
++{
++
++    char fUUID[JACK_UUID_SIZE];
++
++    JackUUIDResult(): JackResult()
++    {}
++    JackUUIDResult(int32_t result, const char* uuid)
++            : JackResult(result)
++    {
++        snprintf(fUUID, sizeof(fUUID), "%s", uuid);
++    }
++
++    int Read(JackChannelTransaction* trans)
++    {
++        CheckRes(JackResult::Read(trans));
++        CheckRes(trans->Read(&fUUID, sizeof(fUUID)));
++        return 0;
++    }
++
++    int Write(JackChannelTransaction* trans)
++    {
++        CheckRes(JackResult::Write(trans));
++        CheckRes(trans->Write(&fUUID, sizeof(fUUID)));
++        return 0;
++    }
++    
++};
++
++struct JackGetUUIDRequest : public JackRequest
++{
++    char fName[JACK_CLIENT_NAME_SIZE + 1];
++
++    JackGetUUIDRequest()
++    {}
++
++    JackGetUUIDRequest(const char* client_name)
++            : JackRequest(JackRequest::kGetUUIDByClient)
++    {
++        strncpy(fName, client_name, sizeof(fName));
++    }
++
++    int Read(JackChannelTransaction* trans)
++    {
++        CheckRes(trans->Read(&fName, sizeof(fName)));
++        return 0;
++    }
++
++    int Write(JackChannelTransaction* trans)
++    {
++        CheckRes(JackRequest::Write(trans));
++        CheckRes(trans->Write(&fName, sizeof(fName)));
++        return 0;
++    }
++
++};
++
++struct JackGetClientNameRequest : public JackRequest
++{
++    char fUUID[JACK_UUID_SIZE];
++
++    JackGetClientNameRequest()
++    {}
++
++    JackGetClientNameRequest(const char* uuid)
++            : JackRequest(JackRequest::kGetClientByUUID)
++    {
++        strncpy(fUUID, uuid, sizeof(fUUID));
++    }
++
++    int Read(JackChannelTransaction* trans)
++    {
++        CheckRes(trans->Read(&fUUID, sizeof(fUUID)));
++        return 0;
++    }
++
++    int Write(JackChannelTransaction* trans)
++    {
++        CheckRes(JackRequest::Write(trans));
++        CheckRes(trans->Write(&fUUID, sizeof(fUUID)));
++        return 0;
++    }
++
++};
++
++struct JackReserveNameRequest : public JackRequest
++{
++    int  fRefNum;
++    char fName[JACK_CLIENT_NAME_SIZE + 1];
++    char fUUID[JACK_UUID_SIZE];
++
++    JackReserveNameRequest()
++    {}
++
++    JackReserveNameRequest(int refnum, const char *name, const char* uuid)
++            : JackRequest(JackRequest::kReserveClientName), fRefNum(refnum)
++    {
++        strncpy(fName, name, sizeof(fName));
++        strncpy(fUUID, uuid, sizeof(fUUID));
++    }
++
++    int Read(JackChannelTransaction* trans)
++    {
++        CheckRes(trans->Read(&fUUID, sizeof(fUUID)));
++        CheckRes(trans->Read(&fName, sizeof(fName)));
++        CheckRes(trans->Read(&fRefNum, sizeof(fRefNum)));
++        return 0;
++    }
++
++    int Write(JackChannelTransaction* trans)
++    {
++        CheckRes(JackRequest::Write(trans));
++        CheckRes(trans->Write(&fUUID, sizeof(fUUID)));
++        CheckRes(trans->Write(&fName, sizeof(fName)));
++        CheckRes(trans->Write(&fRefNum, sizeof(fRefNum)));
++        return 0;
++    }
++
++};
+ 
+ /*!
+ \brief ClientNotification.
+@@ -1092,29 +1393,29 @@
+ 
+     int Read(JackChannelTransaction* trans)
+     {
+-        CheckRes(trans->Read(&fName, JACK_CLIENT_NAME_SIZE + 1));
++        CheckRes(trans->Read(&fName, sizeof(fName)));
+         CheckRes(trans->Read(&fRefNum, sizeof(int)));
+         CheckRes(trans->Read(&fNotify, sizeof(int)));
+         CheckRes(trans->Read(&fValue1, sizeof(int)));
+         CheckRes(trans->Read(&fValue2, sizeof(int)));
+         CheckRes(trans->Read(&fSync, sizeof(int)));
+-        CheckRes(trans->Read(&fMessage, JACK_MESSAGE_SIZE + 1));
++        CheckRes(trans->Read(&fMessage, sizeof(fName)));
+         return 0;
+     }
+ 
+     int Write(JackChannelTransaction* trans)
+     {
+-        CheckRes(trans->Write(&fName, JACK_CLIENT_NAME_SIZE + 1));
++        CheckRes(trans->Write(&fName, sizeof(fName)));
+         CheckRes(trans->Write(&fRefNum, sizeof(int)));
+         CheckRes(trans->Write(&fNotify, sizeof(int)));
+         CheckRes(trans->Write(&fValue1, sizeof(int)));
+         CheckRes(trans->Write(&fValue2, sizeof(int)));
+         CheckRes(trans->Write(&fSync, sizeof(int)));
+-        CheckRes(trans->Write(&fMessage, JACK_MESSAGE_SIZE + 1));
++        CheckRes(trans->Write(&fMessage, sizeof(fName)));
+         return 0;
+     }
+ 
+-} POST_PACKED_STRUCTURE;
++};
+ 
+ } // end of namespace
+ 
+--- a/common/JackServer.cpp
++++ b/common/JackServer.cpp
+@@ -72,22 +72,22 @@
+ {
+     // TODO: move that in reworked JackServerGlobals::Init()
+     JackMessageBuffer::Create();
++    
++     if ((fAudioDriver = fDriverInfo->Open(driver_desc, fEngine, GetSynchroTable(), driver_params)) == NULL) {
++        jack_error("Cannot initialize driver");
++        goto fail_close1;
++    }
+   
+     if (fChannel.Open(fEngineControl->fServerName, this) < 0) {
+         jack_error("Server channel open error");
+-        goto fail_close1;
++        goto fail_close2;
+     }
+   
+     if (fEngine->Open() < 0) {
+         jack_error("Cannot open engine");
+-        goto fail_close2;
+-    }
+-
+-    if ((fAudioDriver = fDriverInfo->Open(driver_desc, fEngine, GetSynchroTable(), driver_params)) == NULL) {
+-        jack_error("Cannot initialize driver");
+         goto fail_close3;
+     }
+- 
++
+     if (fFreewheelDriver->Open() < 0) { // before engine open
+         jack_error("Cannot open driver");
+         goto fail_close4;
+@@ -109,13 +109,13 @@
+     fFreewheelDriver->Close();
+ 
+ fail_close4:
+-    fAudioDriver->Close();
++    fEngine->Close();
+ 
+ fail_close3:
+-    fEngine->Close();
++    fChannel.Close();
+  
+ fail_close2:     
+-    fChannel.Close();
++    fAudioDriver->Close();
+ 
+ fail_close1:     
+     JackMessageBuffer::Destroy();
+@@ -136,25 +136,25 @@
+     return 0;
+ }
+ 
+-int JackServer::InternalClientLoad(const char* client_name, const char* so_name, const char* objet_data, int options, int* int_ref, int* status)
++int JackServer::InternalClientLoad(const char* client_name, const char* so_name, const char* objet_data, int options, int* int_ref, int uuid, int* status)
+ {
+     JackLoadableInternalClient* client = new JackLoadableInternalClient1(JackServerGlobals::fInstance, GetSynchroTable(), objet_data);
+     assert(client);
+-    return InternalClientLoadAux(client, so_name, client_name, options, int_ref, status);
++    return InternalClientLoadAux(client, so_name, client_name, options, int_ref, uuid, status);
+  }
+ 
+-int JackServer::InternalClientLoad(const char* client_name, const char* so_name, const JSList * parameters, int options, int* int_ref, int* status)
++int JackServer::InternalClientLoad(const char* client_name, const char* so_name, const JSList * parameters, int options, int* int_ref, int uuid, int* status)
+ {
+     JackLoadableInternalClient* client = new JackLoadableInternalClient2(JackServerGlobals::fInstance, GetSynchroTable(), parameters);
+     assert(client);
+-    return InternalClientLoadAux(client, so_name, client_name, options, int_ref, status);
++    return InternalClientLoadAux(client, so_name, client_name, options, int_ref, uuid, status);
+ }
+ 
+-int JackServer::InternalClientLoadAux(JackLoadableInternalClient* client, const char* so_name, const char* client_name, int options, int* int_ref, int* status)
++int JackServer::InternalClientLoadAux(JackLoadableInternalClient* client, const char* so_name, const char* client_name, int options, int* int_ref, int uuid, int* status)
+ {
+     // Clear status
+     *status = 0;
+-    if ((client->Init(so_name) < 0) || (client->Open(JACK_DEFAULT_SERVER_NAME, client_name, (jack_options_t)options, (jack_status_t*)status) < 0)) {
++    if ((client->Init(so_name) < 0) || (client->Open(JACK_DEFAULT_SERVER_NAME, client_name,  uuid, (jack_options_t)options, (jack_status_t*)status) < 0)) {
+         delete client;
+         int my_status1 = *status | JackFailure;
+         *status = (jack_status_t)my_status1;
+--- a/common/JackServer.h
++++ b/common/JackServer.h
+@@ -58,7 +58,7 @@
+         JackSynchro fSynchroTable[CLIENT_NUM];
+         bool fFreewheel;
+         
+-        int InternalClientLoadAux(JackLoadableInternalClient* client, const char* so_name, const char* client_name, int options, int* int_ref, int* status);
++        int InternalClientLoadAux(JackLoadableInternalClient* client, const char* so_name, const char* client_name, int options, int* int_ref, int uuid, int* status);
+ 
+     public:
+ 
+@@ -77,8 +77,8 @@
+         // Command thread : API
+         int SetBufferSize(jack_nframes_t buffer_size);
+         int SetFreewheel(bool onoff);
+-        int InternalClientLoad(const char* client_name, const char* so_name, const char* objet_data, int options, int* int_ref, int* status);
+-        int InternalClientLoad(const char* client_name, const char* so_name, const JSList * parameters, int options, int* int_ref, int* status);
++        int InternalClientLoad(const char* client_name, const char* so_name, const char* objet_data, int options, int* int_ref, int uuid, int* status);
++        int InternalClientLoad(const char* client_name, const char* so_name, const JSList * parameters, int options, int* int_ref, int uuid, int* status);
+         void ClientKill(int refnum);
+ 
+         // Transport management
+--- a/common/JackServerAPI.cpp
++++ b/common/JackServerAPI.cpp
+@@ -53,7 +53,7 @@
+ 
+ jack_client_t* jack_client_new_aux(const char* client_name, jack_options_t options, jack_status_t* status)
+ {
+-    jack_varargs_t va;		/* variable arguments */
++    jack_varargs_t va;          /* variable arguments */
+     jack_status_t my_status;
+     JackClient* client;
+ 
+@@ -64,8 +64,8 @@
+ 
+     jack_log("jack_client_new %s", client_name);
+  
+-    if (status == NULL)			/* no status from caller? */
+-        status = &my_status;	/* use local status word */
++    if (status == NULL)         /* no status from caller? */
++        status = &my_status;    /* use local status word */
+     *status = (jack_status_t)0;
+ 
+     /* validate parameters */
+@@ -90,7 +90,7 @@
+         client = new JackInternalClient(JackServerGlobals::fInstance, GetSynchroTable());
+     }
+ 
+-    int res = client->Open(va.server_name, client_name, options, status);
++    int res = client->Open(va.server_name, client_name, va.session_id, options, status);
+     if (res < 0) {
+         delete client;
+         JackServerGlobals::Destroy(); // jack server destruction
+@@ -141,7 +141,7 @@
+         client = new JackInternalClient(JackServerGlobals::fInstance, GetSynchroTable());
+     }
+ 
+-    int res = client->Open(va.server_name, client_name, options, status);
++    int res = client->Open(va.server_name, client_name, va.session_id, options, status);
+     if (res < 0) {
+         delete client;
+         JackServerGlobals::Destroy(); // jack server destruction
+@@ -191,7 +191,7 @@
+     } else {
+         res = client->Close();
+         delete client;
+-        JackServerGlobals::Destroy();	// jack server destruction
++        JackServerGlobals::Destroy();   // jack server destruction
+         jack_log("jack_client_close res = %d", res);
+     }
+     JackGlobals::fOpenMutex->Unlock();
+--- a/common/JackThread.h
++++ b/common/JackThread.h
+@@ -106,6 +106,7 @@
+         int DropSelfRealTime();                 // Used when called from thread itself
+ 
+         pthread_t GetThreadID();
++        bool IsThread();
+ 
+         static int AcquireRealTimeImp(pthread_t thread, int priority);
+         static int AcquireRealTimeImp(pthread_t thread, int priority, UInt64 period, UInt64 computation, UInt64 constraint);
+--- a/common/JackTools.cpp
++++ b/common/JackTools.cpp
+@@ -20,6 +20,7 @@
+ #include "JackConstants.h"
+ #include "JackDriverLoader.h"
+ #include "JackTools.h"
++#include "JackError.h"
+ #include <stdlib.h>
+ #include <stdio.h>
+ #include <assert.h>
+@@ -46,6 +47,15 @@
+     {
+         throw JackNetException();
+     }
++    
++     int JackTools::MkDir(const char* path)
++     {
++#ifdef WIN32
++        return CreateDirectory(path, NULL) == 0;
++#else
++        return mkdir(path, 0777) != 0;
++#endif
++    }
+ 
+ #define DEFAULT_TMP_DIR "/tmp"
+     char* jack_tmpdir = (char*)DEFAULT_TMP_DIR;
+--- a/common/JackTools.h
++++ b/common/JackTools.h
+@@ -22,7 +22,10 @@
+ 
+ #ifdef WIN32
+ #include <windows.h>
++#define DIR_SEPARATOR '\\'
+ #else
++#define DIR_SEPARATOR '/'
++#include <sys/stat.h>
+ #include <sys/types.h>
+ #include <unistd.h>
+ #include <dirent.h>
+@@ -58,6 +61,7 @@
+ 
+         static void KillServer();
+ 
++        static int MkDir(const char* path);
+         static char* UserDir();
+         static char* ServerDir ( const char* server_name, char* server_dir );
+         static const char* DefaultServerName();
+--- a/common/Jackdmp.cpp
++++ b/common/Jackdmp.cpp
+@@ -196,7 +196,7 @@
+                                        { "help", 0, 0, 'h' },
+                                        { "port-max", 1, 0, 'p' },
+                                        { "no-mlock", 0, 0, 'm' },
+-                                       { "name", 0, 0, 'n' },
++                                       { "name", 1, 0, 'n' },
+                                        { "unlock", 0, 0, 'u' },
+                                        { "realtime", 0, 0, 'R' },
+                                        { "no-realtime", 0, 0, 'r' }, 
+@@ -439,7 +439,9 @@
+         goto fail_free1;
+     }
+ 
+-    // Start server
++    // Setup signals then start server
++    signals = jackctl_setup_signals(0);
++   
+     if (!jackctl_server_start(server_ctl, audio_driver_ctl)) {
+         fprintf(stderr, "Failed to start server\n");
+         goto fail_free1;
+@@ -474,7 +476,6 @@
+     notify_server_start(server_name);
+ 
+     // Waits for signal
+-    signals = jackctl_setup_signals(0);
+     jackctl_wait_signals(signals);
+ 
+     if (!jackctl_server_stop(server_ctl))
+--- a/common/jack/jack.h
++++ b/common/jack/jack.h
+@@ -625,13 +625,16 @@
+  * name.  Exceeding that will cause the port registration to fail and
+  * return NULL.
+  *
++ * The @a port_name must be unique among all ports owned by this client.  
++ * If the name is not unique, the registration will fail.  
++ * 
+  * All ports have a type, which may be any non-NULL and non-zero
+  * length string, passed as an argument.  Some port types are built
+  * into the JACK API, currently only JACK_DEFAULT_AUDIO_TYPE.
+  *
+  * @param client pointer to JACK client structure.
+  * @param port_name non-empty short name for the new port (not
+- * including the leading @a "client_name:").
++ * including the leading @a "client_name:"). Must be unique. 
+  * @param port_type port type name.  If longer than
+  * jack_port_type_size(), only that many characters are significant.
+  * @param flags @ref JackPortFlags bit mask.
+--- a/common/jack/midiport.h
++++ b/common/jack/midiport.h
+@@ -105,6 +105,10 @@
+  * messages interspersed with other messages (realtime messages are fine
+  * when they occur on their own, like other messages).
+  *
++ * Events must be written in order, sorted by their sample offsets. 
++ * JACK will not sort the events for you, and will refuse to store  
++ * out-of-order events. 
++ * 
+  * @param port_buffer Buffer to write event to.
+  * @param time Sample offset of event.
+  * @param data_size Length of event's raw data in bytes.
+@@ -122,6 +126,16 @@
+  * This function is simply a wrapper for @ref jack_midi_event_reserve
+  * which writes the event data into the space reserved in the buffer.
+  * The same restrictions on the MIDI data apply.
++ *
++ * Clients must not write more than 
++ * @a data_size bytes into this buffer.  Clients must write normalised 
++ * MIDI data to the port - no running status and no (1-byte) realtime 
++ * messages interspersed with other messages (realtime messages are fine 
++ * when they occur on their own, like other messages). 
++ * 
++ * Events must be written in order, sorted by their sample offsets. 
++ * JACK will not sort the events for you, and will refuse to store  
++ * out-of-order events.
+  * 
+  * @param port_buffer Buffer to write event to.
+  * @param time Sample offset of event.
+--- a/common/jack/types.h
++++ b/common/jack/types.h
+@@ -23,18 +23,17 @@
+ 
+ #include <jack/systemdeps.h>
+ 
+-
+ typedef int32_t jack_shmsize_t;
+ 
+ /**
+  * Type used to represent sample frame counts.
+  */
+-typedef uint32_t	jack_nframes_t;
++typedef uint32_t        jack_nframes_t;
+ 
+ /**
+  * Maximum value that can be stored in jack_nframes_t
+  */
+-#define JACK_MAX_FRAMES (4294967295U)	/* This should be UINT32_MAX, but C++ has a problem with that. */
++#define JACK_MAX_FRAMES (4294967295U)   /* This should be UINT32_MAX, but C++ has a problem with that. */
+ 
+ /**
+  * Type used to represent the value of free running
+@@ -284,9 +283,9 @@
+     /**
+      * JackPortIsTerminal means:
+      *
+-     *	for an input port: the data received by the port
++     *  for an input port: the data received by the port
+      *                    will not be passed on or made
+-     *		           available at any other port
++     *                     available at any other port
+      *
+      * for an output port: the data available at the port
+      *                    does not originate from any other port
+@@ -345,11 +344,16 @@
+      * Pass optional <em>(char *) load_init</em> string to the
+      * jack_initialize() entry point of an internal client.
+      */
+-    JackLoadInit = 0x10
++    JackLoadInit = 0x10,
++
++     /**
++      * pass a SessionID Token this allows the sessionmanager to identify the client again.
++      */
++    JackSessionID = 0x20
+ };
+ 
+ /** Valid options for opening an external client. */
+-#define JackOpenOptions (JackServerName|JackNoStartServer|JackUseExactName)
++#define JackOpenOptions (JackSessionID|JackServerName|JackNoStartServer|JackUseExactName)
+ 
+ /** Valid options for loading an internal client. */
+ #define JackLoadOptions (JackLoadInit|JackLoadName|JackUseExactName)
+@@ -456,20 +460,20 @@
+     JackTransportRolling = 1,       /**< Transport playing */
+     JackTransportLooping = 2,       /**< For OLD_TRANSPORT, now ignored */
+     JackTransportStarting = 3,      /**< Waiting for sync ready */
+-    JackTransportNetStarting = 4, 	/**< Waiting for sync ready on the network*/
++    JackTransportNetStarting = 4,       /**< Waiting for sync ready on the network*/
+ 
+ } jack_transport_state_t;
+ 
+-typedef uint64_t jack_unique_t;		/**< Unique ID (opaque) */
++typedef uint64_t jack_unique_t;         /**< Unique ID (opaque) */
+ 
+ /**
+  * Optional struct jack_position_t fields.
+  */
+ typedef enum {
+ 
+-    JackPositionBBT = 0x10,  	/**< Bar, Beat, Tick */
+-    JackPositionTimecode = 0x20,	/**< External timecode */
+-    JackBBTFrameOffset =      0x40,	/**< Frame offset of BBT information */
++    JackPositionBBT = 0x10,     /**< Bar, Beat, Tick */
++    JackPositionTimecode = 0x20,        /**< External timecode */
++    JackBBTFrameOffset =      0x40,     /**< Frame offset of BBT information */
+     JackAudioVideoRatio =     0x80, /**< audio frames per video frame */
+     JackVideoFrameOffset =   0x100  /**< frame offset of first video frame */
+     
+@@ -482,31 +486,31 @@
+ typedef struct {
+ 
+     /* these four cannot be set from clients: the server sets them */
+-    jack_unique_t	unique_1;	/**< unique ID */
+-    jack_time_t		usecs;		/**< monotonic, free-rolling */
+-    jack_nframes_t	frame_rate;	/**< current frame rate (per second) */
+-    jack_nframes_t	frame;		/**< frame number, always present */
++    jack_unique_t       unique_1;       /**< unique ID */
++    jack_time_t         usecs;          /**< monotonic, free-rolling */
++    jack_nframes_t      frame_rate;     /**< current frame rate (per second) */
++    jack_nframes_t      frame;          /**< frame number, always present */
+ 
+-    jack_position_bits_t valid;		/**< which other fields are valid */
++    jack_position_bits_t valid;         /**< which other fields are valid */
+ 
+     /* JackPositionBBT fields: */
+-    int32_t		bar;		/**< current bar */
+-    int32_t		beat;		/**< current beat-within-bar */
+-    int32_t		tick;		/**< current tick-within-beat */
+-    double		bar_start_tick;
+-
+-    float		beats_per_bar;	/**< time signature "numerator" */
+-    float		beat_type;	/**< time signature "denominator" */
+-    double		ticks_per_beat;
+-    double		beats_per_minute;
+-
+-    /* JackPositionTimecode fields:	(EXPERIMENTAL: could change) */
+-    double		frame_time;	/**< current time in seconds */
+-    double		next_time;	/**< next sequential frame_time
++    int32_t             bar;            /**< current bar */
++    int32_t             beat;           /**< current beat-within-bar */
++    int32_t             tick;           /**< current tick-within-beat */
++    double              bar_start_tick;
++
++    float               beats_per_bar;  /**< time signature "numerator" */
++    float               beat_type;      /**< time signature "denominator" */
++    double              ticks_per_beat;
++    double              beats_per_minute;
++
++    /* JackPositionTimecode fields:     (EXPERIMENTAL: could change) */
++    double              frame_time;     /**< current time in seconds */
++    double              next_time;      /**< next sequential frame_time
+                          (unless repositioned) */
+ 
+     /* JackBBTFrameOffset fields: */
+-    jack_nframes_t	bbt_offset;	/**< frame offset for the BBT fields
++    jack_nframes_t      bbt_offset;     /**< frame offset for the BBT fields
+                          (the given bar, beat, and tick
+                          values actually refer to a time
+                          frame_offset frames before the
+@@ -540,10 +544,10 @@
+     /* For binary compatibility, new fields should be allocated from
+      * this padding area with new valid bits controlling access, so
+      * the existing structure size and offsets are preserved. */
+-    int32_t		padding[7];
++    int32_t             padding[7];
+ 
+     /* When (unique_1 == unique_2) the contents are consistent. */
+-    jack_unique_t	unique_2;	/**< unique ID */
++    jack_unique_t       unique_2;       /**< unique ID */
+ 
+ } jack_position_t;
+ 
+@@ -620,11 +624,11 @@
+  */
+ typedef enum {
+ 
+-    JackTransportState = 0x1,  	/**< Transport state */
+-    JackTransportPosition = 0x2,  	/**< Frame number */
+-    JackTransportLoop = 0x4,  	/**< Loop boundaries (ignored) */
+-    JackTransportSMPTE = 0x8,  	/**< SMPTE (ignored) */
+-    JackTransportBBT = 0x10	/**< Bar, Beat, Tick */
++    JackTransportState = 0x1,   /**< Transport state */
++    JackTransportPosition = 0x2,        /**< Frame number */
++    JackTransportLoop = 0x4,    /**< Loop boundaries (ignored) */
++    JackTransportSMPTE = 0x8,   /**< SMPTE (ignored) */
++    JackTransportBBT = 0x10     /**< Bar, Beat, Tick */
+ 
+ } jack_transport_bits_t;
+ 
+@@ -638,17 +642,17 @@
+ 
+     /* these two cannot be set from clients: the server sets them */
+ 
+-    jack_nframes_t frame_rate;		/**< current frame rate (per second) */
+-    jack_time_t usecs;		/**< monotonic, free-rolling */
++    jack_nframes_t frame_rate;          /**< current frame rate (per second) */
++    jack_time_t usecs;          /**< monotonic, free-rolling */
+ 
+-    jack_transport_bits_t valid;	/**< which fields are legal to read */
++    jack_transport_bits_t valid;        /**< which fields are legal to read */
+     jack_transport_state_t transport_state;
+     jack_nframes_t frame;
+     jack_nframes_t loop_start;
+     jack_nframes_t loop_end;
+ 
+-    long smpte_offset;	/**< SMPTE offset (from frame 0) */
+-    float smpte_frame_rate;	/**< 29.97, 30, 24 etc. */
++    long smpte_offset;  /**< SMPTE offset (from frame 0) */
++    float smpte_frame_rate;     /**< 29.97, 30, 24 etc. */
+ 
+     int bar;
+     int beat;
+--- a/common/varargs.h
++++ b/common/varargs.h
+@@ -32,14 +32,15 @@
+ 
+     /* variable argument structure */
+     typedef struct {
+-        char *server_name;		/* server name */
+-        char *load_name;		/* load module name */
+-        char *load_init;		/* initialization string */
++        char *server_name;              /* server name */
++        char *load_name;                /* load module name */
++        char *load_init;                /* initialization string */
++        int   session_id;               /* requested session_id */
+     }
+     jack_varargs_t;
+ 
+     static const char* jack_default_server_name (void) 
+-	{
++        {
+         const char *server_name;
+         if ((server_name = getenv("JACK_DEFAULT_SERVER")) == NULL)
+             server_name = "default";
+@@ -47,13 +48,14 @@
+     }
+ 
+     static inline void jack_varargs_init (jack_varargs_t *va) 
+-	{
++        {
+         memset (va, 0, sizeof(jack_varargs_t));
+         va->server_name = (char*)jack_default_server_name();
++        va->session_id = -1;
+     }
+ 
+     static inline void jack_varargs_parse (jack_options_t options, va_list ap, jack_varargs_t *va) 
+-	{
++        {
+         // initialize default settings
+         jack_varargs_init (va);
+ 
+@@ -66,6 +68,11 @@
+             va->load_name = va_arg(ap, char *);
+         if ((options & JackLoadInit))
+             va->load_init = va_arg(ap, char *);
++        if ((options & JackSessionID)) {
++            char *sid = va_arg(ap, char *);
++            if (sid)
++                va->session_id = atoi( sid );
++        }
+     }
+ 
+ #ifdef __cplusplus
+--- a/common/wscript
++++ b/common/wscript
+@@ -97,7 +97,7 @@
+             '../posix/JackPosixThread.cpp',
+             '../macosx/JackMachThread.cpp',
+             '../macosx/JackMachSemaphore.cpp',
+-            '../macosx/JackMachPort.cpp',
++            '../posix/JackSocket.cpp',
+             '../macosx/JackMachTime.c',
+             ]
+         includes = ['../macosx', '../macosx/RPC', '../posix'] + includes
+@@ -152,11 +152,9 @@
+ 
+     if bld.env['IS_MACOSX']:
+         serverlib.source += [
+-            '../macosx/JackMachServerChannel.cpp',
+-            '../macosx/JackMachNotifyChannel.cpp',
+-            '../macosx/JackMachServerNotifyChannel.cpp',
+-            '../macosx/JackMacEngineRPC.cpp',
+-            '../macosx/RPC/JackRPCClientUser.c',
++            '../posix/JackSocketServerChannel.cpp',
++            '../posix/JackSocketNotifyChannel.cpp',
++            '../posix/JackSocketServerNotifyChannel.cpp',
+             '../posix/JackNetUnixSocket.cpp',
+             ]
+ 
+@@ -205,9 +203,7 @@
+ 
+     if bld.env['IS_MACOSX']:
+         clientlib.source += [
+-            '../macosx/JackMachClientChannel.cpp',
+-            '../macosx/RPC/JackRPCEngineUser.c',
+-            '../macosx/JackMacLibClientRPC.cpp',
++            '../posix/JackSocketClientChannel.cpp',
+             '../posix/JackPosixServerLaunch.cpp',
+             ]
+ 
+--- a/dbus/controller_iface_patchbay.c
++++ b/dbus/controller_iface_patchbay.c
+@@ -323,7 +323,7 @@
+     list_for_each(node_ptr, &patchbay_ptr->graph.clients)
+     {
+         client_ptr = list_entry(node_ptr, struct jack_graph_client, siblings);
+-        if (strncmp(client_ptr->name, client_name, client_name_len) == 0)
++        if (strlen(client_ptr->name) == client_name_len && strncmp(client_ptr->name, client_name, client_name_len) == 0)
+         {
+             return client_ptr;
+         }
+--- a/doxyfile
++++ b/doxyfile
+@@ -23,7 +23,7 @@
+ # This could be handy for archiving the generated documentation or 
+ # if some version control system is used.
+ 
+-PROJECT_NUMBER         = 1.9.6
++PROJECT_NUMBER         = 1.9.7
+ 
+ # The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) 
+ # base path where the generated documentation will be put. 
+--- a/example-clients/lsp.c
++++ b/example-clients/lsp.c
+@@ -146,7 +146,7 @@
+     if (!ports) 
+         goto error;
+ 
+-	for (i = 0; ports[i]; ++i) {
++	for (i = 0; ports && ports[i]; ++i) {
+ 		// skip over any that don't match ALL of the strings presented at command line
+ 		skip_port = 0;
+ 		for(k = optind; k < argc; k++){
+@@ -227,6 +227,8 @@
+ 	}
+     
+ error:
++    if (ports)
++        jack_free (ports);
+ 	jack_client_close (client);
+ 	exit (0);
+ }
+--- a/example-clients/netsource.c
++++ b/example-clients/netsource.c
+@@ -266,7 +266,7 @@
+ 
+     jack_position_t local_trans_pos;
+ 
+-    uint32_t *packet_buf, *packet_bufX;
++    uint32_t *packet_buf_tx, *packet_bufX;
+     uint32_t *rx_packet_ptr;
+     jack_time_t packet_recv_timestamp;
+ 
+@@ -280,9 +280,9 @@
+ 
+ 
+     /* Allocate a buffer where both In and Out Buffer will fit */
+-    packet_buf = alloca ((rx_bufsize > tx_bufsize) ? rx_bufsize : tx_bufsize);
++    packet_buf_tx = alloca (tx_bufsize);
+ 
+-    jacknet_packet_header *pkthdr = (jacknet_packet_header *) packet_buf;
++    jacknet_packet_header *pkthdr_tx = (jacknet_packet_header *) packet_buf_tx;
+ 
+     /*
+      * for latency==0 we need to send out the packet before we wait on the reply.
+@@ -293,38 +293,38 @@
+ 
+     if( latency == 0 ) {
+ 	    /* reset packet_bufX... */
+-	    packet_bufX = packet_buf + sizeof (jacknet_packet_header) / sizeof (jack_default_audio_sample_t);
++	    packet_bufX = packet_buf_tx + sizeof (jacknet_packet_header) / sizeof (jack_default_audio_sample_t);
+ 
+ 	    /* ---------- Send ---------- */
+ 	    render_jack_ports_to_payload (bitdepth, playback_ports, playback_srcs, nframes,
+ 			    packet_bufX, net_period, dont_htonl_floats);
+ 
+ 	    /* fill in packet hdr */
+-	    pkthdr->transport_state = jack_transport_query (client, &local_trans_pos);
+-	    pkthdr->transport_frame = local_trans_pos.frame;
+-	    pkthdr->framecnt = framecnt;
+-	    pkthdr->latency = latency;
+-	    pkthdr->reply_port = reply_port;
+-	    pkthdr->sample_rate = jack_get_sample_rate (client);
+-	    pkthdr->period_size = nframes;
++	    pkthdr_tx->transport_state = jack_transport_query (client, &local_trans_pos);
++	    pkthdr_tx->transport_frame = local_trans_pos.frame;
++	    pkthdr_tx->framecnt = framecnt;
++	    pkthdr_tx->latency = latency;
++	    pkthdr_tx->reply_port = reply_port;
++	    pkthdr_tx->sample_rate = jack_get_sample_rate (client);
++	    pkthdr_tx->period_size = nframes;
+ 
+ 	    /* playback for us is capture on the other side */
+-	    pkthdr->capture_channels_audio = playback_channels_audio;
+-	    pkthdr->playback_channels_audio = capture_channels_audio;
+-	    pkthdr->capture_channels_midi = playback_channels_midi;
+-	    pkthdr->playback_channels_midi = capture_channels_midi;
+-	    pkthdr->mtu = mtu;
++	    pkthdr_tx->capture_channels_audio = playback_channels_audio;
++	    pkthdr_tx->playback_channels_audio = capture_channels_audio;
++	    pkthdr_tx->capture_channels_midi = playback_channels_midi;
++	    pkthdr_tx->playback_channels_midi = capture_channels_midi;
++	    pkthdr_tx->mtu = mtu;
+ 	    if( freewheeling!= 0 )
+-		    pkthdr->sync_state = (jack_nframes_t)MASTER_FREEWHEELS;
++		    pkthdr_tx->sync_state = (jack_nframes_t)MASTER_FREEWHEELS;
+ 	    else
+-		    pkthdr->sync_state = (jack_nframes_t)deadline_goodness;
++		    pkthdr_tx->sync_state = (jack_nframes_t)deadline_goodness;
+ 	    //printf("goodness=%d\n", deadline_goodness );
+ 
+-	    packet_header_hton (pkthdr);
++	    packet_header_hton (pkthdr_tx);
+ 	    if (cont_miss < 3*latency+5) {
+ 		    int r;
+ 		    for( r=0; r<redundancy; r++ )
+-			    netjack_sendto (outsockfd, (char *) packet_buf, tx_bufsize, 0, &destaddr, sizeof (destaddr), mtu);
++			    netjack_sendto (outsockfd, (char *) packet_buf_tx, tx_bufsize, 0, &destaddr, sizeof (destaddr), mtu);
+ 	    }
+ 	    else if (cont_miss > 50+5*latency)
+ 	    {
+@@ -340,8 +340,6 @@
+      *
+      */
+ 
+-    /* reset packet_bufX... */
+-    packet_bufX = packet_buf + sizeof (jacknet_packet_header) / sizeof (jack_default_audio_sample_t);
+ 
+     if( reply_port )
+ 	input_fd = insockfd;
+@@ -374,14 +372,14 @@
+      * to the JACK ports so it can be played. */
+     if (size == rx_bufsize)
+     {
+-	packet_buf = rx_packet_ptr;
+-	pkthdr = (jacknet_packet_header *) packet_buf;
+-	packet_bufX = packet_buf + sizeof (jacknet_packet_header) / sizeof (jack_default_audio_sample_t);
++	uint32_t *packet_buf_rx = rx_packet_ptr;
++	jacknet_packet_header *pkthdr_rx = (jacknet_packet_header *) packet_buf_rx;
++	packet_bufX = packet_buf_rx + sizeof (jacknet_packet_header) / sizeof (jack_default_audio_sample_t);
+ 	// calculate how much time there would have been, if this packet was sent at the deadline.
+ 
+ 	int recv_time_offset = (int) (jack_get_time() - packet_recv_timestamp);
+-	packet_header_ntoh (pkthdr);
+-	deadline_goodness = recv_time_offset - (int)pkthdr->latency;
++	packet_header_ntoh (pkthdr_rx);
++	deadline_goodness = recv_time_offset - (int)pkthdr_rx->latency;
+ 	//printf( "deadline goodness = %d ---> off: %d\n", deadline_goodness, recv_time_offset );
+ 
+         if (cont_miss)
+@@ -395,7 +393,7 @@
+ 	state_currentframe = framecnt;
+ 	state_recv_packet_queue_time = recv_time_offset;
+ 	state_connected = 1;
+-        sync_state = pkthdr->sync_state;
++        sync_state = pkthdr_rx->sync_state;
+ 	packet_cache_release_packet( global_packcache, framecnt - latency );
+     }
+     /* Second alternative : we've received something that's not
+@@ -434,38 +432,38 @@
+     }
+     if( latency != 0 ) {
+ 	    /* reset packet_bufX... */
+-	    packet_bufX = packet_buf + sizeof (jacknet_packet_header) / sizeof (jack_default_audio_sample_t);
++	    packet_bufX = packet_buf_tx + sizeof (jacknet_packet_header) / sizeof (jack_default_audio_sample_t);
+ 
+ 	    /* ---------- Send ---------- */
+ 	    render_jack_ports_to_payload (bitdepth, playback_ports, playback_srcs, nframes,
+ 			    packet_bufX, net_period, dont_htonl_floats);
+ 
+ 	    /* fill in packet hdr */
+-	    pkthdr->transport_state = jack_transport_query (client, &local_trans_pos);
+-	    pkthdr->transport_frame = local_trans_pos.frame;
+-	    pkthdr->framecnt = framecnt;
+-	    pkthdr->latency = latency;
+-	    pkthdr->reply_port = reply_port;
+-	    pkthdr->sample_rate = jack_get_sample_rate (client);
+-	    pkthdr->period_size = nframes;
++	    pkthdr_tx->transport_state = jack_transport_query (client, &local_trans_pos);
++	    pkthdr_tx->transport_frame = local_trans_pos.frame;
++	    pkthdr_tx->framecnt = framecnt;
++	    pkthdr_tx->latency = latency;
++	    pkthdr_tx->reply_port = reply_port;
++	    pkthdr_tx->sample_rate = jack_get_sample_rate (client);
++	    pkthdr_tx->period_size = nframes;
+ 
+ 	    /* playback for us is capture on the other side */
+-	    pkthdr->capture_channels_audio = playback_channels_audio;
+-	    pkthdr->playback_channels_audio = capture_channels_audio;
+-	    pkthdr->capture_channels_midi = playback_channels_midi;
+-	    pkthdr->playback_channels_midi = capture_channels_midi;
+-	    pkthdr->mtu = mtu;
++	    pkthdr_tx->capture_channels_audio = playback_channels_audio;
++	    pkthdr_tx->playback_channels_audio = capture_channels_audio;
++	    pkthdr_tx->capture_channels_midi = playback_channels_midi;
++	    pkthdr_tx->playback_channels_midi = capture_channels_midi;
++	    pkthdr_tx->mtu = mtu;
+ 	    if( freewheeling!= 0 )
+-		    pkthdr->sync_state = (jack_nframes_t)MASTER_FREEWHEELS;
++		    pkthdr_tx->sync_state = (jack_nframes_t)MASTER_FREEWHEELS;
+ 	    else
+-		    pkthdr->sync_state = (jack_nframes_t)deadline_goodness;
++		    pkthdr_tx->sync_state = (jack_nframes_t)deadline_goodness;
+ 	    //printf("goodness=%d\n", deadline_goodness );
+ 
+-	    packet_header_hton (pkthdr);
++	    packet_header_hton (pkthdr_tx);
+ 	    if (cont_miss < 3*latency+5) {
+ 		    int r;
+ 		    for( r=0; r<redundancy; r++ )
+-			    netjack_sendto (outsockfd, (char *) packet_buf, tx_bufsize, 0, &destaddr, sizeof (destaddr), mtu);
++			    netjack_sendto (outsockfd, (char *) packet_buf_tx, tx_bufsize, 0, &destaddr, sizeof (destaddr), mtu);
+ 	    }
+ 	    else if (cont_miss > 50+5*latency)
+ 	    {
+--- a/example-clients/wscript
++++ b/example-clients/wscript
+@@ -22,6 +22,8 @@
+     'jack_monitor_client' : 'monitor_client.c',
+     'jack_thru' : 'thru_client.c',
+     'jack_cpu_load' : 'cpu_load.c',
++    'jack_simple_session_client' : 'simple_session_client.c',
++    'jack_session_notify' : 'session_notify.c',
+     'jack_server_control' : 'server_control.cpp',
+     }
+ 
+--- a/linux/alsa/JackAlsaDriver.cpp
++++ b/linux/alsa/JackAlsaDriver.cpp
+@@ -120,7 +120,7 @@
+         char tmp[5];
+         strncpy(tmp, strstr(device_name, "hw"), 4);
+         tmp[4] = '\0';
+-        //jack_log("control device %s", tmp);
++        jack_info("control device %s",tmp);
+         ctl_name = strdup(tmp);
+     } else {
+         ctl_name = strdup(device_name);
+@@ -151,21 +151,16 @@
+     if ((err = snd_ctl_open (&driver->ctl_handle, ctl_name, 0)) < 0) {
+         jack_error ("control open \"%s\" (%s)", ctl_name,
+                     snd_strerror(err));
+-        return -1;
+-    }
+-
+-    if ((err = snd_ctl_card_info(driver->ctl_handle, card_info)) < 0) {
++    } else if ((err = snd_ctl_card_info(driver->ctl_handle, card_info)) < 0) {
+         jack_error ("control hardware info \"%s\" (%s)",
+                     driver->alsa_name_playback, snd_strerror (err));
+         snd_ctl_close (driver->ctl_handle);
+-        return -1;
+     }
+ 
+     driver->alsa_driver = strdup(snd_ctl_card_info_get_driver (card_info));
+     jack_info("Using ALSA driver %s running on card %i - %s", driver->alsa_driver, snd_ctl_card_info_get_card(card_info), snd_ctl_card_info_get_longname(card_info));
+ 
+     free(ctl_name);
+-
+     return alsa_driver_check_capabilities (driver);
+ }
+ 
+@@ -1171,7 +1166,6 @@
+ 
+     if (res && driver->midi)
+ 	(driver->midi->stop)(driver->midi);
+-
+     return res;
+ }
+ 
+@@ -1181,8 +1175,6 @@
+     snd_pcm_status_t *status;
+     int res;
+ 
+-    jack_error("alsa_driver_xrun_recovery");
+-
+     snd_pcm_status_alloca(&status);
+ 
+     if (driver->capture_handle) {
+@@ -1196,6 +1188,19 @@
+             jack_error("status error: %s", snd_strerror(res));
+         }
+     }
++    
++    if (snd_pcm_status_get_state(status) == SND_PCM_STATE_SUSPENDED) { 
++        jack_error("**** alsa_pcm: pcm in suspended state, resuming it" ); 
++        if (driver->capture_handle) { 
++            if ((res = snd_pcm_prepare(driver->capture_handle)) < 0) { 
++                    jack_error("error preparing after suspend: %s", snd_strerror(res)); 
++            } 
++        } else { 
++            if ((res = snd_pcm_prepare(driver->playback_handle)) < 0) { 
++                    jack_error("error preparing after suspend: %s", snd_strerror(res)); 
++            } 
++        } 
++    } 
+ 
+     if (snd_pcm_status_get_state(status) == SND_PCM_STATE_XRUN
+             && driver->process_count > XRUN_REPORT_DELAY) {
+@@ -1205,7 +1210,7 @@
+         snd_pcm_status_get_trigger_tstamp(status, &tstamp);
+         timersub(&now, &tstamp, &diff);
+         *delayed_usecs = diff.tv_sec * 1000000.0 + diff.tv_usec;
+-        jack_error("\n\n**** alsa_pcm: xrun of at least %.3f msecs\n\n", *delayed_usecs / 1000.0);
++        jack_error("**** alsa_pcm: xrun of at least %.3f msecs", *delayed_usecs / 1000.0);
+     }
+ 
+     if (alsa_driver_restart (driver)) {
+@@ -1371,7 +1376,7 @@
+ 			/* if POLLIN was the only bit set, we're OK */
+ 
+ 			*status = 0;
+-            if (driver->pfd[nfds-1].revents == POLLIN) {
++            if (driver->pfd[nfds-1].revents != POLLIN) {
+                 jack_error("driver->pfd[nfds-1].revents == POLLIN");
+             }
+ 			return (driver->pfd[nfds-1].revents == POLLIN) ? 0 : -1;
+@@ -1585,7 +1590,6 @@
+          
+             jack_error ("ALSA: could not complete read of %"
+             		PRIu32 " frames: error = %d\n", contiguous, err);
+-            jack_error ("ALSA: could not complete read of %d frames: error = %d", contiguous, err);
+             return -1;
+         }
+ 
+@@ -1725,7 +1729,6 @@
+                                         offset, contiguous)) < 0) {
+             jack_error ("ALSA: could not complete playback of %"
+             		PRIu32 " frames: error = %d", contiguous, err);
+-            jack_error ("ALSA: could not complete playback of %d frames: error = %d", contiguous, err);
+             if (err != EPIPE && err != ESTRPIPE)
+                 return -1;
+         }
+@@ -1751,11 +1754,6 @@
+     jack_slist_free (driver->clock_sync_listeners);
+     
+     if (driver->ctl_handle) {
+-		snd_ctl_close (driver->ctl_handle);
+-		driver->ctl_handle = 0;
+-	} 
+-
+-    if (driver->ctl_handle) {
+         snd_ctl_close (driver->ctl_handle);
+         driver->ctl_handle = 0;
+     } 
+@@ -2328,6 +2326,8 @@
+     jack_nframes_t nframes;
+     fDelayedUsecs = 0.f;
+ 
++retry:
++
+     nframes = alsa_driver_wait((alsa_driver_t *)fDriver, -1, &wait_status, &fDelayedUsecs);
+  
+     if (wait_status < 0)
+@@ -2339,11 +2339,11 @@
+          */
+         jack_log("ALSA XRun wait_status = %d", wait_status);
+         NotifyXRun(fBeginDateUst, fDelayedUsecs);
+-        return -1;
++        goto retry; /* recoverable error*/
+     }
+ 
+     if (nframes != fEngineControl->fBufferSize)
+-        jack_log("JackAlsaDriver::Read error nframes = %ld", nframes);
++        jack_log("JackAlsaDriver::Read warning nframes = %ld", nframes);
+         
+     // Has to be done before read
+     JackDriver::CycleIncTime();
+@@ -2631,352 +2631,352 @@
+     return constraint_ptr;
+ }
+ 
+-    static int
+-    dither_opt (char c, DitherAlgorithm* dither) 
+-    {
+-        switch (c) {
+-            case '-':
+-            case 'n':
+-                *dither = None;
+-                break;
+-
+-            case 'r':
+-                *dither = Rectangular;
+-                break;
+-
+-            case 's':
+-                *dither = Shaped;
+-                break;
+-
+-            case 't':
+-                *dither = Triangular;
+-                break;
+-
+-            default:
+-                fprintf (stderr, "ALSA driver: illegal dithering mode %c\n", c);
+-                return -1;
+-        }
+-        return 0;
+-    }
+-
+-    SERVER_EXPORT const jack_driver_desc_t* driver_get_descriptor () 
+-    {
+-        jack_driver_desc_t * desc;
+-        jack_driver_param_desc_t * params;
+-        unsigned int i;
+-
+-        desc = (jack_driver_desc_t*)calloc (1, sizeof (jack_driver_desc_t));
+-        
+-        strcpy(desc->name, "alsa");                                    // size MUST be less then JACK_DRIVER_NAME_MAX + 1
+-        strcpy(desc->desc, "Linux ALSA API based audio backend");      // size MUST be less then JACK_DRIVER_PARAM_DESC + 1
+-        
+-        desc->nparams = 18;
+-        params = (jack_driver_param_desc_t*)calloc (desc->nparams, sizeof (jack_driver_param_desc_t));
+-
+-        i = 0;
+-        strcpy (params[i].name, "capture");
+-        params[i].character = 'C';
+-        params[i].type = JackDriverParamString;
+-        strcpy (params[i].value.str, "none");
+-        strcpy (params[i].short_desc,
+-                "Provide capture ports.  Optionally set device");
+-        strcpy (params[i].long_desc, params[i].short_desc);
+-
+-        i++;
+-        strcpy (params[i].name, "playback");
+-        params[i].character = 'P';
+-        params[i].type = JackDriverParamString;
+-        strcpy (params[i].value.str, "none");
+-        strcpy (params[i].short_desc,
+-                "Provide playback ports.  Optionally set device");
+-        strcpy (params[i].long_desc, params[i].short_desc);
+-
+-        i++;
+-        strcpy (params[i].name, "device");
+-        params[i].character = 'd';
+-        params[i].type = JackDriverParamString;
+-        strcpy (params[i].value.str, "hw:0");
+-        strcpy (params[i].short_desc, "ALSA device name");
+-        strcpy (params[i].long_desc, params[i].short_desc);
+-        params[i].constraint = enum_alsa_devices();
+-
+-        i++;
+-        strcpy (params[i].name, "rate");
+-        params[i].character = 'r';
+-        params[i].type = JackDriverParamUInt;
+-        params[i].value.ui = 48000U;
+-        strcpy (params[i].short_desc, "Sample rate");
+-        strcpy (params[i].long_desc, params[i].short_desc);
+-
+-        i++;
+-        strcpy (params[i].name, "period");
+-        params[i].character = 'p';
+-        params[i].type = JackDriverParamUInt;
+-        params[i].value.ui = 1024U;
+-        strcpy (params[i].short_desc, "Frames per period");
+-        strcpy (params[i].long_desc, params[i].short_desc);
+-
+-        i++;
+-        strcpy (params[i].name, "nperiods");
+-        params[i].character = 'n';
+-        params[i].type = JackDriverParamUInt;
+-        params[i].value.ui = 2U;
+-        strcpy (params[i].short_desc, "Number of periods of playback latency");
+-        strcpy (params[i].long_desc, params[i].short_desc);
+-
+-        i++;
+-        strcpy (params[i].name, "hwmon");
+-        params[i].character = 'H';
+-        params[i].type = JackDriverParamBool;
+-        params[i].value.i = 0;
+-        strcpy (params[i].short_desc, "Hardware monitoring, if available");
+-        strcpy (params[i].long_desc, params[i].short_desc);
+-
+-        i++;
+-        strcpy (params[i].name, "hwmeter");
+-        params[i].character = 'M';
+-        params[i].type = JackDriverParamBool;
+-        params[i].value.i = 0;
+-        strcpy (params[i].short_desc, "Hardware metering, if available");
+-        strcpy (params[i].long_desc, params[i].short_desc);
+-
+-        i++;
+-        strcpy (params[i].name, "duplex");
+-        params[i].character = 'D';
+-        params[i].type = JackDriverParamBool;
+-        params[i].value.i = 1;
+-        strcpy (params[i].short_desc,
+-                "Provide both capture and playback ports");
+-        strcpy (params[i].long_desc, params[i].short_desc);
+-
+-        i++;
+-        strcpy (params[i].name, "softmode");
+-        params[i].character = 's';
+-        params[i].type = JackDriverParamBool;
+-        params[i].value.i = 0;
+-        strcpy (params[i].short_desc, "Soft-mode, no xrun handling");
+-        strcpy (params[i].long_desc, params[i].short_desc);
+-
+-        i++;
+-        strcpy (params[i].name, "monitor");
+-        params[i].character = 'm';
+-        params[i].type = JackDriverParamBool;
+-        params[i].value.i = 0;
+-        strcpy (params[i].short_desc, "Provide monitor ports for the output");
+-        strcpy (params[i].long_desc, params[i].short_desc);
+-
+-        i++;
+-        strcpy (params[i].name, "dither");
+-        params[i].character = 'z';
+-        params[i].type = JackDriverParamChar;
+-        params[i].value.c = 'n';
+-        strcpy (params[i].short_desc, "Dithering mode");
+-        strcpy (params[i].long_desc,
+-                "Dithering mode:\n"
+-                "  n - none\n"
+-                "  r - rectangular\n"
+-                "  s - shaped\n"
+-                "  t - triangular");
+-        params[i].constraint = get_dither_constraint();
+-
+-        i++;
+-        strcpy (params[i].name, "inchannels");
+-        params[i].character = 'i';
+-        params[i].type = JackDriverParamUInt;
+-        params[i].value.i = 0;
+-        strcpy (params[i].short_desc,
+-                "Number of capture channels (defaults to hardware max)");
+-        strcpy (params[i].long_desc, params[i].short_desc);
+-
+-        i++;
+-        strcpy (params[i].name, "outchannels");
+-        params[i].character = 'o';
+-        params[i].type = JackDriverParamUInt;
+-        params[i].value.i = 0;
+-        strcpy (params[i].short_desc,
+-                "Number of playback channels (defaults to hardware max)");
+-        strcpy (params[i].long_desc, params[i].short_desc);
+-
+-        i++;
+-        strcpy (params[i].name, "shorts");
+-        params[i].character = 'S';
+-        params[i].type = JackDriverParamBool;
+-        params[i].value.i = FALSE;
+-        strcpy (params[i].short_desc, "Try 16-bit samples before 32-bit");
+-        strcpy (params[i].long_desc, params[i].short_desc);
+-
+-        i++;
+-        strcpy (params[i].name, "input-latency");
+-        params[i].character = 'I';
+-        params[i].type = JackDriverParamUInt;
+-        params[i].value.i = 0;
+-        strcpy (params[i].short_desc, "Extra input latency (frames)");
+-        strcpy (params[i].long_desc, params[i].short_desc);
+-
+-        i++;
+-        strcpy (params[i].name, "output-latency");
+-        params[i].character = 'O';
+-        params[i].type = JackDriverParamUInt;
+-        params[i].value.i = 0;
+-        strcpy (params[i].short_desc, "Extra output latency (frames)");
+-        strcpy (params[i].long_desc, params[i].short_desc);
+-
+-        i++;
+-        strcpy (params[i].name, "midi-driver");
+-        params[i].character = 'X';
+-        params[i].type = JackDriverParamString;
+-        strcpy (params[i].value.str, "none");
+-        strcpy (params[i].short_desc, "ALSA MIDI driver name (seq|raw)");
+-        strcpy (params[i].long_desc,
+-                "ALSA MIDI driver:\n"
+-                " none - no MIDI driver\n"
+-                " seq - ALSA Sequencer driver\n"
+-                " raw - ALSA RawMIDI driver\n");
+-        params[i].constraint = get_midi_driver_constraint();
++static int
++dither_opt (char c, DitherAlgorithm* dither) 
++{
++    switch (c) {
++        case '-':
++        case 'n':
++            *dither = None;
++            break;
++
++        case 'r':
++            *dither = Rectangular;
++            break;
++
++        case 's':
++            *dither = Shaped;
++            break;
++
++        case 't':
++            *dither = Triangular;
++            break;
+ 
+-        desc->params = params;
+-        return desc;
++        default:
++            fprintf (stderr, "ALSA driver: illegal dithering mode %c\n", c);
++            return -1;
+     }
++    return 0;
++}
+ 
+-    SERVER_EXPORT Jack::JackDriverClientInterface* driver_initialize(Jack::JackLockedEngine* engine, Jack::JackSynchro* table, const JSList* params) 
+-    {
+-        jack_nframes_t srate = 48000;
+-        jack_nframes_t frames_per_interrupt = 1024;
+-        unsigned long user_nperiods = 2;
+-        const char *playback_pcm_name = "hw:0";
+-        const char *capture_pcm_name = "hw:0";
+-        int hw_monitoring = FALSE;
+-        int hw_metering = FALSE;
+-        int capture = FALSE;
+-        int playback = FALSE;
+-        int soft_mode = FALSE;
+-        int monitor = FALSE;
+-        DitherAlgorithm dither = None;
+-        int user_capture_nchnls = 0;
+-        int user_playback_nchnls = 0;
+-        int shorts_first = FALSE;
+-        jack_nframes_t systemic_input_latency = 0;
+-        jack_nframes_t systemic_output_latency = 0;
+-        const JSList * node;
+-        const jack_driver_param_t * param;
+-        const char *midi_driver = "none";
+-
+-        for (node = params; node; node = jack_slist_next (node)) {
+-            param = (const jack_driver_param_t *) node->data;
+-
+-            switch (param->character) {
+-
+-                case 'C':
+-                    capture = TRUE;
+-                    if (strcmp (param->value.str, "none") != 0) {
+-                        capture_pcm_name = strdup (param->value.str);
+-                        jack_log("capture device %s", capture_pcm_name);
+-                    }
+-                    break;
++SERVER_EXPORT const jack_driver_desc_t* driver_get_descriptor () 
++{
++    jack_driver_desc_t * desc;
++    jack_driver_param_desc_t * params;
++    unsigned int i;
+ 
+-                case 'P':
+-                    playback = TRUE;
+-                    if (strcmp (param->value.str, "none") != 0) {
+-                        playback_pcm_name = strdup (param->value.str);
+-                        jack_log("playback device %s", playback_pcm_name);
+-                    }
+-                    break;
++    desc = (jack_driver_desc_t*)calloc (1, sizeof (jack_driver_desc_t));
++    
++    strcpy(desc->name, "alsa");                                    // size MUST be less then JACK_DRIVER_NAME_MAX + 1
++    strcpy(desc->desc, "Linux ALSA API based audio backend");      // size MUST be less then JACK_DRIVER_PARAM_DESC + 1
++    
++    desc->nparams = 18;
++    params = (jack_driver_param_desc_t*)calloc (desc->nparams, sizeof (jack_driver_param_desc_t));
+ 
+-                case 'D':
+-                    playback = TRUE;
+-                    capture = TRUE;
+-                    break;
++    i = 0;
++    strcpy (params[i].name, "capture");
++    params[i].character = 'C';
++    params[i].type = JackDriverParamString;
++    strcpy (params[i].value.str, "none");
++    strcpy (params[i].short_desc,
++            "Provide capture ports.  Optionally set device");
++    strcpy (params[i].long_desc, params[i].short_desc);
++
++    i++;
++    strcpy (params[i].name, "playback");
++    params[i].character = 'P';
++    params[i].type = JackDriverParamString;
++    strcpy (params[i].value.str, "none");
++    strcpy (params[i].short_desc,
++            "Provide playback ports.  Optionally set device");
++    strcpy (params[i].long_desc, params[i].short_desc);
++
++    i++;
++    strcpy (params[i].name, "device");
++    params[i].character = 'd';
++    params[i].type = JackDriverParamString;
++    strcpy (params[i].value.str, "hw:0");
++    strcpy (params[i].short_desc, "ALSA device name");
++    strcpy (params[i].long_desc, params[i].short_desc);
++    params[i].constraint = enum_alsa_devices();
++
++    i++;
++    strcpy (params[i].name, "rate");
++    params[i].character = 'r';
++    params[i].type = JackDriverParamUInt;
++    params[i].value.ui = 48000U;
++    strcpy (params[i].short_desc, "Sample rate");
++    strcpy (params[i].long_desc, params[i].short_desc);
++
++    i++;
++    strcpy (params[i].name, "period");
++    params[i].character = 'p';
++    params[i].type = JackDriverParamUInt;
++    params[i].value.ui = 1024U;
++    strcpy (params[i].short_desc, "Frames per period");
++    strcpy (params[i].long_desc, params[i].short_desc);
++
++    i++;
++    strcpy (params[i].name, "nperiods");
++    params[i].character = 'n';
++    params[i].type = JackDriverParamUInt;
++    params[i].value.ui = 2U;
++    strcpy (params[i].short_desc, "Number of periods of playback latency");
++    strcpy (params[i].long_desc, params[i].short_desc);
++
++    i++;
++    strcpy (params[i].name, "hwmon");
++    params[i].character = 'H';
++    params[i].type = JackDriverParamBool;
++    params[i].value.i = 0;
++    strcpy (params[i].short_desc, "Hardware monitoring, if available");
++    strcpy (params[i].long_desc, params[i].short_desc);
++
++    i++;
++    strcpy (params[i].name, "hwmeter");
++    params[i].character = 'M';
++    params[i].type = JackDriverParamBool;
++    params[i].value.i = 0;
++    strcpy (params[i].short_desc, "Hardware metering, if available");
++    strcpy (params[i].long_desc, params[i].short_desc);
++
++    i++;
++    strcpy (params[i].name, "duplex");
++    params[i].character = 'D';
++    params[i].type = JackDriverParamBool;
++    params[i].value.i = 1;
++    strcpy (params[i].short_desc,
++            "Provide both capture and playback ports");
++    strcpy (params[i].long_desc, params[i].short_desc);
++
++    i++;
++    strcpy (params[i].name, "softmode");
++    params[i].character = 's';
++    params[i].type = JackDriverParamBool;
++    params[i].value.i = 0;
++    strcpy (params[i].short_desc, "Soft-mode, no xrun handling");
++    strcpy (params[i].long_desc, params[i].short_desc);
++
++    i++;
++    strcpy (params[i].name, "monitor");
++    params[i].character = 'm';
++    params[i].type = JackDriverParamBool;
++    params[i].value.i = 0;
++    strcpy (params[i].short_desc, "Provide monitor ports for the output");
++    strcpy (params[i].long_desc, params[i].short_desc);
++
++    i++;
++    strcpy (params[i].name, "dither");
++    params[i].character = 'z';
++    params[i].type = JackDriverParamChar;
++    params[i].value.c = 'n';
++    strcpy (params[i].short_desc, "Dithering mode");
++    strcpy (params[i].long_desc,
++            "Dithering mode:\n"
++            "  n - none\n"
++            "  r - rectangular\n"
++            "  s - shaped\n"
++            "  t - triangular");
++    params[i].constraint = get_dither_constraint();
++
++    i++;
++    strcpy (params[i].name, "inchannels");
++    params[i].character = 'i';
++    params[i].type = JackDriverParamUInt;
++    params[i].value.i = 0;
++    strcpy (params[i].short_desc,
++            "Number of capture channels (defaults to hardware max)");
++    strcpy (params[i].long_desc, params[i].short_desc);
++
++    i++;
++    strcpy (params[i].name, "outchannels");
++    params[i].character = 'o';
++    params[i].type = JackDriverParamUInt;
++    params[i].value.i = 0;
++    strcpy (params[i].short_desc,
++            "Number of playback channels (defaults to hardware max)");
++    strcpy (params[i].long_desc, params[i].short_desc);
++
++    i++;
++    strcpy (params[i].name, "shorts");
++    params[i].character = 'S';
++    params[i].type = JackDriverParamBool;
++    params[i].value.i = FALSE;
++    strcpy (params[i].short_desc, "Try 16-bit samples before 32-bit");
++    strcpy (params[i].long_desc, params[i].short_desc);
++
++    i++;
++    strcpy (params[i].name, "input-latency");
++    params[i].character = 'I';
++    params[i].type = JackDriverParamUInt;
++    params[i].value.i = 0;
++    strcpy (params[i].short_desc, "Extra input latency (frames)");
++    strcpy (params[i].long_desc, params[i].short_desc);
++
++    i++;
++    strcpy (params[i].name, "output-latency");
++    params[i].character = 'O';
++    params[i].type = JackDriverParamUInt;
++    params[i].value.i = 0;
++    strcpy (params[i].short_desc, "Extra output latency (frames)");
++    strcpy (params[i].long_desc, params[i].short_desc);
++
++    i++;
++    strcpy (params[i].name, "midi-driver");
++    params[i].character = 'X';
++    params[i].type = JackDriverParamString;
++    strcpy (params[i].value.str, "none");
++    strcpy (params[i].short_desc, "ALSA MIDI driver name (seq|raw)");
++    strcpy (params[i].long_desc,
++            "ALSA MIDI driver:\n"
++            " none - no MIDI driver\n"
++            " seq - ALSA Sequencer driver\n"
++            " raw - ALSA RawMIDI driver\n");
++    params[i].constraint = get_midi_driver_constraint();
++
++    desc->params = params;
++    return desc;
++}
++
++SERVER_EXPORT Jack::JackDriverClientInterface* driver_initialize(Jack::JackLockedEngine* engine, Jack::JackSynchro* table, const JSList* params) 
++{
++    jack_nframes_t srate = 48000;
++    jack_nframes_t frames_per_interrupt = 1024;
++    unsigned long user_nperiods = 2;
++    const char *playback_pcm_name = "hw:0";
++    const char *capture_pcm_name = "hw:0";
++    int hw_monitoring = FALSE;
++    int hw_metering = FALSE;
++    int capture = FALSE;
++    int playback = FALSE;
++    int soft_mode = FALSE;
++    int monitor = FALSE;
++    DitherAlgorithm dither = None;
++    int user_capture_nchnls = 0;
++    int user_playback_nchnls = 0;
++    int shorts_first = FALSE;
++    jack_nframes_t systemic_input_latency = 0;
++    jack_nframes_t systemic_output_latency = 0;
++    const JSList * node;
++    const jack_driver_param_t * param;
++    const char *midi_driver = "none";
++
++    for (node = params; node; node = jack_slist_next (node)) {
++        param = (const jack_driver_param_t *) node->data;
++
++        switch (param->character) {
++
++            case 'C':
++                capture = TRUE;
++                if (strcmp (param->value.str, "none") != 0) {
++                    capture_pcm_name = strdup (param->value.str);
++                    jack_log("capture device %s", capture_pcm_name);
++                }
++                break;
+ 
+-                case 'd':
++            case 'P':
++                playback = TRUE;
++                if (strcmp (param->value.str, "none") != 0) {
+                     playback_pcm_name = strdup (param->value.str);
+-                    capture_pcm_name = strdup (param->value.str);
+                     jack_log("playback device %s", playback_pcm_name);
+-                    jack_log("capture device %s", capture_pcm_name);
+-                    break;
++                }
++                break;
+ 
+-                case 'H':
+-                    hw_monitoring = param->value.i;
+-                    break;
++            case 'D':
++                playback = TRUE;
++                capture = TRUE;
++                break;
+ 
+-                case 'm':
+-                    monitor = param->value.i;
+-                    break;
++            case 'd':
++                playback_pcm_name = strdup (param->value.str);
++                capture_pcm_name = strdup (param->value.str);
++                jack_log("playback device %s", playback_pcm_name);
++                jack_log("capture device %s", capture_pcm_name);
++                break;
+ 
+-                case 'M':
+-                    hw_metering = param->value.i;
+-                    break;
++            case 'H':
++                hw_monitoring = param->value.i;
++                break;
+ 
+-                case 'r':
+-                    srate = param->value.ui;
+-                    jack_log("apparent rate = %d", srate);
+-                    break;
++            case 'm':
++                monitor = param->value.i;
++                break;
+ 
+-                case 'p':
+-                    frames_per_interrupt = param->value.ui;
+-                    jack_log("frames per period = %d", frames_per_interrupt);
+-                    break;
++            case 'M':
++                hw_metering = param->value.i;
++                break;
+ 
+-                case 'n':
+-                    user_nperiods = param->value.ui;
+-                    if (user_nperiods < 2)	/* enforce minimum value */
+-                        user_nperiods = 2;
+-                    break;
++            case 'r':
++                srate = param->value.ui;
++                jack_log("apparent rate = %d", srate);
++                break;
+ 
+-                case 's':
+-                    soft_mode = param->value.i;
+-                    break;
++            case 'p':
++                frames_per_interrupt = param->value.ui;
++                jack_log("frames per period = %d", frames_per_interrupt);
++                break;
+ 
+-                case 'z':
+-                    if (dither_opt (param->value.c, &dither)) {
+-                        return NULL;
+-                    }
+-                    break;
++            case 'n':
++                user_nperiods = param->value.ui;
++                if (user_nperiods < 2)	/* enforce minimum value */
++                    user_nperiods = 2;
++                break;
+ 
+-                case 'i':
+-                    user_capture_nchnls = param->value.ui;
+-                    break;
++            case 's':
++                soft_mode = param->value.i;
++                break;
+ 
+-                case 'o':
+-                    user_playback_nchnls = param->value.ui;
+-                    break;
++            case 'z':
++                if (dither_opt (param->value.c, &dither)) {
++                    return NULL;
++                }
++                break;
+ 
+-                case 'S':
+-                    shorts_first = param->value.i;
+-                    break;
++            case 'i':
++                user_capture_nchnls = param->value.ui;
++                break;
+ 
+-                case 'I':
+-                    systemic_input_latency = param->value.ui;
+-                    break;
++            case 'o':
++                user_playback_nchnls = param->value.ui;
++                break;
+ 
+-                case 'O':
+-                    systemic_output_latency = param->value.ui;
+-                    break;
++            case 'S':
++                shorts_first = param->value.i;
++                break;
+ 
+-                case 'X':
+-                    midi_driver = strdup(param->value.str);
+-                    break;
+-            }
+-        }
++            case 'I':
++                systemic_input_latency = param->value.ui;
++                break;
+ 
+-        /* duplex is the default */
+-        if (!capture && !playback) {
+-            capture = TRUE;
+-            playback = TRUE;
+-        }
++            case 'O':
++                systemic_output_latency = param->value.ui;
++                break;
+ 
+-        Jack::JackAlsaDriver* alsa_driver = new Jack::JackAlsaDriver("system", "alsa_pcm", engine, table);
+-        Jack::JackDriverClientInterface* threaded_driver = new Jack::JackThreadedDriver(alsa_driver);
+-        // Special open for ALSA driver...
+-        if (alsa_driver->Open(frames_per_interrupt, user_nperiods, srate, hw_monitoring, hw_metering, capture, playback, dither, soft_mode, monitor,
+-                              user_capture_nchnls, user_playback_nchnls, shorts_first, capture_pcm_name, playback_pcm_name,
+-                              systemic_input_latency, systemic_output_latency, midi_driver) == 0) {
+-            return threaded_driver;
+-        } else {
+-            delete threaded_driver; // Delete the decorated driver
+-            return NULL;
++            case 'X':
++                midi_driver = strdup(param->value.str);
++                break;
+         }
+     }
+ 
++    /* duplex is the default */
++    if (!capture && !playback) {
++        capture = TRUE;
++        playback = TRUE;
++    }
++
++    Jack::JackAlsaDriver* alsa_driver = new Jack::JackAlsaDriver("system", "alsa_pcm", engine, table);
++    Jack::JackDriverClientInterface* threaded_driver = new Jack::JackThreadedDriver(alsa_driver);
++    // Special open for ALSA driver...
++    if (alsa_driver->Open(frames_per_interrupt, user_nperiods, srate, hw_monitoring, hw_metering, capture, playback, dither, soft_mode, monitor,
++                          user_capture_nchnls, user_playback_nchnls, shorts_first, capture_pcm_name, playback_pcm_name,
++                          systemic_input_latency, systemic_output_latency, midi_driver) == 0) {
++        return threaded_driver;
++    } else {
++        delete threaded_driver; // Delete the decorated driver
++        return NULL;
++    }
++}
++
+ #ifdef __cplusplus
+ }
+ #endif
+--- a/linux/firewire/JackFFADODriver.cpp
++++ b/linux/firewire/JackFFADODriver.cpp
+@@ -664,6 +664,8 @@
+     int wait_status = 0;
+     fDelayedUsecs = 0.f;
+ 
++retry:
++
+     jack_nframes_t nframes = ffado_driver_wait(driver, -1, &wait_status,
+                              &fDelayedUsecs);
+ 
+@@ -678,11 +680,11 @@
+          */
+         jack_log("FFADO XRun");
+         NotifyXRun(fBeginDateUst, fDelayedUsecs);
+-        return -1;
++        goto retry; /* recoverable error*/
+     }
+ 
+     if (nframes != fEngineControl->fBufferSize)
+-        jack_log("JackFFADODriver::Read nframes = %ld", nframes);
++        jack_log("JackFFADODriver::Read warning nframes = %ld", nframes);
+         
+     // Has to be done before read
+     JackDriver::CycleIncTime();
+--- a/linux/freebob/JackFreebobDriver.cpp
++++ b/linux/freebob/JackFreebobDriver.cpp
+@@ -854,6 +854,8 @@
+     int wait_status = 0;
+     fDelayedUsecs = 0.f;
+ 
++retry:
++
+     jack_nframes_t nframes = freebob_driver_wait (driver, -1, &wait_status,
+                              &fDelayedUsecs);
+ 
+@@ -868,11 +870,11 @@
+          */
+         jack_log("FreeBoB XRun");
+         NotifyXRun(fBeginDateUst, fDelayedUsecs);
+-        return -1;
++        goto retry; /* recoverable error*/
+     }
+ 
+     if (nframes != fEngineControl->fBufferSize)
+-        jack_log("JackFreebobDriver::Read nframes = %ld", nframes);
++        jack_log("JackFreebobDriver::Read warning nframes = %ld", nframes);
+ 
+     // Has to be done before read
+     JackDriver::CycleIncTime();
+--- a/macosx/Jack-Info.plist
++++ b/macosx/Jack-Info.plist
+@@ -7,7 +7,7 @@
+ 	<key>CFBundleExecutable</key>
+ 	<string>Jackservermp</string>
+ 	<key>CFBundleGetInfoString</key>
+-	<string>Jackdmp 1.9.6, @03-10 Paul Davis, Grame</string>
++	<string>Jackdmp 1.9.7, @03-10 Paul Davis, Grame</string>
+ 	<key>CFBundleIdentifier</key>
+ 	<string>com.grame.Jackmp</string>
+ 	<key>CFBundleInfoDictionaryVersion</key>
+@@ -19,6 +19,6 @@
+ 	<key>CFBundleSignature</key>
+ 	<string>????</string>
+ 	<key>CFBundleVersion</key>
+-	<string>1.9.6</string>
++	<string>1.9.7</string>
+ </dict>
+ </plist>
+--- a/macosx/JackMacEngineRPC.cpp
++++ /dev/null
+@@ -1,250 +0,0 @@
+-/*
+-Copyright (C) 2004-2008 Grame
+-
+-This program is free software; you can redistribute it and/or modify
+-  it under the terms of the GNU General Public License as published by
+-  the Free Software Foundation; either version 2 of the License, or
+-  (at your option) any later version.
+-
+-  This program is distributed in the hope that it will be useful,
+-  but WITHOUT ANY WARRANTY; without even the implied warranty of
+-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+-  GNU General Public License for more details.
+-
+-  You should have received a copy of the GNU General Public License
+-  along with this program; if not, write to the Free Software
+-  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+-
+-*/
+-
+-#include "JackServer.h"
+-#include "JackNotification.h"
+-#include "JackLockedEngine.h"
+-#include "JackRPCEngine.h"
+-#include "JackMachServerChannel.h"
+-#include "JackException.h"
+-#include <assert.h>
+-
+-using namespace Jack;
+-
+-//-------------------
+-// Client management
+-//-------------------
+-
+-#define rpc_type kern_return_t // for astyle
+-
+-rpc_type server_rpc_jack_client_check(mach_port_t private_port, client_name_t name, client_name_t name_res, int protocol, int options, int* status, int* result)
+-{
+-    jack_log("rpc_jack_client_check");
+-    JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
+-    assert(channel);
+-    channel->ClientCheck((char*)name, (char*)name_res, protocol, options, status, result);
+-    return KERN_SUCCESS;
+-}
+-
+-rpc_type server_rpc_jack_client_open(mach_port_t server_port, client_name_t name, int pid, mach_port_t* private_port, int* shared_engine, int* shared_client, int* shared_graph, int* result)
+-{
+-    jack_log("rpc_jack_client_open name = %s", name);
+-    JackMachServerChannel* channel = JackMachServerChannel::fPortTable[server_port];
+-    assert(channel);
+-    channel->ClientOpen((char*)name, pid, private_port, shared_engine, shared_client, shared_graph, result);
+-    return KERN_SUCCESS;
+-}
+-
+-rpc_type server_rpc_jack_client_close(mach_port_t private_port, int refnum, int* result)
+-{
+-    jack_log("rpc_jack_client_close");
+-    JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
+-    assert(channel);
+-    channel->ClientClose(private_port, refnum);
+-    *result = 0;
+-    return KERN_SUCCESS;
+-}
+-
+-rpc_type server_rpc_jack_client_activate(mach_port_t private_port, int refnum, int is_real_time, int* result)
+-{
+-    jack_log("rpc_jack_client_activate");
+-    JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
+-    assert(channel);
+-    *result = channel->GetEngine()->ClientActivate(refnum, is_real_time);
+-    return KERN_SUCCESS;
+-}
+-
+-rpc_type server_rpc_jack_client_deactivate(mach_port_t private_port, int refnum, int* result)
+-{
+-    jack_log("rpc_jack_client_deactivate");
+-    JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
+-    assert(channel);
+-    *result = channel->GetEngine()->ClientDeactivate(refnum);
+-    return KERN_SUCCESS;
+-}
+-
+-//-----------------
+-// Port management
+-//-----------------
+-
+-rpc_type server_rpc_jack_port_register(mach_port_t private_port, int refnum, client_port_name_t name, client_port_type_t type, unsigned int flags, unsigned int buffer_size, unsigned int* port_index, int* result)
+-{
+-    jack_log("rpc_jack_port_register ref = %d name = %s", refnum, name);
+-    JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
+-    assert(channel);
+-    *result = channel->GetEngine()->PortRegister(refnum, name, type, flags, buffer_size, port_index);
+-    return KERN_SUCCESS;
+-}
+-
+-rpc_type server_rpc_jack_port_unregister(mach_port_t private_port, int refnum, int port, int* result)
+-{
+-    jack_log("rpc_jack_port_unregister ref = %d port = %d ", refnum, port);
+-    JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
+-    assert(channel);
+-    *result = channel->GetEngine()->PortUnRegister(refnum, port);
+-    return KERN_SUCCESS;
+-}
+-
+-rpc_type server_rpc_jack_port_connect_name(mach_port_t private_port, int refnum, client_port_name_t src, client_port_name_t dst, int* result)
+-{
+-    jack_log("rpc_jack_port_connect_name");
+-    JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
+-    assert(channel);
+-    *result = channel->GetEngine()->PortConnect(refnum, src, dst);
+-    return KERN_SUCCESS;
+-}
+-
+-rpc_type server_rpc_jack_port_disconnect_name(mach_port_t private_port, int refnum, client_port_name_t src, client_port_name_t dst, int* result)
+-{
+-    jack_log("rpc_jack_port_disconnect_name");
+-    JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
+-    assert(channel);
+-    *result = channel->GetEngine()->PortDisconnect(refnum, src, dst);
+-    return KERN_SUCCESS;
+-}
+-
+-rpc_type server_rpc_jack_port_connect(mach_port_t private_port, int refnum, int src, int dst, int* result)
+-{
+-    jack_log("rpc_jack_port_connect");
+-    JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
+-    assert(channel);
+-    *result = channel->GetEngine()->PortConnect(refnum, src, dst);
+-    return KERN_SUCCESS;
+-}
+-
+-rpc_type server_rpc_jack_port_disconnect(mach_port_t private_port, int refnum, int src, int dst, int* result)
+-{
+-    jack_log("rpc_jack_port_disconnect");
+-    JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
+-    assert(channel);
+-    *result = channel->GetEngine()->PortDisconnect(refnum, src, dst);
+-    return KERN_SUCCESS;
+-}
+-
+-rpc_type server_rpc_jack_port_rename(mach_port_t private_port, int refnum, int port, client_port_name_t name, int* result)
+-{
+-    jack_log("server_rpc_jack_port_rename");
+-    JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
+-    assert(channel);
+-    *result = channel->GetEngine()->PortRename(refnum, port, name);
+-    return KERN_SUCCESS;
+-}
+-
+-//------------------------
+-// Buffer size, freewheel
+-//------------------------
+-
+-rpc_type server_rpc_jack_set_buffer_size(mach_port_t private_port, int buffer_size, int* result)
+-{
+-    jack_log("server_rpc_jack_set_buffer_size");
+-    JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
+-    assert(channel);
+-    *result = channel->GetServer()->SetBufferSize(buffer_size);
+-    return KERN_SUCCESS;
+-}
+-
+-rpc_type server_rpc_jack_set_freewheel(mach_port_t private_port, int onoff, int* result)
+-{
+-    jack_log("server_rpc_jack_set_freewheel");
+-    JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
+-    assert(channel);
+-    *result = channel->GetServer()->SetFreewheel(onoff);
+-    return KERN_SUCCESS;
+-}
+-
+-//----------------------
+-// Transport management
+-//----------------------
+-
+-rpc_type server_rpc_jack_release_timebase(mach_port_t private_port, int refnum, int* result)
+-{
+-    jack_log("server_rpc_jack_release_timebase");
+-    JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
+-    assert(channel);
+-    *result = channel->GetServer()->ReleaseTimebase(refnum);
+-    return KERN_SUCCESS;
+-}
+-
+-rpc_type server_rpc_jack_set_timebase_callback(mach_port_t private_port, int refnum, int conditional, int* result)
+-{
+-    jack_log("server_rpc_jack_set_timebase_callback");
+-    JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
+-    assert(channel);
+-    *result = channel->GetServer()->SetTimebaseCallback(refnum, conditional);
+-    return KERN_SUCCESS;
+-}
+-
+-//------------------
+-// Internal clients
+-//------------------
+-
+-rpc_type server_rpc_jack_get_internal_clientname(mach_port_t private_port, int refnum, int int_ref, client_name_t name_res, int* result)
+-{
+-    jack_log("server_rpc_jack_get_internal_clientname");
+-    JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
+-    assert(channel);
+-    *result = channel->GetServer()->GetEngine()->GetInternalClientName(int_ref, (char*)name_res);
+-    return KERN_SUCCESS;
+-}
+-
+-rpc_type server_rpc_jack_internal_clienthandle(mach_port_t private_port, int refnum, client_name_t client_name, int* status, int* int_ref, int* result)
+-{
+-    jack_log("server_rpc_jack_internal_clienthandle");
+-    JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
+-    assert(channel);
+-    *result = channel->GetServer()->GetEngine()->InternalClientHandle(client_name, status, int_ref);
+-    return KERN_SUCCESS;
+-}
+-
+-rpc_type server_rpc_jack_internal_clientload(mach_port_t private_port, int refnum, client_name_t client_name, so_name_t so_name, objet_data_t objet_data, int options, int* status, int* int_ref, int* result)
+-{
+-    jack_log("server_rpc_jack_internal_clientload");
+-    JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
+-    assert(channel);
+-    *result = channel->GetServer()->InternalClientLoad(client_name, so_name, objet_data, options, int_ref, status);
+-    return KERN_SUCCESS;
+-}
+-
+-rpc_type server_rpc_jack_internal_clientunload(mach_port_t private_port, int refnum, int int_ref, int* status, int* result)
+-{
+-    jack_log("server_rpc_jack_internal_clientunload");
+-    JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
+-    assert(channel);
+-    *result = channel->GetServer()->GetEngine()->InternalClientUnload(int_ref, status);
+-    return KERN_SUCCESS;
+-}
+-
+-//-----------------
+-// RT notification
+-//-----------------
+-
+-rpc_type server_rpc_jack_client_rt_notify(mach_port_t server_port, int refnum, int notify, int value)
+-{
+-    jack_log("rpc_jack_client_rt_notify ref = %d notify = %d value = %d", refnum, notify, value);
+-    JackMachServerChannel* channel = JackMachServerChannel::fPortTable[server_port];
+-    assert(channel);
+-    assert(channel->GetServer());
+-    
+-    if (notify == kQUIT) {
+-        throw JackQuitException();
+-    } else {
+-        channel->GetServer()->Notify(refnum, notify, value);
+-        return KERN_SUCCESS;
+-    }
+-}
+--- a/macosx/JackMacLibClientRPC.cpp
++++ /dev/null
+@@ -1,47 +0,0 @@
+-/*
+-Copyright (C) 2004-2008 Grame
+-
+-This program is free software; you can redistribute it and/or modify
+-  it under the terms of the GNU General Public License as published by
+-  the Free Software Foundation; either version 2 of the License, or
+-  (at your option) any later version.
+-
+-  This program is distributed in the hope that it will be useful,
+-  but WITHOUT ANY WARRANTY; without even the implied warranty of
+-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+-  GNU General Public License for more details.
+-
+-  You should have received a copy of the GNU General Public License
+-  along with this program; if not, write to the Free Software
+-  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+-
+-*/
+-
+-#include "JackLibClient.h"
+-#include "JackMachClientChannel.h"
+-#include "JackRPCEngine.h"
+-#include "JackLibGlobals.h"
+-#include <assert.h>
+-
+-using namespace Jack;
+-
+-#define rpc_type kern_return_t  // for astyle
+-
+-rpc_type rpc_jack_client_sync_notify(mach_port_t client_port, int refnum, client_name_t name, int notify, message_t message, int value1, int value2, int* result)
+-{
+-    jack_log("rpc_jack_client_sync_notify ref = %ld name = %s notify = %ld message %s val1 = %ld val2 = %ld", refnum, name, notify, message, value1, value2);
+-    JackClient* client = gClientTable[client_port];
+-    assert(client);
+-    *result = client->ClientNotify(refnum, name, notify, true, message, value1, value2);
+-    return KERN_SUCCESS;
+-}
+-
+-rpc_type rpc_jack_client_async_notify(mach_port_t client_port, int refnum, client_name_t name, int notify, message_t message,  int value1, int value2)
+-{
+-    jack_log("rpc_jack_client_async_notify ref = %ld name = %s notify = %ld message %s val1 = %ld val2 = %ld", refnum, name, notify, message, value1, value2);
+-    JackClient* client = gClientTable[client_port];
+-    assert(client);
+-    client->ClientNotify(refnum, name, notify, false, message, value1, value2);
+-    return KERN_SUCCESS;
+-}
+-
+--- a/macosx/JackMachClientChannel.cpp
++++ /dev/null
+@@ -1,334 +0,0 @@
+-/*
+-Copyright (C) 2004-2008 Grame
+-
+-This program is free software; you can redistribute it and/or modify
+-it under the terms of the GNU Lesser General Public License as published by
+-the Free Software Foundation; either version 2.1 of the License, or
+-(at your option) any later version.
+-
+-This program is distributed in the hope that it will be useful,
+-but WITHOUT ANY WARRANTY; without even the implied warranty of
+-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+-GNU Lesser General Public License for more details.
+-
+-You should have received a copy of the GNU Lesser General Public License
+-along with this program; if not, write to the Free Software 
+-Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+-
+-*/
+-
+-#include "JackMachClientChannel.h"
+-#include "JackRPCEngine.h"
+-#include "JackTools.h"
+-#include "JackRPCClientServer.c"
+-#include "JackError.h"
+-#include "JackLibClient.h"
+-#include "JackMachThread.h"
+-#include "JackConstants.h"
+-
+-namespace Jack
+-{
+-
+-std::map<mach_port_t, JackClient*> gClientTable;
+-
+-JackMachClientChannel::JackMachClientChannel():fPrivatePort(0),fThread(this)
+-{}
+-
+-JackMachClientChannel::~JackMachClientChannel()
+-{}
+-
+-// Server <===> client
+-
+-int JackMachClientChannel::ServerCheck(const char* server_name)
+-{
+-    jack_log("JackMachClientChannel::ServerCheck = %s", server_name);
+-    char jack_server_entry_name[512];
+-    snprintf(jack_server_entry_name, sizeof(jack_server_entry_name), "%s.%d_%s", jack_server_entry, JackTools::GetUID(), server_name);
+-
+-    // Connect to server
+-    if (!fServerPort.ConnectPort(jack_server_entry_name)) {
+-        jack_error("Cannot connect to server Mach port");
+-        return -1;
+-    } else {
+-        return 0;
+-    }
+-}
+-
+-int JackMachClientChannel::Open(const char* server_name, const char* name, char* name_res, JackClient* client, jack_options_t options, jack_status_t* status)
+-{
+-    jack_log("JackMachClientChannel::Open name = %s", name);
+-    char jack_server_entry_name[512];
+-    snprintf(jack_server_entry_name, sizeof(jack_server_entry_name), "%s.%d_%s", jack_server_entry, JackTools::GetUID(), server_name);
+-
+-    // Connect to server
+-    if (!fServerPort.ConnectPort(jack_server_entry_name)) {
+-        jack_error("Cannot connect to server Mach port");
+-        return -1;
+-    }
+-
+-    // Check name in server
+-    int result = 0;
+-    ClientCheck(name, name_res, JACK_PROTOCOL_VERSION, (int)options, (int*)status, &result);
+-    if (result < 0) {
+-        int status1 = *status;
+-        if (status1 & JackVersionError)
+-            jack_error("JACK protocol mismatch %d", JACK_PROTOCOL_VERSION);
+-        else
+-            jack_error("Client name = %s conflits with another running client", name);
+-        return -1;
+-    }
+-
+-    // Prepare local port using client name
+-    char buf[JACK_CLIENT_NAME_SIZE + 1];
+-    snprintf(buf, sizeof(buf) - 1, "%s:%s", jack_client_entry, name_res);
+-
+-    if (!fClientPort.AllocatePort(buf, 16)) {
+-        jack_error("Cannot allocate client Mach port");
+-        return -1;
+-    }
+-
+-    gClientTable[fClientPort.GetPort()] = client;
+-    return 0;
+-}
+-
+-void JackMachClientChannel::Close()
+-{
+-    jack_log("JackMachClientChannel::Close");
+-    gClientTable.erase(fClientPort.GetPort());
+-    fServerPort.DisconnectPort();
+-    fClientPort.DestroyPort();
+-
+-    if (fPrivatePort != 0) {
+-         kern_return_t res;
+-        if ((res = mach_port_destroy(mach_task_self(), fPrivatePort)) != KERN_SUCCESS) {
+-            jack_error("JackMachClientChannel::Close err = %s", mach_error_string(res));
+-        }
+-    }
+-}
+-
+-int JackMachClientChannel::Start()
+-{
+-    jack_log("JackMachClientChannel::Start");
+-    /*
+-     To be sure notification thread is started before ClientOpen is called.
+-    */
+-    if (fThread.StartSync() != 0) {
+-        jack_error("Cannot start Jack client listener");
+-        return -1;
+-    } else {
+-        return 0;
+-    }
+-}
+-
+-void JackMachClientChannel::Stop()
+-{
+-    jack_log("JackMachClientChannel::Stop");
+-    fThread.Kill();
+-}
+-
+-void JackMachClientChannel::ClientCheck(const char* name, char* name_res, int protocol, int options, int* status, int* result)
+-{
+-    kern_return_t res = rpc_jack_client_check(fServerPort.GetPort(), (char*)name, name_res, protocol, options, status, result);
+-    if (res != KERN_SUCCESS) {
+-        *result = -1;
+-        jack_error("JackMachClientChannel::ClientCheck err = %s", mach_error_string(res));
+-    }
+-}
+-
+-void JackMachClientChannel::ClientOpen(const char* name, int pid, int* shared_engine, int* shared_client, int* shared_graph, int* result)
+-{
+-    kern_return_t res = rpc_jack_client_open(fServerPort.GetPort(), (char*)name, pid, &fPrivatePort, shared_engine, shared_client, shared_graph, result);
+-    if (res != KERN_SUCCESS) {
+-        *result = -1;
+-        jack_error("JackMachClientChannel::ClientOpen err = %s", mach_error_string(res));
+-    }
+-}
+-
+-void JackMachClientChannel::ClientClose(int refnum, int* result)
+-{
+-    kern_return_t res = rpc_jack_client_close(fPrivatePort, refnum, result);
+-    if (res != KERN_SUCCESS) {
+-        *result = -1;
+-        jack_error("JackMachClientChannel::ClientClose err = %s", mach_error_string(res));
+-    }
+-}
+-
+-void JackMachClientChannel::ClientActivate(int refnum, int is_real_time, int* result)
+-{
+-    kern_return_t res = rpc_jack_client_activate(fPrivatePort, refnum, is_real_time, result);
+-    if (res != KERN_SUCCESS) {
+-        *result = -1;
+-        jack_error("JackMachClientChannel::ClientActivate err = %s", mach_error_string(res));
+-    }
+-}
+-
+-void JackMachClientChannel::ClientDeactivate(int refnum, int* result)
+-{
+-    kern_return_t res = rpc_jack_client_deactivate(fPrivatePort, refnum, result);
+-    if (res != KERN_SUCCESS) {
+-        *result = -1;
+-        jack_error("JackMachClientChannel::ClientDeactivate err = %s", mach_error_string(res));
+-    }
+-}
+-
+-void JackMachClientChannel::PortRegister(int refnum, const char* name, const char* type, unsigned int flags, unsigned int buffer_size, jack_port_id_t* port_index, int* result)
+-{
+-    kern_return_t res = rpc_jack_port_register(fPrivatePort, refnum, (char*)name, (char*)type, flags, buffer_size, port_index, result);
+-    if (res != KERN_SUCCESS) {
+-        *result = -1;
+-        jack_error("JackMachClientChannel::PortRegister err = %s", mach_error_string(res));
+-    }
+-}
+-
+-void JackMachClientChannel::PortUnRegister(int refnum, jack_port_id_t port_index, int* result)
+-{
+-    kern_return_t res = rpc_jack_port_unregister(fPrivatePort, refnum, port_index, result);
+-    if (res != KERN_SUCCESS) {
+-        *result = -1;
+-        jack_error("JackMachClientChannel::PortUnRegister err = %s", mach_error_string(res));
+-    }
+-}
+-
+-void JackMachClientChannel::PortConnect(int refnum, const char* src, const char* dst, int* result)
+-{
+-    kern_return_t res = rpc_jack_port_connect_name(fPrivatePort, refnum, (char*)src, (char*)dst, result);
+-    if (res != KERN_SUCCESS) {
+-        jack_error("JackMachClientChannel::PortConnect err = %s", mach_error_string(res));
+-    }
+-}
+-
+-void JackMachClientChannel::PortDisconnect(int refnum, const char* src, const char* dst, int* result)
+-{
+-    kern_return_t res = rpc_jack_port_disconnect_name(fPrivatePort, refnum, (char*)src, (char*)dst, result);
+-    if (res != KERN_SUCCESS) {
+-        *result = -1;
+-        jack_error("JackMachClientChannel::PortDisconnect err = %s", mach_error_string(res));
+-    }
+-}
+-
+-void JackMachClientChannel::PortConnect(int refnum, jack_port_id_t src, jack_port_id_t dst, int* result)
+-{
+-    kern_return_t res = rpc_jack_port_connect(fPrivatePort, refnum, src, dst, result);
+-    if (res != KERN_SUCCESS) {
+-        *result = -1;
+-        jack_error("JackMachClientChannel::PortConnect err = %s", mach_error_string(res));
+-    }
+-}
+-
+-void JackMachClientChannel::PortDisconnect(int refnum, jack_port_id_t src, jack_port_id_t dst, int* result)
+-{
+-    kern_return_t res = rpc_jack_port_disconnect(fPrivatePort, refnum, src, dst, result);
+-    if (res != KERN_SUCCESS) {
+-        *result = -1;
+-        jack_error("JackMachClientChannel::PortDisconnect err = %s", mach_error_string(res));
+-    }
+-}
+-
+-void JackMachClientChannel::PortRename(int refnum, jack_port_id_t port, const char* name, int* result)
+-{
+-    kern_return_t res = rpc_jack_port_rename(fPrivatePort, refnum, port, (char*)name, result);
+-    if (res != KERN_SUCCESS) {
+-        *result = -1;
+-        jack_error("JackMachClientChannel::PortRename err = %s", mach_error_string(res));
+-    }
+-}
+-
+-void JackMachClientChannel::SetBufferSize(jack_nframes_t buffer_size, int* result)
+-{
+-    kern_return_t res = rpc_jack_set_buffer_size(fPrivatePort, buffer_size, result);
+-    if (res != KERN_SUCCESS) {
+-        *result = -1;
+-        jack_error("JackMachClientChannel::SetBufferSize err = %s", mach_error_string(res));
+-    }
+-}
+-
+-void JackMachClientChannel::SetFreewheel(int onoff, int* result)
+-{
+-    kern_return_t res = rpc_jack_set_freewheel(fPrivatePort, onoff, result);
+-    if (res != KERN_SUCCESS) {
+-        *result = -1;
+-        jack_error("JackMachClientChannel::SetFreewheel err = %s", mach_error_string(res));
+-    }
+-}
+-
+-void JackMachClientChannel::ReleaseTimebase(int refnum, int* result)
+-{
+-    kern_return_t res = rpc_jack_release_timebase(fPrivatePort, refnum, result);
+-    if (res != KERN_SUCCESS) {
+-        *result = -1;
+-        jack_error("JackMachClientChannel::ReleaseTimebase err = %s", mach_error_string(res));
+-    }
+-}
+-
+-void JackMachClientChannel::SetTimebaseCallback(int refnum, int conditional, int* result)
+-{
+-    kern_return_t res = rpc_jack_set_timebase_callback(fPrivatePort, refnum, conditional, result);
+-    if (res != KERN_SUCCESS) {
+-        *result = -1;
+-        jack_error("JackMachClientChannel::SetTimebaseCallback err = %s", mach_error_string(res));
+-    }
+-}
+-
+-void JackMachClientChannel::GetInternalClientName(int refnum, int int_ref, char* name_res, int* result)
+-{
+-    kern_return_t res = rpc_jack_get_internal_clientname(fPrivatePort, refnum, int_ref, name_res, result);
+-    if (res != KERN_SUCCESS) {
+-        *result = -1;
+-        jack_error("JackMachClientChannel::GetInternalClientName err = %s", mach_error_string(res));
+-    }
+-}
+-
+-void JackMachClientChannel::InternalClientHandle(int refnum, const char* client_name, int* status, int* int_ref, int* result)
+-{
+-    kern_return_t res = rpc_jack_internal_clienthandle(fPrivatePort, refnum, (char*)client_name, status, int_ref, result);
+-    if (res != KERN_SUCCESS) {
+-        *result = -1;
+-        jack_error("JackMachClientChannel::InternalClientHandle err = %s", mach_error_string(res));
+-    }
+-}
+-
+-void JackMachClientChannel::InternalClientLoad(int refnum, const char* client_name, const char* so_name, const char* objet_data, int options, int* status, int* int_ref, int* result)
+-{
+-    const char* int_client_name = (client_name) ? client_name : "";
+-    const char* int_so_name = (so_name) ? so_name : "";
+-    const char* int_objet_data = (objet_data) ? objet_data : "";
+-    
+-    kern_return_t res = rpc_jack_internal_clientload(fPrivatePort, refnum, (char*)int_client_name, (char*)int_so_name, (char*)int_objet_data, options, status, int_ref, result);
+-    if (res != KERN_SUCCESS) {
+-        *result = -1;
+-        jack_error("JackMachClientChannel::InternalClientLoad err = %s", mach_error_string(res));
+-    }
+-}
+-
+-void JackMachClientChannel::InternalClientUnload(int refnum, int int_ref, int* status, int* result)
+-{
+-    kern_return_t res = rpc_jack_internal_clientunload(fPrivatePort, refnum, int_ref, status, result);
+-    if (res != KERN_SUCCESS) {
+-        *result = -1;
+-        jack_error("JackMachClientChannel::InternalClientUnload err = %s", mach_error_string(res));
+-    }
+-}
+-
+-bool JackMachClientChannel::Init()
+-{
+-    jack_log("JackMachClientChannel::Init");
+-    JackClient* client = gClientTable[fClientPort.GetPort()];
+-    return client->Init();
+-}
+-
+-bool JackMachClientChannel::Execute()
+-{
+-    kern_return_t res;
+-    if ((res = mach_msg_server(JackRPCClient_server, 1024, fClientPort.GetPort(), 0)) != KERN_SUCCESS) {
+-        jack_error("JackMachClientChannel::Execute err = %s", mach_error_string(res));
+-        JackClient* client = gClientTable[fClientPort.GetPort()];
+-        client->ShutDown();
+-        return false;
+-    } else {
+-        return true;
+-    }
+-}
+-
+-} // end of namespace
+-
+-
+--- a/macosx/JackMachClientChannel.h
++++ /dev/null
+@@ -1,99 +0,0 @@
+-/*
+-Copyright (C) 2004-2008 Grame
+-
+-This program is free software; you can redistribute it and/or modify
+-it under the terms of the GNU Lesser General Public License as published by
+-the Free Software Foundation; either version 2.1 of the License, or
+-(at your option) any later version.
+-
+-This program is distributed in the hope that it will be useful,
+-but WITHOUT ANY WARRANTY; without even the implied warranty of
+-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+-GNU Lesser General Public License for more details.
+-
+-You should have received a copy of the GNU Lesser General Public License
+-along with this program; if not, write to the Free Software 
+-Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+-
+-*/
+-
+-#ifndef __JackMachClientChannel__
+-#define __JackMachClientChannel__
+-
+-#include "JackChannel.h"
+-#include "JackMachPort.h"
+-#include "JackPlatformPlug.h"
+-#include <map>
+-
+-namespace Jack
+-{
+-
+-/*!
+-\brief JackClientChannel using Mach IPC.
+-*/
+-
+-class JackMachClientChannel : public detail::JackClientChannelInterface, public JackRunnableInterface
+-{
+-
+-    private:
+-
+-        JackMachPort fClientPort;    /*! Mach port to communicate with the server : from server to client */
+-        JackMachPort fServerPort;    /*! Mach port to communicate with the server : from client to server */
+-        mach_port_t	fPrivatePort;
+-        JackThread	fThread;		 /*! Thread to execute the event loop */
+-
+-    public:
+-
+-        JackMachClientChannel();
+-        ~JackMachClientChannel();
+-
+-        int Open(const char* server_name, const char* name, char* name_res, JackClient* client, jack_options_t options, jack_status_t* status);
+-        void Close();
+-
+-        int Start();
+-        void Stop();
+-
+-        int ServerCheck(const char* server_name);
+-
+-        void ClientCheck(const char* name, char* name_res, int protocol, int options, int* status, int* result);
+-        void ClientOpen(const char* name, int pid, int* shared_engine, int* shared_client, int* shared_graph, int* result);
+-        void ClientOpen(const char* name, int* ref, JackEngineControl** shared_engine, JackGraphManager** shared_manager, JackClientInterface* client, int* result)
+-        {}
+-        void ClientClose(int refnum, int* result);
+-
+-        void ClientActivate(int refnum, int is_real_time, int* result);
+-        void ClientDeactivate(int refnum, int* result);
+-
+-        void PortRegister(int refnum, const char* name, const char* type, unsigned int flags, unsigned int buffer_size, jack_port_id_t* port_index, int* result);
+-        void PortUnRegister(int refnum, jack_port_id_t port_index, int* result);
+-
+-        void PortConnect(int refnum, const char* src, const char* dst, int* result);
+-        void PortDisconnect(int refnum, const char* src, const char* dst, int* result);
+-
+-        void PortConnect(int refnum, jack_port_id_t src, jack_port_id_t dst, int* result);
+-        void PortDisconnect(int refnum, jack_port_id_t src, jack_port_id_t dst, int* result);
+-        
+-        void PortRename(int refnum, jack_port_id_t port, const char* name, int* result);
+-
+-        void SetBufferSize(jack_nframes_t buffer_size, int* result);
+-        void SetFreewheel(int onoff, int* result);
+-
+-        void ReleaseTimebase(int refnum, int* result);
+-        void SetTimebaseCallback(int refnum, int conditional, int* result);
+-
+-        void GetInternalClientName(int refnum, int int_ref, char* name_res, int* result);
+-        void InternalClientHandle(int refnum, const char* client_name, int* status, int* int_ref, int* result);
+-        void InternalClientLoad(int refnum, const char* client_name,  const char* so_name, const char* objet_data, int options, int* status, int* int_ref, int* result);
+-        void InternalClientUnload(int refnum, int int_ref, int* status, int* result);
+-
+-        // JackRunnableInterface interface
+-        bool Init();
+-        bool Execute();
+-};
+-
+-extern std::map<mach_port_t, JackClient*> gClientTable;
+-
+-} // end of namespace
+-
+-#endif
+-
+--- a/macosx/JackMachNotifyChannel.cpp
++++ /dev/null
+@@ -1,67 +0,0 @@
+-/*
+-Copyright (C) 2004-2008 Grame
+-
+-This program is free software; you can redistribute it and/or modify
+-it under the terms of the GNU Lesser General Public License as published by
+-the Free Software Foundation; either version 2.1 of the License, or
+-(at your option) any later version.
+-
+-This program is distributed in the hope that it will be useful,
+-but WITHOUT ANY WARRANTY; without even the implied warranty of
+-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+-GNU Lesser General Public License for more details.
+-
+-You should have received a copy of the GNU Lesser General Public License
+-along with this program; if not, write to the Free Software 
+-Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+-
+-*/
+-
+-#include "JackMachNotifyChannel.h"
+-#include "JackRPCClient.h"
+-#include "JackError.h"
+-#include "JackConstants.h"
+-#include <stdio.h>
+-
+-namespace Jack
+-{
+-
+-// Server side : server to client
+-
+-int JackMachNotifyChannel::Open(const char* name)
+-{
+-    jack_log("JackMachNotifyChannel::Open name = %s", name);
+-
+-    char buf[256];
+-    snprintf(buf, sizeof(buf) - 1, "%s:%s", jack_client_entry, name);
+-
+-    // Connect to client notification port using client name
+-    if (!fClientPort.ConnectPort(buf)) {
+-        jack_error("Cannot connect client port");
+-        return -1;
+-    } else {
+-        return 0;
+-    }
+-}
+-
+-void JackMachNotifyChannel::Close()
+-{
+-    fClientPort.DisconnectPort();
+-}
+-
+-void JackMachNotifyChannel::ClientNotify(int refnum, const char* name, int notify, int sync, const char* message, int value1, int value2, int* result)
+-{
+-    kern_return_t res = (sync)
+-                        ? rpc_jack_client_sync_notify(fClientPort.GetPort(), refnum, (char*)name, notify, (char*)message, value1, value2, result)
+-                        : rpc_jack_client_async_notify(fClientPort.GetPort(), refnum, (char*)name, notify, (char*)message, value1, value2);
+-    if (res == KERN_SUCCESS) {
+-        *result = 0;
+-    } else {
+-        jack_error("JackMachNotifyChannel::ClientNotify: name = %s notify = %ld err = %s", name, notify, mach_error_string(res));
+-        *result = -1;
+-    }
+-}
+-
+-} // end of namespace
+-
+-
+--- a/macosx/JackMachNotifyChannel.h
++++ /dev/null
+@@ -1,53 +0,0 @@
+-/*
+-Copyright (C) 2004-2008 Grame
+-
+-This program is free software; you can redistribute it and/or modify
+-it under the terms of the GNU Lesser General Public License as published by
+-the Free Software Foundation; either version 2.1 of the License, or
+-(at your option) any later version.
+-
+-This program is distributed in the hope that it will be useful,
+-but WITHOUT ANY WARRANTY; without even the implied warranty of
+-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+-GNU Lesser General Public License for more details.
+-
+-You should have received a copy of the GNU Lesser General Public License
+-along with this program; if not, write to the Free Software 
+-Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+-
+-*/
+-
+-#ifndef __JackMachNotifyChannel__
+-#define __JackMachNotifyChannel__
+-
+-#include "JackMachPort.h"
+-
+-namespace Jack
+-{
+-
+-/*!
+-\brief JackNotifyChannel using Mach IPC.
+-*/
+-
+-class JackMachNotifyChannel
+-{
+-
+-    private:
+-
+-        JackMachPort fClientPort;    /*! Mach port to communicate with the client : from server to client */
+-
+-    public:
+-
+-        JackMachNotifyChannel()
+-        {}
+-
+-        int Open(const char* name);		// Open the Server/Client connection
+-        void Close();					// Close the Server/Client connection
+-
+-        void ClientNotify(int refnum, const char* name, int notify, int sync, const char* message, int value1, int value2, int* result);
+-};
+-
+-} // end of namespace
+-
+-#endif
+-
+--- a/macosx/JackMachPort.cpp
++++ /dev/null
+@@ -1,295 +0,0 @@
+-/*
+-Copyright (C) 2004-2008 Grame
+-
+-This program is free software; you can redistribute it and/or modify
+-it under the terms of the GNU Lesser General Public License as published by
+-the Free Software Foundation; either version 2.1 of the License, or
+-(at your option) any later version.
+-
+-This program is distributed in the hope that it will be useful,
+-but WITHOUT ANY WARRANTY; without even the implied warranty of
+-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+-GNU Lesser General Public License for more details.
+-
+-You should have received a copy of the GNU Lesser General Public License
+-along with this program; if not, write to the Free Software 
+-Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+-
+-*/
+-
+-#include "JackMachPort.h"
+-#include "JackError.h"
+-
+-namespace Jack
+-{
+-
+-// Server side : port is published to be accessible from other processes (clients)
+-
+-bool JackMachPort::AllocatePort(const char* name, int queue)
+-{
+-    mach_port_t task = mach_task_self();
+-    kern_return_t res;
+-
+-    if ((res = task_get_bootstrap_port(task, &fBootPort)) != KERN_SUCCESS) {
+-        jack_error("AllocatePort: Can't find bootstrap mach port err = %s", mach_error_string(res));
+-        return false;
+-    }
+-
+-    if ((res = mach_port_allocate(task, MACH_PORT_RIGHT_RECEIVE, &fServerPort)) != KERN_SUCCESS) {
+-        jack_error("AllocatePort: can't allocate mach port err = %s", mach_error_string(res));
+-        return false;
+-    }
+-
+-    if ((res = mach_port_insert_right(task, fServerPort, fServerPort, MACH_MSG_TYPE_MAKE_SEND)) != KERN_SUCCESS) {
+-        jack_error("AllocatePort: error inserting mach rights err = %s", mach_error_string(res));
+-        return false;
+-    }
+-
+-    if ((res = bootstrap_register(fBootPort, (char*)name, fServerPort)) != KERN_SUCCESS) {
+-        jack_error("Allocate: can't check in mach port name = %s err = %s", name, mach_error_string(res));
+-        return false;
+-    }
+-
+-    mach_port_limits_t qlimits;
+-    mach_msg_type_number_t info_cnt = MACH_PORT_LIMITS_INFO_COUNT;
+-    if ((res = mach_port_get_attributes(task, fServerPort, MACH_PORT_LIMITS_INFO, (mach_port_info_t) & qlimits, &info_cnt)) != KERN_SUCCESS) {
+-        jack_error("Allocate: mach_port_get_attributes error err = %s", name, mach_error_string(res));
+-    }
+-
+-    jack_log("AllocatePort: queue limit %ld", qlimits.mpl_qlimit);
+-
+-    if (queue > 0) {
+-        qlimits.mpl_qlimit = queue;
+-        if ((res = mach_port_set_attributes(task, fServerPort, MACH_PORT_LIMITS_INFO, (mach_port_info_t) & qlimits, MACH_PORT_LIMITS_INFO_COUNT)) != KERN_SUCCESS) {
+-            jack_error("Allocate: mach_port_set_attributes error name = %s err = %s", name, mach_error_string(res));
+-        }
+-    }
+-
+-    return true;
+-}
+-
+-// Server side : port is published to be accessible from other processes (clients)
+-
+-bool JackMachPort::AllocatePort(const char* name)
+-{
+-    return AllocatePort(name, -1);
+-}
+-
+-// Client side : get the published port from server
+-
+-bool JackMachPort::ConnectPort(const char* name)
+-{
+-    kern_return_t res;
+-
+-    jack_log("JackMachPort::ConnectPort %s", name);
+-
+-    if ((res = task_get_bootstrap_port(mach_task_self(), &fBootPort)) != KERN_SUCCESS) {
+-        jack_error("ConnectPort: can't find bootstrap port err = %s", mach_error_string(res));
+-        return false;
+-    }
+-
+-    if ((res = bootstrap_look_up(fBootPort, (char*)name, &fServerPort)) != KERN_SUCCESS) {
+-        jack_error("ConnectPort: can't find mach server port name = %s err = %s", name, mach_error_string(res));
+-        return false;
+-    }
+-
+-    return true;
+-}
+-
+-bool JackMachPort::DisconnectPort()
+-{
+-    jack_log("JackMacRPC::DisconnectPort");
+-    kern_return_t res;
+-    mach_port_t task = mach_task_self();
+-
+-    if (fBootPort != 0) {
+-        if ((res = mach_port_deallocate(task, fBootPort)) != KERN_SUCCESS) {
+-            jack_error("JackMacRPC::DisconnectPort mach_port_deallocate fBootPort err = %s", mach_error_string(res));
+-        }
+-    }
+-
+-    if (fServerPort != 0) {
+-        if ((res = mach_port_deallocate(task, fServerPort)) != KERN_SUCCESS) {
+-            jack_error("JackMacRPC::DisconnectPort mach_port_deallocate fServerPort err = %s", mach_error_string(res));
+-        }
+-    }
+-    
+-    return true;
+-}
+-
+-bool JackMachPort::DestroyPort()
+-{
+-    jack_log("JackMacRPC::DisconnectPort");
+-    kern_return_t res;
+-    mach_port_t task = mach_task_self();
+-
+-    if (fBootPort != 0) {
+-        if ((res = mach_port_deallocate(task, fBootPort)) != KERN_SUCCESS) {
+-            jack_error("JackMacRPC::DisconnectPort mach_port_deallocate fBootPort err = %s", mach_error_string(res));
+-        }
+-    }
+-
+-    if (fServerPort != 0) {
+-        if ((res = mach_port_destroy(task, fServerPort)) != KERN_SUCCESS) {
+-            jack_error("JackMacRPC::DisconnectPort mach_port_destroy fServerPort err = %s", mach_error_string(res));
+-        }
+-    }
+-
+-    return true;
+-}
+-
+-mach_port_t JackMachPort::GetPort()
+-{
+-    return fServerPort;
+-}
+-
+-bool JackMachPortSet::AllocatePort(const char* name, int queue)
+-{
+-    kern_return_t res;
+-    mach_port_t task = mach_task_self();
+-
+-    jack_log("JackMachPortSet::AllocatePort");
+-
+-    if ((res = task_get_bootstrap_port(task, &fBootPort)) != KERN_SUCCESS) {
+-        jack_error("AllocatePort: Can't find bootstrap mach port err = %s", mach_error_string(res));
+-        return false;
+-    }
+-
+-    if ((res = mach_port_allocate(task, MACH_PORT_RIGHT_RECEIVE, &fServerPort)) != KERN_SUCCESS) {
+-        jack_error("AllocatePort: can't allocate mach port err = %s", mach_error_string(res));
+-        return false;
+-    }
+-
+-    if ((res = mach_port_insert_right(task, fServerPort, fServerPort, MACH_MSG_TYPE_MAKE_SEND)) != KERN_SUCCESS) {
+-        jack_error("AllocatePort: error inserting mach rights err = %s", mach_error_string(res));
+-        return false;
+-    }
+-
+-    if ((res = mach_port_allocate(task, MACH_PORT_RIGHT_PORT_SET, &fPortSet)) != KERN_SUCCESS) {
+-        jack_error("AllocatePort: can't allocate mach port err = %s", mach_error_string(res));
+-        return false;
+-    }
+-
+-    if ((res = mach_port_move_member(task, fServerPort, fPortSet)) != KERN_SUCCESS) {
+-        jack_error("AllocatePort: error in mach_port_move_member err = %s", mach_error_string(res));
+-        return false;
+-    }
+-
+-    if ((res = bootstrap_register(fBootPort, (char*)name, fServerPort)) != KERN_SUCCESS) {
+-        jack_error("Allocate: can't check in mach port name = %s err = %s", name, mach_error_string(res));
+-        return false;
+-    }
+-
+-    mach_port_limits_t qlimits;
+-    mach_msg_type_number_t info_cnt = MACH_PORT_LIMITS_INFO_COUNT;
+-    if ((res = mach_port_get_attributes(task, fServerPort, MACH_PORT_LIMITS_INFO, (mach_port_info_t) & qlimits, &info_cnt)) != KERN_SUCCESS) {
+-        jack_error("Allocate: mach_port_get_attributes error name = %s err = %s", name, mach_error_string(res));
+-    }
+-
+-    jack_log("AllocatePort: queue limit = %ld", qlimits.mpl_qlimit);
+-
+-    if (queue > 0) {
+-        qlimits.mpl_qlimit = queue;
+-
+-        if ((res = mach_port_set_attributes(task, fServerPort, MACH_PORT_LIMITS_INFO, (mach_port_info_t) & qlimits, MACH_PORT_LIMITS_INFO_COUNT)) != KERN_SUCCESS) {
+-            jack_error("Allocate: mach_port_set_attributes error name = %s err = %s", name, mach_error_string(res));
+-        }
+-    }
+-
+-    return true;
+-}
+-
+-// Server side : port is published to be accessible from other processes (clients)
+-
+-bool JackMachPortSet::AllocatePort(const char* name)
+-{
+-    return AllocatePort(name, -1);
+-}
+-
+-bool JackMachPortSet::DisconnectPort()
+-{
+-    kern_return_t res;
+-    mach_port_t task = mach_task_self();
+-
+-    jack_log("JackMachPortSet::DisconnectPort");
+-
+-    if (fBootPort != 0) {
+-        if ((res = mach_port_deallocate(task, fBootPort)) != KERN_SUCCESS) {
+-            jack_error("JackMachPortSet::DisconnectPort mach_port_deallocate fBootPort err = %s", mach_error_string(res));
+-        }
+-    }
+-
+-    if (fServerPort != 0) {
+-        if ((res = mach_port_deallocate(task, fServerPort)) != KERN_SUCCESS) {
+-            jack_error("JackMachPortSet::DisconnectPort mach_port_deallocate fServerPort err = %s", mach_error_string(res));
+-        }
+-    }
+-
+-    return true;
+-}
+-
+-bool JackMachPortSet::DestroyPort()
+-{
+-    kern_return_t res;
+-    mach_port_t task = mach_task_self();
+-
+-    jack_log("JackMachPortSet::DisconnectPort");
+-
+-    if (fBootPort != 0) {
+-        if ((res = mach_port_deallocate(task, fBootPort)) != KERN_SUCCESS) {
+-            jack_error("JackMachPortSet::DisconnectPort mach_port_deallocate err = %s", mach_error_string(res));
+-        }
+-    }
+-
+-    if (fServerPort != 0) {
+-        if ((res = mach_port_destroy(task, fServerPort)) != KERN_SUCCESS) {
+-            jack_error("JackMachPortSet::DisconnectPort mach_port_destroy fServerPort err = %s", mach_error_string(res));
+-        }
+-    }
+-
+-    return true;
+-}
+-
+-mach_port_t JackMachPortSet::GetPortSet()
+-{
+-    return fPortSet;
+-}
+-
+-mach_port_t JackMachPortSet::AddPort()
+-{
+-    kern_return_t res;
+-    mach_port_t task = mach_task_self();
+-    mach_port_t old_port, result = 0;
+-
+-    jack_log("JackMachPortSet::AddPort");
+-
+-    if ((res = mach_port_allocate(task, MACH_PORT_RIGHT_RECEIVE, &result)) != KERN_SUCCESS) {
+-        jack_error("AddPort: can't allocate mach port err = %s", mach_error_string(res));
+-        goto error;
+-    }
+-
+-    if ((res = mach_port_request_notification(task, result, MACH_NOTIFY_NO_SENDERS,
+-               1, result, MACH_MSG_TYPE_MAKE_SEND_ONCE, &old_port)) != KERN_SUCCESS) {
+-        jack_error("AddPort: error in mach_port_request_notification err = %s", mach_error_string(res));
+-        goto error;
+-    }
+-
+-    if ((res = mach_port_move_member(task, result, fPortSet)) != KERN_SUCCESS) {
+-        jack_error("AddPort: error in mach_port_move_member err = %s", mach_error_string(res));
+-        goto error;
+-    }
+-
+-    return result;
+-
+-error:
+-    if (result) {
+-        if ((res = mach_port_destroy(task, result)) != KERN_SUCCESS) {
+-            jack_error("JackMacRPC::DisconnectPort mach_port_destroy err = %s", mach_error_string(res));
+-        }
+-    }
+-    return 0;
+-}
+-
+-
+-} // end of namespace
+-
+--- a/macosx/JackMachPort.h
++++ /dev/null
+@@ -1,88 +0,0 @@
+-/*
+-Copyright (C) 2004-2008 Grame
+-
+-This program is free software; you can redistribute it and/or modify
+-it under the terms of the GNU Lesser General Public License as published by
+-the Free Software Foundation; either version 2.1 of the License, or
+-(at your option) any later version.
+-
+-This program is distributed in the hope that it will be useful,
+-but WITHOUT ANY WARRANTY; without even the implied warranty of
+-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+-GNU Lesser General Public License for more details.
+-
+-You should have received a copy of the GNU Lesser General Public License
+-along with this program; if not, write to the Free Software 
+-Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+-
+-*/
+-
+-#ifndef __JackMachPort__
+-#define __JackMachPort__
+-
+-#include <mach/mach.h>
+-#include <mach/mach_types.h>
+-#include <mach/message.h>
+-#include <mach/mach_error.h>
+-#include <servers/bootstrap.h>
+-
+-namespace Jack
+-{
+-
+-/*!
+-\brief Mach port.
+-*/
+-
+-class JackMachPort
+-{
+-
+-    protected:
+-
+-        mach_port_t fBootPort;
+-        mach_port_t fServerPort;
+-
+-    public:
+-
+-        JackMachPort():fBootPort(0), fServerPort(0)
+-        {}
+-        virtual ~JackMachPort()
+-        {}
+-
+-        virtual bool AllocatePort(const char* name);
+-        virtual bool AllocatePort(const char* name, int queue);
+-        virtual bool ConnectPort(const char* name);
+-        virtual bool DisconnectPort();
+-        virtual bool DestroyPort();
+-        virtual mach_port_t GetPort();
+-};
+-
+-/*!
+-\brief Mach port set.
+-*/
+-
+-class JackMachPortSet : public JackMachPort
+-{
+-
+-    private:
+-
+-        mach_port_t fPortSet;
+-
+-    public:
+-
+-        JackMachPortSet():fPortSet(0)
+-        {}
+-        virtual ~JackMachPortSet()
+-        {}
+-
+-        bool AllocatePort(const char* name);
+-        bool AllocatePort(const char* name, int queue);
+-        bool DisconnectPort();
+-        bool DestroyPort();
+-        mach_port_t GetPortSet();
+-        mach_port_t AddPort();
+-};
+-
+-} // end of namespace
+-
+-#endif
+-
+--- a/macosx/JackMachServerChannel.cpp
++++ /dev/null
+@@ -1,174 +0,0 @@
+-/*
+-Copyright (C) 2004-2008 Grame
+-
+-This program is free software; you can redistribute it and/or modify
+-it under the terms of the GNU Lesser General Public License as published by
+-the Free Software Foundation; either version 2.1 of the License, or
+-(at your option) any later version.
+-
+-This program is distributed in the hope that it will be useful,
+-but WITHOUT ANY WARRANTY; without even the implied warranty of
+-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+-GNU Lesser General Public License for more details.
+-
+-You should have received a copy of the GNU Lesser General Public License
+-along with this program; if not, write to the Free Software 
+-Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+-
+-*/
+-
+-#include "JackTools.h"
+-#include "JackMachServerChannel.h"
+-#include "JackRPCEngineServer.c"
+-#include "JackError.h"
+-#include "JackServer.h"
+-#include "JackLockedEngine.h"
+-#include "JackNotification.h"
+-#include "JackServerGlobals.h"
+-
+-using namespace std;
+-
+-namespace Jack
+-{
+-
+-map<mach_port_t, JackMachServerChannel*> JackMachServerChannel::fPortTable;
+-
+-JackMachServerChannel::JackMachServerChannel():fThread(this)
+-{}
+-
+-JackMachServerChannel::~JackMachServerChannel()
+-{}
+-
+-int JackMachServerChannel::Open(const char* server_name, JackServer* server)
+-{
+-    jack_log("JackMachServerChannel::Open");
+-    char jack_server_entry_name[512];
+-    snprintf(jack_server_entry_name, sizeof(jack_server_entry_name), "%s.%d_%s", jack_server_entry, JackTools::GetUID(), server_name);
+-
+-    if (!fServerPort.AllocatePort(jack_server_entry_name, 16)) { // 16 is the max possible value
+-        jack_error("Cannot check in Jack server");
+-        return -1;
+-    }
+-
+-    fServer = server;
+-    fPortTable[fServerPort.GetPort()] = this;
+-    return 0;
+-}
+-
+-void JackMachServerChannel::Close()
+-{
+-    jack_log("JackMachServerChannel::Close");
+- #ifdef MAC_OS_X_VERSION_10_5
+-    // Exception does not work in this case on pre Snow Loopard systems, see JackMachServerNotifyChannel::NotifyQuit()
+-    fThread.Kill();
+- #else
+-    fThread.Stop();
+- #endif
+-    fServerPort.DestroyPort();
+-}
+-    
+-int JackMachServerChannel::Start()
+-{
+-    if (fThread.Start() != 0) {
+-        jack_error("Cannot start Jack server listener");
+-        return -1;
+-    }  
+-    
+-    return 0;
+-}
+-
+-JackLockedEngine* JackMachServerChannel::GetEngine()
+-{
+-    return fServer->GetEngine();
+-}
+-
+-JackServer* JackMachServerChannel::GetServer()
+-{
+-    return fServer;
+-}
+-
+-void JackMachServerChannel::ClientCheck(char* name, char* name_res, int protocol, int options, int* status, int* result)
+-{
+-    *result = GetEngine()->ClientCheck(name, name_res, protocol, options, status);
+-}
+-
+-void JackMachServerChannel::ClientOpen(char* name, int pid, mach_port_t* private_port, int* shared_engine, int* shared_client, int* shared_graph, int* result)
+-{
+-    int refnum = -1;
+-    *result = GetEngine()->ClientExternalOpen(name, pid, &refnum, shared_engine, shared_client, shared_graph);
+-
+-    if (*result == 0) {
+-        mach_port_t port = fServerPort.AddPort();
+-        if (port != 0) {
+-            fClientTable[port] = refnum;
+-            fPortTable[port] = this;
+-            *private_port = port;
+-        } else {
+-            jack_error("Cannot create private client mach port");
+-            *result = -1;
+-        }
+-    } else {
+-        jack_error("Cannot create new client");
+-    }
+-}
+-
+-void JackMachServerChannel::ClientClose(mach_port_t private_port, int refnum)
+-{
+-    GetEngine()->ClientExternalClose(refnum);
+-    fClientTable.erase(private_port);
+-
+-    // Hum, hum....
+-    kern_return_t res;
+-    if ((res = mach_port_destroy(mach_task_self(), private_port)) != KERN_SUCCESS) {
+-        jack_error("server_rpc_jack_client_close mach_port_destroy %s", mach_error_string(res));
+-    }
+-}
+-
+-void JackMachServerChannel::ClientKill(mach_port_t private_port)
+-{
+-    jack_log("JackMachServerChannel::ClientKill");
+-    int refnum = fClientTable[private_port];
+-    assert(refnum > 0);
+-    fServer->ClientKill(refnum);
+-    fClientTable.erase(private_port);
+-
+-    // Hum, hum....
+-    kern_return_t res;
+-    if ((res = mach_port_destroy(mach_task_self(), private_port)) != KERN_SUCCESS) {
+-        jack_error("server_rpc_jack_client_close mach_port_destroy %s", mach_error_string(res));
+-    }
+-}
+-
+-boolean_t JackMachServerChannel::MessageHandler(mach_msg_header_t* Request, mach_msg_header_t* Reply)
+-{
+-    if (Request->msgh_id == MACH_NOTIFY_NO_SENDERS) {
+-        jack_log("MACH_NOTIFY_NO_SENDERS %ld", Request->msgh_local_port);
+-        JackMachServerChannel* channel = JackMachServerChannel::fPortTable[Request->msgh_local_port];
+-        assert(channel);
+-        channel->ClientKill(Request->msgh_local_port);
+-    } else {
+-        JackRPCEngine_server(Request, Reply);
+-    }
+-    return true;
+-}
+-
+-bool JackMachServerChannel::Execute()
+-{
+-    try {
+-        
+-        kern_return_t res;
+-        if ((res = mach_msg_server(MessageHandler, 1024, fServerPort.GetPortSet(), 0)) != KERN_SUCCESS) {
+-            jack_log("JackMachServerChannel::Execute: err = %s", mach_error_string(res));
+-            // A recoverable error, so keep running...
+-        }
+-        return true;
+-        
+-    } catch (JackQuitException& e) {
+-        jack_log("JackMachServerChannel::Execute JackQuitException");
+-        return false;
+-    }
+-}
+-
+-} // end of namespace
+-
+-
+--- a/macosx/JackMachServerChannel.h
++++ /dev/null
+@@ -1,76 +0,0 @@
+-/*
+-Copyright (C) 2004-2008 Grame
+-
+-This program is free software; you can redistribute it and/or modify
+-it under the terms of the GNU Lesser General Public License as published by
+-the Free Software Foundation; either version 2.1 of the License, or
+-(at your option) any later version.
+-
+-This program is distributed in the hope that it will be useful,
+-but WITHOUT ANY WARRANTY; without even the implied warranty of
+-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+-GNU Lesser General Public License for more details.
+-
+-You should have received a copy of the GNU Lesser General Public License
+-along with this program; if not, write to the Free Software 
+-Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+-
+-*/
+-
+-#ifndef __JackMachServerChannel__
+-#define __JackMachServerChannel__
+-
+-#include "JackPlatformPlug.h"
+-#include "JackMachPort.h"
+-#include <map>
+-
+-namespace Jack
+-{
+-
+-class JackServer;
+-class JackLockedEngine;
+-
+-/*!
+-\brief JackServerChannel using Mach IPC.
+-*/
+-
+-class JackMachServerChannel : public JackRunnableInterface
+-{
+-
+-    private:
+-
+-        JackMachPortSet fServerPort;    /*! Mach port to communicate with the server : from client to server */
+-        JackThread fThread;             /*! Thread to execute the event loop */
+-        JackServer* fServer;
+-        std::map<mach_port_t, int> fClientTable;
+-
+-        static boolean_t MessageHandler(mach_msg_header_t* Request, mach_msg_header_t* Reply);
+-
+-    public:
+-
+-        JackMachServerChannel();
+-        ~JackMachServerChannel();
+-
+-        int Open(const char* server_name, JackServer* server);	// Open the Server/Client connection
+-        void Close();                                           // Close the Server/Client connection
+-    
+-        int Start();
+-  
+-        JackLockedEngine* GetEngine();
+-        JackServer* GetServer();
+-
+-        void ClientCheck(char* name, char* name_res, int protocol, int options, int* status, int* result);
+-        void ClientOpen(char* name, int pid, mach_port_t* private_port, int* shared_engine, int* shared_client, int* shared_graph, int* result);
+-        void ClientClose(mach_port_t private_port, int refnum);
+-        void ClientKill(mach_port_t private_port);
+-
+-        bool Execute();
+-
+-        // Has to be public..
+-        static std::map<mach_port_t, JackMachServerChannel*> fPortTable;
+-};
+-
+-} // end of namespace
+-
+-#endif
+-
+--- a/macosx/JackMachServerNotifyChannel.cpp
++++ /dev/null
+@@ -1,70 +0,0 @@
+-/*
+-Copyright (C) 2004-2008 Grame
+-
+-This program is free software; you can redistribute it and/or modify
+-it under the terms of the GNU Lesser General Public License as published by
+-the Free Software Foundation; either version 2.1 of the License, or
+-(at your option) any later version.
+-
+-This program is distributed in the hope that it will be useful,
+-but WITHOUT ANY WARRANTY; without even the implied warranty of
+-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+-GNU Lesser General Public License for more details.
+-
+-You should have received a copy of the GNU Lesser General Public License
+-along with this program; if not, write to the Free Software 
+-Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+-
+-*/
+-
+-#include "JackMachServerNotifyChannel.h"
+-#include "JackRPCEngineUser.c"
+-#include "JackNotification.h"
+-#include "JackTools.h"
+-#include "JackConstants.h"
+-#include "JackError.h"
+-#include <stdio.h>
+-
+-namespace Jack
+-{
+-
+-int JackMachServerNotifyChannel::Open(const char* server_name)
+-{
+-    jack_log("JackMachServerChannel::Open");
+-    char jack_server_entry_name[512];
+-    snprintf(jack_server_entry_name, sizeof(jack_server_entry_name), "%s.%d_%s", jack_server_entry, JackTools::GetUID(), server_name);
+-
+-    if (!fClientPort.ConnectPort(jack_server_entry_name)) {
+-        jack_error("Cannot connect to server port");
+-        return -1;
+-    } else {
+-        return 0;
+-    }
+-}
+-
+-void JackMachServerNotifyChannel::Close()
+-{}
+-
+-void JackMachServerNotifyChannel::Notify(int refnum, int notify, int value)
+-{
+-    kern_return_t res = rpc_jack_client_rt_notify(fClientPort.GetPort(), refnum, notify, value, 0);
+-    if (res != KERN_SUCCESS) {
+-        jack_error("Could not write request ref = %d notify = %d err = %s", refnum, notify, mach_error_string(res));
+-    }
+-}
+-    
+-void JackMachServerNotifyChannel::NotifyQuit()
+-{
+- #ifdef MAC_OS_X_VERSION_10_5
+-    // Nothing : since exception does not work in this case on pre Snow Loopard systems, see JackMachServerChannel::Close()
+- #else
+-    kern_return_t res = rpc_jack_client_rt_notify(fClientPort.GetPort(), -1, kQUIT, 0, 0);
+-    if (res != KERN_SUCCESS) {
+-        jack_error("Could not write request ref = %d notify = %d err = %s", -1, kQUIT, mach_error_string(res));
+-    }
+-#endif
+-}
+-
+-} // end of namespace
+-
+-
+--- a/macosx/JackMachServerNotifyChannel.h
++++ /dev/null
+@@ -1,55 +0,0 @@
+-/*
+-Copyright (C) 2004-2008 Grame
+-
+-This program is free software; you can redistribute it and/or modify
+-it under the terms of the GNU Lesser General Public License as published by
+-the Free Software Foundation; either version 2.1 of the License, or
+-(at your option) any later version.
+-
+-This program is distributed in the hope that it will be useful,
+-but WITHOUT ANY WARRANTY; without even the implied warranty of
+-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+-GNU Lesser General Public License for more details.
+-
+-You should have received a copy of the GNU Lesser General Public License
+-along with this program; if not, write to the Free Software 
+-Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+-
+-*/
+-
+-#ifndef __JackMachServerNotifyChannel__
+-#define __JackMachServerNotifyChannel__
+-
+-#include "JackChannel.h"
+-#include "JackMachPort.h"
+-
+-namespace Jack
+-{
+-
+-/*!
+-\brief JackServerNotifyChannel using Mach IPC.
+-*/
+-
+-class JackMachServerNotifyChannel
+-{
+-
+-    private:
+-
+-        JackMachPort fClientPort;    /*! Mach port to communicate with the server : from client to server */
+-
+-    public:
+-
+-        JackMachServerNotifyChannel()
+-        {}
+-
+-        int Open(const char* server_name);  // Open the Server/Client connection
+-        void Close();                       // Close the Server/Client connection
+-
+-        void Notify(int refnum, int notify, int value);
+-        void NotifyQuit();
+-};  
+-
+-} // end of namespace
+-
+-#endif
+-
+--- a/macosx/JackPlatformPlug_os.h
++++ b/macosx/JackPlatformPlug_os.h
+@@ -26,14 +26,18 @@
+ 
+ namespace Jack
+ {       
++    struct JackRequest;
++    struct JackResult;
++    
+ 	class JackPosixMutex;
+ 	class JackMachThread;
+ 	class JackMachSemaphore;
+-
+-	class JackMachServerChannel;
+-	class JackMachClientChannel;
+-	class JackMachServerNotifyChannel;
+-	class JackMachNotifyChannel;
++    
++    class JackSocketServerChannel;
++    class JackSocketClientChannel;
++    class JackSocketServerNotifyChannel;
++    class JackSocketNotifyChannel;
++    
+ 	class JackNetUnixSocket;
+ }
+ 
+@@ -49,25 +53,28 @@
+ #include "JackMachSemaphore.h"
+ namespace Jack { typedef JackMachSemaphore JackSynchro; }
+ 
++#include "JackSocket.h"
++namespace Jack { typedef JackClientSocket JackChannelTransaction; }
++
+ /* __JackPlatformProcessSync__ */
+ #include "JackProcessSync.h"
+ /* Only on windows a special JackProcessSync is used. It is directly defined by including JackProcessSync.h here */
+ 
+ /* __JackPlatformServerChannel__ */ 
+-#include "JackMachServerChannel.h"
+-namespace Jack { typedef JackMachServerChannel JackServerChannel; }
++#include "JackSocketServerChannel.h"
++namespace Jack { typedef JackSocketServerChannel JackServerChannel; }
+ 
+ /* __JackPlatformClientChannel__ */
+-#include "JackMachClientChannel.h"
+-namespace Jack { typedef JackMachClientChannel JackClientChannel; }
++#include "JackSocketClientChannel.h"
++namespace Jack { typedef JackSocketClientChannel JackClientChannel; }
+ 
+ /* __JackPlatformServerNotifyChannel__ */
+-#include "JackMachServerNotifyChannel.h"
+-namespace Jack { typedef JackMachServerNotifyChannel JackServerNotifyChannel; }
++#include "JackSocketServerNotifyChannel.h"
++namespace Jack { typedef JackSocketServerNotifyChannel JackServerNotifyChannel; }
+ 
+ /* __JackPlatformNotifyChannel__ */
+-#include "JackMachNotifyChannel.h"
+-namespace Jack { typedef JackMachNotifyChannel JackNotifyChannel; }
++#include "JackSocketNotifyChannel.h"
++namespace Jack { typedef JackSocketNotifyChannel JackNotifyChannel; }
+ 
+ /* __JackPlatformNetSocket__ */
+ #include "JackNetUnixSocket.h"
+--- a/macosx/Jackdmp.xcodeproj/project.pbxproj
++++ b/macosx/Jackdmp.xcodeproj/project.pbxproj
+@@ -47,6 +47,7 @@
+ 				4BFA833A0DF6AB540087B4E1 /* PBXTargetDependency */,
+ 				4BFA833C0DF6AB540087B4E1 /* PBXTargetDependency */,
+ 				4B32258F10A31AB400838A8E /* PBXTargetDependency */,
++				4B66550E127C356E00753A79 /* PBXTargetDependency */,
+ 			);
+ 			name = "All Universal 32/64 bits";
+ 			productName = All;
+@@ -132,7 +133,6 @@
+ 		4B32258010A3195A00838A8E /* netjack_packet.h in Headers */ = {isa = PBXBuildFile; fileRef = 4B3224ED10A315C400838A8E /* netjack_packet.h */; };
+ 		4B32258110A3195B00838A8E /* netsource.c in Sources */ = {isa = PBXBuildFile; fileRef = 4B32256310A318E300838A8E /* netsource.c */; };
+ 		4B35C41E0D4731D1000DE7AE /* Jackdmp.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BF8D2250834F06A00C94B91 /* Jackdmp.cpp */; };
+-		4B35C4290D4731D1000DE7AE /* JackMachPort.h in Headers */ = {isa = PBXBuildFile; fileRef = 4B799AD707899652003F3F15 /* JackMachPort.h */; };
+ 		4B35C42A0D4731D1000DE7AE /* JackError.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BF8D1770834EE4800C94B91 /* JackError.h */; };
+ 		4B35C42B0D4731D1000DE7AE /* JackTime.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BF8D1830834EE5800C94B91 /* JackTime.h */; };
+ 		4B35C42C0D4731D1000DE7AE /* JackShmMem.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BF8D1870834EE7900C94B91 /* JackShmMem.h */; };
+@@ -153,7 +153,6 @@
+ 		4B35C43D0D4731D1000DE7AE /* JackMachSemaphore.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BF6C1D608ACE64C001E2013 /* JackMachSemaphore.h */; };
+ 		4B35C43E0D4731D1000DE7AE /* JackGlobals.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BFB73F608AD291A00DB99B8 /* JackGlobals.h */; };
+ 		4B35C43F0D4731D1000DE7AE /* JackMachThread.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BFB741F08AD2B9900DB99B8 /* JackMachThread.h */; };
+-		4B35C4400D4731D1000DE7AE /* JackMachClientChannel.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BFB298708AF450200D450D4 /* JackMachClientChannel.h */; };
+ 		4B35C4460D4731D1000DE7AE /* JackSynchro.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BD561C708EEB910006BBC2A /* JackSynchro.h */; };
+ 		4B35C4470D4731D1000DE7AE /* JackDebugClient.h in Headers */ = {isa = PBXBuildFile; fileRef = 4B98AE010931D30C0091932A /* JackDebugClient.h */; };
+ 		4B35C4480D4731D1000DE7AE /* JackConstants.h in Headers */ = {isa = PBXBuildFile; fileRef = 4B66A8580934964500A89560 /* JackConstants.h */; };
+@@ -170,9 +169,6 @@
+ 		4B35C4530D4731D1000DE7AE /* JackMidiPort.h in Headers */ = {isa = PBXBuildFile; fileRef = 4B80D7E50BA0D17400F035BB /* JackMidiPort.h */; };
+ 		4B35C4540D4731D1000DE7AE /* midiport.h in Headers */ = {isa = PBXBuildFile; fileRef = 4B6B9EF50CD0958B0051EE5A /* midiport.h */; settings = {ATTRIBUTES = (Public, ); }; };
+ 		4B35C4550D4731D1000DE7AE /* JackTools.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BE4CC000CDA153400CCF5BB /* JackTools.h */; };
+-		4B35C4580D4731D1000DE7AE /* JackMacLibClientRPC.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BF3937C0626BF3600CC67FA /* JackMacLibClientRPC.cpp */; };
+-		4B35C4590D4731D1000DE7AE /* JackRPCEngineUser.c in Sources */ = {isa = PBXBuildFile; fileRef = 4B89B769076B74D200D170DE /* JackRPCEngineUser.c */; };
+-		4B35C45A0D4731D1000DE7AE /* JackMachPort.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B799AD607899652003F3F15 /* JackMachPort.cpp */; };
+ 		4B35C45B0D4731D1000DE7AE /* JackShmMem.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BF8D1880834EE7900C94B91 /* JackShmMem.cpp */; };
+ 		4B35C45C0D4731D1000DE7AE /* shm.c in Sources */ = {isa = PBXBuildFile; fileRef = 4BF8D1900834EE8400C94B91 /* shm.c */; };
+ 		4B35C45E0D4731D1000DE7AE /* JackActivationCount.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BF8D1A80834EEB400C94B91 /* JackActivationCount.cpp */; };
+@@ -186,7 +182,6 @@
+ 		4B35C4660D4731D1000DE7AE /* JackFrameTimer.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BF8FB0D08AC88EF00D1A344 /* JackFrameTimer.cpp */; };
+ 		4B35C4680D4731D1000DE7AE /* JackMachSemaphore.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BF6C1D508ACE64C001E2013 /* JackMachSemaphore.cpp */; };
+ 		4B35C4690D4731D1000DE7AE /* JackMachThread.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BFB741E08AD2B9900DB99B8 /* JackMachThread.cpp */; };
+-		4B35C46A0D4731D1000DE7AE /* JackMachClientChannel.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BFB29AE08AF45FD00D450D4 /* JackMachClientChannel.cpp */; };
+ 		4B35C4700D4731D1000DE7AE /* JackGlobals.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B2C28F908DAD01E00249230 /* JackGlobals.cpp */; };
+ 		4B35C4720D4731D1000DE7AE /* ringbuffer.c in Sources */ = {isa = PBXBuildFile; fileRef = 4B003AB008E2B2BA0060EFDC /* ringbuffer.c */; };
+ 		4B35C4730D4731D1000DE7AE /* JackDebugClient.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B98AE000931D30C0091932A /* JackDebugClient.cpp */; };
+@@ -198,7 +193,6 @@
+ 		4B35C47A0D4731D1000DE7AE /* JackMidiAPI.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B80D7E70BA0D17400F035BB /* JackMidiAPI.cpp */; };
+ 		4B35C47B0D4731D1000DE7AE /* JackEngineControl.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B6F7AEC0CD0CDBD00F48A9D /* JackEngineControl.cpp */; };
+ 		4B35C47C0D4731D1000DE7AE /* JackTools.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BE4CBFF0CDA153400CCF5BB /* JackTools.cpp */; };
+-		4B35C4870D4731D1000DE7AE /* JackMachPort.h in Headers */ = {isa = PBXBuildFile; fileRef = 4B799AD707899652003F3F15 /* JackMachPort.h */; };
+ 		4B35C4880D4731D1000DE7AE /* JackError.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BF8D1770834EE4800C94B91 /* JackError.h */; };
+ 		4B35C4890D4731D1000DE7AE /* JackTime.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BF8D1830834EE5800C94B91 /* JackTime.h */; };
+ 		4B35C48A0D4731D1000DE7AE /* JackShmMem.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BF8D1870834EE7900C94B91 /* JackShmMem.h */; };
+@@ -227,9 +221,6 @@
+ 		4B35C4A90D4731D1000DE7AE /* JackEngine.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BF8D2130834F02800C94B91 /* JackEngine.h */; };
+ 		4B35C4AA0D4731D1000DE7AE /* JackExternalClient.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BF8D1F70834EFBD00C94B91 /* JackExternalClient.h */; };
+ 		4B35C4AB0D4731D1000DE7AE /* JackServer.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BF8D2220834F05C00C94B91 /* JackServer.h */; };
+-		4B35C4AE0D4731D1000DE7AE /* JackMachNotifyChannel.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BFB298908AF450200D450D4 /* JackMachNotifyChannel.h */; };
+-		4B35C4AF0D4731D1000DE7AE /* JackMachServerChannel.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BFB297808AF44ED00D450D4 /* JackMachServerChannel.h */; };
+-		4B35C4B00D4731D1000DE7AE /* JackMachServerNotifyChannel.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BFB297A08AF44ED00D450D4 /* JackMachServerNotifyChannel.h */; };
+ 		4B35C4B20D4731D1000DE7AE /* JackConstants.h in Headers */ = {isa = PBXBuildFile; fileRef = 4B66A8580934964500A89560 /* JackConstants.h */; };
+ 		4B35C4B30D4731D1000DE7AE /* JackTransportEngine.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BD4B4D409BACD9600750C0F /* JackTransportEngine.h */; };
+ 		4B35C4B40D4731D1000DE7AE /* JackServerGlobals.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BC2168D0A444BED00BDA09F /* JackServerGlobals.h */; };
+@@ -246,7 +237,6 @@
+ 		4B35C4BF0D4731D1000DE7AE /* midiport.h in Headers */ = {isa = PBXBuildFile; fileRef = 4B6B9EF50CD0958B0051EE5A /* midiport.h */; settings = {ATTRIBUTES = (Public, ); }; };
+ 		4B35C4C00D4731D1000DE7AE /* JackDebugClient.h in Headers */ = {isa = PBXBuildFile; fileRef = 4B98AE010931D30C0091932A /* JackDebugClient.h */; };
+ 		4B35C4C10D4731D1000DE7AE /* JackTools.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BE4CC000CDA153400CCF5BB /* JackTools.h */; };
+-		4B35C4C40D4731D1000DE7AE /* JackMachPort.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B799AD607899652003F3F15 /* JackMachPort.cpp */; };
+ 		4B35C4C50D4731D1000DE7AE /* JackShmMem.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BF8D1880834EE7900C94B91 /* JackShmMem.cpp */; };
+ 		4B35C4C60D4731D1000DE7AE /* shm.c in Sources */ = {isa = PBXBuildFile; fileRef = 4BF8D1900834EE8400C94B91 /* shm.c */; };
+ 		4B35C4C80D4731D1000DE7AE /* JackActivationCount.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BF8D1A80834EEB400C94B91 /* JackActivationCount.cpp */; };
+@@ -268,12 +258,7 @@
+ 		4B35C4DD0D4731D1000DE7AE /* JackEngine.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BF8D2140834F02800C94B91 /* JackEngine.cpp */; };
+ 		4B35C4DE0D4731D1000DE7AE /* JackExternalClient.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BF8D1F80834EFBD00C94B91 /* JackExternalClient.cpp */; };
+ 		4B35C4DF0D4731D1000DE7AE /* JackInternalClient.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BF8D1ED0834EF9200C94B91 /* JackInternalClient.cpp */; };
+-		4B35C4E00D4731D1000DE7AE /* JackRPCClientUser.c in Sources */ = {isa = PBXBuildFile; fileRef = 4B89B759076B731100D170DE /* JackRPCClientUser.c */; };
+ 		4B35C4E20D4731D1000DE7AE /* JackServer.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BF8D2210834F05C00C94B91 /* JackServer.cpp */; };
+-		4B35C4E60D4731D1000DE7AE /* JackMacEngineRPC.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B4259E5076B635E00C1ECE1 /* JackMacEngineRPC.cpp */; };
+-		4B35C4E70D4731D1000DE7AE /* JackMachNotifyChannel.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BFB298808AF450200D450D4 /* JackMachNotifyChannel.cpp */; };
+-		4B35C4E80D4731D1000DE7AE /* JackMachServerChannel.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BFB297908AF44ED00D450D4 /* JackMachServerChannel.cpp */; };
+-		4B35C4E90D4731D1000DE7AE /* JackMachServerNotifyChannel.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BFB297708AF44ED00D450D4 /* JackMachServerNotifyChannel.cpp */; };
+ 		4B35C4EB0D4731D1000DE7AE /* JackTransportEngine.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BD4B4D509BACD9600750C0F /* JackTransportEngine.cpp */; };
+ 		4B35C4EC0D4731D1000DE7AE /* JackServerAPI.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BF8D1F50834EFB000C94B91 /* JackServerAPI.cpp */; };
+ 		4B35C4ED0D4731D1000DE7AE /* JackServerGlobals.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BC216880A444BDE00BDA09F /* JackServerGlobals.cpp */; };
+@@ -322,7 +307,6 @@
+ 		4B43A8CB1014605000E52943 /* JackLoopbackDriver.h in Headers */ = {isa = PBXBuildFile; fileRef = 4B43A8C91014605000E52943 /* JackLoopbackDriver.h */; };
+ 		4B43A8DF1014615800E52943 /* JackLoopbackDriver.h in Headers */ = {isa = PBXBuildFile; fileRef = 4B43A8C91014605000E52943 /* JackLoopbackDriver.h */; };
+ 		4B43A8E11014615800E52943 /* JackLoopbackDriver.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B43A8C81014605000E52943 /* JackLoopbackDriver.cpp */; };
+-		4B47AC8210B5890100469C67 /* JackMachPort.h in Headers */ = {isa = PBXBuildFile; fileRef = 4B799AD707899652003F3F15 /* JackMachPort.h */; };
+ 		4B47AC8310B5890100469C67 /* JackError.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BF8D1770834EE4800C94B91 /* JackError.h */; };
+ 		4B47AC8410B5890100469C67 /* JackTime.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BF8D1830834EE5800C94B91 /* JackTime.h */; };
+ 		4B47AC8510B5890100469C67 /* JackShmMem.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BF8D1870834EE7900C94B91 /* JackShmMem.h */; };
+@@ -343,7 +327,6 @@
+ 		4B47AC9410B5890100469C67 /* JackMachSemaphore.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BF6C1D608ACE64C001E2013 /* JackMachSemaphore.h */; };
+ 		4B47AC9510B5890100469C67 /* JackGlobals.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BFB73F608AD291A00DB99B8 /* JackGlobals.h */; };
+ 		4B47AC9610B5890100469C67 /* JackMachThread.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BFB741F08AD2B9900DB99B8 /* JackMachThread.h */; };
+-		4B47AC9710B5890100469C67 /* JackMachClientChannel.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BFB298708AF450200D450D4 /* JackMachClientChannel.h */; };
+ 		4B47AC9810B5890100469C67 /* JackSynchro.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BD561C708EEB910006BBC2A /* JackSynchro.h */; };
+ 		4B47AC9910B5890100469C67 /* JackDebugClient.h in Headers */ = {isa = PBXBuildFile; fileRef = 4B98AE010931D30C0091932A /* JackDebugClient.h */; };
+ 		4B47AC9A10B5890100469C67 /* JackConstants.h in Headers */ = {isa = PBXBuildFile; fileRef = 4B66A8580934964500A89560 /* JackConstants.h */; };
+@@ -364,9 +347,6 @@
+ 		4B47ACA910B5890100469C67 /* JackMessageBuffer.h in Headers */ = {isa = PBXBuildFile; fileRef = 4B4F9C8B0DC20C0400706CB0 /* JackMessageBuffer.h */; };
+ 		4B47ACAA10B5890100469C67 /* JackPosixThread.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BC3B6A30E703B2E0066E42F /* JackPosixThread.h */; };
+ 		4B47ACAB10B5890100469C67 /* JackProcessSync.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BECB2F40F4451C10091B70A /* JackProcessSync.h */; };
+-		4B47ACAE10B5890100469C67 /* JackMacLibClientRPC.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BF3937C0626BF3600CC67FA /* JackMacLibClientRPC.cpp */; };
+-		4B47ACAF10B5890100469C67 /* JackRPCEngineUser.c in Sources */ = {isa = PBXBuildFile; fileRef = 4B89B769076B74D200D170DE /* JackRPCEngineUser.c */; };
+-		4B47ACB010B5890100469C67 /* JackMachPort.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B799AD607899652003F3F15 /* JackMachPort.cpp */; };
+ 		4B47ACB110B5890100469C67 /* JackShmMem.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BF8D1880834EE7900C94B91 /* JackShmMem.cpp */; };
+ 		4B47ACB210B5890100469C67 /* shm.c in Sources */ = {isa = PBXBuildFile; fileRef = 4BF8D1900834EE8400C94B91 /* shm.c */; };
+ 		4B47ACB310B5890100469C67 /* JackActivationCount.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BF8D1A80834EEB400C94B91 /* JackActivationCount.cpp */; };
+@@ -380,7 +360,6 @@
+ 		4B47ACBB10B5890100469C67 /* JackFrameTimer.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BF8FB0D08AC88EF00D1A344 /* JackFrameTimer.cpp */; };
+ 		4B47ACBC10B5890100469C67 /* JackMachSemaphore.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BF6C1D508ACE64C001E2013 /* JackMachSemaphore.cpp */; };
+ 		4B47ACBD10B5890100469C67 /* JackMachThread.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BFB741E08AD2B9900DB99B8 /* JackMachThread.cpp */; };
+-		4B47ACBE10B5890100469C67 /* JackMachClientChannel.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BFB29AE08AF45FD00D450D4 /* JackMachClientChannel.cpp */; };
+ 		4B47ACBF10B5890100469C67 /* JackGlobals.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B2C28F908DAD01E00249230 /* JackGlobals.cpp */; };
+ 		4B47ACC010B5890100469C67 /* ringbuffer.c in Sources */ = {isa = PBXBuildFile; fileRef = 4B003AB008E2B2BA0060EFDC /* ringbuffer.c */; };
+ 		4B47ACC110B5890100469C67 /* JackDebugClient.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B98AE000931D30C0091932A /* JackDebugClient.cpp */; };
+@@ -433,8 +412,8 @@
+ 		4B5F253E0DEE9B8F0041E486 /* JackLockedEngine.h in Headers */ = {isa = PBXBuildFile; fileRef = 4B5F253D0DEE9B8F0041E486 /* JackLockedEngine.h */; };
+ 		4B60CE490AAABA31004956AA /* connect.c in Sources */ = {isa = PBXBuildFile; fileRef = 4B60CE480AAABA31004956AA /* connect.c */; };
+ 		4B60CE4A0AAABA31004956AA /* connect.c in Sources */ = {isa = PBXBuildFile; fileRef = 4B60CE480AAABA31004956AA /* connect.c */; };
++		4B6654FC127C350100753A79 /* server_control.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B6654FB127C350100753A79 /* server_control.cpp */; };
+ 		4B699BAA097D421600A18468 /* Jackdmp.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BF8D2250834F06A00C94B91 /* Jackdmp.cpp */; };
+-		4B699C02097D421600A18468 /* JackMachPort.h in Headers */ = {isa = PBXBuildFile; fileRef = 4B799AD707899652003F3F15 /* JackMachPort.h */; };
+ 		4B699C03097D421600A18468 /* JackError.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BF8D1770834EE4800C94B91 /* JackError.h */; };
+ 		4B699C04097D421600A18468 /* JackTime.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BF8D1830834EE5800C94B91 /* JackTime.h */; };
+ 		4B699C05097D421600A18468 /* JackShmMem.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BF8D1870834EE7900C94B91 /* JackShmMem.h */; };
+@@ -455,13 +434,9 @@
+ 		4B699C16097D421600A18468 /* JackMachSemaphore.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BF6C1D608ACE64C001E2013 /* JackMachSemaphore.h */; };
+ 		4B699C17097D421600A18468 /* JackGlobals.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BFB73F608AD291A00DB99B8 /* JackGlobals.h */; };
+ 		4B699C18097D421600A18468 /* JackMachThread.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BFB741F08AD2B9900DB99B8 /* JackMachThread.h */; };
+-		4B699C19097D421600A18468 /* JackMachClientChannel.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BFB298708AF450200D450D4 /* JackMachClientChannel.h */; };
+ 		4B699C20097D421600A18468 /* JackSynchro.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BD561C708EEB910006BBC2A /* JackSynchro.h */; };
+ 		4B699C21097D421600A18468 /* JackDebugClient.h in Headers */ = {isa = PBXBuildFile; fileRef = 4B98AE010931D30C0091932A /* JackDebugClient.h */; };
+ 		4B699C22097D421600A18468 /* JackConstants.h in Headers */ = {isa = PBXBuildFile; fileRef = 4B66A8580934964500A89560 /* JackConstants.h */; };
+-		4B699C25097D421600A18468 /* JackMacLibClientRPC.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BF3937C0626BF3600CC67FA /* JackMacLibClientRPC.cpp */; };
+-		4B699C26097D421600A18468 /* JackRPCEngineUser.c in Sources */ = {isa = PBXBuildFile; fileRef = 4B89B769076B74D200D170DE /* JackRPCEngineUser.c */; };
+-		4B699C27097D421600A18468 /* JackMachPort.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B799AD607899652003F3F15 /* JackMachPort.cpp */; };
+ 		4B699C28097D421600A18468 /* JackShmMem.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BF8D1880834EE7900C94B91 /* JackShmMem.cpp */; };
+ 		4B699C29097D421600A18468 /* shm.c in Sources */ = {isa = PBXBuildFile; fileRef = 4BF8D1900834EE8400C94B91 /* shm.c */; };
+ 		4B699C2B097D421600A18468 /* JackActivationCount.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BF8D1A80834EEB400C94B91 /* JackActivationCount.cpp */; };
+@@ -475,11 +450,9 @@
+ 		4B699C33097D421600A18468 /* JackFrameTimer.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BF8FB0D08AC88EF00D1A344 /* JackFrameTimer.cpp */; };
+ 		4B699C35097D421600A18468 /* JackMachSemaphore.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BF6C1D508ACE64C001E2013 /* JackMachSemaphore.cpp */; };
+ 		4B699C36097D421600A18468 /* JackMachThread.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BFB741E08AD2B9900DB99B8 /* JackMachThread.cpp */; };
+-		4B699C37097D421600A18468 /* JackMachClientChannel.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BFB29AE08AF45FD00D450D4 /* JackMachClientChannel.cpp */; };
+ 		4B699C3D097D421600A18468 /* JackGlobals.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B2C28F908DAD01E00249230 /* JackGlobals.cpp */; };
+ 		4B699C3F097D421600A18468 /* ringbuffer.c in Sources */ = {isa = PBXBuildFile; fileRef = 4B003AB008E2B2BA0060EFDC /* ringbuffer.c */; };
+ 		4B699C40097D421600A18468 /* JackDebugClient.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B98AE000931D30C0091932A /* JackDebugClient.cpp */; };
+-		4B699C4E097D421600A18468 /* JackMachPort.h in Headers */ = {isa = PBXBuildFile; fileRef = 4B799AD707899652003F3F15 /* JackMachPort.h */; };
+ 		4B699C4F097D421600A18468 /* JackError.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BF8D1770834EE4800C94B91 /* JackError.h */; };
+ 		4B699C50097D421600A18468 /* JackTime.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BF8D1830834EE5800C94B91 /* JackTime.h */; };
+ 		4B699C51097D421600A18468 /* JackShmMem.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BF8D1870834EE7900C94B91 /* JackShmMem.h */; };
+@@ -508,11 +481,7 @@
+ 		4B699C71097D421600A18468 /* JackEngine.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BF8D2130834F02800C94B91 /* JackEngine.h */; };
+ 		4B699C73097D421600A18468 /* JackExternalClient.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BF8D1F70834EFBD00C94B91 /* JackExternalClient.h */; };
+ 		4B699C74097D421600A18468 /* JackServer.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BF8D2220834F05C00C94B91 /* JackServer.h */; };
+-		4B699C77097D421600A18468 /* JackMachNotifyChannel.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BFB298908AF450200D450D4 /* JackMachNotifyChannel.h */; };
+-		4B699C78097D421600A18468 /* JackMachServerChannel.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BFB297808AF44ED00D450D4 /* JackMachServerChannel.h */; };
+-		4B699C79097D421600A18468 /* JackMachServerNotifyChannel.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BFB297A08AF44ED00D450D4 /* JackMachServerNotifyChannel.h */; };
+ 		4B699C7B097D421600A18468 /* JackConstants.h in Headers */ = {isa = PBXBuildFile; fileRef = 4B66A8580934964500A89560 /* JackConstants.h */; };
+-		4B699C7E097D421600A18468 /* JackMachPort.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B799AD607899652003F3F15 /* JackMachPort.cpp */; };
+ 		4B699C7F097D421600A18468 /* JackShmMem.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BF8D1880834EE7900C94B91 /* JackShmMem.cpp */; };
+ 		4B699C80097D421600A18468 /* shm.c in Sources */ = {isa = PBXBuildFile; fileRef = 4BF8D1900834EE8400C94B91 /* shm.c */; };
+ 		4B699C82097D421600A18468 /* JackActivationCount.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BF8D1A80834EEB400C94B91 /* JackActivationCount.cpp */; };
+@@ -534,12 +503,7 @@
+ 		4B699C97097D421600A18468 /* JackEngine.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BF8D2140834F02800C94B91 /* JackEngine.cpp */; };
+ 		4B699C99097D421600A18468 /* JackExternalClient.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BF8D1F80834EFBD00C94B91 /* JackExternalClient.cpp */; };
+ 		4B699C9A097D421600A18468 /* JackInternalClient.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BF8D1ED0834EF9200C94B91 /* JackInternalClient.cpp */; };
+-		4B699C9B097D421600A18468 /* JackRPCClientUser.c in Sources */ = {isa = PBXBuildFile; fileRef = 4B89B759076B731100D170DE /* JackRPCClientUser.c */; };
+ 		4B699C9D097D421600A18468 /* JackServer.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BF8D2210834F05C00C94B91 /* JackServer.cpp */; };
+-		4B699CA1097D421600A18468 /* JackMacEngineRPC.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B4259E5076B635E00C1ECE1 /* JackMacEngineRPC.cpp */; };
+-		4B699CA2097D421600A18468 /* JackMachNotifyChannel.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BFB298808AF450200D450D4 /* JackMachNotifyChannel.cpp */; };
+-		4B699CA3097D421600A18468 /* JackMachServerChannel.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BFB297908AF44ED00D450D4 /* JackMachServerChannel.cpp */; };
+-		4B699CA4097D421600A18468 /* JackMachServerNotifyChannel.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BFB297708AF44ED00D450D4 /* JackMachServerNotifyChannel.cpp */; };
+ 		4B699CB4097D421600A18468 /* metro.c in Sources */ = {isa = PBXBuildFile; fileRef = 4BF8D16B0834EDF000C94B91 /* metro.c */; };
+ 		4B699CC4097D421600A18468 /* lsp.c in Sources */ = {isa = PBXBuildFile; fileRef = 4BF8D1690834EDE600C94B91 /* lsp.c */; };
+ 		4B699CF6097D421600A18468 /* freewheel.c in Sources */ = {isa = PBXBuildFile; fileRef = 4BF8D1710834EE0F00C94B91 /* freewheel.c */; };
+@@ -584,6 +548,18 @@
+ 		4B88D04411298BEE007A87C1 /* weakmacros.h in Headers */ = {isa = PBXBuildFile; fileRef = 4B88D03A11298BEE007A87C1 /* weakmacros.h */; settings = {ATTRIBUTES = (Public, ); }; };
+ 		4B88D04511298BEE007A87C1 /* weakjack.h in Headers */ = {isa = PBXBuildFile; fileRef = 4B88D03911298BEE007A87C1 /* weakjack.h */; settings = {ATTRIBUTES = (Public, ); }; };
+ 		4B88D04611298BEE007A87C1 /* weakmacros.h in Headers */ = {isa = PBXBuildFile; fileRef = 4B88D03A11298BEE007A87C1 /* weakmacros.h */; settings = {ATTRIBUTES = (Public, ); }; };
++		4B8A38A7117B80D300664E07 /* JackSocket.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BC3B6AD0E703B8D0066E42F /* JackSocket.cpp */; };
++		4B8A38A8117B80DA00664E07 /* JackSocket.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BC3B6AE0E703B8D0066E42F /* JackSocket.h */; };
++		4B8A38AD117B810A00664E07 /* JackSocketNotifyChannel.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BC3B6B20E703B8D0066E42F /* JackSocketNotifyChannel.h */; };
++		4B8A38AE117B811100664E07 /* JackSocketNotifyChannel.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BC3B6B10E703B8D0066E42F /* JackSocketNotifyChannel.cpp */; };
++		4B8A38B0117B812500664E07 /* JackSocketServerChannel.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BC3B6B40E703B8D0066E42F /* JackSocketServerChannel.h */; };
++		4B8A38B1117B812D00664E07 /* JackSocketServerChannel.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BC3B6B30E703B8D0066E42F /* JackSocketServerChannel.cpp */; };
++		4B8A38B2117B813400664E07 /* JackSocketServerNotifyChannel.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BC3B6B50E703B8D0066E42F /* JackSocketServerNotifyChannel.cpp */; };
++		4B8A38C4117B814000664E07 /* JackSocketServerNotifyChannel.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BC3B6B60E703B8D0066E42F /* JackSocketServerNotifyChannel.h */; };
++		4B8A38F0117B827900664E07 /* JackSocket.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BC3B6AE0E703B8D0066E42F /* JackSocket.h */; };
++		4B8A38F1117B827E00664E07 /* JackSocketClientChannel.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BC3B6AF0E703B8D0066E42F /* JackSocketClientChannel.cpp */; };
++		4B8A38F6117B82AB00664E07 /* JackSocket.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BC3B6AD0E703B8D0066E42F /* JackSocket.cpp */; };
++		4B8A38F7117B82B200664E07 /* JackSocketClientChannel.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BC3B6B00E703B8D0066E42F /* JackSocketClientChannel.h */; };
+ 		4B93F1990E87992100E4ECCD /* JackPosixThread.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BC3B6A20E703B2E0066E42F /* JackPosixThread.cpp */; };
+ 		4B93F19A0E87992200E4ECCD /* JackPosixThread.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BC3B6A30E703B2E0066E42F /* JackPosixThread.h */; };
+ 		4B93F19C0E87998200E4ECCD /* JackPosixServerLaunch.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BF5FBBA0E878B9C003D2374 /* JackPosixServerLaunch.cpp */; };
+@@ -604,7 +580,6 @@
+ 		4B9A26610DBF8ADD006E9FBC /* JackError.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B9A25B30DBF8330006E9FBC /* JackError.cpp */; };
+ 		4B9A26640DBF8B14006E9FBC /* JackError.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B9A25B30DBF8330006E9FBC /* JackError.cpp */; };
+ 		4B9A26790DBF8B88006E9FBC /* JackError.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B9A25B30DBF8330006E9FBC /* JackError.cpp */; };
+-		4BA3393510B2E36800190E3B /* JackMachPort.h in Headers */ = {isa = PBXBuildFile; fileRef = 4B799AD707899652003F3F15 /* JackMachPort.h */; };
+ 		4BA3393610B2E36800190E3B /* JackError.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BF8D1770834EE4800C94B91 /* JackError.h */; };
+ 		4BA3393710B2E36800190E3B /* JackTime.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BF8D1830834EE5800C94B91 /* JackTime.h */; };
+ 		4BA3393810B2E36800190E3B /* JackShmMem.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BF8D1870834EE7900C94B91 /* JackShmMem.h */; };
+@@ -633,9 +608,6 @@
+ 		4BA3394F10B2E36800190E3B /* JackEngine.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BF8D2130834F02800C94B91 /* JackEngine.h */; };
+ 		4BA3395010B2E36800190E3B /* JackExternalClient.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BF8D1F70834EFBD00C94B91 /* JackExternalClient.h */; };
+ 		4BA3395110B2E36800190E3B /* JackServer.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BF8D2220834F05C00C94B91 /* JackServer.h */; };
+-		4BA3395210B2E36800190E3B /* JackMachNotifyChannel.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BFB298908AF450200D450D4 /* JackMachNotifyChannel.h */; };
+-		4BA3395310B2E36800190E3B /* JackMachServerChannel.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BFB297808AF44ED00D450D4 /* JackMachServerChannel.h */; };
+-		4BA3395410B2E36800190E3B /* JackMachServerNotifyChannel.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BFB297A08AF44ED00D450D4 /* JackMachServerNotifyChannel.h */; };
+ 		4BA3395510B2E36800190E3B /* JackConstants.h in Headers */ = {isa = PBXBuildFile; fileRef = 4B66A8580934964500A89560 /* JackConstants.h */; };
+ 		4BA3395610B2E36800190E3B /* JackTransportEngine.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BD4B4D409BACD9600750C0F /* JackTransportEngine.h */; };
+ 		4BA3395710B2E36800190E3B /* JackServerGlobals.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BC2168D0A444BED00BDA09F /* JackServerGlobals.h */; };
+@@ -663,7 +635,6 @@
+ 		4BA3396D10B2E36800190E3B /* JackMidiDriver.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BF339200F8B873E0080FB5B /* JackMidiDriver.h */; };
+ 		4BA3396E10B2E36800190E3B /* JackWaitThreadedDriver.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BBC93B90DF9736C002DF220 /* JackWaitThreadedDriver.h */; };
+ 		4BA3396F10B2E36800190E3B /* JackArgParser.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BF284170F31B4BC00B05BE3 /* JackArgParser.h */; };
+-		4BA3397210B2E36800190E3B /* JackMachPort.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B799AD607899652003F3F15 /* JackMachPort.cpp */; };
+ 		4BA3397310B2E36800190E3B /* JackShmMem.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BF8D1880834EE7900C94B91 /* JackShmMem.cpp */; };
+ 		4BA3397410B2E36800190E3B /* shm.c in Sources */ = {isa = PBXBuildFile; fileRef = 4BF8D1900834EE8400C94B91 /* shm.c */; };
+ 		4BA3397510B2E36800190E3B /* JackActivationCount.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BF8D1A80834EEB400C94B91 /* JackActivationCount.cpp */; };
+@@ -685,12 +656,7 @@
+ 		4BA3398510B2E36800190E3B /* JackEngine.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BF8D2140834F02800C94B91 /* JackEngine.cpp */; };
+ 		4BA3398610B2E36800190E3B /* JackExternalClient.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BF8D1F80834EFBD00C94B91 /* JackExternalClient.cpp */; };
+ 		4BA3398710B2E36800190E3B /* JackInternalClient.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BF8D1ED0834EF9200C94B91 /* JackInternalClient.cpp */; };
+-		4BA3398810B2E36800190E3B /* JackRPCClientUser.c in Sources */ = {isa = PBXBuildFile; fileRef = 4B89B759076B731100D170DE /* JackRPCClientUser.c */; };
+ 		4BA3398910B2E36800190E3B /* JackServer.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BF8D2210834F05C00C94B91 /* JackServer.cpp */; };
+-		4BA3398A10B2E36800190E3B /* JackMacEngineRPC.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B4259E5076B635E00C1ECE1 /* JackMacEngineRPC.cpp */; };
+-		4BA3398B10B2E36800190E3B /* JackMachNotifyChannel.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BFB298808AF450200D450D4 /* JackMachNotifyChannel.cpp */; };
+-		4BA3398C10B2E36800190E3B /* JackMachServerChannel.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BFB297908AF44ED00D450D4 /* JackMachServerChannel.cpp */; };
+-		4BA3398D10B2E36800190E3B /* JackMachServerNotifyChannel.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BFB297708AF44ED00D450D4 /* JackMachServerNotifyChannel.cpp */; };
+ 		4BA3398E10B2E36800190E3B /* JackTransportEngine.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BD4B4D509BACD9600750C0F /* JackTransportEngine.cpp */; };
+ 		4BA3398F10B2E36800190E3B /* JackServerAPI.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BF8D1F50834EFB000C94B91 /* JackServerAPI.cpp */; };
+ 		4BA3399010B2E36800190E3B /* JackServerGlobals.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BC216880A444BDE00BDA09F /* JackServerGlobals.cpp */; };
+@@ -1146,6 +1112,13 @@
+ 			remoteGlobalIDString = 4B5A1BD00CD1CCE10005BF74;
+ 			remoteInfo = jack_midisine;
+ 		};
++		4B66550D127C356E00753A79 /* PBXContainerItemProxy */ = {
++			isa = PBXContainerItemProxy;
++			containerPortal = 08FB7793FE84155DC02AAC07 /* Project object */;
++			proxyType = 1;
++			remoteGlobalIDString = 4B6654ED127C34AE00753A79;
++			remoteInfo = "jack_server_control 64 bits";
++		};
+ 		4B699DB3097D421700A18468 /* PBXContainerItemProxy */ = {
+ 			isa = PBXContainerItemProxy;
+ 			containerPortal = 08FB7793FE84155DC02AAC07 /* Project object */;
+@@ -1497,7 +1470,6 @@
+ 		4B37C20406DF1FBE0016E567 /* CALatencyLog.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; name = CALatencyLog.h; path = /Developer/Examples/CoreAudio/PublicUtility/CALatencyLog.h; sourceTree = "<absolute>"; };
+ 		4B37C20906DF1FE20016E567 /* latency.c */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.c; name = latency.c; path = /Developer/Examples/CoreAudio/PublicUtility/latency.c; sourceTree = "<absolute>"; };
+ 		4B3F49070AD8503300491C6E /* cpu.c */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.c; name = cpu.c; path = ../tests/cpu.c; sourceTree = SOURCE_ROOT; };
+-		4B4259E5076B635E00C1ECE1 /* JackMacEngineRPC.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = JackMacEngineRPC.cpp; sourceTree = SOURCE_ROOT; };
+ 		4B43A8BA10145F6F00E52943 /* jack_loopback.so */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.dylib"; includeInIndex = 0; path = jack_loopback.so; sourceTree = BUILT_PRODUCTS_DIR; };
+ 		4B43A8C81014605000E52943 /* JackLoopbackDriver.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = JackLoopbackDriver.cpp; path = ../common/JackLoopbackDriver.cpp; sourceTree = SOURCE_ROOT; };
+ 		4B43A8C91014605000E52943 /* JackLoopbackDriver.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = JackLoopbackDriver.h; path = ../common/JackLoopbackDriver.h; sourceTree = SOURCE_ROOT; };
+@@ -1520,6 +1492,8 @@
+ 		4B5E08E00E5B676C00BEE4E0 /* JackNetAdapter.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; name = JackNetAdapter.h; path = ../common/JackNetAdapter.h; sourceTree = SOURCE_ROOT; };
+ 		4B5F253D0DEE9B8F0041E486 /* JackLockedEngine.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = JackLockedEngine.h; path = ../common/JackLockedEngine.h; sourceTree = SOURCE_ROOT; };
+ 		4B60CE480AAABA31004956AA /* connect.c */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.c; name = connect.c; path = "../example-clients/connect.c"; sourceTree = SOURCE_ROOT; };
++		4B6654F7127C34AE00753A79 /* jack_server_control */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.executable"; includeInIndex = 0; path = jack_server_control; sourceTree = BUILT_PRODUCTS_DIR; };
++		4B6654FB127C350100753A79 /* server_control.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = server_control.cpp; path = "../example-clients/server_control.cpp"; sourceTree = SOURCE_ROOT; };
+ 		4B66A8580934964500A89560 /* JackConstants.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; name = JackConstants.h; path = ../common/JackConstants.h; sourceTree = SOURCE_ROOT; };
+ 		4B699BB1097D421600A18468 /* jackdmp */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.executable"; includeInIndex = 0; path = jackdmp; sourceTree = BUILT_PRODUCTS_DIR; };
+ 		4B699C47097D421600A18468 /* Jackmp.framework */ = {isa = PBXFileReference; explicitFileType = wrapper.framework; includeInIndex = 0; path = Jackmp.framework; sourceTree = BUILT_PRODUCTS_DIR; };
+@@ -1549,8 +1523,6 @@
+ 		4B6F7AEC0CD0CDBD00F48A9D /* JackEngineControl.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = JackEngineControl.cpp; path = ../common/JackEngineControl.cpp; sourceTree = SOURCE_ROOT; };
+ 		4B76C7680E5AB2DB00E2AC21 /* JackNetInterface.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = JackNetInterface.cpp; path = ../common/JackNetInterface.cpp; sourceTree = SOURCE_ROOT; };
+ 		4B76C7690E5AB2DB00E2AC21 /* JackNetInterface.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = JackNetInterface.h; path = ../common/JackNetInterface.h; sourceTree = SOURCE_ROOT; };
+-		4B799AD607899652003F3F15 /* JackMachPort.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = JackMachPort.cpp; sourceTree = "<group>"; };
+-		4B799AD707899652003F3F15 /* JackMachPort.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = JackMachPort.h; sourceTree = "<group>"; };
+ 		4B80D7E50BA0D17400F035BB /* JackMidiPort.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; name = JackMidiPort.h; path = ../common/JackMidiPort.h; sourceTree = SOURCE_ROOT; };
+ 		4B80D7E60BA0D17400F035BB /* JackMidiPort.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = JackMidiPort.cpp; path = ../common/JackMidiPort.cpp; sourceTree = SOURCE_ROOT; };
+ 		4B80D7E70BA0D17400F035BB /* JackMidiAPI.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = JackMidiAPI.cpp; path = ../common/JackMidiAPI.cpp; sourceTree = SOURCE_ROOT; };
+@@ -1559,8 +1531,6 @@
+ 		4B869D7F08C9CB00001CF041 /* JackDriverLoader.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = JackDriverLoader.cpp; path = ../common/JackDriverLoader.cpp; sourceTree = SOURCE_ROOT; };
+ 		4B88D03911298BEE007A87C1 /* weakjack.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = weakjack.h; path = ../common/jack/weakjack.h; sourceTree = SOURCE_ROOT; };
+ 		4B88D03A11298BEE007A87C1 /* weakmacros.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = weakmacros.h; path = ../common/jack/weakmacros.h; sourceTree = SOURCE_ROOT; };
+-		4B89B759076B731100D170DE /* JackRPCClientUser.c */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.c; name = JackRPCClientUser.c; path = RPC/JackRPCClientUser.c; sourceTree = SOURCE_ROOT; };
+-		4B89B769076B74D200D170DE /* JackRPCEngineUser.c */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.c; name = JackRPCEngineUser.c; path = RPC/JackRPCEngineUser.c; sourceTree = SOURCE_ROOT; };
+ 		4B940B9B06DDDE5B00D77F60 /* AudioHardware.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; name = AudioHardware.h; path = /System/Library/Frameworks/CoreAudio.framework/Versions/A/Headers/AudioHardware.h; sourceTree = "<absolute>"; };
+ 		4B94334910A5E666002A187F /* systemdeps.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = systemdeps.h; path = ../common/jack/systemdeps.h; sourceTree = SOURCE_ROOT; };
+ 		4B95BCAD0D913073000F7695 /* control.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = control.h; path = ../common/jack/control.h; sourceTree = SOURCE_ROOT; };
+@@ -1645,7 +1615,6 @@
+ 		4BF339150F8B86DC0080FB5B /* JackCoreMidiDriver.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = JackCoreMidiDriver.cpp; path = coremidi/JackCoreMidiDriver.cpp; sourceTree = SOURCE_ROOT; };
+ 		4BF3391F0F8B873E0080FB5B /* JackMidiDriver.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = JackMidiDriver.cpp; path = ../common/JackMidiDriver.cpp; sourceTree = SOURCE_ROOT; };
+ 		4BF339200F8B873E0080FB5B /* JackMidiDriver.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = JackMidiDriver.h; path = ../common/JackMidiDriver.h; sourceTree = SOURCE_ROOT; };
+-		4BF3937C0626BF3600CC67FA /* JackMacLibClientRPC.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = JackMacLibClientRPC.cpp; sourceTree = SOURCE_ROOT; };
+ 		4BF4BAB00E3480AB00403CDF /* JackAudioAdapterFactory.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = JackAudioAdapterFactory.cpp; path = ../common/JackAudioAdapterFactory.cpp; sourceTree = SOURCE_ROOT; };
+ 		4BF520520CB8D0E80037470E /* timestamps.c */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.c; name = timestamps.c; path = ../common/timestamps.c; sourceTree = SOURCE_ROOT; };
+ 		4BF520580CB8D1010037470E /* timestamps.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; name = timestamps.h; path = ../common/timestamps.h; sourceTree = SOURCE_ROOT; };
+@@ -1718,14 +1687,6 @@
+ 		4BFA82CF0DF6A9E40087B4E1 /* jack_impulse_grabber */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.executable"; includeInIndex = 0; path = jack_impulse_grabber; sourceTree = BUILT_PRODUCTS_DIR; };
+ 		4BFA99A20AAAF3B0009E916C /* jdelay */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.executable"; includeInIndex = 0; path = jdelay; sourceTree = BUILT_PRODUCTS_DIR; };
+ 		4BFA99A90AAAF40C009E916C /* jdelay.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = jdelay.cpp; path = ../tests/jdelay.cpp; sourceTree = SOURCE_ROOT; };
+-		4BFB297708AF44ED00D450D4 /* JackMachServerNotifyChannel.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = JackMachServerNotifyChannel.cpp; sourceTree = "<group>"; };
+-		4BFB297808AF44ED00D450D4 /* JackMachServerChannel.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = JackMachServerChannel.h; sourceTree = "<group>"; };
+-		4BFB297908AF44ED00D450D4 /* JackMachServerChannel.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = JackMachServerChannel.cpp; sourceTree = "<group>"; };
+-		4BFB297A08AF44ED00D450D4 /* JackMachServerNotifyChannel.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = JackMachServerNotifyChannel.h; sourceTree = "<group>"; };
+-		4BFB298708AF450200D450D4 /* JackMachClientChannel.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = JackMachClientChannel.h; sourceTree = "<group>"; };
+-		4BFB298808AF450200D450D4 /* JackMachNotifyChannel.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = JackMachNotifyChannel.cpp; sourceTree = "<group>"; };
+-		4BFB298908AF450200D450D4 /* JackMachNotifyChannel.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = JackMachNotifyChannel.h; sourceTree = "<group>"; };
+-		4BFB29AE08AF45FD00D450D4 /* JackMachClientChannel.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = JackMachClientChannel.cpp; sourceTree = SOURCE_ROOT; };
+ 		4BFB73F608AD291A00DB99B8 /* JackGlobals.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; name = JackGlobals.h; path = ../common/JackGlobals.h; sourceTree = SOURCE_ROOT; };
+ 		4BFB741E08AD2B9900DB99B8 /* JackMachThread.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = JackMachThread.cpp; sourceTree = SOURCE_ROOT; };
+ 		4BFB741F08AD2B9900DB99B8 /* JackMachThread.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = JackMachThread.h; sourceTree = SOURCE_ROOT; };
+@@ -2072,6 +2033,13 @@
+ 			);
+ 			runOnlyForDeploymentPostprocessing = 0;
+ 		};
++		4B6654F1127C34AE00753A79 /* Frameworks */ = {
++			isa = PBXFrameworksBuildPhase;
++			buildActionMask = 2147483647;
++			files = (
++			);
++			runOnlyForDeploymentPostprocessing = 0;
++		};
+ 		4B699BAB097D421600A18468 /* Frameworks */ = {
+ 			isa = PBXFrameworksBuildPhase;
+ 			buildActionMask = 2147483647;
+@@ -2499,6 +2467,7 @@
+ 				4B32257B10A3190C00838A8E /* jack_netsource */,
+ 				4BA339AC10B2E36800190E3B /* Jackservermp.framework */,
+ 				4B47ACD710B5890100469C67 /* Jackmp.framework */,
++				4B6654F7127C34AE00753A79 /* jack_server_control */,
+ 			);
+ 			name = Products;
+ 			sourceTree = "<group>";
+@@ -2506,6 +2475,7 @@
+ 		4B03383E0797E19900686131 /* Simple clients */ = {
+ 			isa = PBXGroup;
+ 			children = (
++				4B6654FB127C350100753A79 /* server_control.cpp */,
+ 				4B363F750DEB0D7D001F72D9 /* impulse_grabber.c */,
+ 				4B363F220DEB0AB0001F72D9 /* monitor_client.c */,
+ 				4B363EED0DEB094B001F72D9 /* capture_client.c */,
+@@ -2627,24 +2597,6 @@
+ 			name = Additional;
+ 			sourceTree = "<group>";
+ 		};
+-		4B168CA3076A5319005B2802 /* MIG_RPC */ = {
+-			isa = PBXGroup;
+-			children = (
+-				4B89B759076B731100D170DE /* JackRPCClientUser.c */,
+-				4B4259E5076B635E00C1ECE1 /* JackMacEngineRPC.cpp */,
+-			);
+-			name = MIG_RPC;
+-			sourceTree = "<group>";
+-		};
+-		4B168CA4076A5333005B2802 /* MIG_RPC */ = {
+-			isa = PBXGroup;
+-			children = (
+-				4B89B769076B74D200D170DE /* JackRPCEngineUser.c */,
+-				4BF3937C0626BF3600CC67FA /* JackMacLibClientRPC.cpp */,
+-			);
+-			name = MIG_RPC;
+-			sourceTree = "<group>";
+-		};
+ 		4B19B3010E23629800DD4A82 /* Adapter */ = {
+ 			isa = PBXGroup;
+ 			children = (
+@@ -2818,7 +2770,6 @@
+ 		4BA550F905E241D900569492 /* Library */ = {
+ 			isa = PBXGroup;
+ 			children = (
+-				4B168CA4076A5333005B2802 /* MIG_RPC */,
+ 				4BF8D1FB0834EFD100C94B91 /* JackLibGlobals.h */,
+ 				4BF8D1FC0834EFD100C94B91 /* JackLibClient.h */,
+ 				4BF8D1FD0834EFD100C94B91 /* JackLibClient.cpp */,
+@@ -2844,7 +2795,6 @@
+ 		4BA550FB05E2420000569492 /* Engine */ = {
+ 			isa = PBXGroup;
+ 			children = (
+-				4B168CA3076A5319005B2802 /* MIG_RPC */,
+ 				4B5F253D0DEE9B8F0041E486 /* JackLockedEngine.h */,
+ 				4BF8D2130834F02800C94B91 /* JackEngine.h */,
+ 				4BF8D2140834F02800C94B91 /* JackEngine.cpp */,
+@@ -2872,7 +2822,6 @@
+ 				4BB371D40C1AD85A0050C1E4 /* JackNotification.h */,
+ 				4BF8D1B30834EED500C94B91 /* JackInternalClientChannel.h */,
+ 				4BFB299908AF452300D450D4 /* Socket */,
+-				4BFB299808AF451200D450D4 /* Mach */,
+ 			);
+ 			name = Channels;
+ 			sourceTree = "<group>";
+@@ -2963,23 +2912,6 @@
+ 			name = MIDI;
+ 			sourceTree = "<group>";
+ 		};
+-		4BFB299808AF451200D450D4 /* Mach */ = {
+-			isa = PBXGroup;
+-			children = (
+-				4B799AD707899652003F3F15 /* JackMachPort.h */,
+-				4B799AD607899652003F3F15 /* JackMachPort.cpp */,
+-				4BFB298708AF450200D450D4 /* JackMachClientChannel.h */,
+-				4BFB29AE08AF45FD00D450D4 /* JackMachClientChannel.cpp */,
+-				4BFB297808AF44ED00D450D4 /* JackMachServerChannel.h */,
+-				4BFB297908AF44ED00D450D4 /* JackMachServerChannel.cpp */,
+-				4BFB297A08AF44ED00D450D4 /* JackMachServerNotifyChannel.h */,
+-				4BFB297708AF44ED00D450D4 /* JackMachServerNotifyChannel.cpp */,
+-				4BFB298908AF450200D450D4 /* JackMachNotifyChannel.h */,
+-				4BFB298808AF450200D450D4 /* JackMachNotifyChannel.cpp */,
+-			);
+-			name = Mach;
+-			sourceTree = "<group>";
+-		};
+ 		4BFB299908AF452300D450D4 /* Socket */ = {
+ 			isa = PBXGroup;
+ 			children = (
+@@ -3110,7 +3042,6 @@
+ 			isa = PBXHeadersBuildPhase;
+ 			buildActionMask = 2147483647;
+ 			files = (
+-				4B35C4290D4731D1000DE7AE /* JackMachPort.h in Headers */,
+ 				4B35C42A0D4731D1000DE7AE /* JackError.h in Headers */,
+ 				4B35C42B0D4731D1000DE7AE /* JackTime.h in Headers */,
+ 				4B35C42C0D4731D1000DE7AE /* JackShmMem.h in Headers */,
+@@ -3131,7 +3062,6 @@
+ 				4B35C43D0D4731D1000DE7AE /* JackMachSemaphore.h in Headers */,
+ 				4B35C43E0D4731D1000DE7AE /* JackGlobals.h in Headers */,
+ 				4B35C43F0D4731D1000DE7AE /* JackMachThread.h in Headers */,
+-				4B35C4400D4731D1000DE7AE /* JackMachClientChannel.h in Headers */,
+ 				4B35C4460D4731D1000DE7AE /* JackSynchro.h in Headers */,
+ 				4B35C4470D4731D1000DE7AE /* JackDebugClient.h in Headers */,
+ 				4B35C4480D4731D1000DE7AE /* JackConstants.h in Headers */,
+@@ -3154,6 +3084,8 @@
+ 				4BECB2FA0F4451C10091B70A /* JackProcessSync.h in Headers */,
+ 				4B88D03F11298BEE007A87C1 /* weakjack.h in Headers */,
+ 				4B88D04011298BEE007A87C1 /* weakmacros.h in Headers */,
++				4B8A38F0117B827900664E07 /* JackSocket.h in Headers */,
++				4B8A38F7117B82B200664E07 /* JackSocketClientChannel.h in Headers */,
+ 			);
+ 			runOnlyForDeploymentPostprocessing = 0;
+ 		};
+@@ -3161,7 +3093,6 @@
+ 			isa = PBXHeadersBuildPhase;
+ 			buildActionMask = 2147483647;
+ 			files = (
+-				4B35C4870D4731D1000DE7AE /* JackMachPort.h in Headers */,
+ 				4B35C4880D4731D1000DE7AE /* JackError.h in Headers */,
+ 				4B35C4890D4731D1000DE7AE /* JackTime.h in Headers */,
+ 				4B35C48A0D4731D1000DE7AE /* JackShmMem.h in Headers */,
+@@ -3190,9 +3121,6 @@
+ 				4B35C4A90D4731D1000DE7AE /* JackEngine.h in Headers */,
+ 				4B35C4AA0D4731D1000DE7AE /* JackExternalClient.h in Headers */,
+ 				4B35C4AB0D4731D1000DE7AE /* JackServer.h in Headers */,
+-				4B35C4AE0D4731D1000DE7AE /* JackMachNotifyChannel.h in Headers */,
+-				4B35C4AF0D4731D1000DE7AE /* JackMachServerChannel.h in Headers */,
+-				4B35C4B00D4731D1000DE7AE /* JackMachServerNotifyChannel.h in Headers */,
+ 				4B35C4B20D4731D1000DE7AE /* JackConstants.h in Headers */,
+ 				4B35C4B30D4731D1000DE7AE /* JackTransportEngine.h in Headers */,
+ 				4B35C4B40D4731D1000DE7AE /* JackServerGlobals.h in Headers */,
+@@ -3226,6 +3154,10 @@
+ 				4B88D04411298BEE007A87C1 /* weakmacros.h in Headers */,
+ 				4BC2CA5A113C6CB80076717C /* JackNetInterface.h in Headers */,
+ 				4BC2CA5C113C6CC00076717C /* JackNetUnixSocket.h in Headers */,
++				4B8A38A8117B80DA00664E07 /* JackSocket.h in Headers */,
++				4B8A38AD117B810A00664E07 /* JackSocketNotifyChannel.h in Headers */,
++				4B8A38B0117B812500664E07 /* JackSocketServerChannel.h in Headers */,
++				4B8A38C4117B814000664E07 /* JackSocketServerNotifyChannel.h in Headers */,
+ 			);
+ 			runOnlyForDeploymentPostprocessing = 0;
+ 		};
+@@ -3464,7 +3396,6 @@
+ 			isa = PBXHeadersBuildPhase;
+ 			buildActionMask = 2147483647;
+ 			files = (
+-				4B47AC8210B5890100469C67 /* JackMachPort.h in Headers */,
+ 				4B47AC8310B5890100469C67 /* JackError.h in Headers */,
+ 				4B47AC8410B5890100469C67 /* JackTime.h in Headers */,
+ 				4B47AC8510B5890100469C67 /* JackShmMem.h in Headers */,
+@@ -3485,7 +3416,6 @@
+ 				4B47AC9410B5890100469C67 /* JackMachSemaphore.h in Headers */,
+ 				4B47AC9510B5890100469C67 /* JackGlobals.h in Headers */,
+ 				4B47AC9610B5890100469C67 /* JackMachThread.h in Headers */,
+-				4B47AC9710B5890100469C67 /* JackMachClientChannel.h in Headers */,
+ 				4B47AC9810B5890100469C67 /* JackSynchro.h in Headers */,
+ 				4B47AC9910B5890100469C67 /* JackDebugClient.h in Headers */,
+ 				4B47AC9A10B5890100469C67 /* JackConstants.h in Headers */,
+@@ -3536,6 +3466,13 @@
+ 			);
+ 			runOnlyForDeploymentPostprocessing = 0;
+ 		};
++		4B6654EE127C34AE00753A79 /* Headers */ = {
++			isa = PBXHeadersBuildPhase;
++			buildActionMask = 2147483647;
++			files = (
++			);
++			runOnlyForDeploymentPostprocessing = 0;
++		};
+ 		4B699BA8097D421600A18468 /* Headers */ = {
+ 			isa = PBXHeadersBuildPhase;
+ 			buildActionMask = 2147483647;
+@@ -3547,7 +3484,6 @@
+ 			isa = PBXHeadersBuildPhase;
+ 			buildActionMask = 2147483647;
+ 			files = (
+-				4B699C02097D421600A18468 /* JackMachPort.h in Headers */,
+ 				4B699C03097D421600A18468 /* JackError.h in Headers */,
+ 				4B699C04097D421600A18468 /* JackTime.h in Headers */,
+ 				4B699C05097D421600A18468 /* JackShmMem.h in Headers */,
+@@ -3568,7 +3504,6 @@
+ 				4B699C16097D421600A18468 /* JackMachSemaphore.h in Headers */,
+ 				4B699C17097D421600A18468 /* JackGlobals.h in Headers */,
+ 				4B699C18097D421600A18468 /* JackMachThread.h in Headers */,
+-				4B699C19097D421600A18468 /* JackMachClientChannel.h in Headers */,
+ 				4B699C20097D421600A18468 /* JackSynchro.h in Headers */,
+ 				4B699C21097D421600A18468 /* JackDebugClient.h in Headers */,
+ 				4B699C22097D421600A18468 /* JackConstants.h in Headers */,
+@@ -3599,7 +3534,6 @@
+ 			isa = PBXHeadersBuildPhase;
+ 			buildActionMask = 2147483647;
+ 			files = (
+-				4B699C4E097D421600A18468 /* JackMachPort.h in Headers */,
+ 				4B699C4F097D421600A18468 /* JackError.h in Headers */,
+ 				4B699C50097D421600A18468 /* JackTime.h in Headers */,
+ 				4B699C51097D421600A18468 /* JackShmMem.h in Headers */,
+@@ -3628,9 +3562,6 @@
+ 				4B699C71097D421600A18468 /* JackEngine.h in Headers */,
+ 				4B699C73097D421600A18468 /* JackExternalClient.h in Headers */,
+ 				4B699C74097D421600A18468 /* JackServer.h in Headers */,
+-				4B699C77097D421600A18468 /* JackMachNotifyChannel.h in Headers */,
+-				4B699C78097D421600A18468 /* JackMachServerChannel.h in Headers */,
+-				4B699C79097D421600A18468 /* JackMachServerNotifyChannel.h in Headers */,
+ 				4B699C7B097D421600A18468 /* JackConstants.h in Headers */,
+ 				4BD4B4D809BACD9600750C0F /* JackTransportEngine.h in Headers */,
+ 				4BC2168E0A444BED00BDA09F /* JackServerGlobals.h in Headers */,
+@@ -3784,7 +3715,6 @@
+ 			isa = PBXHeadersBuildPhase;
+ 			buildActionMask = 2147483647;
+ 			files = (
+-				4BA3393510B2E36800190E3B /* JackMachPort.h in Headers */,
+ 				4BA3393610B2E36800190E3B /* JackError.h in Headers */,
+ 				4BA3393710B2E36800190E3B /* JackTime.h in Headers */,
+ 				4BA3393810B2E36800190E3B /* JackShmMem.h in Headers */,
+@@ -3813,9 +3743,6 @@
+ 				4BA3394F10B2E36800190E3B /* JackEngine.h in Headers */,
+ 				4BA3395010B2E36800190E3B /* JackExternalClient.h in Headers */,
+ 				4BA3395110B2E36800190E3B /* JackServer.h in Headers */,
+-				4BA3395210B2E36800190E3B /* JackMachNotifyChannel.h in Headers */,
+-				4BA3395310B2E36800190E3B /* JackMachServerChannel.h in Headers */,
+-				4BA3395410B2E36800190E3B /* JackMachServerNotifyChannel.h in Headers */,
+ 				4BA3395510B2E36800190E3B /* JackConstants.h in Headers */,
+ 				4BA3395610B2E36800190E3B /* JackTransportEngine.h in Headers */,
+ 				4BA3395710B2E36800190E3B /* JackServerGlobals.h in Headers */,
+@@ -4878,6 +4805,25 @@
+ 			productReference = 4B5E08D50E5B66EE00BEE4E0 /* netadapter.so */;
+ 			productType = "com.apple.product-type.library.dynamic";
+ 		};
++		4B6654ED127C34AE00753A79 /* jack_server_control 64 bits */ = {
++			isa = PBXNativeTarget;
++			buildConfigurationList = 4B6654F3127C34AE00753A79 /* Build configuration list for PBXNativeTarget "jack_server_control 64 bits" */;
++			buildPhases = (
++				4B6654EE127C34AE00753A79 /* Headers */,
++				4B6654EF127C34AE00753A79 /* Sources */,
++				4B6654F1127C34AE00753A79 /* Frameworks */,
++				4B6654F2127C34AE00753A79 /* Rez */,
++			);
++			buildRules = (
++			);
++			dependencies = (
++			);
++			name = "jack_server_control 64 bits";
++			productInstallPath = /usr/local/bin;
++			productName = testSem;
++			productReference = 4B6654F7127C34AE00753A79 /* jack_server_control */;
++			productType = "com.apple.product-type.tool";
++		};
+ 		4B699BA7097D421600A18468 /* jackdmp framework Universal */ = {
+ 			isa = PBXNativeTarget;
+ 			buildConfigurationList = 4B699BAD097D421600A18468 /* Build configuration list for PBXNativeTarget "jackdmp framework Universal" */;
+@@ -5642,6 +5588,7 @@
+ 			isa = PBXProject;
+ 			buildConfigurationList = 4B699DD5097D427F00A18468 /* Build configuration list for PBXProject "Jackdmp" */;
+ 			compatibilityVersion = "Xcode 2.4";
++			developmentRegion = English;
+ 			hasScannedForEncodings = 1;
+ 			knownRegions = (
+ 				English,
+@@ -5728,6 +5675,7 @@
+ 				4BFA82B90DF6A9E40087B4E1 /* jack_showtime 64 bits */,
+ 				4BFA82C50DF6A9E40087B4E1 /* jack_impulse_grabber 64 bits */,
+ 				4B32257110A3190C00838A8E /* jack_netsource 64 bits */,
++				4B6654ED127C34AE00753A79 /* jack_server_control 64 bits */,
+ 				4B35C5D80D4731D2000DE7AE /* synchroServer 64 bits */,
+ 				4B35C5EC0D4731D2000DE7AE /* synchroClient 64 bits */,
+ 				4B35C6000D4731D2000DE7AE /* synchroServerClient 64 bits */,
+@@ -6044,6 +5992,13 @@
+ 			);
+ 			runOnlyForDeploymentPostprocessing = 0;
+ 		};
++		4B6654F2127C34AE00753A79 /* Rez */ = {
++			isa = PBXRezBuildPhase;
++			buildActionMask = 2147483647;
++			files = (
++			);
++			runOnlyForDeploymentPostprocessing = 0;
++		};
+ 		4B699BAC097D421600A18468 /* Rez */ = {
+ 			isa = PBXRezBuildPhase;
+ 			buildActionMask = 2147483647;
+@@ -6331,9 +6286,6 @@
+ 			isa = PBXSourcesBuildPhase;
+ 			buildActionMask = 2147483647;
+ 			files = (
+-				4B35C4580D4731D1000DE7AE /* JackMacLibClientRPC.cpp in Sources */,
+-				4B35C4590D4731D1000DE7AE /* JackRPCEngineUser.c in Sources */,
+-				4B35C45A0D4731D1000DE7AE /* JackMachPort.cpp in Sources */,
+ 				4B35C45B0D4731D1000DE7AE /* JackShmMem.cpp in Sources */,
+ 				4B35C45C0D4731D1000DE7AE /* shm.c in Sources */,
+ 				4B35C45E0D4731D1000DE7AE /* JackActivationCount.cpp in Sources */,
+@@ -6347,7 +6299,6 @@
+ 				4B35C4660D4731D1000DE7AE /* JackFrameTimer.cpp in Sources */,
+ 				4B35C4680D4731D1000DE7AE /* JackMachSemaphore.cpp in Sources */,
+ 				4B35C4690D4731D1000DE7AE /* JackMachThread.cpp in Sources */,
+-				4B35C46A0D4731D1000DE7AE /* JackMachClientChannel.cpp in Sources */,
+ 				4B35C4700D4731D1000DE7AE /* JackGlobals.cpp in Sources */,
+ 				4B35C4720D4731D1000DE7AE /* ringbuffer.c in Sources */,
+ 				4B35C4730D4731D1000DE7AE /* JackDebugClient.cpp in Sources */,
+@@ -6365,6 +6316,8 @@
+ 				4B93F19D0E87998400E4ECCD /* JackPosixThread.cpp in Sources */,
+ 				4B93F1C00E87A35400E4ECCD /* JackMachTime.c in Sources */,
+ 				4BECB2F90F4451C10091B70A /* JackProcessSync.cpp in Sources */,
++				4B8A38F1117B827E00664E07 /* JackSocketClientChannel.cpp in Sources */,
++				4B8A38F6117B82AB00664E07 /* JackSocket.cpp in Sources */,
+ 			);
+ 			runOnlyForDeploymentPostprocessing = 0;
+ 		};
+@@ -6372,7 +6325,6 @@
+ 			isa = PBXSourcesBuildPhase;
+ 			buildActionMask = 2147483647;
+ 			files = (
+-				4B35C4C40D4731D1000DE7AE /* JackMachPort.cpp in Sources */,
+ 				4B35C4C50D4731D1000DE7AE /* JackShmMem.cpp in Sources */,
+ 				4B35C4C60D4731D1000DE7AE /* shm.c in Sources */,
+ 				4B35C4C80D4731D1000DE7AE /* JackActivationCount.cpp in Sources */,
+@@ -6394,12 +6346,7 @@
+ 				4B35C4DD0D4731D1000DE7AE /* JackEngine.cpp in Sources */,
+ 				4B35C4DE0D4731D1000DE7AE /* JackExternalClient.cpp in Sources */,
+ 				4B35C4DF0D4731D1000DE7AE /* JackInternalClient.cpp in Sources */,
+-				4B35C4E00D4731D1000DE7AE /* JackRPCClientUser.c in Sources */,
+ 				4B35C4E20D4731D1000DE7AE /* JackServer.cpp in Sources */,
+-				4B35C4E60D4731D1000DE7AE /* JackMacEngineRPC.cpp in Sources */,
+-				4B35C4E70D4731D1000DE7AE /* JackMachNotifyChannel.cpp in Sources */,
+-				4B35C4E80D4731D1000DE7AE /* JackMachServerChannel.cpp in Sources */,
+-				4B35C4E90D4731D1000DE7AE /* JackMachServerNotifyChannel.cpp in Sources */,
+ 				4B35C4EB0D4731D1000DE7AE /* JackTransportEngine.cpp in Sources */,
+ 				4B35C4EC0D4731D1000DE7AE /* JackServerAPI.cpp in Sources */,
+ 				4B35C4ED0D4731D1000DE7AE /* JackServerGlobals.cpp in Sources */,
+@@ -6427,6 +6374,10 @@
+ 				4BCBCE6310C4FE3F00450FFE /* JackPhysicalMidiOutput.cpp in Sources */,
+ 				4BC2CA59113C6CB60076717C /* JackNetInterface.cpp in Sources */,
+ 				4BC2CA5B113C6CBE0076717C /* JackNetUnixSocket.cpp in Sources */,
++				4B8A38A7117B80D300664E07 /* JackSocket.cpp in Sources */,
++				4B8A38AE117B811100664E07 /* JackSocketNotifyChannel.cpp in Sources */,
++				4B8A38B1117B812D00664E07 /* JackSocketServerChannel.cpp in Sources */,
++				4B8A38B2117B813400664E07 /* JackSocketServerNotifyChannel.cpp in Sources */,
+ 			);
+ 			runOnlyForDeploymentPostprocessing = 0;
+ 		};
+@@ -6692,9 +6643,6 @@
+ 			isa = PBXSourcesBuildPhase;
+ 			buildActionMask = 2147483647;
+ 			files = (
+-				4B47ACAE10B5890100469C67 /* JackMacLibClientRPC.cpp in Sources */,
+-				4B47ACAF10B5890100469C67 /* JackRPCEngineUser.c in Sources */,
+-				4B47ACB010B5890100469C67 /* JackMachPort.cpp in Sources */,
+ 				4B47ACB110B5890100469C67 /* JackShmMem.cpp in Sources */,
+ 				4B47ACB210B5890100469C67 /* shm.c in Sources */,
+ 				4B47ACB310B5890100469C67 /* JackActivationCount.cpp in Sources */,
+@@ -6708,7 +6656,6 @@
+ 				4B47ACBB10B5890100469C67 /* JackFrameTimer.cpp in Sources */,
+ 				4B47ACBC10B5890100469C67 /* JackMachSemaphore.cpp in Sources */,
+ 				4B47ACBD10B5890100469C67 /* JackMachThread.cpp in Sources */,
+-				4B47ACBE10B5890100469C67 /* JackMachClientChannel.cpp in Sources */,
+ 				4B47ACBF10B5890100469C67 /* JackGlobals.cpp in Sources */,
+ 				4B47ACC010B5890100469C67 /* ringbuffer.c in Sources */,
+ 				4B47ACC110B5890100469C67 /* JackDebugClient.cpp in Sources */,
+@@ -6757,6 +6704,14 @@
+ 			);
+ 			runOnlyForDeploymentPostprocessing = 0;
+ 		};
++		4B6654EF127C34AE00753A79 /* Sources */ = {
++			isa = PBXSourcesBuildPhase;
++			buildActionMask = 2147483647;
++			files = (
++				4B6654FC127C350100753A79 /* server_control.cpp in Sources */,
++			);
++			runOnlyForDeploymentPostprocessing = 0;
++		};
+ 		4B699BA9097D421600A18468 /* Sources */ = {
+ 			isa = PBXSourcesBuildPhase;
+ 			buildActionMask = 2147483647;
+@@ -6769,9 +6724,6 @@
+ 			isa = PBXSourcesBuildPhase;
+ 			buildActionMask = 2147483647;
+ 			files = (
+-				4B699C25097D421600A18468 /* JackMacLibClientRPC.cpp in Sources */,
+-				4B699C26097D421600A18468 /* JackRPCEngineUser.c in Sources */,
+-				4B699C27097D421600A18468 /* JackMachPort.cpp in Sources */,
+ 				4B699C28097D421600A18468 /* JackShmMem.cpp in Sources */,
+ 				4B699C29097D421600A18468 /* shm.c in Sources */,
+ 				4B699C2B097D421600A18468 /* JackActivationCount.cpp in Sources */,
+@@ -6785,7 +6737,6 @@
+ 				4B699C33097D421600A18468 /* JackFrameTimer.cpp in Sources */,
+ 				4B699C35097D421600A18468 /* JackMachSemaphore.cpp in Sources */,
+ 				4B699C36097D421600A18468 /* JackMachThread.cpp in Sources */,
+-				4B699C37097D421600A18468 /* JackMachClientChannel.cpp in Sources */,
+ 				4B699C3D097D421600A18468 /* JackGlobals.cpp in Sources */,
+ 				4B699C3F097D421600A18468 /* ringbuffer.c in Sources */,
+ 				4B699C40097D421600A18468 /* JackDebugClient.cpp in Sources */,
+@@ -6810,7 +6761,6 @@
+ 			isa = PBXSourcesBuildPhase;
+ 			buildActionMask = 2147483647;
+ 			files = (
+-				4B699C7E097D421600A18468 /* JackMachPort.cpp in Sources */,
+ 				4B699C7F097D421600A18468 /* JackShmMem.cpp in Sources */,
+ 				4B699C80097D421600A18468 /* shm.c in Sources */,
+ 				4B699C82097D421600A18468 /* JackActivationCount.cpp in Sources */,
+@@ -6832,12 +6782,7 @@
+ 				4B699C97097D421600A18468 /* JackEngine.cpp in Sources */,
+ 				4B699C99097D421600A18468 /* JackExternalClient.cpp in Sources */,
+ 				4B699C9A097D421600A18468 /* JackInternalClient.cpp in Sources */,
+-				4B699C9B097D421600A18468 /* JackRPCClientUser.c in Sources */,
+ 				4B699C9D097D421600A18468 /* JackServer.cpp in Sources */,
+-				4B699CA1097D421600A18468 /* JackMacEngineRPC.cpp in Sources */,
+-				4B699CA2097D421600A18468 /* JackMachNotifyChannel.cpp in Sources */,
+-				4B699CA3097D421600A18468 /* JackMachServerChannel.cpp in Sources */,
+-				4B699CA4097D421600A18468 /* JackMachServerNotifyChannel.cpp in Sources */,
+ 				4BD4B4D909BACD9600750C0F /* JackTransportEngine.cpp in Sources */,
+ 				4BC216850A444BAD00BDA09F /* JackServerAPI.cpp in Sources */,
+ 				4BC216890A444BDE00BDA09F /* JackServerGlobals.cpp in Sources */,
+@@ -6992,7 +6937,6 @@
+ 			isa = PBXSourcesBuildPhase;
+ 			buildActionMask = 2147483647;
+ 			files = (
+-				4BA3397210B2E36800190E3B /* JackMachPort.cpp in Sources */,
+ 				4BA3397310B2E36800190E3B /* JackShmMem.cpp in Sources */,
+ 				4BA3397410B2E36800190E3B /* shm.c in Sources */,
+ 				4BA3397510B2E36800190E3B /* JackActivationCount.cpp in Sources */,
+@@ -7014,12 +6958,7 @@
+ 				4BA3398510B2E36800190E3B /* JackEngine.cpp in Sources */,
+ 				4BA3398610B2E36800190E3B /* JackExternalClient.cpp in Sources */,
+ 				4BA3398710B2E36800190E3B /* JackInternalClient.cpp in Sources */,
+-				4BA3398810B2E36800190E3B /* JackRPCClientUser.c in Sources */,
+ 				4BA3398910B2E36800190E3B /* JackServer.cpp in Sources */,
+-				4BA3398A10B2E36800190E3B /* JackMacEngineRPC.cpp in Sources */,
+-				4BA3398B10B2E36800190E3B /* JackMachNotifyChannel.cpp in Sources */,
+-				4BA3398C10B2E36800190E3B /* JackMachServerChannel.cpp in Sources */,
+-				4BA3398D10B2E36800190E3B /* JackMachServerNotifyChannel.cpp in Sources */,
+ 				4BA3398E10B2E36800190E3B /* JackTransportEngine.cpp in Sources */,
+ 				4BA3398F10B2E36800190E3B /* JackServerAPI.cpp in Sources */,
+ 				4BA3399010B2E36800190E3B /* JackServerGlobals.cpp in Sources */,
+@@ -7438,6 +7377,11 @@
+ 			target = 4B5A1BD00CD1CCE10005BF74 /* jack_midisine Universal */;
+ 			targetProxy = 4B5A1BE10CD1CD730005BF74 /* PBXContainerItemProxy */;
+ 		};
++		4B66550E127C356E00753A79 /* PBXTargetDependency */ = {
++			isa = PBXTargetDependency;
++			target = 4B6654ED127C34AE00753A79 /* jack_server_control 64 bits */;
++			targetProxy = 4B66550D127C356E00753A79 /* PBXContainerItemProxy */;
++		};
+ 		4B699DB4097D421700A18468 /* PBXTargetDependency */ = {
+ 			isa = PBXTargetDependency;
+ 			target = 4B699C4C097D421600A18468 /* Jackservermp.framework Universal */;
+@@ -8155,6 +8099,7 @@
+ 				MACOSX_DEPLOYMENT_TARGET = 10.4;
+ 				OTHER_CFLAGS = "-DJACK_32_64";
+ 				OTHER_CPLUSPLUSFLAGS = (
++					"-DSERVER_SIDE",
+ 					"-DHAVE_CELT",
+ 					"-DHAVE_CELT_API_0_7",
+ 					"-DMACH_RPC_MACH_SEMA",
+@@ -10913,6 +10858,7 @@
+ 				MACOSX_DEPLOYMENT_TARGET = 10.4;
+ 				OTHER_CFLAGS = "-DJACK_32_64";
+ 				OTHER_CPLUSPLUSFLAGS = (
++					"-DSERVER_SIDE",
+ 					"-DMACH_RPC_MACH_SEMA",
+ 					"-DJACK_32_64",
+ 				);
+@@ -11210,6 +11156,7 @@
+ 				MACOSX_DEPLOYMENT_TARGET = 10.4;
+ 				OTHER_CFLAGS = "-DJACK_32_64";
+ 				OTHER_CPLUSPLUSFLAGS = (
++					"-DSERVER_SIDE",
+ 					"-DMACH_RPC_MACH_SEMA",
+ 					"-DJACK_32_64",
+ 				);
+@@ -12374,6 +12321,7 @@
+ 				MACOSX_DEPLOYMENT_TARGET = 10.4;
+ 				OTHER_CFLAGS = "-DJACK_32_64";
+ 				OTHER_CPLUSPLUSFLAGS = (
++					"-DSERVER_SIDE",
+ 					"-DMACH_RPC_MACH_SEMA",
+ 					"-DJACK_32_64",
+ 				);
+@@ -12971,6 +12919,94 @@
+ 			};
+ 			name = Default;
+ 		};
++		4B6654F4127C34AE00753A79 /* Development */ = {
++			isa = XCBuildConfiguration;
++			buildSettings = {
++				ARCHS = "$(ARCHS_STANDARD_32_64_BIT_PRE_XCODE_3_1)";
++				ARCHS_STANDARD_32_64_BIT_PRE_XCODE_3_1 = "x86_64 i386 ppc";
++				COPY_PHASE_STRIP = NO;
++				GCC_DYNAMIC_NO_PIC = NO;
++				GCC_ENABLE_FIX_AND_CONTINUE = YES;
++				GCC_GENERATE_DEBUGGING_SYMBOLS = YES;
++				GCC_OPTIMIZATION_LEVEL = 0;
++				HEADER_SEARCH_PATHS = ../common;
++				OTHER_CFLAGS = "";
++				OTHER_LDFLAGS = (
++					"-framework",
++					Jackservermp,
++				);
++				OTHER_REZFLAGS = "";
++				PRODUCT_NAME = jack_test;
++				REZ_EXECUTABLE = YES;
++				SDKROOT = "";
++				SECTORDER_FLAGS = "";
++				WARNING_CFLAGS = (
++					"-Wmost",
++					"-Wno-four-char-constants",
++					"-Wno-unknown-pragmas",
++				);
++				ZERO_LINK = YES;
++			};
++			name = Development;
++		};
++		4B6654F5127C34AE00753A79 /* Deployment */ = {
++			isa = XCBuildConfiguration;
++			buildSettings = {
++				ARCHS = "$(ARCHS_STANDARD_32_64_BIT_PRE_XCODE_3_1)";
++				ARCHS_STANDARD_32_64_BIT_PRE_XCODE_3_1 = "x86_64 i386 ppc";
++				COPY_PHASE_STRIP = YES;
++				GCC_ENABLE_FIX_AND_CONTINUE = NO;
++				GCC_OPTIMIZATION_LEVEL = 3;
++				HEADER_SEARCH_PATHS = ../common;
++				MACOSX_DEPLOYMENT_TARGET = 10.4;
++				OTHER_CFLAGS = "";
++				OTHER_LDFLAGS = (
++					"-framework",
++					Jackservermp,
++				);
++				OTHER_REZFLAGS = "";
++				PRODUCT_NAME = jack_server_control;
++				REZ_EXECUTABLE = YES;
++				SDKROOT = "";
++				SECTORDER_FLAGS = "";
++				WARNING_CFLAGS = (
++					"-Wmost",
++					"-Wno-four-char-constants",
++					"-Wno-unknown-pragmas",
++				);
++				ZERO_LINK = NO;
++			};
++			name = Deployment;
++		};
++		4B6654F6127C34AE00753A79 /* Default */ = {
++			isa = XCBuildConfiguration;
++			buildSettings = {
++				ARCHS = (
++					ppc64,
++					ppc,
++					i386,
++					x86_64,
++				);
++				GCC_OPTIMIZATION_LEVEL = 3;
++				HEADER_SEARCH_PATHS = ../common;
++				OTHER_CFLAGS = "";
++				OTHER_LDFLAGS = (
++					"-framework",
++					Jackmp,
++				);
++				OTHER_REZFLAGS = "";
++				PRODUCT_NAME = jack_test;
++				REZ_EXECUTABLE = YES;
++				SDKROOT = "";
++				SECTORDER_FLAGS = "";
++				WARNING_CFLAGS = (
++					"-Wmost",
++					"-Wno-four-char-constants",
++					"-Wno-unknown-pragmas",
++				);
++			};
++			name = Default;
++		};
+ 		4B699B34097D421600A18468 /* Development */ = {
+ 			isa = XCBuildConfiguration;
+ 			buildSettings = {
+@@ -15963,6 +15999,7 @@
+ 				MACOSX_DEPLOYMENT_TARGET = 10.4;
+ 				OTHER_CFLAGS = "-DJACK_32_64";
+ 				OTHER_CPLUSPLUSFLAGS = (
++					"-DSERVER_SIDE",
+ 					"-DMACH_RPC_MACH_SEMA",
+ 					"-DJACK_32_64",
+ 				);
+@@ -16107,6 +16144,7 @@
+ 				MACOSX_DEPLOYMENT_TARGET = 10.4;
+ 				OTHER_CFLAGS = "-DJACK_32_64";
+ 				OTHER_CPLUSPLUSFLAGS = (
++					"-DSERVER_SIDE",
+ 					"-DMACH_RPC_MACH_SEMA",
+ 					"-DJACK_32_64",
+ 				);
+@@ -16247,7 +16285,10 @@
+ 				MACH_O_TYPE = mh_dylib;
+ 				MACOSX_DEPLOYMENT_TARGET = 10.4;
+ 				OTHER_CFLAGS = "-DJACK_32_64";
+-				OTHER_CPLUSPLUSFLAGS = "$(OTHER_CFLAGS)";
++				OTHER_CPLUSPLUSFLAGS = (
++					"-DSERVER_SIDE",
++					"$(OTHER_CFLAGS)",
++				);
+ 				OTHER_LDFLAGS = (
+ 					"-framework",
+ 					Jackservermp,
+@@ -16390,7 +16431,10 @@
+ 				MACH_O_TYPE = mh_dylib;
+ 				MACOSX_DEPLOYMENT_TARGET = 10.4;
+ 				OTHER_CFLAGS = "-DJACK_32_64";
+-				OTHER_CPLUSPLUSFLAGS = "$(OTHER_CFLAGS)";
++				OTHER_CPLUSPLUSFLAGS = (
++					"-DSERVER_SIDE",
++					"$(OTHER_CFLAGS)",
++				);
+ 				OTHER_LDFLAGS = (
+ 					/opt/local/lib/libsamplerate.a,
+ 					"-framework",
+@@ -16535,6 +16579,7 @@
+ 				MACOSX_DEPLOYMENT_TARGET = 10.4;
+ 				OTHER_CFLAGS = "-DJACK_32_64";
+ 				OTHER_CPLUSPLUSFLAGS = (
++					"-DSERVER_SIDE",
+ 					"-DMACH_RPC_MACH_SEMA",
+ 					"-DJACK_32_64",
+ 				);
+@@ -18471,6 +18516,16 @@
+ 			);
+ 			defaultConfigurationIsVisible = 0;
+ 			defaultConfigurationName = Default;
++		};
++		4B6654F3127C34AE00753A79 /* Build configuration list for PBXNativeTarget "jack_server_control 64 bits" */ = {
++			isa = XCConfigurationList;
++			buildConfigurations = (
++				4B6654F4127C34AE00753A79 /* Development */,
++				4B6654F5127C34AE00753A79 /* Deployment */,
++				4B6654F6127C34AE00753A79 /* Default */,
++			);
++			defaultConfigurationIsVisible = 0;
++			defaultConfigurationName = Default;
+ 		};
+ 		4B699B33097D421600A18468 /* Build configuration list for PBXAggregateTarget "All Universal 32 bits" */ = {
+ 			isa = XCConfigurationList;
+--- a/macosx/RPC/JackRPCClient.defs
++++ /dev/null
+@@ -1,47 +0,0 @@
+-/*
+- 	Copyright (C) 2004 Grame
+-    
+-    This program is free software; you can redistribute it and/or modify
+-    it under the terms of the GNU Lesser General Public License as published by
+-    the Free Software Foundation; either version 2.1 of the License, or
+-    (at your option) any later version.
+-    
+-    This program is distributed in the hope that it will be useful,
+-    but WITHOUT ANY WARRANTY; without even the implied warranty of
+-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+-    GNU Lesser General Public License for more details.
+-    
+-    You should have received a copy of the GNU Lesser General Public License
+-    along with this program; if not, write to the Free Software 
+-    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+-
+-*/
+-
+-subsystem  JackRPCClient 1000;
+-
+-#include <mach/std_types.defs>
+-#include <mach/mach_types.defs>
+-import "Jackdefs.h";
+-waittime 5000;
+-
+-type client_name_t = c_string[64];
+-type message_t = c_string[256];
+-
+-routine rpc_jack_client_sync_notify(
+-	client_port	: mach_port_t;
+-	refnum		: int;
+-	client_name	: client_name_t;
+-	notify		: int;
+-	message		: message_t;
+-	value1		: int;
+-	value2		: int;
+-    out result : int);
+-
+-simpleroutine rpc_jack_client_async_notify(
+-	client_port	: mach_port_t;
+-	refnum		: int;
+-	client_name	: client_name_t;
+-	notify		: int;
+-	message		: message_t;
+-	value1		: int;
+-	value2		: int);
+--- a/macosx/RPC/JackRPCClient.h
++++ /dev/null
+@@ -1,194 +0,0 @@
+-#ifndef	_JackRPCClient_user_
+-#define	_JackRPCClient_user_
+-
+-/* Module JackRPCClient */
+-
+-#include <string.h>
+-#include <mach/ndr.h>
+-#include <mach/boolean.h>
+-#include <mach/kern_return.h>
+-#include <mach/notify.h>
+-#include <mach/mach_types.h>
+-#include <mach/message.h>
+-#include <mach/mig_errors.h>
+-#include <mach/port.h>
+-
+-#ifdef AUTOTEST
+-#ifndef FUNCTION_PTR_T
+-#define FUNCTION_PTR_T
+-typedef void (*function_ptr_t)(mach_port_t, char *, mach_msg_type_number_t);
+-typedef struct {
+-        char            *name;
+-        function_ptr_t  function;
+-} function_table_entry;
+-typedef function_table_entry   *function_table_t;
+-#endif /* FUNCTION_PTR_T */
+-#endif /* AUTOTEST */
+-
+-#ifndef	JackRPCClient_MSG_COUNT
+-#define	JackRPCClient_MSG_COUNT	2
+-#endif	/* JackRPCClient_MSG_COUNT */
+-
+-#include <mach/std_types.h>
+-#include <mach/mig.h>
+-#include <mach/mig.h>
+-#include <mach/mach_types.h>
+-#include "Jackdefs.h"
+-
+-#ifdef __BeforeMigUserHeader
+-__BeforeMigUserHeader
+-#endif /* __BeforeMigUserHeader */
+-
+-#include <sys/cdefs.h>
+-__BEGIN_DECLS
+-
+-
+-/* Routine rpc_jack_client_sync_notify */
+-#ifdef	mig_external
+-mig_external
+-#else
+-extern
+-#endif	/* mig_external */
+-kern_return_t rpc_jack_client_sync_notify
+-(
+-	mach_port_t client_port,
+-	int refnum,
+-	client_name_t client_name,
+-	int notify,
+-	message_t message,
+-	int value1,
+-	int value2,
+-	int *result
+-);
+-
+-/* SimpleRoutine rpc_jack_client_async_notify */
+-#ifdef	mig_external
+-mig_external
+-#else
+-extern
+-#endif	/* mig_external */
+-kern_return_t rpc_jack_client_async_notify
+-(
+-	mach_port_t client_port,
+-	int refnum,
+-	client_name_t client_name,
+-	int notify,
+-	message_t message,
+-	int value1,
+-	int value2
+-);
+-
+-__END_DECLS
+-
+-/********************** Caution **************************/
+-/* The following data types should be used to calculate  */
+-/* maximum message sizes only. The actual message may be */
+-/* smaller, and the position of the arguments within the */
+-/* message layout may vary from what is presented here.  */
+-/* For example, if any of the arguments are variable-    */
+-/* sized, and less than the maximum is sent, the data    */
+-/* will be packed tight in the actual message to reduce  */
+-/* the presence of holes.                                */
+-/********************** Caution **************************/
+-
+-/* typedefs for all requests */
+-
+-#ifndef __Request__JackRPCClient_subsystem__defined
+-#define __Request__JackRPCClient_subsystem__defined
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		int refnum;
+-		client_name_t client_name;
+-		int notify;
+-		message_t message;
+-		int value1;
+-		int value2;
+-	} __Request__rpc_jack_client_sync_notify_t;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		int refnum;
+-		client_name_t client_name;
+-		int notify;
+-		message_t message;
+-		int value1;
+-		int value2;
+-	} __Request__rpc_jack_client_async_notify_t;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-#endif /* !__Request__JackRPCClient_subsystem__defined */
+-
+-/* union of all requests */
+-
+-#ifndef __RequestUnion__JackRPCClient_subsystem__defined
+-#define __RequestUnion__JackRPCClient_subsystem__defined
+-union __RequestUnion__JackRPCClient_subsystem {
+-	__Request__rpc_jack_client_sync_notify_t Request_rpc_jack_client_sync_notify;
+-	__Request__rpc_jack_client_async_notify_t Request_rpc_jack_client_async_notify;
+-};
+-#endif /* !__RequestUnion__JackRPCClient_subsystem__defined */
+-/* typedefs for all replies */
+-
+-#ifndef __Reply__JackRPCClient_subsystem__defined
+-#define __Reply__JackRPCClient_subsystem__defined
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		kern_return_t RetCode;
+-		int result;
+-	} __Reply__rpc_jack_client_sync_notify_t;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		kern_return_t RetCode;
+-	} __Reply__rpc_jack_client_async_notify_t;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-#endif /* !__Reply__JackRPCClient_subsystem__defined */
+-
+-/* union of all replies */
+-
+-#ifndef __ReplyUnion__JackRPCClient_subsystem__defined
+-#define __ReplyUnion__JackRPCClient_subsystem__defined
+-union __ReplyUnion__JackRPCClient_subsystem {
+-	__Reply__rpc_jack_client_sync_notify_t Reply_rpc_jack_client_sync_notify;
+-	__Reply__rpc_jack_client_async_notify_t Reply_rpc_jack_client_async_notify;
+-};
+-#endif /* !__RequestUnion__JackRPCClient_subsystem__defined */
+-
+-#ifndef subsystem_to_name_map_JackRPCClient
+-#define subsystem_to_name_map_JackRPCClient \
+-    { "rpc_jack_client_sync_notify", 1000 },\
+-    { "rpc_jack_client_async_notify", 1001 }
+-#endif
+-
+-#ifdef __AfterMigUserHeader
+-__AfterMigUserHeader
+-#endif /* __AfterMigUserHeader */
+-
+-#endif	 /* _JackRPCClient_user_ */
+--- a/macosx/RPC/JackRPCClientServer.c
++++ /dev/null
+@@ -1,1373 +0,0 @@
+-/*
+- * IDENTIFICATION:
+- * stub generated Fri Oct 23 10:35:08 2009
+- * with a MiG generated Mon May 18 09:59:33 PDT 2009 by root at sulitlana.apple.com
+- * OPTIONS: 
+- */
+-
+-/* Module JackRPCClient */
+-
+-#define	__MIG_check__Request__JackRPCClient_subsystem__ 1
+-#define	__NDR_convert__Request__JackRPCClient_subsystem__ 1
+-
+-#include <string.h>
+-#include <mach/ndr.h>
+-#include <mach/boolean.h>
+-#include <mach/kern_return.h>
+-#include <mach/notify.h>
+-#include <mach/mach_types.h>
+-#include <mach/message.h>
+-#include <mach/mig_errors.h>
+-#include <mach/port.h>
+-
+-#include <mach/std_types.h>
+-#include <mach/mig.h>
+-#include <mach/mig.h>
+-#include <mach/mach_types.h>
+-#include "Jackdefs.h"
+-
+-#ifndef	mig_internal
+-#define	mig_internal	static __inline__
+-#endif	/* mig_internal */
+-
+-#ifndef	mig_external
+-#define mig_external
+-#endif	/* mig_external */
+-
+-#if	!defined(__MigTypeCheck) && defined(TypeCheck)
+-#define	__MigTypeCheck		TypeCheck	/* Legacy setting */
+-#endif	/* !defined(__MigTypeCheck) */
+-
+-#if	!defined(__MigKernelSpecificCode) && defined(_MIG_KERNEL_SPECIFIC_CODE_)
+-#define	__MigKernelSpecificCode	_MIG_KERNEL_SPECIFIC_CODE_	/* Legacy setting */
+-#endif	/* !defined(__MigKernelSpecificCode) */
+-
+-#ifndef	LimitCheck
+-#define	LimitCheck 0
+-#endif	/* LimitCheck */
+-
+-#ifndef	min
+-#define	min(a,b)  ( ((a) < (b))? (a): (b) )
+-#endif	/* min */
+-
+-#if !defined(_WALIGN_)
+-#define _WALIGN_(x) (((x) + 3) & ~3)
+-#endif /* !defined(_WALIGN_) */
+-
+-#if !defined(_WALIGNSZ_)
+-#define _WALIGNSZ_(x) _WALIGN_(sizeof(x))
+-#endif /* !defined(_WALIGNSZ_) */
+-
+-#ifndef	UseStaticTemplates
+-#define	UseStaticTemplates	0
+-#endif	/* UseStaticTemplates */
+-
+-#ifndef	__DeclareRcvRpc
+-#define	__DeclareRcvRpc(_NUM_, _NAME_)
+-#endif	/* __DeclareRcvRpc */
+-
+-#ifndef	__BeforeRcvRpc
+-#define	__BeforeRcvRpc(_NUM_, _NAME_)
+-#endif	/* __BeforeRcvRpc */
+-
+-#ifndef	__AfterRcvRpc
+-#define	__AfterRcvRpc(_NUM_, _NAME_)
+-#endif	/* __AfterRcvRpc */
+-
+-#ifndef	__DeclareRcvSimple
+-#define	__DeclareRcvSimple(_NUM_, _NAME_)
+-#endif	/* __DeclareRcvSimple */
+-
+-#ifndef	__BeforeRcvSimple
+-#define	__BeforeRcvSimple(_NUM_, _NAME_)
+-#endif	/* __BeforeRcvSimple */
+-
+-#ifndef	__AfterRcvSimple
+-#define	__AfterRcvSimple(_NUM_, _NAME_)
+-#endif	/* __AfterRcvSimple */
+-
+-#define novalue void
+-
+-#define msgh_request_port	msgh_local_port
+-#define MACH_MSGH_BITS_REQUEST(bits)	MACH_MSGH_BITS_LOCAL(bits)
+-#define msgh_reply_port		msgh_remote_port
+-#define MACH_MSGH_BITS_REPLY(bits)	MACH_MSGH_BITS_REMOTE(bits)
+-
+-#define MIG_RETURN_ERROR(X, code)	{\
+-				((mig_reply_error_t *)X)->RetCode = code;\
+-				((mig_reply_error_t *)X)->NDR = NDR_record;\
+-				return;\
+-				}
+-
+-/* typedefs for all requests */
+-
+-#ifndef __Request__JackRPCClient_subsystem__defined
+-#define __Request__JackRPCClient_subsystem__defined
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		int refnum;
+-		client_name_t client_name;
+-		int notify;
+-		message_t message;
+-		int value1;
+-		int value2;
+-	} __Request__rpc_jack_client_sync_notify_t;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		int refnum;
+-		client_name_t client_name;
+-		int notify;
+-		message_t message;
+-		int value1;
+-		int value2;
+-	} __Request__rpc_jack_client_async_notify_t;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-#endif /* !__Request__JackRPCClient_subsystem__defined */
+-
+-/* typedefs for all replies */
+-
+-#ifndef __Reply__JackRPCClient_subsystem__defined
+-#define __Reply__JackRPCClient_subsystem__defined
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		kern_return_t RetCode;
+-		int result;
+-	} __Reply__rpc_jack_client_sync_notify_t;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		kern_return_t RetCode;
+-	} __Reply__rpc_jack_client_async_notify_t;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-#endif /* !__Reply__JackRPCClient_subsystem__defined */
+-
+-
+-/* union of all replies */
+-
+-#ifndef __ReplyUnion__JackRPCClient_subsystem__defined
+-#define __ReplyUnion__JackRPCClient_subsystem__defined
+-union __ReplyUnion__JackRPCClient_subsystem {
+-	__Reply__rpc_jack_client_sync_notify_t Reply_rpc_jack_client_sync_notify;
+-	__Reply__rpc_jack_client_async_notify_t Reply_rpc_jack_client_async_notify;
+-};
+-#endif /* __RequestUnion__JackRPCClient_subsystem__defined */
+-/* Forward Declarations */
+-
+-
+-mig_internal novalue _Xrpc_jack_client_sync_notify
+-	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP);
+-
+-mig_internal novalue _Xrpc_jack_client_async_notify
+-	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP);
+-
+-
+-#if ( __MigTypeCheck || __NDR_convert__ )
+-#if __MIG_check__Request__JackRPCClient_subsystem__
+-#if !defined(__MIG_check__Request__rpc_jack_client_sync_notify_t__defined)
+-#define __MIG_check__Request__rpc_jack_client_sync_notify_t__defined
+-#ifndef __NDR_convert__int_rep__Request__rpc_jack_client_sync_notify_t__refnum__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCClient__int__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_sync_notify_t__refnum__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_sync_notify_t__refnum(a, f) \
+-	__NDR_convert__int_rep__JackRPCClient__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_sync_notify_t__refnum__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_sync_notify_t__refnum(a, f) \
+-	__NDR_convert__int_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__JackRPCClient__int32_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_sync_notify_t__refnum__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_sync_notify_t__refnum(a, f) \
+-	__NDR_convert__int_rep__JackRPCClient__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int32_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_sync_notify_t__refnum__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_sync_notify_t__refnum(a, f) \
+-	__NDR_convert__int_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Request__rpc_jack_client_sync_notify_t__refnum__defined */
+-
+-#ifndef __NDR_convert__int_rep__Request__rpc_jack_client_sync_notify_t__client_name__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCClient__client_name_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_sync_notify_t__client_name__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_sync_notify_t__client_name(a, f) \
+-	__NDR_convert__int_rep__JackRPCClient__client_name_t((client_name_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__client_name_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_sync_notify_t__client_name__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_sync_notify_t__client_name(a, f) \
+-	__NDR_convert__int_rep__client_name_t((client_name_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__JackRPCClient__string__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_sync_notify_t__client_name__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_sync_notify_t__client_name(a, f) \
+-	__NDR_convert__int_rep__JackRPCClient__string(a, f, 64)
+-#elif	defined(__NDR_convert__int_rep__string__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_sync_notify_t__client_name__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_sync_notify_t__client_name(a, f) \
+-	__NDR_convert__int_rep__string(a, f, 64)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Request__rpc_jack_client_sync_notify_t__client_name__defined */
+-
+-#ifndef __NDR_convert__int_rep__Request__rpc_jack_client_sync_notify_t__notify__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCClient__int__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_sync_notify_t__notify__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_sync_notify_t__notify(a, f) \
+-	__NDR_convert__int_rep__JackRPCClient__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_sync_notify_t__notify__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_sync_notify_t__notify(a, f) \
+-	__NDR_convert__int_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__JackRPCClient__int32_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_sync_notify_t__notify__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_sync_notify_t__notify(a, f) \
+-	__NDR_convert__int_rep__JackRPCClient__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int32_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_sync_notify_t__notify__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_sync_notify_t__notify(a, f) \
+-	__NDR_convert__int_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Request__rpc_jack_client_sync_notify_t__notify__defined */
+-
+-#ifndef __NDR_convert__int_rep__Request__rpc_jack_client_sync_notify_t__message__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCClient__message_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_sync_notify_t__message__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_sync_notify_t__message(a, f) \
+-	__NDR_convert__int_rep__JackRPCClient__message_t((message_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__message_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_sync_notify_t__message__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_sync_notify_t__message(a, f) \
+-	__NDR_convert__int_rep__message_t((message_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__JackRPCClient__string__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_sync_notify_t__message__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_sync_notify_t__message(a, f) \
+-	__NDR_convert__int_rep__JackRPCClient__string(a, f, 256)
+-#elif	defined(__NDR_convert__int_rep__string__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_sync_notify_t__message__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_sync_notify_t__message(a, f) \
+-	__NDR_convert__int_rep__string(a, f, 256)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Request__rpc_jack_client_sync_notify_t__message__defined */
+-
+-#ifndef __NDR_convert__int_rep__Request__rpc_jack_client_sync_notify_t__value1__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCClient__int__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_sync_notify_t__value1__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_sync_notify_t__value1(a, f) \
+-	__NDR_convert__int_rep__JackRPCClient__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_sync_notify_t__value1__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_sync_notify_t__value1(a, f) \
+-	__NDR_convert__int_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__JackRPCClient__int32_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_sync_notify_t__value1__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_sync_notify_t__value1(a, f) \
+-	__NDR_convert__int_rep__JackRPCClient__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int32_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_sync_notify_t__value1__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_sync_notify_t__value1(a, f) \
+-	__NDR_convert__int_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Request__rpc_jack_client_sync_notify_t__value1__defined */
+-
+-#ifndef __NDR_convert__int_rep__Request__rpc_jack_client_sync_notify_t__value2__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCClient__int__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_sync_notify_t__value2__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_sync_notify_t__value2(a, f) \
+-	__NDR_convert__int_rep__JackRPCClient__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_sync_notify_t__value2__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_sync_notify_t__value2(a, f) \
+-	__NDR_convert__int_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__JackRPCClient__int32_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_sync_notify_t__value2__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_sync_notify_t__value2(a, f) \
+-	__NDR_convert__int_rep__JackRPCClient__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int32_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_sync_notify_t__value2__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_sync_notify_t__value2(a, f) \
+-	__NDR_convert__int_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Request__rpc_jack_client_sync_notify_t__value2__defined */
+-
+-#ifndef __NDR_convert__char_rep__Request__rpc_jack_client_sync_notify_t__refnum__defined
+-#if	defined(__NDR_convert__char_rep__JackRPCClient__int__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_sync_notify_t__refnum__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_sync_notify_t__refnum(a, f) \
+-	__NDR_convert__char_rep__JackRPCClient__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_sync_notify_t__refnum__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_sync_notify_t__refnum(a, f) \
+-	__NDR_convert__char_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__JackRPCClient__int32_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_sync_notify_t__refnum__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_sync_notify_t__refnum(a, f) \
+-	__NDR_convert__char_rep__JackRPCClient__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int32_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_sync_notify_t__refnum__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_sync_notify_t__refnum(a, f) \
+-	__NDR_convert__char_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__char_rep__Request__rpc_jack_client_sync_notify_t__refnum__defined */
+-
+-#ifndef __NDR_convert__char_rep__Request__rpc_jack_client_sync_notify_t__client_name__defined
+-#if	defined(__NDR_convert__char_rep__JackRPCClient__client_name_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_sync_notify_t__client_name__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_sync_notify_t__client_name(a, f) \
+-	__NDR_convert__char_rep__JackRPCClient__client_name_t((client_name_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__client_name_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_sync_notify_t__client_name__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_sync_notify_t__client_name(a, f) \
+-	__NDR_convert__char_rep__client_name_t((client_name_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__JackRPCClient__string__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_sync_notify_t__client_name__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_sync_notify_t__client_name(a, f) \
+-	__NDR_convert__char_rep__JackRPCClient__string(a, f, 64)
+-#elif	defined(__NDR_convert__char_rep__string__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_sync_notify_t__client_name__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_sync_notify_t__client_name(a, f) \
+-	__NDR_convert__char_rep__string(a, f, 64)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__char_rep__Request__rpc_jack_client_sync_notify_t__client_name__defined */
+-
+-#ifndef __NDR_convert__char_rep__Request__rpc_jack_client_sync_notify_t__notify__defined
+-#if	defined(__NDR_convert__char_rep__JackRPCClient__int__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_sync_notify_t__notify__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_sync_notify_t__notify(a, f) \
+-	__NDR_convert__char_rep__JackRPCClient__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_sync_notify_t__notify__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_sync_notify_t__notify(a, f) \
+-	__NDR_convert__char_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__JackRPCClient__int32_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_sync_notify_t__notify__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_sync_notify_t__notify(a, f) \
+-	__NDR_convert__char_rep__JackRPCClient__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int32_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_sync_notify_t__notify__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_sync_notify_t__notify(a, f) \
+-	__NDR_convert__char_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__char_rep__Request__rpc_jack_client_sync_notify_t__notify__defined */
+-
+-#ifndef __NDR_convert__char_rep__Request__rpc_jack_client_sync_notify_t__message__defined
+-#if	defined(__NDR_convert__char_rep__JackRPCClient__message_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_sync_notify_t__message__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_sync_notify_t__message(a, f) \
+-	__NDR_convert__char_rep__JackRPCClient__message_t((message_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__message_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_sync_notify_t__message__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_sync_notify_t__message(a, f) \
+-	__NDR_convert__char_rep__message_t((message_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__JackRPCClient__string__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_sync_notify_t__message__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_sync_notify_t__message(a, f) \
+-	__NDR_convert__char_rep__JackRPCClient__string(a, f, 256)
+-#elif	defined(__NDR_convert__char_rep__string__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_sync_notify_t__message__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_sync_notify_t__message(a, f) \
+-	__NDR_convert__char_rep__string(a, f, 256)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__char_rep__Request__rpc_jack_client_sync_notify_t__message__defined */
+-
+-#ifndef __NDR_convert__char_rep__Request__rpc_jack_client_sync_notify_t__value1__defined
+-#if	defined(__NDR_convert__char_rep__JackRPCClient__int__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_sync_notify_t__value1__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_sync_notify_t__value1(a, f) \
+-	__NDR_convert__char_rep__JackRPCClient__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_sync_notify_t__value1__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_sync_notify_t__value1(a, f) \
+-	__NDR_convert__char_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__JackRPCClient__int32_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_sync_notify_t__value1__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_sync_notify_t__value1(a, f) \
+-	__NDR_convert__char_rep__JackRPCClient__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int32_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_sync_notify_t__value1__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_sync_notify_t__value1(a, f) \
+-	__NDR_convert__char_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__char_rep__Request__rpc_jack_client_sync_notify_t__value1__defined */
+-
+-#ifndef __NDR_convert__char_rep__Request__rpc_jack_client_sync_notify_t__value2__defined
+-#if	defined(__NDR_convert__char_rep__JackRPCClient__int__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_sync_notify_t__value2__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_sync_notify_t__value2(a, f) \
+-	__NDR_convert__char_rep__JackRPCClient__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_sync_notify_t__value2__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_sync_notify_t__value2(a, f) \
+-	__NDR_convert__char_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__JackRPCClient__int32_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_sync_notify_t__value2__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_sync_notify_t__value2(a, f) \
+-	__NDR_convert__char_rep__JackRPCClient__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int32_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_sync_notify_t__value2__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_sync_notify_t__value2(a, f) \
+-	__NDR_convert__char_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__char_rep__Request__rpc_jack_client_sync_notify_t__value2__defined */
+-
+-#ifndef __NDR_convert__float_rep__Request__rpc_jack_client_sync_notify_t__refnum__defined
+-#if	defined(__NDR_convert__float_rep__JackRPCClient__int__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_sync_notify_t__refnum__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_sync_notify_t__refnum(a, f) \
+-	__NDR_convert__float_rep__JackRPCClient__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_sync_notify_t__refnum__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_sync_notify_t__refnum(a, f) \
+-	__NDR_convert__float_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__JackRPCClient__int32_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_sync_notify_t__refnum__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_sync_notify_t__refnum(a, f) \
+-	__NDR_convert__float_rep__JackRPCClient__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int32_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_sync_notify_t__refnum__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_sync_notify_t__refnum(a, f) \
+-	__NDR_convert__float_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__float_rep__Request__rpc_jack_client_sync_notify_t__refnum__defined */
+-
+-#ifndef __NDR_convert__float_rep__Request__rpc_jack_client_sync_notify_t__client_name__defined
+-#if	defined(__NDR_convert__float_rep__JackRPCClient__client_name_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_sync_notify_t__client_name__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_sync_notify_t__client_name(a, f) \
+-	__NDR_convert__float_rep__JackRPCClient__client_name_t((client_name_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__client_name_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_sync_notify_t__client_name__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_sync_notify_t__client_name(a, f) \
+-	__NDR_convert__float_rep__client_name_t((client_name_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__JackRPCClient__string__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_sync_notify_t__client_name__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_sync_notify_t__client_name(a, f) \
+-	__NDR_convert__float_rep__JackRPCClient__string(a, f, 64)
+-#elif	defined(__NDR_convert__float_rep__string__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_sync_notify_t__client_name__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_sync_notify_t__client_name(a, f) \
+-	__NDR_convert__float_rep__string(a, f, 64)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__float_rep__Request__rpc_jack_client_sync_notify_t__client_name__defined */
+-
+-#ifndef __NDR_convert__float_rep__Request__rpc_jack_client_sync_notify_t__notify__defined
+-#if	defined(__NDR_convert__float_rep__JackRPCClient__int__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_sync_notify_t__notify__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_sync_notify_t__notify(a, f) \
+-	__NDR_convert__float_rep__JackRPCClient__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_sync_notify_t__notify__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_sync_notify_t__notify(a, f) \
+-	__NDR_convert__float_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__JackRPCClient__int32_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_sync_notify_t__notify__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_sync_notify_t__notify(a, f) \
+-	__NDR_convert__float_rep__JackRPCClient__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int32_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_sync_notify_t__notify__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_sync_notify_t__notify(a, f) \
+-	__NDR_convert__float_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__float_rep__Request__rpc_jack_client_sync_notify_t__notify__defined */
+-
+-#ifndef __NDR_convert__float_rep__Request__rpc_jack_client_sync_notify_t__message__defined
+-#if	defined(__NDR_convert__float_rep__JackRPCClient__message_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_sync_notify_t__message__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_sync_notify_t__message(a, f) \
+-	__NDR_convert__float_rep__JackRPCClient__message_t((message_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__message_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_sync_notify_t__message__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_sync_notify_t__message(a, f) \
+-	__NDR_convert__float_rep__message_t((message_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__JackRPCClient__string__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_sync_notify_t__message__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_sync_notify_t__message(a, f) \
+-	__NDR_convert__float_rep__JackRPCClient__string(a, f, 256)
+-#elif	defined(__NDR_convert__float_rep__string__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_sync_notify_t__message__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_sync_notify_t__message(a, f) \
+-	__NDR_convert__float_rep__string(a, f, 256)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__float_rep__Request__rpc_jack_client_sync_notify_t__message__defined */
+-
+-#ifndef __NDR_convert__float_rep__Request__rpc_jack_client_sync_notify_t__value1__defined
+-#if	defined(__NDR_convert__float_rep__JackRPCClient__int__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_sync_notify_t__value1__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_sync_notify_t__value1(a, f) \
+-	__NDR_convert__float_rep__JackRPCClient__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_sync_notify_t__value1__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_sync_notify_t__value1(a, f) \
+-	__NDR_convert__float_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__JackRPCClient__int32_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_sync_notify_t__value1__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_sync_notify_t__value1(a, f) \
+-	__NDR_convert__float_rep__JackRPCClient__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int32_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_sync_notify_t__value1__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_sync_notify_t__value1(a, f) \
+-	__NDR_convert__float_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__float_rep__Request__rpc_jack_client_sync_notify_t__value1__defined */
+-
+-#ifndef __NDR_convert__float_rep__Request__rpc_jack_client_sync_notify_t__value2__defined
+-#if	defined(__NDR_convert__float_rep__JackRPCClient__int__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_sync_notify_t__value2__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_sync_notify_t__value2(a, f) \
+-	__NDR_convert__float_rep__JackRPCClient__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_sync_notify_t__value2__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_sync_notify_t__value2(a, f) \
+-	__NDR_convert__float_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__JackRPCClient__int32_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_sync_notify_t__value2__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_sync_notify_t__value2(a, f) \
+-	__NDR_convert__float_rep__JackRPCClient__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int32_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_sync_notify_t__value2__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_sync_notify_t__value2(a, f) \
+-	__NDR_convert__float_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__float_rep__Request__rpc_jack_client_sync_notify_t__value2__defined */
+-
+-
+-mig_internal kern_return_t __MIG_check__Request__rpc_jack_client_sync_notify_t(__attribute__((__unused__)) __Request__rpc_jack_client_sync_notify_t *In0P)
+-{
+-
+-	typedef __Request__rpc_jack_client_sync_notify_t __Request;
+-#if	__MigTypeCheck
+-	if ((In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
+-	    (In0P->Head.msgh_size != (mach_msg_size_t)sizeof(__Request)))
+-		return MIG_BAD_ARGUMENTS;
+-#endif	/* __MigTypeCheck */
+-
+-#if __MigTypeCheck
+-	{
+-		char * msg_limit = ((char *) In0P) + In0P->Head.msgh_size;
+-		size_t memchr_limit;
+-
+-		memchr_limit = min((msg_limit - In0P->client_name),  64);
+-		if (( memchr(In0P->client_name, '\0', memchr_limit) == NULL ))
+-			return MIG_BAD_ARGUMENTS; // string length exceeds buffer length!
+-		memchr_limit = min((msg_limit - In0P->message),  256);
+-		if (( memchr(In0P->message, '\0', memchr_limit) == NULL ))
+-			return MIG_BAD_ARGUMENTS; // string length exceeds buffer length!
+-	}
+-#endif	/* __MigTypeCheck */
+-
+-#if	defined(__NDR_convert__int_rep__Request__rpc_jack_client_sync_notify_t__refnum__defined) || \
+-	defined(__NDR_convert__int_rep__Request__rpc_jack_client_sync_notify_t__client_name__defined) || \
+-	defined(__NDR_convert__int_rep__Request__rpc_jack_client_sync_notify_t__notify__defined) || \
+-	defined(__NDR_convert__int_rep__Request__rpc_jack_client_sync_notify_t__message__defined) || \
+-	defined(__NDR_convert__int_rep__Request__rpc_jack_client_sync_notify_t__value1__defined) || \
+-	defined(__NDR_convert__int_rep__Request__rpc_jack_client_sync_notify_t__value2__defined)
+-	if (In0P->NDR.int_rep != NDR_record.int_rep) {
+-#if defined(__NDR_convert__int_rep__Request__rpc_jack_client_sync_notify_t__refnum__defined)
+-		__NDR_convert__int_rep__Request__rpc_jack_client_sync_notify_t__refnum(&In0P->refnum, In0P->NDR.int_rep);
+-#endif	/* __NDR_convert__int_rep__Request__rpc_jack_client_sync_notify_t__refnum__defined */
+-#if defined(__NDR_convert__int_rep__Request__rpc_jack_client_sync_notify_t__client_name__defined)
+-		__NDR_convert__int_rep__Request__rpc_jack_client_sync_notify_t__client_name(&In0P->client_name, In0P->NDR.int_rep);
+-#endif	/* __NDR_convert__int_rep__Request__rpc_jack_client_sync_notify_t__client_name__defined */
+-#if defined(__NDR_convert__int_rep__Request__rpc_jack_client_sync_notify_t__notify__defined)
+-		__NDR_convert__int_rep__Request__rpc_jack_client_sync_notify_t__notify(&In0P->notify, In0P->NDR.int_rep);
+-#endif	/* __NDR_convert__int_rep__Request__rpc_jack_client_sync_notify_t__notify__defined */
+-#if defined(__NDR_convert__int_rep__Request__rpc_jack_client_sync_notify_t__message__defined)
+-		__NDR_convert__int_rep__Request__rpc_jack_client_sync_notify_t__message(&In0P->message, In0P->NDR.int_rep);
+-#endif	/* __NDR_convert__int_rep__Request__rpc_jack_client_sync_notify_t__message__defined */
+-#if defined(__NDR_convert__int_rep__Request__rpc_jack_client_sync_notify_t__value1__defined)
+-		__NDR_convert__int_rep__Request__rpc_jack_client_sync_notify_t__value1(&In0P->value1, In0P->NDR.int_rep);
+-#endif	/* __NDR_convert__int_rep__Request__rpc_jack_client_sync_notify_t__value1__defined */
+-#if defined(__NDR_convert__int_rep__Request__rpc_jack_client_sync_notify_t__value2__defined)
+-		__NDR_convert__int_rep__Request__rpc_jack_client_sync_notify_t__value2(&In0P->value2, In0P->NDR.int_rep);
+-#endif	/* __NDR_convert__int_rep__Request__rpc_jack_client_sync_notify_t__value2__defined */
+-	}
+-#endif	/* defined(__NDR_convert__int_rep...) */
+-
+-#if	defined(__NDR_convert__char_rep__Request__rpc_jack_client_sync_notify_t__refnum__defined) || \
+-	defined(__NDR_convert__char_rep__Request__rpc_jack_client_sync_notify_t__client_name__defined) || \
+-	defined(__NDR_convert__char_rep__Request__rpc_jack_client_sync_notify_t__notify__defined) || \
+-	defined(__NDR_convert__char_rep__Request__rpc_jack_client_sync_notify_t__message__defined) || \
+-	defined(__NDR_convert__char_rep__Request__rpc_jack_client_sync_notify_t__value1__defined) || \
+-	defined(__NDR_convert__char_rep__Request__rpc_jack_client_sync_notify_t__value2__defined)
+-	if (In0P->NDR.char_rep != NDR_record.char_rep) {
+-#if defined(__NDR_convert__char_rep__Request__rpc_jack_client_sync_notify_t__refnum__defined)
+-		__NDR_convert__char_rep__Request__rpc_jack_client_sync_notify_t__refnum(&In0P->refnum, In0P->NDR.char_rep);
+-#endif	/* __NDR_convert__char_rep__Request__rpc_jack_client_sync_notify_t__refnum__defined */
+-#if defined(__NDR_convert__char_rep__Request__rpc_jack_client_sync_notify_t__client_name__defined)
+-		__NDR_convert__char_rep__Request__rpc_jack_client_sync_notify_t__client_name(&In0P->client_name, In0P->NDR.char_rep);
+-#endif	/* __NDR_convert__char_rep__Request__rpc_jack_client_sync_notify_t__client_name__defined */
+-#if defined(__NDR_convert__char_rep__Request__rpc_jack_client_sync_notify_t__notify__defined)
+-		__NDR_convert__char_rep__Request__rpc_jack_client_sync_notify_t__notify(&In0P->notify, In0P->NDR.char_rep);
+-#endif	/* __NDR_convert__char_rep__Request__rpc_jack_client_sync_notify_t__notify__defined */
+-#if defined(__NDR_convert__char_rep__Request__rpc_jack_client_sync_notify_t__message__defined)
+-		__NDR_convert__char_rep__Request__rpc_jack_client_sync_notify_t__message(&In0P->message, In0P->NDR.char_rep);
+-#endif	/* __NDR_convert__char_rep__Request__rpc_jack_client_sync_notify_t__message__defined */
+-#if defined(__NDR_convert__char_rep__Request__rpc_jack_client_sync_notify_t__value1__defined)
+-		__NDR_convert__char_rep__Request__rpc_jack_client_sync_notify_t__value1(&In0P->value1, In0P->NDR.char_rep);
+-#endif	/* __NDR_convert__char_rep__Request__rpc_jack_client_sync_notify_t__value1__defined */
+-#if defined(__NDR_convert__char_rep__Request__rpc_jack_client_sync_notify_t__value2__defined)
+-		__NDR_convert__char_rep__Request__rpc_jack_client_sync_notify_t__value2(&In0P->value2, In0P->NDR.char_rep);
+-#endif	/* __NDR_convert__char_rep__Request__rpc_jack_client_sync_notify_t__value2__defined */
+-	}
+-#endif	/* defined(__NDR_convert__char_rep...) */
+-
+-#if	defined(__NDR_convert__float_rep__Request__rpc_jack_client_sync_notify_t__refnum__defined) || \
+-	defined(__NDR_convert__float_rep__Request__rpc_jack_client_sync_notify_t__client_name__defined) || \
+-	defined(__NDR_convert__float_rep__Request__rpc_jack_client_sync_notify_t__notify__defined) || \
+-	defined(__NDR_convert__float_rep__Request__rpc_jack_client_sync_notify_t__message__defined) || \
+-	defined(__NDR_convert__float_rep__Request__rpc_jack_client_sync_notify_t__value1__defined) || \
+-	defined(__NDR_convert__float_rep__Request__rpc_jack_client_sync_notify_t__value2__defined)
+-	if (In0P->NDR.float_rep != NDR_record.float_rep) {
+-#if defined(__NDR_convert__float_rep__Request__rpc_jack_client_sync_notify_t__refnum__defined)
+-		__NDR_convert__float_rep__Request__rpc_jack_client_sync_notify_t__refnum(&In0P->refnum, In0P->NDR.float_rep);
+-#endif	/* __NDR_convert__float_rep__Request__rpc_jack_client_sync_notify_t__refnum__defined */
+-#if defined(__NDR_convert__float_rep__Request__rpc_jack_client_sync_notify_t__client_name__defined)
+-		__NDR_convert__float_rep__Request__rpc_jack_client_sync_notify_t__client_name(&In0P->client_name, In0P->NDR.float_rep);
+-#endif	/* __NDR_convert__float_rep__Request__rpc_jack_client_sync_notify_t__client_name__defined */
+-#if defined(__NDR_convert__float_rep__Request__rpc_jack_client_sync_notify_t__notify__defined)
+-		__NDR_convert__float_rep__Request__rpc_jack_client_sync_notify_t__notify(&In0P->notify, In0P->NDR.float_rep);
+-#endif	/* __NDR_convert__float_rep__Request__rpc_jack_client_sync_notify_t__notify__defined */
+-#if defined(__NDR_convert__float_rep__Request__rpc_jack_client_sync_notify_t__message__defined)
+-		__NDR_convert__float_rep__Request__rpc_jack_client_sync_notify_t__message(&In0P->message, In0P->NDR.float_rep);
+-#endif	/* __NDR_convert__float_rep__Request__rpc_jack_client_sync_notify_t__message__defined */
+-#if defined(__NDR_convert__float_rep__Request__rpc_jack_client_sync_notify_t__value1__defined)
+-		__NDR_convert__float_rep__Request__rpc_jack_client_sync_notify_t__value1(&In0P->value1, In0P->NDR.float_rep);
+-#endif	/* __NDR_convert__float_rep__Request__rpc_jack_client_sync_notify_t__value1__defined */
+-#if defined(__NDR_convert__float_rep__Request__rpc_jack_client_sync_notify_t__value2__defined)
+-		__NDR_convert__float_rep__Request__rpc_jack_client_sync_notify_t__value2(&In0P->value2, In0P->NDR.float_rep);
+-#endif	/* __NDR_convert__float_rep__Request__rpc_jack_client_sync_notify_t__value2__defined */
+-	}
+-#endif	/* defined(__NDR_convert__float_rep...) */
+-
+-	return MACH_MSG_SUCCESS;
+-}
+-#endif /* !defined(__MIG_check__Request__rpc_jack_client_sync_notify_t__defined) */
+-#endif /* __MIG_check__Request__JackRPCClient_subsystem__ */
+-#endif /* ( __MigTypeCheck || __NDR_convert__ ) */
+-
+-
+-/* Routine rpc_jack_client_sync_notify */
+-#ifdef	mig_external
+-mig_external
+-#else
+-extern
+-#endif	/* mig_external */
+-kern_return_t rpc_jack_client_sync_notify
+-(
+-	mach_port_t client_port,
+-	int refnum,
+-	client_name_t client_name,
+-	int notify,
+-	message_t message,
+-	int value1,
+-	int value2,
+-	int *result
+-);
+-
+-/* Routine rpc_jack_client_sync_notify */
+-mig_internal novalue _Xrpc_jack_client_sync_notify
+-	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
+-{
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		int refnum;
+-		client_name_t client_name;
+-		int notify;
+-		message_t message;
+-		int value1;
+-		int value2;
+-		mach_msg_trailer_t trailer;
+-	} Request;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-	typedef __Request__rpc_jack_client_sync_notify_t __Request;
+-	typedef __Reply__rpc_jack_client_sync_notify_t Reply;
+-
+-	/*
+-	 * typedef struct {
+-	 * 	mach_msg_header_t Head;
+-	 * 	NDR_record_t NDR;
+-	 * 	kern_return_t RetCode;
+-	 * } mig_reply_error_t;
+-	 */
+-
+-	Request *In0P = (Request *) InHeadP;
+-	Reply *OutP = (Reply *) OutHeadP;
+-#ifdef	__MIG_check__Request__rpc_jack_client_sync_notify_t__defined
+-	kern_return_t check_result;
+-#endif	/* __MIG_check__Request__rpc_jack_client_sync_notify_t__defined */
+-
+-	__DeclareRcvRpc(1000, "rpc_jack_client_sync_notify")
+-	__BeforeRcvRpc(1000, "rpc_jack_client_sync_notify")
+-
+-#if	defined(__MIG_check__Request__rpc_jack_client_sync_notify_t__defined)
+-	check_result = __MIG_check__Request__rpc_jack_client_sync_notify_t((__Request *)In0P);
+-	if (check_result != MACH_MSG_SUCCESS)
+-		{ MIG_RETURN_ERROR(OutP, check_result); }
+-#endif	/* defined(__MIG_check__Request__rpc_jack_client_sync_notify_t__defined) */
+-
+-	OutP->RetCode = rpc_jack_client_sync_notify(In0P->Head.msgh_request_port, In0P->refnum, In0P->client_name, In0P->notify, In0P->message, In0P->value1, In0P->value2, &OutP->result);
+-	if (OutP->RetCode != KERN_SUCCESS) {
+-		MIG_RETURN_ERROR(OutP, OutP->RetCode);
+-	}
+-
+-	OutP->NDR = NDR_record;
+-
+-
+-	OutP->Head.msgh_size = (mach_msg_size_t)(sizeof(Reply));
+-	__AfterRcvRpc(1000, "rpc_jack_client_sync_notify")
+-}
+-
+-#if ( __MigTypeCheck || __NDR_convert__ )
+-#if __MIG_check__Request__JackRPCClient_subsystem__
+-#if !defined(__MIG_check__Request__rpc_jack_client_async_notify_t__defined)
+-#define __MIG_check__Request__rpc_jack_client_async_notify_t__defined
+-#ifndef __NDR_convert__int_rep__Request__rpc_jack_client_async_notify_t__refnum__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCClient__int__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_async_notify_t__refnum__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_async_notify_t__refnum(a, f) \
+-	__NDR_convert__int_rep__JackRPCClient__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_async_notify_t__refnum__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_async_notify_t__refnum(a, f) \
+-	__NDR_convert__int_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__JackRPCClient__int32_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_async_notify_t__refnum__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_async_notify_t__refnum(a, f) \
+-	__NDR_convert__int_rep__JackRPCClient__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int32_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_async_notify_t__refnum__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_async_notify_t__refnum(a, f) \
+-	__NDR_convert__int_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Request__rpc_jack_client_async_notify_t__refnum__defined */
+-
+-#ifndef __NDR_convert__int_rep__Request__rpc_jack_client_async_notify_t__client_name__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCClient__client_name_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_async_notify_t__client_name__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_async_notify_t__client_name(a, f) \
+-	__NDR_convert__int_rep__JackRPCClient__client_name_t((client_name_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__client_name_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_async_notify_t__client_name__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_async_notify_t__client_name(a, f) \
+-	__NDR_convert__int_rep__client_name_t((client_name_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__JackRPCClient__string__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_async_notify_t__client_name__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_async_notify_t__client_name(a, f) \
+-	__NDR_convert__int_rep__JackRPCClient__string(a, f, 64)
+-#elif	defined(__NDR_convert__int_rep__string__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_async_notify_t__client_name__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_async_notify_t__client_name(a, f) \
+-	__NDR_convert__int_rep__string(a, f, 64)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Request__rpc_jack_client_async_notify_t__client_name__defined */
+-
+-#ifndef __NDR_convert__int_rep__Request__rpc_jack_client_async_notify_t__notify__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCClient__int__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_async_notify_t__notify__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_async_notify_t__notify(a, f) \
+-	__NDR_convert__int_rep__JackRPCClient__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_async_notify_t__notify__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_async_notify_t__notify(a, f) \
+-	__NDR_convert__int_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__JackRPCClient__int32_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_async_notify_t__notify__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_async_notify_t__notify(a, f) \
+-	__NDR_convert__int_rep__JackRPCClient__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int32_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_async_notify_t__notify__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_async_notify_t__notify(a, f) \
+-	__NDR_convert__int_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Request__rpc_jack_client_async_notify_t__notify__defined */
+-
+-#ifndef __NDR_convert__int_rep__Request__rpc_jack_client_async_notify_t__message__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCClient__message_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_async_notify_t__message__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_async_notify_t__message(a, f) \
+-	__NDR_convert__int_rep__JackRPCClient__message_t((message_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__message_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_async_notify_t__message__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_async_notify_t__message(a, f) \
+-	__NDR_convert__int_rep__message_t((message_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__JackRPCClient__string__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_async_notify_t__message__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_async_notify_t__message(a, f) \
+-	__NDR_convert__int_rep__JackRPCClient__string(a, f, 256)
+-#elif	defined(__NDR_convert__int_rep__string__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_async_notify_t__message__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_async_notify_t__message(a, f) \
+-	__NDR_convert__int_rep__string(a, f, 256)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Request__rpc_jack_client_async_notify_t__message__defined */
+-
+-#ifndef __NDR_convert__int_rep__Request__rpc_jack_client_async_notify_t__value1__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCClient__int__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_async_notify_t__value1__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_async_notify_t__value1(a, f) \
+-	__NDR_convert__int_rep__JackRPCClient__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_async_notify_t__value1__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_async_notify_t__value1(a, f) \
+-	__NDR_convert__int_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__JackRPCClient__int32_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_async_notify_t__value1__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_async_notify_t__value1(a, f) \
+-	__NDR_convert__int_rep__JackRPCClient__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int32_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_async_notify_t__value1__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_async_notify_t__value1(a, f) \
+-	__NDR_convert__int_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Request__rpc_jack_client_async_notify_t__value1__defined */
+-
+-#ifndef __NDR_convert__int_rep__Request__rpc_jack_client_async_notify_t__value2__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCClient__int__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_async_notify_t__value2__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_async_notify_t__value2(a, f) \
+-	__NDR_convert__int_rep__JackRPCClient__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_async_notify_t__value2__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_async_notify_t__value2(a, f) \
+-	__NDR_convert__int_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__JackRPCClient__int32_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_async_notify_t__value2__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_async_notify_t__value2(a, f) \
+-	__NDR_convert__int_rep__JackRPCClient__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int32_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_async_notify_t__value2__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_async_notify_t__value2(a, f) \
+-	__NDR_convert__int_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Request__rpc_jack_client_async_notify_t__value2__defined */
+-
+-#ifndef __NDR_convert__char_rep__Request__rpc_jack_client_async_notify_t__refnum__defined
+-#if	defined(__NDR_convert__char_rep__JackRPCClient__int__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_async_notify_t__refnum__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_async_notify_t__refnum(a, f) \
+-	__NDR_convert__char_rep__JackRPCClient__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_async_notify_t__refnum__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_async_notify_t__refnum(a, f) \
+-	__NDR_convert__char_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__JackRPCClient__int32_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_async_notify_t__refnum__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_async_notify_t__refnum(a, f) \
+-	__NDR_convert__char_rep__JackRPCClient__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int32_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_async_notify_t__refnum__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_async_notify_t__refnum(a, f) \
+-	__NDR_convert__char_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__char_rep__Request__rpc_jack_client_async_notify_t__refnum__defined */
+-
+-#ifndef __NDR_convert__char_rep__Request__rpc_jack_client_async_notify_t__client_name__defined
+-#if	defined(__NDR_convert__char_rep__JackRPCClient__client_name_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_async_notify_t__client_name__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_async_notify_t__client_name(a, f) \
+-	__NDR_convert__char_rep__JackRPCClient__client_name_t((client_name_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__client_name_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_async_notify_t__client_name__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_async_notify_t__client_name(a, f) \
+-	__NDR_convert__char_rep__client_name_t((client_name_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__JackRPCClient__string__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_async_notify_t__client_name__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_async_notify_t__client_name(a, f) \
+-	__NDR_convert__char_rep__JackRPCClient__string(a, f, 64)
+-#elif	defined(__NDR_convert__char_rep__string__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_async_notify_t__client_name__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_async_notify_t__client_name(a, f) \
+-	__NDR_convert__char_rep__string(a, f, 64)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__char_rep__Request__rpc_jack_client_async_notify_t__client_name__defined */
+-
+-#ifndef __NDR_convert__char_rep__Request__rpc_jack_client_async_notify_t__notify__defined
+-#if	defined(__NDR_convert__char_rep__JackRPCClient__int__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_async_notify_t__notify__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_async_notify_t__notify(a, f) \
+-	__NDR_convert__char_rep__JackRPCClient__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_async_notify_t__notify__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_async_notify_t__notify(a, f) \
+-	__NDR_convert__char_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__JackRPCClient__int32_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_async_notify_t__notify__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_async_notify_t__notify(a, f) \
+-	__NDR_convert__char_rep__JackRPCClient__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int32_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_async_notify_t__notify__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_async_notify_t__notify(a, f) \
+-	__NDR_convert__char_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__char_rep__Request__rpc_jack_client_async_notify_t__notify__defined */
+-
+-#ifndef __NDR_convert__char_rep__Request__rpc_jack_client_async_notify_t__message__defined
+-#if	defined(__NDR_convert__char_rep__JackRPCClient__message_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_async_notify_t__message__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_async_notify_t__message(a, f) \
+-	__NDR_convert__char_rep__JackRPCClient__message_t((message_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__message_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_async_notify_t__message__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_async_notify_t__message(a, f) \
+-	__NDR_convert__char_rep__message_t((message_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__JackRPCClient__string__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_async_notify_t__message__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_async_notify_t__message(a, f) \
+-	__NDR_convert__char_rep__JackRPCClient__string(a, f, 256)
+-#elif	defined(__NDR_convert__char_rep__string__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_async_notify_t__message__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_async_notify_t__message(a, f) \
+-	__NDR_convert__char_rep__string(a, f, 256)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__char_rep__Request__rpc_jack_client_async_notify_t__message__defined */
+-
+-#ifndef __NDR_convert__char_rep__Request__rpc_jack_client_async_notify_t__value1__defined
+-#if	defined(__NDR_convert__char_rep__JackRPCClient__int__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_async_notify_t__value1__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_async_notify_t__value1(a, f) \
+-	__NDR_convert__char_rep__JackRPCClient__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_async_notify_t__value1__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_async_notify_t__value1(a, f) \
+-	__NDR_convert__char_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__JackRPCClient__int32_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_async_notify_t__value1__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_async_notify_t__value1(a, f) \
+-	__NDR_convert__char_rep__JackRPCClient__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int32_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_async_notify_t__value1__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_async_notify_t__value1(a, f) \
+-	__NDR_convert__char_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__char_rep__Request__rpc_jack_client_async_notify_t__value1__defined */
+-
+-#ifndef __NDR_convert__char_rep__Request__rpc_jack_client_async_notify_t__value2__defined
+-#if	defined(__NDR_convert__char_rep__JackRPCClient__int__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_async_notify_t__value2__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_async_notify_t__value2(a, f) \
+-	__NDR_convert__char_rep__JackRPCClient__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_async_notify_t__value2__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_async_notify_t__value2(a, f) \
+-	__NDR_convert__char_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__JackRPCClient__int32_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_async_notify_t__value2__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_async_notify_t__value2(a, f) \
+-	__NDR_convert__char_rep__JackRPCClient__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int32_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_async_notify_t__value2__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_async_notify_t__value2(a, f) \
+-	__NDR_convert__char_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__char_rep__Request__rpc_jack_client_async_notify_t__value2__defined */
+-
+-#ifndef __NDR_convert__float_rep__Request__rpc_jack_client_async_notify_t__refnum__defined
+-#if	defined(__NDR_convert__float_rep__JackRPCClient__int__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_async_notify_t__refnum__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_async_notify_t__refnum(a, f) \
+-	__NDR_convert__float_rep__JackRPCClient__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_async_notify_t__refnum__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_async_notify_t__refnum(a, f) \
+-	__NDR_convert__float_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__JackRPCClient__int32_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_async_notify_t__refnum__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_async_notify_t__refnum(a, f) \
+-	__NDR_convert__float_rep__JackRPCClient__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int32_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_async_notify_t__refnum__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_async_notify_t__refnum(a, f) \
+-	__NDR_convert__float_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__float_rep__Request__rpc_jack_client_async_notify_t__refnum__defined */
+-
+-#ifndef __NDR_convert__float_rep__Request__rpc_jack_client_async_notify_t__client_name__defined
+-#if	defined(__NDR_convert__float_rep__JackRPCClient__client_name_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_async_notify_t__client_name__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_async_notify_t__client_name(a, f) \
+-	__NDR_convert__float_rep__JackRPCClient__client_name_t((client_name_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__client_name_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_async_notify_t__client_name__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_async_notify_t__client_name(a, f) \
+-	__NDR_convert__float_rep__client_name_t((client_name_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__JackRPCClient__string__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_async_notify_t__client_name__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_async_notify_t__client_name(a, f) \
+-	__NDR_convert__float_rep__JackRPCClient__string(a, f, 64)
+-#elif	defined(__NDR_convert__float_rep__string__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_async_notify_t__client_name__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_async_notify_t__client_name(a, f) \
+-	__NDR_convert__float_rep__string(a, f, 64)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__float_rep__Request__rpc_jack_client_async_notify_t__client_name__defined */
+-
+-#ifndef __NDR_convert__float_rep__Request__rpc_jack_client_async_notify_t__notify__defined
+-#if	defined(__NDR_convert__float_rep__JackRPCClient__int__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_async_notify_t__notify__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_async_notify_t__notify(a, f) \
+-	__NDR_convert__float_rep__JackRPCClient__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_async_notify_t__notify__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_async_notify_t__notify(a, f) \
+-	__NDR_convert__float_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__JackRPCClient__int32_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_async_notify_t__notify__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_async_notify_t__notify(a, f) \
+-	__NDR_convert__float_rep__JackRPCClient__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int32_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_async_notify_t__notify__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_async_notify_t__notify(a, f) \
+-	__NDR_convert__float_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__float_rep__Request__rpc_jack_client_async_notify_t__notify__defined */
+-
+-#ifndef __NDR_convert__float_rep__Request__rpc_jack_client_async_notify_t__message__defined
+-#if	defined(__NDR_convert__float_rep__JackRPCClient__message_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_async_notify_t__message__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_async_notify_t__message(a, f) \
+-	__NDR_convert__float_rep__JackRPCClient__message_t((message_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__message_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_async_notify_t__message__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_async_notify_t__message(a, f) \
+-	__NDR_convert__float_rep__message_t((message_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__JackRPCClient__string__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_async_notify_t__message__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_async_notify_t__message(a, f) \
+-	__NDR_convert__float_rep__JackRPCClient__string(a, f, 256)
+-#elif	defined(__NDR_convert__float_rep__string__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_async_notify_t__message__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_async_notify_t__message(a, f) \
+-	__NDR_convert__float_rep__string(a, f, 256)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__float_rep__Request__rpc_jack_client_async_notify_t__message__defined */
+-
+-#ifndef __NDR_convert__float_rep__Request__rpc_jack_client_async_notify_t__value1__defined
+-#if	defined(__NDR_convert__float_rep__JackRPCClient__int__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_async_notify_t__value1__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_async_notify_t__value1(a, f) \
+-	__NDR_convert__float_rep__JackRPCClient__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_async_notify_t__value1__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_async_notify_t__value1(a, f) \
+-	__NDR_convert__float_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__JackRPCClient__int32_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_async_notify_t__value1__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_async_notify_t__value1(a, f) \
+-	__NDR_convert__float_rep__JackRPCClient__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int32_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_async_notify_t__value1__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_async_notify_t__value1(a, f) \
+-	__NDR_convert__float_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__float_rep__Request__rpc_jack_client_async_notify_t__value1__defined */
+-
+-#ifndef __NDR_convert__float_rep__Request__rpc_jack_client_async_notify_t__value2__defined
+-#if	defined(__NDR_convert__float_rep__JackRPCClient__int__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_async_notify_t__value2__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_async_notify_t__value2(a, f) \
+-	__NDR_convert__float_rep__JackRPCClient__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_async_notify_t__value2__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_async_notify_t__value2(a, f) \
+-	__NDR_convert__float_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__JackRPCClient__int32_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_async_notify_t__value2__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_async_notify_t__value2(a, f) \
+-	__NDR_convert__float_rep__JackRPCClient__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int32_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_async_notify_t__value2__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_async_notify_t__value2(a, f) \
+-	__NDR_convert__float_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__float_rep__Request__rpc_jack_client_async_notify_t__value2__defined */
+-
+-
+-mig_internal kern_return_t __MIG_check__Request__rpc_jack_client_async_notify_t(__attribute__((__unused__)) __Request__rpc_jack_client_async_notify_t *In0P)
+-{
+-
+-	typedef __Request__rpc_jack_client_async_notify_t __Request;
+-#if	__MigTypeCheck
+-	if ((In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
+-	    (In0P->Head.msgh_size != (mach_msg_size_t)sizeof(__Request)))
+-		return MIG_BAD_ARGUMENTS;
+-#endif	/* __MigTypeCheck */
+-
+-#if __MigTypeCheck
+-	{
+-		char * msg_limit = ((char *) In0P) + In0P->Head.msgh_size;
+-		size_t memchr_limit;
+-
+-		memchr_limit = min((msg_limit - In0P->client_name),  64);
+-		if (( memchr(In0P->client_name, '\0', memchr_limit) == NULL ))
+-			return MIG_BAD_ARGUMENTS; // string length exceeds buffer length!
+-		memchr_limit = min((msg_limit - In0P->message),  256);
+-		if (( memchr(In0P->message, '\0', memchr_limit) == NULL ))
+-			return MIG_BAD_ARGUMENTS; // string length exceeds buffer length!
+-	}
+-#endif	/* __MigTypeCheck */
+-
+-#if	defined(__NDR_convert__int_rep__Request__rpc_jack_client_async_notify_t__refnum__defined) || \
+-	defined(__NDR_convert__int_rep__Request__rpc_jack_client_async_notify_t__client_name__defined) || \
+-	defined(__NDR_convert__int_rep__Request__rpc_jack_client_async_notify_t__notify__defined) || \
+-	defined(__NDR_convert__int_rep__Request__rpc_jack_client_async_notify_t__message__defined) || \
+-	defined(__NDR_convert__int_rep__Request__rpc_jack_client_async_notify_t__value1__defined) || \
+-	defined(__NDR_convert__int_rep__Request__rpc_jack_client_async_notify_t__value2__defined)
+-	if (In0P->NDR.int_rep != NDR_record.int_rep) {
+-#if defined(__NDR_convert__int_rep__Request__rpc_jack_client_async_notify_t__refnum__defined)
+-		__NDR_convert__int_rep__Request__rpc_jack_client_async_notify_t__refnum(&In0P->refnum, In0P->NDR.int_rep);
+-#endif	/* __NDR_convert__int_rep__Request__rpc_jack_client_async_notify_t__refnum__defined */
+-#if defined(__NDR_convert__int_rep__Request__rpc_jack_client_async_notify_t__client_name__defined)
+-		__NDR_convert__int_rep__Request__rpc_jack_client_async_notify_t__client_name(&In0P->client_name, In0P->NDR.int_rep);
+-#endif	/* __NDR_convert__int_rep__Request__rpc_jack_client_async_notify_t__client_name__defined */
+-#if defined(__NDR_convert__int_rep__Request__rpc_jack_client_async_notify_t__notify__defined)
+-		__NDR_convert__int_rep__Request__rpc_jack_client_async_notify_t__notify(&In0P->notify, In0P->NDR.int_rep);
+-#endif	/* __NDR_convert__int_rep__Request__rpc_jack_client_async_notify_t__notify__defined */
+-#if defined(__NDR_convert__int_rep__Request__rpc_jack_client_async_notify_t__message__defined)
+-		__NDR_convert__int_rep__Request__rpc_jack_client_async_notify_t__message(&In0P->message, In0P->NDR.int_rep);
+-#endif	/* __NDR_convert__int_rep__Request__rpc_jack_client_async_notify_t__message__defined */
+-#if defined(__NDR_convert__int_rep__Request__rpc_jack_client_async_notify_t__value1__defined)
+-		__NDR_convert__int_rep__Request__rpc_jack_client_async_notify_t__value1(&In0P->value1, In0P->NDR.int_rep);
+-#endif	/* __NDR_convert__int_rep__Request__rpc_jack_client_async_notify_t__value1__defined */
+-#if defined(__NDR_convert__int_rep__Request__rpc_jack_client_async_notify_t__value2__defined)
+-		__NDR_convert__int_rep__Request__rpc_jack_client_async_notify_t__value2(&In0P->value2, In0P->NDR.int_rep);
+-#endif	/* __NDR_convert__int_rep__Request__rpc_jack_client_async_notify_t__value2__defined */
+-	}
+-#endif	/* defined(__NDR_convert__int_rep...) */
+-
+-#if	defined(__NDR_convert__char_rep__Request__rpc_jack_client_async_notify_t__refnum__defined) || \
+-	defined(__NDR_convert__char_rep__Request__rpc_jack_client_async_notify_t__client_name__defined) || \
+-	defined(__NDR_convert__char_rep__Request__rpc_jack_client_async_notify_t__notify__defined) || \
+-	defined(__NDR_convert__char_rep__Request__rpc_jack_client_async_notify_t__message__defined) || \
+-	defined(__NDR_convert__char_rep__Request__rpc_jack_client_async_notify_t__value1__defined) || \
+-	defined(__NDR_convert__char_rep__Request__rpc_jack_client_async_notify_t__value2__defined)
+-	if (In0P->NDR.char_rep != NDR_record.char_rep) {
+-#if defined(__NDR_convert__char_rep__Request__rpc_jack_client_async_notify_t__refnum__defined)
+-		__NDR_convert__char_rep__Request__rpc_jack_client_async_notify_t__refnum(&In0P->refnum, In0P->NDR.char_rep);
+-#endif	/* __NDR_convert__char_rep__Request__rpc_jack_client_async_notify_t__refnum__defined */
+-#if defined(__NDR_convert__char_rep__Request__rpc_jack_client_async_notify_t__client_name__defined)
+-		__NDR_convert__char_rep__Request__rpc_jack_client_async_notify_t__client_name(&In0P->client_name, In0P->NDR.char_rep);
+-#endif	/* __NDR_convert__char_rep__Request__rpc_jack_client_async_notify_t__client_name__defined */
+-#if defined(__NDR_convert__char_rep__Request__rpc_jack_client_async_notify_t__notify__defined)
+-		__NDR_convert__char_rep__Request__rpc_jack_client_async_notify_t__notify(&In0P->notify, In0P->NDR.char_rep);
+-#endif	/* __NDR_convert__char_rep__Request__rpc_jack_client_async_notify_t__notify__defined */
+-#if defined(__NDR_convert__char_rep__Request__rpc_jack_client_async_notify_t__message__defined)
+-		__NDR_convert__char_rep__Request__rpc_jack_client_async_notify_t__message(&In0P->message, In0P->NDR.char_rep);
+-#endif	/* __NDR_convert__char_rep__Request__rpc_jack_client_async_notify_t__message__defined */
+-#if defined(__NDR_convert__char_rep__Request__rpc_jack_client_async_notify_t__value1__defined)
+-		__NDR_convert__char_rep__Request__rpc_jack_client_async_notify_t__value1(&In0P->value1, In0P->NDR.char_rep);
+-#endif	/* __NDR_convert__char_rep__Request__rpc_jack_client_async_notify_t__value1__defined */
+-#if defined(__NDR_convert__char_rep__Request__rpc_jack_client_async_notify_t__value2__defined)
+-		__NDR_convert__char_rep__Request__rpc_jack_client_async_notify_t__value2(&In0P->value2, In0P->NDR.char_rep);
+-#endif	/* __NDR_convert__char_rep__Request__rpc_jack_client_async_notify_t__value2__defined */
+-	}
+-#endif	/* defined(__NDR_convert__char_rep...) */
+-
+-#if	defined(__NDR_convert__float_rep__Request__rpc_jack_client_async_notify_t__refnum__defined) || \
+-	defined(__NDR_convert__float_rep__Request__rpc_jack_client_async_notify_t__client_name__defined) || \
+-	defined(__NDR_convert__float_rep__Request__rpc_jack_client_async_notify_t__notify__defined) || \
+-	defined(__NDR_convert__float_rep__Request__rpc_jack_client_async_notify_t__message__defined) || \
+-	defined(__NDR_convert__float_rep__Request__rpc_jack_client_async_notify_t__value1__defined) || \
+-	defined(__NDR_convert__float_rep__Request__rpc_jack_client_async_notify_t__value2__defined)
+-	if (In0P->NDR.float_rep != NDR_record.float_rep) {
+-#if defined(__NDR_convert__float_rep__Request__rpc_jack_client_async_notify_t__refnum__defined)
+-		__NDR_convert__float_rep__Request__rpc_jack_client_async_notify_t__refnum(&In0P->refnum, In0P->NDR.float_rep);
+-#endif	/* __NDR_convert__float_rep__Request__rpc_jack_client_async_notify_t__refnum__defined */
+-#if defined(__NDR_convert__float_rep__Request__rpc_jack_client_async_notify_t__client_name__defined)
+-		__NDR_convert__float_rep__Request__rpc_jack_client_async_notify_t__client_name(&In0P->client_name, In0P->NDR.float_rep);
+-#endif	/* __NDR_convert__float_rep__Request__rpc_jack_client_async_notify_t__client_name__defined */
+-#if defined(__NDR_convert__float_rep__Request__rpc_jack_client_async_notify_t__notify__defined)
+-		__NDR_convert__float_rep__Request__rpc_jack_client_async_notify_t__notify(&In0P->notify, In0P->NDR.float_rep);
+-#endif	/* __NDR_convert__float_rep__Request__rpc_jack_client_async_notify_t__notify__defined */
+-#if defined(__NDR_convert__float_rep__Request__rpc_jack_client_async_notify_t__message__defined)
+-		__NDR_convert__float_rep__Request__rpc_jack_client_async_notify_t__message(&In0P->message, In0P->NDR.float_rep);
+-#endif	/* __NDR_convert__float_rep__Request__rpc_jack_client_async_notify_t__message__defined */
+-#if defined(__NDR_convert__float_rep__Request__rpc_jack_client_async_notify_t__value1__defined)
+-		__NDR_convert__float_rep__Request__rpc_jack_client_async_notify_t__value1(&In0P->value1, In0P->NDR.float_rep);
+-#endif	/* __NDR_convert__float_rep__Request__rpc_jack_client_async_notify_t__value1__defined */
+-#if defined(__NDR_convert__float_rep__Request__rpc_jack_client_async_notify_t__value2__defined)
+-		__NDR_convert__float_rep__Request__rpc_jack_client_async_notify_t__value2(&In0P->value2, In0P->NDR.float_rep);
+-#endif	/* __NDR_convert__float_rep__Request__rpc_jack_client_async_notify_t__value2__defined */
+-	}
+-#endif	/* defined(__NDR_convert__float_rep...) */
+-
+-	return MACH_MSG_SUCCESS;
+-}
+-#endif /* !defined(__MIG_check__Request__rpc_jack_client_async_notify_t__defined) */
+-#endif /* __MIG_check__Request__JackRPCClient_subsystem__ */
+-#endif /* ( __MigTypeCheck || __NDR_convert__ ) */
+-
+-
+-/* SimpleRoutine rpc_jack_client_async_notify */
+-#ifdef	mig_external
+-mig_external
+-#else
+-extern
+-#endif	/* mig_external */
+-kern_return_t rpc_jack_client_async_notify
+-(
+-	mach_port_t client_port,
+-	int refnum,
+-	client_name_t client_name,
+-	int notify,
+-	message_t message,
+-	int value1,
+-	int value2
+-);
+-
+-/* SimpleRoutine rpc_jack_client_async_notify */
+-mig_internal novalue _Xrpc_jack_client_async_notify
+-	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
+-{
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		int refnum;
+-		client_name_t client_name;
+-		int notify;
+-		message_t message;
+-		int value1;
+-		int value2;
+-		mach_msg_trailer_t trailer;
+-	} Request;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-	typedef __Request__rpc_jack_client_async_notify_t __Request;
+-	typedef __Reply__rpc_jack_client_async_notify_t Reply;
+-
+-	/*
+-	 * typedef struct {
+-	 * 	mach_msg_header_t Head;
+-	 * 	NDR_record_t NDR;
+-	 * 	kern_return_t RetCode;
+-	 * } mig_reply_error_t;
+-	 */
+-
+-	Request *In0P = (Request *) InHeadP;
+-	Reply *OutP = (Reply *) OutHeadP;
+-#ifdef	__MIG_check__Request__rpc_jack_client_async_notify_t__defined
+-	kern_return_t check_result;
+-#endif	/* __MIG_check__Request__rpc_jack_client_async_notify_t__defined */
+-
+-	__DeclareRcvSimple(1001, "rpc_jack_client_async_notify")
+-	__BeforeRcvSimple(1001, "rpc_jack_client_async_notify")
+-
+-#if	defined(__MIG_check__Request__rpc_jack_client_async_notify_t__defined)
+-	check_result = __MIG_check__Request__rpc_jack_client_async_notify_t((__Request *)In0P);
+-	if (check_result != MACH_MSG_SUCCESS)
+-		{ MIG_RETURN_ERROR(OutP, check_result); }
+-#endif	/* defined(__MIG_check__Request__rpc_jack_client_async_notify_t__defined) */
+-
+-	OutP->RetCode = rpc_jack_client_async_notify(In0P->Head.msgh_request_port, In0P->refnum, In0P->client_name, In0P->notify, In0P->message, In0P->value1, In0P->value2);
+-	__AfterRcvSimple(1001, "rpc_jack_client_async_notify")
+-}
+-
+-
+-extern boolean_t JackRPCClient_server(
+-		mach_msg_header_t *InHeadP,
+-		mach_msg_header_t *OutHeadP);
+-
+-extern mig_routine_t JackRPCClient_server_routine(
+-		mach_msg_header_t *InHeadP);
+-
+-
+-/* Description of this subsystem, for use in direct RPC */
+-const struct JackRPCClient_subsystem {
+-	mig_server_routine_t 	server;	/* Server routine */
+-	mach_msg_id_t	start;	/* Min routine number */
+-	mach_msg_id_t	end;	/* Max routine number + 1 */
+-	unsigned int	maxsize;	/* Max msg size */
+-	vm_address_t	reserved;	/* Reserved */
+-	struct routine_descriptor	/*Array of routine descriptors */
+-		routine[2];
+-} JackRPCClient_subsystem = {
+-	JackRPCClient_server_routine,
+-	1000,
+-	1002,
+-	(mach_msg_size_t)sizeof(union __ReplyUnion__JackRPCClient_subsystem),
+-	(vm_address_t)0,
+-	{
+-          { (mig_impl_routine_t) 0,
+-          (mig_stub_routine_t) _Xrpc_jack_client_sync_notify, 8, 0, (routine_arg_descriptor_t)0, (mach_msg_size_t)sizeof(__Reply__rpc_jack_client_sync_notify_t)},
+-          { (mig_impl_routine_t) 0,
+-          (mig_stub_routine_t) _Xrpc_jack_client_async_notify, 7, 0, (routine_arg_descriptor_t)0, (mach_msg_size_t)sizeof(__Reply__rpc_jack_client_async_notify_t)},
+-	}
+-};
+-
+-mig_external boolean_t JackRPCClient_server
+-	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
+-{
+-	/*
+-	 * typedef struct {
+-	 * 	mach_msg_header_t Head;
+-	 * 	NDR_record_t NDR;
+-	 * 	kern_return_t RetCode;
+-	 * } mig_reply_error_t;
+-	 */
+-
+-	register mig_routine_t routine;
+-
+-	OutHeadP->msgh_bits = MACH_MSGH_BITS(MACH_MSGH_BITS_REPLY(InHeadP->msgh_bits), 0);
+-	OutHeadP->msgh_remote_port = InHeadP->msgh_reply_port;
+-	/* Minimal size: routine() will update it if different */
+-	OutHeadP->msgh_size = (mach_msg_size_t)sizeof(mig_reply_error_t);
+-	OutHeadP->msgh_local_port = MACH_PORT_NULL;
+-	OutHeadP->msgh_id = InHeadP->msgh_id + 100;
+-
+-	if ((InHeadP->msgh_id > 1001) || (InHeadP->msgh_id < 1000) ||
+-	    ((routine = JackRPCClient_subsystem.routine[InHeadP->msgh_id - 1000].stub_routine) == 0)) {
+-		((mig_reply_error_t *)OutHeadP)->NDR = NDR_record;
+-		((mig_reply_error_t *)OutHeadP)->RetCode = MIG_BAD_ID;
+-		return FALSE;
+-	}
+-	(*routine) (InHeadP, OutHeadP);
+-	return TRUE;
+-}
+-
+-mig_external mig_routine_t JackRPCClient_server_routine
+-	(mach_msg_header_t *InHeadP)
+-{
+-	register int msgh_id;
+-
+-	msgh_id = InHeadP->msgh_id - 1000;
+-
+-	if ((msgh_id > 1) || (msgh_id < 0))
+-		return 0;
+-
+-	return JackRPCClient_subsystem.routine[msgh_id].stub_routine;
+-}
+--- a/macosx/RPC/JackRPCClientUser.c
++++ /dev/null
+@@ -1,466 +0,0 @@
+-/*
+- * IDENTIFICATION:
+- * stub generated Fri Oct 23 10:35:08 2009
+- * with a MiG generated Mon May 18 09:59:33 PDT 2009 by root at sulitlana.apple.com
+- * OPTIONS: 
+- */
+-#define	__MIG_check__Reply__JackRPCClient_subsystem__ 1
+-#define	__NDR_convert__Reply__JackRPCClient_subsystem__ 1
+-#define	__NDR_convert__mig_reply_error_subsystem__ 1
+-
+-#include "JackRPCClient.h"
+-
+-
+-#ifndef	mig_internal
+-#define	mig_internal	static __inline__
+-#endif	/* mig_internal */
+-
+-#ifndef	mig_external
+-#define mig_external
+-#endif	/* mig_external */
+-
+-#if	!defined(__MigTypeCheck) && defined(TypeCheck)
+-#define	__MigTypeCheck		TypeCheck	/* Legacy setting */
+-#endif	/* !defined(__MigTypeCheck) */
+-
+-#if	!defined(__MigKernelSpecificCode) && defined(_MIG_KERNEL_SPECIFIC_CODE_)
+-#define	__MigKernelSpecificCode	_MIG_KERNEL_SPECIFIC_CODE_	/* Legacy setting */
+-#endif	/* !defined(__MigKernelSpecificCode) */
+-
+-#ifndef	LimitCheck
+-#define	LimitCheck 0
+-#endif	/* LimitCheck */
+-
+-#ifndef	min
+-#define	min(a,b)  ( ((a) < (b))? (a): (b) )
+-#endif	/* min */
+-
+-#if !defined(_WALIGN_)
+-#define _WALIGN_(x) (((x) + 3) & ~3)
+-#endif /* !defined(_WALIGN_) */
+-
+-#if !defined(_WALIGNSZ_)
+-#define _WALIGNSZ_(x) _WALIGN_(sizeof(x))
+-#endif /* !defined(_WALIGNSZ_) */
+-
+-#ifndef	UseStaticTemplates
+-#define	UseStaticTemplates	0
+-#endif	/* UseStaticTemplates */
+-
+-#ifndef	__MachMsgErrorWithTimeout
+-#define	__MachMsgErrorWithTimeout(_R_) { \
+-	switch (_R_) { \
+-	case MACH_SEND_INVALID_DATA: \
+-	case MACH_SEND_INVALID_DEST: \
+-	case MACH_SEND_INVALID_HEADER: \
+-		mig_put_reply_port(InP->Head.msgh_reply_port); \
+-		break; \
+-	case MACH_SEND_TIMED_OUT: \
+-	case MACH_RCV_TIMED_OUT: \
+-	default: \
+-		mig_dealloc_reply_port(InP->Head.msgh_reply_port); \
+-	} \
+-}
+-#endif	/* __MachMsgErrorWithTimeout */
+-
+-#ifndef	__MachMsgErrorWithoutTimeout
+-#define	__MachMsgErrorWithoutTimeout(_R_) { \
+-	switch (_R_) { \
+-	case MACH_SEND_INVALID_DATA: \
+-	case MACH_SEND_INVALID_DEST: \
+-	case MACH_SEND_INVALID_HEADER: \
+-		mig_put_reply_port(InP->Head.msgh_reply_port); \
+-		break; \
+-	default: \
+-		mig_dealloc_reply_port(InP->Head.msgh_reply_port); \
+-	} \
+-}
+-#endif	/* __MachMsgErrorWithoutTimeout */
+-
+-#ifndef	__DeclareSendRpc
+-#define	__DeclareSendRpc(_NUM_, _NAME_)
+-#endif	/* __DeclareSendRpc */
+-
+-#ifndef	__BeforeSendRpc
+-#define	__BeforeSendRpc(_NUM_, _NAME_)
+-#endif	/* __BeforeSendRpc */
+-
+-#ifndef	__AfterSendRpc
+-#define	__AfterSendRpc(_NUM_, _NAME_)
+-#endif	/* __AfterSendRpc */
+-
+-#ifndef	__DeclareSendSimple
+-#define	__DeclareSendSimple(_NUM_, _NAME_)
+-#endif	/* __DeclareSendSimple */
+-
+-#ifndef	__BeforeSendSimple
+-#define	__BeforeSendSimple(_NUM_, _NAME_)
+-#endif	/* __BeforeSendSimple */
+-
+-#ifndef	__AfterSendSimple
+-#define	__AfterSendSimple(_NUM_, _NAME_)
+-#endif	/* __AfterSendSimple */
+-
+-#define msgh_request_port	msgh_remote_port
+-#define msgh_reply_port		msgh_local_port
+-
+-
+-
+-#if ( __MigTypeCheck || __NDR_convert__ )
+-#if __MIG_check__Reply__JackRPCClient_subsystem__
+-#if !defined(__MIG_check__Reply__rpc_jack_client_sync_notify_t__defined)
+-#define __MIG_check__Reply__rpc_jack_client_sync_notify_t__defined
+-#ifndef __NDR_convert__int_rep__Reply__rpc_jack_client_sync_notify_t__RetCode__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCClient__kern_return_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_sync_notify_t__RetCode__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_sync_notify_t__RetCode(a, f) \
+-	__NDR_convert__int_rep__JackRPCClient__kern_return_t((kern_return_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__kern_return_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_sync_notify_t__RetCode__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_sync_notify_t__RetCode(a, f) \
+-	__NDR_convert__int_rep__kern_return_t((kern_return_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_sync_notify_t__RetCode__defined */
+-
+-
+-#ifndef __NDR_convert__int_rep__Reply__rpc_jack_client_sync_notify_t__result__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCClient__int__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_sync_notify_t__result__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_sync_notify_t__result(a, f) \
+-	__NDR_convert__int_rep__JackRPCClient__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_sync_notify_t__result__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_sync_notify_t__result(a, f) \
+-	__NDR_convert__int_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__JackRPCClient__int32_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_sync_notify_t__result__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_sync_notify_t__result(a, f) \
+-	__NDR_convert__int_rep__JackRPCClient__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int32_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_sync_notify_t__result__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_sync_notify_t__result(a, f) \
+-	__NDR_convert__int_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_sync_notify_t__result__defined */
+-
+-
+-
+-#ifndef __NDR_convert__char_rep__Reply__rpc_jack_client_sync_notify_t__result__defined
+-#if	defined(__NDR_convert__char_rep__JackRPCClient__int__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_sync_notify_t__result__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_sync_notify_t__result(a, f) \
+-	__NDR_convert__char_rep__JackRPCClient__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_sync_notify_t__result__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_sync_notify_t__result(a, f) \
+-	__NDR_convert__char_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__JackRPCClient__int32_t__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_sync_notify_t__result__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_sync_notify_t__result(a, f) \
+-	__NDR_convert__char_rep__JackRPCClient__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int32_t__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_sync_notify_t__result__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_sync_notify_t__result(a, f) \
+-	__NDR_convert__char_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__char_rep__Reply__rpc_jack_client_sync_notify_t__result__defined */
+-
+-
+-
+-#ifndef __NDR_convert__float_rep__Reply__rpc_jack_client_sync_notify_t__result__defined
+-#if	defined(__NDR_convert__float_rep__JackRPCClient__int__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_sync_notify_t__result__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_sync_notify_t__result(a, f) \
+-	__NDR_convert__float_rep__JackRPCClient__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_sync_notify_t__result__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_sync_notify_t__result(a, f) \
+-	__NDR_convert__float_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__JackRPCClient__int32_t__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_sync_notify_t__result__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_sync_notify_t__result(a, f) \
+-	__NDR_convert__float_rep__JackRPCClient__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int32_t__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_sync_notify_t__result__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_sync_notify_t__result(a, f) \
+-	__NDR_convert__float_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__float_rep__Reply__rpc_jack_client_sync_notify_t__result__defined */
+-
+-
+-
+-mig_internal kern_return_t __MIG_check__Reply__rpc_jack_client_sync_notify_t(__Reply__rpc_jack_client_sync_notify_t *Out0P)
+-{
+-
+-	typedef __Reply__rpc_jack_client_sync_notify_t __Reply;
+-#if	__MigTypeCheck
+-	unsigned int msgh_size;
+-#endif	/* __MigTypeCheck */
+-	if (Out0P->Head.msgh_id != 1100) {
+-	    if (Out0P->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
+-		{ return MIG_SERVER_DIED; }
+-	    else
+-		{ return MIG_REPLY_MISMATCH; }
+-	}
+-
+-#if	__MigTypeCheck
+-	msgh_size = Out0P->Head.msgh_size;
+-
+-	if ((Out0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
+-	    ((msgh_size != (mach_msg_size_t)sizeof(__Reply)) &&
+-	     (msgh_size != (mach_msg_size_t)sizeof(mig_reply_error_t) ||
+-	      Out0P->RetCode == KERN_SUCCESS)))
+-		{ return MIG_TYPE_ERROR ; }
+-#endif	/* __MigTypeCheck */
+-
+-	if (Out0P->RetCode != KERN_SUCCESS) {
+-#ifdef	__NDR_convert__mig_reply_error_t__defined
+-		__NDR_convert__mig_reply_error_t((mig_reply_error_t *)Out0P);
+-#endif	/* __NDR_convert__mig_reply_error_t__defined */
+-		return ((mig_reply_error_t *)Out0P)->RetCode;
+-	}
+-
+-#if	defined(__NDR_convert__int_rep__Reply__rpc_jack_client_sync_notify_t__RetCode__defined) || \
+-	defined(__NDR_convert__int_rep__Reply__rpc_jack_client_sync_notify_t__result__defined)
+-	if (Out0P->NDR.int_rep != NDR_record.int_rep) {
+-#if defined(__NDR_convert__int_rep__Reply__rpc_jack_client_sync_notify_t__RetCode__defined)
+-		__NDR_convert__int_rep__Reply__rpc_jack_client_sync_notify_t__RetCode(&Out0P->RetCode, Out0P->NDR.int_rep);
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_sync_notify_t__RetCode__defined */
+-#if defined(__NDR_convert__int_rep__Reply__rpc_jack_client_sync_notify_t__result__defined)
+-		__NDR_convert__int_rep__Reply__rpc_jack_client_sync_notify_t__result(&Out0P->result, Out0P->NDR.int_rep);
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_sync_notify_t__result__defined */
+-	}
+-#endif	/* defined(__NDR_convert__int_rep...) */
+-
+-#if	0 || \
+-	defined(__NDR_convert__char_rep__Reply__rpc_jack_client_sync_notify_t__result__defined)
+-	if (Out0P->NDR.char_rep != NDR_record.char_rep) {
+-#if defined(__NDR_convert__char_rep__Reply__rpc_jack_client_sync_notify_t__result__defined)
+-		__NDR_convert__char_rep__Reply__rpc_jack_client_sync_notify_t__result(&Out0P->result, Out0P->NDR.char_rep);
+-#endif /* __NDR_convert__char_rep__Reply__rpc_jack_client_sync_notify_t__result__defined */
+-	}
+-#endif	/* defined(__NDR_convert__char_rep...) */
+-
+-#if	0 || \
+-	defined(__NDR_convert__float_rep__Reply__rpc_jack_client_sync_notify_t__result__defined)
+-	if (Out0P->NDR.float_rep != NDR_record.float_rep) {
+-#if defined(__NDR_convert__float_rep__Reply__rpc_jack_client_sync_notify_t__result__defined)
+-		__NDR_convert__float_rep__Reply__rpc_jack_client_sync_notify_t__result(&Out0P->result, Out0P->NDR.float_rep);
+-#endif /* __NDR_convert__float_rep__Reply__rpc_jack_client_sync_notify_t__result__defined */
+-	}
+-#endif	/* defined(__NDR_convert__float_rep...) */
+-
+-	return MACH_MSG_SUCCESS;
+-}
+-#endif /* !defined(__MIG_check__Reply__rpc_jack_client_sync_notify_t__defined) */
+-#endif /* __MIG_check__Reply__JackRPCClient_subsystem__ */
+-#endif /* ( __MigTypeCheck || __NDR_convert__ ) */
+-
+-
+-/* Routine rpc_jack_client_sync_notify */
+-mig_external kern_return_t rpc_jack_client_sync_notify
+-(
+-	mach_port_t client_port,
+-	int refnum,
+-	client_name_t client_name,
+-	int notify,
+-	message_t message,
+-	int value1,
+-	int value2,
+-	int *result
+-)
+-{
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		int refnum;
+-		client_name_t client_name;
+-		int notify;
+-		message_t message;
+-		int value1;
+-		int value2;
+-	} Request;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		kern_return_t RetCode;
+-		int result;
+-		mach_msg_trailer_t trailer;
+-	} Reply;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		kern_return_t RetCode;
+-		int result;
+-	} __Reply;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-	/*
+-	 * typedef struct {
+-	 * 	mach_msg_header_t Head;
+-	 * 	NDR_record_t NDR;
+-	 * 	kern_return_t RetCode;
+-	 * } mig_reply_error_t;
+-	 */
+-
+-	union {
+-		Request In;
+-		Reply Out;
+-	} Mess;
+-
+-	Request *InP = &Mess.In;
+-	Reply *Out0P = &Mess.Out;
+-
+-	mach_msg_return_t msg_result;
+-
+-#ifdef	__MIG_check__Reply__rpc_jack_client_sync_notify_t__defined
+-	kern_return_t check_result;
+-#endif	/* __MIG_check__Reply__rpc_jack_client_sync_notify_t__defined */
+-
+-	__DeclareSendRpc(1000, "rpc_jack_client_sync_notify")
+-
+-	InP->NDR = NDR_record;
+-
+-	InP->refnum = refnum;
+-
+-	(void) mig_strncpy(InP->client_name, client_name, 64);
+-
+-	InP->notify = notify;
+-
+-	(void) mig_strncpy(InP->message, message, 256);
+-
+-	InP->value1 = value1;
+-
+-	InP->value2 = value2;
+-
+-	InP->Head.msgh_bits =
+-		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
+-	/* msgh_size passed as argument */
+-	InP->Head.msgh_request_port = client_port;
+-	InP->Head.msgh_reply_port = mig_get_reply_port();
+-	InP->Head.msgh_id = 1000;
+-
+-	__BeforeSendRpc(1000, "rpc_jack_client_sync_notify")
+-	msg_result = mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_SEND_TIMEOUT|MACH_RCV_TIMEOUT|MACH_MSG_OPTION_NONE, (mach_msg_size_t)sizeof(Request), (mach_msg_size_t)sizeof(Reply), InP->Head.msgh_reply_port, 5000, MACH_PORT_NULL);
+-	__AfterSendRpc(1000, "rpc_jack_client_sync_notify")
+-
+-	if (msg_result == MACH_SEND_TIMED_OUT) {
+-	}
+-
+-	if (msg_result != MACH_MSG_SUCCESS) {
+-		__MachMsgErrorWithTimeout(msg_result);
+-		{ return msg_result; }
+-	}
+-
+-
+-#if	defined(__MIG_check__Reply__rpc_jack_client_sync_notify_t__defined)
+-	check_result = __MIG_check__Reply__rpc_jack_client_sync_notify_t((__Reply__rpc_jack_client_sync_notify_t *)Out0P);
+-	if (check_result != MACH_MSG_SUCCESS)
+-		{ return check_result; }
+-#endif	/* defined(__MIG_check__Reply__rpc_jack_client_sync_notify_t__defined) */
+-
+-	*result = Out0P->result;
+-
+-	return KERN_SUCCESS;
+-}
+-
+-/* SimpleRoutine rpc_jack_client_async_notify */
+-mig_external kern_return_t rpc_jack_client_async_notify
+-(
+-	mach_port_t client_port,
+-	int refnum,
+-	client_name_t client_name,
+-	int notify,
+-	message_t message,
+-	int value1,
+-	int value2
+-)
+-{
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		int refnum;
+-		client_name_t client_name;
+-		int notify;
+-		message_t message;
+-		int value1;
+-		int value2;
+-	} Request;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-	/*
+-	 * typedef struct {
+-	 * 	mach_msg_header_t Head;
+-	 * 	NDR_record_t NDR;
+-	 * 	kern_return_t RetCode;
+-	 * } mig_reply_error_t;
+-	 */
+-
+-	union {
+-		Request In;
+-	} Mess;
+-
+-	Request *InP = &Mess.In;
+-
+-	mach_msg_return_t msg_result;
+-
+-#ifdef	__MIG_check__Reply__rpc_jack_client_async_notify_t__defined
+-	kern_return_t check_result;
+-#endif	/* __MIG_check__Reply__rpc_jack_client_async_notify_t__defined */
+-
+-	__DeclareSendSimple(1001, "rpc_jack_client_async_notify")
+-
+-	InP->NDR = NDR_record;
+-
+-	InP->refnum = refnum;
+-
+-	(void) mig_strncpy(InP->client_name, client_name, 64);
+-
+-	InP->notify = notify;
+-
+-	(void) mig_strncpy(InP->message, message, 256);
+-
+-	InP->value1 = value1;
+-
+-	InP->value2 = value2;
+-
+-	InP->Head.msgh_bits =
+-		MACH_MSGH_BITS(19, 0);
+-	/* msgh_size passed as argument */
+-	InP->Head.msgh_request_port = client_port;
+-	InP->Head.msgh_reply_port = MACH_PORT_NULL;
+-	InP->Head.msgh_id = 1001;
+-
+-	__BeforeSendSimple(1001, "rpc_jack_client_async_notify")
+-	msg_result = mach_msg(&InP->Head, MACH_SEND_MSG|MACH_SEND_TIMEOUT|MACH_MSG_OPTION_NONE, (mach_msg_size_t)sizeof(Request), 0, MACH_PORT_NULL, 5000, MACH_PORT_NULL);
+-	__AfterSendSimple(1001, "rpc_jack_client_async_notify")
+-
+-	if (msg_result == MACH_SEND_TIMED_OUT) {
+-	}
+-
+-	return msg_result;
+-}
+--- a/macosx/RPC/JackRPCEngine.defs
++++ /dev/null
+@@ -1,181 +0,0 @@
+-/*
+- 	Copyright (C) 2004 Grame
+-    
+-    This program is free software; you can redistribute it and/or modify
+-    it under the terms of the GNU Lesser General Public License as published by
+-    the Free Software Foundation; either version 2.1 of the License, or
+-    (at your option) any later version.
+-    
+-    This program is distributed in the hope that it will be useful,
+-    but WITHOUT ANY WARRANTY; without even the implied warranty of
+-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+-    GNU Lesser General Public License for more details.
+-    
+-    You should have received a copy of the GNU Lesser General Public License
+-    along with this program; if not, write to the Free Software 
+-    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+-
+-*/
+-
+-subsystem  JackRPCEngine 1000;
+-
+-#include <mach/std_types.defs>
+-#include <mach/mach_types.defs>
+-import "Jackdefs.h";
+-
+-ServerPrefix server_;
+-
+-type client_name_t = c_string[64];
+-type client_port_name_t = c_string[128];
+-type client_port_type_t = c_string[128];
+-type so_name_t = c_string[256];
+-type objet_data_t = c_string[256];
+-
+-routine rpc_jack_client_open(
+-	server_port	: mach_port_t;
+-	client_name	: client_name_t;
+-    	pid         : int;
+-	out private_port : mach_port_make_send_t;
+-	out shared_engine : int;
+-	out shared_client : int;
+-	out shared_graph : int;
+-	out result : int);
+-
+-routine rpc_jack_client_check(
+-	server_port	: mach_port_t;
+-	client_name	: client_name_t;
+-	out client_name_res	: client_name_t;
+-	protocol	: int;
+-	options		: int;
+-	out status	: int;
+-	out result : int);
+-
+-routine  rpc_jack_client_close(
+-	server_port	: mach_port_t;
+-	refnum		: int;
+-	out result 	: int);
+-    
+-routine  rpc_jack_client_activate(
+-	server_port	: mach_port_t;
+-	refnum		: int;
+-    	state		: int;
+-	out result 	: int);
+-
+-routine  rpc_jack_client_deactivate(
+-	server_port	: mach_port_t;
+-	refnum		: int;
+-	out result 	: int);
+-
+-routine rpc_jack_port_register(
+-	server_port	: mach_port_t;
+-	refnum		: int;
+-	name		: client_port_name_t;
+-	port_type	: client_port_type_t;
+-	flags		: unsigned;
+-	buffer_size : unsigned;
+-	out port_index : unsigned;
+-	out result 	: int);
+-	
+-routine rpc_jack_port_unregister(
+-	server_port	: mach_port_t;
+-	refnum		: int;
+-	port		: int;
+-	out result 	: int);	
+-	
+-routine rpc_jack_port_connect(
+-	server_port	: mach_port_t;
+-	refnum		: int;
+-	src         	: int;
+-	dst         	: int;
+-	out result 	: int);
+-	
+-routine rpc_jack_port_disconnect(
+-	server_port	: mach_port_t;
+-	refnum		: int;
+-	src         	: int;
+-	dst         	: int;
+-	out result 	: int);
+-    
+-routine rpc_jack_port_connect_name(
+-	server_port	: mach_port_t;
+-	refnum		: int;
+-	src         	: client_port_name_t;
+-	dst         	: client_port_name_t;
+-	out result 	: int);
+-	
+-routine rpc_jack_port_disconnect_name(
+-	server_port	: mach_port_t;
+-	refnum		: int;
+-	src         	: client_port_name_t;
+-	dst         	: client_port_name_t;
+-	out result 	: int);
+-	
+-routine rpc_jack_port_rename(
+-	server_port	: mach_port_t;
+-	refnum		: int;
+-	src         	: int;
+-	name        	: client_port_name_t;
+-	out result 	: int);
+-
+-routine rpc_jack_set_buffer_size(
+-	server_port	: mach_port_t;
+-	buffer_size 	: int;
+-	out result 	: int);
+-	
+-routine rpc_jack_set_freewheel(
+-	server_port	: mach_port_t;
+-	onoff		: int;
+-	out result 	: int);
+-
+-routine rpc_jack_release_timebase(
+-	server_port	: mach_port_t;
+-	refnum		: int;
+-	out result 	: int);
+-	
+-routine rpc_jack_set_timebase_callback(
+-	server_port	: mach_port_t;
+-	refnum		: int;
+-	conditional	: int;
+-	out result 	: int);
+-	
+-routine rpc_jack_get_internal_clientname(
+-	server_port	: mach_port_t;
+-	refnum		: int;
+-	int_ref		: int;
+-	out client_name_res	: client_name_t;
+-	out result 	: int);
+-	
+-routine rpc_jack_internal_clienthandle(
+-	server_port	: mach_port_t;
+-	refnum		: int;
+-	client_name	: client_name_t;
+-	out int_ref 	: int;
+-	out status	: int;
+-	out result 	: int);
+-	
+-routine rpc_jack_internal_clientload(
+-	server_port	: mach_port_t;
+-	refnum		: int;
+-	client_name	: client_name_t;
+-	so_name		: so_name_t;
+-	objet_data	: objet_data_t;
+-	options		: int;
+-	out status	: int;
+-	out int_ref 	: int;
+-	out result	: int);
+-	
+-routine rpc_jack_internal_clientunload(
+-	server_port	: mach_port_t;
+-	refnum		: int;
+-	int_ref		: int;
+-	out status	: int;
+-	out result 	: int);
+-
+-simpleroutine rpc_jack_client_rt_notify(
+-	client_port	: mach_port_t;
+-	refnum		: int;
+-	notify		: int;
+-    	value		: int;
+-	waittime timeout : int);
+-
+-	
+--- a/macosx/RPC/JackRPCEngine.h
++++ /dev/null
+@@ -1,1040 +0,0 @@
+-#ifndef	_JackRPCEngine_user_
+-#define	_JackRPCEngine_user_
+-
+-/* Module JackRPCEngine */
+-
+-#include <string.h>
+-#include <mach/ndr.h>
+-#include <mach/boolean.h>
+-#include <mach/kern_return.h>
+-#include <mach/notify.h>
+-#include <mach/mach_types.h>
+-#include <mach/message.h>
+-#include <mach/mig_errors.h>
+-#include <mach/port.h>
+-
+-#ifdef AUTOTEST
+-#ifndef FUNCTION_PTR_T
+-#define FUNCTION_PTR_T
+-typedef void (*function_ptr_t)(mach_port_t, char *, mach_msg_type_number_t);
+-typedef struct {
+-        char            *name;
+-        function_ptr_t  function;
+-} function_table_entry;
+-typedef function_table_entry   *function_table_t;
+-#endif /* FUNCTION_PTR_T */
+-#endif /* AUTOTEST */
+-
+-#ifndef	JackRPCEngine_MSG_COUNT
+-#define	JackRPCEngine_MSG_COUNT	21
+-#endif	/* JackRPCEngine_MSG_COUNT */
+-
+-#include <mach/std_types.h>
+-#include <mach/mig.h>
+-#include <mach/mig.h>
+-#include <mach/mach_types.h>
+-#include "Jackdefs.h"
+-
+-#ifdef __BeforeMigUserHeader
+-__BeforeMigUserHeader
+-#endif /* __BeforeMigUserHeader */
+-
+-#include <sys/cdefs.h>
+-__BEGIN_DECLS
+-
+-
+-/* Routine rpc_jack_client_open */
+-#ifdef	mig_external
+-mig_external
+-#else
+-extern
+-#endif	/* mig_external */
+-kern_return_t rpc_jack_client_open
+-(
+-	mach_port_t server_port,
+-	client_name_t client_name,
+-	int pid,
+-	mach_port_t *private_port,
+-	int *shared_engine,
+-	int *shared_client,
+-	int *shared_graph,
+-	int *result
+-);
+-
+-/* Routine rpc_jack_client_check */
+-#ifdef	mig_external
+-mig_external
+-#else
+-extern
+-#endif	/* mig_external */
+-kern_return_t rpc_jack_client_check
+-(
+-	mach_port_t server_port,
+-	client_name_t client_name,
+-	client_name_t client_name_res,
+-	int protocol,
+-	int options,
+-	int *status,
+-	int *result
+-);
+-
+-/* Routine rpc_jack_client_close */
+-#ifdef	mig_external
+-mig_external
+-#else
+-extern
+-#endif	/* mig_external */
+-kern_return_t rpc_jack_client_close
+-(
+-	mach_port_t server_port,
+-	int refnum,
+-	int *result
+-);
+-
+-/* Routine rpc_jack_client_activate */
+-#ifdef	mig_external
+-mig_external
+-#else
+-extern
+-#endif	/* mig_external */
+-kern_return_t rpc_jack_client_activate
+-(
+-	mach_port_t server_port,
+-	int refnum,
+-	int state,
+-	int *result
+-);
+-
+-/* Routine rpc_jack_client_deactivate */
+-#ifdef	mig_external
+-mig_external
+-#else
+-extern
+-#endif	/* mig_external */
+-kern_return_t rpc_jack_client_deactivate
+-(
+-	mach_port_t server_port,
+-	int refnum,
+-	int *result
+-);
+-
+-/* Routine rpc_jack_port_register */
+-#ifdef	mig_external
+-mig_external
+-#else
+-extern
+-#endif	/* mig_external */
+-kern_return_t rpc_jack_port_register
+-(
+-	mach_port_t server_port,
+-	int refnum,
+-	client_port_name_t name,
+-	client_port_type_t port_type,
+-	unsigned flags,
+-	unsigned buffer_size,
+-	unsigned *port_index,
+-	int *result
+-);
+-
+-/* Routine rpc_jack_port_unregister */
+-#ifdef	mig_external
+-mig_external
+-#else
+-extern
+-#endif	/* mig_external */
+-kern_return_t rpc_jack_port_unregister
+-(
+-	mach_port_t server_port,
+-	int refnum,
+-	int port,
+-	int *result
+-);
+-
+-/* Routine rpc_jack_port_connect */
+-#ifdef	mig_external
+-mig_external
+-#else
+-extern
+-#endif	/* mig_external */
+-kern_return_t rpc_jack_port_connect
+-(
+-	mach_port_t server_port,
+-	int refnum,
+-	int src,
+-	int dst,
+-	int *result
+-);
+-
+-/* Routine rpc_jack_port_disconnect */
+-#ifdef	mig_external
+-mig_external
+-#else
+-extern
+-#endif	/* mig_external */
+-kern_return_t rpc_jack_port_disconnect
+-(
+-	mach_port_t server_port,
+-	int refnum,
+-	int src,
+-	int dst,
+-	int *result
+-);
+-
+-/* Routine rpc_jack_port_connect_name */
+-#ifdef	mig_external
+-mig_external
+-#else
+-extern
+-#endif	/* mig_external */
+-kern_return_t rpc_jack_port_connect_name
+-(
+-	mach_port_t server_port,
+-	int refnum,
+-	client_port_name_t src,
+-	client_port_name_t dst,
+-	int *result
+-);
+-
+-/* Routine rpc_jack_port_disconnect_name */
+-#ifdef	mig_external
+-mig_external
+-#else
+-extern
+-#endif	/* mig_external */
+-kern_return_t rpc_jack_port_disconnect_name
+-(
+-	mach_port_t server_port,
+-	int refnum,
+-	client_port_name_t src,
+-	client_port_name_t dst,
+-	int *result
+-);
+-
+-/* Routine rpc_jack_port_rename */
+-#ifdef	mig_external
+-mig_external
+-#else
+-extern
+-#endif	/* mig_external */
+-kern_return_t rpc_jack_port_rename
+-(
+-	mach_port_t server_port,
+-	int refnum,
+-	int src,
+-	client_port_name_t name,
+-	int *result
+-);
+-
+-/* Routine rpc_jack_set_buffer_size */
+-#ifdef	mig_external
+-mig_external
+-#else
+-extern
+-#endif	/* mig_external */
+-kern_return_t rpc_jack_set_buffer_size
+-(
+-	mach_port_t server_port,
+-	int buffer_size,
+-	int *result
+-);
+-
+-/* Routine rpc_jack_set_freewheel */
+-#ifdef	mig_external
+-mig_external
+-#else
+-extern
+-#endif	/* mig_external */
+-kern_return_t rpc_jack_set_freewheel
+-(
+-	mach_port_t server_port,
+-	int onoff,
+-	int *result
+-);
+-
+-/* Routine rpc_jack_release_timebase */
+-#ifdef	mig_external
+-mig_external
+-#else
+-extern
+-#endif	/* mig_external */
+-kern_return_t rpc_jack_release_timebase
+-(
+-	mach_port_t server_port,
+-	int refnum,
+-	int *result
+-);
+-
+-/* Routine rpc_jack_set_timebase_callback */
+-#ifdef	mig_external
+-mig_external
+-#else
+-extern
+-#endif	/* mig_external */
+-kern_return_t rpc_jack_set_timebase_callback
+-(
+-	mach_port_t server_port,
+-	int refnum,
+-	int conditional,
+-	int *result
+-);
+-
+-/* Routine rpc_jack_get_internal_clientname */
+-#ifdef	mig_external
+-mig_external
+-#else
+-extern
+-#endif	/* mig_external */
+-kern_return_t rpc_jack_get_internal_clientname
+-(
+-	mach_port_t server_port,
+-	int refnum,
+-	int int_ref,
+-	client_name_t client_name_res,
+-	int *result
+-);
+-
+-/* Routine rpc_jack_internal_clienthandle */
+-#ifdef	mig_external
+-mig_external
+-#else
+-extern
+-#endif	/* mig_external */
+-kern_return_t rpc_jack_internal_clienthandle
+-(
+-	mach_port_t server_port,
+-	int refnum,
+-	client_name_t client_name,
+-	int *int_ref,
+-	int *status,
+-	int *result
+-);
+-
+-/* Routine rpc_jack_internal_clientload */
+-#ifdef	mig_external
+-mig_external
+-#else
+-extern
+-#endif	/* mig_external */
+-kern_return_t rpc_jack_internal_clientload
+-(
+-	mach_port_t server_port,
+-	int refnum,
+-	client_name_t client_name,
+-	so_name_t so_name,
+-	objet_data_t objet_data,
+-	int options,
+-	int *status,
+-	int *int_ref,
+-	int *result
+-);
+-
+-/* Routine rpc_jack_internal_clientunload */
+-#ifdef	mig_external
+-mig_external
+-#else
+-extern
+-#endif	/* mig_external */
+-kern_return_t rpc_jack_internal_clientunload
+-(
+-	mach_port_t server_port,
+-	int refnum,
+-	int int_ref,
+-	int *status,
+-	int *result
+-);
+-
+-/* SimpleRoutine rpc_jack_client_rt_notify */
+-#ifdef	mig_external
+-mig_external
+-#else
+-extern
+-#endif	/* mig_external */
+-kern_return_t rpc_jack_client_rt_notify
+-(
+-	mach_port_t client_port,
+-	int refnum,
+-	int notify,
+-	int value,
+-	int timeout
+-);
+-
+-__END_DECLS
+-
+-/********************** Caution **************************/
+-/* The following data types should be used to calculate  */
+-/* maximum message sizes only. The actual message may be */
+-/* smaller, and the position of the arguments within the */
+-/* message layout may vary from what is presented here.  */
+-/* For example, if any of the arguments are variable-    */
+-/* sized, and less than the maximum is sent, the data    */
+-/* will be packed tight in the actual message to reduce  */
+-/* the presence of holes.                                */
+-/********************** Caution **************************/
+-
+-/* typedefs for all requests */
+-
+-#ifndef __Request__JackRPCEngine_subsystem__defined
+-#define __Request__JackRPCEngine_subsystem__defined
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		client_name_t client_name;
+-		int pid;
+-	} __Request__rpc_jack_client_open_t;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		client_name_t client_name;
+-		int protocol;
+-		int options;
+-	} __Request__rpc_jack_client_check_t;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		int refnum;
+-	} __Request__rpc_jack_client_close_t;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		int refnum;
+-		int state;
+-	} __Request__rpc_jack_client_activate_t;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		int refnum;
+-	} __Request__rpc_jack_client_deactivate_t;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		int refnum;
+-		client_port_name_t name;
+-		client_port_type_t port_type;
+-		unsigned flags;
+-		unsigned buffer_size;
+-	} __Request__rpc_jack_port_register_t;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		int refnum;
+-		int port;
+-	} __Request__rpc_jack_port_unregister_t;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		int refnum;
+-		int src;
+-		int dst;
+-	} __Request__rpc_jack_port_connect_t;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		int refnum;
+-		int src;
+-		int dst;
+-	} __Request__rpc_jack_port_disconnect_t;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		int refnum;
+-		client_port_name_t src;
+-		client_port_name_t dst;
+-	} __Request__rpc_jack_port_connect_name_t;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		int refnum;
+-		client_port_name_t src;
+-		client_port_name_t dst;
+-	} __Request__rpc_jack_port_disconnect_name_t;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		int refnum;
+-		int src;
+-		client_port_name_t name;
+-	} __Request__rpc_jack_port_rename_t;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		int buffer_size;
+-	} __Request__rpc_jack_set_buffer_size_t;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		int onoff;
+-	} __Request__rpc_jack_set_freewheel_t;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		int refnum;
+-	} __Request__rpc_jack_release_timebase_t;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		int refnum;
+-		int conditional;
+-	} __Request__rpc_jack_set_timebase_callback_t;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		int refnum;
+-		int int_ref;
+-	} __Request__rpc_jack_get_internal_clientname_t;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		int refnum;
+-		client_name_t client_name;
+-	} __Request__rpc_jack_internal_clienthandle_t;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		int refnum;
+-		client_name_t client_name;
+-		so_name_t so_name;
+-		objet_data_t objet_data;
+-		int options;
+-	} __Request__rpc_jack_internal_clientload_t;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		int refnum;
+-		int int_ref;
+-	} __Request__rpc_jack_internal_clientunload_t;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		int refnum;
+-		int notify;
+-		int value;
+-	} __Request__rpc_jack_client_rt_notify_t;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-#endif /* !__Request__JackRPCEngine_subsystem__defined */
+-
+-/* union of all requests */
+-
+-#ifndef __RequestUnion__JackRPCEngine_subsystem__defined
+-#define __RequestUnion__JackRPCEngine_subsystem__defined
+-union __RequestUnion__JackRPCEngine_subsystem {
+-	__Request__rpc_jack_client_open_t Request_rpc_jack_client_open;
+-	__Request__rpc_jack_client_check_t Request_rpc_jack_client_check;
+-	__Request__rpc_jack_client_close_t Request_rpc_jack_client_close;
+-	__Request__rpc_jack_client_activate_t Request_rpc_jack_client_activate;
+-	__Request__rpc_jack_client_deactivate_t Request_rpc_jack_client_deactivate;
+-	__Request__rpc_jack_port_register_t Request_rpc_jack_port_register;
+-	__Request__rpc_jack_port_unregister_t Request_rpc_jack_port_unregister;
+-	__Request__rpc_jack_port_connect_t Request_rpc_jack_port_connect;
+-	__Request__rpc_jack_port_disconnect_t Request_rpc_jack_port_disconnect;
+-	__Request__rpc_jack_port_connect_name_t Request_rpc_jack_port_connect_name;
+-	__Request__rpc_jack_port_disconnect_name_t Request_rpc_jack_port_disconnect_name;
+-	__Request__rpc_jack_port_rename_t Request_rpc_jack_port_rename;
+-	__Request__rpc_jack_set_buffer_size_t Request_rpc_jack_set_buffer_size;
+-	__Request__rpc_jack_set_freewheel_t Request_rpc_jack_set_freewheel;
+-	__Request__rpc_jack_release_timebase_t Request_rpc_jack_release_timebase;
+-	__Request__rpc_jack_set_timebase_callback_t Request_rpc_jack_set_timebase_callback;
+-	__Request__rpc_jack_get_internal_clientname_t Request_rpc_jack_get_internal_clientname;
+-	__Request__rpc_jack_internal_clienthandle_t Request_rpc_jack_internal_clienthandle;
+-	__Request__rpc_jack_internal_clientload_t Request_rpc_jack_internal_clientload;
+-	__Request__rpc_jack_internal_clientunload_t Request_rpc_jack_internal_clientunload;
+-	__Request__rpc_jack_client_rt_notify_t Request_rpc_jack_client_rt_notify;
+-};
+-#endif /* !__RequestUnion__JackRPCEngine_subsystem__defined */
+-/* typedefs for all replies */
+-
+-#ifndef __Reply__JackRPCEngine_subsystem__defined
+-#define __Reply__JackRPCEngine_subsystem__defined
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		/* start of the kernel processed data */
+-		mach_msg_body_t msgh_body;
+-		mach_msg_port_descriptor_t private_port;
+-		/* end of the kernel processed data */
+-		NDR_record_t NDR;
+-		int shared_engine;
+-		int shared_client;
+-		int shared_graph;
+-		int result;
+-	} __Reply__rpc_jack_client_open_t;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		kern_return_t RetCode;
+-		client_name_t client_name_res;
+-		int status;
+-		int result;
+-	} __Reply__rpc_jack_client_check_t;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		kern_return_t RetCode;
+-		int result;
+-	} __Reply__rpc_jack_client_close_t;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		kern_return_t RetCode;
+-		int result;
+-	} __Reply__rpc_jack_client_activate_t;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		kern_return_t RetCode;
+-		int result;
+-	} __Reply__rpc_jack_client_deactivate_t;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		kern_return_t RetCode;
+-		unsigned port_index;
+-		int result;
+-	} __Reply__rpc_jack_port_register_t;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		kern_return_t RetCode;
+-		int result;
+-	} __Reply__rpc_jack_port_unregister_t;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		kern_return_t RetCode;
+-		int result;
+-	} __Reply__rpc_jack_port_connect_t;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		kern_return_t RetCode;
+-		int result;
+-	} __Reply__rpc_jack_port_disconnect_t;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		kern_return_t RetCode;
+-		int result;
+-	} __Reply__rpc_jack_port_connect_name_t;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		kern_return_t RetCode;
+-		int result;
+-	} __Reply__rpc_jack_port_disconnect_name_t;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		kern_return_t RetCode;
+-		int result;
+-	} __Reply__rpc_jack_port_rename_t;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		kern_return_t RetCode;
+-		int result;
+-	} __Reply__rpc_jack_set_buffer_size_t;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		kern_return_t RetCode;
+-		int result;
+-	} __Reply__rpc_jack_set_freewheel_t;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		kern_return_t RetCode;
+-		int result;
+-	} __Reply__rpc_jack_release_timebase_t;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		kern_return_t RetCode;
+-		int result;
+-	} __Reply__rpc_jack_set_timebase_callback_t;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		kern_return_t RetCode;
+-		client_name_t client_name_res;
+-		int result;
+-	} __Reply__rpc_jack_get_internal_clientname_t;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		kern_return_t RetCode;
+-		int int_ref;
+-		int status;
+-		int result;
+-	} __Reply__rpc_jack_internal_clienthandle_t;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		kern_return_t RetCode;
+-		int status;
+-		int int_ref;
+-		int result;
+-	} __Reply__rpc_jack_internal_clientload_t;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		kern_return_t RetCode;
+-		int status;
+-		int result;
+-	} __Reply__rpc_jack_internal_clientunload_t;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		kern_return_t RetCode;
+-	} __Reply__rpc_jack_client_rt_notify_t;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-#endif /* !__Reply__JackRPCEngine_subsystem__defined */
+-
+-/* union of all replies */
+-
+-#ifndef __ReplyUnion__JackRPCEngine_subsystem__defined
+-#define __ReplyUnion__JackRPCEngine_subsystem__defined
+-union __ReplyUnion__JackRPCEngine_subsystem {
+-	__Reply__rpc_jack_client_open_t Reply_rpc_jack_client_open;
+-	__Reply__rpc_jack_client_check_t Reply_rpc_jack_client_check;
+-	__Reply__rpc_jack_client_close_t Reply_rpc_jack_client_close;
+-	__Reply__rpc_jack_client_activate_t Reply_rpc_jack_client_activate;
+-	__Reply__rpc_jack_client_deactivate_t Reply_rpc_jack_client_deactivate;
+-	__Reply__rpc_jack_port_register_t Reply_rpc_jack_port_register;
+-	__Reply__rpc_jack_port_unregister_t Reply_rpc_jack_port_unregister;
+-	__Reply__rpc_jack_port_connect_t Reply_rpc_jack_port_connect;
+-	__Reply__rpc_jack_port_disconnect_t Reply_rpc_jack_port_disconnect;
+-	__Reply__rpc_jack_port_connect_name_t Reply_rpc_jack_port_connect_name;
+-	__Reply__rpc_jack_port_disconnect_name_t Reply_rpc_jack_port_disconnect_name;
+-	__Reply__rpc_jack_port_rename_t Reply_rpc_jack_port_rename;
+-	__Reply__rpc_jack_set_buffer_size_t Reply_rpc_jack_set_buffer_size;
+-	__Reply__rpc_jack_set_freewheel_t Reply_rpc_jack_set_freewheel;
+-	__Reply__rpc_jack_release_timebase_t Reply_rpc_jack_release_timebase;
+-	__Reply__rpc_jack_set_timebase_callback_t Reply_rpc_jack_set_timebase_callback;
+-	__Reply__rpc_jack_get_internal_clientname_t Reply_rpc_jack_get_internal_clientname;
+-	__Reply__rpc_jack_internal_clienthandle_t Reply_rpc_jack_internal_clienthandle;
+-	__Reply__rpc_jack_internal_clientload_t Reply_rpc_jack_internal_clientload;
+-	__Reply__rpc_jack_internal_clientunload_t Reply_rpc_jack_internal_clientunload;
+-	__Reply__rpc_jack_client_rt_notify_t Reply_rpc_jack_client_rt_notify;
+-};
+-#endif /* !__RequestUnion__JackRPCEngine_subsystem__defined */
+-
+-#ifndef subsystem_to_name_map_JackRPCEngine
+-#define subsystem_to_name_map_JackRPCEngine \
+-    { "rpc_jack_client_open", 1000 },\
+-    { "rpc_jack_client_check", 1001 },\
+-    { "rpc_jack_client_close", 1002 },\
+-    { "rpc_jack_client_activate", 1003 },\
+-    { "rpc_jack_client_deactivate", 1004 },\
+-    { "rpc_jack_port_register", 1005 },\
+-    { "rpc_jack_port_unregister", 1006 },\
+-    { "rpc_jack_port_connect", 1007 },\
+-    { "rpc_jack_port_disconnect", 1008 },\
+-    { "rpc_jack_port_connect_name", 1009 },\
+-    { "rpc_jack_port_disconnect_name", 1010 },\
+-    { "rpc_jack_port_rename", 1011 },\
+-    { "rpc_jack_set_buffer_size", 1012 },\
+-    { "rpc_jack_set_freewheel", 1013 },\
+-    { "rpc_jack_release_timebase", 1014 },\
+-    { "rpc_jack_set_timebase_callback", 1015 },\
+-    { "rpc_jack_get_internal_clientname", 1016 },\
+-    { "rpc_jack_internal_clienthandle", 1017 },\
+-    { "rpc_jack_internal_clientload", 1018 },\
+-    { "rpc_jack_internal_clientunload", 1019 },\
+-    { "rpc_jack_client_rt_notify", 1020 }
+-#endif
+-
+-#ifdef __AfterMigUserHeader
+-__AfterMigUserHeader
+-#endif /* __AfterMigUserHeader */
+-
+-#endif	 /* _JackRPCEngine_user_ */
+--- a/macosx/RPC/JackRPCEngineServer.c
++++ /dev/null
+@@ -1,6817 +0,0 @@
+-/*
+- * IDENTIFICATION:
+- * stub generated Fri Oct 23 10:35:08 2009
+- * with a MiG generated Mon May 18 09:59:33 PDT 2009 by root at sulitlana.apple.com
+- * OPTIONS: 
+- */
+-
+-/* Module JackRPCEngine */
+-
+-#define	__MIG_check__Request__JackRPCEngine_subsystem__ 1
+-#define	__NDR_convert__Request__JackRPCEngine_subsystem__ 1
+-
+-#include <string.h>
+-#include <mach/ndr.h>
+-#include <mach/boolean.h>
+-#include <mach/kern_return.h>
+-#include <mach/notify.h>
+-#include <mach/mach_types.h>
+-#include <mach/message.h>
+-#include <mach/mig_errors.h>
+-#include <mach/port.h>
+-
+-#include <mach/std_types.h>
+-#include <mach/mig.h>
+-#include <mach/mig.h>
+-#include <mach/mach_types.h>
+-#include "Jackdefs.h"
+-
+-#ifndef	mig_internal
+-#define	mig_internal	static __inline__
+-#endif	/* mig_internal */
+-
+-#ifndef	mig_external
+-#define mig_external
+-#endif	/* mig_external */
+-
+-#if	!defined(__MigTypeCheck) && defined(TypeCheck)
+-#define	__MigTypeCheck		TypeCheck	/* Legacy setting */
+-#endif	/* !defined(__MigTypeCheck) */
+-
+-#if	!defined(__MigKernelSpecificCode) && defined(_MIG_KERNEL_SPECIFIC_CODE_)
+-#define	__MigKernelSpecificCode	_MIG_KERNEL_SPECIFIC_CODE_	/* Legacy setting */
+-#endif	/* !defined(__MigKernelSpecificCode) */
+-
+-#ifndef	LimitCheck
+-#define	LimitCheck 0
+-#endif	/* LimitCheck */
+-
+-#ifndef	min
+-#define	min(a,b)  ( ((a) < (b))? (a): (b) )
+-#endif	/* min */
+-
+-#if !defined(_WALIGN_)
+-#define _WALIGN_(x) (((x) + 3) & ~3)
+-#endif /* !defined(_WALIGN_) */
+-
+-#if !defined(_WALIGNSZ_)
+-#define _WALIGNSZ_(x) _WALIGN_(sizeof(x))
+-#endif /* !defined(_WALIGNSZ_) */
+-
+-#ifndef	UseStaticTemplates
+-#define	UseStaticTemplates	0
+-#endif	/* UseStaticTemplates */
+-
+-#ifndef	__DeclareRcvRpc
+-#define	__DeclareRcvRpc(_NUM_, _NAME_)
+-#endif	/* __DeclareRcvRpc */
+-
+-#ifndef	__BeforeRcvRpc
+-#define	__BeforeRcvRpc(_NUM_, _NAME_)
+-#endif	/* __BeforeRcvRpc */
+-
+-#ifndef	__AfterRcvRpc
+-#define	__AfterRcvRpc(_NUM_, _NAME_)
+-#endif	/* __AfterRcvRpc */
+-
+-#ifndef	__DeclareRcvSimple
+-#define	__DeclareRcvSimple(_NUM_, _NAME_)
+-#endif	/* __DeclareRcvSimple */
+-
+-#ifndef	__BeforeRcvSimple
+-#define	__BeforeRcvSimple(_NUM_, _NAME_)
+-#endif	/* __BeforeRcvSimple */
+-
+-#ifndef	__AfterRcvSimple
+-#define	__AfterRcvSimple(_NUM_, _NAME_)
+-#endif	/* __AfterRcvSimple */
+-
+-#define novalue void
+-
+-#define msgh_request_port	msgh_local_port
+-#define MACH_MSGH_BITS_REQUEST(bits)	MACH_MSGH_BITS_LOCAL(bits)
+-#define msgh_reply_port		msgh_remote_port
+-#define MACH_MSGH_BITS_REPLY(bits)	MACH_MSGH_BITS_REMOTE(bits)
+-
+-#define MIG_RETURN_ERROR(X, code)	{\
+-				((mig_reply_error_t *)X)->RetCode = code;\
+-				((mig_reply_error_t *)X)->NDR = NDR_record;\
+-				return;\
+-				}
+-
+-/* typedefs for all requests */
+-
+-#ifndef __Request__JackRPCEngine_subsystem__defined
+-#define __Request__JackRPCEngine_subsystem__defined
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		client_name_t client_name;
+-		int pid;
+-	} __Request__rpc_jack_client_open_t;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		client_name_t client_name;
+-		int protocol;
+-		int options;
+-	} __Request__rpc_jack_client_check_t;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		int refnum;
+-	} __Request__rpc_jack_client_close_t;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		int refnum;
+-		int state;
+-	} __Request__rpc_jack_client_activate_t;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		int refnum;
+-	} __Request__rpc_jack_client_deactivate_t;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		int refnum;
+-		client_port_name_t name;
+-		client_port_type_t port_type;
+-		unsigned flags;
+-		unsigned buffer_size;
+-	} __Request__rpc_jack_port_register_t;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		int refnum;
+-		int port;
+-	} __Request__rpc_jack_port_unregister_t;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		int refnum;
+-		int src;
+-		int dst;
+-	} __Request__rpc_jack_port_connect_t;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		int refnum;
+-		int src;
+-		int dst;
+-	} __Request__rpc_jack_port_disconnect_t;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		int refnum;
+-		client_port_name_t src;
+-		client_port_name_t dst;
+-	} __Request__rpc_jack_port_connect_name_t;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		int refnum;
+-		client_port_name_t src;
+-		client_port_name_t dst;
+-	} __Request__rpc_jack_port_disconnect_name_t;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		int refnum;
+-		int src;
+-		client_port_name_t name;
+-	} __Request__rpc_jack_port_rename_t;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		int buffer_size;
+-	} __Request__rpc_jack_set_buffer_size_t;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		int onoff;
+-	} __Request__rpc_jack_set_freewheel_t;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		int refnum;
+-	} __Request__rpc_jack_release_timebase_t;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		int refnum;
+-		int conditional;
+-	} __Request__rpc_jack_set_timebase_callback_t;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		int refnum;
+-		int int_ref;
+-	} __Request__rpc_jack_get_internal_clientname_t;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		int refnum;
+-		client_name_t client_name;
+-	} __Request__rpc_jack_internal_clienthandle_t;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		int refnum;
+-		client_name_t client_name;
+-		so_name_t so_name;
+-		objet_data_t objet_data;
+-		int options;
+-	} __Request__rpc_jack_internal_clientload_t;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		int refnum;
+-		int int_ref;
+-	} __Request__rpc_jack_internal_clientunload_t;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		int refnum;
+-		int notify;
+-		int value;
+-	} __Request__rpc_jack_client_rt_notify_t;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-#endif /* !__Request__JackRPCEngine_subsystem__defined */
+-
+-/* typedefs for all replies */
+-
+-#ifndef __Reply__JackRPCEngine_subsystem__defined
+-#define __Reply__JackRPCEngine_subsystem__defined
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		/* start of the kernel processed data */
+-		mach_msg_body_t msgh_body;
+-		mach_msg_port_descriptor_t private_port;
+-		/* end of the kernel processed data */
+-		NDR_record_t NDR;
+-		int shared_engine;
+-		int shared_client;
+-		int shared_graph;
+-		int result;
+-	} __Reply__rpc_jack_client_open_t;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		kern_return_t RetCode;
+-		client_name_t client_name_res;
+-		int status;
+-		int result;
+-	} __Reply__rpc_jack_client_check_t;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		kern_return_t RetCode;
+-		int result;
+-	} __Reply__rpc_jack_client_close_t;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		kern_return_t RetCode;
+-		int result;
+-	} __Reply__rpc_jack_client_activate_t;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		kern_return_t RetCode;
+-		int result;
+-	} __Reply__rpc_jack_client_deactivate_t;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		kern_return_t RetCode;
+-		unsigned port_index;
+-		int result;
+-	} __Reply__rpc_jack_port_register_t;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		kern_return_t RetCode;
+-		int result;
+-	} __Reply__rpc_jack_port_unregister_t;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		kern_return_t RetCode;
+-		int result;
+-	} __Reply__rpc_jack_port_connect_t;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		kern_return_t RetCode;
+-		int result;
+-	} __Reply__rpc_jack_port_disconnect_t;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		kern_return_t RetCode;
+-		int result;
+-	} __Reply__rpc_jack_port_connect_name_t;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		kern_return_t RetCode;
+-		int result;
+-	} __Reply__rpc_jack_port_disconnect_name_t;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		kern_return_t RetCode;
+-		int result;
+-	} __Reply__rpc_jack_port_rename_t;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		kern_return_t RetCode;
+-		int result;
+-	} __Reply__rpc_jack_set_buffer_size_t;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		kern_return_t RetCode;
+-		int result;
+-	} __Reply__rpc_jack_set_freewheel_t;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		kern_return_t RetCode;
+-		int result;
+-	} __Reply__rpc_jack_release_timebase_t;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		kern_return_t RetCode;
+-		int result;
+-	} __Reply__rpc_jack_set_timebase_callback_t;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		kern_return_t RetCode;
+-		client_name_t client_name_res;
+-		int result;
+-	} __Reply__rpc_jack_get_internal_clientname_t;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		kern_return_t RetCode;
+-		int int_ref;
+-		int status;
+-		int result;
+-	} __Reply__rpc_jack_internal_clienthandle_t;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		kern_return_t RetCode;
+-		int status;
+-		int int_ref;
+-		int result;
+-	} __Reply__rpc_jack_internal_clientload_t;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		kern_return_t RetCode;
+-		int status;
+-		int result;
+-	} __Reply__rpc_jack_internal_clientunload_t;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		kern_return_t RetCode;
+-	} __Reply__rpc_jack_client_rt_notify_t;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-#endif /* !__Reply__JackRPCEngine_subsystem__defined */
+-
+-
+-/* union of all replies */
+-
+-#ifndef __ReplyUnion__server_JackRPCEngine_subsystem__defined
+-#define __ReplyUnion__server_JackRPCEngine_subsystem__defined
+-union __ReplyUnion__server_JackRPCEngine_subsystem {
+-	__Reply__rpc_jack_client_open_t Reply_rpc_jack_client_open;
+-	__Reply__rpc_jack_client_check_t Reply_rpc_jack_client_check;
+-	__Reply__rpc_jack_client_close_t Reply_rpc_jack_client_close;
+-	__Reply__rpc_jack_client_activate_t Reply_rpc_jack_client_activate;
+-	__Reply__rpc_jack_client_deactivate_t Reply_rpc_jack_client_deactivate;
+-	__Reply__rpc_jack_port_register_t Reply_rpc_jack_port_register;
+-	__Reply__rpc_jack_port_unregister_t Reply_rpc_jack_port_unregister;
+-	__Reply__rpc_jack_port_connect_t Reply_rpc_jack_port_connect;
+-	__Reply__rpc_jack_port_disconnect_t Reply_rpc_jack_port_disconnect;
+-	__Reply__rpc_jack_port_connect_name_t Reply_rpc_jack_port_connect_name;
+-	__Reply__rpc_jack_port_disconnect_name_t Reply_rpc_jack_port_disconnect_name;
+-	__Reply__rpc_jack_port_rename_t Reply_rpc_jack_port_rename;
+-	__Reply__rpc_jack_set_buffer_size_t Reply_rpc_jack_set_buffer_size;
+-	__Reply__rpc_jack_set_freewheel_t Reply_rpc_jack_set_freewheel;
+-	__Reply__rpc_jack_release_timebase_t Reply_rpc_jack_release_timebase;
+-	__Reply__rpc_jack_set_timebase_callback_t Reply_rpc_jack_set_timebase_callback;
+-	__Reply__rpc_jack_get_internal_clientname_t Reply_rpc_jack_get_internal_clientname;
+-	__Reply__rpc_jack_internal_clienthandle_t Reply_rpc_jack_internal_clienthandle;
+-	__Reply__rpc_jack_internal_clientload_t Reply_rpc_jack_internal_clientload;
+-	__Reply__rpc_jack_internal_clientunload_t Reply_rpc_jack_internal_clientunload;
+-	__Reply__rpc_jack_client_rt_notify_t Reply_rpc_jack_client_rt_notify;
+-};
+-#endif /* __RequestUnion__server_JackRPCEngine_subsystem__defined */
+-/* Forward Declarations */
+-
+-
+-mig_internal novalue _Xrpc_jack_client_open
+-	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP);
+-
+-mig_internal novalue _Xrpc_jack_client_check
+-	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP);
+-
+-mig_internal novalue _Xrpc_jack_client_close
+-	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP);
+-
+-mig_internal novalue _Xrpc_jack_client_activate
+-	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP);
+-
+-mig_internal novalue _Xrpc_jack_client_deactivate
+-	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP);
+-
+-mig_internal novalue _Xrpc_jack_port_register
+-	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP);
+-
+-mig_internal novalue _Xrpc_jack_port_unregister
+-	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP);
+-
+-mig_internal novalue _Xrpc_jack_port_connect
+-	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP);
+-
+-mig_internal novalue _Xrpc_jack_port_disconnect
+-	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP);
+-
+-mig_internal novalue _Xrpc_jack_port_connect_name
+-	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP);
+-
+-mig_internal novalue _Xrpc_jack_port_disconnect_name
+-	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP);
+-
+-mig_internal novalue _Xrpc_jack_port_rename
+-	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP);
+-
+-mig_internal novalue _Xrpc_jack_set_buffer_size
+-	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP);
+-
+-mig_internal novalue _Xrpc_jack_set_freewheel
+-	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP);
+-
+-mig_internal novalue _Xrpc_jack_release_timebase
+-	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP);
+-
+-mig_internal novalue _Xrpc_jack_set_timebase_callback
+-	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP);
+-
+-mig_internal novalue _Xrpc_jack_get_internal_clientname
+-	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP);
+-
+-mig_internal novalue _Xrpc_jack_internal_clienthandle
+-	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP);
+-
+-mig_internal novalue _Xrpc_jack_internal_clientload
+-	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP);
+-
+-mig_internal novalue _Xrpc_jack_internal_clientunload
+-	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP);
+-
+-mig_internal novalue _Xrpc_jack_client_rt_notify
+-	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP);
+-
+-
+-#if ( __MigTypeCheck || __NDR_convert__ )
+-#if __MIG_check__Request__JackRPCEngine_subsystem__
+-#if !defined(__MIG_check__Request__rpc_jack_client_open_t__defined)
+-#define __MIG_check__Request__rpc_jack_client_open_t__defined
+-#ifndef __NDR_convert__int_rep__Request__rpc_jack_client_open_t__client_name__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCEngine__client_name_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_open_t__client_name__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_open_t__client_name(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__client_name_t((client_name_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__client_name_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_open_t__client_name__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_open_t__client_name(a, f) \
+-	__NDR_convert__int_rep__client_name_t((client_name_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__JackRPCEngine__string__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_open_t__client_name__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_open_t__client_name(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__string(a, f, 64)
+-#elif	defined(__NDR_convert__int_rep__string__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_open_t__client_name__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_open_t__client_name(a, f) \
+-	__NDR_convert__int_rep__string(a, f, 64)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Request__rpc_jack_client_open_t__client_name__defined */
+-
+-#ifndef __NDR_convert__int_rep__Request__rpc_jack_client_open_t__pid__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_open_t__pid__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_open_t__pid(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_open_t__pid__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_open_t__pid(a, f) \
+-	__NDR_convert__int_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_open_t__pid__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_open_t__pid(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int32_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_open_t__pid__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_open_t__pid(a, f) \
+-	__NDR_convert__int_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Request__rpc_jack_client_open_t__pid__defined */
+-
+-#ifndef __NDR_convert__char_rep__Request__rpc_jack_client_open_t__client_name__defined
+-#if	defined(__NDR_convert__char_rep__JackRPCEngine__client_name_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_open_t__client_name__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_open_t__client_name(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__client_name_t((client_name_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__client_name_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_open_t__client_name__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_open_t__client_name(a, f) \
+-	__NDR_convert__char_rep__client_name_t((client_name_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__JackRPCEngine__string__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_open_t__client_name__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_open_t__client_name(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__string(a, f, 64)
+-#elif	defined(__NDR_convert__char_rep__string__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_open_t__client_name__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_open_t__client_name(a, f) \
+-	__NDR_convert__char_rep__string(a, f, 64)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__char_rep__Request__rpc_jack_client_open_t__client_name__defined */
+-
+-#ifndef __NDR_convert__char_rep__Request__rpc_jack_client_open_t__pid__defined
+-#if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_open_t__pid__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_open_t__pid(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_open_t__pid__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_open_t__pid(a, f) \
+-	__NDR_convert__char_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_open_t__pid__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_open_t__pid(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int32_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_open_t__pid__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_open_t__pid(a, f) \
+-	__NDR_convert__char_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__char_rep__Request__rpc_jack_client_open_t__pid__defined */
+-
+-#ifndef __NDR_convert__float_rep__Request__rpc_jack_client_open_t__client_name__defined
+-#if	defined(__NDR_convert__float_rep__JackRPCEngine__client_name_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_open_t__client_name__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_open_t__client_name(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__client_name_t((client_name_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__client_name_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_open_t__client_name__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_open_t__client_name(a, f) \
+-	__NDR_convert__float_rep__client_name_t((client_name_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__JackRPCEngine__string__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_open_t__client_name__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_open_t__client_name(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__string(a, f, 64)
+-#elif	defined(__NDR_convert__float_rep__string__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_open_t__client_name__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_open_t__client_name(a, f) \
+-	__NDR_convert__float_rep__string(a, f, 64)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__float_rep__Request__rpc_jack_client_open_t__client_name__defined */
+-
+-#ifndef __NDR_convert__float_rep__Request__rpc_jack_client_open_t__pid__defined
+-#if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_open_t__pid__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_open_t__pid(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_open_t__pid__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_open_t__pid(a, f) \
+-	__NDR_convert__float_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_open_t__pid__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_open_t__pid(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int32_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_open_t__pid__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_open_t__pid(a, f) \
+-	__NDR_convert__float_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__float_rep__Request__rpc_jack_client_open_t__pid__defined */
+-
+-
+-mig_internal kern_return_t __MIG_check__Request__rpc_jack_client_open_t(__attribute__((__unused__)) __Request__rpc_jack_client_open_t *In0P)
+-{
+-
+-	typedef __Request__rpc_jack_client_open_t __Request;
+-#if	__MigTypeCheck
+-	if ((In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
+-	    (In0P->Head.msgh_size != (mach_msg_size_t)sizeof(__Request)))
+-		return MIG_BAD_ARGUMENTS;
+-#endif	/* __MigTypeCheck */
+-
+-#if __MigTypeCheck
+-	{
+-		char * msg_limit = ((char *) In0P) + In0P->Head.msgh_size;
+-		size_t memchr_limit;
+-
+-		memchr_limit = min((msg_limit - In0P->client_name),  64);
+-		if (( memchr(In0P->client_name, '\0', memchr_limit) == NULL ))
+-			return MIG_BAD_ARGUMENTS; // string length exceeds buffer length!
+-	}
+-#endif	/* __MigTypeCheck */
+-
+-#if	defined(__NDR_convert__int_rep__Request__rpc_jack_client_open_t__client_name__defined) || \
+-	defined(__NDR_convert__int_rep__Request__rpc_jack_client_open_t__pid__defined)
+-	if (In0P->NDR.int_rep != NDR_record.int_rep) {
+-#if defined(__NDR_convert__int_rep__Request__rpc_jack_client_open_t__client_name__defined)
+-		__NDR_convert__int_rep__Request__rpc_jack_client_open_t__client_name(&In0P->client_name, In0P->NDR.int_rep);
+-#endif	/* __NDR_convert__int_rep__Request__rpc_jack_client_open_t__client_name__defined */
+-#if defined(__NDR_convert__int_rep__Request__rpc_jack_client_open_t__pid__defined)
+-		__NDR_convert__int_rep__Request__rpc_jack_client_open_t__pid(&In0P->pid, In0P->NDR.int_rep);
+-#endif	/* __NDR_convert__int_rep__Request__rpc_jack_client_open_t__pid__defined */
+-	}
+-#endif	/* defined(__NDR_convert__int_rep...) */
+-
+-#if	defined(__NDR_convert__char_rep__Request__rpc_jack_client_open_t__client_name__defined) || \
+-	defined(__NDR_convert__char_rep__Request__rpc_jack_client_open_t__pid__defined)
+-	if (In0P->NDR.char_rep != NDR_record.char_rep) {
+-#if defined(__NDR_convert__char_rep__Request__rpc_jack_client_open_t__client_name__defined)
+-		__NDR_convert__char_rep__Request__rpc_jack_client_open_t__client_name(&In0P->client_name, In0P->NDR.char_rep);
+-#endif	/* __NDR_convert__char_rep__Request__rpc_jack_client_open_t__client_name__defined */
+-#if defined(__NDR_convert__char_rep__Request__rpc_jack_client_open_t__pid__defined)
+-		__NDR_convert__char_rep__Request__rpc_jack_client_open_t__pid(&In0P->pid, In0P->NDR.char_rep);
+-#endif	/* __NDR_convert__char_rep__Request__rpc_jack_client_open_t__pid__defined */
+-	}
+-#endif	/* defined(__NDR_convert__char_rep...) */
+-
+-#if	defined(__NDR_convert__float_rep__Request__rpc_jack_client_open_t__client_name__defined) || \
+-	defined(__NDR_convert__float_rep__Request__rpc_jack_client_open_t__pid__defined)
+-	if (In0P->NDR.float_rep != NDR_record.float_rep) {
+-#if defined(__NDR_convert__float_rep__Request__rpc_jack_client_open_t__client_name__defined)
+-		__NDR_convert__float_rep__Request__rpc_jack_client_open_t__client_name(&In0P->client_name, In0P->NDR.float_rep);
+-#endif	/* __NDR_convert__float_rep__Request__rpc_jack_client_open_t__client_name__defined */
+-#if defined(__NDR_convert__float_rep__Request__rpc_jack_client_open_t__pid__defined)
+-		__NDR_convert__float_rep__Request__rpc_jack_client_open_t__pid(&In0P->pid, In0P->NDR.float_rep);
+-#endif	/* __NDR_convert__float_rep__Request__rpc_jack_client_open_t__pid__defined */
+-	}
+-#endif	/* defined(__NDR_convert__float_rep...) */
+-
+-	return MACH_MSG_SUCCESS;
+-}
+-#endif /* !defined(__MIG_check__Request__rpc_jack_client_open_t__defined) */
+-#endif /* __MIG_check__Request__JackRPCEngine_subsystem__ */
+-#endif /* ( __MigTypeCheck || __NDR_convert__ ) */
+-
+-
+-/* Routine rpc_jack_client_open */
+-#ifdef	mig_external
+-mig_external
+-#else
+-extern
+-#endif	/* mig_external */
+-kern_return_t server_rpc_jack_client_open
+-(
+-	mach_port_t server_port,
+-	client_name_t client_name,
+-	int pid,
+-	mach_port_t *private_port,
+-	int *shared_engine,
+-	int *shared_client,
+-	int *shared_graph,
+-	int *result
+-);
+-
+-/* Routine rpc_jack_client_open */
+-mig_internal novalue _Xrpc_jack_client_open
+-	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
+-{
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		client_name_t client_name;
+-		int pid;
+-		mach_msg_trailer_t trailer;
+-	} Request;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-	typedef __Request__rpc_jack_client_open_t __Request;
+-	typedef __Reply__rpc_jack_client_open_t Reply;
+-
+-	/*
+-	 * typedef struct {
+-	 * 	mach_msg_header_t Head;
+-	 * 	NDR_record_t NDR;
+-	 * 	kern_return_t RetCode;
+-	 * } mig_reply_error_t;
+-	 */
+-
+-	Request *In0P = (Request *) InHeadP;
+-	Reply *OutP = (Reply *) OutHeadP;
+-#ifdef	__MIG_check__Request__rpc_jack_client_open_t__defined
+-	kern_return_t check_result;
+-#endif	/* __MIG_check__Request__rpc_jack_client_open_t__defined */
+-
+-#if	UseStaticTemplates
+-	const static mach_msg_port_descriptor_t private_portTemplate = {
+-		/* name = */		MACH_PORT_NULL,
+-		/* pad1 = */		0,
+-		/* pad2 = */		0,
+-		/* disp = */		20,
+-		/* type = */		MACH_MSG_PORT_DESCRIPTOR,
+-	};
+-#endif	/* UseStaticTemplates */
+-
+-	kern_return_t RetCode;
+-	__DeclareRcvRpc(1000, "rpc_jack_client_open")
+-	__BeforeRcvRpc(1000, "rpc_jack_client_open")
+-
+-#if	defined(__MIG_check__Request__rpc_jack_client_open_t__defined)
+-	check_result = __MIG_check__Request__rpc_jack_client_open_t((__Request *)In0P);
+-	if (check_result != MACH_MSG_SUCCESS)
+-		{ MIG_RETURN_ERROR(OutP, check_result); }
+-#endif	/* defined(__MIG_check__Request__rpc_jack_client_open_t__defined) */
+-
+-#if	UseStaticTemplates
+-	OutP->private_port = private_portTemplate;
+-#else	/* UseStaticTemplates */
+-	OutP->private_port.disposition = 20;
+-	OutP->private_port.type = MACH_MSG_PORT_DESCRIPTOR;
+-#endif	/* UseStaticTemplates */
+-
+-
+-	RetCode = server_rpc_jack_client_open(In0P->Head.msgh_request_port, In0P->client_name, In0P->pid, &OutP->private_port.name, &OutP->shared_engine, &OutP->shared_client, &OutP->shared_graph, &OutP->result);
+-	if (RetCode != KERN_SUCCESS) {
+-		MIG_RETURN_ERROR(OutP, RetCode);
+-	}
+-
+-	OutP->NDR = NDR_record;
+-
+-
+-	OutP->Head.msgh_bits |= MACH_MSGH_BITS_COMPLEX;
+-	OutP->Head.msgh_size = (mach_msg_size_t)(sizeof(Reply));
+-	OutP->msgh_body.msgh_descriptor_count = 1;
+-	__AfterRcvRpc(1000, "rpc_jack_client_open")
+-}
+-
+-#if ( __MigTypeCheck || __NDR_convert__ )
+-#if __MIG_check__Request__JackRPCEngine_subsystem__
+-#if !defined(__MIG_check__Request__rpc_jack_client_check_t__defined)
+-#define __MIG_check__Request__rpc_jack_client_check_t__defined
+-#ifndef __NDR_convert__int_rep__Request__rpc_jack_client_check_t__client_name__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCEngine__client_name_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_check_t__client_name__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_check_t__client_name(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__client_name_t((client_name_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__client_name_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_check_t__client_name__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_check_t__client_name(a, f) \
+-	__NDR_convert__int_rep__client_name_t((client_name_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__JackRPCEngine__string__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_check_t__client_name__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_check_t__client_name(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__string(a, f, 64)
+-#elif	defined(__NDR_convert__int_rep__string__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_check_t__client_name__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_check_t__client_name(a, f) \
+-	__NDR_convert__int_rep__string(a, f, 64)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Request__rpc_jack_client_check_t__client_name__defined */
+-
+-#ifndef __NDR_convert__int_rep__Request__rpc_jack_client_check_t__protocol__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_check_t__protocol__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_check_t__protocol(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_check_t__protocol__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_check_t__protocol(a, f) \
+-	__NDR_convert__int_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_check_t__protocol__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_check_t__protocol(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int32_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_check_t__protocol__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_check_t__protocol(a, f) \
+-	__NDR_convert__int_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Request__rpc_jack_client_check_t__protocol__defined */
+-
+-#ifndef __NDR_convert__int_rep__Request__rpc_jack_client_check_t__options__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_check_t__options__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_check_t__options(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_check_t__options__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_check_t__options(a, f) \
+-	__NDR_convert__int_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_check_t__options__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_check_t__options(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int32_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_check_t__options__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_check_t__options(a, f) \
+-	__NDR_convert__int_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Request__rpc_jack_client_check_t__options__defined */
+-
+-#ifndef __NDR_convert__char_rep__Request__rpc_jack_client_check_t__client_name__defined
+-#if	defined(__NDR_convert__char_rep__JackRPCEngine__client_name_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_check_t__client_name__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_check_t__client_name(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__client_name_t((client_name_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__client_name_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_check_t__client_name__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_check_t__client_name(a, f) \
+-	__NDR_convert__char_rep__client_name_t((client_name_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__JackRPCEngine__string__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_check_t__client_name__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_check_t__client_name(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__string(a, f, 64)
+-#elif	defined(__NDR_convert__char_rep__string__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_check_t__client_name__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_check_t__client_name(a, f) \
+-	__NDR_convert__char_rep__string(a, f, 64)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__char_rep__Request__rpc_jack_client_check_t__client_name__defined */
+-
+-#ifndef __NDR_convert__char_rep__Request__rpc_jack_client_check_t__protocol__defined
+-#if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_check_t__protocol__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_check_t__protocol(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_check_t__protocol__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_check_t__protocol(a, f) \
+-	__NDR_convert__char_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_check_t__protocol__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_check_t__protocol(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int32_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_check_t__protocol__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_check_t__protocol(a, f) \
+-	__NDR_convert__char_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__char_rep__Request__rpc_jack_client_check_t__protocol__defined */
+-
+-#ifndef __NDR_convert__char_rep__Request__rpc_jack_client_check_t__options__defined
+-#if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_check_t__options__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_check_t__options(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_check_t__options__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_check_t__options(a, f) \
+-	__NDR_convert__char_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_check_t__options__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_check_t__options(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int32_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_check_t__options__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_check_t__options(a, f) \
+-	__NDR_convert__char_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__char_rep__Request__rpc_jack_client_check_t__options__defined */
+-
+-#ifndef __NDR_convert__float_rep__Request__rpc_jack_client_check_t__client_name__defined
+-#if	defined(__NDR_convert__float_rep__JackRPCEngine__client_name_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_check_t__client_name__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_check_t__client_name(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__client_name_t((client_name_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__client_name_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_check_t__client_name__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_check_t__client_name(a, f) \
+-	__NDR_convert__float_rep__client_name_t((client_name_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__JackRPCEngine__string__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_check_t__client_name__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_check_t__client_name(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__string(a, f, 64)
+-#elif	defined(__NDR_convert__float_rep__string__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_check_t__client_name__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_check_t__client_name(a, f) \
+-	__NDR_convert__float_rep__string(a, f, 64)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__float_rep__Request__rpc_jack_client_check_t__client_name__defined */
+-
+-#ifndef __NDR_convert__float_rep__Request__rpc_jack_client_check_t__protocol__defined
+-#if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_check_t__protocol__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_check_t__protocol(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_check_t__protocol__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_check_t__protocol(a, f) \
+-	__NDR_convert__float_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_check_t__protocol__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_check_t__protocol(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int32_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_check_t__protocol__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_check_t__protocol(a, f) \
+-	__NDR_convert__float_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__float_rep__Request__rpc_jack_client_check_t__protocol__defined */
+-
+-#ifndef __NDR_convert__float_rep__Request__rpc_jack_client_check_t__options__defined
+-#if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_check_t__options__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_check_t__options(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_check_t__options__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_check_t__options(a, f) \
+-	__NDR_convert__float_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_check_t__options__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_check_t__options(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int32_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_check_t__options__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_check_t__options(a, f) \
+-	__NDR_convert__float_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__float_rep__Request__rpc_jack_client_check_t__options__defined */
+-
+-
+-mig_internal kern_return_t __MIG_check__Request__rpc_jack_client_check_t(__attribute__((__unused__)) __Request__rpc_jack_client_check_t *In0P)
+-{
+-
+-	typedef __Request__rpc_jack_client_check_t __Request;
+-#if	__MigTypeCheck
+-	if ((In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
+-	    (In0P->Head.msgh_size != (mach_msg_size_t)sizeof(__Request)))
+-		return MIG_BAD_ARGUMENTS;
+-#endif	/* __MigTypeCheck */
+-
+-#if __MigTypeCheck
+-	{
+-		char * msg_limit = ((char *) In0P) + In0P->Head.msgh_size;
+-		size_t memchr_limit;
+-
+-		memchr_limit = min((msg_limit - In0P->client_name),  64);
+-		if (( memchr(In0P->client_name, '\0', memchr_limit) == NULL ))
+-			return MIG_BAD_ARGUMENTS; // string length exceeds buffer length!
+-	}
+-#endif	/* __MigTypeCheck */
+-
+-#if	defined(__NDR_convert__int_rep__Request__rpc_jack_client_check_t__client_name__defined) || \
+-	defined(__NDR_convert__int_rep__Request__rpc_jack_client_check_t__protocol__defined) || \
+-	defined(__NDR_convert__int_rep__Request__rpc_jack_client_check_t__options__defined)
+-	if (In0P->NDR.int_rep != NDR_record.int_rep) {
+-#if defined(__NDR_convert__int_rep__Request__rpc_jack_client_check_t__client_name__defined)
+-		__NDR_convert__int_rep__Request__rpc_jack_client_check_t__client_name(&In0P->client_name, In0P->NDR.int_rep);
+-#endif	/* __NDR_convert__int_rep__Request__rpc_jack_client_check_t__client_name__defined */
+-#if defined(__NDR_convert__int_rep__Request__rpc_jack_client_check_t__protocol__defined)
+-		__NDR_convert__int_rep__Request__rpc_jack_client_check_t__protocol(&In0P->protocol, In0P->NDR.int_rep);
+-#endif	/* __NDR_convert__int_rep__Request__rpc_jack_client_check_t__protocol__defined */
+-#if defined(__NDR_convert__int_rep__Request__rpc_jack_client_check_t__options__defined)
+-		__NDR_convert__int_rep__Request__rpc_jack_client_check_t__options(&In0P->options, In0P->NDR.int_rep);
+-#endif	/* __NDR_convert__int_rep__Request__rpc_jack_client_check_t__options__defined */
+-	}
+-#endif	/* defined(__NDR_convert__int_rep...) */
+-
+-#if	defined(__NDR_convert__char_rep__Request__rpc_jack_client_check_t__client_name__defined) || \
+-	defined(__NDR_convert__char_rep__Request__rpc_jack_client_check_t__protocol__defined) || \
+-	defined(__NDR_convert__char_rep__Request__rpc_jack_client_check_t__options__defined)
+-	if (In0P->NDR.char_rep != NDR_record.char_rep) {
+-#if defined(__NDR_convert__char_rep__Request__rpc_jack_client_check_t__client_name__defined)
+-		__NDR_convert__char_rep__Request__rpc_jack_client_check_t__client_name(&In0P->client_name, In0P->NDR.char_rep);
+-#endif	/* __NDR_convert__char_rep__Request__rpc_jack_client_check_t__client_name__defined */
+-#if defined(__NDR_convert__char_rep__Request__rpc_jack_client_check_t__protocol__defined)
+-		__NDR_convert__char_rep__Request__rpc_jack_client_check_t__protocol(&In0P->protocol, In0P->NDR.char_rep);
+-#endif	/* __NDR_convert__char_rep__Request__rpc_jack_client_check_t__protocol__defined */
+-#if defined(__NDR_convert__char_rep__Request__rpc_jack_client_check_t__options__defined)
+-		__NDR_convert__char_rep__Request__rpc_jack_client_check_t__options(&In0P->options, In0P->NDR.char_rep);
+-#endif	/* __NDR_convert__char_rep__Request__rpc_jack_client_check_t__options__defined */
+-	}
+-#endif	/* defined(__NDR_convert__char_rep...) */
+-
+-#if	defined(__NDR_convert__float_rep__Request__rpc_jack_client_check_t__client_name__defined) || \
+-	defined(__NDR_convert__float_rep__Request__rpc_jack_client_check_t__protocol__defined) || \
+-	defined(__NDR_convert__float_rep__Request__rpc_jack_client_check_t__options__defined)
+-	if (In0P->NDR.float_rep != NDR_record.float_rep) {
+-#if defined(__NDR_convert__float_rep__Request__rpc_jack_client_check_t__client_name__defined)
+-		__NDR_convert__float_rep__Request__rpc_jack_client_check_t__client_name(&In0P->client_name, In0P->NDR.float_rep);
+-#endif	/* __NDR_convert__float_rep__Request__rpc_jack_client_check_t__client_name__defined */
+-#if defined(__NDR_convert__float_rep__Request__rpc_jack_client_check_t__protocol__defined)
+-		__NDR_convert__float_rep__Request__rpc_jack_client_check_t__protocol(&In0P->protocol, In0P->NDR.float_rep);
+-#endif	/* __NDR_convert__float_rep__Request__rpc_jack_client_check_t__protocol__defined */
+-#if defined(__NDR_convert__float_rep__Request__rpc_jack_client_check_t__options__defined)
+-		__NDR_convert__float_rep__Request__rpc_jack_client_check_t__options(&In0P->options, In0P->NDR.float_rep);
+-#endif	/* __NDR_convert__float_rep__Request__rpc_jack_client_check_t__options__defined */
+-	}
+-#endif	/* defined(__NDR_convert__float_rep...) */
+-
+-	return MACH_MSG_SUCCESS;
+-}
+-#endif /* !defined(__MIG_check__Request__rpc_jack_client_check_t__defined) */
+-#endif /* __MIG_check__Request__JackRPCEngine_subsystem__ */
+-#endif /* ( __MigTypeCheck || __NDR_convert__ ) */
+-
+-
+-/* Routine rpc_jack_client_check */
+-#ifdef	mig_external
+-mig_external
+-#else
+-extern
+-#endif	/* mig_external */
+-kern_return_t server_rpc_jack_client_check
+-(
+-	mach_port_t server_port,
+-	client_name_t client_name,
+-	client_name_t client_name_res,
+-	int protocol,
+-	int options,
+-	int *status,
+-	int *result
+-);
+-
+-/* Routine rpc_jack_client_check */
+-mig_internal novalue _Xrpc_jack_client_check
+-	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
+-{
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		client_name_t client_name;
+-		int protocol;
+-		int options;
+-		mach_msg_trailer_t trailer;
+-	} Request;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-	typedef __Request__rpc_jack_client_check_t __Request;
+-	typedef __Reply__rpc_jack_client_check_t Reply;
+-
+-	/*
+-	 * typedef struct {
+-	 * 	mach_msg_header_t Head;
+-	 * 	NDR_record_t NDR;
+-	 * 	kern_return_t RetCode;
+-	 * } mig_reply_error_t;
+-	 */
+-
+-	Request *In0P = (Request *) InHeadP;
+-	Reply *OutP = (Reply *) OutHeadP;
+-#ifdef	__MIG_check__Request__rpc_jack_client_check_t__defined
+-	kern_return_t check_result;
+-#endif	/* __MIG_check__Request__rpc_jack_client_check_t__defined */
+-
+-	__DeclareRcvRpc(1001, "rpc_jack_client_check")
+-	__BeforeRcvRpc(1001, "rpc_jack_client_check")
+-
+-#if	defined(__MIG_check__Request__rpc_jack_client_check_t__defined)
+-	check_result = __MIG_check__Request__rpc_jack_client_check_t((__Request *)In0P);
+-	if (check_result != MACH_MSG_SUCCESS)
+-		{ MIG_RETURN_ERROR(OutP, check_result); }
+-#endif	/* defined(__MIG_check__Request__rpc_jack_client_check_t__defined) */
+-
+-	OutP->RetCode = server_rpc_jack_client_check(In0P->Head.msgh_request_port, In0P->client_name, OutP->client_name_res, In0P->protocol, In0P->options, &OutP->status, &OutP->result);
+-	if (OutP->RetCode != KERN_SUCCESS) {
+-		MIG_RETURN_ERROR(OutP, OutP->RetCode);
+-	}
+-
+-	OutP->NDR = NDR_record;
+-
+-
+-	OutP->Head.msgh_size = (mach_msg_size_t)(sizeof(Reply));
+-	__AfterRcvRpc(1001, "rpc_jack_client_check")
+-}
+-
+-#if ( __MigTypeCheck || __NDR_convert__ )
+-#if __MIG_check__Request__JackRPCEngine_subsystem__
+-#if !defined(__MIG_check__Request__rpc_jack_client_close_t__defined)
+-#define __MIG_check__Request__rpc_jack_client_close_t__defined
+-#ifndef __NDR_convert__int_rep__Request__rpc_jack_client_close_t__refnum__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_close_t__refnum__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_close_t__refnum(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_close_t__refnum__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_close_t__refnum(a, f) \
+-	__NDR_convert__int_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_close_t__refnum__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_close_t__refnum(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int32_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_close_t__refnum__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_close_t__refnum(a, f) \
+-	__NDR_convert__int_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Request__rpc_jack_client_close_t__refnum__defined */
+-
+-#ifndef __NDR_convert__char_rep__Request__rpc_jack_client_close_t__refnum__defined
+-#if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_close_t__refnum__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_close_t__refnum(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_close_t__refnum__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_close_t__refnum(a, f) \
+-	__NDR_convert__char_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_close_t__refnum__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_close_t__refnum(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int32_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_close_t__refnum__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_close_t__refnum(a, f) \
+-	__NDR_convert__char_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__char_rep__Request__rpc_jack_client_close_t__refnum__defined */
+-
+-#ifndef __NDR_convert__float_rep__Request__rpc_jack_client_close_t__refnum__defined
+-#if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_close_t__refnum__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_close_t__refnum(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_close_t__refnum__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_close_t__refnum(a, f) \
+-	__NDR_convert__float_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_close_t__refnum__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_close_t__refnum(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int32_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_close_t__refnum__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_close_t__refnum(a, f) \
+-	__NDR_convert__float_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__float_rep__Request__rpc_jack_client_close_t__refnum__defined */
+-
+-
+-mig_internal kern_return_t __MIG_check__Request__rpc_jack_client_close_t(__attribute__((__unused__)) __Request__rpc_jack_client_close_t *In0P)
+-{
+-
+-	typedef __Request__rpc_jack_client_close_t __Request;
+-#if	__MigTypeCheck
+-	if ((In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
+-	    (In0P->Head.msgh_size != (mach_msg_size_t)sizeof(__Request)))
+-		return MIG_BAD_ARGUMENTS;
+-#endif	/* __MigTypeCheck */
+-
+-#if	defined(__NDR_convert__int_rep__Request__rpc_jack_client_close_t__refnum__defined)
+-	if (In0P->NDR.int_rep != NDR_record.int_rep) {
+-#if defined(__NDR_convert__int_rep__Request__rpc_jack_client_close_t__refnum__defined)
+-		__NDR_convert__int_rep__Request__rpc_jack_client_close_t__refnum(&In0P->refnum, In0P->NDR.int_rep);
+-#endif	/* __NDR_convert__int_rep__Request__rpc_jack_client_close_t__refnum__defined */
+-	}
+-#endif	/* defined(__NDR_convert__int_rep...) */
+-
+-#if	defined(__NDR_convert__char_rep__Request__rpc_jack_client_close_t__refnum__defined)
+-	if (In0P->NDR.char_rep != NDR_record.char_rep) {
+-#if defined(__NDR_convert__char_rep__Request__rpc_jack_client_close_t__refnum__defined)
+-		__NDR_convert__char_rep__Request__rpc_jack_client_close_t__refnum(&In0P->refnum, In0P->NDR.char_rep);
+-#endif	/* __NDR_convert__char_rep__Request__rpc_jack_client_close_t__refnum__defined */
+-	}
+-#endif	/* defined(__NDR_convert__char_rep...) */
+-
+-#if	defined(__NDR_convert__float_rep__Request__rpc_jack_client_close_t__refnum__defined)
+-	if (In0P->NDR.float_rep != NDR_record.float_rep) {
+-#if defined(__NDR_convert__float_rep__Request__rpc_jack_client_close_t__refnum__defined)
+-		__NDR_convert__float_rep__Request__rpc_jack_client_close_t__refnum(&In0P->refnum, In0P->NDR.float_rep);
+-#endif	/* __NDR_convert__float_rep__Request__rpc_jack_client_close_t__refnum__defined */
+-	}
+-#endif	/* defined(__NDR_convert__float_rep...) */
+-
+-	return MACH_MSG_SUCCESS;
+-}
+-#endif /* !defined(__MIG_check__Request__rpc_jack_client_close_t__defined) */
+-#endif /* __MIG_check__Request__JackRPCEngine_subsystem__ */
+-#endif /* ( __MigTypeCheck || __NDR_convert__ ) */
+-
+-
+-/* Routine rpc_jack_client_close */
+-#ifdef	mig_external
+-mig_external
+-#else
+-extern
+-#endif	/* mig_external */
+-kern_return_t server_rpc_jack_client_close
+-(
+-	mach_port_t server_port,
+-	int refnum,
+-	int *result
+-);
+-
+-/* Routine rpc_jack_client_close */
+-mig_internal novalue _Xrpc_jack_client_close
+-	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
+-{
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		int refnum;
+-		mach_msg_trailer_t trailer;
+-	} Request;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-	typedef __Request__rpc_jack_client_close_t __Request;
+-	typedef __Reply__rpc_jack_client_close_t Reply;
+-
+-	/*
+-	 * typedef struct {
+-	 * 	mach_msg_header_t Head;
+-	 * 	NDR_record_t NDR;
+-	 * 	kern_return_t RetCode;
+-	 * } mig_reply_error_t;
+-	 */
+-
+-	Request *In0P = (Request *) InHeadP;
+-	Reply *OutP = (Reply *) OutHeadP;
+-#ifdef	__MIG_check__Request__rpc_jack_client_close_t__defined
+-	kern_return_t check_result;
+-#endif	/* __MIG_check__Request__rpc_jack_client_close_t__defined */
+-
+-	__DeclareRcvRpc(1002, "rpc_jack_client_close")
+-	__BeforeRcvRpc(1002, "rpc_jack_client_close")
+-
+-#if	defined(__MIG_check__Request__rpc_jack_client_close_t__defined)
+-	check_result = __MIG_check__Request__rpc_jack_client_close_t((__Request *)In0P);
+-	if (check_result != MACH_MSG_SUCCESS)
+-		{ MIG_RETURN_ERROR(OutP, check_result); }
+-#endif	/* defined(__MIG_check__Request__rpc_jack_client_close_t__defined) */
+-
+-	OutP->RetCode = server_rpc_jack_client_close(In0P->Head.msgh_request_port, In0P->refnum, &OutP->result);
+-	if (OutP->RetCode != KERN_SUCCESS) {
+-		MIG_RETURN_ERROR(OutP, OutP->RetCode);
+-	}
+-
+-	OutP->NDR = NDR_record;
+-
+-
+-	OutP->Head.msgh_size = (mach_msg_size_t)(sizeof(Reply));
+-	__AfterRcvRpc(1002, "rpc_jack_client_close")
+-}
+-
+-#if ( __MigTypeCheck || __NDR_convert__ )
+-#if __MIG_check__Request__JackRPCEngine_subsystem__
+-#if !defined(__MIG_check__Request__rpc_jack_client_activate_t__defined)
+-#define __MIG_check__Request__rpc_jack_client_activate_t__defined
+-#ifndef __NDR_convert__int_rep__Request__rpc_jack_client_activate_t__refnum__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_activate_t__refnum__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_activate_t__refnum(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_activate_t__refnum__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_activate_t__refnum(a, f) \
+-	__NDR_convert__int_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_activate_t__refnum__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_activate_t__refnum(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int32_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_activate_t__refnum__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_activate_t__refnum(a, f) \
+-	__NDR_convert__int_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Request__rpc_jack_client_activate_t__refnum__defined */
+-
+-#ifndef __NDR_convert__int_rep__Request__rpc_jack_client_activate_t__state__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_activate_t__state__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_activate_t__state(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_activate_t__state__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_activate_t__state(a, f) \
+-	__NDR_convert__int_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_activate_t__state__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_activate_t__state(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int32_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_activate_t__state__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_activate_t__state(a, f) \
+-	__NDR_convert__int_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Request__rpc_jack_client_activate_t__state__defined */
+-
+-#ifndef __NDR_convert__char_rep__Request__rpc_jack_client_activate_t__refnum__defined
+-#if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_activate_t__refnum__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_activate_t__refnum(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_activate_t__refnum__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_activate_t__refnum(a, f) \
+-	__NDR_convert__char_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_activate_t__refnum__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_activate_t__refnum(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int32_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_activate_t__refnum__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_activate_t__refnum(a, f) \
+-	__NDR_convert__char_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__char_rep__Request__rpc_jack_client_activate_t__refnum__defined */
+-
+-#ifndef __NDR_convert__char_rep__Request__rpc_jack_client_activate_t__state__defined
+-#if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_activate_t__state__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_activate_t__state(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_activate_t__state__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_activate_t__state(a, f) \
+-	__NDR_convert__char_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_activate_t__state__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_activate_t__state(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int32_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_activate_t__state__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_activate_t__state(a, f) \
+-	__NDR_convert__char_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__char_rep__Request__rpc_jack_client_activate_t__state__defined */
+-
+-#ifndef __NDR_convert__float_rep__Request__rpc_jack_client_activate_t__refnum__defined
+-#if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_activate_t__refnum__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_activate_t__refnum(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_activate_t__refnum__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_activate_t__refnum(a, f) \
+-	__NDR_convert__float_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_activate_t__refnum__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_activate_t__refnum(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int32_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_activate_t__refnum__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_activate_t__refnum(a, f) \
+-	__NDR_convert__float_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__float_rep__Request__rpc_jack_client_activate_t__refnum__defined */
+-
+-#ifndef __NDR_convert__float_rep__Request__rpc_jack_client_activate_t__state__defined
+-#if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_activate_t__state__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_activate_t__state(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_activate_t__state__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_activate_t__state(a, f) \
+-	__NDR_convert__float_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_activate_t__state__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_activate_t__state(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int32_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_activate_t__state__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_activate_t__state(a, f) \
+-	__NDR_convert__float_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__float_rep__Request__rpc_jack_client_activate_t__state__defined */
+-
+-
+-mig_internal kern_return_t __MIG_check__Request__rpc_jack_client_activate_t(__attribute__((__unused__)) __Request__rpc_jack_client_activate_t *In0P)
+-{
+-
+-	typedef __Request__rpc_jack_client_activate_t __Request;
+-#if	__MigTypeCheck
+-	if ((In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
+-	    (In0P->Head.msgh_size != (mach_msg_size_t)sizeof(__Request)))
+-		return MIG_BAD_ARGUMENTS;
+-#endif	/* __MigTypeCheck */
+-
+-#if	defined(__NDR_convert__int_rep__Request__rpc_jack_client_activate_t__refnum__defined) || \
+-	defined(__NDR_convert__int_rep__Request__rpc_jack_client_activate_t__state__defined)
+-	if (In0P->NDR.int_rep != NDR_record.int_rep) {
+-#if defined(__NDR_convert__int_rep__Request__rpc_jack_client_activate_t__refnum__defined)
+-		__NDR_convert__int_rep__Request__rpc_jack_client_activate_t__refnum(&In0P->refnum, In0P->NDR.int_rep);
+-#endif	/* __NDR_convert__int_rep__Request__rpc_jack_client_activate_t__refnum__defined */
+-#if defined(__NDR_convert__int_rep__Request__rpc_jack_client_activate_t__state__defined)
+-		__NDR_convert__int_rep__Request__rpc_jack_client_activate_t__state(&In0P->state, In0P->NDR.int_rep);
+-#endif	/* __NDR_convert__int_rep__Request__rpc_jack_client_activate_t__state__defined */
+-	}
+-#endif	/* defined(__NDR_convert__int_rep...) */
+-
+-#if	defined(__NDR_convert__char_rep__Request__rpc_jack_client_activate_t__refnum__defined) || \
+-	defined(__NDR_convert__char_rep__Request__rpc_jack_client_activate_t__state__defined)
+-	if (In0P->NDR.char_rep != NDR_record.char_rep) {
+-#if defined(__NDR_convert__char_rep__Request__rpc_jack_client_activate_t__refnum__defined)
+-		__NDR_convert__char_rep__Request__rpc_jack_client_activate_t__refnum(&In0P->refnum, In0P->NDR.char_rep);
+-#endif	/* __NDR_convert__char_rep__Request__rpc_jack_client_activate_t__refnum__defined */
+-#if defined(__NDR_convert__char_rep__Request__rpc_jack_client_activate_t__state__defined)
+-		__NDR_convert__char_rep__Request__rpc_jack_client_activate_t__state(&In0P->state, In0P->NDR.char_rep);
+-#endif	/* __NDR_convert__char_rep__Request__rpc_jack_client_activate_t__state__defined */
+-	}
+-#endif	/* defined(__NDR_convert__char_rep...) */
+-
+-#if	defined(__NDR_convert__float_rep__Request__rpc_jack_client_activate_t__refnum__defined) || \
+-	defined(__NDR_convert__float_rep__Request__rpc_jack_client_activate_t__state__defined)
+-	if (In0P->NDR.float_rep != NDR_record.float_rep) {
+-#if defined(__NDR_convert__float_rep__Request__rpc_jack_client_activate_t__refnum__defined)
+-		__NDR_convert__float_rep__Request__rpc_jack_client_activate_t__refnum(&In0P->refnum, In0P->NDR.float_rep);
+-#endif	/* __NDR_convert__float_rep__Request__rpc_jack_client_activate_t__refnum__defined */
+-#if defined(__NDR_convert__float_rep__Request__rpc_jack_client_activate_t__state__defined)
+-		__NDR_convert__float_rep__Request__rpc_jack_client_activate_t__state(&In0P->state, In0P->NDR.float_rep);
+-#endif	/* __NDR_convert__float_rep__Request__rpc_jack_client_activate_t__state__defined */
+-	}
+-#endif	/* defined(__NDR_convert__float_rep...) */
+-
+-	return MACH_MSG_SUCCESS;
+-}
+-#endif /* !defined(__MIG_check__Request__rpc_jack_client_activate_t__defined) */
+-#endif /* __MIG_check__Request__JackRPCEngine_subsystem__ */
+-#endif /* ( __MigTypeCheck || __NDR_convert__ ) */
+-
+-
+-/* Routine rpc_jack_client_activate */
+-#ifdef	mig_external
+-mig_external
+-#else
+-extern
+-#endif	/* mig_external */
+-kern_return_t server_rpc_jack_client_activate
+-(
+-	mach_port_t server_port,
+-	int refnum,
+-	int state,
+-	int *result
+-);
+-
+-/* Routine rpc_jack_client_activate */
+-mig_internal novalue _Xrpc_jack_client_activate
+-	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
+-{
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		int refnum;
+-		int state;
+-		mach_msg_trailer_t trailer;
+-	} Request;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-	typedef __Request__rpc_jack_client_activate_t __Request;
+-	typedef __Reply__rpc_jack_client_activate_t Reply;
+-
+-	/*
+-	 * typedef struct {
+-	 * 	mach_msg_header_t Head;
+-	 * 	NDR_record_t NDR;
+-	 * 	kern_return_t RetCode;
+-	 * } mig_reply_error_t;
+-	 */
+-
+-	Request *In0P = (Request *) InHeadP;
+-	Reply *OutP = (Reply *) OutHeadP;
+-#ifdef	__MIG_check__Request__rpc_jack_client_activate_t__defined
+-	kern_return_t check_result;
+-#endif	/* __MIG_check__Request__rpc_jack_client_activate_t__defined */
+-
+-	__DeclareRcvRpc(1003, "rpc_jack_client_activate")
+-	__BeforeRcvRpc(1003, "rpc_jack_client_activate")
+-
+-#if	defined(__MIG_check__Request__rpc_jack_client_activate_t__defined)
+-	check_result = __MIG_check__Request__rpc_jack_client_activate_t((__Request *)In0P);
+-	if (check_result != MACH_MSG_SUCCESS)
+-		{ MIG_RETURN_ERROR(OutP, check_result); }
+-#endif	/* defined(__MIG_check__Request__rpc_jack_client_activate_t__defined) */
+-
+-	OutP->RetCode = server_rpc_jack_client_activate(In0P->Head.msgh_request_port, In0P->refnum, In0P->state, &OutP->result);
+-	if (OutP->RetCode != KERN_SUCCESS) {
+-		MIG_RETURN_ERROR(OutP, OutP->RetCode);
+-	}
+-
+-	OutP->NDR = NDR_record;
+-
+-
+-	OutP->Head.msgh_size = (mach_msg_size_t)(sizeof(Reply));
+-	__AfterRcvRpc(1003, "rpc_jack_client_activate")
+-}
+-
+-#if ( __MigTypeCheck || __NDR_convert__ )
+-#if __MIG_check__Request__JackRPCEngine_subsystem__
+-#if !defined(__MIG_check__Request__rpc_jack_client_deactivate_t__defined)
+-#define __MIG_check__Request__rpc_jack_client_deactivate_t__defined
+-#ifndef __NDR_convert__int_rep__Request__rpc_jack_client_deactivate_t__refnum__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_deactivate_t__refnum__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_deactivate_t__refnum(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_deactivate_t__refnum__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_deactivate_t__refnum(a, f) \
+-	__NDR_convert__int_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_deactivate_t__refnum__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_deactivate_t__refnum(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int32_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_deactivate_t__refnum__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_deactivate_t__refnum(a, f) \
+-	__NDR_convert__int_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Request__rpc_jack_client_deactivate_t__refnum__defined */
+-
+-#ifndef __NDR_convert__char_rep__Request__rpc_jack_client_deactivate_t__refnum__defined
+-#if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_deactivate_t__refnum__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_deactivate_t__refnum(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_deactivate_t__refnum__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_deactivate_t__refnum(a, f) \
+-	__NDR_convert__char_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_deactivate_t__refnum__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_deactivate_t__refnum(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int32_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_deactivate_t__refnum__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_deactivate_t__refnum(a, f) \
+-	__NDR_convert__char_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__char_rep__Request__rpc_jack_client_deactivate_t__refnum__defined */
+-
+-#ifndef __NDR_convert__float_rep__Request__rpc_jack_client_deactivate_t__refnum__defined
+-#if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_deactivate_t__refnum__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_deactivate_t__refnum(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_deactivate_t__refnum__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_deactivate_t__refnum(a, f) \
+-	__NDR_convert__float_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_deactivate_t__refnum__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_deactivate_t__refnum(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int32_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_deactivate_t__refnum__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_deactivate_t__refnum(a, f) \
+-	__NDR_convert__float_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__float_rep__Request__rpc_jack_client_deactivate_t__refnum__defined */
+-
+-
+-mig_internal kern_return_t __MIG_check__Request__rpc_jack_client_deactivate_t(__attribute__((__unused__)) __Request__rpc_jack_client_deactivate_t *In0P)
+-{
+-
+-	typedef __Request__rpc_jack_client_deactivate_t __Request;
+-#if	__MigTypeCheck
+-	if ((In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
+-	    (In0P->Head.msgh_size != (mach_msg_size_t)sizeof(__Request)))
+-		return MIG_BAD_ARGUMENTS;
+-#endif	/* __MigTypeCheck */
+-
+-#if	defined(__NDR_convert__int_rep__Request__rpc_jack_client_deactivate_t__refnum__defined)
+-	if (In0P->NDR.int_rep != NDR_record.int_rep) {
+-#if defined(__NDR_convert__int_rep__Request__rpc_jack_client_deactivate_t__refnum__defined)
+-		__NDR_convert__int_rep__Request__rpc_jack_client_deactivate_t__refnum(&In0P->refnum, In0P->NDR.int_rep);
+-#endif	/* __NDR_convert__int_rep__Request__rpc_jack_client_deactivate_t__refnum__defined */
+-	}
+-#endif	/* defined(__NDR_convert__int_rep...) */
+-
+-#if	defined(__NDR_convert__char_rep__Request__rpc_jack_client_deactivate_t__refnum__defined)
+-	if (In0P->NDR.char_rep != NDR_record.char_rep) {
+-#if defined(__NDR_convert__char_rep__Request__rpc_jack_client_deactivate_t__refnum__defined)
+-		__NDR_convert__char_rep__Request__rpc_jack_client_deactivate_t__refnum(&In0P->refnum, In0P->NDR.char_rep);
+-#endif	/* __NDR_convert__char_rep__Request__rpc_jack_client_deactivate_t__refnum__defined */
+-	}
+-#endif	/* defined(__NDR_convert__char_rep...) */
+-
+-#if	defined(__NDR_convert__float_rep__Request__rpc_jack_client_deactivate_t__refnum__defined)
+-	if (In0P->NDR.float_rep != NDR_record.float_rep) {
+-#if defined(__NDR_convert__float_rep__Request__rpc_jack_client_deactivate_t__refnum__defined)
+-		__NDR_convert__float_rep__Request__rpc_jack_client_deactivate_t__refnum(&In0P->refnum, In0P->NDR.float_rep);
+-#endif	/* __NDR_convert__float_rep__Request__rpc_jack_client_deactivate_t__refnum__defined */
+-	}
+-#endif	/* defined(__NDR_convert__float_rep...) */
+-
+-	return MACH_MSG_SUCCESS;
+-}
+-#endif /* !defined(__MIG_check__Request__rpc_jack_client_deactivate_t__defined) */
+-#endif /* __MIG_check__Request__JackRPCEngine_subsystem__ */
+-#endif /* ( __MigTypeCheck || __NDR_convert__ ) */
+-
+-
+-/* Routine rpc_jack_client_deactivate */
+-#ifdef	mig_external
+-mig_external
+-#else
+-extern
+-#endif	/* mig_external */
+-kern_return_t server_rpc_jack_client_deactivate
+-(
+-	mach_port_t server_port,
+-	int refnum,
+-	int *result
+-);
+-
+-/* Routine rpc_jack_client_deactivate */
+-mig_internal novalue _Xrpc_jack_client_deactivate
+-	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
+-{
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		int refnum;
+-		mach_msg_trailer_t trailer;
+-	} Request;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-	typedef __Request__rpc_jack_client_deactivate_t __Request;
+-	typedef __Reply__rpc_jack_client_deactivate_t Reply;
+-
+-	/*
+-	 * typedef struct {
+-	 * 	mach_msg_header_t Head;
+-	 * 	NDR_record_t NDR;
+-	 * 	kern_return_t RetCode;
+-	 * } mig_reply_error_t;
+-	 */
+-
+-	Request *In0P = (Request *) InHeadP;
+-	Reply *OutP = (Reply *) OutHeadP;
+-#ifdef	__MIG_check__Request__rpc_jack_client_deactivate_t__defined
+-	kern_return_t check_result;
+-#endif	/* __MIG_check__Request__rpc_jack_client_deactivate_t__defined */
+-
+-	__DeclareRcvRpc(1004, "rpc_jack_client_deactivate")
+-	__BeforeRcvRpc(1004, "rpc_jack_client_deactivate")
+-
+-#if	defined(__MIG_check__Request__rpc_jack_client_deactivate_t__defined)
+-	check_result = __MIG_check__Request__rpc_jack_client_deactivate_t((__Request *)In0P);
+-	if (check_result != MACH_MSG_SUCCESS)
+-		{ MIG_RETURN_ERROR(OutP, check_result); }
+-#endif	/* defined(__MIG_check__Request__rpc_jack_client_deactivate_t__defined) */
+-
+-	OutP->RetCode = server_rpc_jack_client_deactivate(In0P->Head.msgh_request_port, In0P->refnum, &OutP->result);
+-	if (OutP->RetCode != KERN_SUCCESS) {
+-		MIG_RETURN_ERROR(OutP, OutP->RetCode);
+-	}
+-
+-	OutP->NDR = NDR_record;
+-
+-
+-	OutP->Head.msgh_size = (mach_msg_size_t)(sizeof(Reply));
+-	__AfterRcvRpc(1004, "rpc_jack_client_deactivate")
+-}
+-
+-#if ( __MigTypeCheck || __NDR_convert__ )
+-#if __MIG_check__Request__JackRPCEngine_subsystem__
+-#if !defined(__MIG_check__Request__rpc_jack_port_register_t__defined)
+-#define __MIG_check__Request__rpc_jack_port_register_t__defined
+-#ifndef __NDR_convert__int_rep__Request__rpc_jack_port_register_t__refnum__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_register_t__refnum__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_register_t__refnum(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_register_t__refnum__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_register_t__refnum(a, f) \
+-	__NDR_convert__int_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_register_t__refnum__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_register_t__refnum(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int32_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_register_t__refnum__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_register_t__refnum(a, f) \
+-	__NDR_convert__int_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Request__rpc_jack_port_register_t__refnum__defined */
+-
+-#ifndef __NDR_convert__int_rep__Request__rpc_jack_port_register_t__name__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCEngine__client_port_name_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_register_t__name__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_register_t__name(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__client_port_name_t((client_port_name_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__client_port_name_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_register_t__name__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_register_t__name(a, f) \
+-	__NDR_convert__int_rep__client_port_name_t((client_port_name_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__JackRPCEngine__string__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_register_t__name__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_register_t__name(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__string(a, f, 128)
+-#elif	defined(__NDR_convert__int_rep__string__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_register_t__name__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_register_t__name(a, f) \
+-	__NDR_convert__int_rep__string(a, f, 128)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Request__rpc_jack_port_register_t__name__defined */
+-
+-#ifndef __NDR_convert__int_rep__Request__rpc_jack_port_register_t__port_type__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCEngine__client_port_type_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_register_t__port_type__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_register_t__port_type(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__client_port_type_t((client_port_type_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__client_port_type_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_register_t__port_type__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_register_t__port_type(a, f) \
+-	__NDR_convert__int_rep__client_port_type_t((client_port_type_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__JackRPCEngine__string__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_register_t__port_type__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_register_t__port_type(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__string(a, f, 128)
+-#elif	defined(__NDR_convert__int_rep__string__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_register_t__port_type__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_register_t__port_type(a, f) \
+-	__NDR_convert__int_rep__string(a, f, 128)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Request__rpc_jack_port_register_t__port_type__defined */
+-
+-#ifndef __NDR_convert__int_rep__Request__rpc_jack_port_register_t__flags__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCEngine__unsigned__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_register_t__flags__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_register_t__flags(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__unsigned((unsigned *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__unsigned__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_register_t__flags__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_register_t__flags(a, f) \
+-	__NDR_convert__int_rep__unsigned((unsigned *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__JackRPCEngine__uint32_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_register_t__flags__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_register_t__flags(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__uint32_t((uint32_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__uint32_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_register_t__flags__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_register_t__flags(a, f) \
+-	__NDR_convert__int_rep__uint32_t((uint32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Request__rpc_jack_port_register_t__flags__defined */
+-
+-#ifndef __NDR_convert__int_rep__Request__rpc_jack_port_register_t__buffer_size__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCEngine__unsigned__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_register_t__buffer_size__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_register_t__buffer_size(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__unsigned((unsigned *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__unsigned__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_register_t__buffer_size__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_register_t__buffer_size(a, f) \
+-	__NDR_convert__int_rep__unsigned((unsigned *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__JackRPCEngine__uint32_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_register_t__buffer_size__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_register_t__buffer_size(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__uint32_t((uint32_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__uint32_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_register_t__buffer_size__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_register_t__buffer_size(a, f) \
+-	__NDR_convert__int_rep__uint32_t((uint32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Request__rpc_jack_port_register_t__buffer_size__defined */
+-
+-#ifndef __NDR_convert__char_rep__Request__rpc_jack_port_register_t__refnum__defined
+-#if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_register_t__refnum__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_register_t__refnum(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_register_t__refnum__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_register_t__refnum(a, f) \
+-	__NDR_convert__char_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_register_t__refnum__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_register_t__refnum(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int32_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_register_t__refnum__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_register_t__refnum(a, f) \
+-	__NDR_convert__char_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__char_rep__Request__rpc_jack_port_register_t__refnum__defined */
+-
+-#ifndef __NDR_convert__char_rep__Request__rpc_jack_port_register_t__name__defined
+-#if	defined(__NDR_convert__char_rep__JackRPCEngine__client_port_name_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_register_t__name__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_register_t__name(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__client_port_name_t((client_port_name_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__client_port_name_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_register_t__name__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_register_t__name(a, f) \
+-	__NDR_convert__char_rep__client_port_name_t((client_port_name_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__JackRPCEngine__string__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_register_t__name__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_register_t__name(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__string(a, f, 128)
+-#elif	defined(__NDR_convert__char_rep__string__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_register_t__name__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_register_t__name(a, f) \
+-	__NDR_convert__char_rep__string(a, f, 128)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__char_rep__Request__rpc_jack_port_register_t__name__defined */
+-
+-#ifndef __NDR_convert__char_rep__Request__rpc_jack_port_register_t__port_type__defined
+-#if	defined(__NDR_convert__char_rep__JackRPCEngine__client_port_type_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_register_t__port_type__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_register_t__port_type(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__client_port_type_t((client_port_type_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__client_port_type_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_register_t__port_type__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_register_t__port_type(a, f) \
+-	__NDR_convert__char_rep__client_port_type_t((client_port_type_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__JackRPCEngine__string__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_register_t__port_type__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_register_t__port_type(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__string(a, f, 128)
+-#elif	defined(__NDR_convert__char_rep__string__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_register_t__port_type__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_register_t__port_type(a, f) \
+-	__NDR_convert__char_rep__string(a, f, 128)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__char_rep__Request__rpc_jack_port_register_t__port_type__defined */
+-
+-#ifndef __NDR_convert__char_rep__Request__rpc_jack_port_register_t__flags__defined
+-#if	defined(__NDR_convert__char_rep__JackRPCEngine__unsigned__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_register_t__flags__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_register_t__flags(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__unsigned((unsigned *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__unsigned__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_register_t__flags__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_register_t__flags(a, f) \
+-	__NDR_convert__char_rep__unsigned((unsigned *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__JackRPCEngine__uint32_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_register_t__flags__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_register_t__flags(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__uint32_t((uint32_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__uint32_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_register_t__flags__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_register_t__flags(a, f) \
+-	__NDR_convert__char_rep__uint32_t((uint32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__char_rep__Request__rpc_jack_port_register_t__flags__defined */
+-
+-#ifndef __NDR_convert__char_rep__Request__rpc_jack_port_register_t__buffer_size__defined
+-#if	defined(__NDR_convert__char_rep__JackRPCEngine__unsigned__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_register_t__buffer_size__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_register_t__buffer_size(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__unsigned((unsigned *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__unsigned__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_register_t__buffer_size__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_register_t__buffer_size(a, f) \
+-	__NDR_convert__char_rep__unsigned((unsigned *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__JackRPCEngine__uint32_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_register_t__buffer_size__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_register_t__buffer_size(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__uint32_t((uint32_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__uint32_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_register_t__buffer_size__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_register_t__buffer_size(a, f) \
+-	__NDR_convert__char_rep__uint32_t((uint32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__char_rep__Request__rpc_jack_port_register_t__buffer_size__defined */
+-
+-#ifndef __NDR_convert__float_rep__Request__rpc_jack_port_register_t__refnum__defined
+-#if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_register_t__refnum__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_register_t__refnum(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_register_t__refnum__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_register_t__refnum(a, f) \
+-	__NDR_convert__float_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_register_t__refnum__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_register_t__refnum(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int32_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_register_t__refnum__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_register_t__refnum(a, f) \
+-	__NDR_convert__float_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__float_rep__Request__rpc_jack_port_register_t__refnum__defined */
+-
+-#ifndef __NDR_convert__float_rep__Request__rpc_jack_port_register_t__name__defined
+-#if	defined(__NDR_convert__float_rep__JackRPCEngine__client_port_name_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_register_t__name__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_register_t__name(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__client_port_name_t((client_port_name_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__client_port_name_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_register_t__name__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_register_t__name(a, f) \
+-	__NDR_convert__float_rep__client_port_name_t((client_port_name_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__JackRPCEngine__string__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_register_t__name__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_register_t__name(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__string(a, f, 128)
+-#elif	defined(__NDR_convert__float_rep__string__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_register_t__name__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_register_t__name(a, f) \
+-	__NDR_convert__float_rep__string(a, f, 128)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__float_rep__Request__rpc_jack_port_register_t__name__defined */
+-
+-#ifndef __NDR_convert__float_rep__Request__rpc_jack_port_register_t__port_type__defined
+-#if	defined(__NDR_convert__float_rep__JackRPCEngine__client_port_type_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_register_t__port_type__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_register_t__port_type(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__client_port_type_t((client_port_type_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__client_port_type_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_register_t__port_type__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_register_t__port_type(a, f) \
+-	__NDR_convert__float_rep__client_port_type_t((client_port_type_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__JackRPCEngine__string__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_register_t__port_type__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_register_t__port_type(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__string(a, f, 128)
+-#elif	defined(__NDR_convert__float_rep__string__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_register_t__port_type__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_register_t__port_type(a, f) \
+-	__NDR_convert__float_rep__string(a, f, 128)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__float_rep__Request__rpc_jack_port_register_t__port_type__defined */
+-
+-#ifndef __NDR_convert__float_rep__Request__rpc_jack_port_register_t__flags__defined
+-#if	defined(__NDR_convert__float_rep__JackRPCEngine__unsigned__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_register_t__flags__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_register_t__flags(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__unsigned((unsigned *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__unsigned__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_register_t__flags__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_register_t__flags(a, f) \
+-	__NDR_convert__float_rep__unsigned((unsigned *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__JackRPCEngine__uint32_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_register_t__flags__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_register_t__flags(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__uint32_t((uint32_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__uint32_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_register_t__flags__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_register_t__flags(a, f) \
+-	__NDR_convert__float_rep__uint32_t((uint32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__float_rep__Request__rpc_jack_port_register_t__flags__defined */
+-
+-#ifndef __NDR_convert__float_rep__Request__rpc_jack_port_register_t__buffer_size__defined
+-#if	defined(__NDR_convert__float_rep__JackRPCEngine__unsigned__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_register_t__buffer_size__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_register_t__buffer_size(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__unsigned((unsigned *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__unsigned__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_register_t__buffer_size__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_register_t__buffer_size(a, f) \
+-	__NDR_convert__float_rep__unsigned((unsigned *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__JackRPCEngine__uint32_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_register_t__buffer_size__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_register_t__buffer_size(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__uint32_t((uint32_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__uint32_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_register_t__buffer_size__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_register_t__buffer_size(a, f) \
+-	__NDR_convert__float_rep__uint32_t((uint32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__float_rep__Request__rpc_jack_port_register_t__buffer_size__defined */
+-
+-
+-mig_internal kern_return_t __MIG_check__Request__rpc_jack_port_register_t(__attribute__((__unused__)) __Request__rpc_jack_port_register_t *In0P)
+-{
+-
+-	typedef __Request__rpc_jack_port_register_t __Request;
+-#if	__MigTypeCheck
+-	if ((In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
+-	    (In0P->Head.msgh_size != (mach_msg_size_t)sizeof(__Request)))
+-		return MIG_BAD_ARGUMENTS;
+-#endif	/* __MigTypeCheck */
+-
+-#if __MigTypeCheck
+-	{
+-		char * msg_limit = ((char *) In0P) + In0P->Head.msgh_size;
+-		size_t memchr_limit;
+-
+-		memchr_limit = min((msg_limit - In0P->name),  128);
+-		if (( memchr(In0P->name, '\0', memchr_limit) == NULL ))
+-			return MIG_BAD_ARGUMENTS; // string length exceeds buffer length!
+-		memchr_limit = min((msg_limit - In0P->port_type),  128);
+-		if (( memchr(In0P->port_type, '\0', memchr_limit) == NULL ))
+-			return MIG_BAD_ARGUMENTS; // string length exceeds buffer length!
+-	}
+-#endif	/* __MigTypeCheck */
+-
+-#if	defined(__NDR_convert__int_rep__Request__rpc_jack_port_register_t__refnum__defined) || \
+-	defined(__NDR_convert__int_rep__Request__rpc_jack_port_register_t__name__defined) || \
+-	defined(__NDR_convert__int_rep__Request__rpc_jack_port_register_t__port_type__defined) || \
+-	defined(__NDR_convert__int_rep__Request__rpc_jack_port_register_t__flags__defined) || \
+-	defined(__NDR_convert__int_rep__Request__rpc_jack_port_register_t__buffer_size__defined)
+-	if (In0P->NDR.int_rep != NDR_record.int_rep) {
+-#if defined(__NDR_convert__int_rep__Request__rpc_jack_port_register_t__refnum__defined)
+-		__NDR_convert__int_rep__Request__rpc_jack_port_register_t__refnum(&In0P->refnum, In0P->NDR.int_rep);
+-#endif	/* __NDR_convert__int_rep__Request__rpc_jack_port_register_t__refnum__defined */
+-#if defined(__NDR_convert__int_rep__Request__rpc_jack_port_register_t__name__defined)
+-		__NDR_convert__int_rep__Request__rpc_jack_port_register_t__name(&In0P->name, In0P->NDR.int_rep);
+-#endif	/* __NDR_convert__int_rep__Request__rpc_jack_port_register_t__name__defined */
+-#if defined(__NDR_convert__int_rep__Request__rpc_jack_port_register_t__port_type__defined)
+-		__NDR_convert__int_rep__Request__rpc_jack_port_register_t__port_type(&In0P->port_type, In0P->NDR.int_rep);
+-#endif	/* __NDR_convert__int_rep__Request__rpc_jack_port_register_t__port_type__defined */
+-#if defined(__NDR_convert__int_rep__Request__rpc_jack_port_register_t__flags__defined)
+-		__NDR_convert__int_rep__Request__rpc_jack_port_register_t__flags(&In0P->flags, In0P->NDR.int_rep);
+-#endif	/* __NDR_convert__int_rep__Request__rpc_jack_port_register_t__flags__defined */
+-#if defined(__NDR_convert__int_rep__Request__rpc_jack_port_register_t__buffer_size__defined)
+-		__NDR_convert__int_rep__Request__rpc_jack_port_register_t__buffer_size(&In0P->buffer_size, In0P->NDR.int_rep);
+-#endif	/* __NDR_convert__int_rep__Request__rpc_jack_port_register_t__buffer_size__defined */
+-	}
+-#endif	/* defined(__NDR_convert__int_rep...) */
+-
+-#if	defined(__NDR_convert__char_rep__Request__rpc_jack_port_register_t__refnum__defined) || \
+-	defined(__NDR_convert__char_rep__Request__rpc_jack_port_register_t__name__defined) || \
+-	defined(__NDR_convert__char_rep__Request__rpc_jack_port_register_t__port_type__defined) || \
+-	defined(__NDR_convert__char_rep__Request__rpc_jack_port_register_t__flags__defined) || \
+-	defined(__NDR_convert__char_rep__Request__rpc_jack_port_register_t__buffer_size__defined)
+-	if (In0P->NDR.char_rep != NDR_record.char_rep) {
+-#if defined(__NDR_convert__char_rep__Request__rpc_jack_port_register_t__refnum__defined)
+-		__NDR_convert__char_rep__Request__rpc_jack_port_register_t__refnum(&In0P->refnum, In0P->NDR.char_rep);
+-#endif	/* __NDR_convert__char_rep__Request__rpc_jack_port_register_t__refnum__defined */
+-#if defined(__NDR_convert__char_rep__Request__rpc_jack_port_register_t__name__defined)
+-		__NDR_convert__char_rep__Request__rpc_jack_port_register_t__name(&In0P->name, In0P->NDR.char_rep);
+-#endif	/* __NDR_convert__char_rep__Request__rpc_jack_port_register_t__name__defined */
+-#if defined(__NDR_convert__char_rep__Request__rpc_jack_port_register_t__port_type__defined)
+-		__NDR_convert__char_rep__Request__rpc_jack_port_register_t__port_type(&In0P->port_type, In0P->NDR.char_rep);
+-#endif	/* __NDR_convert__char_rep__Request__rpc_jack_port_register_t__port_type__defined */
+-#if defined(__NDR_convert__char_rep__Request__rpc_jack_port_register_t__flags__defined)
+-		__NDR_convert__char_rep__Request__rpc_jack_port_register_t__flags(&In0P->flags, In0P->NDR.char_rep);
+-#endif	/* __NDR_convert__char_rep__Request__rpc_jack_port_register_t__flags__defined */
+-#if defined(__NDR_convert__char_rep__Request__rpc_jack_port_register_t__buffer_size__defined)
+-		__NDR_convert__char_rep__Request__rpc_jack_port_register_t__buffer_size(&In0P->buffer_size, In0P->NDR.char_rep);
+-#endif	/* __NDR_convert__char_rep__Request__rpc_jack_port_register_t__buffer_size__defined */
+-	}
+-#endif	/* defined(__NDR_convert__char_rep...) */
+-
+-#if	defined(__NDR_convert__float_rep__Request__rpc_jack_port_register_t__refnum__defined) || \
+-	defined(__NDR_convert__float_rep__Request__rpc_jack_port_register_t__name__defined) || \
+-	defined(__NDR_convert__float_rep__Request__rpc_jack_port_register_t__port_type__defined) || \
+-	defined(__NDR_convert__float_rep__Request__rpc_jack_port_register_t__flags__defined) || \
+-	defined(__NDR_convert__float_rep__Request__rpc_jack_port_register_t__buffer_size__defined)
+-	if (In0P->NDR.float_rep != NDR_record.float_rep) {
+-#if defined(__NDR_convert__float_rep__Request__rpc_jack_port_register_t__refnum__defined)
+-		__NDR_convert__float_rep__Request__rpc_jack_port_register_t__refnum(&In0P->refnum, In0P->NDR.float_rep);
+-#endif	/* __NDR_convert__float_rep__Request__rpc_jack_port_register_t__refnum__defined */
+-#if defined(__NDR_convert__float_rep__Request__rpc_jack_port_register_t__name__defined)
+-		__NDR_convert__float_rep__Request__rpc_jack_port_register_t__name(&In0P->name, In0P->NDR.float_rep);
+-#endif	/* __NDR_convert__float_rep__Request__rpc_jack_port_register_t__name__defined */
+-#if defined(__NDR_convert__float_rep__Request__rpc_jack_port_register_t__port_type__defined)
+-		__NDR_convert__float_rep__Request__rpc_jack_port_register_t__port_type(&In0P->port_type, In0P->NDR.float_rep);
+-#endif	/* __NDR_convert__float_rep__Request__rpc_jack_port_register_t__port_type__defined */
+-#if defined(__NDR_convert__float_rep__Request__rpc_jack_port_register_t__flags__defined)
+-		__NDR_convert__float_rep__Request__rpc_jack_port_register_t__flags(&In0P->flags, In0P->NDR.float_rep);
+-#endif	/* __NDR_convert__float_rep__Request__rpc_jack_port_register_t__flags__defined */
+-#if defined(__NDR_convert__float_rep__Request__rpc_jack_port_register_t__buffer_size__defined)
+-		__NDR_convert__float_rep__Request__rpc_jack_port_register_t__buffer_size(&In0P->buffer_size, In0P->NDR.float_rep);
+-#endif	/* __NDR_convert__float_rep__Request__rpc_jack_port_register_t__buffer_size__defined */
+-	}
+-#endif	/* defined(__NDR_convert__float_rep...) */
+-
+-	return MACH_MSG_SUCCESS;
+-}
+-#endif /* !defined(__MIG_check__Request__rpc_jack_port_register_t__defined) */
+-#endif /* __MIG_check__Request__JackRPCEngine_subsystem__ */
+-#endif /* ( __MigTypeCheck || __NDR_convert__ ) */
+-
+-
+-/* Routine rpc_jack_port_register */
+-#ifdef	mig_external
+-mig_external
+-#else
+-extern
+-#endif	/* mig_external */
+-kern_return_t server_rpc_jack_port_register
+-(
+-	mach_port_t server_port,
+-	int refnum,
+-	client_port_name_t name,
+-	client_port_type_t port_type,
+-	unsigned flags,
+-	unsigned buffer_size,
+-	unsigned *port_index,
+-	int *result
+-);
+-
+-/* Routine rpc_jack_port_register */
+-mig_internal novalue _Xrpc_jack_port_register
+-	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
+-{
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		int refnum;
+-		client_port_name_t name;
+-		client_port_type_t port_type;
+-		unsigned flags;
+-		unsigned buffer_size;
+-		mach_msg_trailer_t trailer;
+-	} Request;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-	typedef __Request__rpc_jack_port_register_t __Request;
+-	typedef __Reply__rpc_jack_port_register_t Reply;
+-
+-	/*
+-	 * typedef struct {
+-	 * 	mach_msg_header_t Head;
+-	 * 	NDR_record_t NDR;
+-	 * 	kern_return_t RetCode;
+-	 * } mig_reply_error_t;
+-	 */
+-
+-	Request *In0P = (Request *) InHeadP;
+-	Reply *OutP = (Reply *) OutHeadP;
+-#ifdef	__MIG_check__Request__rpc_jack_port_register_t__defined
+-	kern_return_t check_result;
+-#endif	/* __MIG_check__Request__rpc_jack_port_register_t__defined */
+-
+-	__DeclareRcvRpc(1005, "rpc_jack_port_register")
+-	__BeforeRcvRpc(1005, "rpc_jack_port_register")
+-
+-#if	defined(__MIG_check__Request__rpc_jack_port_register_t__defined)
+-	check_result = __MIG_check__Request__rpc_jack_port_register_t((__Request *)In0P);
+-	if (check_result != MACH_MSG_SUCCESS)
+-		{ MIG_RETURN_ERROR(OutP, check_result); }
+-#endif	/* defined(__MIG_check__Request__rpc_jack_port_register_t__defined) */
+-
+-	OutP->RetCode = server_rpc_jack_port_register(In0P->Head.msgh_request_port, In0P->refnum, In0P->name, In0P->port_type, In0P->flags, In0P->buffer_size, &OutP->port_index, &OutP->result);
+-	if (OutP->RetCode != KERN_SUCCESS) {
+-		MIG_RETURN_ERROR(OutP, OutP->RetCode);
+-	}
+-
+-	OutP->NDR = NDR_record;
+-
+-
+-	OutP->Head.msgh_size = (mach_msg_size_t)(sizeof(Reply));
+-	__AfterRcvRpc(1005, "rpc_jack_port_register")
+-}
+-
+-#if ( __MigTypeCheck || __NDR_convert__ )
+-#if __MIG_check__Request__JackRPCEngine_subsystem__
+-#if !defined(__MIG_check__Request__rpc_jack_port_unregister_t__defined)
+-#define __MIG_check__Request__rpc_jack_port_unregister_t__defined
+-#ifndef __NDR_convert__int_rep__Request__rpc_jack_port_unregister_t__refnum__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_unregister_t__refnum__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_unregister_t__refnum(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_unregister_t__refnum__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_unregister_t__refnum(a, f) \
+-	__NDR_convert__int_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_unregister_t__refnum__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_unregister_t__refnum(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int32_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_unregister_t__refnum__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_unregister_t__refnum(a, f) \
+-	__NDR_convert__int_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Request__rpc_jack_port_unregister_t__refnum__defined */
+-
+-#ifndef __NDR_convert__int_rep__Request__rpc_jack_port_unregister_t__port__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_unregister_t__port__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_unregister_t__port(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_unregister_t__port__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_unregister_t__port(a, f) \
+-	__NDR_convert__int_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_unregister_t__port__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_unregister_t__port(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int32_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_unregister_t__port__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_unregister_t__port(a, f) \
+-	__NDR_convert__int_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Request__rpc_jack_port_unregister_t__port__defined */
+-
+-#ifndef __NDR_convert__char_rep__Request__rpc_jack_port_unregister_t__refnum__defined
+-#if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_unregister_t__refnum__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_unregister_t__refnum(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_unregister_t__refnum__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_unregister_t__refnum(a, f) \
+-	__NDR_convert__char_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_unregister_t__refnum__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_unregister_t__refnum(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int32_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_unregister_t__refnum__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_unregister_t__refnum(a, f) \
+-	__NDR_convert__char_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__char_rep__Request__rpc_jack_port_unregister_t__refnum__defined */
+-
+-#ifndef __NDR_convert__char_rep__Request__rpc_jack_port_unregister_t__port__defined
+-#if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_unregister_t__port__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_unregister_t__port(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_unregister_t__port__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_unregister_t__port(a, f) \
+-	__NDR_convert__char_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_unregister_t__port__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_unregister_t__port(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int32_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_unregister_t__port__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_unregister_t__port(a, f) \
+-	__NDR_convert__char_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__char_rep__Request__rpc_jack_port_unregister_t__port__defined */
+-
+-#ifndef __NDR_convert__float_rep__Request__rpc_jack_port_unregister_t__refnum__defined
+-#if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_unregister_t__refnum__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_unregister_t__refnum(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_unregister_t__refnum__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_unregister_t__refnum(a, f) \
+-	__NDR_convert__float_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_unregister_t__refnum__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_unregister_t__refnum(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int32_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_unregister_t__refnum__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_unregister_t__refnum(a, f) \
+-	__NDR_convert__float_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__float_rep__Request__rpc_jack_port_unregister_t__refnum__defined */
+-
+-#ifndef __NDR_convert__float_rep__Request__rpc_jack_port_unregister_t__port__defined
+-#if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_unregister_t__port__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_unregister_t__port(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_unregister_t__port__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_unregister_t__port(a, f) \
+-	__NDR_convert__float_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_unregister_t__port__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_unregister_t__port(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int32_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_unregister_t__port__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_unregister_t__port(a, f) \
+-	__NDR_convert__float_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__float_rep__Request__rpc_jack_port_unregister_t__port__defined */
+-
+-
+-mig_internal kern_return_t __MIG_check__Request__rpc_jack_port_unregister_t(__attribute__((__unused__)) __Request__rpc_jack_port_unregister_t *In0P)
+-{
+-
+-	typedef __Request__rpc_jack_port_unregister_t __Request;
+-#if	__MigTypeCheck
+-	if ((In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
+-	    (In0P->Head.msgh_size != (mach_msg_size_t)sizeof(__Request)))
+-		return MIG_BAD_ARGUMENTS;
+-#endif	/* __MigTypeCheck */
+-
+-#if	defined(__NDR_convert__int_rep__Request__rpc_jack_port_unregister_t__refnum__defined) || \
+-	defined(__NDR_convert__int_rep__Request__rpc_jack_port_unregister_t__port__defined)
+-	if (In0P->NDR.int_rep != NDR_record.int_rep) {
+-#if defined(__NDR_convert__int_rep__Request__rpc_jack_port_unregister_t__refnum__defined)
+-		__NDR_convert__int_rep__Request__rpc_jack_port_unregister_t__refnum(&In0P->refnum, In0P->NDR.int_rep);
+-#endif	/* __NDR_convert__int_rep__Request__rpc_jack_port_unregister_t__refnum__defined */
+-#if defined(__NDR_convert__int_rep__Request__rpc_jack_port_unregister_t__port__defined)
+-		__NDR_convert__int_rep__Request__rpc_jack_port_unregister_t__port(&In0P->port, In0P->NDR.int_rep);
+-#endif	/* __NDR_convert__int_rep__Request__rpc_jack_port_unregister_t__port__defined */
+-	}
+-#endif	/* defined(__NDR_convert__int_rep...) */
+-
+-#if	defined(__NDR_convert__char_rep__Request__rpc_jack_port_unregister_t__refnum__defined) || \
+-	defined(__NDR_convert__char_rep__Request__rpc_jack_port_unregister_t__port__defined)
+-	if (In0P->NDR.char_rep != NDR_record.char_rep) {
+-#if defined(__NDR_convert__char_rep__Request__rpc_jack_port_unregister_t__refnum__defined)
+-		__NDR_convert__char_rep__Request__rpc_jack_port_unregister_t__refnum(&In0P->refnum, In0P->NDR.char_rep);
+-#endif	/* __NDR_convert__char_rep__Request__rpc_jack_port_unregister_t__refnum__defined */
+-#if defined(__NDR_convert__char_rep__Request__rpc_jack_port_unregister_t__port__defined)
+-		__NDR_convert__char_rep__Request__rpc_jack_port_unregister_t__port(&In0P->port, In0P->NDR.char_rep);
+-#endif	/* __NDR_convert__char_rep__Request__rpc_jack_port_unregister_t__port__defined */
+-	}
+-#endif	/* defined(__NDR_convert__char_rep...) */
+-
+-#if	defined(__NDR_convert__float_rep__Request__rpc_jack_port_unregister_t__refnum__defined) || \
+-	defined(__NDR_convert__float_rep__Request__rpc_jack_port_unregister_t__port__defined)
+-	if (In0P->NDR.float_rep != NDR_record.float_rep) {
+-#if defined(__NDR_convert__float_rep__Request__rpc_jack_port_unregister_t__refnum__defined)
+-		__NDR_convert__float_rep__Request__rpc_jack_port_unregister_t__refnum(&In0P->refnum, In0P->NDR.float_rep);
+-#endif	/* __NDR_convert__float_rep__Request__rpc_jack_port_unregister_t__refnum__defined */
+-#if defined(__NDR_convert__float_rep__Request__rpc_jack_port_unregister_t__port__defined)
+-		__NDR_convert__float_rep__Request__rpc_jack_port_unregister_t__port(&In0P->port, In0P->NDR.float_rep);
+-#endif	/* __NDR_convert__float_rep__Request__rpc_jack_port_unregister_t__port__defined */
+-	}
+-#endif	/* defined(__NDR_convert__float_rep...) */
+-
+-	return MACH_MSG_SUCCESS;
+-}
+-#endif /* !defined(__MIG_check__Request__rpc_jack_port_unregister_t__defined) */
+-#endif /* __MIG_check__Request__JackRPCEngine_subsystem__ */
+-#endif /* ( __MigTypeCheck || __NDR_convert__ ) */
+-
+-
+-/* Routine rpc_jack_port_unregister */
+-#ifdef	mig_external
+-mig_external
+-#else
+-extern
+-#endif	/* mig_external */
+-kern_return_t server_rpc_jack_port_unregister
+-(
+-	mach_port_t server_port,
+-	int refnum,
+-	int port,
+-	int *result
+-);
+-
+-/* Routine rpc_jack_port_unregister */
+-mig_internal novalue _Xrpc_jack_port_unregister
+-	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
+-{
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		int refnum;
+-		int port;
+-		mach_msg_trailer_t trailer;
+-	} Request;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-	typedef __Request__rpc_jack_port_unregister_t __Request;
+-	typedef __Reply__rpc_jack_port_unregister_t Reply;
+-
+-	/*
+-	 * typedef struct {
+-	 * 	mach_msg_header_t Head;
+-	 * 	NDR_record_t NDR;
+-	 * 	kern_return_t RetCode;
+-	 * } mig_reply_error_t;
+-	 */
+-
+-	Request *In0P = (Request *) InHeadP;
+-	Reply *OutP = (Reply *) OutHeadP;
+-#ifdef	__MIG_check__Request__rpc_jack_port_unregister_t__defined
+-	kern_return_t check_result;
+-#endif	/* __MIG_check__Request__rpc_jack_port_unregister_t__defined */
+-
+-	__DeclareRcvRpc(1006, "rpc_jack_port_unregister")
+-	__BeforeRcvRpc(1006, "rpc_jack_port_unregister")
+-
+-#if	defined(__MIG_check__Request__rpc_jack_port_unregister_t__defined)
+-	check_result = __MIG_check__Request__rpc_jack_port_unregister_t((__Request *)In0P);
+-	if (check_result != MACH_MSG_SUCCESS)
+-		{ MIG_RETURN_ERROR(OutP, check_result); }
+-#endif	/* defined(__MIG_check__Request__rpc_jack_port_unregister_t__defined) */
+-
+-	OutP->RetCode = server_rpc_jack_port_unregister(In0P->Head.msgh_request_port, In0P->refnum, In0P->port, &OutP->result);
+-	if (OutP->RetCode != KERN_SUCCESS) {
+-		MIG_RETURN_ERROR(OutP, OutP->RetCode);
+-	}
+-
+-	OutP->NDR = NDR_record;
+-
+-
+-	OutP->Head.msgh_size = (mach_msg_size_t)(sizeof(Reply));
+-	__AfterRcvRpc(1006, "rpc_jack_port_unregister")
+-}
+-
+-#if ( __MigTypeCheck || __NDR_convert__ )
+-#if __MIG_check__Request__JackRPCEngine_subsystem__
+-#if !defined(__MIG_check__Request__rpc_jack_port_connect_t__defined)
+-#define __MIG_check__Request__rpc_jack_port_connect_t__defined
+-#ifndef __NDR_convert__int_rep__Request__rpc_jack_port_connect_t__refnum__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_connect_t__refnum__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_connect_t__refnum(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_connect_t__refnum__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_connect_t__refnum(a, f) \
+-	__NDR_convert__int_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_connect_t__refnum__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_connect_t__refnum(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int32_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_connect_t__refnum__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_connect_t__refnum(a, f) \
+-	__NDR_convert__int_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Request__rpc_jack_port_connect_t__refnum__defined */
+-
+-#ifndef __NDR_convert__int_rep__Request__rpc_jack_port_connect_t__src__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_connect_t__src__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_connect_t__src(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_connect_t__src__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_connect_t__src(a, f) \
+-	__NDR_convert__int_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_connect_t__src__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_connect_t__src(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int32_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_connect_t__src__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_connect_t__src(a, f) \
+-	__NDR_convert__int_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Request__rpc_jack_port_connect_t__src__defined */
+-
+-#ifndef __NDR_convert__int_rep__Request__rpc_jack_port_connect_t__dst__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_connect_t__dst__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_connect_t__dst(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_connect_t__dst__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_connect_t__dst(a, f) \
+-	__NDR_convert__int_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_connect_t__dst__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_connect_t__dst(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int32_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_connect_t__dst__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_connect_t__dst(a, f) \
+-	__NDR_convert__int_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Request__rpc_jack_port_connect_t__dst__defined */
+-
+-#ifndef __NDR_convert__char_rep__Request__rpc_jack_port_connect_t__refnum__defined
+-#if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_connect_t__refnum__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_connect_t__refnum(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_connect_t__refnum__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_connect_t__refnum(a, f) \
+-	__NDR_convert__char_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_connect_t__refnum__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_connect_t__refnum(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int32_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_connect_t__refnum__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_connect_t__refnum(a, f) \
+-	__NDR_convert__char_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__char_rep__Request__rpc_jack_port_connect_t__refnum__defined */
+-
+-#ifndef __NDR_convert__char_rep__Request__rpc_jack_port_connect_t__src__defined
+-#if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_connect_t__src__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_connect_t__src(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_connect_t__src__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_connect_t__src(a, f) \
+-	__NDR_convert__char_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_connect_t__src__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_connect_t__src(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int32_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_connect_t__src__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_connect_t__src(a, f) \
+-	__NDR_convert__char_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__char_rep__Request__rpc_jack_port_connect_t__src__defined */
+-
+-#ifndef __NDR_convert__char_rep__Request__rpc_jack_port_connect_t__dst__defined
+-#if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_connect_t__dst__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_connect_t__dst(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_connect_t__dst__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_connect_t__dst(a, f) \
+-	__NDR_convert__char_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_connect_t__dst__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_connect_t__dst(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int32_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_connect_t__dst__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_connect_t__dst(a, f) \
+-	__NDR_convert__char_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__char_rep__Request__rpc_jack_port_connect_t__dst__defined */
+-
+-#ifndef __NDR_convert__float_rep__Request__rpc_jack_port_connect_t__refnum__defined
+-#if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_connect_t__refnum__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_connect_t__refnum(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_connect_t__refnum__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_connect_t__refnum(a, f) \
+-	__NDR_convert__float_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_connect_t__refnum__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_connect_t__refnum(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int32_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_connect_t__refnum__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_connect_t__refnum(a, f) \
+-	__NDR_convert__float_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__float_rep__Request__rpc_jack_port_connect_t__refnum__defined */
+-
+-#ifndef __NDR_convert__float_rep__Request__rpc_jack_port_connect_t__src__defined
+-#if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_connect_t__src__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_connect_t__src(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_connect_t__src__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_connect_t__src(a, f) \
+-	__NDR_convert__float_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_connect_t__src__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_connect_t__src(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int32_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_connect_t__src__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_connect_t__src(a, f) \
+-	__NDR_convert__float_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__float_rep__Request__rpc_jack_port_connect_t__src__defined */
+-
+-#ifndef __NDR_convert__float_rep__Request__rpc_jack_port_connect_t__dst__defined
+-#if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_connect_t__dst__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_connect_t__dst(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_connect_t__dst__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_connect_t__dst(a, f) \
+-	__NDR_convert__float_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_connect_t__dst__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_connect_t__dst(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int32_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_connect_t__dst__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_connect_t__dst(a, f) \
+-	__NDR_convert__float_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__float_rep__Request__rpc_jack_port_connect_t__dst__defined */
+-
+-
+-mig_internal kern_return_t __MIG_check__Request__rpc_jack_port_connect_t(__attribute__((__unused__)) __Request__rpc_jack_port_connect_t *In0P)
+-{
+-
+-	typedef __Request__rpc_jack_port_connect_t __Request;
+-#if	__MigTypeCheck
+-	if ((In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
+-	    (In0P->Head.msgh_size != (mach_msg_size_t)sizeof(__Request)))
+-		return MIG_BAD_ARGUMENTS;
+-#endif	/* __MigTypeCheck */
+-
+-#if	defined(__NDR_convert__int_rep__Request__rpc_jack_port_connect_t__refnum__defined) || \
+-	defined(__NDR_convert__int_rep__Request__rpc_jack_port_connect_t__src__defined) || \
+-	defined(__NDR_convert__int_rep__Request__rpc_jack_port_connect_t__dst__defined)
+-	if (In0P->NDR.int_rep != NDR_record.int_rep) {
+-#if defined(__NDR_convert__int_rep__Request__rpc_jack_port_connect_t__refnum__defined)
+-		__NDR_convert__int_rep__Request__rpc_jack_port_connect_t__refnum(&In0P->refnum, In0P->NDR.int_rep);
+-#endif	/* __NDR_convert__int_rep__Request__rpc_jack_port_connect_t__refnum__defined */
+-#if defined(__NDR_convert__int_rep__Request__rpc_jack_port_connect_t__src__defined)
+-		__NDR_convert__int_rep__Request__rpc_jack_port_connect_t__src(&In0P->src, In0P->NDR.int_rep);
+-#endif	/* __NDR_convert__int_rep__Request__rpc_jack_port_connect_t__src__defined */
+-#if defined(__NDR_convert__int_rep__Request__rpc_jack_port_connect_t__dst__defined)
+-		__NDR_convert__int_rep__Request__rpc_jack_port_connect_t__dst(&In0P->dst, In0P->NDR.int_rep);
+-#endif	/* __NDR_convert__int_rep__Request__rpc_jack_port_connect_t__dst__defined */
+-	}
+-#endif	/* defined(__NDR_convert__int_rep...) */
+-
+-#if	defined(__NDR_convert__char_rep__Request__rpc_jack_port_connect_t__refnum__defined) || \
+-	defined(__NDR_convert__char_rep__Request__rpc_jack_port_connect_t__src__defined) || \
+-	defined(__NDR_convert__char_rep__Request__rpc_jack_port_connect_t__dst__defined)
+-	if (In0P->NDR.char_rep != NDR_record.char_rep) {
+-#if defined(__NDR_convert__char_rep__Request__rpc_jack_port_connect_t__refnum__defined)
+-		__NDR_convert__char_rep__Request__rpc_jack_port_connect_t__refnum(&In0P->refnum, In0P->NDR.char_rep);
+-#endif	/* __NDR_convert__char_rep__Request__rpc_jack_port_connect_t__refnum__defined */
+-#if defined(__NDR_convert__char_rep__Request__rpc_jack_port_connect_t__src__defined)
+-		__NDR_convert__char_rep__Request__rpc_jack_port_connect_t__src(&In0P->src, In0P->NDR.char_rep);
+-#endif	/* __NDR_convert__char_rep__Request__rpc_jack_port_connect_t__src__defined */
+-#if defined(__NDR_convert__char_rep__Request__rpc_jack_port_connect_t__dst__defined)
+-		__NDR_convert__char_rep__Request__rpc_jack_port_connect_t__dst(&In0P->dst, In0P->NDR.char_rep);
+-#endif	/* __NDR_convert__char_rep__Request__rpc_jack_port_connect_t__dst__defined */
+-	}
+-#endif	/* defined(__NDR_convert__char_rep...) */
+-
+-#if	defined(__NDR_convert__float_rep__Request__rpc_jack_port_connect_t__refnum__defined) || \
+-	defined(__NDR_convert__float_rep__Request__rpc_jack_port_connect_t__src__defined) || \
+-	defined(__NDR_convert__float_rep__Request__rpc_jack_port_connect_t__dst__defined)
+-	if (In0P->NDR.float_rep != NDR_record.float_rep) {
+-#if defined(__NDR_convert__float_rep__Request__rpc_jack_port_connect_t__refnum__defined)
+-		__NDR_convert__float_rep__Request__rpc_jack_port_connect_t__refnum(&In0P->refnum, In0P->NDR.float_rep);
+-#endif	/* __NDR_convert__float_rep__Request__rpc_jack_port_connect_t__refnum__defined */
+-#if defined(__NDR_convert__float_rep__Request__rpc_jack_port_connect_t__src__defined)
+-		__NDR_convert__float_rep__Request__rpc_jack_port_connect_t__src(&In0P->src, In0P->NDR.float_rep);
+-#endif	/* __NDR_convert__float_rep__Request__rpc_jack_port_connect_t__src__defined */
+-#if defined(__NDR_convert__float_rep__Request__rpc_jack_port_connect_t__dst__defined)
+-		__NDR_convert__float_rep__Request__rpc_jack_port_connect_t__dst(&In0P->dst, In0P->NDR.float_rep);
+-#endif	/* __NDR_convert__float_rep__Request__rpc_jack_port_connect_t__dst__defined */
+-	}
+-#endif	/* defined(__NDR_convert__float_rep...) */
+-
+-	return MACH_MSG_SUCCESS;
+-}
+-#endif /* !defined(__MIG_check__Request__rpc_jack_port_connect_t__defined) */
+-#endif /* __MIG_check__Request__JackRPCEngine_subsystem__ */
+-#endif /* ( __MigTypeCheck || __NDR_convert__ ) */
+-
+-
+-/* Routine rpc_jack_port_connect */
+-#ifdef	mig_external
+-mig_external
+-#else
+-extern
+-#endif	/* mig_external */
+-kern_return_t server_rpc_jack_port_connect
+-(
+-	mach_port_t server_port,
+-	int refnum,
+-	int src,
+-	int dst,
+-	int *result
+-);
+-
+-/* Routine rpc_jack_port_connect */
+-mig_internal novalue _Xrpc_jack_port_connect
+-	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
+-{
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		int refnum;
+-		int src;
+-		int dst;
+-		mach_msg_trailer_t trailer;
+-	} Request;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-	typedef __Request__rpc_jack_port_connect_t __Request;
+-	typedef __Reply__rpc_jack_port_connect_t Reply;
+-
+-	/*
+-	 * typedef struct {
+-	 * 	mach_msg_header_t Head;
+-	 * 	NDR_record_t NDR;
+-	 * 	kern_return_t RetCode;
+-	 * } mig_reply_error_t;
+-	 */
+-
+-	Request *In0P = (Request *) InHeadP;
+-	Reply *OutP = (Reply *) OutHeadP;
+-#ifdef	__MIG_check__Request__rpc_jack_port_connect_t__defined
+-	kern_return_t check_result;
+-#endif	/* __MIG_check__Request__rpc_jack_port_connect_t__defined */
+-
+-	__DeclareRcvRpc(1007, "rpc_jack_port_connect")
+-	__BeforeRcvRpc(1007, "rpc_jack_port_connect")
+-
+-#if	defined(__MIG_check__Request__rpc_jack_port_connect_t__defined)
+-	check_result = __MIG_check__Request__rpc_jack_port_connect_t((__Request *)In0P);
+-	if (check_result != MACH_MSG_SUCCESS)
+-		{ MIG_RETURN_ERROR(OutP, check_result); }
+-#endif	/* defined(__MIG_check__Request__rpc_jack_port_connect_t__defined) */
+-
+-	OutP->RetCode = server_rpc_jack_port_connect(In0P->Head.msgh_request_port, In0P->refnum, In0P->src, In0P->dst, &OutP->result);
+-	if (OutP->RetCode != KERN_SUCCESS) {
+-		MIG_RETURN_ERROR(OutP, OutP->RetCode);
+-	}
+-
+-	OutP->NDR = NDR_record;
+-
+-
+-	OutP->Head.msgh_size = (mach_msg_size_t)(sizeof(Reply));
+-	__AfterRcvRpc(1007, "rpc_jack_port_connect")
+-}
+-
+-#if ( __MigTypeCheck || __NDR_convert__ )
+-#if __MIG_check__Request__JackRPCEngine_subsystem__
+-#if !defined(__MIG_check__Request__rpc_jack_port_disconnect_t__defined)
+-#define __MIG_check__Request__rpc_jack_port_disconnect_t__defined
+-#ifndef __NDR_convert__int_rep__Request__rpc_jack_port_disconnect_t__refnum__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_disconnect_t__refnum__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_disconnect_t__refnum(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_disconnect_t__refnum__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_disconnect_t__refnum(a, f) \
+-	__NDR_convert__int_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_disconnect_t__refnum__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_disconnect_t__refnum(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int32_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_disconnect_t__refnum__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_disconnect_t__refnum(a, f) \
+-	__NDR_convert__int_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Request__rpc_jack_port_disconnect_t__refnum__defined */
+-
+-#ifndef __NDR_convert__int_rep__Request__rpc_jack_port_disconnect_t__src__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_disconnect_t__src__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_disconnect_t__src(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_disconnect_t__src__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_disconnect_t__src(a, f) \
+-	__NDR_convert__int_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_disconnect_t__src__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_disconnect_t__src(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int32_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_disconnect_t__src__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_disconnect_t__src(a, f) \
+-	__NDR_convert__int_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Request__rpc_jack_port_disconnect_t__src__defined */
+-
+-#ifndef __NDR_convert__int_rep__Request__rpc_jack_port_disconnect_t__dst__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_disconnect_t__dst__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_disconnect_t__dst(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_disconnect_t__dst__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_disconnect_t__dst(a, f) \
+-	__NDR_convert__int_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_disconnect_t__dst__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_disconnect_t__dst(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int32_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_disconnect_t__dst__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_disconnect_t__dst(a, f) \
+-	__NDR_convert__int_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Request__rpc_jack_port_disconnect_t__dst__defined */
+-
+-#ifndef __NDR_convert__char_rep__Request__rpc_jack_port_disconnect_t__refnum__defined
+-#if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_disconnect_t__refnum__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_disconnect_t__refnum(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_disconnect_t__refnum__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_disconnect_t__refnum(a, f) \
+-	__NDR_convert__char_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_disconnect_t__refnum__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_disconnect_t__refnum(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int32_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_disconnect_t__refnum__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_disconnect_t__refnum(a, f) \
+-	__NDR_convert__char_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__char_rep__Request__rpc_jack_port_disconnect_t__refnum__defined */
+-
+-#ifndef __NDR_convert__char_rep__Request__rpc_jack_port_disconnect_t__src__defined
+-#if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_disconnect_t__src__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_disconnect_t__src(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_disconnect_t__src__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_disconnect_t__src(a, f) \
+-	__NDR_convert__char_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_disconnect_t__src__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_disconnect_t__src(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int32_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_disconnect_t__src__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_disconnect_t__src(a, f) \
+-	__NDR_convert__char_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__char_rep__Request__rpc_jack_port_disconnect_t__src__defined */
+-
+-#ifndef __NDR_convert__char_rep__Request__rpc_jack_port_disconnect_t__dst__defined
+-#if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_disconnect_t__dst__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_disconnect_t__dst(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_disconnect_t__dst__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_disconnect_t__dst(a, f) \
+-	__NDR_convert__char_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_disconnect_t__dst__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_disconnect_t__dst(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int32_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_disconnect_t__dst__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_disconnect_t__dst(a, f) \
+-	__NDR_convert__char_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__char_rep__Request__rpc_jack_port_disconnect_t__dst__defined */
+-
+-#ifndef __NDR_convert__float_rep__Request__rpc_jack_port_disconnect_t__refnum__defined
+-#if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_disconnect_t__refnum__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_disconnect_t__refnum(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_disconnect_t__refnum__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_disconnect_t__refnum(a, f) \
+-	__NDR_convert__float_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_disconnect_t__refnum__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_disconnect_t__refnum(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int32_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_disconnect_t__refnum__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_disconnect_t__refnum(a, f) \
+-	__NDR_convert__float_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__float_rep__Request__rpc_jack_port_disconnect_t__refnum__defined */
+-
+-#ifndef __NDR_convert__float_rep__Request__rpc_jack_port_disconnect_t__src__defined
+-#if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_disconnect_t__src__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_disconnect_t__src(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_disconnect_t__src__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_disconnect_t__src(a, f) \
+-	__NDR_convert__float_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_disconnect_t__src__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_disconnect_t__src(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int32_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_disconnect_t__src__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_disconnect_t__src(a, f) \
+-	__NDR_convert__float_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__float_rep__Request__rpc_jack_port_disconnect_t__src__defined */
+-
+-#ifndef __NDR_convert__float_rep__Request__rpc_jack_port_disconnect_t__dst__defined
+-#if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_disconnect_t__dst__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_disconnect_t__dst(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_disconnect_t__dst__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_disconnect_t__dst(a, f) \
+-	__NDR_convert__float_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_disconnect_t__dst__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_disconnect_t__dst(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int32_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_disconnect_t__dst__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_disconnect_t__dst(a, f) \
+-	__NDR_convert__float_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__float_rep__Request__rpc_jack_port_disconnect_t__dst__defined */
+-
+-
+-mig_internal kern_return_t __MIG_check__Request__rpc_jack_port_disconnect_t(__attribute__((__unused__)) __Request__rpc_jack_port_disconnect_t *In0P)
+-{
+-
+-	typedef __Request__rpc_jack_port_disconnect_t __Request;
+-#if	__MigTypeCheck
+-	if ((In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
+-	    (In0P->Head.msgh_size != (mach_msg_size_t)sizeof(__Request)))
+-		return MIG_BAD_ARGUMENTS;
+-#endif	/* __MigTypeCheck */
+-
+-#if	defined(__NDR_convert__int_rep__Request__rpc_jack_port_disconnect_t__refnum__defined) || \
+-	defined(__NDR_convert__int_rep__Request__rpc_jack_port_disconnect_t__src__defined) || \
+-	defined(__NDR_convert__int_rep__Request__rpc_jack_port_disconnect_t__dst__defined)
+-	if (In0P->NDR.int_rep != NDR_record.int_rep) {
+-#if defined(__NDR_convert__int_rep__Request__rpc_jack_port_disconnect_t__refnum__defined)
+-		__NDR_convert__int_rep__Request__rpc_jack_port_disconnect_t__refnum(&In0P->refnum, In0P->NDR.int_rep);
+-#endif	/* __NDR_convert__int_rep__Request__rpc_jack_port_disconnect_t__refnum__defined */
+-#if defined(__NDR_convert__int_rep__Request__rpc_jack_port_disconnect_t__src__defined)
+-		__NDR_convert__int_rep__Request__rpc_jack_port_disconnect_t__src(&In0P->src, In0P->NDR.int_rep);
+-#endif	/* __NDR_convert__int_rep__Request__rpc_jack_port_disconnect_t__src__defined */
+-#if defined(__NDR_convert__int_rep__Request__rpc_jack_port_disconnect_t__dst__defined)
+-		__NDR_convert__int_rep__Request__rpc_jack_port_disconnect_t__dst(&In0P->dst, In0P->NDR.int_rep);
+-#endif	/* __NDR_convert__int_rep__Request__rpc_jack_port_disconnect_t__dst__defined */
+-	}
+-#endif	/* defined(__NDR_convert__int_rep...) */
+-
+-#if	defined(__NDR_convert__char_rep__Request__rpc_jack_port_disconnect_t__refnum__defined) || \
+-	defined(__NDR_convert__char_rep__Request__rpc_jack_port_disconnect_t__src__defined) || \
+-	defined(__NDR_convert__char_rep__Request__rpc_jack_port_disconnect_t__dst__defined)
+-	if (In0P->NDR.char_rep != NDR_record.char_rep) {
+-#if defined(__NDR_convert__char_rep__Request__rpc_jack_port_disconnect_t__refnum__defined)
+-		__NDR_convert__char_rep__Request__rpc_jack_port_disconnect_t__refnum(&In0P->refnum, In0P->NDR.char_rep);
+-#endif	/* __NDR_convert__char_rep__Request__rpc_jack_port_disconnect_t__refnum__defined */
+-#if defined(__NDR_convert__char_rep__Request__rpc_jack_port_disconnect_t__src__defined)
+-		__NDR_convert__char_rep__Request__rpc_jack_port_disconnect_t__src(&In0P->src, In0P->NDR.char_rep);
+-#endif	/* __NDR_convert__char_rep__Request__rpc_jack_port_disconnect_t__src__defined */
+-#if defined(__NDR_convert__char_rep__Request__rpc_jack_port_disconnect_t__dst__defined)
+-		__NDR_convert__char_rep__Request__rpc_jack_port_disconnect_t__dst(&In0P->dst, In0P->NDR.char_rep);
+-#endif	/* __NDR_convert__char_rep__Request__rpc_jack_port_disconnect_t__dst__defined */
+-	}
+-#endif	/* defined(__NDR_convert__char_rep...) */
+-
+-#if	defined(__NDR_convert__float_rep__Request__rpc_jack_port_disconnect_t__refnum__defined) || \
+-	defined(__NDR_convert__float_rep__Request__rpc_jack_port_disconnect_t__src__defined) || \
+-	defined(__NDR_convert__float_rep__Request__rpc_jack_port_disconnect_t__dst__defined)
+-	if (In0P->NDR.float_rep != NDR_record.float_rep) {
+-#if defined(__NDR_convert__float_rep__Request__rpc_jack_port_disconnect_t__refnum__defined)
+-		__NDR_convert__float_rep__Request__rpc_jack_port_disconnect_t__refnum(&In0P->refnum, In0P->NDR.float_rep);
+-#endif	/* __NDR_convert__float_rep__Request__rpc_jack_port_disconnect_t__refnum__defined */
+-#if defined(__NDR_convert__float_rep__Request__rpc_jack_port_disconnect_t__src__defined)
+-		__NDR_convert__float_rep__Request__rpc_jack_port_disconnect_t__src(&In0P->src, In0P->NDR.float_rep);
+-#endif	/* __NDR_convert__float_rep__Request__rpc_jack_port_disconnect_t__src__defined */
+-#if defined(__NDR_convert__float_rep__Request__rpc_jack_port_disconnect_t__dst__defined)
+-		__NDR_convert__float_rep__Request__rpc_jack_port_disconnect_t__dst(&In0P->dst, In0P->NDR.float_rep);
+-#endif	/* __NDR_convert__float_rep__Request__rpc_jack_port_disconnect_t__dst__defined */
+-	}
+-#endif	/* defined(__NDR_convert__float_rep...) */
+-
+-	return MACH_MSG_SUCCESS;
+-}
+-#endif /* !defined(__MIG_check__Request__rpc_jack_port_disconnect_t__defined) */
+-#endif /* __MIG_check__Request__JackRPCEngine_subsystem__ */
+-#endif /* ( __MigTypeCheck || __NDR_convert__ ) */
+-
+-
+-/* Routine rpc_jack_port_disconnect */
+-#ifdef	mig_external
+-mig_external
+-#else
+-extern
+-#endif	/* mig_external */
+-kern_return_t server_rpc_jack_port_disconnect
+-(
+-	mach_port_t server_port,
+-	int refnum,
+-	int src,
+-	int dst,
+-	int *result
+-);
+-
+-/* Routine rpc_jack_port_disconnect */
+-mig_internal novalue _Xrpc_jack_port_disconnect
+-	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
+-{
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		int refnum;
+-		int src;
+-		int dst;
+-		mach_msg_trailer_t trailer;
+-	} Request;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-	typedef __Request__rpc_jack_port_disconnect_t __Request;
+-	typedef __Reply__rpc_jack_port_disconnect_t Reply;
+-
+-	/*
+-	 * typedef struct {
+-	 * 	mach_msg_header_t Head;
+-	 * 	NDR_record_t NDR;
+-	 * 	kern_return_t RetCode;
+-	 * } mig_reply_error_t;
+-	 */
+-
+-	Request *In0P = (Request *) InHeadP;
+-	Reply *OutP = (Reply *) OutHeadP;
+-#ifdef	__MIG_check__Request__rpc_jack_port_disconnect_t__defined
+-	kern_return_t check_result;
+-#endif	/* __MIG_check__Request__rpc_jack_port_disconnect_t__defined */
+-
+-	__DeclareRcvRpc(1008, "rpc_jack_port_disconnect")
+-	__BeforeRcvRpc(1008, "rpc_jack_port_disconnect")
+-
+-#if	defined(__MIG_check__Request__rpc_jack_port_disconnect_t__defined)
+-	check_result = __MIG_check__Request__rpc_jack_port_disconnect_t((__Request *)In0P);
+-	if (check_result != MACH_MSG_SUCCESS)
+-		{ MIG_RETURN_ERROR(OutP, check_result); }
+-#endif	/* defined(__MIG_check__Request__rpc_jack_port_disconnect_t__defined) */
+-
+-	OutP->RetCode = server_rpc_jack_port_disconnect(In0P->Head.msgh_request_port, In0P->refnum, In0P->src, In0P->dst, &OutP->result);
+-	if (OutP->RetCode != KERN_SUCCESS) {
+-		MIG_RETURN_ERROR(OutP, OutP->RetCode);
+-	}
+-
+-	OutP->NDR = NDR_record;
+-
+-
+-	OutP->Head.msgh_size = (mach_msg_size_t)(sizeof(Reply));
+-	__AfterRcvRpc(1008, "rpc_jack_port_disconnect")
+-}
+-
+-#if ( __MigTypeCheck || __NDR_convert__ )
+-#if __MIG_check__Request__JackRPCEngine_subsystem__
+-#if !defined(__MIG_check__Request__rpc_jack_port_connect_name_t__defined)
+-#define __MIG_check__Request__rpc_jack_port_connect_name_t__defined
+-#ifndef __NDR_convert__int_rep__Request__rpc_jack_port_connect_name_t__refnum__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_connect_name_t__refnum__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_connect_name_t__refnum(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_connect_name_t__refnum__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_connect_name_t__refnum(a, f) \
+-	__NDR_convert__int_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_connect_name_t__refnum__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_connect_name_t__refnum(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int32_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_connect_name_t__refnum__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_connect_name_t__refnum(a, f) \
+-	__NDR_convert__int_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Request__rpc_jack_port_connect_name_t__refnum__defined */
+-
+-#ifndef __NDR_convert__int_rep__Request__rpc_jack_port_connect_name_t__src__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCEngine__client_port_name_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_connect_name_t__src__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_connect_name_t__src(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__client_port_name_t((client_port_name_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__client_port_name_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_connect_name_t__src__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_connect_name_t__src(a, f) \
+-	__NDR_convert__int_rep__client_port_name_t((client_port_name_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__JackRPCEngine__string__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_connect_name_t__src__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_connect_name_t__src(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__string(a, f, 128)
+-#elif	defined(__NDR_convert__int_rep__string__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_connect_name_t__src__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_connect_name_t__src(a, f) \
+-	__NDR_convert__int_rep__string(a, f, 128)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Request__rpc_jack_port_connect_name_t__src__defined */
+-
+-#ifndef __NDR_convert__int_rep__Request__rpc_jack_port_connect_name_t__dst__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCEngine__client_port_name_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_connect_name_t__dst__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_connect_name_t__dst(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__client_port_name_t((client_port_name_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__client_port_name_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_connect_name_t__dst__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_connect_name_t__dst(a, f) \
+-	__NDR_convert__int_rep__client_port_name_t((client_port_name_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__JackRPCEngine__string__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_connect_name_t__dst__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_connect_name_t__dst(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__string(a, f, 128)
+-#elif	defined(__NDR_convert__int_rep__string__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_connect_name_t__dst__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_connect_name_t__dst(a, f) \
+-	__NDR_convert__int_rep__string(a, f, 128)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Request__rpc_jack_port_connect_name_t__dst__defined */
+-
+-#ifndef __NDR_convert__char_rep__Request__rpc_jack_port_connect_name_t__refnum__defined
+-#if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_connect_name_t__refnum__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_connect_name_t__refnum(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_connect_name_t__refnum__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_connect_name_t__refnum(a, f) \
+-	__NDR_convert__char_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_connect_name_t__refnum__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_connect_name_t__refnum(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int32_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_connect_name_t__refnum__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_connect_name_t__refnum(a, f) \
+-	__NDR_convert__char_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__char_rep__Request__rpc_jack_port_connect_name_t__refnum__defined */
+-
+-#ifndef __NDR_convert__char_rep__Request__rpc_jack_port_connect_name_t__src__defined
+-#if	defined(__NDR_convert__char_rep__JackRPCEngine__client_port_name_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_connect_name_t__src__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_connect_name_t__src(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__client_port_name_t((client_port_name_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__client_port_name_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_connect_name_t__src__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_connect_name_t__src(a, f) \
+-	__NDR_convert__char_rep__client_port_name_t((client_port_name_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__JackRPCEngine__string__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_connect_name_t__src__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_connect_name_t__src(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__string(a, f, 128)
+-#elif	defined(__NDR_convert__char_rep__string__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_connect_name_t__src__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_connect_name_t__src(a, f) \
+-	__NDR_convert__char_rep__string(a, f, 128)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__char_rep__Request__rpc_jack_port_connect_name_t__src__defined */
+-
+-#ifndef __NDR_convert__char_rep__Request__rpc_jack_port_connect_name_t__dst__defined
+-#if	defined(__NDR_convert__char_rep__JackRPCEngine__client_port_name_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_connect_name_t__dst__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_connect_name_t__dst(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__client_port_name_t((client_port_name_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__client_port_name_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_connect_name_t__dst__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_connect_name_t__dst(a, f) \
+-	__NDR_convert__char_rep__client_port_name_t((client_port_name_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__JackRPCEngine__string__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_connect_name_t__dst__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_connect_name_t__dst(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__string(a, f, 128)
+-#elif	defined(__NDR_convert__char_rep__string__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_connect_name_t__dst__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_connect_name_t__dst(a, f) \
+-	__NDR_convert__char_rep__string(a, f, 128)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__char_rep__Request__rpc_jack_port_connect_name_t__dst__defined */
+-
+-#ifndef __NDR_convert__float_rep__Request__rpc_jack_port_connect_name_t__refnum__defined
+-#if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_connect_name_t__refnum__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_connect_name_t__refnum(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_connect_name_t__refnum__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_connect_name_t__refnum(a, f) \
+-	__NDR_convert__float_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_connect_name_t__refnum__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_connect_name_t__refnum(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int32_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_connect_name_t__refnum__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_connect_name_t__refnum(a, f) \
+-	__NDR_convert__float_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__float_rep__Request__rpc_jack_port_connect_name_t__refnum__defined */
+-
+-#ifndef __NDR_convert__float_rep__Request__rpc_jack_port_connect_name_t__src__defined
+-#if	defined(__NDR_convert__float_rep__JackRPCEngine__client_port_name_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_connect_name_t__src__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_connect_name_t__src(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__client_port_name_t((client_port_name_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__client_port_name_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_connect_name_t__src__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_connect_name_t__src(a, f) \
+-	__NDR_convert__float_rep__client_port_name_t((client_port_name_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__JackRPCEngine__string__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_connect_name_t__src__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_connect_name_t__src(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__string(a, f, 128)
+-#elif	defined(__NDR_convert__float_rep__string__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_connect_name_t__src__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_connect_name_t__src(a, f) \
+-	__NDR_convert__float_rep__string(a, f, 128)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__float_rep__Request__rpc_jack_port_connect_name_t__src__defined */
+-
+-#ifndef __NDR_convert__float_rep__Request__rpc_jack_port_connect_name_t__dst__defined
+-#if	defined(__NDR_convert__float_rep__JackRPCEngine__client_port_name_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_connect_name_t__dst__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_connect_name_t__dst(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__client_port_name_t((client_port_name_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__client_port_name_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_connect_name_t__dst__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_connect_name_t__dst(a, f) \
+-	__NDR_convert__float_rep__client_port_name_t((client_port_name_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__JackRPCEngine__string__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_connect_name_t__dst__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_connect_name_t__dst(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__string(a, f, 128)
+-#elif	defined(__NDR_convert__float_rep__string__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_connect_name_t__dst__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_connect_name_t__dst(a, f) \
+-	__NDR_convert__float_rep__string(a, f, 128)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__float_rep__Request__rpc_jack_port_connect_name_t__dst__defined */
+-
+-
+-mig_internal kern_return_t __MIG_check__Request__rpc_jack_port_connect_name_t(__attribute__((__unused__)) __Request__rpc_jack_port_connect_name_t *In0P)
+-{
+-
+-	typedef __Request__rpc_jack_port_connect_name_t __Request;
+-#if	__MigTypeCheck
+-	if ((In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
+-	    (In0P->Head.msgh_size != (mach_msg_size_t)sizeof(__Request)))
+-		return MIG_BAD_ARGUMENTS;
+-#endif	/* __MigTypeCheck */
+-
+-#if __MigTypeCheck
+-	{
+-		char * msg_limit = ((char *) In0P) + In0P->Head.msgh_size;
+-		size_t memchr_limit;
+-
+-		memchr_limit = min((msg_limit - In0P->src),  128);
+-		if (( memchr(In0P->src, '\0', memchr_limit) == NULL ))
+-			return MIG_BAD_ARGUMENTS; // string length exceeds buffer length!
+-		memchr_limit = min((msg_limit - In0P->dst),  128);
+-		if (( memchr(In0P->dst, '\0', memchr_limit) == NULL ))
+-			return MIG_BAD_ARGUMENTS; // string length exceeds buffer length!
+-	}
+-#endif	/* __MigTypeCheck */
+-
+-#if	defined(__NDR_convert__int_rep__Request__rpc_jack_port_connect_name_t__refnum__defined) || \
+-	defined(__NDR_convert__int_rep__Request__rpc_jack_port_connect_name_t__src__defined) || \
+-	defined(__NDR_convert__int_rep__Request__rpc_jack_port_connect_name_t__dst__defined)
+-	if (In0P->NDR.int_rep != NDR_record.int_rep) {
+-#if defined(__NDR_convert__int_rep__Request__rpc_jack_port_connect_name_t__refnum__defined)
+-		__NDR_convert__int_rep__Request__rpc_jack_port_connect_name_t__refnum(&In0P->refnum, In0P->NDR.int_rep);
+-#endif	/* __NDR_convert__int_rep__Request__rpc_jack_port_connect_name_t__refnum__defined */
+-#if defined(__NDR_convert__int_rep__Request__rpc_jack_port_connect_name_t__src__defined)
+-		__NDR_convert__int_rep__Request__rpc_jack_port_connect_name_t__src(&In0P->src, In0P->NDR.int_rep);
+-#endif	/* __NDR_convert__int_rep__Request__rpc_jack_port_connect_name_t__src__defined */
+-#if defined(__NDR_convert__int_rep__Request__rpc_jack_port_connect_name_t__dst__defined)
+-		__NDR_convert__int_rep__Request__rpc_jack_port_connect_name_t__dst(&In0P->dst, In0P->NDR.int_rep);
+-#endif	/* __NDR_convert__int_rep__Request__rpc_jack_port_connect_name_t__dst__defined */
+-	}
+-#endif	/* defined(__NDR_convert__int_rep...) */
+-
+-#if	defined(__NDR_convert__char_rep__Request__rpc_jack_port_connect_name_t__refnum__defined) || \
+-	defined(__NDR_convert__char_rep__Request__rpc_jack_port_connect_name_t__src__defined) || \
+-	defined(__NDR_convert__char_rep__Request__rpc_jack_port_connect_name_t__dst__defined)
+-	if (In0P->NDR.char_rep != NDR_record.char_rep) {
+-#if defined(__NDR_convert__char_rep__Request__rpc_jack_port_connect_name_t__refnum__defined)
+-		__NDR_convert__char_rep__Request__rpc_jack_port_connect_name_t__refnum(&In0P->refnum, In0P->NDR.char_rep);
+-#endif	/* __NDR_convert__char_rep__Request__rpc_jack_port_connect_name_t__refnum__defined */
+-#if defined(__NDR_convert__char_rep__Request__rpc_jack_port_connect_name_t__src__defined)
+-		__NDR_convert__char_rep__Request__rpc_jack_port_connect_name_t__src(&In0P->src, In0P->NDR.char_rep);
+-#endif	/* __NDR_convert__char_rep__Request__rpc_jack_port_connect_name_t__src__defined */
+-#if defined(__NDR_convert__char_rep__Request__rpc_jack_port_connect_name_t__dst__defined)
+-		__NDR_convert__char_rep__Request__rpc_jack_port_connect_name_t__dst(&In0P->dst, In0P->NDR.char_rep);
+-#endif	/* __NDR_convert__char_rep__Request__rpc_jack_port_connect_name_t__dst__defined */
+-	}
+-#endif	/* defined(__NDR_convert__char_rep...) */
+-
+-#if	defined(__NDR_convert__float_rep__Request__rpc_jack_port_connect_name_t__refnum__defined) || \
+-	defined(__NDR_convert__float_rep__Request__rpc_jack_port_connect_name_t__src__defined) || \
+-	defined(__NDR_convert__float_rep__Request__rpc_jack_port_connect_name_t__dst__defined)
+-	if (In0P->NDR.float_rep != NDR_record.float_rep) {
+-#if defined(__NDR_convert__float_rep__Request__rpc_jack_port_connect_name_t__refnum__defined)
+-		__NDR_convert__float_rep__Request__rpc_jack_port_connect_name_t__refnum(&In0P->refnum, In0P->NDR.float_rep);
+-#endif	/* __NDR_convert__float_rep__Request__rpc_jack_port_connect_name_t__refnum__defined */
+-#if defined(__NDR_convert__float_rep__Request__rpc_jack_port_connect_name_t__src__defined)
+-		__NDR_convert__float_rep__Request__rpc_jack_port_connect_name_t__src(&In0P->src, In0P->NDR.float_rep);
+-#endif	/* __NDR_convert__float_rep__Request__rpc_jack_port_connect_name_t__src__defined */
+-#if defined(__NDR_convert__float_rep__Request__rpc_jack_port_connect_name_t__dst__defined)
+-		__NDR_convert__float_rep__Request__rpc_jack_port_connect_name_t__dst(&In0P->dst, In0P->NDR.float_rep);
+-#endif	/* __NDR_convert__float_rep__Request__rpc_jack_port_connect_name_t__dst__defined */
+-	}
+-#endif	/* defined(__NDR_convert__float_rep...) */
+-
+-	return MACH_MSG_SUCCESS;
+-}
+-#endif /* !defined(__MIG_check__Request__rpc_jack_port_connect_name_t__defined) */
+-#endif /* __MIG_check__Request__JackRPCEngine_subsystem__ */
+-#endif /* ( __MigTypeCheck || __NDR_convert__ ) */
+-
+-
+-/* Routine rpc_jack_port_connect_name */
+-#ifdef	mig_external
+-mig_external
+-#else
+-extern
+-#endif	/* mig_external */
+-kern_return_t server_rpc_jack_port_connect_name
+-(
+-	mach_port_t server_port,
+-	int refnum,
+-	client_port_name_t src,
+-	client_port_name_t dst,
+-	int *result
+-);
+-
+-/* Routine rpc_jack_port_connect_name */
+-mig_internal novalue _Xrpc_jack_port_connect_name
+-	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
+-{
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		int refnum;
+-		client_port_name_t src;
+-		client_port_name_t dst;
+-		mach_msg_trailer_t trailer;
+-	} Request;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-	typedef __Request__rpc_jack_port_connect_name_t __Request;
+-	typedef __Reply__rpc_jack_port_connect_name_t Reply;
+-
+-	/*
+-	 * typedef struct {
+-	 * 	mach_msg_header_t Head;
+-	 * 	NDR_record_t NDR;
+-	 * 	kern_return_t RetCode;
+-	 * } mig_reply_error_t;
+-	 */
+-
+-	Request *In0P = (Request *) InHeadP;
+-	Reply *OutP = (Reply *) OutHeadP;
+-#ifdef	__MIG_check__Request__rpc_jack_port_connect_name_t__defined
+-	kern_return_t check_result;
+-#endif	/* __MIG_check__Request__rpc_jack_port_connect_name_t__defined */
+-
+-	__DeclareRcvRpc(1009, "rpc_jack_port_connect_name")
+-	__BeforeRcvRpc(1009, "rpc_jack_port_connect_name")
+-
+-#if	defined(__MIG_check__Request__rpc_jack_port_connect_name_t__defined)
+-	check_result = __MIG_check__Request__rpc_jack_port_connect_name_t((__Request *)In0P);
+-	if (check_result != MACH_MSG_SUCCESS)
+-		{ MIG_RETURN_ERROR(OutP, check_result); }
+-#endif	/* defined(__MIG_check__Request__rpc_jack_port_connect_name_t__defined) */
+-
+-	OutP->RetCode = server_rpc_jack_port_connect_name(In0P->Head.msgh_request_port, In0P->refnum, In0P->src, In0P->dst, &OutP->result);
+-	if (OutP->RetCode != KERN_SUCCESS) {
+-		MIG_RETURN_ERROR(OutP, OutP->RetCode);
+-	}
+-
+-	OutP->NDR = NDR_record;
+-
+-
+-	OutP->Head.msgh_size = (mach_msg_size_t)(sizeof(Reply));
+-	__AfterRcvRpc(1009, "rpc_jack_port_connect_name")
+-}
+-
+-#if ( __MigTypeCheck || __NDR_convert__ )
+-#if __MIG_check__Request__JackRPCEngine_subsystem__
+-#if !defined(__MIG_check__Request__rpc_jack_port_disconnect_name_t__defined)
+-#define __MIG_check__Request__rpc_jack_port_disconnect_name_t__defined
+-#ifndef __NDR_convert__int_rep__Request__rpc_jack_port_disconnect_name_t__refnum__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_disconnect_name_t__refnum__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_disconnect_name_t__refnum(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_disconnect_name_t__refnum__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_disconnect_name_t__refnum(a, f) \
+-	__NDR_convert__int_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_disconnect_name_t__refnum__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_disconnect_name_t__refnum(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int32_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_disconnect_name_t__refnum__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_disconnect_name_t__refnum(a, f) \
+-	__NDR_convert__int_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Request__rpc_jack_port_disconnect_name_t__refnum__defined */
+-
+-#ifndef __NDR_convert__int_rep__Request__rpc_jack_port_disconnect_name_t__src__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCEngine__client_port_name_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_disconnect_name_t__src__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_disconnect_name_t__src(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__client_port_name_t((client_port_name_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__client_port_name_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_disconnect_name_t__src__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_disconnect_name_t__src(a, f) \
+-	__NDR_convert__int_rep__client_port_name_t((client_port_name_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__JackRPCEngine__string__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_disconnect_name_t__src__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_disconnect_name_t__src(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__string(a, f, 128)
+-#elif	defined(__NDR_convert__int_rep__string__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_disconnect_name_t__src__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_disconnect_name_t__src(a, f) \
+-	__NDR_convert__int_rep__string(a, f, 128)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Request__rpc_jack_port_disconnect_name_t__src__defined */
+-
+-#ifndef __NDR_convert__int_rep__Request__rpc_jack_port_disconnect_name_t__dst__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCEngine__client_port_name_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_disconnect_name_t__dst__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_disconnect_name_t__dst(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__client_port_name_t((client_port_name_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__client_port_name_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_disconnect_name_t__dst__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_disconnect_name_t__dst(a, f) \
+-	__NDR_convert__int_rep__client_port_name_t((client_port_name_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__JackRPCEngine__string__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_disconnect_name_t__dst__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_disconnect_name_t__dst(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__string(a, f, 128)
+-#elif	defined(__NDR_convert__int_rep__string__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_disconnect_name_t__dst__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_disconnect_name_t__dst(a, f) \
+-	__NDR_convert__int_rep__string(a, f, 128)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Request__rpc_jack_port_disconnect_name_t__dst__defined */
+-
+-#ifndef __NDR_convert__char_rep__Request__rpc_jack_port_disconnect_name_t__refnum__defined
+-#if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_disconnect_name_t__refnum__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_disconnect_name_t__refnum(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_disconnect_name_t__refnum__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_disconnect_name_t__refnum(a, f) \
+-	__NDR_convert__char_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_disconnect_name_t__refnum__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_disconnect_name_t__refnum(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int32_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_disconnect_name_t__refnum__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_disconnect_name_t__refnum(a, f) \
+-	__NDR_convert__char_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__char_rep__Request__rpc_jack_port_disconnect_name_t__refnum__defined */
+-
+-#ifndef __NDR_convert__char_rep__Request__rpc_jack_port_disconnect_name_t__src__defined
+-#if	defined(__NDR_convert__char_rep__JackRPCEngine__client_port_name_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_disconnect_name_t__src__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_disconnect_name_t__src(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__client_port_name_t((client_port_name_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__client_port_name_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_disconnect_name_t__src__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_disconnect_name_t__src(a, f) \
+-	__NDR_convert__char_rep__client_port_name_t((client_port_name_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__JackRPCEngine__string__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_disconnect_name_t__src__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_disconnect_name_t__src(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__string(a, f, 128)
+-#elif	defined(__NDR_convert__char_rep__string__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_disconnect_name_t__src__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_disconnect_name_t__src(a, f) \
+-	__NDR_convert__char_rep__string(a, f, 128)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__char_rep__Request__rpc_jack_port_disconnect_name_t__src__defined */
+-
+-#ifndef __NDR_convert__char_rep__Request__rpc_jack_port_disconnect_name_t__dst__defined
+-#if	defined(__NDR_convert__char_rep__JackRPCEngine__client_port_name_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_disconnect_name_t__dst__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_disconnect_name_t__dst(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__client_port_name_t((client_port_name_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__client_port_name_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_disconnect_name_t__dst__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_disconnect_name_t__dst(a, f) \
+-	__NDR_convert__char_rep__client_port_name_t((client_port_name_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__JackRPCEngine__string__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_disconnect_name_t__dst__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_disconnect_name_t__dst(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__string(a, f, 128)
+-#elif	defined(__NDR_convert__char_rep__string__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_disconnect_name_t__dst__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_disconnect_name_t__dst(a, f) \
+-	__NDR_convert__char_rep__string(a, f, 128)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__char_rep__Request__rpc_jack_port_disconnect_name_t__dst__defined */
+-
+-#ifndef __NDR_convert__float_rep__Request__rpc_jack_port_disconnect_name_t__refnum__defined
+-#if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_disconnect_name_t__refnum__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_disconnect_name_t__refnum(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_disconnect_name_t__refnum__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_disconnect_name_t__refnum(a, f) \
+-	__NDR_convert__float_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_disconnect_name_t__refnum__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_disconnect_name_t__refnum(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int32_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_disconnect_name_t__refnum__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_disconnect_name_t__refnum(a, f) \
+-	__NDR_convert__float_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__float_rep__Request__rpc_jack_port_disconnect_name_t__refnum__defined */
+-
+-#ifndef __NDR_convert__float_rep__Request__rpc_jack_port_disconnect_name_t__src__defined
+-#if	defined(__NDR_convert__float_rep__JackRPCEngine__client_port_name_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_disconnect_name_t__src__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_disconnect_name_t__src(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__client_port_name_t((client_port_name_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__client_port_name_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_disconnect_name_t__src__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_disconnect_name_t__src(a, f) \
+-	__NDR_convert__float_rep__client_port_name_t((client_port_name_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__JackRPCEngine__string__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_disconnect_name_t__src__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_disconnect_name_t__src(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__string(a, f, 128)
+-#elif	defined(__NDR_convert__float_rep__string__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_disconnect_name_t__src__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_disconnect_name_t__src(a, f) \
+-	__NDR_convert__float_rep__string(a, f, 128)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__float_rep__Request__rpc_jack_port_disconnect_name_t__src__defined */
+-
+-#ifndef __NDR_convert__float_rep__Request__rpc_jack_port_disconnect_name_t__dst__defined
+-#if	defined(__NDR_convert__float_rep__JackRPCEngine__client_port_name_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_disconnect_name_t__dst__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_disconnect_name_t__dst(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__client_port_name_t((client_port_name_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__client_port_name_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_disconnect_name_t__dst__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_disconnect_name_t__dst(a, f) \
+-	__NDR_convert__float_rep__client_port_name_t((client_port_name_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__JackRPCEngine__string__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_disconnect_name_t__dst__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_disconnect_name_t__dst(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__string(a, f, 128)
+-#elif	defined(__NDR_convert__float_rep__string__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_disconnect_name_t__dst__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_disconnect_name_t__dst(a, f) \
+-	__NDR_convert__float_rep__string(a, f, 128)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__float_rep__Request__rpc_jack_port_disconnect_name_t__dst__defined */
+-
+-
+-mig_internal kern_return_t __MIG_check__Request__rpc_jack_port_disconnect_name_t(__attribute__((__unused__)) __Request__rpc_jack_port_disconnect_name_t *In0P)
+-{
+-
+-	typedef __Request__rpc_jack_port_disconnect_name_t __Request;
+-#if	__MigTypeCheck
+-	if ((In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
+-	    (In0P->Head.msgh_size != (mach_msg_size_t)sizeof(__Request)))
+-		return MIG_BAD_ARGUMENTS;
+-#endif	/* __MigTypeCheck */
+-
+-#if __MigTypeCheck
+-	{
+-		char * msg_limit = ((char *) In0P) + In0P->Head.msgh_size;
+-		size_t memchr_limit;
+-
+-		memchr_limit = min((msg_limit - In0P->src),  128);
+-		if (( memchr(In0P->src, '\0', memchr_limit) == NULL ))
+-			return MIG_BAD_ARGUMENTS; // string length exceeds buffer length!
+-		memchr_limit = min((msg_limit - In0P->dst),  128);
+-		if (( memchr(In0P->dst, '\0', memchr_limit) == NULL ))
+-			return MIG_BAD_ARGUMENTS; // string length exceeds buffer length!
+-	}
+-#endif	/* __MigTypeCheck */
+-
+-#if	defined(__NDR_convert__int_rep__Request__rpc_jack_port_disconnect_name_t__refnum__defined) || \
+-	defined(__NDR_convert__int_rep__Request__rpc_jack_port_disconnect_name_t__src__defined) || \
+-	defined(__NDR_convert__int_rep__Request__rpc_jack_port_disconnect_name_t__dst__defined)
+-	if (In0P->NDR.int_rep != NDR_record.int_rep) {
+-#if defined(__NDR_convert__int_rep__Request__rpc_jack_port_disconnect_name_t__refnum__defined)
+-		__NDR_convert__int_rep__Request__rpc_jack_port_disconnect_name_t__refnum(&In0P->refnum, In0P->NDR.int_rep);
+-#endif	/* __NDR_convert__int_rep__Request__rpc_jack_port_disconnect_name_t__refnum__defined */
+-#if defined(__NDR_convert__int_rep__Request__rpc_jack_port_disconnect_name_t__src__defined)
+-		__NDR_convert__int_rep__Request__rpc_jack_port_disconnect_name_t__src(&In0P->src, In0P->NDR.int_rep);
+-#endif	/* __NDR_convert__int_rep__Request__rpc_jack_port_disconnect_name_t__src__defined */
+-#if defined(__NDR_convert__int_rep__Request__rpc_jack_port_disconnect_name_t__dst__defined)
+-		__NDR_convert__int_rep__Request__rpc_jack_port_disconnect_name_t__dst(&In0P->dst, In0P->NDR.int_rep);
+-#endif	/* __NDR_convert__int_rep__Request__rpc_jack_port_disconnect_name_t__dst__defined */
+-	}
+-#endif	/* defined(__NDR_convert__int_rep...) */
+-
+-#if	defined(__NDR_convert__char_rep__Request__rpc_jack_port_disconnect_name_t__refnum__defined) || \
+-	defined(__NDR_convert__char_rep__Request__rpc_jack_port_disconnect_name_t__src__defined) || \
+-	defined(__NDR_convert__char_rep__Request__rpc_jack_port_disconnect_name_t__dst__defined)
+-	if (In0P->NDR.char_rep != NDR_record.char_rep) {
+-#if defined(__NDR_convert__char_rep__Request__rpc_jack_port_disconnect_name_t__refnum__defined)
+-		__NDR_convert__char_rep__Request__rpc_jack_port_disconnect_name_t__refnum(&In0P->refnum, In0P->NDR.char_rep);
+-#endif	/* __NDR_convert__char_rep__Request__rpc_jack_port_disconnect_name_t__refnum__defined */
+-#if defined(__NDR_convert__char_rep__Request__rpc_jack_port_disconnect_name_t__src__defined)
+-		__NDR_convert__char_rep__Request__rpc_jack_port_disconnect_name_t__src(&In0P->src, In0P->NDR.char_rep);
+-#endif	/* __NDR_convert__char_rep__Request__rpc_jack_port_disconnect_name_t__src__defined */
+-#if defined(__NDR_convert__char_rep__Request__rpc_jack_port_disconnect_name_t__dst__defined)
+-		__NDR_convert__char_rep__Request__rpc_jack_port_disconnect_name_t__dst(&In0P->dst, In0P->NDR.char_rep);
+-#endif	/* __NDR_convert__char_rep__Request__rpc_jack_port_disconnect_name_t__dst__defined */
+-	}
+-#endif	/* defined(__NDR_convert__char_rep...) */
+-
+-#if	defined(__NDR_convert__float_rep__Request__rpc_jack_port_disconnect_name_t__refnum__defined) || \
+-	defined(__NDR_convert__float_rep__Request__rpc_jack_port_disconnect_name_t__src__defined) || \
+-	defined(__NDR_convert__float_rep__Request__rpc_jack_port_disconnect_name_t__dst__defined)
+-	if (In0P->NDR.float_rep != NDR_record.float_rep) {
+-#if defined(__NDR_convert__float_rep__Request__rpc_jack_port_disconnect_name_t__refnum__defined)
+-		__NDR_convert__float_rep__Request__rpc_jack_port_disconnect_name_t__refnum(&In0P->refnum, In0P->NDR.float_rep);
+-#endif	/* __NDR_convert__float_rep__Request__rpc_jack_port_disconnect_name_t__refnum__defined */
+-#if defined(__NDR_convert__float_rep__Request__rpc_jack_port_disconnect_name_t__src__defined)
+-		__NDR_convert__float_rep__Request__rpc_jack_port_disconnect_name_t__src(&In0P->src, In0P->NDR.float_rep);
+-#endif	/* __NDR_convert__float_rep__Request__rpc_jack_port_disconnect_name_t__src__defined */
+-#if defined(__NDR_convert__float_rep__Request__rpc_jack_port_disconnect_name_t__dst__defined)
+-		__NDR_convert__float_rep__Request__rpc_jack_port_disconnect_name_t__dst(&In0P->dst, In0P->NDR.float_rep);
+-#endif	/* __NDR_convert__float_rep__Request__rpc_jack_port_disconnect_name_t__dst__defined */
+-	}
+-#endif	/* defined(__NDR_convert__float_rep...) */
+-
+-	return MACH_MSG_SUCCESS;
+-}
+-#endif /* !defined(__MIG_check__Request__rpc_jack_port_disconnect_name_t__defined) */
+-#endif /* __MIG_check__Request__JackRPCEngine_subsystem__ */
+-#endif /* ( __MigTypeCheck || __NDR_convert__ ) */
+-
+-
+-/* Routine rpc_jack_port_disconnect_name */
+-#ifdef	mig_external
+-mig_external
+-#else
+-extern
+-#endif	/* mig_external */
+-kern_return_t server_rpc_jack_port_disconnect_name
+-(
+-	mach_port_t server_port,
+-	int refnum,
+-	client_port_name_t src,
+-	client_port_name_t dst,
+-	int *result
+-);
+-
+-/* Routine rpc_jack_port_disconnect_name */
+-mig_internal novalue _Xrpc_jack_port_disconnect_name
+-	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
+-{
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		int refnum;
+-		client_port_name_t src;
+-		client_port_name_t dst;
+-		mach_msg_trailer_t trailer;
+-	} Request;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-	typedef __Request__rpc_jack_port_disconnect_name_t __Request;
+-	typedef __Reply__rpc_jack_port_disconnect_name_t Reply;
+-
+-	/*
+-	 * typedef struct {
+-	 * 	mach_msg_header_t Head;
+-	 * 	NDR_record_t NDR;
+-	 * 	kern_return_t RetCode;
+-	 * } mig_reply_error_t;
+-	 */
+-
+-	Request *In0P = (Request *) InHeadP;
+-	Reply *OutP = (Reply *) OutHeadP;
+-#ifdef	__MIG_check__Request__rpc_jack_port_disconnect_name_t__defined
+-	kern_return_t check_result;
+-#endif	/* __MIG_check__Request__rpc_jack_port_disconnect_name_t__defined */
+-
+-	__DeclareRcvRpc(1010, "rpc_jack_port_disconnect_name")
+-	__BeforeRcvRpc(1010, "rpc_jack_port_disconnect_name")
+-
+-#if	defined(__MIG_check__Request__rpc_jack_port_disconnect_name_t__defined)
+-	check_result = __MIG_check__Request__rpc_jack_port_disconnect_name_t((__Request *)In0P);
+-	if (check_result != MACH_MSG_SUCCESS)
+-		{ MIG_RETURN_ERROR(OutP, check_result); }
+-#endif	/* defined(__MIG_check__Request__rpc_jack_port_disconnect_name_t__defined) */
+-
+-	OutP->RetCode = server_rpc_jack_port_disconnect_name(In0P->Head.msgh_request_port, In0P->refnum, In0P->src, In0P->dst, &OutP->result);
+-	if (OutP->RetCode != KERN_SUCCESS) {
+-		MIG_RETURN_ERROR(OutP, OutP->RetCode);
+-	}
+-
+-	OutP->NDR = NDR_record;
+-
+-
+-	OutP->Head.msgh_size = (mach_msg_size_t)(sizeof(Reply));
+-	__AfterRcvRpc(1010, "rpc_jack_port_disconnect_name")
+-}
+-
+-#if ( __MigTypeCheck || __NDR_convert__ )
+-#if __MIG_check__Request__JackRPCEngine_subsystem__
+-#if !defined(__MIG_check__Request__rpc_jack_port_rename_t__defined)
+-#define __MIG_check__Request__rpc_jack_port_rename_t__defined
+-#ifndef __NDR_convert__int_rep__Request__rpc_jack_port_rename_t__refnum__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_rename_t__refnum__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_rename_t__refnum(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_rename_t__refnum__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_rename_t__refnum(a, f) \
+-	__NDR_convert__int_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_rename_t__refnum__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_rename_t__refnum(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int32_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_rename_t__refnum__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_rename_t__refnum(a, f) \
+-	__NDR_convert__int_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Request__rpc_jack_port_rename_t__refnum__defined */
+-
+-#ifndef __NDR_convert__int_rep__Request__rpc_jack_port_rename_t__src__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_rename_t__src__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_rename_t__src(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_rename_t__src__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_rename_t__src(a, f) \
+-	__NDR_convert__int_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_rename_t__src__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_rename_t__src(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int32_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_rename_t__src__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_rename_t__src(a, f) \
+-	__NDR_convert__int_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Request__rpc_jack_port_rename_t__src__defined */
+-
+-#ifndef __NDR_convert__int_rep__Request__rpc_jack_port_rename_t__name__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCEngine__client_port_name_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_rename_t__name__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_rename_t__name(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__client_port_name_t((client_port_name_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__client_port_name_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_rename_t__name__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_rename_t__name(a, f) \
+-	__NDR_convert__int_rep__client_port_name_t((client_port_name_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__JackRPCEngine__string__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_rename_t__name__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_rename_t__name(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__string(a, f, 128)
+-#elif	defined(__NDR_convert__int_rep__string__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_rename_t__name__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_port_rename_t__name(a, f) \
+-	__NDR_convert__int_rep__string(a, f, 128)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Request__rpc_jack_port_rename_t__name__defined */
+-
+-#ifndef __NDR_convert__char_rep__Request__rpc_jack_port_rename_t__refnum__defined
+-#if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_rename_t__refnum__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_rename_t__refnum(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_rename_t__refnum__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_rename_t__refnum(a, f) \
+-	__NDR_convert__char_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_rename_t__refnum__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_rename_t__refnum(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int32_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_rename_t__refnum__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_rename_t__refnum(a, f) \
+-	__NDR_convert__char_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__char_rep__Request__rpc_jack_port_rename_t__refnum__defined */
+-
+-#ifndef __NDR_convert__char_rep__Request__rpc_jack_port_rename_t__src__defined
+-#if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_rename_t__src__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_rename_t__src(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_rename_t__src__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_rename_t__src(a, f) \
+-	__NDR_convert__char_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_rename_t__src__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_rename_t__src(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int32_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_rename_t__src__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_rename_t__src(a, f) \
+-	__NDR_convert__char_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__char_rep__Request__rpc_jack_port_rename_t__src__defined */
+-
+-#ifndef __NDR_convert__char_rep__Request__rpc_jack_port_rename_t__name__defined
+-#if	defined(__NDR_convert__char_rep__JackRPCEngine__client_port_name_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_rename_t__name__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_rename_t__name(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__client_port_name_t((client_port_name_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__client_port_name_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_rename_t__name__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_rename_t__name(a, f) \
+-	__NDR_convert__char_rep__client_port_name_t((client_port_name_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__JackRPCEngine__string__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_rename_t__name__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_rename_t__name(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__string(a, f, 128)
+-#elif	defined(__NDR_convert__char_rep__string__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_rename_t__name__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_port_rename_t__name(a, f) \
+-	__NDR_convert__char_rep__string(a, f, 128)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__char_rep__Request__rpc_jack_port_rename_t__name__defined */
+-
+-#ifndef __NDR_convert__float_rep__Request__rpc_jack_port_rename_t__refnum__defined
+-#if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_rename_t__refnum__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_rename_t__refnum(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_rename_t__refnum__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_rename_t__refnum(a, f) \
+-	__NDR_convert__float_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_rename_t__refnum__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_rename_t__refnum(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int32_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_rename_t__refnum__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_rename_t__refnum(a, f) \
+-	__NDR_convert__float_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__float_rep__Request__rpc_jack_port_rename_t__refnum__defined */
+-
+-#ifndef __NDR_convert__float_rep__Request__rpc_jack_port_rename_t__src__defined
+-#if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_rename_t__src__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_rename_t__src(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_rename_t__src__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_rename_t__src(a, f) \
+-	__NDR_convert__float_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_rename_t__src__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_rename_t__src(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int32_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_rename_t__src__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_rename_t__src(a, f) \
+-	__NDR_convert__float_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__float_rep__Request__rpc_jack_port_rename_t__src__defined */
+-
+-#ifndef __NDR_convert__float_rep__Request__rpc_jack_port_rename_t__name__defined
+-#if	defined(__NDR_convert__float_rep__JackRPCEngine__client_port_name_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_rename_t__name__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_rename_t__name(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__client_port_name_t((client_port_name_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__client_port_name_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_rename_t__name__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_rename_t__name(a, f) \
+-	__NDR_convert__float_rep__client_port_name_t((client_port_name_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__JackRPCEngine__string__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_rename_t__name__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_rename_t__name(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__string(a, f, 128)
+-#elif	defined(__NDR_convert__float_rep__string__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_rename_t__name__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_port_rename_t__name(a, f) \
+-	__NDR_convert__float_rep__string(a, f, 128)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__float_rep__Request__rpc_jack_port_rename_t__name__defined */
+-
+-
+-mig_internal kern_return_t __MIG_check__Request__rpc_jack_port_rename_t(__attribute__((__unused__)) __Request__rpc_jack_port_rename_t *In0P)
+-{
+-
+-	typedef __Request__rpc_jack_port_rename_t __Request;
+-#if	__MigTypeCheck
+-	if ((In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
+-	    (In0P->Head.msgh_size != (mach_msg_size_t)sizeof(__Request)))
+-		return MIG_BAD_ARGUMENTS;
+-#endif	/* __MigTypeCheck */
+-
+-#if __MigTypeCheck
+-	{
+-		char * msg_limit = ((char *) In0P) + In0P->Head.msgh_size;
+-		size_t memchr_limit;
+-
+-		memchr_limit = min((msg_limit - In0P->name),  128);
+-		if (( memchr(In0P->name, '\0', memchr_limit) == NULL ))
+-			return MIG_BAD_ARGUMENTS; // string length exceeds buffer length!
+-	}
+-#endif	/* __MigTypeCheck */
+-
+-#if	defined(__NDR_convert__int_rep__Request__rpc_jack_port_rename_t__refnum__defined) || \
+-	defined(__NDR_convert__int_rep__Request__rpc_jack_port_rename_t__src__defined) || \
+-	defined(__NDR_convert__int_rep__Request__rpc_jack_port_rename_t__name__defined)
+-	if (In0P->NDR.int_rep != NDR_record.int_rep) {
+-#if defined(__NDR_convert__int_rep__Request__rpc_jack_port_rename_t__refnum__defined)
+-		__NDR_convert__int_rep__Request__rpc_jack_port_rename_t__refnum(&In0P->refnum, In0P->NDR.int_rep);
+-#endif	/* __NDR_convert__int_rep__Request__rpc_jack_port_rename_t__refnum__defined */
+-#if defined(__NDR_convert__int_rep__Request__rpc_jack_port_rename_t__src__defined)
+-		__NDR_convert__int_rep__Request__rpc_jack_port_rename_t__src(&In0P->src, In0P->NDR.int_rep);
+-#endif	/* __NDR_convert__int_rep__Request__rpc_jack_port_rename_t__src__defined */
+-#if defined(__NDR_convert__int_rep__Request__rpc_jack_port_rename_t__name__defined)
+-		__NDR_convert__int_rep__Request__rpc_jack_port_rename_t__name(&In0P->name, In0P->NDR.int_rep);
+-#endif	/* __NDR_convert__int_rep__Request__rpc_jack_port_rename_t__name__defined */
+-	}
+-#endif	/* defined(__NDR_convert__int_rep...) */
+-
+-#if	defined(__NDR_convert__char_rep__Request__rpc_jack_port_rename_t__refnum__defined) || \
+-	defined(__NDR_convert__char_rep__Request__rpc_jack_port_rename_t__src__defined) || \
+-	defined(__NDR_convert__char_rep__Request__rpc_jack_port_rename_t__name__defined)
+-	if (In0P->NDR.char_rep != NDR_record.char_rep) {
+-#if defined(__NDR_convert__char_rep__Request__rpc_jack_port_rename_t__refnum__defined)
+-		__NDR_convert__char_rep__Request__rpc_jack_port_rename_t__refnum(&In0P->refnum, In0P->NDR.char_rep);
+-#endif	/* __NDR_convert__char_rep__Request__rpc_jack_port_rename_t__refnum__defined */
+-#if defined(__NDR_convert__char_rep__Request__rpc_jack_port_rename_t__src__defined)
+-		__NDR_convert__char_rep__Request__rpc_jack_port_rename_t__src(&In0P->src, In0P->NDR.char_rep);
+-#endif	/* __NDR_convert__char_rep__Request__rpc_jack_port_rename_t__src__defined */
+-#if defined(__NDR_convert__char_rep__Request__rpc_jack_port_rename_t__name__defined)
+-		__NDR_convert__char_rep__Request__rpc_jack_port_rename_t__name(&In0P->name, In0P->NDR.char_rep);
+-#endif	/* __NDR_convert__char_rep__Request__rpc_jack_port_rename_t__name__defined */
+-	}
+-#endif	/* defined(__NDR_convert__char_rep...) */
+-
+-#if	defined(__NDR_convert__float_rep__Request__rpc_jack_port_rename_t__refnum__defined) || \
+-	defined(__NDR_convert__float_rep__Request__rpc_jack_port_rename_t__src__defined) || \
+-	defined(__NDR_convert__float_rep__Request__rpc_jack_port_rename_t__name__defined)
+-	if (In0P->NDR.float_rep != NDR_record.float_rep) {
+-#if defined(__NDR_convert__float_rep__Request__rpc_jack_port_rename_t__refnum__defined)
+-		__NDR_convert__float_rep__Request__rpc_jack_port_rename_t__refnum(&In0P->refnum, In0P->NDR.float_rep);
+-#endif	/* __NDR_convert__float_rep__Request__rpc_jack_port_rename_t__refnum__defined */
+-#if defined(__NDR_convert__float_rep__Request__rpc_jack_port_rename_t__src__defined)
+-		__NDR_convert__float_rep__Request__rpc_jack_port_rename_t__src(&In0P->src, In0P->NDR.float_rep);
+-#endif	/* __NDR_convert__float_rep__Request__rpc_jack_port_rename_t__src__defined */
+-#if defined(__NDR_convert__float_rep__Request__rpc_jack_port_rename_t__name__defined)
+-		__NDR_convert__float_rep__Request__rpc_jack_port_rename_t__name(&In0P->name, In0P->NDR.float_rep);
+-#endif	/* __NDR_convert__float_rep__Request__rpc_jack_port_rename_t__name__defined */
+-	}
+-#endif	/* defined(__NDR_convert__float_rep...) */
+-
+-	return MACH_MSG_SUCCESS;
+-}
+-#endif /* !defined(__MIG_check__Request__rpc_jack_port_rename_t__defined) */
+-#endif /* __MIG_check__Request__JackRPCEngine_subsystem__ */
+-#endif /* ( __MigTypeCheck || __NDR_convert__ ) */
+-
+-
+-/* Routine rpc_jack_port_rename */
+-#ifdef	mig_external
+-mig_external
+-#else
+-extern
+-#endif	/* mig_external */
+-kern_return_t server_rpc_jack_port_rename
+-(
+-	mach_port_t server_port,
+-	int refnum,
+-	int src,
+-	client_port_name_t name,
+-	int *result
+-);
+-
+-/* Routine rpc_jack_port_rename */
+-mig_internal novalue _Xrpc_jack_port_rename
+-	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
+-{
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		int refnum;
+-		int src;
+-		client_port_name_t name;
+-		mach_msg_trailer_t trailer;
+-	} Request;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-	typedef __Request__rpc_jack_port_rename_t __Request;
+-	typedef __Reply__rpc_jack_port_rename_t Reply;
+-
+-	/*
+-	 * typedef struct {
+-	 * 	mach_msg_header_t Head;
+-	 * 	NDR_record_t NDR;
+-	 * 	kern_return_t RetCode;
+-	 * } mig_reply_error_t;
+-	 */
+-
+-	Request *In0P = (Request *) InHeadP;
+-	Reply *OutP = (Reply *) OutHeadP;
+-#ifdef	__MIG_check__Request__rpc_jack_port_rename_t__defined
+-	kern_return_t check_result;
+-#endif	/* __MIG_check__Request__rpc_jack_port_rename_t__defined */
+-
+-	__DeclareRcvRpc(1011, "rpc_jack_port_rename")
+-	__BeforeRcvRpc(1011, "rpc_jack_port_rename")
+-
+-#if	defined(__MIG_check__Request__rpc_jack_port_rename_t__defined)
+-	check_result = __MIG_check__Request__rpc_jack_port_rename_t((__Request *)In0P);
+-	if (check_result != MACH_MSG_SUCCESS)
+-		{ MIG_RETURN_ERROR(OutP, check_result); }
+-#endif	/* defined(__MIG_check__Request__rpc_jack_port_rename_t__defined) */
+-
+-	OutP->RetCode = server_rpc_jack_port_rename(In0P->Head.msgh_request_port, In0P->refnum, In0P->src, In0P->name, &OutP->result);
+-	if (OutP->RetCode != KERN_SUCCESS) {
+-		MIG_RETURN_ERROR(OutP, OutP->RetCode);
+-	}
+-
+-	OutP->NDR = NDR_record;
+-
+-
+-	OutP->Head.msgh_size = (mach_msg_size_t)(sizeof(Reply));
+-	__AfterRcvRpc(1011, "rpc_jack_port_rename")
+-}
+-
+-#if ( __MigTypeCheck || __NDR_convert__ )
+-#if __MIG_check__Request__JackRPCEngine_subsystem__
+-#if !defined(__MIG_check__Request__rpc_jack_set_buffer_size_t__defined)
+-#define __MIG_check__Request__rpc_jack_set_buffer_size_t__defined
+-#ifndef __NDR_convert__int_rep__Request__rpc_jack_set_buffer_size_t__buffer_size__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_set_buffer_size_t__buffer_size__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_set_buffer_size_t__buffer_size(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_set_buffer_size_t__buffer_size__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_set_buffer_size_t__buffer_size(a, f) \
+-	__NDR_convert__int_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_set_buffer_size_t__buffer_size__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_set_buffer_size_t__buffer_size(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int32_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_set_buffer_size_t__buffer_size__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_set_buffer_size_t__buffer_size(a, f) \
+-	__NDR_convert__int_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Request__rpc_jack_set_buffer_size_t__buffer_size__defined */
+-
+-#ifndef __NDR_convert__char_rep__Request__rpc_jack_set_buffer_size_t__buffer_size__defined
+-#if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_set_buffer_size_t__buffer_size__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_set_buffer_size_t__buffer_size(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_set_buffer_size_t__buffer_size__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_set_buffer_size_t__buffer_size(a, f) \
+-	__NDR_convert__char_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_set_buffer_size_t__buffer_size__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_set_buffer_size_t__buffer_size(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int32_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_set_buffer_size_t__buffer_size__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_set_buffer_size_t__buffer_size(a, f) \
+-	__NDR_convert__char_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__char_rep__Request__rpc_jack_set_buffer_size_t__buffer_size__defined */
+-
+-#ifndef __NDR_convert__float_rep__Request__rpc_jack_set_buffer_size_t__buffer_size__defined
+-#if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_set_buffer_size_t__buffer_size__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_set_buffer_size_t__buffer_size(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_set_buffer_size_t__buffer_size__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_set_buffer_size_t__buffer_size(a, f) \
+-	__NDR_convert__float_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_set_buffer_size_t__buffer_size__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_set_buffer_size_t__buffer_size(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int32_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_set_buffer_size_t__buffer_size__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_set_buffer_size_t__buffer_size(a, f) \
+-	__NDR_convert__float_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__float_rep__Request__rpc_jack_set_buffer_size_t__buffer_size__defined */
+-
+-
+-mig_internal kern_return_t __MIG_check__Request__rpc_jack_set_buffer_size_t(__attribute__((__unused__)) __Request__rpc_jack_set_buffer_size_t *In0P)
+-{
+-
+-	typedef __Request__rpc_jack_set_buffer_size_t __Request;
+-#if	__MigTypeCheck
+-	if ((In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
+-	    (In0P->Head.msgh_size != (mach_msg_size_t)sizeof(__Request)))
+-		return MIG_BAD_ARGUMENTS;
+-#endif	/* __MigTypeCheck */
+-
+-#if	defined(__NDR_convert__int_rep__Request__rpc_jack_set_buffer_size_t__buffer_size__defined)
+-	if (In0P->NDR.int_rep != NDR_record.int_rep) {
+-#if defined(__NDR_convert__int_rep__Request__rpc_jack_set_buffer_size_t__buffer_size__defined)
+-		__NDR_convert__int_rep__Request__rpc_jack_set_buffer_size_t__buffer_size(&In0P->buffer_size, In0P->NDR.int_rep);
+-#endif	/* __NDR_convert__int_rep__Request__rpc_jack_set_buffer_size_t__buffer_size__defined */
+-	}
+-#endif	/* defined(__NDR_convert__int_rep...) */
+-
+-#if	defined(__NDR_convert__char_rep__Request__rpc_jack_set_buffer_size_t__buffer_size__defined)
+-	if (In0P->NDR.char_rep != NDR_record.char_rep) {
+-#if defined(__NDR_convert__char_rep__Request__rpc_jack_set_buffer_size_t__buffer_size__defined)
+-		__NDR_convert__char_rep__Request__rpc_jack_set_buffer_size_t__buffer_size(&In0P->buffer_size, In0P->NDR.char_rep);
+-#endif	/* __NDR_convert__char_rep__Request__rpc_jack_set_buffer_size_t__buffer_size__defined */
+-	}
+-#endif	/* defined(__NDR_convert__char_rep...) */
+-
+-#if	defined(__NDR_convert__float_rep__Request__rpc_jack_set_buffer_size_t__buffer_size__defined)
+-	if (In0P->NDR.float_rep != NDR_record.float_rep) {
+-#if defined(__NDR_convert__float_rep__Request__rpc_jack_set_buffer_size_t__buffer_size__defined)
+-		__NDR_convert__float_rep__Request__rpc_jack_set_buffer_size_t__buffer_size(&In0P->buffer_size, In0P->NDR.float_rep);
+-#endif	/* __NDR_convert__float_rep__Request__rpc_jack_set_buffer_size_t__buffer_size__defined */
+-	}
+-#endif	/* defined(__NDR_convert__float_rep...) */
+-
+-	return MACH_MSG_SUCCESS;
+-}
+-#endif /* !defined(__MIG_check__Request__rpc_jack_set_buffer_size_t__defined) */
+-#endif /* __MIG_check__Request__JackRPCEngine_subsystem__ */
+-#endif /* ( __MigTypeCheck || __NDR_convert__ ) */
+-
+-
+-/* Routine rpc_jack_set_buffer_size */
+-#ifdef	mig_external
+-mig_external
+-#else
+-extern
+-#endif	/* mig_external */
+-kern_return_t server_rpc_jack_set_buffer_size
+-(
+-	mach_port_t server_port,
+-	int buffer_size,
+-	int *result
+-);
+-
+-/* Routine rpc_jack_set_buffer_size */
+-mig_internal novalue _Xrpc_jack_set_buffer_size
+-	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
+-{
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		int buffer_size;
+-		mach_msg_trailer_t trailer;
+-	} Request;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-	typedef __Request__rpc_jack_set_buffer_size_t __Request;
+-	typedef __Reply__rpc_jack_set_buffer_size_t Reply;
+-
+-	/*
+-	 * typedef struct {
+-	 * 	mach_msg_header_t Head;
+-	 * 	NDR_record_t NDR;
+-	 * 	kern_return_t RetCode;
+-	 * } mig_reply_error_t;
+-	 */
+-
+-	Request *In0P = (Request *) InHeadP;
+-	Reply *OutP = (Reply *) OutHeadP;
+-#ifdef	__MIG_check__Request__rpc_jack_set_buffer_size_t__defined
+-	kern_return_t check_result;
+-#endif	/* __MIG_check__Request__rpc_jack_set_buffer_size_t__defined */
+-
+-	__DeclareRcvRpc(1012, "rpc_jack_set_buffer_size")
+-	__BeforeRcvRpc(1012, "rpc_jack_set_buffer_size")
+-
+-#if	defined(__MIG_check__Request__rpc_jack_set_buffer_size_t__defined)
+-	check_result = __MIG_check__Request__rpc_jack_set_buffer_size_t((__Request *)In0P);
+-	if (check_result != MACH_MSG_SUCCESS)
+-		{ MIG_RETURN_ERROR(OutP, check_result); }
+-#endif	/* defined(__MIG_check__Request__rpc_jack_set_buffer_size_t__defined) */
+-
+-	OutP->RetCode = server_rpc_jack_set_buffer_size(In0P->Head.msgh_request_port, In0P->buffer_size, &OutP->result);
+-	if (OutP->RetCode != KERN_SUCCESS) {
+-		MIG_RETURN_ERROR(OutP, OutP->RetCode);
+-	}
+-
+-	OutP->NDR = NDR_record;
+-
+-
+-	OutP->Head.msgh_size = (mach_msg_size_t)(sizeof(Reply));
+-	__AfterRcvRpc(1012, "rpc_jack_set_buffer_size")
+-}
+-
+-#if ( __MigTypeCheck || __NDR_convert__ )
+-#if __MIG_check__Request__JackRPCEngine_subsystem__
+-#if !defined(__MIG_check__Request__rpc_jack_set_freewheel_t__defined)
+-#define __MIG_check__Request__rpc_jack_set_freewheel_t__defined
+-#ifndef __NDR_convert__int_rep__Request__rpc_jack_set_freewheel_t__onoff__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_set_freewheel_t__onoff__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_set_freewheel_t__onoff(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_set_freewheel_t__onoff__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_set_freewheel_t__onoff(a, f) \
+-	__NDR_convert__int_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_set_freewheel_t__onoff__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_set_freewheel_t__onoff(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int32_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_set_freewheel_t__onoff__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_set_freewheel_t__onoff(a, f) \
+-	__NDR_convert__int_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Request__rpc_jack_set_freewheel_t__onoff__defined */
+-
+-#ifndef __NDR_convert__char_rep__Request__rpc_jack_set_freewheel_t__onoff__defined
+-#if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_set_freewheel_t__onoff__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_set_freewheel_t__onoff(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_set_freewheel_t__onoff__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_set_freewheel_t__onoff(a, f) \
+-	__NDR_convert__char_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_set_freewheel_t__onoff__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_set_freewheel_t__onoff(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int32_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_set_freewheel_t__onoff__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_set_freewheel_t__onoff(a, f) \
+-	__NDR_convert__char_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__char_rep__Request__rpc_jack_set_freewheel_t__onoff__defined */
+-
+-#ifndef __NDR_convert__float_rep__Request__rpc_jack_set_freewheel_t__onoff__defined
+-#if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_set_freewheel_t__onoff__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_set_freewheel_t__onoff(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_set_freewheel_t__onoff__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_set_freewheel_t__onoff(a, f) \
+-	__NDR_convert__float_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_set_freewheel_t__onoff__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_set_freewheel_t__onoff(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int32_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_set_freewheel_t__onoff__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_set_freewheel_t__onoff(a, f) \
+-	__NDR_convert__float_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__float_rep__Request__rpc_jack_set_freewheel_t__onoff__defined */
+-
+-
+-mig_internal kern_return_t __MIG_check__Request__rpc_jack_set_freewheel_t(__attribute__((__unused__)) __Request__rpc_jack_set_freewheel_t *In0P)
+-{
+-
+-	typedef __Request__rpc_jack_set_freewheel_t __Request;
+-#if	__MigTypeCheck
+-	if ((In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
+-	    (In0P->Head.msgh_size != (mach_msg_size_t)sizeof(__Request)))
+-		return MIG_BAD_ARGUMENTS;
+-#endif	/* __MigTypeCheck */
+-
+-#if	defined(__NDR_convert__int_rep__Request__rpc_jack_set_freewheel_t__onoff__defined)
+-	if (In0P->NDR.int_rep != NDR_record.int_rep) {
+-#if defined(__NDR_convert__int_rep__Request__rpc_jack_set_freewheel_t__onoff__defined)
+-		__NDR_convert__int_rep__Request__rpc_jack_set_freewheel_t__onoff(&In0P->onoff, In0P->NDR.int_rep);
+-#endif	/* __NDR_convert__int_rep__Request__rpc_jack_set_freewheel_t__onoff__defined */
+-	}
+-#endif	/* defined(__NDR_convert__int_rep...) */
+-
+-#if	defined(__NDR_convert__char_rep__Request__rpc_jack_set_freewheel_t__onoff__defined)
+-	if (In0P->NDR.char_rep != NDR_record.char_rep) {
+-#if defined(__NDR_convert__char_rep__Request__rpc_jack_set_freewheel_t__onoff__defined)
+-		__NDR_convert__char_rep__Request__rpc_jack_set_freewheel_t__onoff(&In0P->onoff, In0P->NDR.char_rep);
+-#endif	/* __NDR_convert__char_rep__Request__rpc_jack_set_freewheel_t__onoff__defined */
+-	}
+-#endif	/* defined(__NDR_convert__char_rep...) */
+-
+-#if	defined(__NDR_convert__float_rep__Request__rpc_jack_set_freewheel_t__onoff__defined)
+-	if (In0P->NDR.float_rep != NDR_record.float_rep) {
+-#if defined(__NDR_convert__float_rep__Request__rpc_jack_set_freewheel_t__onoff__defined)
+-		__NDR_convert__float_rep__Request__rpc_jack_set_freewheel_t__onoff(&In0P->onoff, In0P->NDR.float_rep);
+-#endif	/* __NDR_convert__float_rep__Request__rpc_jack_set_freewheel_t__onoff__defined */
+-	}
+-#endif	/* defined(__NDR_convert__float_rep...) */
+-
+-	return MACH_MSG_SUCCESS;
+-}
+-#endif /* !defined(__MIG_check__Request__rpc_jack_set_freewheel_t__defined) */
+-#endif /* __MIG_check__Request__JackRPCEngine_subsystem__ */
+-#endif /* ( __MigTypeCheck || __NDR_convert__ ) */
+-
+-
+-/* Routine rpc_jack_set_freewheel */
+-#ifdef	mig_external
+-mig_external
+-#else
+-extern
+-#endif	/* mig_external */
+-kern_return_t server_rpc_jack_set_freewheel
+-(
+-	mach_port_t server_port,
+-	int onoff,
+-	int *result
+-);
+-
+-/* Routine rpc_jack_set_freewheel */
+-mig_internal novalue _Xrpc_jack_set_freewheel
+-	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
+-{
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		int onoff;
+-		mach_msg_trailer_t trailer;
+-	} Request;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-	typedef __Request__rpc_jack_set_freewheel_t __Request;
+-	typedef __Reply__rpc_jack_set_freewheel_t Reply;
+-
+-	/*
+-	 * typedef struct {
+-	 * 	mach_msg_header_t Head;
+-	 * 	NDR_record_t NDR;
+-	 * 	kern_return_t RetCode;
+-	 * } mig_reply_error_t;
+-	 */
+-
+-	Request *In0P = (Request *) InHeadP;
+-	Reply *OutP = (Reply *) OutHeadP;
+-#ifdef	__MIG_check__Request__rpc_jack_set_freewheel_t__defined
+-	kern_return_t check_result;
+-#endif	/* __MIG_check__Request__rpc_jack_set_freewheel_t__defined */
+-
+-	__DeclareRcvRpc(1013, "rpc_jack_set_freewheel")
+-	__BeforeRcvRpc(1013, "rpc_jack_set_freewheel")
+-
+-#if	defined(__MIG_check__Request__rpc_jack_set_freewheel_t__defined)
+-	check_result = __MIG_check__Request__rpc_jack_set_freewheel_t((__Request *)In0P);
+-	if (check_result != MACH_MSG_SUCCESS)
+-		{ MIG_RETURN_ERROR(OutP, check_result); }
+-#endif	/* defined(__MIG_check__Request__rpc_jack_set_freewheel_t__defined) */
+-
+-	OutP->RetCode = server_rpc_jack_set_freewheel(In0P->Head.msgh_request_port, In0P->onoff, &OutP->result);
+-	if (OutP->RetCode != KERN_SUCCESS) {
+-		MIG_RETURN_ERROR(OutP, OutP->RetCode);
+-	}
+-
+-	OutP->NDR = NDR_record;
+-
+-
+-	OutP->Head.msgh_size = (mach_msg_size_t)(sizeof(Reply));
+-	__AfterRcvRpc(1013, "rpc_jack_set_freewheel")
+-}
+-
+-#if ( __MigTypeCheck || __NDR_convert__ )
+-#if __MIG_check__Request__JackRPCEngine_subsystem__
+-#if !defined(__MIG_check__Request__rpc_jack_release_timebase_t__defined)
+-#define __MIG_check__Request__rpc_jack_release_timebase_t__defined
+-#ifndef __NDR_convert__int_rep__Request__rpc_jack_release_timebase_t__refnum__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_release_timebase_t__refnum__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_release_timebase_t__refnum(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_release_timebase_t__refnum__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_release_timebase_t__refnum(a, f) \
+-	__NDR_convert__int_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_release_timebase_t__refnum__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_release_timebase_t__refnum(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int32_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_release_timebase_t__refnum__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_release_timebase_t__refnum(a, f) \
+-	__NDR_convert__int_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Request__rpc_jack_release_timebase_t__refnum__defined */
+-
+-#ifndef __NDR_convert__char_rep__Request__rpc_jack_release_timebase_t__refnum__defined
+-#if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_release_timebase_t__refnum__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_release_timebase_t__refnum(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_release_timebase_t__refnum__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_release_timebase_t__refnum(a, f) \
+-	__NDR_convert__char_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_release_timebase_t__refnum__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_release_timebase_t__refnum(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int32_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_release_timebase_t__refnum__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_release_timebase_t__refnum(a, f) \
+-	__NDR_convert__char_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__char_rep__Request__rpc_jack_release_timebase_t__refnum__defined */
+-
+-#ifndef __NDR_convert__float_rep__Request__rpc_jack_release_timebase_t__refnum__defined
+-#if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_release_timebase_t__refnum__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_release_timebase_t__refnum(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_release_timebase_t__refnum__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_release_timebase_t__refnum(a, f) \
+-	__NDR_convert__float_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_release_timebase_t__refnum__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_release_timebase_t__refnum(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int32_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_release_timebase_t__refnum__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_release_timebase_t__refnum(a, f) \
+-	__NDR_convert__float_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__float_rep__Request__rpc_jack_release_timebase_t__refnum__defined */
+-
+-
+-mig_internal kern_return_t __MIG_check__Request__rpc_jack_release_timebase_t(__attribute__((__unused__)) __Request__rpc_jack_release_timebase_t *In0P)
+-{
+-
+-	typedef __Request__rpc_jack_release_timebase_t __Request;
+-#if	__MigTypeCheck
+-	if ((In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
+-	    (In0P->Head.msgh_size != (mach_msg_size_t)sizeof(__Request)))
+-		return MIG_BAD_ARGUMENTS;
+-#endif	/* __MigTypeCheck */
+-
+-#if	defined(__NDR_convert__int_rep__Request__rpc_jack_release_timebase_t__refnum__defined)
+-	if (In0P->NDR.int_rep != NDR_record.int_rep) {
+-#if defined(__NDR_convert__int_rep__Request__rpc_jack_release_timebase_t__refnum__defined)
+-		__NDR_convert__int_rep__Request__rpc_jack_release_timebase_t__refnum(&In0P->refnum, In0P->NDR.int_rep);
+-#endif	/* __NDR_convert__int_rep__Request__rpc_jack_release_timebase_t__refnum__defined */
+-	}
+-#endif	/* defined(__NDR_convert__int_rep...) */
+-
+-#if	defined(__NDR_convert__char_rep__Request__rpc_jack_release_timebase_t__refnum__defined)
+-	if (In0P->NDR.char_rep != NDR_record.char_rep) {
+-#if defined(__NDR_convert__char_rep__Request__rpc_jack_release_timebase_t__refnum__defined)
+-		__NDR_convert__char_rep__Request__rpc_jack_release_timebase_t__refnum(&In0P->refnum, In0P->NDR.char_rep);
+-#endif	/* __NDR_convert__char_rep__Request__rpc_jack_release_timebase_t__refnum__defined */
+-	}
+-#endif	/* defined(__NDR_convert__char_rep...) */
+-
+-#if	defined(__NDR_convert__float_rep__Request__rpc_jack_release_timebase_t__refnum__defined)
+-	if (In0P->NDR.float_rep != NDR_record.float_rep) {
+-#if defined(__NDR_convert__float_rep__Request__rpc_jack_release_timebase_t__refnum__defined)
+-		__NDR_convert__float_rep__Request__rpc_jack_release_timebase_t__refnum(&In0P->refnum, In0P->NDR.float_rep);
+-#endif	/* __NDR_convert__float_rep__Request__rpc_jack_release_timebase_t__refnum__defined */
+-	}
+-#endif	/* defined(__NDR_convert__float_rep...) */
+-
+-	return MACH_MSG_SUCCESS;
+-}
+-#endif /* !defined(__MIG_check__Request__rpc_jack_release_timebase_t__defined) */
+-#endif /* __MIG_check__Request__JackRPCEngine_subsystem__ */
+-#endif /* ( __MigTypeCheck || __NDR_convert__ ) */
+-
+-
+-/* Routine rpc_jack_release_timebase */
+-#ifdef	mig_external
+-mig_external
+-#else
+-extern
+-#endif	/* mig_external */
+-kern_return_t server_rpc_jack_release_timebase
+-(
+-	mach_port_t server_port,
+-	int refnum,
+-	int *result
+-);
+-
+-/* Routine rpc_jack_release_timebase */
+-mig_internal novalue _Xrpc_jack_release_timebase
+-	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
+-{
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		int refnum;
+-		mach_msg_trailer_t trailer;
+-	} Request;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-	typedef __Request__rpc_jack_release_timebase_t __Request;
+-	typedef __Reply__rpc_jack_release_timebase_t Reply;
+-
+-	/*
+-	 * typedef struct {
+-	 * 	mach_msg_header_t Head;
+-	 * 	NDR_record_t NDR;
+-	 * 	kern_return_t RetCode;
+-	 * } mig_reply_error_t;
+-	 */
+-
+-	Request *In0P = (Request *) InHeadP;
+-	Reply *OutP = (Reply *) OutHeadP;
+-#ifdef	__MIG_check__Request__rpc_jack_release_timebase_t__defined
+-	kern_return_t check_result;
+-#endif	/* __MIG_check__Request__rpc_jack_release_timebase_t__defined */
+-
+-	__DeclareRcvRpc(1014, "rpc_jack_release_timebase")
+-	__BeforeRcvRpc(1014, "rpc_jack_release_timebase")
+-
+-#if	defined(__MIG_check__Request__rpc_jack_release_timebase_t__defined)
+-	check_result = __MIG_check__Request__rpc_jack_release_timebase_t((__Request *)In0P);
+-	if (check_result != MACH_MSG_SUCCESS)
+-		{ MIG_RETURN_ERROR(OutP, check_result); }
+-#endif	/* defined(__MIG_check__Request__rpc_jack_release_timebase_t__defined) */
+-
+-	OutP->RetCode = server_rpc_jack_release_timebase(In0P->Head.msgh_request_port, In0P->refnum, &OutP->result);
+-	if (OutP->RetCode != KERN_SUCCESS) {
+-		MIG_RETURN_ERROR(OutP, OutP->RetCode);
+-	}
+-
+-	OutP->NDR = NDR_record;
+-
+-
+-	OutP->Head.msgh_size = (mach_msg_size_t)(sizeof(Reply));
+-	__AfterRcvRpc(1014, "rpc_jack_release_timebase")
+-}
+-
+-#if ( __MigTypeCheck || __NDR_convert__ )
+-#if __MIG_check__Request__JackRPCEngine_subsystem__
+-#if !defined(__MIG_check__Request__rpc_jack_set_timebase_callback_t__defined)
+-#define __MIG_check__Request__rpc_jack_set_timebase_callback_t__defined
+-#ifndef __NDR_convert__int_rep__Request__rpc_jack_set_timebase_callback_t__refnum__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_set_timebase_callback_t__refnum__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_set_timebase_callback_t__refnum(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_set_timebase_callback_t__refnum__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_set_timebase_callback_t__refnum(a, f) \
+-	__NDR_convert__int_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_set_timebase_callback_t__refnum__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_set_timebase_callback_t__refnum(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int32_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_set_timebase_callback_t__refnum__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_set_timebase_callback_t__refnum(a, f) \
+-	__NDR_convert__int_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Request__rpc_jack_set_timebase_callback_t__refnum__defined */
+-
+-#ifndef __NDR_convert__int_rep__Request__rpc_jack_set_timebase_callback_t__conditional__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_set_timebase_callback_t__conditional__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_set_timebase_callback_t__conditional(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_set_timebase_callback_t__conditional__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_set_timebase_callback_t__conditional(a, f) \
+-	__NDR_convert__int_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_set_timebase_callback_t__conditional__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_set_timebase_callback_t__conditional(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int32_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_set_timebase_callback_t__conditional__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_set_timebase_callback_t__conditional(a, f) \
+-	__NDR_convert__int_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Request__rpc_jack_set_timebase_callback_t__conditional__defined */
+-
+-#ifndef __NDR_convert__char_rep__Request__rpc_jack_set_timebase_callback_t__refnum__defined
+-#if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_set_timebase_callback_t__refnum__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_set_timebase_callback_t__refnum(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_set_timebase_callback_t__refnum__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_set_timebase_callback_t__refnum(a, f) \
+-	__NDR_convert__char_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_set_timebase_callback_t__refnum__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_set_timebase_callback_t__refnum(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int32_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_set_timebase_callback_t__refnum__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_set_timebase_callback_t__refnum(a, f) \
+-	__NDR_convert__char_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__char_rep__Request__rpc_jack_set_timebase_callback_t__refnum__defined */
+-
+-#ifndef __NDR_convert__char_rep__Request__rpc_jack_set_timebase_callback_t__conditional__defined
+-#if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_set_timebase_callback_t__conditional__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_set_timebase_callback_t__conditional(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_set_timebase_callback_t__conditional__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_set_timebase_callback_t__conditional(a, f) \
+-	__NDR_convert__char_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_set_timebase_callback_t__conditional__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_set_timebase_callback_t__conditional(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int32_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_set_timebase_callback_t__conditional__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_set_timebase_callback_t__conditional(a, f) \
+-	__NDR_convert__char_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__char_rep__Request__rpc_jack_set_timebase_callback_t__conditional__defined */
+-
+-#ifndef __NDR_convert__float_rep__Request__rpc_jack_set_timebase_callback_t__refnum__defined
+-#if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_set_timebase_callback_t__refnum__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_set_timebase_callback_t__refnum(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_set_timebase_callback_t__refnum__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_set_timebase_callback_t__refnum(a, f) \
+-	__NDR_convert__float_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_set_timebase_callback_t__refnum__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_set_timebase_callback_t__refnum(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int32_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_set_timebase_callback_t__refnum__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_set_timebase_callback_t__refnum(a, f) \
+-	__NDR_convert__float_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__float_rep__Request__rpc_jack_set_timebase_callback_t__refnum__defined */
+-
+-#ifndef __NDR_convert__float_rep__Request__rpc_jack_set_timebase_callback_t__conditional__defined
+-#if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_set_timebase_callback_t__conditional__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_set_timebase_callback_t__conditional(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_set_timebase_callback_t__conditional__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_set_timebase_callback_t__conditional(a, f) \
+-	__NDR_convert__float_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_set_timebase_callback_t__conditional__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_set_timebase_callback_t__conditional(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int32_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_set_timebase_callback_t__conditional__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_set_timebase_callback_t__conditional(a, f) \
+-	__NDR_convert__float_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__float_rep__Request__rpc_jack_set_timebase_callback_t__conditional__defined */
+-
+-
+-mig_internal kern_return_t __MIG_check__Request__rpc_jack_set_timebase_callback_t(__attribute__((__unused__)) __Request__rpc_jack_set_timebase_callback_t *In0P)
+-{
+-
+-	typedef __Request__rpc_jack_set_timebase_callback_t __Request;
+-#if	__MigTypeCheck
+-	if ((In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
+-	    (In0P->Head.msgh_size != (mach_msg_size_t)sizeof(__Request)))
+-		return MIG_BAD_ARGUMENTS;
+-#endif	/* __MigTypeCheck */
+-
+-#if	defined(__NDR_convert__int_rep__Request__rpc_jack_set_timebase_callback_t__refnum__defined) || \
+-	defined(__NDR_convert__int_rep__Request__rpc_jack_set_timebase_callback_t__conditional__defined)
+-	if (In0P->NDR.int_rep != NDR_record.int_rep) {
+-#if defined(__NDR_convert__int_rep__Request__rpc_jack_set_timebase_callback_t__refnum__defined)
+-		__NDR_convert__int_rep__Request__rpc_jack_set_timebase_callback_t__refnum(&In0P->refnum, In0P->NDR.int_rep);
+-#endif	/* __NDR_convert__int_rep__Request__rpc_jack_set_timebase_callback_t__refnum__defined */
+-#if defined(__NDR_convert__int_rep__Request__rpc_jack_set_timebase_callback_t__conditional__defined)
+-		__NDR_convert__int_rep__Request__rpc_jack_set_timebase_callback_t__conditional(&In0P->conditional, In0P->NDR.int_rep);
+-#endif	/* __NDR_convert__int_rep__Request__rpc_jack_set_timebase_callback_t__conditional__defined */
+-	}
+-#endif	/* defined(__NDR_convert__int_rep...) */
+-
+-#if	defined(__NDR_convert__char_rep__Request__rpc_jack_set_timebase_callback_t__refnum__defined) || \
+-	defined(__NDR_convert__char_rep__Request__rpc_jack_set_timebase_callback_t__conditional__defined)
+-	if (In0P->NDR.char_rep != NDR_record.char_rep) {
+-#if defined(__NDR_convert__char_rep__Request__rpc_jack_set_timebase_callback_t__refnum__defined)
+-		__NDR_convert__char_rep__Request__rpc_jack_set_timebase_callback_t__refnum(&In0P->refnum, In0P->NDR.char_rep);
+-#endif	/* __NDR_convert__char_rep__Request__rpc_jack_set_timebase_callback_t__refnum__defined */
+-#if defined(__NDR_convert__char_rep__Request__rpc_jack_set_timebase_callback_t__conditional__defined)
+-		__NDR_convert__char_rep__Request__rpc_jack_set_timebase_callback_t__conditional(&In0P->conditional, In0P->NDR.char_rep);
+-#endif	/* __NDR_convert__char_rep__Request__rpc_jack_set_timebase_callback_t__conditional__defined */
+-	}
+-#endif	/* defined(__NDR_convert__char_rep...) */
+-
+-#if	defined(__NDR_convert__float_rep__Request__rpc_jack_set_timebase_callback_t__refnum__defined) || \
+-	defined(__NDR_convert__float_rep__Request__rpc_jack_set_timebase_callback_t__conditional__defined)
+-	if (In0P->NDR.float_rep != NDR_record.float_rep) {
+-#if defined(__NDR_convert__float_rep__Request__rpc_jack_set_timebase_callback_t__refnum__defined)
+-		__NDR_convert__float_rep__Request__rpc_jack_set_timebase_callback_t__refnum(&In0P->refnum, In0P->NDR.float_rep);
+-#endif	/* __NDR_convert__float_rep__Request__rpc_jack_set_timebase_callback_t__refnum__defined */
+-#if defined(__NDR_convert__float_rep__Request__rpc_jack_set_timebase_callback_t__conditional__defined)
+-		__NDR_convert__float_rep__Request__rpc_jack_set_timebase_callback_t__conditional(&In0P->conditional, In0P->NDR.float_rep);
+-#endif	/* __NDR_convert__float_rep__Request__rpc_jack_set_timebase_callback_t__conditional__defined */
+-	}
+-#endif	/* defined(__NDR_convert__float_rep...) */
+-
+-	return MACH_MSG_SUCCESS;
+-}
+-#endif /* !defined(__MIG_check__Request__rpc_jack_set_timebase_callback_t__defined) */
+-#endif /* __MIG_check__Request__JackRPCEngine_subsystem__ */
+-#endif /* ( __MigTypeCheck || __NDR_convert__ ) */
+-
+-
+-/* Routine rpc_jack_set_timebase_callback */
+-#ifdef	mig_external
+-mig_external
+-#else
+-extern
+-#endif	/* mig_external */
+-kern_return_t server_rpc_jack_set_timebase_callback
+-(
+-	mach_port_t server_port,
+-	int refnum,
+-	int conditional,
+-	int *result
+-);
+-
+-/* Routine rpc_jack_set_timebase_callback */
+-mig_internal novalue _Xrpc_jack_set_timebase_callback
+-	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
+-{
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		int refnum;
+-		int conditional;
+-		mach_msg_trailer_t trailer;
+-	} Request;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-	typedef __Request__rpc_jack_set_timebase_callback_t __Request;
+-	typedef __Reply__rpc_jack_set_timebase_callback_t Reply;
+-
+-	/*
+-	 * typedef struct {
+-	 * 	mach_msg_header_t Head;
+-	 * 	NDR_record_t NDR;
+-	 * 	kern_return_t RetCode;
+-	 * } mig_reply_error_t;
+-	 */
+-
+-	Request *In0P = (Request *) InHeadP;
+-	Reply *OutP = (Reply *) OutHeadP;
+-#ifdef	__MIG_check__Request__rpc_jack_set_timebase_callback_t__defined
+-	kern_return_t check_result;
+-#endif	/* __MIG_check__Request__rpc_jack_set_timebase_callback_t__defined */
+-
+-	__DeclareRcvRpc(1015, "rpc_jack_set_timebase_callback")
+-	__BeforeRcvRpc(1015, "rpc_jack_set_timebase_callback")
+-
+-#if	defined(__MIG_check__Request__rpc_jack_set_timebase_callback_t__defined)
+-	check_result = __MIG_check__Request__rpc_jack_set_timebase_callback_t((__Request *)In0P);
+-	if (check_result != MACH_MSG_SUCCESS)
+-		{ MIG_RETURN_ERROR(OutP, check_result); }
+-#endif	/* defined(__MIG_check__Request__rpc_jack_set_timebase_callback_t__defined) */
+-
+-	OutP->RetCode = server_rpc_jack_set_timebase_callback(In0P->Head.msgh_request_port, In0P->refnum, In0P->conditional, &OutP->result);
+-	if (OutP->RetCode != KERN_SUCCESS) {
+-		MIG_RETURN_ERROR(OutP, OutP->RetCode);
+-	}
+-
+-	OutP->NDR = NDR_record;
+-
+-
+-	OutP->Head.msgh_size = (mach_msg_size_t)(sizeof(Reply));
+-	__AfterRcvRpc(1015, "rpc_jack_set_timebase_callback")
+-}
+-
+-#if ( __MigTypeCheck || __NDR_convert__ )
+-#if __MIG_check__Request__JackRPCEngine_subsystem__
+-#if !defined(__MIG_check__Request__rpc_jack_get_internal_clientname_t__defined)
+-#define __MIG_check__Request__rpc_jack_get_internal_clientname_t__defined
+-#ifndef __NDR_convert__int_rep__Request__rpc_jack_get_internal_clientname_t__refnum__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_get_internal_clientname_t__refnum__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_get_internal_clientname_t__refnum(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_get_internal_clientname_t__refnum__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_get_internal_clientname_t__refnum(a, f) \
+-	__NDR_convert__int_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_get_internal_clientname_t__refnum__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_get_internal_clientname_t__refnum(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int32_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_get_internal_clientname_t__refnum__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_get_internal_clientname_t__refnum(a, f) \
+-	__NDR_convert__int_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Request__rpc_jack_get_internal_clientname_t__refnum__defined */
+-
+-#ifndef __NDR_convert__int_rep__Request__rpc_jack_get_internal_clientname_t__int_ref__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_get_internal_clientname_t__int_ref__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_get_internal_clientname_t__int_ref(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_get_internal_clientname_t__int_ref__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_get_internal_clientname_t__int_ref(a, f) \
+-	__NDR_convert__int_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_get_internal_clientname_t__int_ref__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_get_internal_clientname_t__int_ref(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int32_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_get_internal_clientname_t__int_ref__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_get_internal_clientname_t__int_ref(a, f) \
+-	__NDR_convert__int_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Request__rpc_jack_get_internal_clientname_t__int_ref__defined */
+-
+-#ifndef __NDR_convert__char_rep__Request__rpc_jack_get_internal_clientname_t__refnum__defined
+-#if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_get_internal_clientname_t__refnum__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_get_internal_clientname_t__refnum(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_get_internal_clientname_t__refnum__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_get_internal_clientname_t__refnum(a, f) \
+-	__NDR_convert__char_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_get_internal_clientname_t__refnum__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_get_internal_clientname_t__refnum(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int32_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_get_internal_clientname_t__refnum__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_get_internal_clientname_t__refnum(a, f) \
+-	__NDR_convert__char_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__char_rep__Request__rpc_jack_get_internal_clientname_t__refnum__defined */
+-
+-#ifndef __NDR_convert__char_rep__Request__rpc_jack_get_internal_clientname_t__int_ref__defined
+-#if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_get_internal_clientname_t__int_ref__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_get_internal_clientname_t__int_ref(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_get_internal_clientname_t__int_ref__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_get_internal_clientname_t__int_ref(a, f) \
+-	__NDR_convert__char_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_get_internal_clientname_t__int_ref__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_get_internal_clientname_t__int_ref(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int32_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_get_internal_clientname_t__int_ref__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_get_internal_clientname_t__int_ref(a, f) \
+-	__NDR_convert__char_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__char_rep__Request__rpc_jack_get_internal_clientname_t__int_ref__defined */
+-
+-#ifndef __NDR_convert__float_rep__Request__rpc_jack_get_internal_clientname_t__refnum__defined
+-#if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_get_internal_clientname_t__refnum__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_get_internal_clientname_t__refnum(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_get_internal_clientname_t__refnum__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_get_internal_clientname_t__refnum(a, f) \
+-	__NDR_convert__float_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_get_internal_clientname_t__refnum__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_get_internal_clientname_t__refnum(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int32_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_get_internal_clientname_t__refnum__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_get_internal_clientname_t__refnum(a, f) \
+-	__NDR_convert__float_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__float_rep__Request__rpc_jack_get_internal_clientname_t__refnum__defined */
+-
+-#ifndef __NDR_convert__float_rep__Request__rpc_jack_get_internal_clientname_t__int_ref__defined
+-#if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_get_internal_clientname_t__int_ref__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_get_internal_clientname_t__int_ref(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_get_internal_clientname_t__int_ref__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_get_internal_clientname_t__int_ref(a, f) \
+-	__NDR_convert__float_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_get_internal_clientname_t__int_ref__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_get_internal_clientname_t__int_ref(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int32_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_get_internal_clientname_t__int_ref__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_get_internal_clientname_t__int_ref(a, f) \
+-	__NDR_convert__float_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__float_rep__Request__rpc_jack_get_internal_clientname_t__int_ref__defined */
+-
+-
+-mig_internal kern_return_t __MIG_check__Request__rpc_jack_get_internal_clientname_t(__attribute__((__unused__)) __Request__rpc_jack_get_internal_clientname_t *In0P)
+-{
+-
+-	typedef __Request__rpc_jack_get_internal_clientname_t __Request;
+-#if	__MigTypeCheck
+-	if ((In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
+-	    (In0P->Head.msgh_size != (mach_msg_size_t)sizeof(__Request)))
+-		return MIG_BAD_ARGUMENTS;
+-#endif	/* __MigTypeCheck */
+-
+-#if	defined(__NDR_convert__int_rep__Request__rpc_jack_get_internal_clientname_t__refnum__defined) || \
+-	defined(__NDR_convert__int_rep__Request__rpc_jack_get_internal_clientname_t__int_ref__defined)
+-	if (In0P->NDR.int_rep != NDR_record.int_rep) {
+-#if defined(__NDR_convert__int_rep__Request__rpc_jack_get_internal_clientname_t__refnum__defined)
+-		__NDR_convert__int_rep__Request__rpc_jack_get_internal_clientname_t__refnum(&In0P->refnum, In0P->NDR.int_rep);
+-#endif	/* __NDR_convert__int_rep__Request__rpc_jack_get_internal_clientname_t__refnum__defined */
+-#if defined(__NDR_convert__int_rep__Request__rpc_jack_get_internal_clientname_t__int_ref__defined)
+-		__NDR_convert__int_rep__Request__rpc_jack_get_internal_clientname_t__int_ref(&In0P->int_ref, In0P->NDR.int_rep);
+-#endif	/* __NDR_convert__int_rep__Request__rpc_jack_get_internal_clientname_t__int_ref__defined */
+-	}
+-#endif	/* defined(__NDR_convert__int_rep...) */
+-
+-#if	defined(__NDR_convert__char_rep__Request__rpc_jack_get_internal_clientname_t__refnum__defined) || \
+-	defined(__NDR_convert__char_rep__Request__rpc_jack_get_internal_clientname_t__int_ref__defined)
+-	if (In0P->NDR.char_rep != NDR_record.char_rep) {
+-#if defined(__NDR_convert__char_rep__Request__rpc_jack_get_internal_clientname_t__refnum__defined)
+-		__NDR_convert__char_rep__Request__rpc_jack_get_internal_clientname_t__refnum(&In0P->refnum, In0P->NDR.char_rep);
+-#endif	/* __NDR_convert__char_rep__Request__rpc_jack_get_internal_clientname_t__refnum__defined */
+-#if defined(__NDR_convert__char_rep__Request__rpc_jack_get_internal_clientname_t__int_ref__defined)
+-		__NDR_convert__char_rep__Request__rpc_jack_get_internal_clientname_t__int_ref(&In0P->int_ref, In0P->NDR.char_rep);
+-#endif	/* __NDR_convert__char_rep__Request__rpc_jack_get_internal_clientname_t__int_ref__defined */
+-	}
+-#endif	/* defined(__NDR_convert__char_rep...) */
+-
+-#if	defined(__NDR_convert__float_rep__Request__rpc_jack_get_internal_clientname_t__refnum__defined) || \
+-	defined(__NDR_convert__float_rep__Request__rpc_jack_get_internal_clientname_t__int_ref__defined)
+-	if (In0P->NDR.float_rep != NDR_record.float_rep) {
+-#if defined(__NDR_convert__float_rep__Request__rpc_jack_get_internal_clientname_t__refnum__defined)
+-		__NDR_convert__float_rep__Request__rpc_jack_get_internal_clientname_t__refnum(&In0P->refnum, In0P->NDR.float_rep);
+-#endif	/* __NDR_convert__float_rep__Request__rpc_jack_get_internal_clientname_t__refnum__defined */
+-#if defined(__NDR_convert__float_rep__Request__rpc_jack_get_internal_clientname_t__int_ref__defined)
+-		__NDR_convert__float_rep__Request__rpc_jack_get_internal_clientname_t__int_ref(&In0P->int_ref, In0P->NDR.float_rep);
+-#endif	/* __NDR_convert__float_rep__Request__rpc_jack_get_internal_clientname_t__int_ref__defined */
+-	}
+-#endif	/* defined(__NDR_convert__float_rep...) */
+-
+-	return MACH_MSG_SUCCESS;
+-}
+-#endif /* !defined(__MIG_check__Request__rpc_jack_get_internal_clientname_t__defined) */
+-#endif /* __MIG_check__Request__JackRPCEngine_subsystem__ */
+-#endif /* ( __MigTypeCheck || __NDR_convert__ ) */
+-
+-
+-/* Routine rpc_jack_get_internal_clientname */
+-#ifdef	mig_external
+-mig_external
+-#else
+-extern
+-#endif	/* mig_external */
+-kern_return_t server_rpc_jack_get_internal_clientname
+-(
+-	mach_port_t server_port,
+-	int refnum,
+-	int int_ref,
+-	client_name_t client_name_res,
+-	int *result
+-);
+-
+-/* Routine rpc_jack_get_internal_clientname */
+-mig_internal novalue _Xrpc_jack_get_internal_clientname
+-	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
+-{
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		int refnum;
+-		int int_ref;
+-		mach_msg_trailer_t trailer;
+-	} Request;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-	typedef __Request__rpc_jack_get_internal_clientname_t __Request;
+-	typedef __Reply__rpc_jack_get_internal_clientname_t Reply;
+-
+-	/*
+-	 * typedef struct {
+-	 * 	mach_msg_header_t Head;
+-	 * 	NDR_record_t NDR;
+-	 * 	kern_return_t RetCode;
+-	 * } mig_reply_error_t;
+-	 */
+-
+-	Request *In0P = (Request *) InHeadP;
+-	Reply *OutP = (Reply *) OutHeadP;
+-#ifdef	__MIG_check__Request__rpc_jack_get_internal_clientname_t__defined
+-	kern_return_t check_result;
+-#endif	/* __MIG_check__Request__rpc_jack_get_internal_clientname_t__defined */
+-
+-	__DeclareRcvRpc(1016, "rpc_jack_get_internal_clientname")
+-	__BeforeRcvRpc(1016, "rpc_jack_get_internal_clientname")
+-
+-#if	defined(__MIG_check__Request__rpc_jack_get_internal_clientname_t__defined)
+-	check_result = __MIG_check__Request__rpc_jack_get_internal_clientname_t((__Request *)In0P);
+-	if (check_result != MACH_MSG_SUCCESS)
+-		{ MIG_RETURN_ERROR(OutP, check_result); }
+-#endif	/* defined(__MIG_check__Request__rpc_jack_get_internal_clientname_t__defined) */
+-
+-	OutP->RetCode = server_rpc_jack_get_internal_clientname(In0P->Head.msgh_request_port, In0P->refnum, In0P->int_ref, OutP->client_name_res, &OutP->result);
+-	if (OutP->RetCode != KERN_SUCCESS) {
+-		MIG_RETURN_ERROR(OutP, OutP->RetCode);
+-	}
+-
+-	OutP->NDR = NDR_record;
+-
+-
+-	OutP->Head.msgh_size = (mach_msg_size_t)(sizeof(Reply));
+-	__AfterRcvRpc(1016, "rpc_jack_get_internal_clientname")
+-}
+-
+-#if ( __MigTypeCheck || __NDR_convert__ )
+-#if __MIG_check__Request__JackRPCEngine_subsystem__
+-#if !defined(__MIG_check__Request__rpc_jack_internal_clienthandle_t__defined)
+-#define __MIG_check__Request__rpc_jack_internal_clienthandle_t__defined
+-#ifndef __NDR_convert__int_rep__Request__rpc_jack_internal_clienthandle_t__refnum__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_internal_clienthandle_t__refnum__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_internal_clienthandle_t__refnum(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_internal_clienthandle_t__refnum__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_internal_clienthandle_t__refnum(a, f) \
+-	__NDR_convert__int_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_internal_clienthandle_t__refnum__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_internal_clienthandle_t__refnum(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int32_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_internal_clienthandle_t__refnum__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_internal_clienthandle_t__refnum(a, f) \
+-	__NDR_convert__int_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Request__rpc_jack_internal_clienthandle_t__refnum__defined */
+-
+-#ifndef __NDR_convert__int_rep__Request__rpc_jack_internal_clienthandle_t__client_name__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCEngine__client_name_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_internal_clienthandle_t__client_name__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_internal_clienthandle_t__client_name(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__client_name_t((client_name_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__client_name_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_internal_clienthandle_t__client_name__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_internal_clienthandle_t__client_name(a, f) \
+-	__NDR_convert__int_rep__client_name_t((client_name_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__JackRPCEngine__string__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_internal_clienthandle_t__client_name__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_internal_clienthandle_t__client_name(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__string(a, f, 64)
+-#elif	defined(__NDR_convert__int_rep__string__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_internal_clienthandle_t__client_name__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_internal_clienthandle_t__client_name(a, f) \
+-	__NDR_convert__int_rep__string(a, f, 64)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Request__rpc_jack_internal_clienthandle_t__client_name__defined */
+-
+-#ifndef __NDR_convert__char_rep__Request__rpc_jack_internal_clienthandle_t__refnum__defined
+-#if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_internal_clienthandle_t__refnum__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_internal_clienthandle_t__refnum(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_internal_clienthandle_t__refnum__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_internal_clienthandle_t__refnum(a, f) \
+-	__NDR_convert__char_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_internal_clienthandle_t__refnum__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_internal_clienthandle_t__refnum(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int32_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_internal_clienthandle_t__refnum__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_internal_clienthandle_t__refnum(a, f) \
+-	__NDR_convert__char_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__char_rep__Request__rpc_jack_internal_clienthandle_t__refnum__defined */
+-
+-#ifndef __NDR_convert__char_rep__Request__rpc_jack_internal_clienthandle_t__client_name__defined
+-#if	defined(__NDR_convert__char_rep__JackRPCEngine__client_name_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_internal_clienthandle_t__client_name__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_internal_clienthandle_t__client_name(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__client_name_t((client_name_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__client_name_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_internal_clienthandle_t__client_name__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_internal_clienthandle_t__client_name(a, f) \
+-	__NDR_convert__char_rep__client_name_t((client_name_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__JackRPCEngine__string__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_internal_clienthandle_t__client_name__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_internal_clienthandle_t__client_name(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__string(a, f, 64)
+-#elif	defined(__NDR_convert__char_rep__string__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_internal_clienthandle_t__client_name__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_internal_clienthandle_t__client_name(a, f) \
+-	__NDR_convert__char_rep__string(a, f, 64)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__char_rep__Request__rpc_jack_internal_clienthandle_t__client_name__defined */
+-
+-#ifndef __NDR_convert__float_rep__Request__rpc_jack_internal_clienthandle_t__refnum__defined
+-#if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_internal_clienthandle_t__refnum__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_internal_clienthandle_t__refnum(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_internal_clienthandle_t__refnum__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_internal_clienthandle_t__refnum(a, f) \
+-	__NDR_convert__float_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_internal_clienthandle_t__refnum__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_internal_clienthandle_t__refnum(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int32_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_internal_clienthandle_t__refnum__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_internal_clienthandle_t__refnum(a, f) \
+-	__NDR_convert__float_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__float_rep__Request__rpc_jack_internal_clienthandle_t__refnum__defined */
+-
+-#ifndef __NDR_convert__float_rep__Request__rpc_jack_internal_clienthandle_t__client_name__defined
+-#if	defined(__NDR_convert__float_rep__JackRPCEngine__client_name_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_internal_clienthandle_t__client_name__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_internal_clienthandle_t__client_name(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__client_name_t((client_name_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__client_name_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_internal_clienthandle_t__client_name__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_internal_clienthandle_t__client_name(a, f) \
+-	__NDR_convert__float_rep__client_name_t((client_name_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__JackRPCEngine__string__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_internal_clienthandle_t__client_name__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_internal_clienthandle_t__client_name(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__string(a, f, 64)
+-#elif	defined(__NDR_convert__float_rep__string__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_internal_clienthandle_t__client_name__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_internal_clienthandle_t__client_name(a, f) \
+-	__NDR_convert__float_rep__string(a, f, 64)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__float_rep__Request__rpc_jack_internal_clienthandle_t__client_name__defined */
+-
+-
+-mig_internal kern_return_t __MIG_check__Request__rpc_jack_internal_clienthandle_t(__attribute__((__unused__)) __Request__rpc_jack_internal_clienthandle_t *In0P)
+-{
+-
+-	typedef __Request__rpc_jack_internal_clienthandle_t __Request;
+-#if	__MigTypeCheck
+-	if ((In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
+-	    (In0P->Head.msgh_size != (mach_msg_size_t)sizeof(__Request)))
+-		return MIG_BAD_ARGUMENTS;
+-#endif	/* __MigTypeCheck */
+-
+-#if __MigTypeCheck
+-	{
+-		char * msg_limit = ((char *) In0P) + In0P->Head.msgh_size;
+-		size_t memchr_limit;
+-
+-		memchr_limit = min((msg_limit - In0P->client_name),  64);
+-		if (( memchr(In0P->client_name, '\0', memchr_limit) == NULL ))
+-			return MIG_BAD_ARGUMENTS; // string length exceeds buffer length!
+-	}
+-#endif	/* __MigTypeCheck */
+-
+-#if	defined(__NDR_convert__int_rep__Request__rpc_jack_internal_clienthandle_t__refnum__defined) || \
+-	defined(__NDR_convert__int_rep__Request__rpc_jack_internal_clienthandle_t__client_name__defined)
+-	if (In0P->NDR.int_rep != NDR_record.int_rep) {
+-#if defined(__NDR_convert__int_rep__Request__rpc_jack_internal_clienthandle_t__refnum__defined)
+-		__NDR_convert__int_rep__Request__rpc_jack_internal_clienthandle_t__refnum(&In0P->refnum, In0P->NDR.int_rep);
+-#endif	/* __NDR_convert__int_rep__Request__rpc_jack_internal_clienthandle_t__refnum__defined */
+-#if defined(__NDR_convert__int_rep__Request__rpc_jack_internal_clienthandle_t__client_name__defined)
+-		__NDR_convert__int_rep__Request__rpc_jack_internal_clienthandle_t__client_name(&In0P->client_name, In0P->NDR.int_rep);
+-#endif	/* __NDR_convert__int_rep__Request__rpc_jack_internal_clienthandle_t__client_name__defined */
+-	}
+-#endif	/* defined(__NDR_convert__int_rep...) */
+-
+-#if	defined(__NDR_convert__char_rep__Request__rpc_jack_internal_clienthandle_t__refnum__defined) || \
+-	defined(__NDR_convert__char_rep__Request__rpc_jack_internal_clienthandle_t__client_name__defined)
+-	if (In0P->NDR.char_rep != NDR_record.char_rep) {
+-#if defined(__NDR_convert__char_rep__Request__rpc_jack_internal_clienthandle_t__refnum__defined)
+-		__NDR_convert__char_rep__Request__rpc_jack_internal_clienthandle_t__refnum(&In0P->refnum, In0P->NDR.char_rep);
+-#endif	/* __NDR_convert__char_rep__Request__rpc_jack_internal_clienthandle_t__refnum__defined */
+-#if defined(__NDR_convert__char_rep__Request__rpc_jack_internal_clienthandle_t__client_name__defined)
+-		__NDR_convert__char_rep__Request__rpc_jack_internal_clienthandle_t__client_name(&In0P->client_name, In0P->NDR.char_rep);
+-#endif	/* __NDR_convert__char_rep__Request__rpc_jack_internal_clienthandle_t__client_name__defined */
+-	}
+-#endif	/* defined(__NDR_convert__char_rep...) */
+-
+-#if	defined(__NDR_convert__float_rep__Request__rpc_jack_internal_clienthandle_t__refnum__defined) || \
+-	defined(__NDR_convert__float_rep__Request__rpc_jack_internal_clienthandle_t__client_name__defined)
+-	if (In0P->NDR.float_rep != NDR_record.float_rep) {
+-#if defined(__NDR_convert__float_rep__Request__rpc_jack_internal_clienthandle_t__refnum__defined)
+-		__NDR_convert__float_rep__Request__rpc_jack_internal_clienthandle_t__refnum(&In0P->refnum, In0P->NDR.float_rep);
+-#endif	/* __NDR_convert__float_rep__Request__rpc_jack_internal_clienthandle_t__refnum__defined */
+-#if defined(__NDR_convert__float_rep__Request__rpc_jack_internal_clienthandle_t__client_name__defined)
+-		__NDR_convert__float_rep__Request__rpc_jack_internal_clienthandle_t__client_name(&In0P->client_name, In0P->NDR.float_rep);
+-#endif	/* __NDR_convert__float_rep__Request__rpc_jack_internal_clienthandle_t__client_name__defined */
+-	}
+-#endif	/* defined(__NDR_convert__float_rep...) */
+-
+-	return MACH_MSG_SUCCESS;
+-}
+-#endif /* !defined(__MIG_check__Request__rpc_jack_internal_clienthandle_t__defined) */
+-#endif /* __MIG_check__Request__JackRPCEngine_subsystem__ */
+-#endif /* ( __MigTypeCheck || __NDR_convert__ ) */
+-
+-
+-/* Routine rpc_jack_internal_clienthandle */
+-#ifdef	mig_external
+-mig_external
+-#else
+-extern
+-#endif	/* mig_external */
+-kern_return_t server_rpc_jack_internal_clienthandle
+-(
+-	mach_port_t server_port,
+-	int refnum,
+-	client_name_t client_name,
+-	int *int_ref,
+-	int *status,
+-	int *result
+-);
+-
+-/* Routine rpc_jack_internal_clienthandle */
+-mig_internal novalue _Xrpc_jack_internal_clienthandle
+-	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
+-{
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		int refnum;
+-		client_name_t client_name;
+-		mach_msg_trailer_t trailer;
+-	} Request;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-	typedef __Request__rpc_jack_internal_clienthandle_t __Request;
+-	typedef __Reply__rpc_jack_internal_clienthandle_t Reply;
+-
+-	/*
+-	 * typedef struct {
+-	 * 	mach_msg_header_t Head;
+-	 * 	NDR_record_t NDR;
+-	 * 	kern_return_t RetCode;
+-	 * } mig_reply_error_t;
+-	 */
+-
+-	Request *In0P = (Request *) InHeadP;
+-	Reply *OutP = (Reply *) OutHeadP;
+-#ifdef	__MIG_check__Request__rpc_jack_internal_clienthandle_t__defined
+-	kern_return_t check_result;
+-#endif	/* __MIG_check__Request__rpc_jack_internal_clienthandle_t__defined */
+-
+-	__DeclareRcvRpc(1017, "rpc_jack_internal_clienthandle")
+-	__BeforeRcvRpc(1017, "rpc_jack_internal_clienthandle")
+-
+-#if	defined(__MIG_check__Request__rpc_jack_internal_clienthandle_t__defined)
+-	check_result = __MIG_check__Request__rpc_jack_internal_clienthandle_t((__Request *)In0P);
+-	if (check_result != MACH_MSG_SUCCESS)
+-		{ MIG_RETURN_ERROR(OutP, check_result); }
+-#endif	/* defined(__MIG_check__Request__rpc_jack_internal_clienthandle_t__defined) */
+-
+-	OutP->RetCode = server_rpc_jack_internal_clienthandle(In0P->Head.msgh_request_port, In0P->refnum, In0P->client_name, &OutP->int_ref, &OutP->status, &OutP->result);
+-	if (OutP->RetCode != KERN_SUCCESS) {
+-		MIG_RETURN_ERROR(OutP, OutP->RetCode);
+-	}
+-
+-	OutP->NDR = NDR_record;
+-
+-
+-	OutP->Head.msgh_size = (mach_msg_size_t)(sizeof(Reply));
+-	__AfterRcvRpc(1017, "rpc_jack_internal_clienthandle")
+-}
+-
+-#if ( __MigTypeCheck || __NDR_convert__ )
+-#if __MIG_check__Request__JackRPCEngine_subsystem__
+-#if !defined(__MIG_check__Request__rpc_jack_internal_clientload_t__defined)
+-#define __MIG_check__Request__rpc_jack_internal_clientload_t__defined
+-#ifndef __NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__refnum__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__refnum__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__refnum(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__refnum__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__refnum(a, f) \
+-	__NDR_convert__int_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__refnum__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__refnum(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int32_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__refnum__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__refnum(a, f) \
+-	__NDR_convert__int_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__refnum__defined */
+-
+-#ifndef __NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__client_name__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCEngine__client_name_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__client_name__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__client_name(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__client_name_t((client_name_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__client_name_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__client_name__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__client_name(a, f) \
+-	__NDR_convert__int_rep__client_name_t((client_name_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__JackRPCEngine__string__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__client_name__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__client_name(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__string(a, f, 64)
+-#elif	defined(__NDR_convert__int_rep__string__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__client_name__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__client_name(a, f) \
+-	__NDR_convert__int_rep__string(a, f, 64)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__client_name__defined */
+-
+-#ifndef __NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__so_name__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCEngine__so_name_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__so_name__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__so_name(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__so_name_t((so_name_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__so_name_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__so_name__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__so_name(a, f) \
+-	__NDR_convert__int_rep__so_name_t((so_name_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__JackRPCEngine__string__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__so_name__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__so_name(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__string(a, f, 256)
+-#elif	defined(__NDR_convert__int_rep__string__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__so_name__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__so_name(a, f) \
+-	__NDR_convert__int_rep__string(a, f, 256)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__so_name__defined */
+-
+-#ifndef __NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__objet_data__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCEngine__objet_data_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__objet_data__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__objet_data(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__objet_data_t((objet_data_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__objet_data_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__objet_data__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__objet_data(a, f) \
+-	__NDR_convert__int_rep__objet_data_t((objet_data_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__JackRPCEngine__string__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__objet_data__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__objet_data(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__string(a, f, 256)
+-#elif	defined(__NDR_convert__int_rep__string__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__objet_data__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__objet_data(a, f) \
+-	__NDR_convert__int_rep__string(a, f, 256)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__objet_data__defined */
+-
+-#ifndef __NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__options__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__options__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__options(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__options__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__options(a, f) \
+-	__NDR_convert__int_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__options__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__options(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int32_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__options__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__options(a, f) \
+-	__NDR_convert__int_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__options__defined */
+-
+-#ifndef __NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__refnum__defined
+-#if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__refnum__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__refnum(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__refnum__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__refnum(a, f) \
+-	__NDR_convert__char_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__refnum__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__refnum(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int32_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__refnum__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__refnum(a, f) \
+-	__NDR_convert__char_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__refnum__defined */
+-
+-#ifndef __NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__client_name__defined
+-#if	defined(__NDR_convert__char_rep__JackRPCEngine__client_name_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__client_name__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__client_name(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__client_name_t((client_name_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__client_name_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__client_name__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__client_name(a, f) \
+-	__NDR_convert__char_rep__client_name_t((client_name_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__JackRPCEngine__string__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__client_name__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__client_name(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__string(a, f, 64)
+-#elif	defined(__NDR_convert__char_rep__string__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__client_name__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__client_name(a, f) \
+-	__NDR_convert__char_rep__string(a, f, 64)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__client_name__defined */
+-
+-#ifndef __NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__so_name__defined
+-#if	defined(__NDR_convert__char_rep__JackRPCEngine__so_name_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__so_name__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__so_name(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__so_name_t((so_name_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__so_name_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__so_name__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__so_name(a, f) \
+-	__NDR_convert__char_rep__so_name_t((so_name_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__JackRPCEngine__string__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__so_name__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__so_name(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__string(a, f, 256)
+-#elif	defined(__NDR_convert__char_rep__string__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__so_name__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__so_name(a, f) \
+-	__NDR_convert__char_rep__string(a, f, 256)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__so_name__defined */
+-
+-#ifndef __NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__objet_data__defined
+-#if	defined(__NDR_convert__char_rep__JackRPCEngine__objet_data_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__objet_data__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__objet_data(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__objet_data_t((objet_data_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__objet_data_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__objet_data__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__objet_data(a, f) \
+-	__NDR_convert__char_rep__objet_data_t((objet_data_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__JackRPCEngine__string__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__objet_data__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__objet_data(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__string(a, f, 256)
+-#elif	defined(__NDR_convert__char_rep__string__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__objet_data__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__objet_data(a, f) \
+-	__NDR_convert__char_rep__string(a, f, 256)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__objet_data__defined */
+-
+-#ifndef __NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__options__defined
+-#if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__options__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__options(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__options__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__options(a, f) \
+-	__NDR_convert__char_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__options__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__options(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int32_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__options__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__options(a, f) \
+-	__NDR_convert__char_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__options__defined */
+-
+-#ifndef __NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__refnum__defined
+-#if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__refnum__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__refnum(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__refnum__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__refnum(a, f) \
+-	__NDR_convert__float_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__refnum__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__refnum(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int32_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__refnum__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__refnum(a, f) \
+-	__NDR_convert__float_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__refnum__defined */
+-
+-#ifndef __NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__client_name__defined
+-#if	defined(__NDR_convert__float_rep__JackRPCEngine__client_name_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__client_name__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__client_name(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__client_name_t((client_name_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__client_name_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__client_name__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__client_name(a, f) \
+-	__NDR_convert__float_rep__client_name_t((client_name_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__JackRPCEngine__string__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__client_name__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__client_name(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__string(a, f, 64)
+-#elif	defined(__NDR_convert__float_rep__string__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__client_name__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__client_name(a, f) \
+-	__NDR_convert__float_rep__string(a, f, 64)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__client_name__defined */
+-
+-#ifndef __NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__so_name__defined
+-#if	defined(__NDR_convert__float_rep__JackRPCEngine__so_name_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__so_name__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__so_name(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__so_name_t((so_name_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__so_name_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__so_name__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__so_name(a, f) \
+-	__NDR_convert__float_rep__so_name_t((so_name_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__JackRPCEngine__string__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__so_name__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__so_name(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__string(a, f, 256)
+-#elif	defined(__NDR_convert__float_rep__string__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__so_name__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__so_name(a, f) \
+-	__NDR_convert__float_rep__string(a, f, 256)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__so_name__defined */
+-
+-#ifndef __NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__objet_data__defined
+-#if	defined(__NDR_convert__float_rep__JackRPCEngine__objet_data_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__objet_data__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__objet_data(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__objet_data_t((objet_data_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__objet_data_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__objet_data__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__objet_data(a, f) \
+-	__NDR_convert__float_rep__objet_data_t((objet_data_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__JackRPCEngine__string__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__objet_data__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__objet_data(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__string(a, f, 256)
+-#elif	defined(__NDR_convert__float_rep__string__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__objet_data__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__objet_data(a, f) \
+-	__NDR_convert__float_rep__string(a, f, 256)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__objet_data__defined */
+-
+-#ifndef __NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__options__defined
+-#if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__options__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__options(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__options__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__options(a, f) \
+-	__NDR_convert__float_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__options__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__options(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int32_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__options__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__options(a, f) \
+-	__NDR_convert__float_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__options__defined */
+-
+-
+-mig_internal kern_return_t __MIG_check__Request__rpc_jack_internal_clientload_t(__attribute__((__unused__)) __Request__rpc_jack_internal_clientload_t *In0P)
+-{
+-
+-	typedef __Request__rpc_jack_internal_clientload_t __Request;
+-#if	__MigTypeCheck
+-	if ((In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
+-	    (In0P->Head.msgh_size != (mach_msg_size_t)sizeof(__Request)))
+-		return MIG_BAD_ARGUMENTS;
+-#endif	/* __MigTypeCheck */
+-
+-#if __MigTypeCheck
+-	{
+-		char * msg_limit = ((char *) In0P) + In0P->Head.msgh_size;
+-		size_t memchr_limit;
+-
+-		memchr_limit = min((msg_limit - In0P->client_name),  64);
+-		if (( memchr(In0P->client_name, '\0', memchr_limit) == NULL ))
+-			return MIG_BAD_ARGUMENTS; // string length exceeds buffer length!
+-		memchr_limit = min((msg_limit - In0P->so_name),  256);
+-		if (( memchr(In0P->so_name, '\0', memchr_limit) == NULL ))
+-			return MIG_BAD_ARGUMENTS; // string length exceeds buffer length!
+-		memchr_limit = min((msg_limit - In0P->objet_data),  256);
+-		if (( memchr(In0P->objet_data, '\0', memchr_limit) == NULL ))
+-			return MIG_BAD_ARGUMENTS; // string length exceeds buffer length!
+-	}
+-#endif	/* __MigTypeCheck */
+-
+-#if	defined(__NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__refnum__defined) || \
+-	defined(__NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__client_name__defined) || \
+-	defined(__NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__so_name__defined) || \
+-	defined(__NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__objet_data__defined) || \
+-	defined(__NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__options__defined)
+-	if (In0P->NDR.int_rep != NDR_record.int_rep) {
+-#if defined(__NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__refnum__defined)
+-		__NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__refnum(&In0P->refnum, In0P->NDR.int_rep);
+-#endif	/* __NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__refnum__defined */
+-#if defined(__NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__client_name__defined)
+-		__NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__client_name(&In0P->client_name, In0P->NDR.int_rep);
+-#endif	/* __NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__client_name__defined */
+-#if defined(__NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__so_name__defined)
+-		__NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__so_name(&In0P->so_name, In0P->NDR.int_rep);
+-#endif	/* __NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__so_name__defined */
+-#if defined(__NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__objet_data__defined)
+-		__NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__objet_data(&In0P->objet_data, In0P->NDR.int_rep);
+-#endif	/* __NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__objet_data__defined */
+-#if defined(__NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__options__defined)
+-		__NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__options(&In0P->options, In0P->NDR.int_rep);
+-#endif	/* __NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__options__defined */
+-	}
+-#endif	/* defined(__NDR_convert__int_rep...) */
+-
+-#if	defined(__NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__refnum__defined) || \
+-	defined(__NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__client_name__defined) || \
+-	defined(__NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__so_name__defined) || \
+-	defined(__NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__objet_data__defined) || \
+-	defined(__NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__options__defined)
+-	if (In0P->NDR.char_rep != NDR_record.char_rep) {
+-#if defined(__NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__refnum__defined)
+-		__NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__refnum(&In0P->refnum, In0P->NDR.char_rep);
+-#endif	/* __NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__refnum__defined */
+-#if defined(__NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__client_name__defined)
+-		__NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__client_name(&In0P->client_name, In0P->NDR.char_rep);
+-#endif	/* __NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__client_name__defined */
+-#if defined(__NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__so_name__defined)
+-		__NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__so_name(&In0P->so_name, In0P->NDR.char_rep);
+-#endif	/* __NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__so_name__defined */
+-#if defined(__NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__objet_data__defined)
+-		__NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__objet_data(&In0P->objet_data, In0P->NDR.char_rep);
+-#endif	/* __NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__objet_data__defined */
+-#if defined(__NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__options__defined)
+-		__NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__options(&In0P->options, In0P->NDR.char_rep);
+-#endif	/* __NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__options__defined */
+-	}
+-#endif	/* defined(__NDR_convert__char_rep...) */
+-
+-#if	defined(__NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__refnum__defined) || \
+-	defined(__NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__client_name__defined) || \
+-	defined(__NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__so_name__defined) || \
+-	defined(__NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__objet_data__defined) || \
+-	defined(__NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__options__defined)
+-	if (In0P->NDR.float_rep != NDR_record.float_rep) {
+-#if defined(__NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__refnum__defined)
+-		__NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__refnum(&In0P->refnum, In0P->NDR.float_rep);
+-#endif	/* __NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__refnum__defined */
+-#if defined(__NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__client_name__defined)
+-		__NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__client_name(&In0P->client_name, In0P->NDR.float_rep);
+-#endif	/* __NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__client_name__defined */
+-#if defined(__NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__so_name__defined)
+-		__NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__so_name(&In0P->so_name, In0P->NDR.float_rep);
+-#endif	/* __NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__so_name__defined */
+-#if defined(__NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__objet_data__defined)
+-		__NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__objet_data(&In0P->objet_data, In0P->NDR.float_rep);
+-#endif	/* __NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__objet_data__defined */
+-#if defined(__NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__options__defined)
+-		__NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__options(&In0P->options, In0P->NDR.float_rep);
+-#endif	/* __NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__options__defined */
+-	}
+-#endif	/* defined(__NDR_convert__float_rep...) */
+-
+-	return MACH_MSG_SUCCESS;
+-}
+-#endif /* !defined(__MIG_check__Request__rpc_jack_internal_clientload_t__defined) */
+-#endif /* __MIG_check__Request__JackRPCEngine_subsystem__ */
+-#endif /* ( __MigTypeCheck || __NDR_convert__ ) */
+-
+-
+-/* Routine rpc_jack_internal_clientload */
+-#ifdef	mig_external
+-mig_external
+-#else
+-extern
+-#endif	/* mig_external */
+-kern_return_t server_rpc_jack_internal_clientload
+-(
+-	mach_port_t server_port,
+-	int refnum,
+-	client_name_t client_name,
+-	so_name_t so_name,
+-	objet_data_t objet_data,
+-	int options,
+-	int *status,
+-	int *int_ref,
+-	int *result
+-);
+-
+-/* Routine rpc_jack_internal_clientload */
+-mig_internal novalue _Xrpc_jack_internal_clientload
+-	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
+-{
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		int refnum;
+-		client_name_t client_name;
+-		so_name_t so_name;
+-		objet_data_t objet_data;
+-		int options;
+-		mach_msg_trailer_t trailer;
+-	} Request;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-	typedef __Request__rpc_jack_internal_clientload_t __Request;
+-	typedef __Reply__rpc_jack_internal_clientload_t Reply;
+-
+-	/*
+-	 * typedef struct {
+-	 * 	mach_msg_header_t Head;
+-	 * 	NDR_record_t NDR;
+-	 * 	kern_return_t RetCode;
+-	 * } mig_reply_error_t;
+-	 */
+-
+-	Request *In0P = (Request *) InHeadP;
+-	Reply *OutP = (Reply *) OutHeadP;
+-#ifdef	__MIG_check__Request__rpc_jack_internal_clientload_t__defined
+-	kern_return_t check_result;
+-#endif	/* __MIG_check__Request__rpc_jack_internal_clientload_t__defined */
+-
+-	__DeclareRcvRpc(1018, "rpc_jack_internal_clientload")
+-	__BeforeRcvRpc(1018, "rpc_jack_internal_clientload")
+-
+-#if	defined(__MIG_check__Request__rpc_jack_internal_clientload_t__defined)
+-	check_result = __MIG_check__Request__rpc_jack_internal_clientload_t((__Request *)In0P);
+-	if (check_result != MACH_MSG_SUCCESS)
+-		{ MIG_RETURN_ERROR(OutP, check_result); }
+-#endif	/* defined(__MIG_check__Request__rpc_jack_internal_clientload_t__defined) */
+-
+-	OutP->RetCode = server_rpc_jack_internal_clientload(In0P->Head.msgh_request_port, In0P->refnum, In0P->client_name, In0P->so_name, In0P->objet_data, In0P->options, &OutP->status, &OutP->int_ref, &OutP->result);
+-	if (OutP->RetCode != KERN_SUCCESS) {
+-		MIG_RETURN_ERROR(OutP, OutP->RetCode);
+-	}
+-
+-	OutP->NDR = NDR_record;
+-
+-
+-	OutP->Head.msgh_size = (mach_msg_size_t)(sizeof(Reply));
+-	__AfterRcvRpc(1018, "rpc_jack_internal_clientload")
+-}
+-
+-#if ( __MigTypeCheck || __NDR_convert__ )
+-#if __MIG_check__Request__JackRPCEngine_subsystem__
+-#if !defined(__MIG_check__Request__rpc_jack_internal_clientunload_t__defined)
+-#define __MIG_check__Request__rpc_jack_internal_clientunload_t__defined
+-#ifndef __NDR_convert__int_rep__Request__rpc_jack_internal_clientunload_t__refnum__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_internal_clientunload_t__refnum__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_internal_clientunload_t__refnum(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_internal_clientunload_t__refnum__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_internal_clientunload_t__refnum(a, f) \
+-	__NDR_convert__int_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_internal_clientunload_t__refnum__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_internal_clientunload_t__refnum(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int32_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_internal_clientunload_t__refnum__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_internal_clientunload_t__refnum(a, f) \
+-	__NDR_convert__int_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Request__rpc_jack_internal_clientunload_t__refnum__defined */
+-
+-#ifndef __NDR_convert__int_rep__Request__rpc_jack_internal_clientunload_t__int_ref__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_internal_clientunload_t__int_ref__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_internal_clientunload_t__int_ref(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_internal_clientunload_t__int_ref__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_internal_clientunload_t__int_ref(a, f) \
+-	__NDR_convert__int_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_internal_clientunload_t__int_ref__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_internal_clientunload_t__int_ref(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int32_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_internal_clientunload_t__int_ref__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_internal_clientunload_t__int_ref(a, f) \
+-	__NDR_convert__int_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Request__rpc_jack_internal_clientunload_t__int_ref__defined */
+-
+-#ifndef __NDR_convert__char_rep__Request__rpc_jack_internal_clientunload_t__refnum__defined
+-#if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_internal_clientunload_t__refnum__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_internal_clientunload_t__refnum(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_internal_clientunload_t__refnum__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_internal_clientunload_t__refnum(a, f) \
+-	__NDR_convert__char_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_internal_clientunload_t__refnum__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_internal_clientunload_t__refnum(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int32_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_internal_clientunload_t__refnum__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_internal_clientunload_t__refnum(a, f) \
+-	__NDR_convert__char_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__char_rep__Request__rpc_jack_internal_clientunload_t__refnum__defined */
+-
+-#ifndef __NDR_convert__char_rep__Request__rpc_jack_internal_clientunload_t__int_ref__defined
+-#if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_internal_clientunload_t__int_ref__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_internal_clientunload_t__int_ref(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_internal_clientunload_t__int_ref__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_internal_clientunload_t__int_ref(a, f) \
+-	__NDR_convert__char_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_internal_clientunload_t__int_ref__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_internal_clientunload_t__int_ref(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int32_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_internal_clientunload_t__int_ref__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_internal_clientunload_t__int_ref(a, f) \
+-	__NDR_convert__char_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__char_rep__Request__rpc_jack_internal_clientunload_t__int_ref__defined */
+-
+-#ifndef __NDR_convert__float_rep__Request__rpc_jack_internal_clientunload_t__refnum__defined
+-#if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_internal_clientunload_t__refnum__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_internal_clientunload_t__refnum(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_internal_clientunload_t__refnum__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_internal_clientunload_t__refnum(a, f) \
+-	__NDR_convert__float_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_internal_clientunload_t__refnum__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_internal_clientunload_t__refnum(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int32_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_internal_clientunload_t__refnum__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_internal_clientunload_t__refnum(a, f) \
+-	__NDR_convert__float_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__float_rep__Request__rpc_jack_internal_clientunload_t__refnum__defined */
+-
+-#ifndef __NDR_convert__float_rep__Request__rpc_jack_internal_clientunload_t__int_ref__defined
+-#if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_internal_clientunload_t__int_ref__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_internal_clientunload_t__int_ref(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_internal_clientunload_t__int_ref__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_internal_clientunload_t__int_ref(a, f) \
+-	__NDR_convert__float_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_internal_clientunload_t__int_ref__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_internal_clientunload_t__int_ref(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int32_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_internal_clientunload_t__int_ref__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_internal_clientunload_t__int_ref(a, f) \
+-	__NDR_convert__float_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__float_rep__Request__rpc_jack_internal_clientunload_t__int_ref__defined */
+-
+-
+-mig_internal kern_return_t __MIG_check__Request__rpc_jack_internal_clientunload_t(__attribute__((__unused__)) __Request__rpc_jack_internal_clientunload_t *In0P)
+-{
+-
+-	typedef __Request__rpc_jack_internal_clientunload_t __Request;
+-#if	__MigTypeCheck
+-	if ((In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
+-	    (In0P->Head.msgh_size != (mach_msg_size_t)sizeof(__Request)))
+-		return MIG_BAD_ARGUMENTS;
+-#endif	/* __MigTypeCheck */
+-
+-#if	defined(__NDR_convert__int_rep__Request__rpc_jack_internal_clientunload_t__refnum__defined) || \
+-	defined(__NDR_convert__int_rep__Request__rpc_jack_internal_clientunload_t__int_ref__defined)
+-	if (In0P->NDR.int_rep != NDR_record.int_rep) {
+-#if defined(__NDR_convert__int_rep__Request__rpc_jack_internal_clientunload_t__refnum__defined)
+-		__NDR_convert__int_rep__Request__rpc_jack_internal_clientunload_t__refnum(&In0P->refnum, In0P->NDR.int_rep);
+-#endif	/* __NDR_convert__int_rep__Request__rpc_jack_internal_clientunload_t__refnum__defined */
+-#if defined(__NDR_convert__int_rep__Request__rpc_jack_internal_clientunload_t__int_ref__defined)
+-		__NDR_convert__int_rep__Request__rpc_jack_internal_clientunload_t__int_ref(&In0P->int_ref, In0P->NDR.int_rep);
+-#endif	/* __NDR_convert__int_rep__Request__rpc_jack_internal_clientunload_t__int_ref__defined */
+-	}
+-#endif	/* defined(__NDR_convert__int_rep...) */
+-
+-#if	defined(__NDR_convert__char_rep__Request__rpc_jack_internal_clientunload_t__refnum__defined) || \
+-	defined(__NDR_convert__char_rep__Request__rpc_jack_internal_clientunload_t__int_ref__defined)
+-	if (In0P->NDR.char_rep != NDR_record.char_rep) {
+-#if defined(__NDR_convert__char_rep__Request__rpc_jack_internal_clientunload_t__refnum__defined)
+-		__NDR_convert__char_rep__Request__rpc_jack_internal_clientunload_t__refnum(&In0P->refnum, In0P->NDR.char_rep);
+-#endif	/* __NDR_convert__char_rep__Request__rpc_jack_internal_clientunload_t__refnum__defined */
+-#if defined(__NDR_convert__char_rep__Request__rpc_jack_internal_clientunload_t__int_ref__defined)
+-		__NDR_convert__char_rep__Request__rpc_jack_internal_clientunload_t__int_ref(&In0P->int_ref, In0P->NDR.char_rep);
+-#endif	/* __NDR_convert__char_rep__Request__rpc_jack_internal_clientunload_t__int_ref__defined */
+-	}
+-#endif	/* defined(__NDR_convert__char_rep...) */
+-
+-#if	defined(__NDR_convert__float_rep__Request__rpc_jack_internal_clientunload_t__refnum__defined) || \
+-	defined(__NDR_convert__float_rep__Request__rpc_jack_internal_clientunload_t__int_ref__defined)
+-	if (In0P->NDR.float_rep != NDR_record.float_rep) {
+-#if defined(__NDR_convert__float_rep__Request__rpc_jack_internal_clientunload_t__refnum__defined)
+-		__NDR_convert__float_rep__Request__rpc_jack_internal_clientunload_t__refnum(&In0P->refnum, In0P->NDR.float_rep);
+-#endif	/* __NDR_convert__float_rep__Request__rpc_jack_internal_clientunload_t__refnum__defined */
+-#if defined(__NDR_convert__float_rep__Request__rpc_jack_internal_clientunload_t__int_ref__defined)
+-		__NDR_convert__float_rep__Request__rpc_jack_internal_clientunload_t__int_ref(&In0P->int_ref, In0P->NDR.float_rep);
+-#endif	/* __NDR_convert__float_rep__Request__rpc_jack_internal_clientunload_t__int_ref__defined */
+-	}
+-#endif	/* defined(__NDR_convert__float_rep...) */
+-
+-	return MACH_MSG_SUCCESS;
+-}
+-#endif /* !defined(__MIG_check__Request__rpc_jack_internal_clientunload_t__defined) */
+-#endif /* __MIG_check__Request__JackRPCEngine_subsystem__ */
+-#endif /* ( __MigTypeCheck || __NDR_convert__ ) */
+-
+-
+-/* Routine rpc_jack_internal_clientunload */
+-#ifdef	mig_external
+-mig_external
+-#else
+-extern
+-#endif	/* mig_external */
+-kern_return_t server_rpc_jack_internal_clientunload
+-(
+-	mach_port_t server_port,
+-	int refnum,
+-	int int_ref,
+-	int *status,
+-	int *result
+-);
+-
+-/* Routine rpc_jack_internal_clientunload */
+-mig_internal novalue _Xrpc_jack_internal_clientunload
+-	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
+-{
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		int refnum;
+-		int int_ref;
+-		mach_msg_trailer_t trailer;
+-	} Request;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-	typedef __Request__rpc_jack_internal_clientunload_t __Request;
+-	typedef __Reply__rpc_jack_internal_clientunload_t Reply;
+-
+-	/*
+-	 * typedef struct {
+-	 * 	mach_msg_header_t Head;
+-	 * 	NDR_record_t NDR;
+-	 * 	kern_return_t RetCode;
+-	 * } mig_reply_error_t;
+-	 */
+-
+-	Request *In0P = (Request *) InHeadP;
+-	Reply *OutP = (Reply *) OutHeadP;
+-#ifdef	__MIG_check__Request__rpc_jack_internal_clientunload_t__defined
+-	kern_return_t check_result;
+-#endif	/* __MIG_check__Request__rpc_jack_internal_clientunload_t__defined */
+-
+-	__DeclareRcvRpc(1019, "rpc_jack_internal_clientunload")
+-	__BeforeRcvRpc(1019, "rpc_jack_internal_clientunload")
+-
+-#if	defined(__MIG_check__Request__rpc_jack_internal_clientunload_t__defined)
+-	check_result = __MIG_check__Request__rpc_jack_internal_clientunload_t((__Request *)In0P);
+-	if (check_result != MACH_MSG_SUCCESS)
+-		{ MIG_RETURN_ERROR(OutP, check_result); }
+-#endif	/* defined(__MIG_check__Request__rpc_jack_internal_clientunload_t__defined) */
+-
+-	OutP->RetCode = server_rpc_jack_internal_clientunload(In0P->Head.msgh_request_port, In0P->refnum, In0P->int_ref, &OutP->status, &OutP->result);
+-	if (OutP->RetCode != KERN_SUCCESS) {
+-		MIG_RETURN_ERROR(OutP, OutP->RetCode);
+-	}
+-
+-	OutP->NDR = NDR_record;
+-
+-
+-	OutP->Head.msgh_size = (mach_msg_size_t)(sizeof(Reply));
+-	__AfterRcvRpc(1019, "rpc_jack_internal_clientunload")
+-}
+-
+-#if ( __MigTypeCheck || __NDR_convert__ )
+-#if __MIG_check__Request__JackRPCEngine_subsystem__
+-#if !defined(__MIG_check__Request__rpc_jack_client_rt_notify_t__defined)
+-#define __MIG_check__Request__rpc_jack_client_rt_notify_t__defined
+-#ifndef __NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__refnum__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__refnum__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__refnum(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__refnum__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__refnum(a, f) \
+-	__NDR_convert__int_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__refnum__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__refnum(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int32_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__refnum__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__refnum(a, f) \
+-	__NDR_convert__int_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__refnum__defined */
+-
+-#ifndef __NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__notify__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__notify__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__notify(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__notify__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__notify(a, f) \
+-	__NDR_convert__int_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__notify__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__notify(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int32_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__notify__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__notify(a, f) \
+-	__NDR_convert__int_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__notify__defined */
+-
+-#ifndef __NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__value__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__value__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__value(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__value__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__value(a, f) \
+-	__NDR_convert__int_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__value__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__value(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int32_t__defined)
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__value__defined
+-#define	__NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__value(a, f) \
+-	__NDR_convert__int_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__value__defined */
+-
+-#ifndef __NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__refnum__defined
+-#if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__refnum__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__refnum(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__refnum__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__refnum(a, f) \
+-	__NDR_convert__char_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__refnum__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__refnum(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int32_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__refnum__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__refnum(a, f) \
+-	__NDR_convert__char_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__refnum__defined */
+-
+-#ifndef __NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__notify__defined
+-#if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__notify__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__notify(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__notify__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__notify(a, f) \
+-	__NDR_convert__char_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__notify__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__notify(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int32_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__notify__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__notify(a, f) \
+-	__NDR_convert__char_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__notify__defined */
+-
+-#ifndef __NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__value__defined
+-#if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__value__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__value(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__value__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__value(a, f) \
+-	__NDR_convert__char_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__value__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__value(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int32_t__defined)
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__value__defined
+-#define	__NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__value(a, f) \
+-	__NDR_convert__char_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__value__defined */
+-
+-#ifndef __NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__refnum__defined
+-#if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__refnum__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__refnum(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__refnum__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__refnum(a, f) \
+-	__NDR_convert__float_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__refnum__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__refnum(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int32_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__refnum__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__refnum(a, f) \
+-	__NDR_convert__float_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__refnum__defined */
+-
+-#ifndef __NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__notify__defined
+-#if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__notify__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__notify(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__notify__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__notify(a, f) \
+-	__NDR_convert__float_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__notify__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__notify(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int32_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__notify__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__notify(a, f) \
+-	__NDR_convert__float_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__notify__defined */
+-
+-#ifndef __NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__value__defined
+-#if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__value__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__value(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__value__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__value(a, f) \
+-	__NDR_convert__float_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__value__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__value(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int32_t__defined)
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__value__defined
+-#define	__NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__value(a, f) \
+-	__NDR_convert__float_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__value__defined */
+-
+-
+-mig_internal kern_return_t __MIG_check__Request__rpc_jack_client_rt_notify_t(__attribute__((__unused__)) __Request__rpc_jack_client_rt_notify_t *In0P)
+-{
+-
+-	typedef __Request__rpc_jack_client_rt_notify_t __Request;
+-#if	__MigTypeCheck
+-	if ((In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
+-	    (In0P->Head.msgh_size != (mach_msg_size_t)sizeof(__Request)))
+-		return MIG_BAD_ARGUMENTS;
+-#endif	/* __MigTypeCheck */
+-
+-#if	defined(__NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__refnum__defined) || \
+-	defined(__NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__notify__defined) || \
+-	defined(__NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__value__defined)
+-	if (In0P->NDR.int_rep != NDR_record.int_rep) {
+-#if defined(__NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__refnum__defined)
+-		__NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__refnum(&In0P->refnum, In0P->NDR.int_rep);
+-#endif	/* __NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__refnum__defined */
+-#if defined(__NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__notify__defined)
+-		__NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__notify(&In0P->notify, In0P->NDR.int_rep);
+-#endif	/* __NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__notify__defined */
+-#if defined(__NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__value__defined)
+-		__NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__value(&In0P->value, In0P->NDR.int_rep);
+-#endif	/* __NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__value__defined */
+-	}
+-#endif	/* defined(__NDR_convert__int_rep...) */
+-
+-#if	defined(__NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__refnum__defined) || \
+-	defined(__NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__notify__defined) || \
+-	defined(__NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__value__defined)
+-	if (In0P->NDR.char_rep != NDR_record.char_rep) {
+-#if defined(__NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__refnum__defined)
+-		__NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__refnum(&In0P->refnum, In0P->NDR.char_rep);
+-#endif	/* __NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__refnum__defined */
+-#if defined(__NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__notify__defined)
+-		__NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__notify(&In0P->notify, In0P->NDR.char_rep);
+-#endif	/* __NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__notify__defined */
+-#if defined(__NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__value__defined)
+-		__NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__value(&In0P->value, In0P->NDR.char_rep);
+-#endif	/* __NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__value__defined */
+-	}
+-#endif	/* defined(__NDR_convert__char_rep...) */
+-
+-#if	defined(__NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__refnum__defined) || \
+-	defined(__NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__notify__defined) || \
+-	defined(__NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__value__defined)
+-	if (In0P->NDR.float_rep != NDR_record.float_rep) {
+-#if defined(__NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__refnum__defined)
+-		__NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__refnum(&In0P->refnum, In0P->NDR.float_rep);
+-#endif	/* __NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__refnum__defined */
+-#if defined(__NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__notify__defined)
+-		__NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__notify(&In0P->notify, In0P->NDR.float_rep);
+-#endif	/* __NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__notify__defined */
+-#if defined(__NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__value__defined)
+-		__NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__value(&In0P->value, In0P->NDR.float_rep);
+-#endif	/* __NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__value__defined */
+-	}
+-#endif	/* defined(__NDR_convert__float_rep...) */
+-
+-	return MACH_MSG_SUCCESS;
+-}
+-#endif /* !defined(__MIG_check__Request__rpc_jack_client_rt_notify_t__defined) */
+-#endif /* __MIG_check__Request__JackRPCEngine_subsystem__ */
+-#endif /* ( __MigTypeCheck || __NDR_convert__ ) */
+-
+-
+-/* SimpleRoutine rpc_jack_client_rt_notify */
+-#ifdef	mig_external
+-mig_external
+-#else
+-extern
+-#endif	/* mig_external */
+-kern_return_t server_rpc_jack_client_rt_notify
+-(
+-	mach_port_t client_port,
+-	int refnum,
+-	int notify,
+-	int value
+-);
+-
+-/* SimpleRoutine rpc_jack_client_rt_notify */
+-mig_internal novalue _Xrpc_jack_client_rt_notify
+-	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
+-{
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		int refnum;
+-		int notify;
+-		int value;
+-		mach_msg_trailer_t trailer;
+-	} Request;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-	typedef __Request__rpc_jack_client_rt_notify_t __Request;
+-	typedef __Reply__rpc_jack_client_rt_notify_t Reply;
+-
+-	/*
+-	 * typedef struct {
+-	 * 	mach_msg_header_t Head;
+-	 * 	NDR_record_t NDR;
+-	 * 	kern_return_t RetCode;
+-	 * } mig_reply_error_t;
+-	 */
+-
+-	Request *In0P = (Request *) InHeadP;
+-	Reply *OutP = (Reply *) OutHeadP;
+-#ifdef	__MIG_check__Request__rpc_jack_client_rt_notify_t__defined
+-	kern_return_t check_result;
+-#endif	/* __MIG_check__Request__rpc_jack_client_rt_notify_t__defined */
+-
+-	__DeclareRcvSimple(1020, "rpc_jack_client_rt_notify")
+-	__BeforeRcvSimple(1020, "rpc_jack_client_rt_notify")
+-
+-#if	defined(__MIG_check__Request__rpc_jack_client_rt_notify_t__defined)
+-	check_result = __MIG_check__Request__rpc_jack_client_rt_notify_t((__Request *)In0P);
+-	if (check_result != MACH_MSG_SUCCESS)
+-		{ MIG_RETURN_ERROR(OutP, check_result); }
+-#endif	/* defined(__MIG_check__Request__rpc_jack_client_rt_notify_t__defined) */
+-
+-	OutP->RetCode = server_rpc_jack_client_rt_notify(In0P->Head.msgh_request_port, In0P->refnum, In0P->notify, In0P->value);
+-	__AfterRcvSimple(1020, "rpc_jack_client_rt_notify")
+-}
+-
+-
+-extern boolean_t JackRPCEngine_server(
+-		mach_msg_header_t *InHeadP,
+-		mach_msg_header_t *OutHeadP);
+-
+-extern mig_routine_t JackRPCEngine_server_routine(
+-		mach_msg_header_t *InHeadP);
+-
+-
+-/* Description of this subsystem, for use in direct RPC */
+-const struct server_JackRPCEngine_subsystem {
+-	mig_server_routine_t 	server;	/* Server routine */
+-	mach_msg_id_t	start;	/* Min routine number */
+-	mach_msg_id_t	end;	/* Max routine number + 1 */
+-	unsigned int	maxsize;	/* Max msg size */
+-	vm_address_t	reserved;	/* Reserved */
+-	struct routine_descriptor	/*Array of routine descriptors */
+-		routine[21];
+-} server_JackRPCEngine_subsystem = {
+-	JackRPCEngine_server_routine,
+-	1000,
+-	1021,
+-	(mach_msg_size_t)sizeof(union __ReplyUnion__server_JackRPCEngine_subsystem),
+-	(vm_address_t)0,
+-	{
+-          { (mig_impl_routine_t) 0,
+-          (mig_stub_routine_t) _Xrpc_jack_client_open, 8, 0, (routine_arg_descriptor_t)0, (mach_msg_size_t)sizeof(__Reply__rpc_jack_client_open_t)},
+-          { (mig_impl_routine_t) 0,
+-          (mig_stub_routine_t) _Xrpc_jack_client_check, 7, 0, (routine_arg_descriptor_t)0, (mach_msg_size_t)sizeof(__Reply__rpc_jack_client_check_t)},
+-          { (mig_impl_routine_t) 0,
+-          (mig_stub_routine_t) _Xrpc_jack_client_close, 3, 0, (routine_arg_descriptor_t)0, (mach_msg_size_t)sizeof(__Reply__rpc_jack_client_close_t)},
+-          { (mig_impl_routine_t) 0,
+-          (mig_stub_routine_t) _Xrpc_jack_client_activate, 4, 0, (routine_arg_descriptor_t)0, (mach_msg_size_t)sizeof(__Reply__rpc_jack_client_activate_t)},
+-          { (mig_impl_routine_t) 0,
+-          (mig_stub_routine_t) _Xrpc_jack_client_deactivate, 3, 0, (routine_arg_descriptor_t)0, (mach_msg_size_t)sizeof(__Reply__rpc_jack_client_deactivate_t)},
+-          { (mig_impl_routine_t) 0,
+-          (mig_stub_routine_t) _Xrpc_jack_port_register, 8, 0, (routine_arg_descriptor_t)0, (mach_msg_size_t)sizeof(__Reply__rpc_jack_port_register_t)},
+-          { (mig_impl_routine_t) 0,
+-          (mig_stub_routine_t) _Xrpc_jack_port_unregister, 4, 0, (routine_arg_descriptor_t)0, (mach_msg_size_t)sizeof(__Reply__rpc_jack_port_unregister_t)},
+-          { (mig_impl_routine_t) 0,
+-          (mig_stub_routine_t) _Xrpc_jack_port_connect, 5, 0, (routine_arg_descriptor_t)0, (mach_msg_size_t)sizeof(__Reply__rpc_jack_port_connect_t)},
+-          { (mig_impl_routine_t) 0,
+-          (mig_stub_routine_t) _Xrpc_jack_port_disconnect, 5, 0, (routine_arg_descriptor_t)0, (mach_msg_size_t)sizeof(__Reply__rpc_jack_port_disconnect_t)},
+-          { (mig_impl_routine_t) 0,
+-          (mig_stub_routine_t) _Xrpc_jack_port_connect_name, 5, 0, (routine_arg_descriptor_t)0, (mach_msg_size_t)sizeof(__Reply__rpc_jack_port_connect_name_t)},
+-          { (mig_impl_routine_t) 0,
+-          (mig_stub_routine_t) _Xrpc_jack_port_disconnect_name, 5, 0, (routine_arg_descriptor_t)0, (mach_msg_size_t)sizeof(__Reply__rpc_jack_port_disconnect_name_t)},
+-          { (mig_impl_routine_t) 0,
+-          (mig_stub_routine_t) _Xrpc_jack_port_rename, 5, 0, (routine_arg_descriptor_t)0, (mach_msg_size_t)sizeof(__Reply__rpc_jack_port_rename_t)},
+-          { (mig_impl_routine_t) 0,
+-          (mig_stub_routine_t) _Xrpc_jack_set_buffer_size, 3, 0, (routine_arg_descriptor_t)0, (mach_msg_size_t)sizeof(__Reply__rpc_jack_set_buffer_size_t)},
+-          { (mig_impl_routine_t) 0,
+-          (mig_stub_routine_t) _Xrpc_jack_set_freewheel, 3, 0, (routine_arg_descriptor_t)0, (mach_msg_size_t)sizeof(__Reply__rpc_jack_set_freewheel_t)},
+-          { (mig_impl_routine_t) 0,
+-          (mig_stub_routine_t) _Xrpc_jack_release_timebase, 3, 0, (routine_arg_descriptor_t)0, (mach_msg_size_t)sizeof(__Reply__rpc_jack_release_timebase_t)},
+-          { (mig_impl_routine_t) 0,
+-          (mig_stub_routine_t) _Xrpc_jack_set_timebase_callback, 4, 0, (routine_arg_descriptor_t)0, (mach_msg_size_t)sizeof(__Reply__rpc_jack_set_timebase_callback_t)},
+-          { (mig_impl_routine_t) 0,
+-          (mig_stub_routine_t) _Xrpc_jack_get_internal_clientname, 5, 0, (routine_arg_descriptor_t)0, (mach_msg_size_t)sizeof(__Reply__rpc_jack_get_internal_clientname_t)},
+-          { (mig_impl_routine_t) 0,
+-          (mig_stub_routine_t) _Xrpc_jack_internal_clienthandle, 6, 0, (routine_arg_descriptor_t)0, (mach_msg_size_t)sizeof(__Reply__rpc_jack_internal_clienthandle_t)},
+-          { (mig_impl_routine_t) 0,
+-          (mig_stub_routine_t) _Xrpc_jack_internal_clientload, 9, 0, (routine_arg_descriptor_t)0, (mach_msg_size_t)sizeof(__Reply__rpc_jack_internal_clientload_t)},
+-          { (mig_impl_routine_t) 0,
+-          (mig_stub_routine_t) _Xrpc_jack_internal_clientunload, 5, 0, (routine_arg_descriptor_t)0, (mach_msg_size_t)sizeof(__Reply__rpc_jack_internal_clientunload_t)},
+-          { (mig_impl_routine_t) 0,
+-          (mig_stub_routine_t) _Xrpc_jack_client_rt_notify, 4, 0, (routine_arg_descriptor_t)0, (mach_msg_size_t)sizeof(__Reply__rpc_jack_client_rt_notify_t)},
+-	}
+-};
+-
+-mig_external boolean_t JackRPCEngine_server
+-	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
+-{
+-	/*
+-	 * typedef struct {
+-	 * 	mach_msg_header_t Head;
+-	 * 	NDR_record_t NDR;
+-	 * 	kern_return_t RetCode;
+-	 * } mig_reply_error_t;
+-	 */
+-
+-	register mig_routine_t routine;
+-
+-	OutHeadP->msgh_bits = MACH_MSGH_BITS(MACH_MSGH_BITS_REPLY(InHeadP->msgh_bits), 0);
+-	OutHeadP->msgh_remote_port = InHeadP->msgh_reply_port;
+-	/* Minimal size: routine() will update it if different */
+-	OutHeadP->msgh_size = (mach_msg_size_t)sizeof(mig_reply_error_t);
+-	OutHeadP->msgh_local_port = MACH_PORT_NULL;
+-	OutHeadP->msgh_id = InHeadP->msgh_id + 100;
+-
+-	if ((InHeadP->msgh_id > 1020) || (InHeadP->msgh_id < 1000) ||
+-	    ((routine = server_JackRPCEngine_subsystem.routine[InHeadP->msgh_id - 1000].stub_routine) == 0)) {
+-		((mig_reply_error_t *)OutHeadP)->NDR = NDR_record;
+-		((mig_reply_error_t *)OutHeadP)->RetCode = MIG_BAD_ID;
+-		return FALSE;
+-	}
+-	(*routine) (InHeadP, OutHeadP);
+-	return TRUE;
+-}
+-
+-mig_external mig_routine_t JackRPCEngine_server_routine
+-	(mach_msg_header_t *InHeadP)
+-{
+-	register int msgh_id;
+-
+-	msgh_id = InHeadP->msgh_id - 1000;
+-
+-	if ((msgh_id > 20) || (msgh_id < 0))
+-		return 0;
+-
+-	return server_JackRPCEngine_subsystem.routine[msgh_id].stub_routine;
+-}
+--- a/macosx/RPC/JackRPCEngineUser.c
++++ /dev/null
+@@ -1,6302 +0,0 @@
+-/*
+- * IDENTIFICATION:
+- * stub generated Fri Oct 23 10:35:08 2009
+- * with a MiG generated Mon May 18 09:59:33 PDT 2009 by root at sulitlana.apple.com
+- * OPTIONS: 
+- */
+-#define	__MIG_check__Reply__JackRPCEngine_subsystem__ 1
+-#define	__NDR_convert__Reply__JackRPCEngine_subsystem__ 1
+-#define	__NDR_convert__mig_reply_error_subsystem__ 1
+-
+-#include "JackRPCEngine.h"
+-
+-
+-#ifndef	mig_internal
+-#define	mig_internal	static __inline__
+-#endif	/* mig_internal */
+-
+-#ifndef	mig_external
+-#define mig_external
+-#endif	/* mig_external */
+-
+-#if	!defined(__MigTypeCheck) && defined(TypeCheck)
+-#define	__MigTypeCheck		TypeCheck	/* Legacy setting */
+-#endif	/* !defined(__MigTypeCheck) */
+-
+-#if	!defined(__MigKernelSpecificCode) && defined(_MIG_KERNEL_SPECIFIC_CODE_)
+-#define	__MigKernelSpecificCode	_MIG_KERNEL_SPECIFIC_CODE_	/* Legacy setting */
+-#endif	/* !defined(__MigKernelSpecificCode) */
+-
+-#ifndef	LimitCheck
+-#define	LimitCheck 0
+-#endif	/* LimitCheck */
+-
+-#ifndef	min
+-#define	min(a,b)  ( ((a) < (b))? (a): (b) )
+-#endif	/* min */
+-
+-#if !defined(_WALIGN_)
+-#define _WALIGN_(x) (((x) + 3) & ~3)
+-#endif /* !defined(_WALIGN_) */
+-
+-#if !defined(_WALIGNSZ_)
+-#define _WALIGNSZ_(x) _WALIGN_(sizeof(x))
+-#endif /* !defined(_WALIGNSZ_) */
+-
+-#ifndef	UseStaticTemplates
+-#define	UseStaticTemplates	0
+-#endif	/* UseStaticTemplates */
+-
+-#ifndef	__MachMsgErrorWithTimeout
+-#define	__MachMsgErrorWithTimeout(_R_) { \
+-	switch (_R_) { \
+-	case MACH_SEND_INVALID_DATA: \
+-	case MACH_SEND_INVALID_DEST: \
+-	case MACH_SEND_INVALID_HEADER: \
+-		mig_put_reply_port(InP->Head.msgh_reply_port); \
+-		break; \
+-	case MACH_SEND_TIMED_OUT: \
+-	case MACH_RCV_TIMED_OUT: \
+-	default: \
+-		mig_dealloc_reply_port(InP->Head.msgh_reply_port); \
+-	} \
+-}
+-#endif	/* __MachMsgErrorWithTimeout */
+-
+-#ifndef	__MachMsgErrorWithoutTimeout
+-#define	__MachMsgErrorWithoutTimeout(_R_) { \
+-	switch (_R_) { \
+-	case MACH_SEND_INVALID_DATA: \
+-	case MACH_SEND_INVALID_DEST: \
+-	case MACH_SEND_INVALID_HEADER: \
+-		mig_put_reply_port(InP->Head.msgh_reply_port); \
+-		break; \
+-	default: \
+-		mig_dealloc_reply_port(InP->Head.msgh_reply_port); \
+-	} \
+-}
+-#endif	/* __MachMsgErrorWithoutTimeout */
+-
+-#ifndef	__DeclareSendRpc
+-#define	__DeclareSendRpc(_NUM_, _NAME_)
+-#endif	/* __DeclareSendRpc */
+-
+-#ifndef	__BeforeSendRpc
+-#define	__BeforeSendRpc(_NUM_, _NAME_)
+-#endif	/* __BeforeSendRpc */
+-
+-#ifndef	__AfterSendRpc
+-#define	__AfterSendRpc(_NUM_, _NAME_)
+-#endif	/* __AfterSendRpc */
+-
+-#ifndef	__DeclareSendSimple
+-#define	__DeclareSendSimple(_NUM_, _NAME_)
+-#endif	/* __DeclareSendSimple */
+-
+-#ifndef	__BeforeSendSimple
+-#define	__BeforeSendSimple(_NUM_, _NAME_)
+-#endif	/* __BeforeSendSimple */
+-
+-#ifndef	__AfterSendSimple
+-#define	__AfterSendSimple(_NUM_, _NAME_)
+-#endif	/* __AfterSendSimple */
+-
+-#define msgh_request_port	msgh_remote_port
+-#define msgh_reply_port		msgh_local_port
+-
+-
+-
+-#if ( __MigTypeCheck || __NDR_convert__ )
+-#if __MIG_check__Reply__JackRPCEngine_subsystem__
+-#if !defined(__MIG_check__Reply__rpc_jack_client_open_t__defined)
+-#define __MIG_check__Reply__rpc_jack_client_open_t__defined
+-#ifndef __NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_engine__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_engine__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_engine(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_engine__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_engine(a, f) \
+-	__NDR_convert__int_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_engine__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_engine(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int32_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_engine__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_engine(a, f) \
+-	__NDR_convert__int_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_engine__defined */
+-
+-
+-#ifndef __NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_client__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_client__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_client(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_client__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_client(a, f) \
+-	__NDR_convert__int_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_client__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_client(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int32_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_client__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_client(a, f) \
+-	__NDR_convert__int_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_client__defined */
+-
+-
+-#ifndef __NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_graph__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_graph__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_graph(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_graph__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_graph(a, f) \
+-	__NDR_convert__int_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_graph__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_graph(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int32_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_graph__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_graph(a, f) \
+-	__NDR_convert__int_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_graph__defined */
+-
+-
+-#ifndef __NDR_convert__int_rep__Reply__rpc_jack_client_open_t__result__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__result__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__result(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__result__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__result(a, f) \
+-	__NDR_convert__int_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__result__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__result(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int32_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__result__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__result(a, f) \
+-	__NDR_convert__int_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_open_t__result__defined */
+-
+-
+-#ifndef __NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_engine__defined
+-#if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_engine__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_engine(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_engine__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_engine(a, f) \
+-	__NDR_convert__char_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_engine__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_engine(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int32_t__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_engine__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_engine(a, f) \
+-	__NDR_convert__char_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_engine__defined */
+-
+-
+-#ifndef __NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_client__defined
+-#if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_client__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_client(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_client__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_client(a, f) \
+-	__NDR_convert__char_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_client__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_client(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int32_t__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_client__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_client(a, f) \
+-	__NDR_convert__char_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_client__defined */
+-
+-
+-#ifndef __NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_graph__defined
+-#if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_graph__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_graph(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_graph__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_graph(a, f) \
+-	__NDR_convert__char_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_graph__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_graph(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int32_t__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_graph__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_graph(a, f) \
+-	__NDR_convert__char_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_graph__defined */
+-
+-
+-#ifndef __NDR_convert__char_rep__Reply__rpc_jack_client_open_t__result__defined
+-#if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__result__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__result(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__result__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__result(a, f) \
+-	__NDR_convert__char_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__result__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__result(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int32_t__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__result__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__result(a, f) \
+-	__NDR_convert__char_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__char_rep__Reply__rpc_jack_client_open_t__result__defined */
+-
+-
+-#ifndef __NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_engine__defined
+-#if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_engine__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_engine(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_engine__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_engine(a, f) \
+-	__NDR_convert__float_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_engine__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_engine(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int32_t__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_engine__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_engine(a, f) \
+-	__NDR_convert__float_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_engine__defined */
+-
+-
+-#ifndef __NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_client__defined
+-#if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_client__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_client(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_client__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_client(a, f) \
+-	__NDR_convert__float_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_client__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_client(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int32_t__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_client__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_client(a, f) \
+-	__NDR_convert__float_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_client__defined */
+-
+-
+-#ifndef __NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_graph__defined
+-#if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_graph__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_graph(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_graph__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_graph(a, f) \
+-	__NDR_convert__float_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_graph__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_graph(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int32_t__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_graph__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_graph(a, f) \
+-	__NDR_convert__float_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_graph__defined */
+-
+-
+-#ifndef __NDR_convert__float_rep__Reply__rpc_jack_client_open_t__result__defined
+-#if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__result__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__result(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__result__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__result(a, f) \
+-	__NDR_convert__float_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__result__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__result(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int32_t__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__result__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__result(a, f) \
+-	__NDR_convert__float_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__float_rep__Reply__rpc_jack_client_open_t__result__defined */
+-
+-
+-
+-mig_internal kern_return_t __MIG_check__Reply__rpc_jack_client_open_t(__Reply__rpc_jack_client_open_t *Out0P)
+-{
+-
+-	typedef __Reply__rpc_jack_client_open_t __Reply;
+-	boolean_t msgh_simple;
+-#if	__MigTypeCheck
+-	unsigned int msgh_size;
+-#endif	/* __MigTypeCheck */
+-	if (Out0P->Head.msgh_id != 1100) {
+-	    if (Out0P->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
+-		{ return MIG_SERVER_DIED; }
+-	    else
+-		{ return MIG_REPLY_MISMATCH; }
+-	}
+-
+-	msgh_simple = !(Out0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX);
+-#if	__MigTypeCheck
+-	msgh_size = Out0P->Head.msgh_size;
+-
+-	if ((msgh_simple || Out0P->msgh_body.msgh_descriptor_count != 1 ||
+-	    msgh_size != (mach_msg_size_t)sizeof(__Reply)) &&
+-	    (!msgh_simple || msgh_size != (mach_msg_size_t)sizeof(mig_reply_error_t) ||
+-	    ((mig_reply_error_t *)Out0P)->RetCode == KERN_SUCCESS))
+-		{ return MIG_TYPE_ERROR ; }
+-#endif	/* __MigTypeCheck */
+-
+-	if (msgh_simple) {
+-#ifdef	__NDR_convert__mig_reply_error_t__defined
+-		__NDR_convert__mig_reply_error_t((mig_reply_error_t *)Out0P);
+-#endif	/* __NDR_convert__mig_reply_error_t__defined */
+-		return ((mig_reply_error_t *)Out0P)->RetCode;
+-	}
+-
+-#if	__MigTypeCheck
+-	if (Out0P->private_port.type != MACH_MSG_PORT_DESCRIPTOR ||
+-	    Out0P->private_port.disposition != 17) {
+-		return MIG_TYPE_ERROR;
+-	}
+-#endif	/* __MigTypeCheck */
+-
+-#if	defined(__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_engine__defined) || \
+-	defined(__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_client__defined) || \
+-	defined(__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_graph__defined) || \
+-	defined(__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__result__defined)
+-	if (Out0P->NDR.int_rep != NDR_record.int_rep) {
+-#if defined(__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_engine__defined)
+-		__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_engine(&Out0P->shared_engine, Out0P->NDR.int_rep);
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_engine__defined */
+-#if defined(__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_client__defined)
+-		__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_client(&Out0P->shared_client, Out0P->NDR.int_rep);
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_client__defined */
+-#if defined(__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_graph__defined)
+-		__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_graph(&Out0P->shared_graph, Out0P->NDR.int_rep);
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_graph__defined */
+-#if defined(__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__result__defined)
+-		__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__result(&Out0P->result, Out0P->NDR.int_rep);
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_open_t__result__defined */
+-	}
+-#endif	/* defined(__NDR_convert__int_rep...) */
+-
+-#if	defined(__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_engine__defined) || \
+-	defined(__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_client__defined) || \
+-	defined(__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_graph__defined) || \
+-	defined(__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__result__defined)
+-	if (Out0P->NDR.char_rep != NDR_record.char_rep) {
+-#if defined(__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_engine__defined)
+-		__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_engine(&Out0P->shared_engine, Out0P->NDR.char_rep);
+-#endif /* __NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_engine__defined */
+-#if defined(__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_client__defined)
+-		__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_client(&Out0P->shared_client, Out0P->NDR.char_rep);
+-#endif /* __NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_client__defined */
+-#if defined(__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_graph__defined)
+-		__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_graph(&Out0P->shared_graph, Out0P->NDR.char_rep);
+-#endif /* __NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_graph__defined */
+-#if defined(__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__result__defined)
+-		__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__result(&Out0P->result, Out0P->NDR.char_rep);
+-#endif /* __NDR_convert__char_rep__Reply__rpc_jack_client_open_t__result__defined */
+-	}
+-#endif	/* defined(__NDR_convert__char_rep...) */
+-
+-#if	defined(__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_engine__defined) || \
+-	defined(__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_client__defined) || \
+-	defined(__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_graph__defined) || \
+-	defined(__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__result__defined)
+-	if (Out0P->NDR.float_rep != NDR_record.float_rep) {
+-#if defined(__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_engine__defined)
+-		__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_engine(&Out0P->shared_engine, Out0P->NDR.float_rep);
+-#endif /* __NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_engine__defined */
+-#if defined(__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_client__defined)
+-		__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_client(&Out0P->shared_client, Out0P->NDR.float_rep);
+-#endif /* __NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_client__defined */
+-#if defined(__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_graph__defined)
+-		__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_graph(&Out0P->shared_graph, Out0P->NDR.float_rep);
+-#endif /* __NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_graph__defined */
+-#if defined(__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__result__defined)
+-		__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__result(&Out0P->result, Out0P->NDR.float_rep);
+-#endif /* __NDR_convert__float_rep__Reply__rpc_jack_client_open_t__result__defined */
+-	}
+-#endif	/* defined(__NDR_convert__float_rep...) */
+-
+-	return MACH_MSG_SUCCESS;
+-}
+-#endif /* !defined(__MIG_check__Reply__rpc_jack_client_open_t__defined) */
+-#endif /* __MIG_check__Reply__JackRPCEngine_subsystem__ */
+-#endif /* ( __MigTypeCheck || __NDR_convert__ ) */
+-
+-
+-/* Routine rpc_jack_client_open */
+-mig_external kern_return_t rpc_jack_client_open
+-(
+-	mach_port_t server_port,
+-	client_name_t client_name,
+-	int pid,
+-	mach_port_t *private_port,
+-	int *shared_engine,
+-	int *shared_client,
+-	int *shared_graph,
+-	int *result
+-)
+-{
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		client_name_t client_name;
+-		int pid;
+-	} Request;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		/* start of the kernel processed data */
+-		mach_msg_body_t msgh_body;
+-		mach_msg_port_descriptor_t private_port;
+-		/* end of the kernel processed data */
+-		NDR_record_t NDR;
+-		int shared_engine;
+-		int shared_client;
+-		int shared_graph;
+-		int result;
+-		mach_msg_trailer_t trailer;
+-	} Reply;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		/* start of the kernel processed data */
+-		mach_msg_body_t msgh_body;
+-		mach_msg_port_descriptor_t private_port;
+-		/* end of the kernel processed data */
+-		NDR_record_t NDR;
+-		int shared_engine;
+-		int shared_client;
+-		int shared_graph;
+-		int result;
+-	} __Reply;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-	/*
+-	 * typedef struct {
+-	 * 	mach_msg_header_t Head;
+-	 * 	NDR_record_t NDR;
+-	 * 	kern_return_t RetCode;
+-	 * } mig_reply_error_t;
+-	 */
+-
+-	union {
+-		Request In;
+-		Reply Out;
+-	} Mess;
+-
+-	Request *InP = &Mess.In;
+-	Reply *Out0P = &Mess.Out;
+-
+-	mach_msg_return_t msg_result;
+-
+-#ifdef	__MIG_check__Reply__rpc_jack_client_open_t__defined
+-	kern_return_t check_result;
+-#endif	/* __MIG_check__Reply__rpc_jack_client_open_t__defined */
+-
+-	__DeclareSendRpc(1000, "rpc_jack_client_open")
+-
+-	InP->NDR = NDR_record;
+-
+-	(void) mig_strncpy(InP->client_name, client_name, 64);
+-
+-	InP->pid = pid;
+-
+-	InP->Head.msgh_bits =
+-		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
+-	/* msgh_size passed as argument */
+-	InP->Head.msgh_request_port = server_port;
+-	InP->Head.msgh_reply_port = mig_get_reply_port();
+-	InP->Head.msgh_id = 1000;
+-
+-	__BeforeSendRpc(1000, "rpc_jack_client_open")
+-	msg_result = mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, (mach_msg_size_t)sizeof(Request), (mach_msg_size_t)sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
+-	__AfterSendRpc(1000, "rpc_jack_client_open")
+-	if (msg_result != MACH_MSG_SUCCESS) {
+-		__MachMsgErrorWithoutTimeout(msg_result);
+-		{ return msg_result; }
+-	}
+-
+-
+-#if	defined(__MIG_check__Reply__rpc_jack_client_open_t__defined)
+-	check_result = __MIG_check__Reply__rpc_jack_client_open_t((__Reply__rpc_jack_client_open_t *)Out0P);
+-	if (check_result != MACH_MSG_SUCCESS)
+-		{ return check_result; }
+-#endif	/* defined(__MIG_check__Reply__rpc_jack_client_open_t__defined) */
+-
+-	*private_port = Out0P->private_port.name;
+-	*shared_engine = Out0P->shared_engine;
+-
+-	*shared_client = Out0P->shared_client;
+-
+-	*shared_graph = Out0P->shared_graph;
+-
+-	*result = Out0P->result;
+-
+-	return KERN_SUCCESS;
+-}
+-
+-#if ( __MigTypeCheck || __NDR_convert__ )
+-#if __MIG_check__Reply__JackRPCEngine_subsystem__
+-#if !defined(__MIG_check__Reply__rpc_jack_client_check_t__defined)
+-#define __MIG_check__Reply__rpc_jack_client_check_t__defined
+-#ifndef __NDR_convert__int_rep__Reply__rpc_jack_client_check_t__RetCode__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCEngine__kern_return_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__RetCode__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__RetCode(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__kern_return_t((kern_return_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__kern_return_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__RetCode__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__RetCode(a, f) \
+-	__NDR_convert__int_rep__kern_return_t((kern_return_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_check_t__RetCode__defined */
+-
+-
+-#ifndef __NDR_convert__int_rep__Reply__rpc_jack_client_check_t__client_name_res__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCEngine__client_name_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__client_name_res__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__client_name_res(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__client_name_t((client_name_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__client_name_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__client_name_res__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__client_name_res(a, f) \
+-	__NDR_convert__int_rep__client_name_t((client_name_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__JackRPCEngine__string__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__client_name_res__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__client_name_res(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__string(a, f, 64)
+-#elif	defined(__NDR_convert__int_rep__string__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__client_name_res__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__client_name_res(a, f) \
+-	__NDR_convert__int_rep__string(a, f, 64)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_check_t__client_name_res__defined */
+-
+-
+-#ifndef __NDR_convert__int_rep__Reply__rpc_jack_client_check_t__status__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__status__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__status(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__status__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__status(a, f) \
+-	__NDR_convert__int_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__status__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__status(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int32_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__status__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__status(a, f) \
+-	__NDR_convert__int_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_check_t__status__defined */
+-
+-
+-#ifndef __NDR_convert__int_rep__Reply__rpc_jack_client_check_t__result__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__result__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__result(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__result__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__result(a, f) \
+-	__NDR_convert__int_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__result__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__result(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int32_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__result__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__result(a, f) \
+-	__NDR_convert__int_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_check_t__result__defined */
+-
+-
+-
+-#ifndef __NDR_convert__char_rep__Reply__rpc_jack_client_check_t__client_name_res__defined
+-#if	defined(__NDR_convert__char_rep__JackRPCEngine__client_name_t__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__client_name_res__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__client_name_res(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__client_name_t((client_name_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__client_name_t__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__client_name_res__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__client_name_res(a, f) \
+-	__NDR_convert__char_rep__client_name_t((client_name_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__JackRPCEngine__string__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__client_name_res__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__client_name_res(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__string(a, f, 64)
+-#elif	defined(__NDR_convert__char_rep__string__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__client_name_res__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__client_name_res(a, f) \
+-	__NDR_convert__char_rep__string(a, f, 64)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__char_rep__Reply__rpc_jack_client_check_t__client_name_res__defined */
+-
+-
+-#ifndef __NDR_convert__char_rep__Reply__rpc_jack_client_check_t__status__defined
+-#if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__status__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__status(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__status__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__status(a, f) \
+-	__NDR_convert__char_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__status__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__status(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int32_t__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__status__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__status(a, f) \
+-	__NDR_convert__char_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__char_rep__Reply__rpc_jack_client_check_t__status__defined */
+-
+-
+-#ifndef __NDR_convert__char_rep__Reply__rpc_jack_client_check_t__result__defined
+-#if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__result__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__result(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__result__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__result(a, f) \
+-	__NDR_convert__char_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__result__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__result(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int32_t__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__result__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__result(a, f) \
+-	__NDR_convert__char_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__char_rep__Reply__rpc_jack_client_check_t__result__defined */
+-
+-
+-
+-#ifndef __NDR_convert__float_rep__Reply__rpc_jack_client_check_t__client_name_res__defined
+-#if	defined(__NDR_convert__float_rep__JackRPCEngine__client_name_t__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__client_name_res__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__client_name_res(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__client_name_t((client_name_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__client_name_t__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__client_name_res__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__client_name_res(a, f) \
+-	__NDR_convert__float_rep__client_name_t((client_name_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__JackRPCEngine__string__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__client_name_res__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__client_name_res(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__string(a, f, 64)
+-#elif	defined(__NDR_convert__float_rep__string__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__client_name_res__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__client_name_res(a, f) \
+-	__NDR_convert__float_rep__string(a, f, 64)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__float_rep__Reply__rpc_jack_client_check_t__client_name_res__defined */
+-
+-
+-#ifndef __NDR_convert__float_rep__Reply__rpc_jack_client_check_t__status__defined
+-#if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__status__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__status(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__status__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__status(a, f) \
+-	__NDR_convert__float_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__status__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__status(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int32_t__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__status__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__status(a, f) \
+-	__NDR_convert__float_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__float_rep__Reply__rpc_jack_client_check_t__status__defined */
+-
+-
+-#ifndef __NDR_convert__float_rep__Reply__rpc_jack_client_check_t__result__defined
+-#if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__result__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__result(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__result__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__result(a, f) \
+-	__NDR_convert__float_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__result__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__result(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int32_t__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__result__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__result(a, f) \
+-	__NDR_convert__float_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__float_rep__Reply__rpc_jack_client_check_t__result__defined */
+-
+-
+-
+-mig_internal kern_return_t __MIG_check__Reply__rpc_jack_client_check_t(__Reply__rpc_jack_client_check_t *Out0P)
+-{
+-
+-	typedef __Reply__rpc_jack_client_check_t __Reply;
+-#if	__MigTypeCheck
+-	unsigned int msgh_size;
+-#endif	/* __MigTypeCheck */
+-	if (Out0P->Head.msgh_id != 1101) {
+-	    if (Out0P->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
+-		{ return MIG_SERVER_DIED; }
+-	    else
+-		{ return MIG_REPLY_MISMATCH; }
+-	}
+-
+-#if	__MigTypeCheck
+-	msgh_size = Out0P->Head.msgh_size;
+-
+-	if ((Out0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
+-	    ((msgh_size != (mach_msg_size_t)sizeof(__Reply)) &&
+-	     (msgh_size != (mach_msg_size_t)sizeof(mig_reply_error_t) ||
+-	      Out0P->RetCode == KERN_SUCCESS)))
+-		{ return MIG_TYPE_ERROR ; }
+-#endif	/* __MigTypeCheck */
+-
+-	if (Out0P->RetCode != KERN_SUCCESS) {
+-#ifdef	__NDR_convert__mig_reply_error_t__defined
+-		__NDR_convert__mig_reply_error_t((mig_reply_error_t *)Out0P);
+-#endif	/* __NDR_convert__mig_reply_error_t__defined */
+-		return ((mig_reply_error_t *)Out0P)->RetCode;
+-	}
+-
+-#if	defined(__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__RetCode__defined) || \
+-	defined(__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__client_name_res__defined) || \
+-	defined(__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__status__defined) || \
+-	defined(__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__result__defined)
+-	if (Out0P->NDR.int_rep != NDR_record.int_rep) {
+-#if defined(__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__RetCode__defined)
+-		__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__RetCode(&Out0P->RetCode, Out0P->NDR.int_rep);
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_check_t__RetCode__defined */
+-#if defined(__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__client_name_res__defined)
+-		__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__client_name_res(&Out0P->client_name_res, Out0P->NDR.int_rep);
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_check_t__client_name_res__defined */
+-#if defined(__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__status__defined)
+-		__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__status(&Out0P->status, Out0P->NDR.int_rep);
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_check_t__status__defined */
+-#if defined(__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__result__defined)
+-		__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__result(&Out0P->result, Out0P->NDR.int_rep);
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_check_t__result__defined */
+-	}
+-#endif	/* defined(__NDR_convert__int_rep...) */
+-
+-#if	0 || \
+-	defined(__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__client_name_res__defined) || \
+-	defined(__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__status__defined) || \
+-	defined(__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__result__defined)
+-	if (Out0P->NDR.char_rep != NDR_record.char_rep) {
+-#if defined(__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__client_name_res__defined)
+-		__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__client_name_res(&Out0P->client_name_res, Out0P->NDR.char_rep);
+-#endif /* __NDR_convert__char_rep__Reply__rpc_jack_client_check_t__client_name_res__defined */
+-#if defined(__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__status__defined)
+-		__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__status(&Out0P->status, Out0P->NDR.char_rep);
+-#endif /* __NDR_convert__char_rep__Reply__rpc_jack_client_check_t__status__defined */
+-#if defined(__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__result__defined)
+-		__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__result(&Out0P->result, Out0P->NDR.char_rep);
+-#endif /* __NDR_convert__char_rep__Reply__rpc_jack_client_check_t__result__defined */
+-	}
+-#endif	/* defined(__NDR_convert__char_rep...) */
+-
+-#if	0 || \
+-	defined(__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__client_name_res__defined) || \
+-	defined(__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__status__defined) || \
+-	defined(__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__result__defined)
+-	if (Out0P->NDR.float_rep != NDR_record.float_rep) {
+-#if defined(__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__client_name_res__defined)
+-		__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__client_name_res(&Out0P->client_name_res, Out0P->NDR.float_rep);
+-#endif /* __NDR_convert__float_rep__Reply__rpc_jack_client_check_t__client_name_res__defined */
+-#if defined(__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__status__defined)
+-		__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__status(&Out0P->status, Out0P->NDR.float_rep);
+-#endif /* __NDR_convert__float_rep__Reply__rpc_jack_client_check_t__status__defined */
+-#if defined(__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__result__defined)
+-		__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__result(&Out0P->result, Out0P->NDR.float_rep);
+-#endif /* __NDR_convert__float_rep__Reply__rpc_jack_client_check_t__result__defined */
+-	}
+-#endif	/* defined(__NDR_convert__float_rep...) */
+-
+-	return MACH_MSG_SUCCESS;
+-}
+-#endif /* !defined(__MIG_check__Reply__rpc_jack_client_check_t__defined) */
+-#endif /* __MIG_check__Reply__JackRPCEngine_subsystem__ */
+-#endif /* ( __MigTypeCheck || __NDR_convert__ ) */
+-
+-
+-/* Routine rpc_jack_client_check */
+-mig_external kern_return_t rpc_jack_client_check
+-(
+-	mach_port_t server_port,
+-	client_name_t client_name,
+-	client_name_t client_name_res,
+-	int protocol,
+-	int options,
+-	int *status,
+-	int *result
+-)
+-{
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		client_name_t client_name;
+-		int protocol;
+-		int options;
+-	} Request;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		kern_return_t RetCode;
+-		client_name_t client_name_res;
+-		int status;
+-		int result;
+-		mach_msg_trailer_t trailer;
+-	} Reply;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		kern_return_t RetCode;
+-		client_name_t client_name_res;
+-		int status;
+-		int result;
+-	} __Reply;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-	/*
+-	 * typedef struct {
+-	 * 	mach_msg_header_t Head;
+-	 * 	NDR_record_t NDR;
+-	 * 	kern_return_t RetCode;
+-	 * } mig_reply_error_t;
+-	 */
+-
+-	union {
+-		Request In;
+-		Reply Out;
+-	} Mess;
+-
+-	Request *InP = &Mess.In;
+-	Reply *Out0P = &Mess.Out;
+-
+-	mach_msg_return_t msg_result;
+-
+-#ifdef	__MIG_check__Reply__rpc_jack_client_check_t__defined
+-	kern_return_t check_result;
+-#endif	/* __MIG_check__Reply__rpc_jack_client_check_t__defined */
+-
+-	__DeclareSendRpc(1001, "rpc_jack_client_check")
+-
+-	InP->NDR = NDR_record;
+-
+-	(void) mig_strncpy(InP->client_name, client_name, 64);
+-
+-	InP->protocol = protocol;
+-
+-	InP->options = options;
+-
+-	InP->Head.msgh_bits =
+-		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
+-	/* msgh_size passed as argument */
+-	InP->Head.msgh_request_port = server_port;
+-	InP->Head.msgh_reply_port = mig_get_reply_port();
+-	InP->Head.msgh_id = 1001;
+-
+-	__BeforeSendRpc(1001, "rpc_jack_client_check")
+-	msg_result = mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, (mach_msg_size_t)sizeof(Request), (mach_msg_size_t)sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
+-	__AfterSendRpc(1001, "rpc_jack_client_check")
+-	if (msg_result != MACH_MSG_SUCCESS) {
+-		__MachMsgErrorWithoutTimeout(msg_result);
+-		{ return msg_result; }
+-	}
+-
+-
+-#if	defined(__MIG_check__Reply__rpc_jack_client_check_t__defined)
+-	check_result = __MIG_check__Reply__rpc_jack_client_check_t((__Reply__rpc_jack_client_check_t *)Out0P);
+-	if (check_result != MACH_MSG_SUCCESS)
+-		{ return check_result; }
+-#endif	/* defined(__MIG_check__Reply__rpc_jack_client_check_t__defined) */
+-
+-	(void) mig_strncpy(client_name_res, Out0P->client_name_res, 64);
+-
+-	*status = Out0P->status;
+-
+-	*result = Out0P->result;
+-
+-	return KERN_SUCCESS;
+-}
+-
+-#if ( __MigTypeCheck || __NDR_convert__ )
+-#if __MIG_check__Reply__JackRPCEngine_subsystem__
+-#if !defined(__MIG_check__Reply__rpc_jack_client_close_t__defined)
+-#define __MIG_check__Reply__rpc_jack_client_close_t__defined
+-#ifndef __NDR_convert__int_rep__Reply__rpc_jack_client_close_t__RetCode__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCEngine__kern_return_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_close_t__RetCode__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_close_t__RetCode(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__kern_return_t((kern_return_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__kern_return_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_close_t__RetCode__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_close_t__RetCode(a, f) \
+-	__NDR_convert__int_rep__kern_return_t((kern_return_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_close_t__RetCode__defined */
+-
+-
+-#ifndef __NDR_convert__int_rep__Reply__rpc_jack_client_close_t__result__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_close_t__result__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_close_t__result(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_close_t__result__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_close_t__result(a, f) \
+-	__NDR_convert__int_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_close_t__result__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_close_t__result(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int32_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_close_t__result__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_close_t__result(a, f) \
+-	__NDR_convert__int_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_close_t__result__defined */
+-
+-
+-
+-#ifndef __NDR_convert__char_rep__Reply__rpc_jack_client_close_t__result__defined
+-#if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_close_t__result__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_close_t__result(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_close_t__result__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_close_t__result(a, f) \
+-	__NDR_convert__char_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_close_t__result__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_close_t__result(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int32_t__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_close_t__result__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_close_t__result(a, f) \
+-	__NDR_convert__char_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__char_rep__Reply__rpc_jack_client_close_t__result__defined */
+-
+-
+-
+-#ifndef __NDR_convert__float_rep__Reply__rpc_jack_client_close_t__result__defined
+-#if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_close_t__result__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_close_t__result(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_close_t__result__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_close_t__result(a, f) \
+-	__NDR_convert__float_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_close_t__result__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_close_t__result(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int32_t__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_close_t__result__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_close_t__result(a, f) \
+-	__NDR_convert__float_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__float_rep__Reply__rpc_jack_client_close_t__result__defined */
+-
+-
+-
+-mig_internal kern_return_t __MIG_check__Reply__rpc_jack_client_close_t(__Reply__rpc_jack_client_close_t *Out0P)
+-{
+-
+-	typedef __Reply__rpc_jack_client_close_t __Reply;
+-#if	__MigTypeCheck
+-	unsigned int msgh_size;
+-#endif	/* __MigTypeCheck */
+-	if (Out0P->Head.msgh_id != 1102) {
+-	    if (Out0P->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
+-		{ return MIG_SERVER_DIED; }
+-	    else
+-		{ return MIG_REPLY_MISMATCH; }
+-	}
+-
+-#if	__MigTypeCheck
+-	msgh_size = Out0P->Head.msgh_size;
+-
+-	if ((Out0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
+-	    ((msgh_size != (mach_msg_size_t)sizeof(__Reply)) &&
+-	     (msgh_size != (mach_msg_size_t)sizeof(mig_reply_error_t) ||
+-	      Out0P->RetCode == KERN_SUCCESS)))
+-		{ return MIG_TYPE_ERROR ; }
+-#endif	/* __MigTypeCheck */
+-
+-	if (Out0P->RetCode != KERN_SUCCESS) {
+-#ifdef	__NDR_convert__mig_reply_error_t__defined
+-		__NDR_convert__mig_reply_error_t((mig_reply_error_t *)Out0P);
+-#endif	/* __NDR_convert__mig_reply_error_t__defined */
+-		return ((mig_reply_error_t *)Out0P)->RetCode;
+-	}
+-
+-#if	defined(__NDR_convert__int_rep__Reply__rpc_jack_client_close_t__RetCode__defined) || \
+-	defined(__NDR_convert__int_rep__Reply__rpc_jack_client_close_t__result__defined)
+-	if (Out0P->NDR.int_rep != NDR_record.int_rep) {
+-#if defined(__NDR_convert__int_rep__Reply__rpc_jack_client_close_t__RetCode__defined)
+-		__NDR_convert__int_rep__Reply__rpc_jack_client_close_t__RetCode(&Out0P->RetCode, Out0P->NDR.int_rep);
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_close_t__RetCode__defined */
+-#if defined(__NDR_convert__int_rep__Reply__rpc_jack_client_close_t__result__defined)
+-		__NDR_convert__int_rep__Reply__rpc_jack_client_close_t__result(&Out0P->result, Out0P->NDR.int_rep);
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_close_t__result__defined */
+-	}
+-#endif	/* defined(__NDR_convert__int_rep...) */
+-
+-#if	0 || \
+-	defined(__NDR_convert__char_rep__Reply__rpc_jack_client_close_t__result__defined)
+-	if (Out0P->NDR.char_rep != NDR_record.char_rep) {
+-#if defined(__NDR_convert__char_rep__Reply__rpc_jack_client_close_t__result__defined)
+-		__NDR_convert__char_rep__Reply__rpc_jack_client_close_t__result(&Out0P->result, Out0P->NDR.char_rep);
+-#endif /* __NDR_convert__char_rep__Reply__rpc_jack_client_close_t__result__defined */
+-	}
+-#endif	/* defined(__NDR_convert__char_rep...) */
+-
+-#if	0 || \
+-	defined(__NDR_convert__float_rep__Reply__rpc_jack_client_close_t__result__defined)
+-	if (Out0P->NDR.float_rep != NDR_record.float_rep) {
+-#if defined(__NDR_convert__float_rep__Reply__rpc_jack_client_close_t__result__defined)
+-		__NDR_convert__float_rep__Reply__rpc_jack_client_close_t__result(&Out0P->result, Out0P->NDR.float_rep);
+-#endif /* __NDR_convert__float_rep__Reply__rpc_jack_client_close_t__result__defined */
+-	}
+-#endif	/* defined(__NDR_convert__float_rep...) */
+-
+-	return MACH_MSG_SUCCESS;
+-}
+-#endif /* !defined(__MIG_check__Reply__rpc_jack_client_close_t__defined) */
+-#endif /* __MIG_check__Reply__JackRPCEngine_subsystem__ */
+-#endif /* ( __MigTypeCheck || __NDR_convert__ ) */
+-
+-
+-/* Routine rpc_jack_client_close */
+-mig_external kern_return_t rpc_jack_client_close
+-(
+-	mach_port_t server_port,
+-	int refnum,
+-	int *result
+-)
+-{
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		int refnum;
+-	} Request;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		kern_return_t RetCode;
+-		int result;
+-		mach_msg_trailer_t trailer;
+-	} Reply;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		kern_return_t RetCode;
+-		int result;
+-	} __Reply;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-	/*
+-	 * typedef struct {
+-	 * 	mach_msg_header_t Head;
+-	 * 	NDR_record_t NDR;
+-	 * 	kern_return_t RetCode;
+-	 * } mig_reply_error_t;
+-	 */
+-
+-	union {
+-		Request In;
+-		Reply Out;
+-	} Mess;
+-
+-	Request *InP = &Mess.In;
+-	Reply *Out0P = &Mess.Out;
+-
+-	mach_msg_return_t msg_result;
+-
+-#ifdef	__MIG_check__Reply__rpc_jack_client_close_t__defined
+-	kern_return_t check_result;
+-#endif	/* __MIG_check__Reply__rpc_jack_client_close_t__defined */
+-
+-	__DeclareSendRpc(1002, "rpc_jack_client_close")
+-
+-	InP->NDR = NDR_record;
+-
+-	InP->refnum = refnum;
+-
+-	InP->Head.msgh_bits =
+-		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
+-	/* msgh_size passed as argument */
+-	InP->Head.msgh_request_port = server_port;
+-	InP->Head.msgh_reply_port = mig_get_reply_port();
+-	InP->Head.msgh_id = 1002;
+-
+-	__BeforeSendRpc(1002, "rpc_jack_client_close")
+-	msg_result = mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, (mach_msg_size_t)sizeof(Request), (mach_msg_size_t)sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
+-	__AfterSendRpc(1002, "rpc_jack_client_close")
+-	if (msg_result != MACH_MSG_SUCCESS) {
+-		__MachMsgErrorWithoutTimeout(msg_result);
+-		{ return msg_result; }
+-	}
+-
+-
+-#if	defined(__MIG_check__Reply__rpc_jack_client_close_t__defined)
+-	check_result = __MIG_check__Reply__rpc_jack_client_close_t((__Reply__rpc_jack_client_close_t *)Out0P);
+-	if (check_result != MACH_MSG_SUCCESS)
+-		{ return check_result; }
+-#endif	/* defined(__MIG_check__Reply__rpc_jack_client_close_t__defined) */
+-
+-	*result = Out0P->result;
+-
+-	return KERN_SUCCESS;
+-}
+-
+-#if ( __MigTypeCheck || __NDR_convert__ )
+-#if __MIG_check__Reply__JackRPCEngine_subsystem__
+-#if !defined(__MIG_check__Reply__rpc_jack_client_activate_t__defined)
+-#define __MIG_check__Reply__rpc_jack_client_activate_t__defined
+-#ifndef __NDR_convert__int_rep__Reply__rpc_jack_client_activate_t__RetCode__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCEngine__kern_return_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_activate_t__RetCode__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_activate_t__RetCode(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__kern_return_t((kern_return_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__kern_return_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_activate_t__RetCode__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_activate_t__RetCode(a, f) \
+-	__NDR_convert__int_rep__kern_return_t((kern_return_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_activate_t__RetCode__defined */
+-
+-
+-#ifndef __NDR_convert__int_rep__Reply__rpc_jack_client_activate_t__result__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_activate_t__result__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_activate_t__result(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_activate_t__result__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_activate_t__result(a, f) \
+-	__NDR_convert__int_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_activate_t__result__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_activate_t__result(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int32_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_activate_t__result__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_activate_t__result(a, f) \
+-	__NDR_convert__int_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_activate_t__result__defined */
+-
+-
+-
+-#ifndef __NDR_convert__char_rep__Reply__rpc_jack_client_activate_t__result__defined
+-#if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_activate_t__result__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_activate_t__result(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_activate_t__result__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_activate_t__result(a, f) \
+-	__NDR_convert__char_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_activate_t__result__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_activate_t__result(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int32_t__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_activate_t__result__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_activate_t__result(a, f) \
+-	__NDR_convert__char_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__char_rep__Reply__rpc_jack_client_activate_t__result__defined */
+-
+-
+-
+-#ifndef __NDR_convert__float_rep__Reply__rpc_jack_client_activate_t__result__defined
+-#if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_activate_t__result__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_activate_t__result(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_activate_t__result__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_activate_t__result(a, f) \
+-	__NDR_convert__float_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_activate_t__result__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_activate_t__result(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int32_t__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_activate_t__result__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_activate_t__result(a, f) \
+-	__NDR_convert__float_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__float_rep__Reply__rpc_jack_client_activate_t__result__defined */
+-
+-
+-
+-mig_internal kern_return_t __MIG_check__Reply__rpc_jack_client_activate_t(__Reply__rpc_jack_client_activate_t *Out0P)
+-{
+-
+-	typedef __Reply__rpc_jack_client_activate_t __Reply;
+-#if	__MigTypeCheck
+-	unsigned int msgh_size;
+-#endif	/* __MigTypeCheck */
+-	if (Out0P->Head.msgh_id != 1103) {
+-	    if (Out0P->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
+-		{ return MIG_SERVER_DIED; }
+-	    else
+-		{ return MIG_REPLY_MISMATCH; }
+-	}
+-
+-#if	__MigTypeCheck
+-	msgh_size = Out0P->Head.msgh_size;
+-
+-	if ((Out0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
+-	    ((msgh_size != (mach_msg_size_t)sizeof(__Reply)) &&
+-	     (msgh_size != (mach_msg_size_t)sizeof(mig_reply_error_t) ||
+-	      Out0P->RetCode == KERN_SUCCESS)))
+-		{ return MIG_TYPE_ERROR ; }
+-#endif	/* __MigTypeCheck */
+-
+-	if (Out0P->RetCode != KERN_SUCCESS) {
+-#ifdef	__NDR_convert__mig_reply_error_t__defined
+-		__NDR_convert__mig_reply_error_t((mig_reply_error_t *)Out0P);
+-#endif	/* __NDR_convert__mig_reply_error_t__defined */
+-		return ((mig_reply_error_t *)Out0P)->RetCode;
+-	}
+-
+-#if	defined(__NDR_convert__int_rep__Reply__rpc_jack_client_activate_t__RetCode__defined) || \
+-	defined(__NDR_convert__int_rep__Reply__rpc_jack_client_activate_t__result__defined)
+-	if (Out0P->NDR.int_rep != NDR_record.int_rep) {
+-#if defined(__NDR_convert__int_rep__Reply__rpc_jack_client_activate_t__RetCode__defined)
+-		__NDR_convert__int_rep__Reply__rpc_jack_client_activate_t__RetCode(&Out0P->RetCode, Out0P->NDR.int_rep);
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_activate_t__RetCode__defined */
+-#if defined(__NDR_convert__int_rep__Reply__rpc_jack_client_activate_t__result__defined)
+-		__NDR_convert__int_rep__Reply__rpc_jack_client_activate_t__result(&Out0P->result, Out0P->NDR.int_rep);
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_activate_t__result__defined */
+-	}
+-#endif	/* defined(__NDR_convert__int_rep...) */
+-
+-#if	0 || \
+-	defined(__NDR_convert__char_rep__Reply__rpc_jack_client_activate_t__result__defined)
+-	if (Out0P->NDR.char_rep != NDR_record.char_rep) {
+-#if defined(__NDR_convert__char_rep__Reply__rpc_jack_client_activate_t__result__defined)
+-		__NDR_convert__char_rep__Reply__rpc_jack_client_activate_t__result(&Out0P->result, Out0P->NDR.char_rep);
+-#endif /* __NDR_convert__char_rep__Reply__rpc_jack_client_activate_t__result__defined */
+-	}
+-#endif	/* defined(__NDR_convert__char_rep...) */
+-
+-#if	0 || \
+-	defined(__NDR_convert__float_rep__Reply__rpc_jack_client_activate_t__result__defined)
+-	if (Out0P->NDR.float_rep != NDR_record.float_rep) {
+-#if defined(__NDR_convert__float_rep__Reply__rpc_jack_client_activate_t__result__defined)
+-		__NDR_convert__float_rep__Reply__rpc_jack_client_activate_t__result(&Out0P->result, Out0P->NDR.float_rep);
+-#endif /* __NDR_convert__float_rep__Reply__rpc_jack_client_activate_t__result__defined */
+-	}
+-#endif	/* defined(__NDR_convert__float_rep...) */
+-
+-	return MACH_MSG_SUCCESS;
+-}
+-#endif /* !defined(__MIG_check__Reply__rpc_jack_client_activate_t__defined) */
+-#endif /* __MIG_check__Reply__JackRPCEngine_subsystem__ */
+-#endif /* ( __MigTypeCheck || __NDR_convert__ ) */
+-
+-
+-/* Routine rpc_jack_client_activate */
+-mig_external kern_return_t rpc_jack_client_activate
+-(
+-	mach_port_t server_port,
+-	int refnum,
+-	int state,
+-	int *result
+-)
+-{
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		int refnum;
+-		int state;
+-	} Request;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		kern_return_t RetCode;
+-		int result;
+-		mach_msg_trailer_t trailer;
+-	} Reply;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		kern_return_t RetCode;
+-		int result;
+-	} __Reply;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-	/*
+-	 * typedef struct {
+-	 * 	mach_msg_header_t Head;
+-	 * 	NDR_record_t NDR;
+-	 * 	kern_return_t RetCode;
+-	 * } mig_reply_error_t;
+-	 */
+-
+-	union {
+-		Request In;
+-		Reply Out;
+-	} Mess;
+-
+-	Request *InP = &Mess.In;
+-	Reply *Out0P = &Mess.Out;
+-
+-	mach_msg_return_t msg_result;
+-
+-#ifdef	__MIG_check__Reply__rpc_jack_client_activate_t__defined
+-	kern_return_t check_result;
+-#endif	/* __MIG_check__Reply__rpc_jack_client_activate_t__defined */
+-
+-	__DeclareSendRpc(1003, "rpc_jack_client_activate")
+-
+-	InP->NDR = NDR_record;
+-
+-	InP->refnum = refnum;
+-
+-	InP->state = state;
+-
+-	InP->Head.msgh_bits =
+-		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
+-	/* msgh_size passed as argument */
+-	InP->Head.msgh_request_port = server_port;
+-	InP->Head.msgh_reply_port = mig_get_reply_port();
+-	InP->Head.msgh_id = 1003;
+-
+-	__BeforeSendRpc(1003, "rpc_jack_client_activate")
+-	msg_result = mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, (mach_msg_size_t)sizeof(Request), (mach_msg_size_t)sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
+-	__AfterSendRpc(1003, "rpc_jack_client_activate")
+-	if (msg_result != MACH_MSG_SUCCESS) {
+-		__MachMsgErrorWithoutTimeout(msg_result);
+-		{ return msg_result; }
+-	}
+-
+-
+-#if	defined(__MIG_check__Reply__rpc_jack_client_activate_t__defined)
+-	check_result = __MIG_check__Reply__rpc_jack_client_activate_t((__Reply__rpc_jack_client_activate_t *)Out0P);
+-	if (check_result != MACH_MSG_SUCCESS)
+-		{ return check_result; }
+-#endif	/* defined(__MIG_check__Reply__rpc_jack_client_activate_t__defined) */
+-
+-	*result = Out0P->result;
+-
+-	return KERN_SUCCESS;
+-}
+-
+-#if ( __MigTypeCheck || __NDR_convert__ )
+-#if __MIG_check__Reply__JackRPCEngine_subsystem__
+-#if !defined(__MIG_check__Reply__rpc_jack_client_deactivate_t__defined)
+-#define __MIG_check__Reply__rpc_jack_client_deactivate_t__defined
+-#ifndef __NDR_convert__int_rep__Reply__rpc_jack_client_deactivate_t__RetCode__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCEngine__kern_return_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_deactivate_t__RetCode__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_deactivate_t__RetCode(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__kern_return_t((kern_return_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__kern_return_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_deactivate_t__RetCode__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_deactivate_t__RetCode(a, f) \
+-	__NDR_convert__int_rep__kern_return_t((kern_return_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_deactivate_t__RetCode__defined */
+-
+-
+-#ifndef __NDR_convert__int_rep__Reply__rpc_jack_client_deactivate_t__result__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_deactivate_t__result__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_deactivate_t__result(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_deactivate_t__result__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_deactivate_t__result(a, f) \
+-	__NDR_convert__int_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_deactivate_t__result__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_deactivate_t__result(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int32_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_deactivate_t__result__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_client_deactivate_t__result(a, f) \
+-	__NDR_convert__int_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_deactivate_t__result__defined */
+-
+-
+-
+-#ifndef __NDR_convert__char_rep__Reply__rpc_jack_client_deactivate_t__result__defined
+-#if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_deactivate_t__result__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_deactivate_t__result(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_deactivate_t__result__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_deactivate_t__result(a, f) \
+-	__NDR_convert__char_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_deactivate_t__result__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_deactivate_t__result(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int32_t__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_deactivate_t__result__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_client_deactivate_t__result(a, f) \
+-	__NDR_convert__char_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__char_rep__Reply__rpc_jack_client_deactivate_t__result__defined */
+-
+-
+-
+-#ifndef __NDR_convert__float_rep__Reply__rpc_jack_client_deactivate_t__result__defined
+-#if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_deactivate_t__result__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_deactivate_t__result(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_deactivate_t__result__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_deactivate_t__result(a, f) \
+-	__NDR_convert__float_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_deactivate_t__result__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_deactivate_t__result(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int32_t__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_deactivate_t__result__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_client_deactivate_t__result(a, f) \
+-	__NDR_convert__float_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__float_rep__Reply__rpc_jack_client_deactivate_t__result__defined */
+-
+-
+-
+-mig_internal kern_return_t __MIG_check__Reply__rpc_jack_client_deactivate_t(__Reply__rpc_jack_client_deactivate_t *Out0P)
+-{
+-
+-	typedef __Reply__rpc_jack_client_deactivate_t __Reply;
+-#if	__MigTypeCheck
+-	unsigned int msgh_size;
+-#endif	/* __MigTypeCheck */
+-	if (Out0P->Head.msgh_id != 1104) {
+-	    if (Out0P->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
+-		{ return MIG_SERVER_DIED; }
+-	    else
+-		{ return MIG_REPLY_MISMATCH; }
+-	}
+-
+-#if	__MigTypeCheck
+-	msgh_size = Out0P->Head.msgh_size;
+-
+-	if ((Out0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
+-	    ((msgh_size != (mach_msg_size_t)sizeof(__Reply)) &&
+-	     (msgh_size != (mach_msg_size_t)sizeof(mig_reply_error_t) ||
+-	      Out0P->RetCode == KERN_SUCCESS)))
+-		{ return MIG_TYPE_ERROR ; }
+-#endif	/* __MigTypeCheck */
+-
+-	if (Out0P->RetCode != KERN_SUCCESS) {
+-#ifdef	__NDR_convert__mig_reply_error_t__defined
+-		__NDR_convert__mig_reply_error_t((mig_reply_error_t *)Out0P);
+-#endif	/* __NDR_convert__mig_reply_error_t__defined */
+-		return ((mig_reply_error_t *)Out0P)->RetCode;
+-	}
+-
+-#if	defined(__NDR_convert__int_rep__Reply__rpc_jack_client_deactivate_t__RetCode__defined) || \
+-	defined(__NDR_convert__int_rep__Reply__rpc_jack_client_deactivate_t__result__defined)
+-	if (Out0P->NDR.int_rep != NDR_record.int_rep) {
+-#if defined(__NDR_convert__int_rep__Reply__rpc_jack_client_deactivate_t__RetCode__defined)
+-		__NDR_convert__int_rep__Reply__rpc_jack_client_deactivate_t__RetCode(&Out0P->RetCode, Out0P->NDR.int_rep);
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_deactivate_t__RetCode__defined */
+-#if defined(__NDR_convert__int_rep__Reply__rpc_jack_client_deactivate_t__result__defined)
+-		__NDR_convert__int_rep__Reply__rpc_jack_client_deactivate_t__result(&Out0P->result, Out0P->NDR.int_rep);
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_deactivate_t__result__defined */
+-	}
+-#endif	/* defined(__NDR_convert__int_rep...) */
+-
+-#if	0 || \
+-	defined(__NDR_convert__char_rep__Reply__rpc_jack_client_deactivate_t__result__defined)
+-	if (Out0P->NDR.char_rep != NDR_record.char_rep) {
+-#if defined(__NDR_convert__char_rep__Reply__rpc_jack_client_deactivate_t__result__defined)
+-		__NDR_convert__char_rep__Reply__rpc_jack_client_deactivate_t__result(&Out0P->result, Out0P->NDR.char_rep);
+-#endif /* __NDR_convert__char_rep__Reply__rpc_jack_client_deactivate_t__result__defined */
+-	}
+-#endif	/* defined(__NDR_convert__char_rep...) */
+-
+-#if	0 || \
+-	defined(__NDR_convert__float_rep__Reply__rpc_jack_client_deactivate_t__result__defined)
+-	if (Out0P->NDR.float_rep != NDR_record.float_rep) {
+-#if defined(__NDR_convert__float_rep__Reply__rpc_jack_client_deactivate_t__result__defined)
+-		__NDR_convert__float_rep__Reply__rpc_jack_client_deactivate_t__result(&Out0P->result, Out0P->NDR.float_rep);
+-#endif /* __NDR_convert__float_rep__Reply__rpc_jack_client_deactivate_t__result__defined */
+-	}
+-#endif	/* defined(__NDR_convert__float_rep...) */
+-
+-	return MACH_MSG_SUCCESS;
+-}
+-#endif /* !defined(__MIG_check__Reply__rpc_jack_client_deactivate_t__defined) */
+-#endif /* __MIG_check__Reply__JackRPCEngine_subsystem__ */
+-#endif /* ( __MigTypeCheck || __NDR_convert__ ) */
+-
+-
+-/* Routine rpc_jack_client_deactivate */
+-mig_external kern_return_t rpc_jack_client_deactivate
+-(
+-	mach_port_t server_port,
+-	int refnum,
+-	int *result
+-)
+-{
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		int refnum;
+-	} Request;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		kern_return_t RetCode;
+-		int result;
+-		mach_msg_trailer_t trailer;
+-	} Reply;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		kern_return_t RetCode;
+-		int result;
+-	} __Reply;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-	/*
+-	 * typedef struct {
+-	 * 	mach_msg_header_t Head;
+-	 * 	NDR_record_t NDR;
+-	 * 	kern_return_t RetCode;
+-	 * } mig_reply_error_t;
+-	 */
+-
+-	union {
+-		Request In;
+-		Reply Out;
+-	} Mess;
+-
+-	Request *InP = &Mess.In;
+-	Reply *Out0P = &Mess.Out;
+-
+-	mach_msg_return_t msg_result;
+-
+-#ifdef	__MIG_check__Reply__rpc_jack_client_deactivate_t__defined
+-	kern_return_t check_result;
+-#endif	/* __MIG_check__Reply__rpc_jack_client_deactivate_t__defined */
+-
+-	__DeclareSendRpc(1004, "rpc_jack_client_deactivate")
+-
+-	InP->NDR = NDR_record;
+-
+-	InP->refnum = refnum;
+-
+-	InP->Head.msgh_bits =
+-		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
+-	/* msgh_size passed as argument */
+-	InP->Head.msgh_request_port = server_port;
+-	InP->Head.msgh_reply_port = mig_get_reply_port();
+-	InP->Head.msgh_id = 1004;
+-
+-	__BeforeSendRpc(1004, "rpc_jack_client_deactivate")
+-	msg_result = mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, (mach_msg_size_t)sizeof(Request), (mach_msg_size_t)sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
+-	__AfterSendRpc(1004, "rpc_jack_client_deactivate")
+-	if (msg_result != MACH_MSG_SUCCESS) {
+-		__MachMsgErrorWithoutTimeout(msg_result);
+-		{ return msg_result; }
+-	}
+-
+-
+-#if	defined(__MIG_check__Reply__rpc_jack_client_deactivate_t__defined)
+-	check_result = __MIG_check__Reply__rpc_jack_client_deactivate_t((__Reply__rpc_jack_client_deactivate_t *)Out0P);
+-	if (check_result != MACH_MSG_SUCCESS)
+-		{ return check_result; }
+-#endif	/* defined(__MIG_check__Reply__rpc_jack_client_deactivate_t__defined) */
+-
+-	*result = Out0P->result;
+-
+-	return KERN_SUCCESS;
+-}
+-
+-#if ( __MigTypeCheck || __NDR_convert__ )
+-#if __MIG_check__Reply__JackRPCEngine_subsystem__
+-#if !defined(__MIG_check__Reply__rpc_jack_port_register_t__defined)
+-#define __MIG_check__Reply__rpc_jack_port_register_t__defined
+-#ifndef __NDR_convert__int_rep__Reply__rpc_jack_port_register_t__RetCode__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCEngine__kern_return_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_port_register_t__RetCode__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_port_register_t__RetCode(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__kern_return_t((kern_return_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__kern_return_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_port_register_t__RetCode__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_port_register_t__RetCode(a, f) \
+-	__NDR_convert__int_rep__kern_return_t((kern_return_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_register_t__RetCode__defined */
+-
+-
+-#ifndef __NDR_convert__int_rep__Reply__rpc_jack_port_register_t__port_index__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCEngine__unsigned__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_port_register_t__port_index__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_port_register_t__port_index(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__unsigned((unsigned *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__unsigned__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_port_register_t__port_index__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_port_register_t__port_index(a, f) \
+-	__NDR_convert__int_rep__unsigned((unsigned *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__JackRPCEngine__uint32_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_port_register_t__port_index__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_port_register_t__port_index(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__uint32_t((uint32_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__uint32_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_port_register_t__port_index__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_port_register_t__port_index(a, f) \
+-	__NDR_convert__int_rep__uint32_t((uint32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_register_t__port_index__defined */
+-
+-
+-#ifndef __NDR_convert__int_rep__Reply__rpc_jack_port_register_t__result__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_port_register_t__result__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_port_register_t__result(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_port_register_t__result__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_port_register_t__result(a, f) \
+-	__NDR_convert__int_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_port_register_t__result__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_port_register_t__result(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int32_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_port_register_t__result__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_port_register_t__result(a, f) \
+-	__NDR_convert__int_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_register_t__result__defined */
+-
+-
+-
+-#ifndef __NDR_convert__char_rep__Reply__rpc_jack_port_register_t__port_index__defined
+-#if	defined(__NDR_convert__char_rep__JackRPCEngine__unsigned__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_port_register_t__port_index__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_port_register_t__port_index(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__unsigned((unsigned *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__unsigned__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_port_register_t__port_index__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_port_register_t__port_index(a, f) \
+-	__NDR_convert__char_rep__unsigned((unsigned *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__JackRPCEngine__uint32_t__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_port_register_t__port_index__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_port_register_t__port_index(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__uint32_t((uint32_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__uint32_t__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_port_register_t__port_index__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_port_register_t__port_index(a, f) \
+-	__NDR_convert__char_rep__uint32_t((uint32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__char_rep__Reply__rpc_jack_port_register_t__port_index__defined */
+-
+-
+-#ifndef __NDR_convert__char_rep__Reply__rpc_jack_port_register_t__result__defined
+-#if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_port_register_t__result__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_port_register_t__result(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_port_register_t__result__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_port_register_t__result(a, f) \
+-	__NDR_convert__char_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_port_register_t__result__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_port_register_t__result(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int32_t__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_port_register_t__result__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_port_register_t__result(a, f) \
+-	__NDR_convert__char_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__char_rep__Reply__rpc_jack_port_register_t__result__defined */
+-
+-
+-
+-#ifndef __NDR_convert__float_rep__Reply__rpc_jack_port_register_t__port_index__defined
+-#if	defined(__NDR_convert__float_rep__JackRPCEngine__unsigned__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_port_register_t__port_index__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_port_register_t__port_index(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__unsigned((unsigned *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__unsigned__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_port_register_t__port_index__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_port_register_t__port_index(a, f) \
+-	__NDR_convert__float_rep__unsigned((unsigned *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__JackRPCEngine__uint32_t__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_port_register_t__port_index__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_port_register_t__port_index(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__uint32_t((uint32_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__uint32_t__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_port_register_t__port_index__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_port_register_t__port_index(a, f) \
+-	__NDR_convert__float_rep__uint32_t((uint32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__float_rep__Reply__rpc_jack_port_register_t__port_index__defined */
+-
+-
+-#ifndef __NDR_convert__float_rep__Reply__rpc_jack_port_register_t__result__defined
+-#if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_port_register_t__result__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_port_register_t__result(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_port_register_t__result__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_port_register_t__result(a, f) \
+-	__NDR_convert__float_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_port_register_t__result__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_port_register_t__result(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int32_t__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_port_register_t__result__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_port_register_t__result(a, f) \
+-	__NDR_convert__float_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__float_rep__Reply__rpc_jack_port_register_t__result__defined */
+-
+-
+-
+-mig_internal kern_return_t __MIG_check__Reply__rpc_jack_port_register_t(__Reply__rpc_jack_port_register_t *Out0P)
+-{
+-
+-	typedef __Reply__rpc_jack_port_register_t __Reply;
+-#if	__MigTypeCheck
+-	unsigned int msgh_size;
+-#endif	/* __MigTypeCheck */
+-	if (Out0P->Head.msgh_id != 1105) {
+-	    if (Out0P->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
+-		{ return MIG_SERVER_DIED; }
+-	    else
+-		{ return MIG_REPLY_MISMATCH; }
+-	}
+-
+-#if	__MigTypeCheck
+-	msgh_size = Out0P->Head.msgh_size;
+-
+-	if ((Out0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
+-	    ((msgh_size != (mach_msg_size_t)sizeof(__Reply)) &&
+-	     (msgh_size != (mach_msg_size_t)sizeof(mig_reply_error_t) ||
+-	      Out0P->RetCode == KERN_SUCCESS)))
+-		{ return MIG_TYPE_ERROR ; }
+-#endif	/* __MigTypeCheck */
+-
+-	if (Out0P->RetCode != KERN_SUCCESS) {
+-#ifdef	__NDR_convert__mig_reply_error_t__defined
+-		__NDR_convert__mig_reply_error_t((mig_reply_error_t *)Out0P);
+-#endif	/* __NDR_convert__mig_reply_error_t__defined */
+-		return ((mig_reply_error_t *)Out0P)->RetCode;
+-	}
+-
+-#if	defined(__NDR_convert__int_rep__Reply__rpc_jack_port_register_t__RetCode__defined) || \
+-	defined(__NDR_convert__int_rep__Reply__rpc_jack_port_register_t__port_index__defined) || \
+-	defined(__NDR_convert__int_rep__Reply__rpc_jack_port_register_t__result__defined)
+-	if (Out0P->NDR.int_rep != NDR_record.int_rep) {
+-#if defined(__NDR_convert__int_rep__Reply__rpc_jack_port_register_t__RetCode__defined)
+-		__NDR_convert__int_rep__Reply__rpc_jack_port_register_t__RetCode(&Out0P->RetCode, Out0P->NDR.int_rep);
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_register_t__RetCode__defined */
+-#if defined(__NDR_convert__int_rep__Reply__rpc_jack_port_register_t__port_index__defined)
+-		__NDR_convert__int_rep__Reply__rpc_jack_port_register_t__port_index(&Out0P->port_index, Out0P->NDR.int_rep);
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_register_t__port_index__defined */
+-#if defined(__NDR_convert__int_rep__Reply__rpc_jack_port_register_t__result__defined)
+-		__NDR_convert__int_rep__Reply__rpc_jack_port_register_t__result(&Out0P->result, Out0P->NDR.int_rep);
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_register_t__result__defined */
+-	}
+-#endif	/* defined(__NDR_convert__int_rep...) */
+-
+-#if	0 || \
+-	defined(__NDR_convert__char_rep__Reply__rpc_jack_port_register_t__port_index__defined) || \
+-	defined(__NDR_convert__char_rep__Reply__rpc_jack_port_register_t__result__defined)
+-	if (Out0P->NDR.char_rep != NDR_record.char_rep) {
+-#if defined(__NDR_convert__char_rep__Reply__rpc_jack_port_register_t__port_index__defined)
+-		__NDR_convert__char_rep__Reply__rpc_jack_port_register_t__port_index(&Out0P->port_index, Out0P->NDR.char_rep);
+-#endif /* __NDR_convert__char_rep__Reply__rpc_jack_port_register_t__port_index__defined */
+-#if defined(__NDR_convert__char_rep__Reply__rpc_jack_port_register_t__result__defined)
+-		__NDR_convert__char_rep__Reply__rpc_jack_port_register_t__result(&Out0P->result, Out0P->NDR.char_rep);
+-#endif /* __NDR_convert__char_rep__Reply__rpc_jack_port_register_t__result__defined */
+-	}
+-#endif	/* defined(__NDR_convert__char_rep...) */
+-
+-#if	0 || \
+-	defined(__NDR_convert__float_rep__Reply__rpc_jack_port_register_t__port_index__defined) || \
+-	defined(__NDR_convert__float_rep__Reply__rpc_jack_port_register_t__result__defined)
+-	if (Out0P->NDR.float_rep != NDR_record.float_rep) {
+-#if defined(__NDR_convert__float_rep__Reply__rpc_jack_port_register_t__port_index__defined)
+-		__NDR_convert__float_rep__Reply__rpc_jack_port_register_t__port_index(&Out0P->port_index, Out0P->NDR.float_rep);
+-#endif /* __NDR_convert__float_rep__Reply__rpc_jack_port_register_t__port_index__defined */
+-#if defined(__NDR_convert__float_rep__Reply__rpc_jack_port_register_t__result__defined)
+-		__NDR_convert__float_rep__Reply__rpc_jack_port_register_t__result(&Out0P->result, Out0P->NDR.float_rep);
+-#endif /* __NDR_convert__float_rep__Reply__rpc_jack_port_register_t__result__defined */
+-	}
+-#endif	/* defined(__NDR_convert__float_rep...) */
+-
+-	return MACH_MSG_SUCCESS;
+-}
+-#endif /* !defined(__MIG_check__Reply__rpc_jack_port_register_t__defined) */
+-#endif /* __MIG_check__Reply__JackRPCEngine_subsystem__ */
+-#endif /* ( __MigTypeCheck || __NDR_convert__ ) */
+-
+-
+-/* Routine rpc_jack_port_register */
+-mig_external kern_return_t rpc_jack_port_register
+-(
+-	mach_port_t server_port,
+-	int refnum,
+-	client_port_name_t name,
+-	client_port_type_t port_type,
+-	unsigned flags,
+-	unsigned buffer_size,
+-	unsigned *port_index,
+-	int *result
+-)
+-{
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		int refnum;
+-		client_port_name_t name;
+-		client_port_type_t port_type;
+-		unsigned flags;
+-		unsigned buffer_size;
+-	} Request;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		kern_return_t RetCode;
+-		unsigned port_index;
+-		int result;
+-		mach_msg_trailer_t trailer;
+-	} Reply;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		kern_return_t RetCode;
+-		unsigned port_index;
+-		int result;
+-	} __Reply;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-	/*
+-	 * typedef struct {
+-	 * 	mach_msg_header_t Head;
+-	 * 	NDR_record_t NDR;
+-	 * 	kern_return_t RetCode;
+-	 * } mig_reply_error_t;
+-	 */
+-
+-	union {
+-		Request In;
+-		Reply Out;
+-	} Mess;
+-
+-	Request *InP = &Mess.In;
+-	Reply *Out0P = &Mess.Out;
+-
+-	mach_msg_return_t msg_result;
+-
+-#ifdef	__MIG_check__Reply__rpc_jack_port_register_t__defined
+-	kern_return_t check_result;
+-#endif	/* __MIG_check__Reply__rpc_jack_port_register_t__defined */
+-
+-	__DeclareSendRpc(1005, "rpc_jack_port_register")
+-
+-	InP->NDR = NDR_record;
+-
+-	InP->refnum = refnum;
+-
+-	(void) mig_strncpy(InP->name, name, 128);
+-
+-	(void) mig_strncpy(InP->port_type, port_type, 128);
+-
+-	InP->flags = flags;
+-
+-	InP->buffer_size = buffer_size;
+-
+-	InP->Head.msgh_bits =
+-		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
+-	/* msgh_size passed as argument */
+-	InP->Head.msgh_request_port = server_port;
+-	InP->Head.msgh_reply_port = mig_get_reply_port();
+-	InP->Head.msgh_id = 1005;
+-
+-	__BeforeSendRpc(1005, "rpc_jack_port_register")
+-	msg_result = mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, (mach_msg_size_t)sizeof(Request), (mach_msg_size_t)sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
+-	__AfterSendRpc(1005, "rpc_jack_port_register")
+-	if (msg_result != MACH_MSG_SUCCESS) {
+-		__MachMsgErrorWithoutTimeout(msg_result);
+-		{ return msg_result; }
+-	}
+-
+-
+-#if	defined(__MIG_check__Reply__rpc_jack_port_register_t__defined)
+-	check_result = __MIG_check__Reply__rpc_jack_port_register_t((__Reply__rpc_jack_port_register_t *)Out0P);
+-	if (check_result != MACH_MSG_SUCCESS)
+-		{ return check_result; }
+-#endif	/* defined(__MIG_check__Reply__rpc_jack_port_register_t__defined) */
+-
+-	*port_index = Out0P->port_index;
+-
+-	*result = Out0P->result;
+-
+-	return KERN_SUCCESS;
+-}
+-
+-#if ( __MigTypeCheck || __NDR_convert__ )
+-#if __MIG_check__Reply__JackRPCEngine_subsystem__
+-#if !defined(__MIG_check__Reply__rpc_jack_port_unregister_t__defined)
+-#define __MIG_check__Reply__rpc_jack_port_unregister_t__defined
+-#ifndef __NDR_convert__int_rep__Reply__rpc_jack_port_unregister_t__RetCode__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCEngine__kern_return_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_port_unregister_t__RetCode__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_port_unregister_t__RetCode(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__kern_return_t((kern_return_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__kern_return_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_port_unregister_t__RetCode__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_port_unregister_t__RetCode(a, f) \
+-	__NDR_convert__int_rep__kern_return_t((kern_return_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_unregister_t__RetCode__defined */
+-
+-
+-#ifndef __NDR_convert__int_rep__Reply__rpc_jack_port_unregister_t__result__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_port_unregister_t__result__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_port_unregister_t__result(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_port_unregister_t__result__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_port_unregister_t__result(a, f) \
+-	__NDR_convert__int_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_port_unregister_t__result__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_port_unregister_t__result(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int32_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_port_unregister_t__result__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_port_unregister_t__result(a, f) \
+-	__NDR_convert__int_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_unregister_t__result__defined */
+-
+-
+-
+-#ifndef __NDR_convert__char_rep__Reply__rpc_jack_port_unregister_t__result__defined
+-#if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_port_unregister_t__result__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_port_unregister_t__result(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_port_unregister_t__result__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_port_unregister_t__result(a, f) \
+-	__NDR_convert__char_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_port_unregister_t__result__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_port_unregister_t__result(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int32_t__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_port_unregister_t__result__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_port_unregister_t__result(a, f) \
+-	__NDR_convert__char_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__char_rep__Reply__rpc_jack_port_unregister_t__result__defined */
+-
+-
+-
+-#ifndef __NDR_convert__float_rep__Reply__rpc_jack_port_unregister_t__result__defined
+-#if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_port_unregister_t__result__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_port_unregister_t__result(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_port_unregister_t__result__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_port_unregister_t__result(a, f) \
+-	__NDR_convert__float_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_port_unregister_t__result__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_port_unregister_t__result(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int32_t__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_port_unregister_t__result__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_port_unregister_t__result(a, f) \
+-	__NDR_convert__float_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__float_rep__Reply__rpc_jack_port_unregister_t__result__defined */
+-
+-
+-
+-mig_internal kern_return_t __MIG_check__Reply__rpc_jack_port_unregister_t(__Reply__rpc_jack_port_unregister_t *Out0P)
+-{
+-
+-	typedef __Reply__rpc_jack_port_unregister_t __Reply;
+-#if	__MigTypeCheck
+-	unsigned int msgh_size;
+-#endif	/* __MigTypeCheck */
+-	if (Out0P->Head.msgh_id != 1106) {
+-	    if (Out0P->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
+-		{ return MIG_SERVER_DIED; }
+-	    else
+-		{ return MIG_REPLY_MISMATCH; }
+-	}
+-
+-#if	__MigTypeCheck
+-	msgh_size = Out0P->Head.msgh_size;
+-
+-	if ((Out0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
+-	    ((msgh_size != (mach_msg_size_t)sizeof(__Reply)) &&
+-	     (msgh_size != (mach_msg_size_t)sizeof(mig_reply_error_t) ||
+-	      Out0P->RetCode == KERN_SUCCESS)))
+-		{ return MIG_TYPE_ERROR ; }
+-#endif	/* __MigTypeCheck */
+-
+-	if (Out0P->RetCode != KERN_SUCCESS) {
+-#ifdef	__NDR_convert__mig_reply_error_t__defined
+-		__NDR_convert__mig_reply_error_t((mig_reply_error_t *)Out0P);
+-#endif	/* __NDR_convert__mig_reply_error_t__defined */
+-		return ((mig_reply_error_t *)Out0P)->RetCode;
+-	}
+-
+-#if	defined(__NDR_convert__int_rep__Reply__rpc_jack_port_unregister_t__RetCode__defined) || \
+-	defined(__NDR_convert__int_rep__Reply__rpc_jack_port_unregister_t__result__defined)
+-	if (Out0P->NDR.int_rep != NDR_record.int_rep) {
+-#if defined(__NDR_convert__int_rep__Reply__rpc_jack_port_unregister_t__RetCode__defined)
+-		__NDR_convert__int_rep__Reply__rpc_jack_port_unregister_t__RetCode(&Out0P->RetCode, Out0P->NDR.int_rep);
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_unregister_t__RetCode__defined */
+-#if defined(__NDR_convert__int_rep__Reply__rpc_jack_port_unregister_t__result__defined)
+-		__NDR_convert__int_rep__Reply__rpc_jack_port_unregister_t__result(&Out0P->result, Out0P->NDR.int_rep);
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_unregister_t__result__defined */
+-	}
+-#endif	/* defined(__NDR_convert__int_rep...) */
+-
+-#if	0 || \
+-	defined(__NDR_convert__char_rep__Reply__rpc_jack_port_unregister_t__result__defined)
+-	if (Out0P->NDR.char_rep != NDR_record.char_rep) {
+-#if defined(__NDR_convert__char_rep__Reply__rpc_jack_port_unregister_t__result__defined)
+-		__NDR_convert__char_rep__Reply__rpc_jack_port_unregister_t__result(&Out0P->result, Out0P->NDR.char_rep);
+-#endif /* __NDR_convert__char_rep__Reply__rpc_jack_port_unregister_t__result__defined */
+-	}
+-#endif	/* defined(__NDR_convert__char_rep...) */
+-
+-#if	0 || \
+-	defined(__NDR_convert__float_rep__Reply__rpc_jack_port_unregister_t__result__defined)
+-	if (Out0P->NDR.float_rep != NDR_record.float_rep) {
+-#if defined(__NDR_convert__float_rep__Reply__rpc_jack_port_unregister_t__result__defined)
+-		__NDR_convert__float_rep__Reply__rpc_jack_port_unregister_t__result(&Out0P->result, Out0P->NDR.float_rep);
+-#endif /* __NDR_convert__float_rep__Reply__rpc_jack_port_unregister_t__result__defined */
+-	}
+-#endif	/* defined(__NDR_convert__float_rep...) */
+-
+-	return MACH_MSG_SUCCESS;
+-}
+-#endif /* !defined(__MIG_check__Reply__rpc_jack_port_unregister_t__defined) */
+-#endif /* __MIG_check__Reply__JackRPCEngine_subsystem__ */
+-#endif /* ( __MigTypeCheck || __NDR_convert__ ) */
+-
+-
+-/* Routine rpc_jack_port_unregister */
+-mig_external kern_return_t rpc_jack_port_unregister
+-(
+-	mach_port_t server_port,
+-	int refnum,
+-	int port,
+-	int *result
+-)
+-{
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		int refnum;
+-		int port;
+-	} Request;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		kern_return_t RetCode;
+-		int result;
+-		mach_msg_trailer_t trailer;
+-	} Reply;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		kern_return_t RetCode;
+-		int result;
+-	} __Reply;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-	/*
+-	 * typedef struct {
+-	 * 	mach_msg_header_t Head;
+-	 * 	NDR_record_t NDR;
+-	 * 	kern_return_t RetCode;
+-	 * } mig_reply_error_t;
+-	 */
+-
+-	union {
+-		Request In;
+-		Reply Out;
+-	} Mess;
+-
+-	Request *InP = &Mess.In;
+-	Reply *Out0P = &Mess.Out;
+-
+-	mach_msg_return_t msg_result;
+-
+-#ifdef	__MIG_check__Reply__rpc_jack_port_unregister_t__defined
+-	kern_return_t check_result;
+-#endif	/* __MIG_check__Reply__rpc_jack_port_unregister_t__defined */
+-
+-	__DeclareSendRpc(1006, "rpc_jack_port_unregister")
+-
+-	InP->NDR = NDR_record;
+-
+-	InP->refnum = refnum;
+-
+-	InP->port = port;
+-
+-	InP->Head.msgh_bits =
+-		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
+-	/* msgh_size passed as argument */
+-	InP->Head.msgh_request_port = server_port;
+-	InP->Head.msgh_reply_port = mig_get_reply_port();
+-	InP->Head.msgh_id = 1006;
+-
+-	__BeforeSendRpc(1006, "rpc_jack_port_unregister")
+-	msg_result = mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, (mach_msg_size_t)sizeof(Request), (mach_msg_size_t)sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
+-	__AfterSendRpc(1006, "rpc_jack_port_unregister")
+-	if (msg_result != MACH_MSG_SUCCESS) {
+-		__MachMsgErrorWithoutTimeout(msg_result);
+-		{ return msg_result; }
+-	}
+-
+-
+-#if	defined(__MIG_check__Reply__rpc_jack_port_unregister_t__defined)
+-	check_result = __MIG_check__Reply__rpc_jack_port_unregister_t((__Reply__rpc_jack_port_unregister_t *)Out0P);
+-	if (check_result != MACH_MSG_SUCCESS)
+-		{ return check_result; }
+-#endif	/* defined(__MIG_check__Reply__rpc_jack_port_unregister_t__defined) */
+-
+-	*result = Out0P->result;
+-
+-	return KERN_SUCCESS;
+-}
+-
+-#if ( __MigTypeCheck || __NDR_convert__ )
+-#if __MIG_check__Reply__JackRPCEngine_subsystem__
+-#if !defined(__MIG_check__Reply__rpc_jack_port_connect_t__defined)
+-#define __MIG_check__Reply__rpc_jack_port_connect_t__defined
+-#ifndef __NDR_convert__int_rep__Reply__rpc_jack_port_connect_t__RetCode__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCEngine__kern_return_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_port_connect_t__RetCode__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_port_connect_t__RetCode(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__kern_return_t((kern_return_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__kern_return_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_port_connect_t__RetCode__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_port_connect_t__RetCode(a, f) \
+-	__NDR_convert__int_rep__kern_return_t((kern_return_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_connect_t__RetCode__defined */
+-
+-
+-#ifndef __NDR_convert__int_rep__Reply__rpc_jack_port_connect_t__result__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_port_connect_t__result__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_port_connect_t__result(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_port_connect_t__result__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_port_connect_t__result(a, f) \
+-	__NDR_convert__int_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_port_connect_t__result__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_port_connect_t__result(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int32_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_port_connect_t__result__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_port_connect_t__result(a, f) \
+-	__NDR_convert__int_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_connect_t__result__defined */
+-
+-
+-
+-#ifndef __NDR_convert__char_rep__Reply__rpc_jack_port_connect_t__result__defined
+-#if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_port_connect_t__result__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_port_connect_t__result(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_port_connect_t__result__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_port_connect_t__result(a, f) \
+-	__NDR_convert__char_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_port_connect_t__result__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_port_connect_t__result(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int32_t__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_port_connect_t__result__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_port_connect_t__result(a, f) \
+-	__NDR_convert__char_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__char_rep__Reply__rpc_jack_port_connect_t__result__defined */
+-
+-
+-
+-#ifndef __NDR_convert__float_rep__Reply__rpc_jack_port_connect_t__result__defined
+-#if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_port_connect_t__result__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_port_connect_t__result(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_port_connect_t__result__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_port_connect_t__result(a, f) \
+-	__NDR_convert__float_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_port_connect_t__result__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_port_connect_t__result(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int32_t__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_port_connect_t__result__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_port_connect_t__result(a, f) \
+-	__NDR_convert__float_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__float_rep__Reply__rpc_jack_port_connect_t__result__defined */
+-
+-
+-
+-mig_internal kern_return_t __MIG_check__Reply__rpc_jack_port_connect_t(__Reply__rpc_jack_port_connect_t *Out0P)
+-{
+-
+-	typedef __Reply__rpc_jack_port_connect_t __Reply;
+-#if	__MigTypeCheck
+-	unsigned int msgh_size;
+-#endif	/* __MigTypeCheck */
+-	if (Out0P->Head.msgh_id != 1107) {
+-	    if (Out0P->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
+-		{ return MIG_SERVER_DIED; }
+-	    else
+-		{ return MIG_REPLY_MISMATCH; }
+-	}
+-
+-#if	__MigTypeCheck
+-	msgh_size = Out0P->Head.msgh_size;
+-
+-	if ((Out0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
+-	    ((msgh_size != (mach_msg_size_t)sizeof(__Reply)) &&
+-	     (msgh_size != (mach_msg_size_t)sizeof(mig_reply_error_t) ||
+-	      Out0P->RetCode == KERN_SUCCESS)))
+-		{ return MIG_TYPE_ERROR ; }
+-#endif	/* __MigTypeCheck */
+-
+-	if (Out0P->RetCode != KERN_SUCCESS) {
+-#ifdef	__NDR_convert__mig_reply_error_t__defined
+-		__NDR_convert__mig_reply_error_t((mig_reply_error_t *)Out0P);
+-#endif	/* __NDR_convert__mig_reply_error_t__defined */
+-		return ((mig_reply_error_t *)Out0P)->RetCode;
+-	}
+-
+-#if	defined(__NDR_convert__int_rep__Reply__rpc_jack_port_connect_t__RetCode__defined) || \
+-	defined(__NDR_convert__int_rep__Reply__rpc_jack_port_connect_t__result__defined)
+-	if (Out0P->NDR.int_rep != NDR_record.int_rep) {
+-#if defined(__NDR_convert__int_rep__Reply__rpc_jack_port_connect_t__RetCode__defined)
+-		__NDR_convert__int_rep__Reply__rpc_jack_port_connect_t__RetCode(&Out0P->RetCode, Out0P->NDR.int_rep);
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_connect_t__RetCode__defined */
+-#if defined(__NDR_convert__int_rep__Reply__rpc_jack_port_connect_t__result__defined)
+-		__NDR_convert__int_rep__Reply__rpc_jack_port_connect_t__result(&Out0P->result, Out0P->NDR.int_rep);
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_connect_t__result__defined */
+-	}
+-#endif	/* defined(__NDR_convert__int_rep...) */
+-
+-#if	0 || \
+-	defined(__NDR_convert__char_rep__Reply__rpc_jack_port_connect_t__result__defined)
+-	if (Out0P->NDR.char_rep != NDR_record.char_rep) {
+-#if defined(__NDR_convert__char_rep__Reply__rpc_jack_port_connect_t__result__defined)
+-		__NDR_convert__char_rep__Reply__rpc_jack_port_connect_t__result(&Out0P->result, Out0P->NDR.char_rep);
+-#endif /* __NDR_convert__char_rep__Reply__rpc_jack_port_connect_t__result__defined */
+-	}
+-#endif	/* defined(__NDR_convert__char_rep...) */
+-
+-#if	0 || \
+-	defined(__NDR_convert__float_rep__Reply__rpc_jack_port_connect_t__result__defined)
+-	if (Out0P->NDR.float_rep != NDR_record.float_rep) {
+-#if defined(__NDR_convert__float_rep__Reply__rpc_jack_port_connect_t__result__defined)
+-		__NDR_convert__float_rep__Reply__rpc_jack_port_connect_t__result(&Out0P->result, Out0P->NDR.float_rep);
+-#endif /* __NDR_convert__float_rep__Reply__rpc_jack_port_connect_t__result__defined */
+-	}
+-#endif	/* defined(__NDR_convert__float_rep...) */
+-
+-	return MACH_MSG_SUCCESS;
+-}
+-#endif /* !defined(__MIG_check__Reply__rpc_jack_port_connect_t__defined) */
+-#endif /* __MIG_check__Reply__JackRPCEngine_subsystem__ */
+-#endif /* ( __MigTypeCheck || __NDR_convert__ ) */
+-
+-
+-/* Routine rpc_jack_port_connect */
+-mig_external kern_return_t rpc_jack_port_connect
+-(
+-	mach_port_t server_port,
+-	int refnum,
+-	int src,
+-	int dst,
+-	int *result
+-)
+-{
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		int refnum;
+-		int src;
+-		int dst;
+-	} Request;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		kern_return_t RetCode;
+-		int result;
+-		mach_msg_trailer_t trailer;
+-	} Reply;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		kern_return_t RetCode;
+-		int result;
+-	} __Reply;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-	/*
+-	 * typedef struct {
+-	 * 	mach_msg_header_t Head;
+-	 * 	NDR_record_t NDR;
+-	 * 	kern_return_t RetCode;
+-	 * } mig_reply_error_t;
+-	 */
+-
+-	union {
+-		Request In;
+-		Reply Out;
+-	} Mess;
+-
+-	Request *InP = &Mess.In;
+-	Reply *Out0P = &Mess.Out;
+-
+-	mach_msg_return_t msg_result;
+-
+-#ifdef	__MIG_check__Reply__rpc_jack_port_connect_t__defined
+-	kern_return_t check_result;
+-#endif	/* __MIG_check__Reply__rpc_jack_port_connect_t__defined */
+-
+-	__DeclareSendRpc(1007, "rpc_jack_port_connect")
+-
+-	InP->NDR = NDR_record;
+-
+-	InP->refnum = refnum;
+-
+-	InP->src = src;
+-
+-	InP->dst = dst;
+-
+-	InP->Head.msgh_bits =
+-		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
+-	/* msgh_size passed as argument */
+-	InP->Head.msgh_request_port = server_port;
+-	InP->Head.msgh_reply_port = mig_get_reply_port();
+-	InP->Head.msgh_id = 1007;
+-
+-	__BeforeSendRpc(1007, "rpc_jack_port_connect")
+-	msg_result = mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, (mach_msg_size_t)sizeof(Request), (mach_msg_size_t)sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
+-	__AfterSendRpc(1007, "rpc_jack_port_connect")
+-	if (msg_result != MACH_MSG_SUCCESS) {
+-		__MachMsgErrorWithoutTimeout(msg_result);
+-		{ return msg_result; }
+-	}
+-
+-
+-#if	defined(__MIG_check__Reply__rpc_jack_port_connect_t__defined)
+-	check_result = __MIG_check__Reply__rpc_jack_port_connect_t((__Reply__rpc_jack_port_connect_t *)Out0P);
+-	if (check_result != MACH_MSG_SUCCESS)
+-		{ return check_result; }
+-#endif	/* defined(__MIG_check__Reply__rpc_jack_port_connect_t__defined) */
+-
+-	*result = Out0P->result;
+-
+-	return KERN_SUCCESS;
+-}
+-
+-#if ( __MigTypeCheck || __NDR_convert__ )
+-#if __MIG_check__Reply__JackRPCEngine_subsystem__
+-#if !defined(__MIG_check__Reply__rpc_jack_port_disconnect_t__defined)
+-#define __MIG_check__Reply__rpc_jack_port_disconnect_t__defined
+-#ifndef __NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_t__RetCode__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCEngine__kern_return_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_t__RetCode__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_t__RetCode(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__kern_return_t((kern_return_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__kern_return_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_t__RetCode__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_t__RetCode(a, f) \
+-	__NDR_convert__int_rep__kern_return_t((kern_return_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_t__RetCode__defined */
+-
+-
+-#ifndef __NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_t__result__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_t__result__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_t__result(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_t__result__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_t__result(a, f) \
+-	__NDR_convert__int_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_t__result__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_t__result(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int32_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_t__result__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_t__result(a, f) \
+-	__NDR_convert__int_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_t__result__defined */
+-
+-
+-
+-#ifndef __NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_t__result__defined
+-#if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_t__result__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_t__result(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_t__result__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_t__result(a, f) \
+-	__NDR_convert__char_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_t__result__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_t__result(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int32_t__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_t__result__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_t__result(a, f) \
+-	__NDR_convert__char_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_t__result__defined */
+-
+-
+-
+-#ifndef __NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_t__result__defined
+-#if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_t__result__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_t__result(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_t__result__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_t__result(a, f) \
+-	__NDR_convert__float_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_t__result__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_t__result(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int32_t__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_t__result__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_t__result(a, f) \
+-	__NDR_convert__float_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_t__result__defined */
+-
+-
+-
+-mig_internal kern_return_t __MIG_check__Reply__rpc_jack_port_disconnect_t(__Reply__rpc_jack_port_disconnect_t *Out0P)
+-{
+-
+-	typedef __Reply__rpc_jack_port_disconnect_t __Reply;
+-#if	__MigTypeCheck
+-	unsigned int msgh_size;
+-#endif	/* __MigTypeCheck */
+-	if (Out0P->Head.msgh_id != 1108) {
+-	    if (Out0P->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
+-		{ return MIG_SERVER_DIED; }
+-	    else
+-		{ return MIG_REPLY_MISMATCH; }
+-	}
+-
+-#if	__MigTypeCheck
+-	msgh_size = Out0P->Head.msgh_size;
+-
+-	if ((Out0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
+-	    ((msgh_size != (mach_msg_size_t)sizeof(__Reply)) &&
+-	     (msgh_size != (mach_msg_size_t)sizeof(mig_reply_error_t) ||
+-	      Out0P->RetCode == KERN_SUCCESS)))
+-		{ return MIG_TYPE_ERROR ; }
+-#endif	/* __MigTypeCheck */
+-
+-	if (Out0P->RetCode != KERN_SUCCESS) {
+-#ifdef	__NDR_convert__mig_reply_error_t__defined
+-		__NDR_convert__mig_reply_error_t((mig_reply_error_t *)Out0P);
+-#endif	/* __NDR_convert__mig_reply_error_t__defined */
+-		return ((mig_reply_error_t *)Out0P)->RetCode;
+-	}
+-
+-#if	defined(__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_t__RetCode__defined) || \
+-	defined(__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_t__result__defined)
+-	if (Out0P->NDR.int_rep != NDR_record.int_rep) {
+-#if defined(__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_t__RetCode__defined)
+-		__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_t__RetCode(&Out0P->RetCode, Out0P->NDR.int_rep);
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_t__RetCode__defined */
+-#if defined(__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_t__result__defined)
+-		__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_t__result(&Out0P->result, Out0P->NDR.int_rep);
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_t__result__defined */
+-	}
+-#endif	/* defined(__NDR_convert__int_rep...) */
+-
+-#if	0 || \
+-	defined(__NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_t__result__defined)
+-	if (Out0P->NDR.char_rep != NDR_record.char_rep) {
+-#if defined(__NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_t__result__defined)
+-		__NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_t__result(&Out0P->result, Out0P->NDR.char_rep);
+-#endif /* __NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_t__result__defined */
+-	}
+-#endif	/* defined(__NDR_convert__char_rep...) */
+-
+-#if	0 || \
+-	defined(__NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_t__result__defined)
+-	if (Out0P->NDR.float_rep != NDR_record.float_rep) {
+-#if defined(__NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_t__result__defined)
+-		__NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_t__result(&Out0P->result, Out0P->NDR.float_rep);
+-#endif /* __NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_t__result__defined */
+-	}
+-#endif	/* defined(__NDR_convert__float_rep...) */
+-
+-	return MACH_MSG_SUCCESS;
+-}
+-#endif /* !defined(__MIG_check__Reply__rpc_jack_port_disconnect_t__defined) */
+-#endif /* __MIG_check__Reply__JackRPCEngine_subsystem__ */
+-#endif /* ( __MigTypeCheck || __NDR_convert__ ) */
+-
+-
+-/* Routine rpc_jack_port_disconnect */
+-mig_external kern_return_t rpc_jack_port_disconnect
+-(
+-	mach_port_t server_port,
+-	int refnum,
+-	int src,
+-	int dst,
+-	int *result
+-)
+-{
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		int refnum;
+-		int src;
+-		int dst;
+-	} Request;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		kern_return_t RetCode;
+-		int result;
+-		mach_msg_trailer_t trailer;
+-	} Reply;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		kern_return_t RetCode;
+-		int result;
+-	} __Reply;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-	/*
+-	 * typedef struct {
+-	 * 	mach_msg_header_t Head;
+-	 * 	NDR_record_t NDR;
+-	 * 	kern_return_t RetCode;
+-	 * } mig_reply_error_t;
+-	 */
+-
+-	union {
+-		Request In;
+-		Reply Out;
+-	} Mess;
+-
+-	Request *InP = &Mess.In;
+-	Reply *Out0P = &Mess.Out;
+-
+-	mach_msg_return_t msg_result;
+-
+-#ifdef	__MIG_check__Reply__rpc_jack_port_disconnect_t__defined
+-	kern_return_t check_result;
+-#endif	/* __MIG_check__Reply__rpc_jack_port_disconnect_t__defined */
+-
+-	__DeclareSendRpc(1008, "rpc_jack_port_disconnect")
+-
+-	InP->NDR = NDR_record;
+-
+-	InP->refnum = refnum;
+-
+-	InP->src = src;
+-
+-	InP->dst = dst;
+-
+-	InP->Head.msgh_bits =
+-		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
+-	/* msgh_size passed as argument */
+-	InP->Head.msgh_request_port = server_port;
+-	InP->Head.msgh_reply_port = mig_get_reply_port();
+-	InP->Head.msgh_id = 1008;
+-
+-	__BeforeSendRpc(1008, "rpc_jack_port_disconnect")
+-	msg_result = mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, (mach_msg_size_t)sizeof(Request), (mach_msg_size_t)sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
+-	__AfterSendRpc(1008, "rpc_jack_port_disconnect")
+-	if (msg_result != MACH_MSG_SUCCESS) {
+-		__MachMsgErrorWithoutTimeout(msg_result);
+-		{ return msg_result; }
+-	}
+-
+-
+-#if	defined(__MIG_check__Reply__rpc_jack_port_disconnect_t__defined)
+-	check_result = __MIG_check__Reply__rpc_jack_port_disconnect_t((__Reply__rpc_jack_port_disconnect_t *)Out0P);
+-	if (check_result != MACH_MSG_SUCCESS)
+-		{ return check_result; }
+-#endif	/* defined(__MIG_check__Reply__rpc_jack_port_disconnect_t__defined) */
+-
+-	*result = Out0P->result;
+-
+-	return KERN_SUCCESS;
+-}
+-
+-#if ( __MigTypeCheck || __NDR_convert__ )
+-#if __MIG_check__Reply__JackRPCEngine_subsystem__
+-#if !defined(__MIG_check__Reply__rpc_jack_port_connect_name_t__defined)
+-#define __MIG_check__Reply__rpc_jack_port_connect_name_t__defined
+-#ifndef __NDR_convert__int_rep__Reply__rpc_jack_port_connect_name_t__RetCode__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCEngine__kern_return_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_port_connect_name_t__RetCode__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_port_connect_name_t__RetCode(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__kern_return_t((kern_return_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__kern_return_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_port_connect_name_t__RetCode__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_port_connect_name_t__RetCode(a, f) \
+-	__NDR_convert__int_rep__kern_return_t((kern_return_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_connect_name_t__RetCode__defined */
+-
+-
+-#ifndef __NDR_convert__int_rep__Reply__rpc_jack_port_connect_name_t__result__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_port_connect_name_t__result__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_port_connect_name_t__result(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_port_connect_name_t__result__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_port_connect_name_t__result(a, f) \
+-	__NDR_convert__int_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_port_connect_name_t__result__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_port_connect_name_t__result(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int32_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_port_connect_name_t__result__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_port_connect_name_t__result(a, f) \
+-	__NDR_convert__int_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_connect_name_t__result__defined */
+-
+-
+-
+-#ifndef __NDR_convert__char_rep__Reply__rpc_jack_port_connect_name_t__result__defined
+-#if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_port_connect_name_t__result__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_port_connect_name_t__result(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_port_connect_name_t__result__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_port_connect_name_t__result(a, f) \
+-	__NDR_convert__char_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_port_connect_name_t__result__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_port_connect_name_t__result(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int32_t__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_port_connect_name_t__result__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_port_connect_name_t__result(a, f) \
+-	__NDR_convert__char_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__char_rep__Reply__rpc_jack_port_connect_name_t__result__defined */
+-
+-
+-
+-#ifndef __NDR_convert__float_rep__Reply__rpc_jack_port_connect_name_t__result__defined
+-#if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_port_connect_name_t__result__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_port_connect_name_t__result(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_port_connect_name_t__result__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_port_connect_name_t__result(a, f) \
+-	__NDR_convert__float_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_port_connect_name_t__result__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_port_connect_name_t__result(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int32_t__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_port_connect_name_t__result__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_port_connect_name_t__result(a, f) \
+-	__NDR_convert__float_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__float_rep__Reply__rpc_jack_port_connect_name_t__result__defined */
+-
+-
+-
+-mig_internal kern_return_t __MIG_check__Reply__rpc_jack_port_connect_name_t(__Reply__rpc_jack_port_connect_name_t *Out0P)
+-{
+-
+-	typedef __Reply__rpc_jack_port_connect_name_t __Reply;
+-#if	__MigTypeCheck
+-	unsigned int msgh_size;
+-#endif	/* __MigTypeCheck */
+-	if (Out0P->Head.msgh_id != 1109) {
+-	    if (Out0P->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
+-		{ return MIG_SERVER_DIED; }
+-	    else
+-		{ return MIG_REPLY_MISMATCH; }
+-	}
+-
+-#if	__MigTypeCheck
+-	msgh_size = Out0P->Head.msgh_size;
+-
+-	if ((Out0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
+-	    ((msgh_size != (mach_msg_size_t)sizeof(__Reply)) &&
+-	     (msgh_size != (mach_msg_size_t)sizeof(mig_reply_error_t) ||
+-	      Out0P->RetCode == KERN_SUCCESS)))
+-		{ return MIG_TYPE_ERROR ; }
+-#endif	/* __MigTypeCheck */
+-
+-	if (Out0P->RetCode != KERN_SUCCESS) {
+-#ifdef	__NDR_convert__mig_reply_error_t__defined
+-		__NDR_convert__mig_reply_error_t((mig_reply_error_t *)Out0P);
+-#endif	/* __NDR_convert__mig_reply_error_t__defined */
+-		return ((mig_reply_error_t *)Out0P)->RetCode;
+-	}
+-
+-#if	defined(__NDR_convert__int_rep__Reply__rpc_jack_port_connect_name_t__RetCode__defined) || \
+-	defined(__NDR_convert__int_rep__Reply__rpc_jack_port_connect_name_t__result__defined)
+-	if (Out0P->NDR.int_rep != NDR_record.int_rep) {
+-#if defined(__NDR_convert__int_rep__Reply__rpc_jack_port_connect_name_t__RetCode__defined)
+-		__NDR_convert__int_rep__Reply__rpc_jack_port_connect_name_t__RetCode(&Out0P->RetCode, Out0P->NDR.int_rep);
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_connect_name_t__RetCode__defined */
+-#if defined(__NDR_convert__int_rep__Reply__rpc_jack_port_connect_name_t__result__defined)
+-		__NDR_convert__int_rep__Reply__rpc_jack_port_connect_name_t__result(&Out0P->result, Out0P->NDR.int_rep);
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_connect_name_t__result__defined */
+-	}
+-#endif	/* defined(__NDR_convert__int_rep...) */
+-
+-#if	0 || \
+-	defined(__NDR_convert__char_rep__Reply__rpc_jack_port_connect_name_t__result__defined)
+-	if (Out0P->NDR.char_rep != NDR_record.char_rep) {
+-#if defined(__NDR_convert__char_rep__Reply__rpc_jack_port_connect_name_t__result__defined)
+-		__NDR_convert__char_rep__Reply__rpc_jack_port_connect_name_t__result(&Out0P->result, Out0P->NDR.char_rep);
+-#endif /* __NDR_convert__char_rep__Reply__rpc_jack_port_connect_name_t__result__defined */
+-	}
+-#endif	/* defined(__NDR_convert__char_rep...) */
+-
+-#if	0 || \
+-	defined(__NDR_convert__float_rep__Reply__rpc_jack_port_connect_name_t__result__defined)
+-	if (Out0P->NDR.float_rep != NDR_record.float_rep) {
+-#if defined(__NDR_convert__float_rep__Reply__rpc_jack_port_connect_name_t__result__defined)
+-		__NDR_convert__float_rep__Reply__rpc_jack_port_connect_name_t__result(&Out0P->result, Out0P->NDR.float_rep);
+-#endif /* __NDR_convert__float_rep__Reply__rpc_jack_port_connect_name_t__result__defined */
+-	}
+-#endif	/* defined(__NDR_convert__float_rep...) */
+-
+-	return MACH_MSG_SUCCESS;
+-}
+-#endif /* !defined(__MIG_check__Reply__rpc_jack_port_connect_name_t__defined) */
+-#endif /* __MIG_check__Reply__JackRPCEngine_subsystem__ */
+-#endif /* ( __MigTypeCheck || __NDR_convert__ ) */
+-
+-
+-/* Routine rpc_jack_port_connect_name */
+-mig_external kern_return_t rpc_jack_port_connect_name
+-(
+-	mach_port_t server_port,
+-	int refnum,
+-	client_port_name_t src,
+-	client_port_name_t dst,
+-	int *result
+-)
+-{
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		int refnum;
+-		client_port_name_t src;
+-		client_port_name_t dst;
+-	} Request;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		kern_return_t RetCode;
+-		int result;
+-		mach_msg_trailer_t trailer;
+-	} Reply;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		kern_return_t RetCode;
+-		int result;
+-	} __Reply;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-	/*
+-	 * typedef struct {
+-	 * 	mach_msg_header_t Head;
+-	 * 	NDR_record_t NDR;
+-	 * 	kern_return_t RetCode;
+-	 * } mig_reply_error_t;
+-	 */
+-
+-	union {
+-		Request In;
+-		Reply Out;
+-	} Mess;
+-
+-	Request *InP = &Mess.In;
+-	Reply *Out0P = &Mess.Out;
+-
+-	mach_msg_return_t msg_result;
+-
+-#ifdef	__MIG_check__Reply__rpc_jack_port_connect_name_t__defined
+-	kern_return_t check_result;
+-#endif	/* __MIG_check__Reply__rpc_jack_port_connect_name_t__defined */
+-
+-	__DeclareSendRpc(1009, "rpc_jack_port_connect_name")
+-
+-	InP->NDR = NDR_record;
+-
+-	InP->refnum = refnum;
+-
+-	(void) mig_strncpy(InP->src, src, 128);
+-
+-	(void) mig_strncpy(InP->dst, dst, 128);
+-
+-	InP->Head.msgh_bits =
+-		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
+-	/* msgh_size passed as argument */
+-	InP->Head.msgh_request_port = server_port;
+-	InP->Head.msgh_reply_port = mig_get_reply_port();
+-	InP->Head.msgh_id = 1009;
+-
+-	__BeforeSendRpc(1009, "rpc_jack_port_connect_name")
+-	msg_result = mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, (mach_msg_size_t)sizeof(Request), (mach_msg_size_t)sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
+-	__AfterSendRpc(1009, "rpc_jack_port_connect_name")
+-	if (msg_result != MACH_MSG_SUCCESS) {
+-		__MachMsgErrorWithoutTimeout(msg_result);
+-		{ return msg_result; }
+-	}
+-
+-
+-#if	defined(__MIG_check__Reply__rpc_jack_port_connect_name_t__defined)
+-	check_result = __MIG_check__Reply__rpc_jack_port_connect_name_t((__Reply__rpc_jack_port_connect_name_t *)Out0P);
+-	if (check_result != MACH_MSG_SUCCESS)
+-		{ return check_result; }
+-#endif	/* defined(__MIG_check__Reply__rpc_jack_port_connect_name_t__defined) */
+-
+-	*result = Out0P->result;
+-
+-	return KERN_SUCCESS;
+-}
+-
+-#if ( __MigTypeCheck || __NDR_convert__ )
+-#if __MIG_check__Reply__JackRPCEngine_subsystem__
+-#if !defined(__MIG_check__Reply__rpc_jack_port_disconnect_name_t__defined)
+-#define __MIG_check__Reply__rpc_jack_port_disconnect_name_t__defined
+-#ifndef __NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_name_t__RetCode__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCEngine__kern_return_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_name_t__RetCode__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_name_t__RetCode(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__kern_return_t((kern_return_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__kern_return_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_name_t__RetCode__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_name_t__RetCode(a, f) \
+-	__NDR_convert__int_rep__kern_return_t((kern_return_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_name_t__RetCode__defined */
+-
+-
+-#ifndef __NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_name_t__result(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_name_t__result(a, f) \
+-	__NDR_convert__int_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_name_t__result(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int32_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_name_t__result(a, f) \
+-	__NDR_convert__int_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined */
+-
+-
+-
+-#ifndef __NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined
+-#if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_name_t__result(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_name_t__result(a, f) \
+-	__NDR_convert__char_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_name_t__result(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int32_t__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_name_t__result(a, f) \
+-	__NDR_convert__char_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined */
+-
+-
+-
+-#ifndef __NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined
+-#if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_name_t__result(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_name_t__result(a, f) \
+-	__NDR_convert__float_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_name_t__result(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int32_t__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_name_t__result(a, f) \
+-	__NDR_convert__float_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined */
+-
+-
+-
+-mig_internal kern_return_t __MIG_check__Reply__rpc_jack_port_disconnect_name_t(__Reply__rpc_jack_port_disconnect_name_t *Out0P)
+-{
+-
+-	typedef __Reply__rpc_jack_port_disconnect_name_t __Reply;
+-#if	__MigTypeCheck
+-	unsigned int msgh_size;
+-#endif	/* __MigTypeCheck */
+-	if (Out0P->Head.msgh_id != 1110) {
+-	    if (Out0P->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
+-		{ return MIG_SERVER_DIED; }
+-	    else
+-		{ return MIG_REPLY_MISMATCH; }
+-	}
+-
+-#if	__MigTypeCheck
+-	msgh_size = Out0P->Head.msgh_size;
+-
+-	if ((Out0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
+-	    ((msgh_size != (mach_msg_size_t)sizeof(__Reply)) &&
+-	     (msgh_size != (mach_msg_size_t)sizeof(mig_reply_error_t) ||
+-	      Out0P->RetCode == KERN_SUCCESS)))
+-		{ return MIG_TYPE_ERROR ; }
+-#endif	/* __MigTypeCheck */
+-
+-	if (Out0P->RetCode != KERN_SUCCESS) {
+-#ifdef	__NDR_convert__mig_reply_error_t__defined
+-		__NDR_convert__mig_reply_error_t((mig_reply_error_t *)Out0P);
+-#endif	/* __NDR_convert__mig_reply_error_t__defined */
+-		return ((mig_reply_error_t *)Out0P)->RetCode;
+-	}
+-
+-#if	defined(__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_name_t__RetCode__defined) || \
+-	defined(__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined)
+-	if (Out0P->NDR.int_rep != NDR_record.int_rep) {
+-#if defined(__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_name_t__RetCode__defined)
+-		__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_name_t__RetCode(&Out0P->RetCode, Out0P->NDR.int_rep);
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_name_t__RetCode__defined */
+-#if defined(__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined)
+-		__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_name_t__result(&Out0P->result, Out0P->NDR.int_rep);
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined */
+-	}
+-#endif	/* defined(__NDR_convert__int_rep...) */
+-
+-#if	0 || \
+-	defined(__NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined)
+-	if (Out0P->NDR.char_rep != NDR_record.char_rep) {
+-#if defined(__NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined)
+-		__NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_name_t__result(&Out0P->result, Out0P->NDR.char_rep);
+-#endif /* __NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined */
+-	}
+-#endif	/* defined(__NDR_convert__char_rep...) */
+-
+-#if	0 || \
+-	defined(__NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined)
+-	if (Out0P->NDR.float_rep != NDR_record.float_rep) {
+-#if defined(__NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined)
+-		__NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_name_t__result(&Out0P->result, Out0P->NDR.float_rep);
+-#endif /* __NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined */
+-	}
+-#endif	/* defined(__NDR_convert__float_rep...) */
+-
+-	return MACH_MSG_SUCCESS;
+-}
+-#endif /* !defined(__MIG_check__Reply__rpc_jack_port_disconnect_name_t__defined) */
+-#endif /* __MIG_check__Reply__JackRPCEngine_subsystem__ */
+-#endif /* ( __MigTypeCheck || __NDR_convert__ ) */
+-
+-
+-/* Routine rpc_jack_port_disconnect_name */
+-mig_external kern_return_t rpc_jack_port_disconnect_name
+-(
+-	mach_port_t server_port,
+-	int refnum,
+-	client_port_name_t src,
+-	client_port_name_t dst,
+-	int *result
+-)
+-{
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		int refnum;
+-		client_port_name_t src;
+-		client_port_name_t dst;
+-	} Request;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		kern_return_t RetCode;
+-		int result;
+-		mach_msg_trailer_t trailer;
+-	} Reply;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		kern_return_t RetCode;
+-		int result;
+-	} __Reply;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-	/*
+-	 * typedef struct {
+-	 * 	mach_msg_header_t Head;
+-	 * 	NDR_record_t NDR;
+-	 * 	kern_return_t RetCode;
+-	 * } mig_reply_error_t;
+-	 */
+-
+-	union {
+-		Request In;
+-		Reply Out;
+-	} Mess;
+-
+-	Request *InP = &Mess.In;
+-	Reply *Out0P = &Mess.Out;
+-
+-	mach_msg_return_t msg_result;
+-
+-#ifdef	__MIG_check__Reply__rpc_jack_port_disconnect_name_t__defined
+-	kern_return_t check_result;
+-#endif	/* __MIG_check__Reply__rpc_jack_port_disconnect_name_t__defined */
+-
+-	__DeclareSendRpc(1010, "rpc_jack_port_disconnect_name")
+-
+-	InP->NDR = NDR_record;
+-
+-	InP->refnum = refnum;
+-
+-	(void) mig_strncpy(InP->src, src, 128);
+-
+-	(void) mig_strncpy(InP->dst, dst, 128);
+-
+-	InP->Head.msgh_bits =
+-		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
+-	/* msgh_size passed as argument */
+-	InP->Head.msgh_request_port = server_port;
+-	InP->Head.msgh_reply_port = mig_get_reply_port();
+-	InP->Head.msgh_id = 1010;
+-
+-	__BeforeSendRpc(1010, "rpc_jack_port_disconnect_name")
+-	msg_result = mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, (mach_msg_size_t)sizeof(Request), (mach_msg_size_t)sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
+-	__AfterSendRpc(1010, "rpc_jack_port_disconnect_name")
+-	if (msg_result != MACH_MSG_SUCCESS) {
+-		__MachMsgErrorWithoutTimeout(msg_result);
+-		{ return msg_result; }
+-	}
+-
+-
+-#if	defined(__MIG_check__Reply__rpc_jack_port_disconnect_name_t__defined)
+-	check_result = __MIG_check__Reply__rpc_jack_port_disconnect_name_t((__Reply__rpc_jack_port_disconnect_name_t *)Out0P);
+-	if (check_result != MACH_MSG_SUCCESS)
+-		{ return check_result; }
+-#endif	/* defined(__MIG_check__Reply__rpc_jack_port_disconnect_name_t__defined) */
+-
+-	*result = Out0P->result;
+-
+-	return KERN_SUCCESS;
+-}
+-
+-#if ( __MigTypeCheck || __NDR_convert__ )
+-#if __MIG_check__Reply__JackRPCEngine_subsystem__
+-#if !defined(__MIG_check__Reply__rpc_jack_port_rename_t__defined)
+-#define __MIG_check__Reply__rpc_jack_port_rename_t__defined
+-#ifndef __NDR_convert__int_rep__Reply__rpc_jack_port_rename_t__RetCode__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCEngine__kern_return_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_port_rename_t__RetCode__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_port_rename_t__RetCode(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__kern_return_t((kern_return_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__kern_return_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_port_rename_t__RetCode__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_port_rename_t__RetCode(a, f) \
+-	__NDR_convert__int_rep__kern_return_t((kern_return_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_rename_t__RetCode__defined */
+-
+-
+-#ifndef __NDR_convert__int_rep__Reply__rpc_jack_port_rename_t__result__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_port_rename_t__result__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_port_rename_t__result(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_port_rename_t__result__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_port_rename_t__result(a, f) \
+-	__NDR_convert__int_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_port_rename_t__result__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_port_rename_t__result(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int32_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_port_rename_t__result__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_port_rename_t__result(a, f) \
+-	__NDR_convert__int_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_rename_t__result__defined */
+-
+-
+-
+-#ifndef __NDR_convert__char_rep__Reply__rpc_jack_port_rename_t__result__defined
+-#if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_port_rename_t__result__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_port_rename_t__result(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_port_rename_t__result__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_port_rename_t__result(a, f) \
+-	__NDR_convert__char_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_port_rename_t__result__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_port_rename_t__result(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int32_t__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_port_rename_t__result__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_port_rename_t__result(a, f) \
+-	__NDR_convert__char_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__char_rep__Reply__rpc_jack_port_rename_t__result__defined */
+-
+-
+-
+-#ifndef __NDR_convert__float_rep__Reply__rpc_jack_port_rename_t__result__defined
+-#if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_port_rename_t__result__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_port_rename_t__result(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_port_rename_t__result__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_port_rename_t__result(a, f) \
+-	__NDR_convert__float_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_port_rename_t__result__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_port_rename_t__result(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int32_t__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_port_rename_t__result__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_port_rename_t__result(a, f) \
+-	__NDR_convert__float_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__float_rep__Reply__rpc_jack_port_rename_t__result__defined */
+-
+-
+-
+-mig_internal kern_return_t __MIG_check__Reply__rpc_jack_port_rename_t(__Reply__rpc_jack_port_rename_t *Out0P)
+-{
+-
+-	typedef __Reply__rpc_jack_port_rename_t __Reply;
+-#if	__MigTypeCheck
+-	unsigned int msgh_size;
+-#endif	/* __MigTypeCheck */
+-	if (Out0P->Head.msgh_id != 1111) {
+-	    if (Out0P->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
+-		{ return MIG_SERVER_DIED; }
+-	    else
+-		{ return MIG_REPLY_MISMATCH; }
+-	}
+-
+-#if	__MigTypeCheck
+-	msgh_size = Out0P->Head.msgh_size;
+-
+-	if ((Out0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
+-	    ((msgh_size != (mach_msg_size_t)sizeof(__Reply)) &&
+-	     (msgh_size != (mach_msg_size_t)sizeof(mig_reply_error_t) ||
+-	      Out0P->RetCode == KERN_SUCCESS)))
+-		{ return MIG_TYPE_ERROR ; }
+-#endif	/* __MigTypeCheck */
+-
+-	if (Out0P->RetCode != KERN_SUCCESS) {
+-#ifdef	__NDR_convert__mig_reply_error_t__defined
+-		__NDR_convert__mig_reply_error_t((mig_reply_error_t *)Out0P);
+-#endif	/* __NDR_convert__mig_reply_error_t__defined */
+-		return ((mig_reply_error_t *)Out0P)->RetCode;
+-	}
+-
+-#if	defined(__NDR_convert__int_rep__Reply__rpc_jack_port_rename_t__RetCode__defined) || \
+-	defined(__NDR_convert__int_rep__Reply__rpc_jack_port_rename_t__result__defined)
+-	if (Out0P->NDR.int_rep != NDR_record.int_rep) {
+-#if defined(__NDR_convert__int_rep__Reply__rpc_jack_port_rename_t__RetCode__defined)
+-		__NDR_convert__int_rep__Reply__rpc_jack_port_rename_t__RetCode(&Out0P->RetCode, Out0P->NDR.int_rep);
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_rename_t__RetCode__defined */
+-#if defined(__NDR_convert__int_rep__Reply__rpc_jack_port_rename_t__result__defined)
+-		__NDR_convert__int_rep__Reply__rpc_jack_port_rename_t__result(&Out0P->result, Out0P->NDR.int_rep);
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_rename_t__result__defined */
+-	}
+-#endif	/* defined(__NDR_convert__int_rep...) */
+-
+-#if	0 || \
+-	defined(__NDR_convert__char_rep__Reply__rpc_jack_port_rename_t__result__defined)
+-	if (Out0P->NDR.char_rep != NDR_record.char_rep) {
+-#if defined(__NDR_convert__char_rep__Reply__rpc_jack_port_rename_t__result__defined)
+-		__NDR_convert__char_rep__Reply__rpc_jack_port_rename_t__result(&Out0P->result, Out0P->NDR.char_rep);
+-#endif /* __NDR_convert__char_rep__Reply__rpc_jack_port_rename_t__result__defined */
+-	}
+-#endif	/* defined(__NDR_convert__char_rep...) */
+-
+-#if	0 || \
+-	defined(__NDR_convert__float_rep__Reply__rpc_jack_port_rename_t__result__defined)
+-	if (Out0P->NDR.float_rep != NDR_record.float_rep) {
+-#if defined(__NDR_convert__float_rep__Reply__rpc_jack_port_rename_t__result__defined)
+-		__NDR_convert__float_rep__Reply__rpc_jack_port_rename_t__result(&Out0P->result, Out0P->NDR.float_rep);
+-#endif /* __NDR_convert__float_rep__Reply__rpc_jack_port_rename_t__result__defined */
+-	}
+-#endif	/* defined(__NDR_convert__float_rep...) */
+-
+-	return MACH_MSG_SUCCESS;
+-}
+-#endif /* !defined(__MIG_check__Reply__rpc_jack_port_rename_t__defined) */
+-#endif /* __MIG_check__Reply__JackRPCEngine_subsystem__ */
+-#endif /* ( __MigTypeCheck || __NDR_convert__ ) */
+-
+-
+-/* Routine rpc_jack_port_rename */
+-mig_external kern_return_t rpc_jack_port_rename
+-(
+-	mach_port_t server_port,
+-	int refnum,
+-	int src,
+-	client_port_name_t name,
+-	int *result
+-)
+-{
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		int refnum;
+-		int src;
+-		client_port_name_t name;
+-	} Request;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		kern_return_t RetCode;
+-		int result;
+-		mach_msg_trailer_t trailer;
+-	} Reply;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		kern_return_t RetCode;
+-		int result;
+-	} __Reply;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-	/*
+-	 * typedef struct {
+-	 * 	mach_msg_header_t Head;
+-	 * 	NDR_record_t NDR;
+-	 * 	kern_return_t RetCode;
+-	 * } mig_reply_error_t;
+-	 */
+-
+-	union {
+-		Request In;
+-		Reply Out;
+-	} Mess;
+-
+-	Request *InP = &Mess.In;
+-	Reply *Out0P = &Mess.Out;
+-
+-	mach_msg_return_t msg_result;
+-
+-#ifdef	__MIG_check__Reply__rpc_jack_port_rename_t__defined
+-	kern_return_t check_result;
+-#endif	/* __MIG_check__Reply__rpc_jack_port_rename_t__defined */
+-
+-	__DeclareSendRpc(1011, "rpc_jack_port_rename")
+-
+-	InP->NDR = NDR_record;
+-
+-	InP->refnum = refnum;
+-
+-	InP->src = src;
+-
+-	(void) mig_strncpy(InP->name, name, 128);
+-
+-	InP->Head.msgh_bits =
+-		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
+-	/* msgh_size passed as argument */
+-	InP->Head.msgh_request_port = server_port;
+-	InP->Head.msgh_reply_port = mig_get_reply_port();
+-	InP->Head.msgh_id = 1011;
+-
+-	__BeforeSendRpc(1011, "rpc_jack_port_rename")
+-	msg_result = mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, (mach_msg_size_t)sizeof(Request), (mach_msg_size_t)sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
+-	__AfterSendRpc(1011, "rpc_jack_port_rename")
+-	if (msg_result != MACH_MSG_SUCCESS) {
+-		__MachMsgErrorWithoutTimeout(msg_result);
+-		{ return msg_result; }
+-	}
+-
+-
+-#if	defined(__MIG_check__Reply__rpc_jack_port_rename_t__defined)
+-	check_result = __MIG_check__Reply__rpc_jack_port_rename_t((__Reply__rpc_jack_port_rename_t *)Out0P);
+-	if (check_result != MACH_MSG_SUCCESS)
+-		{ return check_result; }
+-#endif	/* defined(__MIG_check__Reply__rpc_jack_port_rename_t__defined) */
+-
+-	*result = Out0P->result;
+-
+-	return KERN_SUCCESS;
+-}
+-
+-#if ( __MigTypeCheck || __NDR_convert__ )
+-#if __MIG_check__Reply__JackRPCEngine_subsystem__
+-#if !defined(__MIG_check__Reply__rpc_jack_set_buffer_size_t__defined)
+-#define __MIG_check__Reply__rpc_jack_set_buffer_size_t__defined
+-#ifndef __NDR_convert__int_rep__Reply__rpc_jack_set_buffer_size_t__RetCode__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCEngine__kern_return_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_set_buffer_size_t__RetCode__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_set_buffer_size_t__RetCode(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__kern_return_t((kern_return_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__kern_return_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_set_buffer_size_t__RetCode__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_set_buffer_size_t__RetCode(a, f) \
+-	__NDR_convert__int_rep__kern_return_t((kern_return_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_set_buffer_size_t__RetCode__defined */
+-
+-
+-#ifndef __NDR_convert__int_rep__Reply__rpc_jack_set_buffer_size_t__result__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_set_buffer_size_t__result__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_set_buffer_size_t__result(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_set_buffer_size_t__result__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_set_buffer_size_t__result(a, f) \
+-	__NDR_convert__int_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_set_buffer_size_t__result__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_set_buffer_size_t__result(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int32_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_set_buffer_size_t__result__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_set_buffer_size_t__result(a, f) \
+-	__NDR_convert__int_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_set_buffer_size_t__result__defined */
+-
+-
+-
+-#ifndef __NDR_convert__char_rep__Reply__rpc_jack_set_buffer_size_t__result__defined
+-#if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_set_buffer_size_t__result__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_set_buffer_size_t__result(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_set_buffer_size_t__result__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_set_buffer_size_t__result(a, f) \
+-	__NDR_convert__char_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_set_buffer_size_t__result__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_set_buffer_size_t__result(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int32_t__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_set_buffer_size_t__result__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_set_buffer_size_t__result(a, f) \
+-	__NDR_convert__char_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__char_rep__Reply__rpc_jack_set_buffer_size_t__result__defined */
+-
+-
+-
+-#ifndef __NDR_convert__float_rep__Reply__rpc_jack_set_buffer_size_t__result__defined
+-#if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_set_buffer_size_t__result__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_set_buffer_size_t__result(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_set_buffer_size_t__result__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_set_buffer_size_t__result(a, f) \
+-	__NDR_convert__float_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_set_buffer_size_t__result__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_set_buffer_size_t__result(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int32_t__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_set_buffer_size_t__result__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_set_buffer_size_t__result(a, f) \
+-	__NDR_convert__float_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__float_rep__Reply__rpc_jack_set_buffer_size_t__result__defined */
+-
+-
+-
+-mig_internal kern_return_t __MIG_check__Reply__rpc_jack_set_buffer_size_t(__Reply__rpc_jack_set_buffer_size_t *Out0P)
+-{
+-
+-	typedef __Reply__rpc_jack_set_buffer_size_t __Reply;
+-#if	__MigTypeCheck
+-	unsigned int msgh_size;
+-#endif	/* __MigTypeCheck */
+-	if (Out0P->Head.msgh_id != 1112) {
+-	    if (Out0P->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
+-		{ return MIG_SERVER_DIED; }
+-	    else
+-		{ return MIG_REPLY_MISMATCH; }
+-	}
+-
+-#if	__MigTypeCheck
+-	msgh_size = Out0P->Head.msgh_size;
+-
+-	if ((Out0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
+-	    ((msgh_size != (mach_msg_size_t)sizeof(__Reply)) &&
+-	     (msgh_size != (mach_msg_size_t)sizeof(mig_reply_error_t) ||
+-	      Out0P->RetCode == KERN_SUCCESS)))
+-		{ return MIG_TYPE_ERROR ; }
+-#endif	/* __MigTypeCheck */
+-
+-	if (Out0P->RetCode != KERN_SUCCESS) {
+-#ifdef	__NDR_convert__mig_reply_error_t__defined
+-		__NDR_convert__mig_reply_error_t((mig_reply_error_t *)Out0P);
+-#endif	/* __NDR_convert__mig_reply_error_t__defined */
+-		return ((mig_reply_error_t *)Out0P)->RetCode;
+-	}
+-
+-#if	defined(__NDR_convert__int_rep__Reply__rpc_jack_set_buffer_size_t__RetCode__defined) || \
+-	defined(__NDR_convert__int_rep__Reply__rpc_jack_set_buffer_size_t__result__defined)
+-	if (Out0P->NDR.int_rep != NDR_record.int_rep) {
+-#if defined(__NDR_convert__int_rep__Reply__rpc_jack_set_buffer_size_t__RetCode__defined)
+-		__NDR_convert__int_rep__Reply__rpc_jack_set_buffer_size_t__RetCode(&Out0P->RetCode, Out0P->NDR.int_rep);
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_set_buffer_size_t__RetCode__defined */
+-#if defined(__NDR_convert__int_rep__Reply__rpc_jack_set_buffer_size_t__result__defined)
+-		__NDR_convert__int_rep__Reply__rpc_jack_set_buffer_size_t__result(&Out0P->result, Out0P->NDR.int_rep);
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_set_buffer_size_t__result__defined */
+-	}
+-#endif	/* defined(__NDR_convert__int_rep...) */
+-
+-#if	0 || \
+-	defined(__NDR_convert__char_rep__Reply__rpc_jack_set_buffer_size_t__result__defined)
+-	if (Out0P->NDR.char_rep != NDR_record.char_rep) {
+-#if defined(__NDR_convert__char_rep__Reply__rpc_jack_set_buffer_size_t__result__defined)
+-		__NDR_convert__char_rep__Reply__rpc_jack_set_buffer_size_t__result(&Out0P->result, Out0P->NDR.char_rep);
+-#endif /* __NDR_convert__char_rep__Reply__rpc_jack_set_buffer_size_t__result__defined */
+-	}
+-#endif	/* defined(__NDR_convert__char_rep...) */
+-
+-#if	0 || \
+-	defined(__NDR_convert__float_rep__Reply__rpc_jack_set_buffer_size_t__result__defined)
+-	if (Out0P->NDR.float_rep != NDR_record.float_rep) {
+-#if defined(__NDR_convert__float_rep__Reply__rpc_jack_set_buffer_size_t__result__defined)
+-		__NDR_convert__float_rep__Reply__rpc_jack_set_buffer_size_t__result(&Out0P->result, Out0P->NDR.float_rep);
+-#endif /* __NDR_convert__float_rep__Reply__rpc_jack_set_buffer_size_t__result__defined */
+-	}
+-#endif	/* defined(__NDR_convert__float_rep...) */
+-
+-	return MACH_MSG_SUCCESS;
+-}
+-#endif /* !defined(__MIG_check__Reply__rpc_jack_set_buffer_size_t__defined) */
+-#endif /* __MIG_check__Reply__JackRPCEngine_subsystem__ */
+-#endif /* ( __MigTypeCheck || __NDR_convert__ ) */
+-
+-
+-/* Routine rpc_jack_set_buffer_size */
+-mig_external kern_return_t rpc_jack_set_buffer_size
+-(
+-	mach_port_t server_port,
+-	int buffer_size,
+-	int *result
+-)
+-{
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		int buffer_size;
+-	} Request;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		kern_return_t RetCode;
+-		int result;
+-		mach_msg_trailer_t trailer;
+-	} Reply;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		kern_return_t RetCode;
+-		int result;
+-	} __Reply;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-	/*
+-	 * typedef struct {
+-	 * 	mach_msg_header_t Head;
+-	 * 	NDR_record_t NDR;
+-	 * 	kern_return_t RetCode;
+-	 * } mig_reply_error_t;
+-	 */
+-
+-	union {
+-		Request In;
+-		Reply Out;
+-	} Mess;
+-
+-	Request *InP = &Mess.In;
+-	Reply *Out0P = &Mess.Out;
+-
+-	mach_msg_return_t msg_result;
+-
+-#ifdef	__MIG_check__Reply__rpc_jack_set_buffer_size_t__defined
+-	kern_return_t check_result;
+-#endif	/* __MIG_check__Reply__rpc_jack_set_buffer_size_t__defined */
+-
+-	__DeclareSendRpc(1012, "rpc_jack_set_buffer_size")
+-
+-	InP->NDR = NDR_record;
+-
+-	InP->buffer_size = buffer_size;
+-
+-	InP->Head.msgh_bits =
+-		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
+-	/* msgh_size passed as argument */
+-	InP->Head.msgh_request_port = server_port;
+-	InP->Head.msgh_reply_port = mig_get_reply_port();
+-	InP->Head.msgh_id = 1012;
+-
+-	__BeforeSendRpc(1012, "rpc_jack_set_buffer_size")
+-	msg_result = mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, (mach_msg_size_t)sizeof(Request), (mach_msg_size_t)sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
+-	__AfterSendRpc(1012, "rpc_jack_set_buffer_size")
+-	if (msg_result != MACH_MSG_SUCCESS) {
+-		__MachMsgErrorWithoutTimeout(msg_result);
+-		{ return msg_result; }
+-	}
+-
+-
+-#if	defined(__MIG_check__Reply__rpc_jack_set_buffer_size_t__defined)
+-	check_result = __MIG_check__Reply__rpc_jack_set_buffer_size_t((__Reply__rpc_jack_set_buffer_size_t *)Out0P);
+-	if (check_result != MACH_MSG_SUCCESS)
+-		{ return check_result; }
+-#endif	/* defined(__MIG_check__Reply__rpc_jack_set_buffer_size_t__defined) */
+-
+-	*result = Out0P->result;
+-
+-	return KERN_SUCCESS;
+-}
+-
+-#if ( __MigTypeCheck || __NDR_convert__ )
+-#if __MIG_check__Reply__JackRPCEngine_subsystem__
+-#if !defined(__MIG_check__Reply__rpc_jack_set_freewheel_t__defined)
+-#define __MIG_check__Reply__rpc_jack_set_freewheel_t__defined
+-#ifndef __NDR_convert__int_rep__Reply__rpc_jack_set_freewheel_t__RetCode__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCEngine__kern_return_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_set_freewheel_t__RetCode__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_set_freewheel_t__RetCode(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__kern_return_t((kern_return_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__kern_return_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_set_freewheel_t__RetCode__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_set_freewheel_t__RetCode(a, f) \
+-	__NDR_convert__int_rep__kern_return_t((kern_return_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_set_freewheel_t__RetCode__defined */
+-
+-
+-#ifndef __NDR_convert__int_rep__Reply__rpc_jack_set_freewheel_t__result__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_set_freewheel_t__result__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_set_freewheel_t__result(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_set_freewheel_t__result__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_set_freewheel_t__result(a, f) \
+-	__NDR_convert__int_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_set_freewheel_t__result__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_set_freewheel_t__result(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int32_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_set_freewheel_t__result__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_set_freewheel_t__result(a, f) \
+-	__NDR_convert__int_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_set_freewheel_t__result__defined */
+-
+-
+-
+-#ifndef __NDR_convert__char_rep__Reply__rpc_jack_set_freewheel_t__result__defined
+-#if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_set_freewheel_t__result__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_set_freewheel_t__result(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_set_freewheel_t__result__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_set_freewheel_t__result(a, f) \
+-	__NDR_convert__char_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_set_freewheel_t__result__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_set_freewheel_t__result(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int32_t__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_set_freewheel_t__result__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_set_freewheel_t__result(a, f) \
+-	__NDR_convert__char_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__char_rep__Reply__rpc_jack_set_freewheel_t__result__defined */
+-
+-
+-
+-#ifndef __NDR_convert__float_rep__Reply__rpc_jack_set_freewheel_t__result__defined
+-#if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_set_freewheel_t__result__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_set_freewheel_t__result(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_set_freewheel_t__result__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_set_freewheel_t__result(a, f) \
+-	__NDR_convert__float_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_set_freewheel_t__result__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_set_freewheel_t__result(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int32_t__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_set_freewheel_t__result__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_set_freewheel_t__result(a, f) \
+-	__NDR_convert__float_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__float_rep__Reply__rpc_jack_set_freewheel_t__result__defined */
+-
+-
+-
+-mig_internal kern_return_t __MIG_check__Reply__rpc_jack_set_freewheel_t(__Reply__rpc_jack_set_freewheel_t *Out0P)
+-{
+-
+-	typedef __Reply__rpc_jack_set_freewheel_t __Reply;
+-#if	__MigTypeCheck
+-	unsigned int msgh_size;
+-#endif	/* __MigTypeCheck */
+-	if (Out0P->Head.msgh_id != 1113) {
+-	    if (Out0P->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
+-		{ return MIG_SERVER_DIED; }
+-	    else
+-		{ return MIG_REPLY_MISMATCH; }
+-	}
+-
+-#if	__MigTypeCheck
+-	msgh_size = Out0P->Head.msgh_size;
+-
+-	if ((Out0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
+-	    ((msgh_size != (mach_msg_size_t)sizeof(__Reply)) &&
+-	     (msgh_size != (mach_msg_size_t)sizeof(mig_reply_error_t) ||
+-	      Out0P->RetCode == KERN_SUCCESS)))
+-		{ return MIG_TYPE_ERROR ; }
+-#endif	/* __MigTypeCheck */
+-
+-	if (Out0P->RetCode != KERN_SUCCESS) {
+-#ifdef	__NDR_convert__mig_reply_error_t__defined
+-		__NDR_convert__mig_reply_error_t((mig_reply_error_t *)Out0P);
+-#endif	/* __NDR_convert__mig_reply_error_t__defined */
+-		return ((mig_reply_error_t *)Out0P)->RetCode;
+-	}
+-
+-#if	defined(__NDR_convert__int_rep__Reply__rpc_jack_set_freewheel_t__RetCode__defined) || \
+-	defined(__NDR_convert__int_rep__Reply__rpc_jack_set_freewheel_t__result__defined)
+-	if (Out0P->NDR.int_rep != NDR_record.int_rep) {
+-#if defined(__NDR_convert__int_rep__Reply__rpc_jack_set_freewheel_t__RetCode__defined)
+-		__NDR_convert__int_rep__Reply__rpc_jack_set_freewheel_t__RetCode(&Out0P->RetCode, Out0P->NDR.int_rep);
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_set_freewheel_t__RetCode__defined */
+-#if defined(__NDR_convert__int_rep__Reply__rpc_jack_set_freewheel_t__result__defined)
+-		__NDR_convert__int_rep__Reply__rpc_jack_set_freewheel_t__result(&Out0P->result, Out0P->NDR.int_rep);
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_set_freewheel_t__result__defined */
+-	}
+-#endif	/* defined(__NDR_convert__int_rep...) */
+-
+-#if	0 || \
+-	defined(__NDR_convert__char_rep__Reply__rpc_jack_set_freewheel_t__result__defined)
+-	if (Out0P->NDR.char_rep != NDR_record.char_rep) {
+-#if defined(__NDR_convert__char_rep__Reply__rpc_jack_set_freewheel_t__result__defined)
+-		__NDR_convert__char_rep__Reply__rpc_jack_set_freewheel_t__result(&Out0P->result, Out0P->NDR.char_rep);
+-#endif /* __NDR_convert__char_rep__Reply__rpc_jack_set_freewheel_t__result__defined */
+-	}
+-#endif	/* defined(__NDR_convert__char_rep...) */
+-
+-#if	0 || \
+-	defined(__NDR_convert__float_rep__Reply__rpc_jack_set_freewheel_t__result__defined)
+-	if (Out0P->NDR.float_rep != NDR_record.float_rep) {
+-#if defined(__NDR_convert__float_rep__Reply__rpc_jack_set_freewheel_t__result__defined)
+-		__NDR_convert__float_rep__Reply__rpc_jack_set_freewheel_t__result(&Out0P->result, Out0P->NDR.float_rep);
+-#endif /* __NDR_convert__float_rep__Reply__rpc_jack_set_freewheel_t__result__defined */
+-	}
+-#endif	/* defined(__NDR_convert__float_rep...) */
+-
+-	return MACH_MSG_SUCCESS;
+-}
+-#endif /* !defined(__MIG_check__Reply__rpc_jack_set_freewheel_t__defined) */
+-#endif /* __MIG_check__Reply__JackRPCEngine_subsystem__ */
+-#endif /* ( __MigTypeCheck || __NDR_convert__ ) */
+-
+-
+-/* Routine rpc_jack_set_freewheel */
+-mig_external kern_return_t rpc_jack_set_freewheel
+-(
+-	mach_port_t server_port,
+-	int onoff,
+-	int *result
+-)
+-{
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		int onoff;
+-	} Request;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		kern_return_t RetCode;
+-		int result;
+-		mach_msg_trailer_t trailer;
+-	} Reply;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		kern_return_t RetCode;
+-		int result;
+-	} __Reply;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-	/*
+-	 * typedef struct {
+-	 * 	mach_msg_header_t Head;
+-	 * 	NDR_record_t NDR;
+-	 * 	kern_return_t RetCode;
+-	 * } mig_reply_error_t;
+-	 */
+-
+-	union {
+-		Request In;
+-		Reply Out;
+-	} Mess;
+-
+-	Request *InP = &Mess.In;
+-	Reply *Out0P = &Mess.Out;
+-
+-	mach_msg_return_t msg_result;
+-
+-#ifdef	__MIG_check__Reply__rpc_jack_set_freewheel_t__defined
+-	kern_return_t check_result;
+-#endif	/* __MIG_check__Reply__rpc_jack_set_freewheel_t__defined */
+-
+-	__DeclareSendRpc(1013, "rpc_jack_set_freewheel")
+-
+-	InP->NDR = NDR_record;
+-
+-	InP->onoff = onoff;
+-
+-	InP->Head.msgh_bits =
+-		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
+-	/* msgh_size passed as argument */
+-	InP->Head.msgh_request_port = server_port;
+-	InP->Head.msgh_reply_port = mig_get_reply_port();
+-	InP->Head.msgh_id = 1013;
+-
+-	__BeforeSendRpc(1013, "rpc_jack_set_freewheel")
+-	msg_result = mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, (mach_msg_size_t)sizeof(Request), (mach_msg_size_t)sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
+-	__AfterSendRpc(1013, "rpc_jack_set_freewheel")
+-	if (msg_result != MACH_MSG_SUCCESS) {
+-		__MachMsgErrorWithoutTimeout(msg_result);
+-		{ return msg_result; }
+-	}
+-
+-
+-#if	defined(__MIG_check__Reply__rpc_jack_set_freewheel_t__defined)
+-	check_result = __MIG_check__Reply__rpc_jack_set_freewheel_t((__Reply__rpc_jack_set_freewheel_t *)Out0P);
+-	if (check_result != MACH_MSG_SUCCESS)
+-		{ return check_result; }
+-#endif	/* defined(__MIG_check__Reply__rpc_jack_set_freewheel_t__defined) */
+-
+-	*result = Out0P->result;
+-
+-	return KERN_SUCCESS;
+-}
+-
+-#if ( __MigTypeCheck || __NDR_convert__ )
+-#if __MIG_check__Reply__JackRPCEngine_subsystem__
+-#if !defined(__MIG_check__Reply__rpc_jack_release_timebase_t__defined)
+-#define __MIG_check__Reply__rpc_jack_release_timebase_t__defined
+-#ifndef __NDR_convert__int_rep__Reply__rpc_jack_release_timebase_t__RetCode__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCEngine__kern_return_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_release_timebase_t__RetCode__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_release_timebase_t__RetCode(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__kern_return_t((kern_return_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__kern_return_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_release_timebase_t__RetCode__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_release_timebase_t__RetCode(a, f) \
+-	__NDR_convert__int_rep__kern_return_t((kern_return_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_release_timebase_t__RetCode__defined */
+-
+-
+-#ifndef __NDR_convert__int_rep__Reply__rpc_jack_release_timebase_t__result__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_release_timebase_t__result__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_release_timebase_t__result(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_release_timebase_t__result__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_release_timebase_t__result(a, f) \
+-	__NDR_convert__int_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_release_timebase_t__result__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_release_timebase_t__result(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int32_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_release_timebase_t__result__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_release_timebase_t__result(a, f) \
+-	__NDR_convert__int_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_release_timebase_t__result__defined */
+-
+-
+-
+-#ifndef __NDR_convert__char_rep__Reply__rpc_jack_release_timebase_t__result__defined
+-#if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_release_timebase_t__result__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_release_timebase_t__result(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_release_timebase_t__result__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_release_timebase_t__result(a, f) \
+-	__NDR_convert__char_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_release_timebase_t__result__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_release_timebase_t__result(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int32_t__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_release_timebase_t__result__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_release_timebase_t__result(a, f) \
+-	__NDR_convert__char_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__char_rep__Reply__rpc_jack_release_timebase_t__result__defined */
+-
+-
+-
+-#ifndef __NDR_convert__float_rep__Reply__rpc_jack_release_timebase_t__result__defined
+-#if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_release_timebase_t__result__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_release_timebase_t__result(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_release_timebase_t__result__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_release_timebase_t__result(a, f) \
+-	__NDR_convert__float_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_release_timebase_t__result__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_release_timebase_t__result(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int32_t__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_release_timebase_t__result__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_release_timebase_t__result(a, f) \
+-	__NDR_convert__float_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__float_rep__Reply__rpc_jack_release_timebase_t__result__defined */
+-
+-
+-
+-mig_internal kern_return_t __MIG_check__Reply__rpc_jack_release_timebase_t(__Reply__rpc_jack_release_timebase_t *Out0P)
+-{
+-
+-	typedef __Reply__rpc_jack_release_timebase_t __Reply;
+-#if	__MigTypeCheck
+-	unsigned int msgh_size;
+-#endif	/* __MigTypeCheck */
+-	if (Out0P->Head.msgh_id != 1114) {
+-	    if (Out0P->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
+-		{ return MIG_SERVER_DIED; }
+-	    else
+-		{ return MIG_REPLY_MISMATCH; }
+-	}
+-
+-#if	__MigTypeCheck
+-	msgh_size = Out0P->Head.msgh_size;
+-
+-	if ((Out0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
+-	    ((msgh_size != (mach_msg_size_t)sizeof(__Reply)) &&
+-	     (msgh_size != (mach_msg_size_t)sizeof(mig_reply_error_t) ||
+-	      Out0P->RetCode == KERN_SUCCESS)))
+-		{ return MIG_TYPE_ERROR ; }
+-#endif	/* __MigTypeCheck */
+-
+-	if (Out0P->RetCode != KERN_SUCCESS) {
+-#ifdef	__NDR_convert__mig_reply_error_t__defined
+-		__NDR_convert__mig_reply_error_t((mig_reply_error_t *)Out0P);
+-#endif	/* __NDR_convert__mig_reply_error_t__defined */
+-		return ((mig_reply_error_t *)Out0P)->RetCode;
+-	}
+-
+-#if	defined(__NDR_convert__int_rep__Reply__rpc_jack_release_timebase_t__RetCode__defined) || \
+-	defined(__NDR_convert__int_rep__Reply__rpc_jack_release_timebase_t__result__defined)
+-	if (Out0P->NDR.int_rep != NDR_record.int_rep) {
+-#if defined(__NDR_convert__int_rep__Reply__rpc_jack_release_timebase_t__RetCode__defined)
+-		__NDR_convert__int_rep__Reply__rpc_jack_release_timebase_t__RetCode(&Out0P->RetCode, Out0P->NDR.int_rep);
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_release_timebase_t__RetCode__defined */
+-#if defined(__NDR_convert__int_rep__Reply__rpc_jack_release_timebase_t__result__defined)
+-		__NDR_convert__int_rep__Reply__rpc_jack_release_timebase_t__result(&Out0P->result, Out0P->NDR.int_rep);
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_release_timebase_t__result__defined */
+-	}
+-#endif	/* defined(__NDR_convert__int_rep...) */
+-
+-#if	0 || \
+-	defined(__NDR_convert__char_rep__Reply__rpc_jack_release_timebase_t__result__defined)
+-	if (Out0P->NDR.char_rep != NDR_record.char_rep) {
+-#if defined(__NDR_convert__char_rep__Reply__rpc_jack_release_timebase_t__result__defined)
+-		__NDR_convert__char_rep__Reply__rpc_jack_release_timebase_t__result(&Out0P->result, Out0P->NDR.char_rep);
+-#endif /* __NDR_convert__char_rep__Reply__rpc_jack_release_timebase_t__result__defined */
+-	}
+-#endif	/* defined(__NDR_convert__char_rep...) */
+-
+-#if	0 || \
+-	defined(__NDR_convert__float_rep__Reply__rpc_jack_release_timebase_t__result__defined)
+-	if (Out0P->NDR.float_rep != NDR_record.float_rep) {
+-#if defined(__NDR_convert__float_rep__Reply__rpc_jack_release_timebase_t__result__defined)
+-		__NDR_convert__float_rep__Reply__rpc_jack_release_timebase_t__result(&Out0P->result, Out0P->NDR.float_rep);
+-#endif /* __NDR_convert__float_rep__Reply__rpc_jack_release_timebase_t__result__defined */
+-	}
+-#endif	/* defined(__NDR_convert__float_rep...) */
+-
+-	return MACH_MSG_SUCCESS;
+-}
+-#endif /* !defined(__MIG_check__Reply__rpc_jack_release_timebase_t__defined) */
+-#endif /* __MIG_check__Reply__JackRPCEngine_subsystem__ */
+-#endif /* ( __MigTypeCheck || __NDR_convert__ ) */
+-
+-
+-/* Routine rpc_jack_release_timebase */
+-mig_external kern_return_t rpc_jack_release_timebase
+-(
+-	mach_port_t server_port,
+-	int refnum,
+-	int *result
+-)
+-{
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		int refnum;
+-	} Request;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		kern_return_t RetCode;
+-		int result;
+-		mach_msg_trailer_t trailer;
+-	} Reply;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		kern_return_t RetCode;
+-		int result;
+-	} __Reply;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-	/*
+-	 * typedef struct {
+-	 * 	mach_msg_header_t Head;
+-	 * 	NDR_record_t NDR;
+-	 * 	kern_return_t RetCode;
+-	 * } mig_reply_error_t;
+-	 */
+-
+-	union {
+-		Request In;
+-		Reply Out;
+-	} Mess;
+-
+-	Request *InP = &Mess.In;
+-	Reply *Out0P = &Mess.Out;
+-
+-	mach_msg_return_t msg_result;
+-
+-#ifdef	__MIG_check__Reply__rpc_jack_release_timebase_t__defined
+-	kern_return_t check_result;
+-#endif	/* __MIG_check__Reply__rpc_jack_release_timebase_t__defined */
+-
+-	__DeclareSendRpc(1014, "rpc_jack_release_timebase")
+-
+-	InP->NDR = NDR_record;
+-
+-	InP->refnum = refnum;
+-
+-	InP->Head.msgh_bits =
+-		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
+-	/* msgh_size passed as argument */
+-	InP->Head.msgh_request_port = server_port;
+-	InP->Head.msgh_reply_port = mig_get_reply_port();
+-	InP->Head.msgh_id = 1014;
+-
+-	__BeforeSendRpc(1014, "rpc_jack_release_timebase")
+-	msg_result = mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, (mach_msg_size_t)sizeof(Request), (mach_msg_size_t)sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
+-	__AfterSendRpc(1014, "rpc_jack_release_timebase")
+-	if (msg_result != MACH_MSG_SUCCESS) {
+-		__MachMsgErrorWithoutTimeout(msg_result);
+-		{ return msg_result; }
+-	}
+-
+-
+-#if	defined(__MIG_check__Reply__rpc_jack_release_timebase_t__defined)
+-	check_result = __MIG_check__Reply__rpc_jack_release_timebase_t((__Reply__rpc_jack_release_timebase_t *)Out0P);
+-	if (check_result != MACH_MSG_SUCCESS)
+-		{ return check_result; }
+-#endif	/* defined(__MIG_check__Reply__rpc_jack_release_timebase_t__defined) */
+-
+-	*result = Out0P->result;
+-
+-	return KERN_SUCCESS;
+-}
+-
+-#if ( __MigTypeCheck || __NDR_convert__ )
+-#if __MIG_check__Reply__JackRPCEngine_subsystem__
+-#if !defined(__MIG_check__Reply__rpc_jack_set_timebase_callback_t__defined)
+-#define __MIG_check__Reply__rpc_jack_set_timebase_callback_t__defined
+-#ifndef __NDR_convert__int_rep__Reply__rpc_jack_set_timebase_callback_t__RetCode__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCEngine__kern_return_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_set_timebase_callback_t__RetCode__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_set_timebase_callback_t__RetCode(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__kern_return_t((kern_return_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__kern_return_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_set_timebase_callback_t__RetCode__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_set_timebase_callback_t__RetCode(a, f) \
+-	__NDR_convert__int_rep__kern_return_t((kern_return_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_set_timebase_callback_t__RetCode__defined */
+-
+-
+-#ifndef __NDR_convert__int_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_set_timebase_callback_t__result(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_set_timebase_callback_t__result(a, f) \
+-	__NDR_convert__int_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_set_timebase_callback_t__result(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int32_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_set_timebase_callback_t__result(a, f) \
+-	__NDR_convert__int_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined */
+-
+-
+-
+-#ifndef __NDR_convert__char_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined
+-#if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_set_timebase_callback_t__result(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_set_timebase_callback_t__result(a, f) \
+-	__NDR_convert__char_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_set_timebase_callback_t__result(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int32_t__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_set_timebase_callback_t__result(a, f) \
+-	__NDR_convert__char_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__char_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined */
+-
+-
+-
+-#ifndef __NDR_convert__float_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined
+-#if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_set_timebase_callback_t__result(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_set_timebase_callback_t__result(a, f) \
+-	__NDR_convert__float_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_set_timebase_callback_t__result(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int32_t__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_set_timebase_callback_t__result(a, f) \
+-	__NDR_convert__float_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__float_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined */
+-
+-
+-
+-mig_internal kern_return_t __MIG_check__Reply__rpc_jack_set_timebase_callback_t(__Reply__rpc_jack_set_timebase_callback_t *Out0P)
+-{
+-
+-	typedef __Reply__rpc_jack_set_timebase_callback_t __Reply;
+-#if	__MigTypeCheck
+-	unsigned int msgh_size;
+-#endif	/* __MigTypeCheck */
+-	if (Out0P->Head.msgh_id != 1115) {
+-	    if (Out0P->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
+-		{ return MIG_SERVER_DIED; }
+-	    else
+-		{ return MIG_REPLY_MISMATCH; }
+-	}
+-
+-#if	__MigTypeCheck
+-	msgh_size = Out0P->Head.msgh_size;
+-
+-	if ((Out0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
+-	    ((msgh_size != (mach_msg_size_t)sizeof(__Reply)) &&
+-	     (msgh_size != (mach_msg_size_t)sizeof(mig_reply_error_t) ||
+-	      Out0P->RetCode == KERN_SUCCESS)))
+-		{ return MIG_TYPE_ERROR ; }
+-#endif	/* __MigTypeCheck */
+-
+-	if (Out0P->RetCode != KERN_SUCCESS) {
+-#ifdef	__NDR_convert__mig_reply_error_t__defined
+-		__NDR_convert__mig_reply_error_t((mig_reply_error_t *)Out0P);
+-#endif	/* __NDR_convert__mig_reply_error_t__defined */
+-		return ((mig_reply_error_t *)Out0P)->RetCode;
+-	}
+-
+-#if	defined(__NDR_convert__int_rep__Reply__rpc_jack_set_timebase_callback_t__RetCode__defined) || \
+-	defined(__NDR_convert__int_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined)
+-	if (Out0P->NDR.int_rep != NDR_record.int_rep) {
+-#if defined(__NDR_convert__int_rep__Reply__rpc_jack_set_timebase_callback_t__RetCode__defined)
+-		__NDR_convert__int_rep__Reply__rpc_jack_set_timebase_callback_t__RetCode(&Out0P->RetCode, Out0P->NDR.int_rep);
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_set_timebase_callback_t__RetCode__defined */
+-#if defined(__NDR_convert__int_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined)
+-		__NDR_convert__int_rep__Reply__rpc_jack_set_timebase_callback_t__result(&Out0P->result, Out0P->NDR.int_rep);
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined */
+-	}
+-#endif	/* defined(__NDR_convert__int_rep...) */
+-
+-#if	0 || \
+-	defined(__NDR_convert__char_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined)
+-	if (Out0P->NDR.char_rep != NDR_record.char_rep) {
+-#if defined(__NDR_convert__char_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined)
+-		__NDR_convert__char_rep__Reply__rpc_jack_set_timebase_callback_t__result(&Out0P->result, Out0P->NDR.char_rep);
+-#endif /* __NDR_convert__char_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined */
+-	}
+-#endif	/* defined(__NDR_convert__char_rep...) */
+-
+-#if	0 || \
+-	defined(__NDR_convert__float_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined)
+-	if (Out0P->NDR.float_rep != NDR_record.float_rep) {
+-#if defined(__NDR_convert__float_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined)
+-		__NDR_convert__float_rep__Reply__rpc_jack_set_timebase_callback_t__result(&Out0P->result, Out0P->NDR.float_rep);
+-#endif /* __NDR_convert__float_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined */
+-	}
+-#endif	/* defined(__NDR_convert__float_rep...) */
+-
+-	return MACH_MSG_SUCCESS;
+-}
+-#endif /* !defined(__MIG_check__Reply__rpc_jack_set_timebase_callback_t__defined) */
+-#endif /* __MIG_check__Reply__JackRPCEngine_subsystem__ */
+-#endif /* ( __MigTypeCheck || __NDR_convert__ ) */
+-
+-
+-/* Routine rpc_jack_set_timebase_callback */
+-mig_external kern_return_t rpc_jack_set_timebase_callback
+-(
+-	mach_port_t server_port,
+-	int refnum,
+-	int conditional,
+-	int *result
+-)
+-{
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		int refnum;
+-		int conditional;
+-	} Request;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		kern_return_t RetCode;
+-		int result;
+-		mach_msg_trailer_t trailer;
+-	} Reply;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		kern_return_t RetCode;
+-		int result;
+-	} __Reply;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-	/*
+-	 * typedef struct {
+-	 * 	mach_msg_header_t Head;
+-	 * 	NDR_record_t NDR;
+-	 * 	kern_return_t RetCode;
+-	 * } mig_reply_error_t;
+-	 */
+-
+-	union {
+-		Request In;
+-		Reply Out;
+-	} Mess;
+-
+-	Request *InP = &Mess.In;
+-	Reply *Out0P = &Mess.Out;
+-
+-	mach_msg_return_t msg_result;
+-
+-#ifdef	__MIG_check__Reply__rpc_jack_set_timebase_callback_t__defined
+-	kern_return_t check_result;
+-#endif	/* __MIG_check__Reply__rpc_jack_set_timebase_callback_t__defined */
+-
+-	__DeclareSendRpc(1015, "rpc_jack_set_timebase_callback")
+-
+-	InP->NDR = NDR_record;
+-
+-	InP->refnum = refnum;
+-
+-	InP->conditional = conditional;
+-
+-	InP->Head.msgh_bits =
+-		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
+-	/* msgh_size passed as argument */
+-	InP->Head.msgh_request_port = server_port;
+-	InP->Head.msgh_reply_port = mig_get_reply_port();
+-	InP->Head.msgh_id = 1015;
+-
+-	__BeforeSendRpc(1015, "rpc_jack_set_timebase_callback")
+-	msg_result = mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, (mach_msg_size_t)sizeof(Request), (mach_msg_size_t)sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
+-	__AfterSendRpc(1015, "rpc_jack_set_timebase_callback")
+-	if (msg_result != MACH_MSG_SUCCESS) {
+-		__MachMsgErrorWithoutTimeout(msg_result);
+-		{ return msg_result; }
+-	}
+-
+-
+-#if	defined(__MIG_check__Reply__rpc_jack_set_timebase_callback_t__defined)
+-	check_result = __MIG_check__Reply__rpc_jack_set_timebase_callback_t((__Reply__rpc_jack_set_timebase_callback_t *)Out0P);
+-	if (check_result != MACH_MSG_SUCCESS)
+-		{ return check_result; }
+-#endif	/* defined(__MIG_check__Reply__rpc_jack_set_timebase_callback_t__defined) */
+-
+-	*result = Out0P->result;
+-
+-	return KERN_SUCCESS;
+-}
+-
+-#if ( __MigTypeCheck || __NDR_convert__ )
+-#if __MIG_check__Reply__JackRPCEngine_subsystem__
+-#if !defined(__MIG_check__Reply__rpc_jack_get_internal_clientname_t__defined)
+-#define __MIG_check__Reply__rpc_jack_get_internal_clientname_t__defined
+-#ifndef __NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__RetCode__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCEngine__kern_return_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__RetCode__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__RetCode(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__kern_return_t((kern_return_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__kern_return_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__RetCode__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__RetCode(a, f) \
+-	__NDR_convert__int_rep__kern_return_t((kern_return_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__RetCode__defined */
+-
+-
+-#ifndef __NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCEngine__client_name_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__client_name_t((client_name_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__client_name_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res(a, f) \
+-	__NDR_convert__int_rep__client_name_t((client_name_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__JackRPCEngine__string__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__string(a, f, 64)
+-#elif	defined(__NDR_convert__int_rep__string__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res(a, f) \
+-	__NDR_convert__int_rep__string(a, f, 64)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res__defined */
+-
+-
+-#ifndef __NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__result__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__result__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__result(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__result__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__result(a, f) \
+-	__NDR_convert__int_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__result__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__result(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int32_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__result__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__result(a, f) \
+-	__NDR_convert__int_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__result__defined */
+-
+-
+-
+-#ifndef __NDR_convert__char_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res__defined
+-#if	defined(__NDR_convert__char_rep__JackRPCEngine__client_name_t__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__client_name_t((client_name_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__client_name_t__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res(a, f) \
+-	__NDR_convert__char_rep__client_name_t((client_name_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__JackRPCEngine__string__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__string(a, f, 64)
+-#elif	defined(__NDR_convert__char_rep__string__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res(a, f) \
+-	__NDR_convert__char_rep__string(a, f, 64)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__char_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res__defined */
+-
+-
+-#ifndef __NDR_convert__char_rep__Reply__rpc_jack_get_internal_clientname_t__result__defined
+-#if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_get_internal_clientname_t__result__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_get_internal_clientname_t__result(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_get_internal_clientname_t__result__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_get_internal_clientname_t__result(a, f) \
+-	__NDR_convert__char_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_get_internal_clientname_t__result__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_get_internal_clientname_t__result(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int32_t__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_get_internal_clientname_t__result__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_get_internal_clientname_t__result(a, f) \
+-	__NDR_convert__char_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__char_rep__Reply__rpc_jack_get_internal_clientname_t__result__defined */
+-
+-
+-
+-#ifndef __NDR_convert__float_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res__defined
+-#if	defined(__NDR_convert__float_rep__JackRPCEngine__client_name_t__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__client_name_t((client_name_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__client_name_t__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res(a, f) \
+-	__NDR_convert__float_rep__client_name_t((client_name_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__JackRPCEngine__string__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__string(a, f, 64)
+-#elif	defined(__NDR_convert__float_rep__string__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res(a, f) \
+-	__NDR_convert__float_rep__string(a, f, 64)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__float_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res__defined */
+-
+-
+-#ifndef __NDR_convert__float_rep__Reply__rpc_jack_get_internal_clientname_t__result__defined
+-#if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_get_internal_clientname_t__result__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_get_internal_clientname_t__result(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_get_internal_clientname_t__result__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_get_internal_clientname_t__result(a, f) \
+-	__NDR_convert__float_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_get_internal_clientname_t__result__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_get_internal_clientname_t__result(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int32_t__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_get_internal_clientname_t__result__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_get_internal_clientname_t__result(a, f) \
+-	__NDR_convert__float_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__float_rep__Reply__rpc_jack_get_internal_clientname_t__result__defined */
+-
+-
+-
+-mig_internal kern_return_t __MIG_check__Reply__rpc_jack_get_internal_clientname_t(__Reply__rpc_jack_get_internal_clientname_t *Out0P)
+-{
+-
+-	typedef __Reply__rpc_jack_get_internal_clientname_t __Reply;
+-#if	__MigTypeCheck
+-	unsigned int msgh_size;
+-#endif	/* __MigTypeCheck */
+-	if (Out0P->Head.msgh_id != 1116) {
+-	    if (Out0P->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
+-		{ return MIG_SERVER_DIED; }
+-	    else
+-		{ return MIG_REPLY_MISMATCH; }
+-	}
+-
+-#if	__MigTypeCheck
+-	msgh_size = Out0P->Head.msgh_size;
+-
+-	if ((Out0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
+-	    ((msgh_size != (mach_msg_size_t)sizeof(__Reply)) &&
+-	     (msgh_size != (mach_msg_size_t)sizeof(mig_reply_error_t) ||
+-	      Out0P->RetCode == KERN_SUCCESS)))
+-		{ return MIG_TYPE_ERROR ; }
+-#endif	/* __MigTypeCheck */
+-
+-	if (Out0P->RetCode != KERN_SUCCESS) {
+-#ifdef	__NDR_convert__mig_reply_error_t__defined
+-		__NDR_convert__mig_reply_error_t((mig_reply_error_t *)Out0P);
+-#endif	/* __NDR_convert__mig_reply_error_t__defined */
+-		return ((mig_reply_error_t *)Out0P)->RetCode;
+-	}
+-
+-#if	defined(__NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__RetCode__defined) || \
+-	defined(__NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res__defined) || \
+-	defined(__NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__result__defined)
+-	if (Out0P->NDR.int_rep != NDR_record.int_rep) {
+-#if defined(__NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__RetCode__defined)
+-		__NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__RetCode(&Out0P->RetCode, Out0P->NDR.int_rep);
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__RetCode__defined */
+-#if defined(__NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res__defined)
+-		__NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res(&Out0P->client_name_res, Out0P->NDR.int_rep);
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res__defined */
+-#if defined(__NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__result__defined)
+-		__NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__result(&Out0P->result, Out0P->NDR.int_rep);
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__result__defined */
+-	}
+-#endif	/* defined(__NDR_convert__int_rep...) */
+-
+-#if	0 || \
+-	defined(__NDR_convert__char_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res__defined) || \
+-	defined(__NDR_convert__char_rep__Reply__rpc_jack_get_internal_clientname_t__result__defined)
+-	if (Out0P->NDR.char_rep != NDR_record.char_rep) {
+-#if defined(__NDR_convert__char_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res__defined)
+-		__NDR_convert__char_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res(&Out0P->client_name_res, Out0P->NDR.char_rep);
+-#endif /* __NDR_convert__char_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res__defined */
+-#if defined(__NDR_convert__char_rep__Reply__rpc_jack_get_internal_clientname_t__result__defined)
+-		__NDR_convert__char_rep__Reply__rpc_jack_get_internal_clientname_t__result(&Out0P->result, Out0P->NDR.char_rep);
+-#endif /* __NDR_convert__char_rep__Reply__rpc_jack_get_internal_clientname_t__result__defined */
+-	}
+-#endif	/* defined(__NDR_convert__char_rep...) */
+-
+-#if	0 || \
+-	defined(__NDR_convert__float_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res__defined) || \
+-	defined(__NDR_convert__float_rep__Reply__rpc_jack_get_internal_clientname_t__result__defined)
+-	if (Out0P->NDR.float_rep != NDR_record.float_rep) {
+-#if defined(__NDR_convert__float_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res__defined)
+-		__NDR_convert__float_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res(&Out0P->client_name_res, Out0P->NDR.float_rep);
+-#endif /* __NDR_convert__float_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res__defined */
+-#if defined(__NDR_convert__float_rep__Reply__rpc_jack_get_internal_clientname_t__result__defined)
+-		__NDR_convert__float_rep__Reply__rpc_jack_get_internal_clientname_t__result(&Out0P->result, Out0P->NDR.float_rep);
+-#endif /* __NDR_convert__float_rep__Reply__rpc_jack_get_internal_clientname_t__result__defined */
+-	}
+-#endif	/* defined(__NDR_convert__float_rep...) */
+-
+-	return MACH_MSG_SUCCESS;
+-}
+-#endif /* !defined(__MIG_check__Reply__rpc_jack_get_internal_clientname_t__defined) */
+-#endif /* __MIG_check__Reply__JackRPCEngine_subsystem__ */
+-#endif /* ( __MigTypeCheck || __NDR_convert__ ) */
+-
+-
+-/* Routine rpc_jack_get_internal_clientname */
+-mig_external kern_return_t rpc_jack_get_internal_clientname
+-(
+-	mach_port_t server_port,
+-	int refnum,
+-	int int_ref,
+-	client_name_t client_name_res,
+-	int *result
+-)
+-{
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		int refnum;
+-		int int_ref;
+-	} Request;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		kern_return_t RetCode;
+-		client_name_t client_name_res;
+-		int result;
+-		mach_msg_trailer_t trailer;
+-	} Reply;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		kern_return_t RetCode;
+-		client_name_t client_name_res;
+-		int result;
+-	} __Reply;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-	/*
+-	 * typedef struct {
+-	 * 	mach_msg_header_t Head;
+-	 * 	NDR_record_t NDR;
+-	 * 	kern_return_t RetCode;
+-	 * } mig_reply_error_t;
+-	 */
+-
+-	union {
+-		Request In;
+-		Reply Out;
+-	} Mess;
+-
+-	Request *InP = &Mess.In;
+-	Reply *Out0P = &Mess.Out;
+-
+-	mach_msg_return_t msg_result;
+-
+-#ifdef	__MIG_check__Reply__rpc_jack_get_internal_clientname_t__defined
+-	kern_return_t check_result;
+-#endif	/* __MIG_check__Reply__rpc_jack_get_internal_clientname_t__defined */
+-
+-	__DeclareSendRpc(1016, "rpc_jack_get_internal_clientname")
+-
+-	InP->NDR = NDR_record;
+-
+-	InP->refnum = refnum;
+-
+-	InP->int_ref = int_ref;
+-
+-	InP->Head.msgh_bits =
+-		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
+-	/* msgh_size passed as argument */
+-	InP->Head.msgh_request_port = server_port;
+-	InP->Head.msgh_reply_port = mig_get_reply_port();
+-	InP->Head.msgh_id = 1016;
+-
+-	__BeforeSendRpc(1016, "rpc_jack_get_internal_clientname")
+-	msg_result = mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, (mach_msg_size_t)sizeof(Request), (mach_msg_size_t)sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
+-	__AfterSendRpc(1016, "rpc_jack_get_internal_clientname")
+-	if (msg_result != MACH_MSG_SUCCESS) {
+-		__MachMsgErrorWithoutTimeout(msg_result);
+-		{ return msg_result; }
+-	}
+-
+-
+-#if	defined(__MIG_check__Reply__rpc_jack_get_internal_clientname_t__defined)
+-	check_result = __MIG_check__Reply__rpc_jack_get_internal_clientname_t((__Reply__rpc_jack_get_internal_clientname_t *)Out0P);
+-	if (check_result != MACH_MSG_SUCCESS)
+-		{ return check_result; }
+-#endif	/* defined(__MIG_check__Reply__rpc_jack_get_internal_clientname_t__defined) */
+-
+-	(void) mig_strncpy(client_name_res, Out0P->client_name_res, 64);
+-
+-	*result = Out0P->result;
+-
+-	return KERN_SUCCESS;
+-}
+-
+-#if ( __MigTypeCheck || __NDR_convert__ )
+-#if __MIG_check__Reply__JackRPCEngine_subsystem__
+-#if !defined(__MIG_check__Reply__rpc_jack_internal_clienthandle_t__defined)
+-#define __MIG_check__Reply__rpc_jack_internal_clienthandle_t__defined
+-#ifndef __NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__RetCode__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCEngine__kern_return_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__RetCode__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__RetCode(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__kern_return_t((kern_return_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__kern_return_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__RetCode__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__RetCode(a, f) \
+-	__NDR_convert__int_rep__kern_return_t((kern_return_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__RetCode__defined */
+-
+-
+-#ifndef __NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref(a, f) \
+-	__NDR_convert__int_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int32_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref(a, f) \
+-	__NDR_convert__int_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref__defined */
+-
+-
+-#ifndef __NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__status__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__status__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__status(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__status__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__status(a, f) \
+-	__NDR_convert__int_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__status__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__status(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int32_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__status__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__status(a, f) \
+-	__NDR_convert__int_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__status__defined */
+-
+-
+-#ifndef __NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__result__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__result__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__result(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__result__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__result(a, f) \
+-	__NDR_convert__int_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__result__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__result(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int32_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__result__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__result(a, f) \
+-	__NDR_convert__int_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__result__defined */
+-
+-
+-
+-#ifndef __NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref__defined
+-#if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref(a, f) \
+-	__NDR_convert__char_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int32_t__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref(a, f) \
+-	__NDR_convert__char_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref__defined */
+-
+-
+-#ifndef __NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__status__defined
+-#if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__status__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__status(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__status__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__status(a, f) \
+-	__NDR_convert__char_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__status__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__status(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int32_t__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__status__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__status(a, f) \
+-	__NDR_convert__char_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__status__defined */
+-
+-
+-#ifndef __NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__result__defined
+-#if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__result__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__result(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__result__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__result(a, f) \
+-	__NDR_convert__char_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__result__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__result(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int32_t__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__result__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__result(a, f) \
+-	__NDR_convert__char_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__result__defined */
+-
+-
+-
+-#ifndef __NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref__defined
+-#if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref(a, f) \
+-	__NDR_convert__float_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int32_t__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref(a, f) \
+-	__NDR_convert__float_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref__defined */
+-
+-
+-#ifndef __NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__status__defined
+-#if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__status__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__status(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__status__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__status(a, f) \
+-	__NDR_convert__float_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__status__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__status(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int32_t__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__status__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__status(a, f) \
+-	__NDR_convert__float_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__status__defined */
+-
+-
+-#ifndef __NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__result__defined
+-#if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__result__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__result(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__result__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__result(a, f) \
+-	__NDR_convert__float_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__result__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__result(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int32_t__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__result__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__result(a, f) \
+-	__NDR_convert__float_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__result__defined */
+-
+-
+-
+-mig_internal kern_return_t __MIG_check__Reply__rpc_jack_internal_clienthandle_t(__Reply__rpc_jack_internal_clienthandle_t *Out0P)
+-{
+-
+-	typedef __Reply__rpc_jack_internal_clienthandle_t __Reply;
+-#if	__MigTypeCheck
+-	unsigned int msgh_size;
+-#endif	/* __MigTypeCheck */
+-	if (Out0P->Head.msgh_id != 1117) {
+-	    if (Out0P->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
+-		{ return MIG_SERVER_DIED; }
+-	    else
+-		{ return MIG_REPLY_MISMATCH; }
+-	}
+-
+-#if	__MigTypeCheck
+-	msgh_size = Out0P->Head.msgh_size;
+-
+-	if ((Out0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
+-	    ((msgh_size != (mach_msg_size_t)sizeof(__Reply)) &&
+-	     (msgh_size != (mach_msg_size_t)sizeof(mig_reply_error_t) ||
+-	      Out0P->RetCode == KERN_SUCCESS)))
+-		{ return MIG_TYPE_ERROR ; }
+-#endif	/* __MigTypeCheck */
+-
+-	if (Out0P->RetCode != KERN_SUCCESS) {
+-#ifdef	__NDR_convert__mig_reply_error_t__defined
+-		__NDR_convert__mig_reply_error_t((mig_reply_error_t *)Out0P);
+-#endif	/* __NDR_convert__mig_reply_error_t__defined */
+-		return ((mig_reply_error_t *)Out0P)->RetCode;
+-	}
+-
+-#if	defined(__NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__RetCode__defined) || \
+-	defined(__NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref__defined) || \
+-	defined(__NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__status__defined) || \
+-	defined(__NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__result__defined)
+-	if (Out0P->NDR.int_rep != NDR_record.int_rep) {
+-#if defined(__NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__RetCode__defined)
+-		__NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__RetCode(&Out0P->RetCode, Out0P->NDR.int_rep);
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__RetCode__defined */
+-#if defined(__NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref__defined)
+-		__NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref(&Out0P->int_ref, Out0P->NDR.int_rep);
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref__defined */
+-#if defined(__NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__status__defined)
+-		__NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__status(&Out0P->status, Out0P->NDR.int_rep);
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__status__defined */
+-#if defined(__NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__result__defined)
+-		__NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__result(&Out0P->result, Out0P->NDR.int_rep);
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__result__defined */
+-	}
+-#endif	/* defined(__NDR_convert__int_rep...) */
+-
+-#if	0 || \
+-	defined(__NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref__defined) || \
+-	defined(__NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__status__defined) || \
+-	defined(__NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__result__defined)
+-	if (Out0P->NDR.char_rep != NDR_record.char_rep) {
+-#if defined(__NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref__defined)
+-		__NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref(&Out0P->int_ref, Out0P->NDR.char_rep);
+-#endif /* __NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref__defined */
+-#if defined(__NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__status__defined)
+-		__NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__status(&Out0P->status, Out0P->NDR.char_rep);
+-#endif /* __NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__status__defined */
+-#if defined(__NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__result__defined)
+-		__NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__result(&Out0P->result, Out0P->NDR.char_rep);
+-#endif /* __NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__result__defined */
+-	}
+-#endif	/* defined(__NDR_convert__char_rep...) */
+-
+-#if	0 || \
+-	defined(__NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref__defined) || \
+-	defined(__NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__status__defined) || \
+-	defined(__NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__result__defined)
+-	if (Out0P->NDR.float_rep != NDR_record.float_rep) {
+-#if defined(__NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref__defined)
+-		__NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref(&Out0P->int_ref, Out0P->NDR.float_rep);
+-#endif /* __NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref__defined */
+-#if defined(__NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__status__defined)
+-		__NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__status(&Out0P->status, Out0P->NDR.float_rep);
+-#endif /* __NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__status__defined */
+-#if defined(__NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__result__defined)
+-		__NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__result(&Out0P->result, Out0P->NDR.float_rep);
+-#endif /* __NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__result__defined */
+-	}
+-#endif	/* defined(__NDR_convert__float_rep...) */
+-
+-	return MACH_MSG_SUCCESS;
+-}
+-#endif /* !defined(__MIG_check__Reply__rpc_jack_internal_clienthandle_t__defined) */
+-#endif /* __MIG_check__Reply__JackRPCEngine_subsystem__ */
+-#endif /* ( __MigTypeCheck || __NDR_convert__ ) */
+-
+-
+-/* Routine rpc_jack_internal_clienthandle */
+-mig_external kern_return_t rpc_jack_internal_clienthandle
+-(
+-	mach_port_t server_port,
+-	int refnum,
+-	client_name_t client_name,
+-	int *int_ref,
+-	int *status,
+-	int *result
+-)
+-{
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		int refnum;
+-		client_name_t client_name;
+-	} Request;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		kern_return_t RetCode;
+-		int int_ref;
+-		int status;
+-		int result;
+-		mach_msg_trailer_t trailer;
+-	} Reply;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		kern_return_t RetCode;
+-		int int_ref;
+-		int status;
+-		int result;
+-	} __Reply;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-	/*
+-	 * typedef struct {
+-	 * 	mach_msg_header_t Head;
+-	 * 	NDR_record_t NDR;
+-	 * 	kern_return_t RetCode;
+-	 * } mig_reply_error_t;
+-	 */
+-
+-	union {
+-		Request In;
+-		Reply Out;
+-	} Mess;
+-
+-	Request *InP = &Mess.In;
+-	Reply *Out0P = &Mess.Out;
+-
+-	mach_msg_return_t msg_result;
+-
+-#ifdef	__MIG_check__Reply__rpc_jack_internal_clienthandle_t__defined
+-	kern_return_t check_result;
+-#endif	/* __MIG_check__Reply__rpc_jack_internal_clienthandle_t__defined */
+-
+-	__DeclareSendRpc(1017, "rpc_jack_internal_clienthandle")
+-
+-	InP->NDR = NDR_record;
+-
+-	InP->refnum = refnum;
+-
+-	(void) mig_strncpy(InP->client_name, client_name, 64);
+-
+-	InP->Head.msgh_bits =
+-		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
+-	/* msgh_size passed as argument */
+-	InP->Head.msgh_request_port = server_port;
+-	InP->Head.msgh_reply_port = mig_get_reply_port();
+-	InP->Head.msgh_id = 1017;
+-
+-	__BeforeSendRpc(1017, "rpc_jack_internal_clienthandle")
+-	msg_result = mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, (mach_msg_size_t)sizeof(Request), (mach_msg_size_t)sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
+-	__AfterSendRpc(1017, "rpc_jack_internal_clienthandle")
+-	if (msg_result != MACH_MSG_SUCCESS) {
+-		__MachMsgErrorWithoutTimeout(msg_result);
+-		{ return msg_result; }
+-	}
+-
+-
+-#if	defined(__MIG_check__Reply__rpc_jack_internal_clienthandle_t__defined)
+-	check_result = __MIG_check__Reply__rpc_jack_internal_clienthandle_t((__Reply__rpc_jack_internal_clienthandle_t *)Out0P);
+-	if (check_result != MACH_MSG_SUCCESS)
+-		{ return check_result; }
+-#endif	/* defined(__MIG_check__Reply__rpc_jack_internal_clienthandle_t__defined) */
+-
+-	*int_ref = Out0P->int_ref;
+-
+-	*status = Out0P->status;
+-
+-	*result = Out0P->result;
+-
+-	return KERN_SUCCESS;
+-}
+-
+-#if ( __MigTypeCheck || __NDR_convert__ )
+-#if __MIG_check__Reply__JackRPCEngine_subsystem__
+-#if !defined(__MIG_check__Reply__rpc_jack_internal_clientload_t__defined)
+-#define __MIG_check__Reply__rpc_jack_internal_clientload_t__defined
+-#ifndef __NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__RetCode__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCEngine__kern_return_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__RetCode__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__RetCode(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__kern_return_t((kern_return_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__kern_return_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__RetCode__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__RetCode(a, f) \
+-	__NDR_convert__int_rep__kern_return_t((kern_return_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__RetCode__defined */
+-
+-
+-#ifndef __NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__status__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__status__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__status(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__status__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__status(a, f) \
+-	__NDR_convert__int_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__status__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__status(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int32_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__status__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__status(a, f) \
+-	__NDR_convert__int_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__status__defined */
+-
+-
+-#ifndef __NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__int_ref__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__int_ref__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__int_ref(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__int_ref__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__int_ref(a, f) \
+-	__NDR_convert__int_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__int_ref__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__int_ref(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int32_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__int_ref__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__int_ref(a, f) \
+-	__NDR_convert__int_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__int_ref__defined */
+-
+-
+-#ifndef __NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__result__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__result__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__result(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__result__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__result(a, f) \
+-	__NDR_convert__int_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__result__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__result(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int32_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__result__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__result(a, f) \
+-	__NDR_convert__int_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__result__defined */
+-
+-
+-
+-#ifndef __NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__status__defined
+-#if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__status__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__status(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__status__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__status(a, f) \
+-	__NDR_convert__char_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__status__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__status(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int32_t__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__status__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__status(a, f) \
+-	__NDR_convert__char_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__status__defined */
+-
+-
+-#ifndef __NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__int_ref__defined
+-#if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__int_ref__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__int_ref(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__int_ref__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__int_ref(a, f) \
+-	__NDR_convert__char_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__int_ref__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__int_ref(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int32_t__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__int_ref__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__int_ref(a, f) \
+-	__NDR_convert__char_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__int_ref__defined */
+-
+-
+-#ifndef __NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__result__defined
+-#if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__result__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__result(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__result__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__result(a, f) \
+-	__NDR_convert__char_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__result__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__result(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int32_t__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__result__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__result(a, f) \
+-	__NDR_convert__char_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__result__defined */
+-
+-
+-
+-#ifndef __NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__status__defined
+-#if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__status__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__status(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__status__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__status(a, f) \
+-	__NDR_convert__float_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__status__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__status(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int32_t__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__status__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__status(a, f) \
+-	__NDR_convert__float_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__status__defined */
+-
+-
+-#ifndef __NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__int_ref__defined
+-#if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__int_ref__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__int_ref(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__int_ref__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__int_ref(a, f) \
+-	__NDR_convert__float_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__int_ref__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__int_ref(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int32_t__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__int_ref__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__int_ref(a, f) \
+-	__NDR_convert__float_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__int_ref__defined */
+-
+-
+-#ifndef __NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__result__defined
+-#if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__result__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__result(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__result__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__result(a, f) \
+-	__NDR_convert__float_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__result__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__result(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int32_t__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__result__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__result(a, f) \
+-	__NDR_convert__float_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__result__defined */
+-
+-
+-
+-mig_internal kern_return_t __MIG_check__Reply__rpc_jack_internal_clientload_t(__Reply__rpc_jack_internal_clientload_t *Out0P)
+-{
+-
+-	typedef __Reply__rpc_jack_internal_clientload_t __Reply;
+-#if	__MigTypeCheck
+-	unsigned int msgh_size;
+-#endif	/* __MigTypeCheck */
+-	if (Out0P->Head.msgh_id != 1118) {
+-	    if (Out0P->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
+-		{ return MIG_SERVER_DIED; }
+-	    else
+-		{ return MIG_REPLY_MISMATCH; }
+-	}
+-
+-#if	__MigTypeCheck
+-	msgh_size = Out0P->Head.msgh_size;
+-
+-	if ((Out0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
+-	    ((msgh_size != (mach_msg_size_t)sizeof(__Reply)) &&
+-	     (msgh_size != (mach_msg_size_t)sizeof(mig_reply_error_t) ||
+-	      Out0P->RetCode == KERN_SUCCESS)))
+-		{ return MIG_TYPE_ERROR ; }
+-#endif	/* __MigTypeCheck */
+-
+-	if (Out0P->RetCode != KERN_SUCCESS) {
+-#ifdef	__NDR_convert__mig_reply_error_t__defined
+-		__NDR_convert__mig_reply_error_t((mig_reply_error_t *)Out0P);
+-#endif	/* __NDR_convert__mig_reply_error_t__defined */
+-		return ((mig_reply_error_t *)Out0P)->RetCode;
+-	}
+-
+-#if	defined(__NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__RetCode__defined) || \
+-	defined(__NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__status__defined) || \
+-	defined(__NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__int_ref__defined) || \
+-	defined(__NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__result__defined)
+-	if (Out0P->NDR.int_rep != NDR_record.int_rep) {
+-#if defined(__NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__RetCode__defined)
+-		__NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__RetCode(&Out0P->RetCode, Out0P->NDR.int_rep);
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__RetCode__defined */
+-#if defined(__NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__status__defined)
+-		__NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__status(&Out0P->status, Out0P->NDR.int_rep);
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__status__defined */
+-#if defined(__NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__int_ref__defined)
+-		__NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__int_ref(&Out0P->int_ref, Out0P->NDR.int_rep);
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__int_ref__defined */
+-#if defined(__NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__result__defined)
+-		__NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__result(&Out0P->result, Out0P->NDR.int_rep);
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__result__defined */
+-	}
+-#endif	/* defined(__NDR_convert__int_rep...) */
+-
+-#if	0 || \
+-	defined(__NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__status__defined) || \
+-	defined(__NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__int_ref__defined) || \
+-	defined(__NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__result__defined)
+-	if (Out0P->NDR.char_rep != NDR_record.char_rep) {
+-#if defined(__NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__status__defined)
+-		__NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__status(&Out0P->status, Out0P->NDR.char_rep);
+-#endif /* __NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__status__defined */
+-#if defined(__NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__int_ref__defined)
+-		__NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__int_ref(&Out0P->int_ref, Out0P->NDR.char_rep);
+-#endif /* __NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__int_ref__defined */
+-#if defined(__NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__result__defined)
+-		__NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__result(&Out0P->result, Out0P->NDR.char_rep);
+-#endif /* __NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__result__defined */
+-	}
+-#endif	/* defined(__NDR_convert__char_rep...) */
+-
+-#if	0 || \
+-	defined(__NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__status__defined) || \
+-	defined(__NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__int_ref__defined) || \
+-	defined(__NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__result__defined)
+-	if (Out0P->NDR.float_rep != NDR_record.float_rep) {
+-#if defined(__NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__status__defined)
+-		__NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__status(&Out0P->status, Out0P->NDR.float_rep);
+-#endif /* __NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__status__defined */
+-#if defined(__NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__int_ref__defined)
+-		__NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__int_ref(&Out0P->int_ref, Out0P->NDR.float_rep);
+-#endif /* __NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__int_ref__defined */
+-#if defined(__NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__result__defined)
+-		__NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__result(&Out0P->result, Out0P->NDR.float_rep);
+-#endif /* __NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__result__defined */
+-	}
+-#endif	/* defined(__NDR_convert__float_rep...) */
+-
+-	return MACH_MSG_SUCCESS;
+-}
+-#endif /* !defined(__MIG_check__Reply__rpc_jack_internal_clientload_t__defined) */
+-#endif /* __MIG_check__Reply__JackRPCEngine_subsystem__ */
+-#endif /* ( __MigTypeCheck || __NDR_convert__ ) */
+-
+-
+-/* Routine rpc_jack_internal_clientload */
+-mig_external kern_return_t rpc_jack_internal_clientload
+-(
+-	mach_port_t server_port,
+-	int refnum,
+-	client_name_t client_name,
+-	so_name_t so_name,
+-	objet_data_t objet_data,
+-	int options,
+-	int *status,
+-	int *int_ref,
+-	int *result
+-)
+-{
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		int refnum;
+-		client_name_t client_name;
+-		so_name_t so_name;
+-		objet_data_t objet_data;
+-		int options;
+-	} Request;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		kern_return_t RetCode;
+-		int status;
+-		int int_ref;
+-		int result;
+-		mach_msg_trailer_t trailer;
+-	} Reply;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		kern_return_t RetCode;
+-		int status;
+-		int int_ref;
+-		int result;
+-	} __Reply;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-	/*
+-	 * typedef struct {
+-	 * 	mach_msg_header_t Head;
+-	 * 	NDR_record_t NDR;
+-	 * 	kern_return_t RetCode;
+-	 * } mig_reply_error_t;
+-	 */
+-
+-	union {
+-		Request In;
+-		Reply Out;
+-	} Mess;
+-
+-	Request *InP = &Mess.In;
+-	Reply *Out0P = &Mess.Out;
+-
+-	mach_msg_return_t msg_result;
+-
+-#ifdef	__MIG_check__Reply__rpc_jack_internal_clientload_t__defined
+-	kern_return_t check_result;
+-#endif	/* __MIG_check__Reply__rpc_jack_internal_clientload_t__defined */
+-
+-	__DeclareSendRpc(1018, "rpc_jack_internal_clientload")
+-
+-	InP->NDR = NDR_record;
+-
+-	InP->refnum = refnum;
+-
+-	(void) mig_strncpy(InP->client_name, client_name, 64);
+-
+-	(void) mig_strncpy(InP->so_name, so_name, 256);
+-
+-	(void) mig_strncpy(InP->objet_data, objet_data, 256);
+-
+-	InP->options = options;
+-
+-	InP->Head.msgh_bits =
+-		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
+-	/* msgh_size passed as argument */
+-	InP->Head.msgh_request_port = server_port;
+-	InP->Head.msgh_reply_port = mig_get_reply_port();
+-	InP->Head.msgh_id = 1018;
+-
+-	__BeforeSendRpc(1018, "rpc_jack_internal_clientload")
+-	msg_result = mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, (mach_msg_size_t)sizeof(Request), (mach_msg_size_t)sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
+-	__AfterSendRpc(1018, "rpc_jack_internal_clientload")
+-	if (msg_result != MACH_MSG_SUCCESS) {
+-		__MachMsgErrorWithoutTimeout(msg_result);
+-		{ return msg_result; }
+-	}
+-
+-
+-#if	defined(__MIG_check__Reply__rpc_jack_internal_clientload_t__defined)
+-	check_result = __MIG_check__Reply__rpc_jack_internal_clientload_t((__Reply__rpc_jack_internal_clientload_t *)Out0P);
+-	if (check_result != MACH_MSG_SUCCESS)
+-		{ return check_result; }
+-#endif	/* defined(__MIG_check__Reply__rpc_jack_internal_clientload_t__defined) */
+-
+-	*status = Out0P->status;
+-
+-	*int_ref = Out0P->int_ref;
+-
+-	*result = Out0P->result;
+-
+-	return KERN_SUCCESS;
+-}
+-
+-#if ( __MigTypeCheck || __NDR_convert__ )
+-#if __MIG_check__Reply__JackRPCEngine_subsystem__
+-#if !defined(__MIG_check__Reply__rpc_jack_internal_clientunload_t__defined)
+-#define __MIG_check__Reply__rpc_jack_internal_clientunload_t__defined
+-#ifndef __NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__RetCode__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCEngine__kern_return_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__RetCode__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__RetCode(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__kern_return_t((kern_return_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__kern_return_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__RetCode__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__RetCode(a, f) \
+-	__NDR_convert__int_rep__kern_return_t((kern_return_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__RetCode__defined */
+-
+-
+-#ifndef __NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__status__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__status__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__status(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__status__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__status(a, f) \
+-	__NDR_convert__int_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__status__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__status(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int32_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__status__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__status(a, f) \
+-	__NDR_convert__int_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__status__defined */
+-
+-
+-#ifndef __NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__result__defined
+-#if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__result__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__result(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__result__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__result(a, f) \
+-	__NDR_convert__int_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__result__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__result(a, f) \
+-	__NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__int_rep__int32_t__defined)
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__result__defined
+-#define	__NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__result(a, f) \
+-	__NDR_convert__int_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__result__defined */
+-
+-
+-
+-#ifndef __NDR_convert__char_rep__Reply__rpc_jack_internal_clientunload_t__status__defined
+-#if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_internal_clientunload_t__status__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_internal_clientunload_t__status(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_internal_clientunload_t__status__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_internal_clientunload_t__status(a, f) \
+-	__NDR_convert__char_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_internal_clientunload_t__status__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_internal_clientunload_t__status(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int32_t__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_internal_clientunload_t__status__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_internal_clientunload_t__status(a, f) \
+-	__NDR_convert__char_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__char_rep__Reply__rpc_jack_internal_clientunload_t__status__defined */
+-
+-
+-#ifndef __NDR_convert__char_rep__Reply__rpc_jack_internal_clientunload_t__result__defined
+-#if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_internal_clientunload_t__result__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_internal_clientunload_t__result(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_internal_clientunload_t__result__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_internal_clientunload_t__result(a, f) \
+-	__NDR_convert__char_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_internal_clientunload_t__result__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_internal_clientunload_t__result(a, f) \
+-	__NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__char_rep__int32_t__defined)
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_internal_clientunload_t__result__defined
+-#define	__NDR_convert__char_rep__Reply__rpc_jack_internal_clientunload_t__result(a, f) \
+-	__NDR_convert__char_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__char_rep__Reply__rpc_jack_internal_clientunload_t__result__defined */
+-
+-
+-
+-#ifndef __NDR_convert__float_rep__Reply__rpc_jack_internal_clientunload_t__status__defined
+-#if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_internal_clientunload_t__status__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_internal_clientunload_t__status(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_internal_clientunload_t__status__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_internal_clientunload_t__status(a, f) \
+-	__NDR_convert__float_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_internal_clientunload_t__status__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_internal_clientunload_t__status(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int32_t__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_internal_clientunload_t__status__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_internal_clientunload_t__status(a, f) \
+-	__NDR_convert__float_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__float_rep__Reply__rpc_jack_internal_clientunload_t__status__defined */
+-
+-
+-#ifndef __NDR_convert__float_rep__Reply__rpc_jack_internal_clientunload_t__result__defined
+-#if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_internal_clientunload_t__result__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_internal_clientunload_t__result(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_internal_clientunload_t__result__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_internal_clientunload_t__result(a, f) \
+-	__NDR_convert__float_rep__int((int *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_internal_clientunload_t__result__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_internal_clientunload_t__result(a, f) \
+-	__NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
+-#elif	defined(__NDR_convert__float_rep__int32_t__defined)
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_internal_clientunload_t__result__defined
+-#define	__NDR_convert__float_rep__Reply__rpc_jack_internal_clientunload_t__result(a, f) \
+-	__NDR_convert__float_rep__int32_t((int32_t *)(a), f)
+-#endif /* defined(__NDR_convert__*__defined) */
+-#endif /* __NDR_convert__float_rep__Reply__rpc_jack_internal_clientunload_t__result__defined */
+-
+-
+-
+-mig_internal kern_return_t __MIG_check__Reply__rpc_jack_internal_clientunload_t(__Reply__rpc_jack_internal_clientunload_t *Out0P)
+-{
+-
+-	typedef __Reply__rpc_jack_internal_clientunload_t __Reply;
+-#if	__MigTypeCheck
+-	unsigned int msgh_size;
+-#endif	/* __MigTypeCheck */
+-	if (Out0P->Head.msgh_id != 1119) {
+-	    if (Out0P->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
+-		{ return MIG_SERVER_DIED; }
+-	    else
+-		{ return MIG_REPLY_MISMATCH; }
+-	}
+-
+-#if	__MigTypeCheck
+-	msgh_size = Out0P->Head.msgh_size;
+-
+-	if ((Out0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
+-	    ((msgh_size != (mach_msg_size_t)sizeof(__Reply)) &&
+-	     (msgh_size != (mach_msg_size_t)sizeof(mig_reply_error_t) ||
+-	      Out0P->RetCode == KERN_SUCCESS)))
+-		{ return MIG_TYPE_ERROR ; }
+-#endif	/* __MigTypeCheck */
+-
+-	if (Out0P->RetCode != KERN_SUCCESS) {
+-#ifdef	__NDR_convert__mig_reply_error_t__defined
+-		__NDR_convert__mig_reply_error_t((mig_reply_error_t *)Out0P);
+-#endif	/* __NDR_convert__mig_reply_error_t__defined */
+-		return ((mig_reply_error_t *)Out0P)->RetCode;
+-	}
+-
+-#if	defined(__NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__RetCode__defined) || \
+-	defined(__NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__status__defined) || \
+-	defined(__NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__result__defined)
+-	if (Out0P->NDR.int_rep != NDR_record.int_rep) {
+-#if defined(__NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__RetCode__defined)
+-		__NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__RetCode(&Out0P->RetCode, Out0P->NDR.int_rep);
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__RetCode__defined */
+-#if defined(__NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__status__defined)
+-		__NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__status(&Out0P->status, Out0P->NDR.int_rep);
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__status__defined */
+-#if defined(__NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__result__defined)
+-		__NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__result(&Out0P->result, Out0P->NDR.int_rep);
+-#endif /* __NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__result__defined */
+-	}
+-#endif	/* defined(__NDR_convert__int_rep...) */
+-
+-#if	0 || \
+-	defined(__NDR_convert__char_rep__Reply__rpc_jack_internal_clientunload_t__status__defined) || \
+-	defined(__NDR_convert__char_rep__Reply__rpc_jack_internal_clientunload_t__result__defined)
+-	if (Out0P->NDR.char_rep != NDR_record.char_rep) {
+-#if defined(__NDR_convert__char_rep__Reply__rpc_jack_internal_clientunload_t__status__defined)
+-		__NDR_convert__char_rep__Reply__rpc_jack_internal_clientunload_t__status(&Out0P->status, Out0P->NDR.char_rep);
+-#endif /* __NDR_convert__char_rep__Reply__rpc_jack_internal_clientunload_t__status__defined */
+-#if defined(__NDR_convert__char_rep__Reply__rpc_jack_internal_clientunload_t__result__defined)
+-		__NDR_convert__char_rep__Reply__rpc_jack_internal_clientunload_t__result(&Out0P->result, Out0P->NDR.char_rep);
+-#endif /* __NDR_convert__char_rep__Reply__rpc_jack_internal_clientunload_t__result__defined */
+-	}
+-#endif	/* defined(__NDR_convert__char_rep...) */
+-
+-#if	0 || \
+-	defined(__NDR_convert__float_rep__Reply__rpc_jack_internal_clientunload_t__status__defined) || \
+-	defined(__NDR_convert__float_rep__Reply__rpc_jack_internal_clientunload_t__result__defined)
+-	if (Out0P->NDR.float_rep != NDR_record.float_rep) {
+-#if defined(__NDR_convert__float_rep__Reply__rpc_jack_internal_clientunload_t__status__defined)
+-		__NDR_convert__float_rep__Reply__rpc_jack_internal_clientunload_t__status(&Out0P->status, Out0P->NDR.float_rep);
+-#endif /* __NDR_convert__float_rep__Reply__rpc_jack_internal_clientunload_t__status__defined */
+-#if defined(__NDR_convert__float_rep__Reply__rpc_jack_internal_clientunload_t__result__defined)
+-		__NDR_convert__float_rep__Reply__rpc_jack_internal_clientunload_t__result(&Out0P->result, Out0P->NDR.float_rep);
+-#endif /* __NDR_convert__float_rep__Reply__rpc_jack_internal_clientunload_t__result__defined */
+-	}
+-#endif	/* defined(__NDR_convert__float_rep...) */
+-
+-	return MACH_MSG_SUCCESS;
+-}
+-#endif /* !defined(__MIG_check__Reply__rpc_jack_internal_clientunload_t__defined) */
+-#endif /* __MIG_check__Reply__JackRPCEngine_subsystem__ */
+-#endif /* ( __MigTypeCheck || __NDR_convert__ ) */
+-
+-
+-/* Routine rpc_jack_internal_clientunload */
+-mig_external kern_return_t rpc_jack_internal_clientunload
+-(
+-	mach_port_t server_port,
+-	int refnum,
+-	int int_ref,
+-	int *status,
+-	int *result
+-)
+-{
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		int refnum;
+-		int int_ref;
+-	} Request;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		kern_return_t RetCode;
+-		int status;
+-		int result;
+-		mach_msg_trailer_t trailer;
+-	} Reply;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		kern_return_t RetCode;
+-		int status;
+-		int result;
+-	} __Reply;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-	/*
+-	 * typedef struct {
+-	 * 	mach_msg_header_t Head;
+-	 * 	NDR_record_t NDR;
+-	 * 	kern_return_t RetCode;
+-	 * } mig_reply_error_t;
+-	 */
+-
+-	union {
+-		Request In;
+-		Reply Out;
+-	} Mess;
+-
+-	Request *InP = &Mess.In;
+-	Reply *Out0P = &Mess.Out;
+-
+-	mach_msg_return_t msg_result;
+-
+-#ifdef	__MIG_check__Reply__rpc_jack_internal_clientunload_t__defined
+-	kern_return_t check_result;
+-#endif	/* __MIG_check__Reply__rpc_jack_internal_clientunload_t__defined */
+-
+-	__DeclareSendRpc(1019, "rpc_jack_internal_clientunload")
+-
+-	InP->NDR = NDR_record;
+-
+-	InP->refnum = refnum;
+-
+-	InP->int_ref = int_ref;
+-
+-	InP->Head.msgh_bits =
+-		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
+-	/* msgh_size passed as argument */
+-	InP->Head.msgh_request_port = server_port;
+-	InP->Head.msgh_reply_port = mig_get_reply_port();
+-	InP->Head.msgh_id = 1019;
+-
+-	__BeforeSendRpc(1019, "rpc_jack_internal_clientunload")
+-	msg_result = mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, (mach_msg_size_t)sizeof(Request), (mach_msg_size_t)sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
+-	__AfterSendRpc(1019, "rpc_jack_internal_clientunload")
+-	if (msg_result != MACH_MSG_SUCCESS) {
+-		__MachMsgErrorWithoutTimeout(msg_result);
+-		{ return msg_result; }
+-	}
+-
+-
+-#if	defined(__MIG_check__Reply__rpc_jack_internal_clientunload_t__defined)
+-	check_result = __MIG_check__Reply__rpc_jack_internal_clientunload_t((__Reply__rpc_jack_internal_clientunload_t *)Out0P);
+-	if (check_result != MACH_MSG_SUCCESS)
+-		{ return check_result; }
+-#endif	/* defined(__MIG_check__Reply__rpc_jack_internal_clientunload_t__defined) */
+-
+-	*status = Out0P->status;
+-
+-	*result = Out0P->result;
+-
+-	return KERN_SUCCESS;
+-}
+-
+-/* SimpleRoutine rpc_jack_client_rt_notify */
+-mig_external kern_return_t rpc_jack_client_rt_notify
+-(
+-	mach_port_t client_port,
+-	int refnum,
+-	int notify,
+-	int value,
+-	int timeout
+-)
+-{
+-
+-#ifdef  __MigPackStructs
+-#pragma pack(4)
+-#endif
+-	typedef struct {
+-		mach_msg_header_t Head;
+-		NDR_record_t NDR;
+-		int refnum;
+-		int notify;
+-		int value;
+-	} Request;
+-#ifdef  __MigPackStructs
+-#pragma pack()
+-#endif
+-	/*
+-	 * typedef struct {
+-	 * 	mach_msg_header_t Head;
+-	 * 	NDR_record_t NDR;
+-	 * 	kern_return_t RetCode;
+-	 * } mig_reply_error_t;
+-	 */
+-
+-	union {
+-		Request In;
+-	} Mess;
+-
+-	Request *InP = &Mess.In;
+-
+-	mach_msg_return_t msg_result;
+-
+-#ifdef	__MIG_check__Reply__rpc_jack_client_rt_notify_t__defined
+-	kern_return_t check_result;
+-#endif	/* __MIG_check__Reply__rpc_jack_client_rt_notify_t__defined */
+-
+-	__DeclareSendSimple(1020, "rpc_jack_client_rt_notify")
+-
+-	InP->NDR = NDR_record;
+-
+-	InP->refnum = refnum;
+-
+-	InP->notify = notify;
+-
+-	InP->value = value;
+-
+-	InP->Head.msgh_bits =
+-		MACH_MSGH_BITS(19, 0);
+-	/* msgh_size passed as argument */
+-	InP->Head.msgh_request_port = client_port;
+-	InP->Head.msgh_reply_port = MACH_PORT_NULL;
+-	InP->Head.msgh_id = 1020;
+-
+-	__BeforeSendSimple(1020, "rpc_jack_client_rt_notify")
+-	msg_result = mach_msg(&InP->Head, MACH_SEND_MSG|MACH_SEND_TIMEOUT|MACH_MSG_OPTION_NONE, (mach_msg_size_t)sizeof(Request), 0, MACH_PORT_NULL, timeout, MACH_PORT_NULL);
+-	__AfterSendSimple(1020, "rpc_jack_client_rt_notify")
+-
+-	if (msg_result == MACH_SEND_TIMED_OUT) {
+-	}
+-
+-	return msg_result;
+-}
+--- a/macosx/RPC/Jackdefs.h
++++ /dev/null
+@@ -1,25 +0,0 @@
+-/*
+-Copyright (C) 2004-2006 Grame
+-
+-This program is free software; you can redistribute it and/or modify
+-it under the terms of the GNU General Public License as published by
+-the Free Software Foundation; either version 2 of the License, or
+-(at your option) any later version.
+-
+-This program is distributed in the hope that it will be useful,
+-but WITHOUT ANY WARRANTY; without even the implied warranty of
+-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+-GNU General Public License for more details.
+-
+-You should have received a copy of the GNU General Public License
+-along with this program; if not, write to the Free Software
+-Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+-
+-*/
+-
+-typedef char client_name_t[64];
+-typedef char client_port_name_t[128];
+-typedef char client_port_type_t[128];
+-typedef char so_name_t[256];
+-typedef char objet_data_t[256];
+-typedef char message_t[256];
+--- a/macosx/coreaudio/JackCoreAudioDriver.cpp
++++ b/macosx/coreaudio/JackCoreAudioDriver.cpp
+@@ -216,8 +216,8 @@
+ 
+ int JackCoreAudioDriver::Read()
+ {
+-    AudioUnitRender(fAUHAL, fActionFags, fCurrentTime, 1, fEngineControl->fBufferSize, fJackInputData);
+-    return 0;
++    OSStatus err = AudioUnitRender(fAUHAL, fActionFags, fCurrentTime, 1, fEngineControl->fBufferSize, fJackInputData);
++    return (err == noErr) ? 0 : -1;
+ }
+ 
+ int JackCoreAudioDriver::Write()
+--- a/posix/JackCompilerDeps_os.h
++++ b/posix/JackCompilerDeps_os.h
+@@ -48,7 +48,7 @@
+             #define SERVER_EXPORT __attribute__((visibility("default")))
+         #endif
+     #else
+-        #define SERVER_EXPORT
++        #define SERVER_EXPORT __attribute__((visibility("hidden")))
+     #endif
+ #else
+     #define MEM_ALIGN(x,y) x
+--- a/posix/JackPosixThread.cpp
++++ b/posix/JackPosixThread.cpp
+@@ -117,7 +117,7 @@
+         if ((res = pthread_attr_setinheritsched(&attributes, PTHREAD_EXPLICIT_SCHED))) {
+             jack_error("Cannot request explicit scheduling for RT thread res = %d", res);
+             return -1;
+-    	}
++        }
+     
+         if ((res = pthread_attr_setschedpolicy(&attributes, JACK_SCHED_POLICY))) {
+             jack_error("Cannot set RR scheduling class for RT thread res = %d", res);
+@@ -270,6 +270,11 @@
+     return fThread;
+ }
+ 
++bool JackPosixThread::IsThread()
++{
++    return pthread_self() == fThread;
++}
++
+ void JackPosixThread::Terminate()
+ {
+     jack_log("JackPosixThread::Terminate");
+--- a/posix/JackPosixThread.h
++++ b/posix/JackPosixThread.h
+@@ -68,10 +68,11 @@
+         int DropSelfRealTime();                 // Used when called from thread itself
+ 
+         pthread_t GetThreadID();
++        bool IsThread();
+ 
+         static int AcquireRealTimeImp(pthread_t thread, int priority);
+         static int AcquireRealTimeImp(pthread_t thread, int priority, UInt64 period, UInt64 computation, UInt64 constraint)
+-		{ return JackPosixThread::AcquireRealTimeImp(thread, priority); }
++                { return JackPosixThread::AcquireRealTimeImp(thread, priority); }
+         static int DropRealTimeImp(pthread_t thread);
+         static int StartImp(pthread_t* thread, int priority, int realtime, void*(*start_routine)(void*), void* arg);
+         static int StopImp(pthread_t thread);
+--- a/posix/JackSocket.cpp
++++ b/posix/JackSocket.cpp
+@@ -129,7 +129,7 @@
+     }
+ 
+ #ifdef __APPLE__
+-    int on = 1 ;
++    int on = 1;
+     if (setsockopt(fSocket, SOL_SOCKET, SO_NOSIGPIPE, (const char*)&on, sizeof(on)) < 0) {
+         jack_log("setsockopt SO_NOSIGPIPE fd = %ld err = %s", fSocket, strerror(errno));
+     }
+@@ -260,7 +260,7 @@
+         goto error;
+     }
+ 
+-    if (listen(fSocket, 1) < 0) {
++    if (listen(fSocket, 100) < 0) {
+         jack_error("Cannot enable listen on server socket err = %s", strerror(errno));
+         goto error;
+     }
+--- a/posix/JackSocketClientChannel.cpp
++++ b/posix/JackSocketClientChannel.cpp
+@@ -51,7 +51,7 @@
+     }
+ }
+ 
+-int JackSocketClientChannel::Open(const char* server_name, const char* name, char* name_res, JackClient* obj, jack_options_t options, jack_status_t* status)
++int JackSocketClientChannel::Open(const char* server_name, const char* name, int uuid, char* name_res, JackClient* obj, jack_options_t options, jack_status_t* status)
+ {
+     int result = 0;
+     jack_log("JackSocketClientChannel::Open name = %s", name);
+@@ -62,7 +62,7 @@
+     }
+ 
+     // Check name in server
+-    ClientCheck(name, name_res, JACK_PROTOCOL_VERSION, (int)options, (int*)status, &result);
++    ClientCheck(name, uuid, name_res, JACK_PROTOCOL_VERSION, (int)options, (int*)status, &result);
+     if (result < 0) {
+         int status1 = *status;
+         if (status1 & JackVersionError)
+@@ -142,18 +142,18 @@
+     }
+ }
+ 
+-void JackSocketClientChannel::ClientCheck(const char* name, char* name_res, int protocol, int options, int* status, int* result)
++void JackSocketClientChannel::ClientCheck(const char* name, int uuid, char* name_res, int protocol, int options, int* status, int* result)
+ {
+-    JackClientCheckRequest req(name, protocol, options);
++    JackClientCheckRequest req(name, protocol, options, uuid);
+     JackClientCheckResult res;
+     ServerSyncCall(&req, &res, result);
+     *status = res.fStatus;
+     strcpy(name_res, res.fName);
+ }
+ 
+-void JackSocketClientChannel::ClientOpen(const char* name, int pid, int* shared_engine, int* shared_client, int* shared_graph, int* result)
++void JackSocketClientChannel::ClientOpen(const char* name, int pid, int uuid, int* shared_engine, int* shared_client, int* shared_graph, int* result)
+ {
+-    JackClientOpenRequest req(name, pid);
++    JackClientOpenRequest req(name, pid, uuid);
+     JackClientOpenResult res;
+     ServerSyncCall(&req, &res, result);
+     *shared_engine = res.fSharedEngine;
+@@ -246,6 +246,64 @@
+     ServerSyncCall(&req, &res, result);
+ }
+ 
++void JackSocketClientChannel::SessionNotify(int refnum, const char* target, jack_session_event_type_t type, const char* path, jack_session_command_t ** result)
++{
++    JackSessionNotifyRequest req(refnum, path, type, target);
++    JackSessionNotifyResult  res;
++    int intresult;
++    ServerSyncCall(&req, &res, &intresult);
++
++    jack_session_command_t *session_command = (jack_session_command_t *)malloc( sizeof(jack_session_command_t) * (res.fCommandList.size()+1) );
++    int i=0;
++   
++    for (std::list<JackSessionCommand>::iterator ci=res.fCommandList.begin(); ci!=res.fCommandList.end(); ci++) {
++	session_command[i].uuid = strdup( ci->fUUID );
++	session_command[i].client_name = strdup( ci->fClientName );
++	session_command[i].command = strdup( ci->fCommand );
++	session_command[i].flags = ci->fFlags;
++
++	i+=1;
++    }	
++	
++    session_command[i].uuid = NULL;
++    session_command[i].client_name = NULL;
++    session_command[i].command = NULL;
++    session_command[i].flags = (jack_session_flags_t)0;
++
++
++    *result = session_command;
++}
++
++void JackSocketClientChannel::SessionReply(int refnum, int* result)
++{
++    JackSessionReplyRequest req(refnum);
++    JackResult  res;
++    ServerSyncCall(&req, &res, result);
++}
++
++void JackSocketClientChannel::GetUUIDForClientName( int refnum, const char *client_name, char *uuid_res, int *result )
++{
++    JackGetUUIDRequest req(client_name);
++    JackUUIDResult  res;
++    ServerSyncCall(&req, &res, result);
++    strncpy( uuid_res, res.fUUID, JACK_UUID_SIZE );
++}
++
++void JackSocketClientChannel::GetClientNameForUUID( int refnum, const char *uuid, char *name_res, int *result )
++{
++    JackGetClientNameRequest req(uuid);
++    JackClientNameResult  res;
++    ServerSyncCall(&req, &res, result);
++    strncpy( name_res, res.fName, JACK_CLIENT_NAME_SIZE );
++}
++
++void JackSocketClientChannel::ReserveClientName( int refnum, const char *client_name, const char *uuid, int *result )
++{
++    JackReserveNameRequest req(refnum, client_name, uuid);
++    JackResult  res;
++    ServerSyncCall(&req, &res, result);
++}
++
+ void JackSocketClientChannel::ReleaseTimebase(int refnum, int* result)
+ {
+     JackReleaseTimebaseRequest req(refnum);
+@@ -277,9 +335,9 @@
+     *status = res.fStatus;
+ }
+ 
+-void JackSocketClientChannel::InternalClientLoad(int refnum, const char* client_name, const char* so_name, const char* objet_data, int options, int* status, int* int_ref, int* result)
++void JackSocketClientChannel::InternalClientLoad(int refnum, const char* client_name, const char* so_name, const char* objet_data, int options, int* status, int* int_ref, int uuid, int* result)
+ {
+-    JackInternalClientLoadRequest req(refnum, client_name, so_name, objet_data, options);
++    JackInternalClientLoadRequest req(refnum, client_name, so_name, objet_data, options, uuid);
+     JackInternalClientLoadResult res;
+     ServerSyncCall(&req, &res, result);
+     *int_ref = res.fIntRefNum;
+--- a/posix/JackSocketClientChannel.h
++++ b/posix/JackSocketClientChannel.h
+@@ -38,11 +38,11 @@
+ 
+     private:
+ 
+-        JackClientSocket fRequestSocket;			// Socket to communicate with the server
+-        JackServerSocket fNotificationListenSocket;	// Socket listener for server notification
+-        JackClientSocket* fNotificationSocket;		// Socket for server notification
++        JackClientSocket fRequestSocket;                        // Socket to communicate with the server
++        JackServerSocket fNotificationListenSocket;     // Socket listener for server notification
++        JackClientSocket* fNotificationSocket;          // Socket for server notification
+         JackThread fThread;                         // Thread to execute the event loop
+-        JackClient*	fClient;
++        JackClient*     fClient;
+ 
+         void ServerSyncCall(JackRequest* req, JackResult* res, int* result);
+         void ServerAsyncCall(JackRequest* req, JackResult* res, int* result);
+@@ -52,7 +52,7 @@
+         JackSocketClientChannel();
+         virtual ~JackSocketClientChannel();
+ 
+-        int Open(const char* server_name, const char* name, char* name_res, JackClient* obj, jack_options_t options, jack_status_t* status);
++        int Open(const char* server_name, const char* name, int uuid, char* name_res, JackClient* obj, jack_options_t options, jack_status_t* status);
+         void Close();
+ 
+         int Start();
+@@ -60,9 +60,9 @@
+ 
+         int ServerCheck(const char* server_name);
+ 
+-        void ClientCheck(const char* name, char* name_res, int protocol, int options, int* status, int* result);
+-        void ClientOpen(const char* name, int pid, int* shared_engine, int* shared_client, int* shared_graph, int* result);
+-        void ClientOpen(const char* name, int* ref, JackEngineControl** shared_engine, JackGraphManager** shared_manager, JackClientInterface* client, int* result)
++        void ClientCheck(const char* name, int uuid, char* name_res, int protocol, int options, int* status, int* result);
++        void ClientOpen(const char* name, int pid, int uuid, int* shared_engine, int* shared_client, int* shared_graph, int* result);
++        void ClientOpen(const char* name, int* ref, int uuid, JackEngineControl** shared_engine, JackGraphManager** shared_manager, JackClientInterface* client, int* result)
+         {}
+         void ClientClose(int refnum, int* result);
+ 
+@@ -88,12 +88,22 @@
+ 
+         void GetInternalClientName(int refnum, int int_ref, char* name_res, int* result);
+         void InternalClientHandle(int refnum, const char* client_name, int* status, int* int_ref, int* result);
+-        void InternalClientLoad(int refnum, const char* client_name, const char* so_name, const char* objet_data, int options, int* status, int* int_ref, int* result);
++        void InternalClientLoad(int refnum, const char* client_name, const char* so_name, const char* objet_data, int options, int* status, int* int_ref, int uuid, int* result);
+         void InternalClientUnload(int refnum, int int_ref, int* status, int* result);
+ 
++        // Session Stuff
++        void SessionNotify(int refnum, const char* target, jack_session_event_type_t type, const char* path, jack_session_command_t** result);
++        void SessionReply(int refnum, int* result);
++        void GetUUIDForClientName( int refnum, const char *client_name, char *uuid_res, int *result );
++        void GetClientNameForUUID( int refnum, const char *uuid, char *name_res, int *result );
++        void ReserveClientName( int refnum, const char *client_name, const char *uuid, int *result );
++
+         // JackRunnableInterface interface
+         bool Init();
+         bool Execute();
++
++
++        bool IsChannelThread() { return fThread.IsThread(); }
+ };
+ 
+ } // end of namespace
+--- a/posix/JackSocketServerChannel.cpp
++++ b/posix/JackSocketServerChannel.cpp
+@@ -102,14 +102,20 @@
+     }
+ }
+ 
+-void JackSocketServerChannel::ClientAdd(int fd, char* name, int pid, int* shared_engine, int* shared_client, int* shared_graph, int* result)
++void JackSocketServerChannel::ClientAdd(int fd, char* name, int pid, int uuid, int* shared_engine, int* shared_client, int* shared_graph, int* result)
+ {
+     jack_log("JackSocketServerChannel::ClientAdd");
+     int refnum = -1;
+-    *result = fServer->GetEngine()->ClientExternalOpen(name, pid, &refnum, shared_engine, shared_client, shared_graph);
++    *result = fServer->GetEngine()->ClientExternalOpen(name, pid, uuid, &refnum, shared_engine, shared_client, shared_graph);
+     if (*result == 0) {
+         fSocketTable[fd].first = refnum;
+         fRebuild = true;
++    #ifdef __APPLE__
++        int on = 1;
++        if (setsockopt(fd, SOL_SOCKET, SO_NOSIGPIPE, (const char*)&on, sizeof(on)) < 0) {
++            jack_log("setsockopt SO_NOSIGPIPE fd = %ld err = %s", fd, strerror(errno));
++        }
++    #endif
+     } else {
+         jack_error("Cannot create new client");
+     }
+@@ -170,7 +176,7 @@
+             JackClientCheckRequest req;
+             JackClientCheckResult res;
+             if (req.Read(socket) == 0)
+-                res.fResult = fServer->GetEngine()->ClientCheck(req.fName, res.fName, req.fProtocol, req.fOptions, &res.fStatus);
++                res.fResult = fServer->GetEngine()->ClientCheck(req.fName, req.fUUID, res.fName, req.fProtocol, req.fOptions, &res.fStatus);
+             if (res.Write(socket) < 0)
+                 jack_error("JackRequest::ClientCheck write error name = %s", req.fName);
+             break;
+@@ -181,7 +187,7 @@
+             JackClientOpenRequest req;
+             JackClientOpenResult res;
+             if (req.Read(socket) == 0)
+-                ClientAdd(fd, req.fName, req.fPID, &res.fSharedEngine, &res.fSharedClient, &res.fSharedGraph, &res.fResult);
++                ClientAdd(fd, req.fName, req.fPID, req.fUUID, &res.fSharedEngine, &res.fSharedClient, &res.fSharedGraph, &res.fResult);
+             if (res.Write(socket) < 0)
+                 jack_error("JackRequest::ClientOpen write error name = %s", req.fName);
+             break;
+@@ -369,7 +375,7 @@
+             JackInternalClientLoadRequest req;
+             JackInternalClientLoadResult res;
+             if (req.Read(socket) == 0)
+-                res.fResult = fServer->InternalClientLoad(req.fName, req.fDllName, req.fLoadInitName, req.fOptions, &res.fIntRefNum, &res.fStatus);
++                res.fResult = fServer->InternalClientLoad(req.fName, req.fDllName, req.fLoadInitName, req.fOptions, &res.fIntRefNum, req.fUUID, &res.fStatus);
+             if (res.Write(socket) < 0)
+                 jack_error("JackRequest::InternalClientLoad write error name = %s", req.fName);
+             break;
+@@ -400,6 +406,66 @@
+             break;
+         }
+ 
++        case JackRequest::kSessionNotify: {
++            jack_log("JackRequest::SessionNotify");
++            JackSessionNotifyRequest req;
++            JackSessionNotifyResult res;
++            if (req.Read(socket) == 0) {
++                fServer->GetEngine()->SessionNotify(req.fRefNum, req.fDst, req.fEventType, req.fPath, socket);
++            }
++            break;
++        }
++
++        case JackRequest::kSessionReply: {
++            jack_log("JackRequest::SessionReply");
++            JackSessionReplyRequest req;
++            JackResult res;
++            if (req.Read(socket) == 0) {
++                fServer->GetEngine()->SessionReply(req.fRefNum);
++                res.fResult = 0;
++            }
++            if (res.Write(socket) < 0)
++                jack_error("JackRequest::SessionReply write error");
++            break;
++        }
++
++        case JackRequest::kGetClientByUUID: {
++            jack_log("JackRequest::GetClientNameForUUID");
++            JackGetClientNameRequest req;
++            JackClientNameResult res;
++            if (req.Read(socket) == 0) {
++                fServer->GetEngine()->GetClientNameForUUID(req.fUUID, res.fName, &res.fResult);
++            }
++            if (res.Write(socket) < 0)
++                jack_error("JackRequest::GetClientNameForUUID write error");
++            break;
++        }
++
++        case JackRequest::kGetUUIDByClient: {
++            jack_log("JackRequest::GetUUIDForClientName");
++            JackGetUUIDRequest req;
++            JackUUIDResult res;
++            if (req.Read(socket) == 0) {
++                fServer->GetEngine()->GetUUIDForClientName(req.fName, res.fUUID, &res.fResult);
++                res.fResult = 0;
++            }
++            if (res.Write(socket) < 0)
++                jack_error("JackRequest::GetUUIDForClientName write error");
++            break;
++        }
++
++        case JackRequest::kReserveClientName: {
++            jack_log("JackRequest::ReserveClientName");
++            JackReserveNameRequest req;
++            JackResult res;
++            if (req.Read(socket) == 0) {
++                fServer->GetEngine()->ReserveClientName(req.fName, req.fUUID, &res.fResult);
++            }
++            if (res.Write(socket) < 0)
++                jack_error("JackRequest::ReserveClientName write error");
++            break;
++        }
++
+         default:
+             jack_error("Unknown request %ld", header.fType);
+             break;
+--- a/posix/JackSocketServerChannel.h
++++ b/posix/JackSocketServerChannel.h
+@@ -39,10 +39,10 @@
+ 
+     private:
+ 
+-        JackServerSocket fRequestListenSocket;	// Socket to create request socket for the client
++        JackServerSocket fRequestListenSocket;  // Socket to create request socket for the client
+         JackThread fThread;                     // Thread to execute the event loop
+-        JackServer*	fServer;
+-        pollfd*	fPollTable;
++        JackServer*     fServer;
++        pollfd* fPollTable;
+         bool fRebuild;
+         std::map<int, std::pair<int, JackClientSocket*> > fSocketTable;
+ 
+@@ -50,7 +50,7 @@
+         void BuildPoolTable();
+ 
+         void ClientCreate();
+-        void ClientAdd(int fd, char* name, int pid, int* shared_engine, int* shared_client, int* shared_graph, int* result);
++        void ClientAdd(int fd, char* name, int pid, int uuid, int* shared_engine, int* shared_client, int* shared_graph, int* result);
+         void ClientRemove(int fd, int refnum);
+         void ClientKill(int fd);
+ 
+--- a/solaris/oss/JackBoomerDriver.cpp
++++ b/solaris/oss/JackBoomerDriver.cpp
+@@ -634,6 +634,7 @@
+     return true;
+ }
+ 
++// TODO : better error handling
+ bool JackBoomerDriver::JackBoomerDriverInput::Execute()
+ {
+   
+@@ -721,6 +722,7 @@
+     return true;
+ }
+ 
++// TODO : better error handling
+ bool JackBoomerDriver::JackBoomerDriverOutput::Execute()
+ {
+     memset(fDriver->fOutputBuffer, 0, fDriver->fOutputBufferSize);
+--- a/solaris/oss/JackBoomerDriver.h
++++ b/solaris/oss/JackBoomerDriver.h
+@@ -152,10 +152,7 @@
+         }
+ 
+         int SetBufferSize(jack_nframes_t buffer_size);
+-        
+-        bool Init();
+-        bool Execute();
+-
++  
+ };
+ 
+ } // end of namespace
+--- a/solaris/oss/JackOSSDriver.cpp
++++ b/solaris/oss/JackOSSDriver.cpp
+@@ -707,7 +707,7 @@
+     // Read input buffers for the current cycle
+     if (Read() < 0) { 
+         jack_error("ProcessSync: read error, skip cycle");
+-        return 0;   // Skip cycle, but continue processing...
++        return 0;   // Non fatal error here, skip cycle, but continue processing...
+     }
+ 
+     if (fIsMaster) {
+@@ -719,7 +719,7 @@
+     // Write output buffers for the current cycle
+     if (Write() < 0) { 
+         jack_error("JackAudioDriver::ProcessSync: write error, skip cycle");
+-        return 0;   // Skip cycle, but continue processing...
++        return 0;   // Non fatal error here, skip cycle, but continue processing...
+     }
+     
+     return 0;
+--- a/tests/test.cpp
++++ b/tests/test.cpp
+@@ -169,7 +169,7 @@
+ 
+ void Jack_Freewheel_Callback(int starting, void *arg)
+ {
+-    Log("Freewhell callback has been successfully called with value %i. (msg from callback)\n", starting);
++    Log("Freewheel callback has been successfully called with value %i. (msg from callback)\n", starting);
+     FW = starting;
+ }
+ 
+@@ -633,39 +633,39 @@
+     if (status & JackServerStarted) {
+         fprintf(stderr, "JACK server started\n");
+     }
+-    
++
+     /**
+      * Internal client tests...
+      *
+      */
+     jack_intclient_t intclient;
+-    
++
+     Log("trying to load the \"inprocess\" server internal client \n");
+-    
++
+     intclient = jack_internal_client_load (client1, "inprocess",
+                                            (jack_options_t)(JackLoadName|JackLoadInit),
+                                            &status, "inprocess", "");
+-    
++
+     if (intclient == 0 || status & JackFailure) {
+         printf("!!! ERROR !!! cannot load internal client \"inprocess\" intclient %d status 0x%2.0x !\n", intclient, status);
+ 	} else {
+-        
++
+         Log("\"inprocess\" server internal client loaded\n");
+-        
++
+         char* internal_name = jack_get_internal_client_name(client1, intclient);
+         if (strcmp(internal_name, "inprocess") == 0) {
+             Log("jack_get_internal_client_name returns %s\n", internal_name);
+         } else {
+             printf("!!! ERROR !!! jack_get_internal_client_name returns incorrect name %s\n", internal_name);
+         }
+-        
++
+         jack_intclient_t intclient1 = jack_internal_client_handle(client1, "inprocess", &status);
+         if (intclient1 == intclient) {
+             Log("jack_internal_client_handle returns correct handle\n");
+         } else {
+             printf("!!! ERROR !!! jack_internal_client_handle returns incorrect handle %d\n", intclient1);
+         }
+-        
++
+         // Unload internal client
+         status = jack_internal_client_unload (client1, intclient);
+         if (status  == 0) {
+@@ -673,7 +673,7 @@
+         } else {
+             printf("!!! ERROR !!! jack_internal_client_unload returns incorrect value 0x%2.0x\n", status);
+         }
+-        
++
+         // Unload internal client second time
+         status = jack_internal_client_unload (client1, intclient);
+         if (status & JackFailure &&  status & JackNoSuchClient) {
+@@ -682,8 +682,8 @@
+             printf("!!! ERROR !!! jack_internal_client_unload returns incorrect value 0x%2.0x\n", status);
+         }
+     }
+-    
+-    
++
++
+     /**
+      * try to register another one with the same name...
+      *
+@@ -738,7 +738,7 @@
+         printf("!!! ERROR !!! while calling jack_set_thread_init_callback()...\n");
+     if (jack_set_freewheel_callback(client1, Jack_Freewheel_Callback, 0) != 0 )
+         printf("\n!!! ERROR !!! while calling jack_set_freewheel_callback()...\n");
+-  
++
+ 
+     if (jack_set_process_callback(client1, process1, 0) != 0) {
+         printf("Error when calling jack_set_process_callback() !\n");
+@@ -754,7 +754,7 @@
+     if (jack_set_graph_order_callback(client1, Jack_Graph_Order_Callback, 0) != 0) {
+         printf("Error when calling Jack_Graph_Order_Callback() !\n");
+     }
+-    
++
+     if (jack_set_port_rename_callback(client1, Jack_Port_Rename_Callback, 0) != 0 )
+         printf("\n!!! ERROR !!! while calling jack_set_rename_callback()...\n");
+ 
+@@ -874,7 +874,7 @@
+     }
+ 
+     port_callback_reg = 0;	// number of port registration received by the callback
+-    
++
+     /**
+      * Activate the client
+      *
+@@ -883,31 +883,31 @@
+         printf ("Fatal error : cannot activate client1\n");
+         exit(1);
+     }
+-    
++
+     /**
+      * Test if portrename callback have been called.
+      *
+      */
+     jack_port_set_name (output_port1, "renamed-port#");
+-    jack_sleep(1 * 1000); 
++    jack_sleep(1 * 1000);
+ 
+     if (port_rename_clbk == 0)
+         printf("!!! ERROR !!! Jack_Port_Rename_Callback was not called !!.\n");
+-        
+-        
++
++
+     /**
+      * Test if portregistration callback have been called.
+      *
+      */
+-     
+-    jack_sleep(1 * 1000); 
++
++    jack_sleep(1 * 1000);
+ 
+     if (1 == port_callback_reg) {
+         Log("%i ports have been successfully created, and %i callback reg ports have been received... ok\n", 1, port_callback_reg);
+     } else {
+         printf("!!! ERROR !!! %i ports have been created, and %i callback reg ports have been received !\n", 1, port_callback_reg);
+     }
+- 
++
+     /**
+      * Test if init callback initThread have been called.
+      *
+@@ -1162,14 +1162,14 @@
+     }
+ 
+     jack_sleep(1 * 1000); // To hope all port registration and reorder callback have been received...
+-    
++
+     // Check port registration callback
+     if (j == port_callback_reg) {
+         Log("%i ports have been successfully created, and %i callback reg ports have been received... ok\n", j, port_callback_reg);
+     } else {
+         printf("!!! ERROR !!! %i ports have been created, and %i callback reg ports have been received !\n", j, port_callback_reg);
+     }
+-    
++
+     if (reorder == (2 * j)) {
+         Log("%i graph reorder callback have been received... ok\n", reorder);
+     } else {
+@@ -1231,9 +1231,9 @@
+         }
+         a++;
+     }
+-    
++
+     // Check port registration callback again
+-    if (j == port_callback_reg) { 
++    if (j == port_callback_reg) {
+         Log("%i ports have been successfully created, and %i callback reg ports have been received... ok\n", j, port_callback_reg);
+     } else {
+         printf("!!! ERROR !!! %i ports have been created, and %i callback reg ports have been received !\n", j, port_callback_reg);
+--- a/windows/JackWinNamedPipeClientChannel.cpp
++++ b/windows/JackWinNamedPipeClientChannel.cpp
+@@ -48,7 +48,7 @@
+     }
+ }
+ 
+-int JackWinNamedPipeClientChannel::Open(const char* server_name, const char* name, char* name_res, JackClient* obj, jack_options_t options, jack_status_t* status)
++int JackWinNamedPipeClientChannel::Open(const char* server_name, const char* name, int uuid, char* name_res, JackClient* obj, jack_options_t options, jack_status_t* status)
+ {
+     int result = 0;
+     jack_log("JackWinNamedPipeClientChannel::Open name = %s", name);
+@@ -67,7 +67,7 @@
+     }
+ 
+     // Check name in server
+-    ClientCheck(name, name_res, JACK_PROTOCOL_VERSION, (int)options, (int*)status, &result);
++    ClientCheck(name, uuid, name_res, JACK_PROTOCOL_VERSION, (int)options, (int*)status, &result);
+     if (result < 0) {
+         jack_error("Client name = %s conflits with another running client", name);
+         goto error;
+@@ -142,18 +142,18 @@
+     }
+ }
+ 
+-void JackWinNamedPipeClientChannel::ClientCheck(const char* name, char* name_res, int protocol, int options, int* status, int* result)
++void JackWinNamedPipeClientChannel::ClientCheck(const char* name, int uuid, char* name_res, int protocol, int options, int* status, int* result)
+ {
+-    JackClientCheckRequest req(name, protocol, options);
++    JackClientCheckRequest req(name, protocol, options, uuid);
+     JackClientCheckResult res;
+     ServerSyncCall(&req, &res, result);
+     *status = res.fStatus;
+     strcpy(name_res, res.fName);
+ }
+ 
+-void JackWinNamedPipeClientChannel::ClientOpen(const char* name, int pid, int* shared_engine, int* shared_client, int* shared_graph, int* result)
++void JackWinNamedPipeClientChannel::ClientOpen(const char* name, int pid, int uuid, int* shared_engine, int* shared_client, int* shared_graph, int* result)
+ {
+-    JackClientOpenRequest req(name, pid);
++    JackClientOpenRequest req(name, pid, uuid);
+     JackClientOpenResult res;
+     ServerSyncCall(&req, &res, result);
+     *shared_engine = res.fSharedEngine;
+@@ -246,6 +246,16 @@
+     ServerSyncCall(&req, &res, result);
+ }
+ 
++void JackWinNamedPipeClientChannel::SessionNotify(int refnum, const char* target, jack_session_event_type_t type, const char* path, jack_session_command_t** result)
++{
++    JackSessionNotifyRequest req(refnum, target, type, path);
++    JackResult res;
++    int intresult;
++    ServerSyncCall(&req, &res, &intresult);
++
++    *result = NULL;
++}
++
+ void JackWinNamedPipeClientChannel::ReleaseTimebase(int refnum, int* result)
+ {
+     JackReleaseTimebaseRequest req(refnum);
+@@ -277,9 +287,9 @@
+     *status = res.fStatus;
+ }
+ 
+-void JackWinNamedPipeClientChannel::InternalClientLoad(int refnum, const char* client_name, const char* so_name, const char* objet_data, int options, int* status, int* int_ref, int* result)
++void JackWinNamedPipeClientChannel::InternalClientLoad(int refnum, const char* client_name, const char* so_name, const char* objet_data, int options, int* status, int* int_ref, int uuid, int* result)
+ {
+-    JackInternalClientLoadRequest req(refnum, client_name, so_name, objet_data, options);
++    JackInternalClientLoadRequest req(refnum, client_name, so_name, objet_data, options, uuid);
+     JackInternalClientLoadResult res;
+     ServerSyncCall(&req, &res, result);
+     *int_ref = res.fIntRefNum;
+--- a/windows/JackWinNamedPipeClientChannel.h
++++ b/windows/JackWinNamedPipeClientChannel.h
+@@ -1,20 +1,20 @@
+ /*
+  Copyright (C) 2004-2008 Grame
+- 
++
+  This program is free software; you can redistribute it and/or modify
+  it under the terms of the GNU Lesser General Public License as published by
+  the Free Software Foundation; either version 2.1 of the License, or
+  (at your option) any later version.
+- 
++
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU Lesser General Public License for more details.
+- 
++
+  You should have received a copy of the GNU Lesser General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+- 
++
+  */
+ 
+ 
+@@ -51,7 +51,7 @@
+         JackWinNamedPipeClientChannel();
+         virtual ~JackWinNamedPipeClientChannel();
+ 
+-        int Open(const char* server_name, const char* name, char* name_res, JackClient* obj, jack_options_t options, jack_status_t* status);
++        int Open(const char* server_name, const char* name, int uuid, char* name_res, JackClient* obj, jack_options_t options, jack_status_t* status);
+         void Close();
+ 
+         int Start();
+@@ -59,8 +59,8 @@
+ 
+         int ServerCheck(const char* server_name);
+ 
+-        void ClientCheck(const char* name, char* name_res, int protocol, int options, int* status, int* result);
+-        void ClientOpen(const char* name, int pid, int* shared_engine, int* shared_client, int* shared_graph, int* result);
++        void ClientCheck(const char* name, int uuid, char* name_res, int protocol, int options, int* status, int* result);
++        void ClientOpen(const char* name, int pid, int uuid, int* shared_engine, int* shared_client, int* shared_graph, int* result);
+         void ClientOpen(const char* name, int* ref, JackEngineControl** shared_engine, JackGraphManager** shared_manager, JackClientInterface* client, int* result)
+         {}
+         void ClientClose(int refnum, int* result);
+@@ -76,7 +76,7 @@
+ 
+         void PortConnect(int refnum, jack_port_id_t src, jack_port_id_t dst, int* result);
+         void PortDisconnect(int refnum, jack_port_id_t src, jack_port_id_t dst, int* result);
+-        
++
+         void PortRename(int refnum, jack_port_id_t port, const char* name, int* result);
+ 
+         void SetBufferSize(jack_nframes_t buffer_size, int* result);
+@@ -87,9 +87,11 @@
+ 
+         void GetInternalClientName(int refnum, int int_ref, char* name_res, int* result);
+         void InternalClientHandle(int refnum, const char* client_name, int* status, int* int_ref, int* result);
+-        void InternalClientLoad(int refnum, const char* client_name, const char* so_name, const char* objet_data, int options, int* status, int* int_ref, int* result);
++        void InternalClientLoad(int refnum, const char* client_name, const char* so_name, const char* objet_data, int options, int* status, int* int_ref, int uuid, int* result);
+         void InternalClientUnload(int refnum, int int_ref, int* status, int* result);
+ 
++        void SessionNotify(int refnum, const char* target, jack_session_event_type_t type, const char* path, jack_session_command_t** result);
++
+         // JackRunnableInterface interface
+         bool Init();
+         bool Execute();
+--- a/windows/JackWinNamedPipeServerChannel.cpp
++++ b/windows/JackWinNamedPipeServerChannel.cpp
+@@ -53,7 +53,7 @@
+     delete fPipe;
+ }
+ 
+-int JackClientPipeThread::Open(JackServer* server)	// Open the Server/Client connection
++int JackClientPipeThread::Open(JackServer* server)      // Open the Server/Client connection
+ {
+     // Start listening
+     if (fThread.Start() != 0) {
+@@ -65,13 +65,13 @@
+     return 0;
+ }
+ 
+-void JackClientPipeThread::Close()					// Close the Server/Client connection
++void JackClientPipeThread::Close()                                      // Close the Server/Client connection
+ {
+     jack_log("JackClientPipeThread::Close %x %ld", this, fRefNum);
+     /*
+-    	TODO : solve WIN32 thread Kill issue
+-    	This would hang.. since Close will be followed by a delete,
+-    	all ressources will be desallocated at the end.
++        TODO : solve WIN32 thread Kill issue
++        This would hang.. since Close will be followed by a delete,
++        all ressources will be desallocated at the end.
+     */
+ 
+     fThread.Kill();
+@@ -115,7 +115,7 @@
+                 JackClientCheckRequest req;
+                 JackClientCheckResult res;
+                 if (req.Read(fPipe) == 0)
+-                    res.fResult = fServer->GetEngine()->ClientCheck(req.fName, res.fName, req.fProtocol, req.fOptions, &res.fStatus);
++                    res.fResult = fServer->GetEngine()->ClientCheck(req.fName, req.fUUID, res.fName, req.fProtocol, req.fOptions, &res.fStatus);
+                 res.Write(fPipe);
+                 break;
+             }
+@@ -125,7 +125,7 @@
+                 JackClientOpenRequest req;
+                 JackClientOpenResult res;
+                 if (req.Read(fPipe) == 0)
+-                    ClientAdd(req.fName, req.fPID, &res.fSharedEngine, &res.fSharedClient, &res.fSharedGraph, &res.fResult);
++                    ClientAdd(req.fName, req.fPID, req.fUUID, &res.fSharedEngine, &res.fSharedClient, &res.fSharedGraph, &res.fResult);
+                 res.Write(fPipe);
+                 break;
+             }
+@@ -297,7 +297,7 @@
+                 JackInternalClientLoadRequest req;
+                 JackInternalClientLoadResult res;
+                 if (req.Read(fPipe) == 0)
+-                    res.fResult = fServer->InternalClientLoad(req.fName, req.fDllName, req.fLoadInitName, req.fOptions, &res.fIntRefNum, &res.fStatus);
++                    res.fResult = fServer->InternalClientLoad(req.fName, req.fDllName, req.fLoadInitName, req.fOptions, &res.fIntRefNum, req.fUUID, &res.fStatus);
+                 res.Write(fPipe);
+                 break;
+             }
+@@ -326,6 +326,63 @@
+                 break;
+             }
+ 
++            case JackRequest::kSessionNotify: {
++                jack_log("JackRequest::SessionNotify");
++                JackSessionNotifyRequest req;
++                JackSessionNotifyResult res;
++                if (req.Read(fPipe) == 0) {
++                    fServer->GetEngine()->SessionNotify(req.fRefNum, req.fDst, req.fEventType, req.fPath, fPipe);
++                }
++                res.Write(fPipe);
++                break;
++            }
++
++            case JackRequest::kSessionReply: {
++                jack_log("JackRequest::SessionReply");
++                JackSessionReplyRequest req;
++                JackResult res;
++                if (req.Read(fPipe) == 0) {
++                    fServer->GetEngine()->SessionReply(req.fRefNum);
++                    res.fResult = 0;
++                }
++                break;
++            }
++
++            case JackRequest::kGetClientByUUID: {
++                jack_log("JackRequest::GetClientNameForUUID");
++                JackGetClientNameRequest req;
++                JackClientNameResult res;
++                if (req.Read(fPipe) == 0) {
++                    fServer->GetEngine()->GetClientNameForUUID(req.fUUID, res.fName, &res.fResult);
++                }
++                res.Write(fPipe);
++                break;
++            }
++
++            case JackRequest::kGetUUIDByClient: {
++                jack_log("JackRequest::GetUUIDForClientName");
++                JackGetUUIDRequest req;
++                JackUUIDResult res;
++                if (req.Read(fPipe) == 0) {
++                    fServer->GetEngine()->GetUUIDForClientName(req.fName, res.fUUID, &res.fResult);
++                    res.fResult = 0;
++                }
++                res.Write(fPipe);
++                break;
++            }
++
++            case JackRequest::kReserveClientName: {
++                jack_log("JackRequest::ReserveClientName");
++                JackReserveNameRequest req;
++                JackResult res;
++                if (req.Read(fPipe) == 0) {
++                    fServer->GetEngine()->ReserveClientName(req.fName, req.fUUID, &res.fResult);
++                    res.fResult = 0;
++                }
++                res.Write(fPipe);
++                break;
++            }
++
+             default:
+                 jack_log("Unknown request %ld", header.fType);
+                 break;
+@@ -337,11 +394,11 @@
+     return ret;
+ }
+ 
+-void JackClientPipeThread::ClientAdd(char* name, int pid, int* shared_engine, int* shared_client, int* shared_graph, int* result)
++void JackClientPipeThread::ClientAdd(char* name, int pid, int uuid, int* shared_engine, int* shared_client, int* shared_graph, int* result)
+ {
+     jack_log("JackClientPipeThread::ClientAdd %s", name);
+     fRefNum = -1;
+-    *result = fServer->GetEngine()->ClientExternalOpen(name, pid, &fRefNum, shared_engine, shared_client, shared_graph);
++    *result = fServer->GetEngine()->ClientExternalOpen(name, pid, uuid, &fRefNum, shared_engine, shared_client, shared_graph);
+ }
+ 
+ void JackClientPipeThread::ClientRemove()
+@@ -358,7 +415,7 @@
+ {
+     jack_log("JackClientPipeThread::ClientKill ref = %d", fRefNum);
+ 
+-    if (fRefNum == -1) {		// Correspond to an already removed client.
++    if (fRefNum == -1) {                // Correspond to an already removed client.
+         jack_log("Kill a closed client");
+     } else if (fRefNum == 0) {  // Correspond to a still not opened client.
+         jack_log("Kill a not opened client");
+@@ -401,10 +458,10 @@
+ void JackWinNamedPipeServerChannel::Close()
+ {
+     /* TODO : solve WIN32 thread Kill issue
+-    	This would hang the server... since we are quitting it, its not really problematic,
+-    	all ressources will be desallocated at the end.
++        This would hang the server... since we are quitting it, its not really problematic,
++        all ressources will be desallocated at the end.
+ 
+-    	fRequestListenPipe.Close();
++        fRequestListenPipe.Close();
+         fThread.Stop();
+     */
+ 
+--- a/windows/JackWinNamedPipeServerChannel.h
++++ b/windows/JackWinNamedPipeServerChannel.h
+@@ -1,20 +1,20 @@
+ /*
+  Copyright (C) 2004-2008 Grame
+- 
++
+  This program is free software; you can redistribute it and/or modify
+  it under the terms of the GNU Lesser General Public License as published by
+  the Free Software Foundation; either version 2.1 of the License, or
+  (at your option) any later version.
+- 
++
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU Lesser General Public License for more details.
+- 
++
+  You should have received a copy of the GNU Lesser General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+- 
++
+  */
+ 
+ 
+@@ -40,7 +40,7 @@
+         JackThread fThread;
+         int fRefNum;
+ 
+-        void ClientAdd(char* name, int pid, int* shared_engine, int* shared_client, int* shared_graph, int* result);
++        void ClientAdd(char* name, int pid, int uuid, int* shared_engine, int* shared_client, int* shared_graph, int* result);
+         void ClientRemove();
+         void ClientKill();
+ 
+@@ -53,7 +53,7 @@
+ 
+         int Open(JackServer* server);   // Open the Server/Client connection
+         void Close();                   // Close the Server/Client connection
+-   
++
+         bool HandleRequest();
+ 
+         // JackRunnableInterface interface
+@@ -91,7 +91,7 @@
+ 
+         int Open(const char* server_name, JackServer* server);  // Open the Server/Client connection
+         void Close();                                           // Close the Server/Client connection
+-    
++
+         int Start();
+ 
+         // JackRunnableInterface interface
+--- a/windows/JackWinThread.cpp
++++ b/windows/JackWinThread.cpp
+@@ -235,6 +235,11 @@
+     return fThread;
+ }
+ 
++bool JackWinThread::IsThread()
++{
++    return GetCurrentThread() == fThread;
++}
++
+ void JackWinThread::Terminate()
+ {
+     jack_log("JackWinThread::Terminate");
+--- a/windows/JackWinThread.h
++++ b/windows/JackWinThread.h
+@@ -1,20 +1,20 @@
+ /*
+  Copyright (C) 2004-2008 Grame
+- 
++
+  This program is free software; you can redistribute it and/or modify
+  it under the terms of the GNU Lesser General Public License as published by
+  the Free Software Foundation; either version 2.1 of the License, or
+  (at your option) any later version.
+- 
++
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU Lesser General Public License for more details.
+- 
++
+  You should have received a copy of the GNU Lesser General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+- 
++
+  */
+ 
+ 
+@@ -59,24 +59,25 @@
+ 
+         int AcquireRealTime();                  // Used when called from another thread
+         int AcquireSelfRealTime();              // Used when called from thread itself
+-        
++
+         int AcquireRealTime(int priority);      // Used when called from another thread
+         int AcquireSelfRealTime(int priority);  // Used when called from thread itself
+-        
++
+         int DropRealTime();                     // Used when called from another thread
+         int DropSelfRealTime();                 // Used when called from thread itself
+-   
++
+         pthread_t GetThreadID();
++        bool IsThread();
+ 
+         static int AcquireRealTimeImp(pthread_t thread, int priority);
+         static int AcquireRealTimeImp(pthread_t thread, int priority, UInt64 period, UInt64 computation, UInt64 constraint)
+-        { 
+-            return JackWinThread::AcquireRealTimeImp(thread, priority); 
++        {
++            return JackWinThread::AcquireRealTimeImp(thread, priority);
+         }
+         static int DropRealTimeImp(pthread_t thread);
+         static int StartImp(pthread_t* thread, int priority, int realtime, void*(*start_routine)(void*), void* arg)
+-        { 
+-            return JackWinThread::StartImp(thread, priority, realtime, (ThreadCallback) start_routine, arg); 
++        {
++            return JackWinThread::StartImp(thread, priority, realtime, (ThreadCallback) start_routine, arg);
+         }
+         static int StartImp(pthread_t* thread, int priority, int realtime, ThreadCallback start_routine, void* arg);
+         static int StopImp(pthread_t thread);
+--- a/windows/Setup/jack.ci
++++ b/windows/Setup/jack.ci
+@@ -1,9 +1,9 @@
+ <*project
+       version = 4 civer = "Free v4.14.5" winver = "2.6/5.1.2600" > 
+    <output> .</>
+-   <exename> Jack_v1.9.6_setup.exe</>
++   <exename> Jack_v1.9.7_setup.exe</>
+    <digitsign> </>
+-   <appname> Jack v1.9.6</>
++   <appname> Jack v1.9.7</>
+    <password> </>
+    <addlang> </>
+    <icon> Default - 2</>
+--- a/wscript
++++ b/wscript
+@@ -11,7 +11,7 @@
+ import re
+ import Logs
+ 
+-VERSION='1.9.6'
++VERSION='1.9.7'
+ APPNAME='jack'
+ JACK_API_VERSION = '0.1.0'
+ 

-- 
jackd2 packaging



More information about the pkg-multimedia-commits mailing list