1 // Generated code, do not modify
2 
3 package run;
4 
5 
6 /** Skeleton class for remote class 'run.ModelCluster_instance_impl' */
7 public final class ModelCluster_instance_impl_KSkel extends uka.karmi.rmi.RemoteSkeleton {
8   /** reference to the implementation object */
9   run.ModelCluster_instance_impl impl;
10 
11   /** Set the implementation object of this skeleton */
setRemoteObject(uka.karmi.rmi.Remote object)12   public final void setRemoteObject(uka.karmi.rmi.Remote object) {
13     this.impl = (run.ModelCluster_instance_impl) object;
14   }
15 
getRemoteObject()16   protected final uka.karmi.rmi.Remote getRemoteObject() {
17     return this.impl;
18   }
19 
20   /** Direct marshaling protocol: Generic invocation */
doApplicationCall(uka.karmi.rmi.ServerConnection c)21   public final void doApplicationCall(uka.karmi.rmi.ServerConnection c)
22     throws java.io.IOException, ClassNotFoundException
23   {
24     switch(c.mid) {
25       case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_number_of_elements_get_$: {
26         // unmarshal parameters
27         c.closeReceiveCall();
28 
29         int result;
30         try {
31           // call the implementation
32           result = impl.run_ModelCluster_number_of_elements_get_();
33         } catch (Throwable ex) {
34           // marshal the server-side exception
35           c.openSendResult(false);
36           c.sendObject(ex);
37           return;
38         }
39 
40         // marshal the return value
41         c.openSendResult(true);
42         c.sendSingleInt(result);
43         return;
44       }
45 
46       case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_number_of_elements_set_$int: {
47         // unmarshal parameters
48         c.openReceivePrimitive(4);
49         int p0 = c.receiveInt();
50         c.closeReceivePrimitive(4);
51         c.closeReceiveCall();
52 
53         int result;
54         try {
55           // call the implementation
56           result = impl.run_ModelCluster_number_of_elements_set_(p0);
57         } catch (Throwable ex) {
58           // marshal the server-side exception
59           c.openSendResult(false);
60           c.sendObject(ex);
61           return;
62         }
63 
64         // marshal the return value
65         c.openSendResult(true);
66         c.sendSingleInt(result);
67         return;
68       }
69 
70       case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_number_of_elements_inc_$int$boolean: {
71         // unmarshal parameters
72         c.openReceivePrimitive(5);
73         int p0 = c.receiveInt();
74         boolean p1 = c.receiveBoolean();
75         c.closeReceivePrimitive(5);
76         c.closeReceiveCall();
77 
78         int result;
79         try {
80           // call the implementation
81           result = impl.run_ModelCluster_number_of_elements_inc_(p0, p1);
82         } catch (Throwable ex) {
83           // marshal the server-side exception
84           c.openSendResult(false);
85           c.sendObject(ex);
86           return;
87         }
88 
89         // marshal the return value
90         c.openSendResult(true);
91         c.sendSingleInt(result);
92         return;
93       }
94 
95       case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_number_of_trackers_get_$: {
96         // unmarshal parameters
97         c.closeReceiveCall();
98 
99         int result;
100         try {
101           // call the implementation
102           result = impl.run_ModelCluster_number_of_trackers_get_();
103         } catch (Throwable ex) {
104           // marshal the server-side exception
105           c.openSendResult(false);
106           c.sendObject(ex);
107           return;
108         }
109 
110         // marshal the return value
111         c.openSendResult(true);
112         c.sendSingleInt(result);
113         return;
114       }
115 
116       case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_number_of_trackers_set_$int: {
117         // unmarshal parameters
118         c.openReceivePrimitive(4);
119         int p0 = c.receiveInt();
120         c.closeReceivePrimitive(4);
121         c.closeReceiveCall();
122 
123         int result;
124         try {
125           // call the implementation
126           result = impl.run_ModelCluster_number_of_trackers_set_(p0);
127         } catch (Throwable ex) {
128           // marshal the server-side exception
129           c.openSendResult(false);
130           c.sendObject(ex);
131           return;
132         }
133 
134         // marshal the return value
135         c.openSendResult(true);
136         c.sendSingleInt(result);
137         return;
138       }
139 
140       case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_number_of_trackers_inc_$int$boolean: {
141         // unmarshal parameters
142         c.openReceivePrimitive(5);
143         int p0 = c.receiveInt();
144         boolean p1 = c.receiveBoolean();
145         c.closeReceivePrimitive(5);
146         c.closeReceiveCall();
147 
148         int result;
149         try {
150           // call the implementation
151           result = impl.run_ModelCluster_number_of_trackers_inc_(p0, p1);
152         } catch (Throwable ex) {
153           // marshal the server-side exception
154           c.openSendResult(false);
155           c.sendObject(ex);
156           return;
157         }
158 
159         // marshal the return value
160         c.openSendResult(true);
161         c.sendSingleInt(result);
162         return;
163       }
164 
165       case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_number_of_nodes_get_$: {
166         // unmarshal parameters
167         c.closeReceiveCall();
168 
169         int result;
170         try {
171           // call the implementation
172           result = impl.run_ModelCluster_number_of_nodes_get_();
173         } catch (Throwable ex) {
174           // marshal the server-side exception
175           c.openSendResult(false);
176           c.sendObject(ex);
177           return;
178         }
179 
180         // marshal the return value
181         c.openSendResult(true);
182         c.sendSingleInt(result);
183         return;
184       }
185 
186       case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_number_of_nodes_set_$int: {
187         // unmarshal parameters
188         c.openReceivePrimitive(4);
189         int p0 = c.receiveInt();
190         c.closeReceivePrimitive(4);
191         c.closeReceiveCall();
192 
193         int result;
194         try {
195           // call the implementation
196           result = impl.run_ModelCluster_number_of_nodes_set_(p0);
197         } catch (Throwable ex) {
198           // marshal the server-side exception
199           c.openSendResult(false);
200           c.sendObject(ex);
201           return;
202         }
203 
204         // marshal the return value
205         c.openSendResult(true);
206         c.sendSingleInt(result);
207         return;
208       }
209 
210       case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_number_of_nodes_inc_$int$boolean: {
211         // unmarshal parameters
212         c.openReceivePrimitive(5);
213         int p0 = c.receiveInt();
214         boolean p1 = c.receiveBoolean();
215         c.closeReceivePrimitive(5);
216         c.closeReceiveCall();
217 
218         int result;
219         try {
220           // call the implementation
221           result = impl.run_ModelCluster_number_of_nodes_inc_(p0, p1);
222         } catch (Throwable ex) {
223           // marshal the server-side exception
224           c.openSendResult(false);
225           c.sendObject(ex);
226           return;
227         }
228 
229         // marshal the return value
230         c.openSendResult(true);
231         c.sendSingleInt(result);
232         return;
233       }
234 
235       case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_number_of_materials_get_$: {
236         // unmarshal parameters
237         c.closeReceiveCall();
238 
239         int result;
240         try {
241           // call the implementation
242           result = impl.run_ModelCluster_number_of_materials_get_();
243         } catch (Throwable ex) {
244           // marshal the server-side exception
245           c.openSendResult(false);
246           c.sendObject(ex);
247           return;
248         }
249 
250         // marshal the return value
251         c.openSendResult(true);
252         c.sendSingleInt(result);
253         return;
254       }
255 
256       case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_number_of_materials_set_$int: {
257         // unmarshal parameters
258         c.openReceivePrimitive(4);
259         int p0 = c.receiveInt();
260         c.closeReceivePrimitive(4);
261         c.closeReceiveCall();
262 
263         int result;
264         try {
265           // call the implementation
266           result = impl.run_ModelCluster_number_of_materials_set_(p0);
267         } catch (Throwable ex) {
268           // marshal the server-side exception
269           c.openSendResult(false);
270           c.sendObject(ex);
271           return;
272         }
273 
274         // marshal the return value
275         c.openSendResult(true);
276         c.sendSingleInt(result);
277         return;
278       }
279 
280       case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_number_of_materials_inc_$int$boolean: {
281         // unmarshal parameters
282         c.openReceivePrimitive(5);
283         int p0 = c.receiveInt();
284         boolean p1 = c.receiveBoolean();
285         c.closeReceivePrimitive(5);
286         c.closeReceiveCall();
287 
288         int result;
289         try {
290           // call the implementation
291           result = impl.run_ModelCluster_number_of_materials_inc_(p0, p1);
292         } catch (Throwable ex) {
293           // marshal the server-side exception
294           c.openSendResult(false);
295           c.sendObject(ex);
296           return;
297         }
298 
299         // marshal the return value
300         c.openSendResult(true);
301         c.sendSingleInt(result);
302         return;
303       }
304 
305       case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_number_of_controls_get_$: {
306         // unmarshal parameters
307         c.closeReceiveCall();
308 
309         int result;
310         try {
311           // call the implementation
312           result = impl.run_ModelCluster_number_of_controls_get_();
313         } catch (Throwable ex) {
314           // marshal the server-side exception
315           c.openSendResult(false);
316           c.sendObject(ex);
317           return;
318         }
319 
320         // marshal the return value
321         c.openSendResult(true);
322         c.sendSingleInt(result);
323         return;
324       }
325 
326       case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_number_of_controls_set_$int: {
327         // unmarshal parameters
328         c.openReceivePrimitive(4);
329         int p0 = c.receiveInt();
330         c.closeReceivePrimitive(4);
331         c.closeReceiveCall();
332 
333         int result;
334         try {
335           // call the implementation
336           result = impl.run_ModelCluster_number_of_controls_set_(p0);
337         } catch (Throwable ex) {
338           // marshal the server-side exception
339           c.openSendResult(false);
340           c.sendObject(ex);
341           return;
342         }
343 
344         // marshal the return value
345         c.openSendResult(true);
346         c.sendSingleInt(result);
347         return;
348       }
349 
350       case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_number_of_controls_inc_$int$boolean: {
351         // unmarshal parameters
352         c.openReceivePrimitive(5);
353         int p0 = c.receiveInt();
354         boolean p1 = c.receiveBoolean();
355         c.closeReceivePrimitive(5);
356         c.closeReceiveCall();
357 
358         int result;
359         try {
360           // call the implementation
361           result = impl.run_ModelCluster_number_of_controls_inc_(p0, p1);
362         } catch (Throwable ex) {
363           // marshal the server-side exception
364           c.openSendResult(false);
365           c.sendObject(ex);
366           return;
367         }
368 
369         // marshal the return value
370         c.openSendResult(true);
371         c.sendSingleInt(result);
372         return;
373       }
374 
375       case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_number_of_constraints_get_$: {
376         // unmarshal parameters
377         c.closeReceiveCall();
378 
379         int result;
380         try {
381           // call the implementation
382           result = impl.run_ModelCluster_number_of_constraints_get_();
383         } catch (Throwable ex) {
384           // marshal the server-side exception
385           c.openSendResult(false);
386           c.sendObject(ex);
387           return;
388         }
389 
390         // marshal the return value
391         c.openSendResult(true);
392         c.sendSingleInt(result);
393         return;
394       }
395 
396       case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_number_of_constraints_set_$int: {
397         // unmarshal parameters
398         c.openReceivePrimitive(4);
399         int p0 = c.receiveInt();
400         c.closeReceivePrimitive(4);
401         c.closeReceiveCall();
402 
403         int result;
404         try {
405           // call the implementation
406           result = impl.run_ModelCluster_number_of_constraints_set_(p0);
407         } catch (Throwable ex) {
408           // marshal the server-side exception
409           c.openSendResult(false);
410           c.sendObject(ex);
411           return;
412         }
413 
414         // marshal the return value
415         c.openSendResult(true);
416         c.sendSingleInt(result);
417         return;
418       }
419 
420       case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_number_of_constraints_inc_$int$boolean: {
421         // unmarshal parameters
422         c.openReceivePrimitive(5);
423         int p0 = c.receiveInt();
424         boolean p1 = c.receiveBoolean();
425         c.closeReceivePrimitive(5);
426         c.closeReceiveCall();
427 
428         int result;
429         try {
430           // call the implementation
431           result = impl.run_ModelCluster_number_of_constraints_inc_(p0, p1);
432         } catch (Throwable ex) {
433           // marshal the server-side exception
434           c.openSendResult(false);
435           c.sendObject(ex);
436           return;
437         }
438 
439         // marshal the return value
440         c.openSendResult(true);
441         c.sendSingleInt(result);
442         return;
443       }
444 
445       case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_number_of_loads_get_$: {
446         // unmarshal parameters
447         c.closeReceiveCall();
448 
449         int result;
450         try {
451           // call the implementation
452           result = impl.run_ModelCluster_number_of_loads_get_();
453         } catch (Throwable ex) {
454           // marshal the server-side exception
455           c.openSendResult(false);
456           c.sendObject(ex);
457           return;
458         }
459 
460         // marshal the return value
461         c.openSendResult(true);
462         c.sendSingleInt(result);
463         return;
464       }
465 
466       case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_number_of_loads_set_$int: {
467         // unmarshal parameters
468         c.openReceivePrimitive(4);
469         int p0 = c.receiveInt();
470         c.closeReceivePrimitive(4);
471         c.closeReceiveCall();
472 
473         int result;
474         try {
475           // call the implementation
476           result = impl.run_ModelCluster_number_of_loads_set_(p0);
477         } catch (Throwable ex) {
478           // marshal the server-side exception
479           c.openSendResult(false);
480           c.sendObject(ex);
481           return;
482         }
483 
484         // marshal the return value
485         c.openSendResult(true);
486         c.sendSingleInt(result);
487         return;
488       }
489 
490       case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_number_of_loads_inc_$int$boolean: {
491         // unmarshal parameters
492         c.openReceivePrimitive(5);
493         int p0 = c.receiveInt();
494         boolean p1 = c.receiveBoolean();
495         c.closeReceivePrimitive(5);
496         c.closeReceiveCall();
497 
498         int result;
499         try {
500           // call the implementation
501           result = impl.run_ModelCluster_number_of_loads_inc_(p0, p1);
502         } catch (Throwable ex) {
503           // marshal the server-side exception
504           c.openSendResult(false);
505           c.sendObject(ex);
506           return;
507         }
508 
509         // marshal the return value
510         c.openSendResult(true);
511         c.sendSingleInt(result);
512         return;
513       }
514 
515       case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_constraintlist_get_$: {
516         // unmarshal parameters
517         c.closeReceiveCall();
518 
519         run.RplVector result;
520         try {
521           // call the implementation
522           result = impl.run_ModelCluster_constraintlist_get_();
523         } catch (Throwable ex) {
524           // marshal the server-side exception
525           c.openSendResult(false);
526           c.sendObject(ex);
527           return;
528         }
529 
530         // marshal the return value
531         c.openSendResult(true);
532         c.sendObject(result);
533         return;
534       }
535 
536       case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_constraintlist_set_$run_RplVector: {
537         // unmarshal parameters
538         run.RplVector p0 = (run.RplVector) c.receiveObject();
539         c.closeReceiveCall();
540 
541         run.RplVector result;
542         try {
543           // call the implementation
544           result = impl.run_ModelCluster_constraintlist_set_(p0);
545         } catch (Throwable ex) {
546           // marshal the server-side exception
547           c.openSendResult(false);
548           c.sendObject(ex);
549           return;
550         }
551 
552         // marshal the return value
553         c.openSendResult(true);
554         c.sendObject(result);
555         return;
556       }
557 
558       case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_loadlist_get_$: {
559         // unmarshal parameters
560         c.closeReceiveCall();
561 
562         run.RplVector result;
563         try {
564           // call the implementation
565           result = impl.run_ModelCluster_loadlist_get_();
566         } catch (Throwable ex) {
567           // marshal the server-side exception
568           c.openSendResult(false);
569           c.sendObject(ex);
570           return;
571         }
572 
573         // marshal the return value
574         c.openSendResult(true);
575         c.sendObject(result);
576         return;
577       }
578 
579       case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_loadlist_set_$run_RplVector: {
580         // unmarshal parameters
581         run.RplVector p0 = (run.RplVector) c.receiveObject();
582         c.closeReceiveCall();
583 
584         run.RplVector result;
585         try {
586           // call the implementation
587           result = impl.run_ModelCluster_loadlist_set_(p0);
588         } catch (Throwable ex) {
589           // marshal the server-side exception
590           c.openSendResult(false);
591           c.sendObject(ex);
592           return;
593         }
594 
595         // marshal the return value
596         c.openSendResult(true);
597         c.sendObject(result);
598         return;
599       }
600 
601       case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_nodelist_get_$: {
602         // unmarshal parameters
603         c.closeReceiveCall();
604 
605         run.RplVector result;
606         try {
607           // call the implementation
608           result = impl.run_ModelCluster_nodelist_get_();
609         } catch (Throwable ex) {
610           // marshal the server-side exception
611           c.openSendResult(false);
612           c.sendObject(ex);
613           return;
614         }
615 
616         // marshal the return value
617         c.openSendResult(true);
618         c.sendObject(result);
619         return;
620       }
621 
622       case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_nodelist_set_$run_RplVector: {
623         // unmarshal parameters
624         run.RplVector p0 = (run.RplVector) c.receiveObject();
625         c.closeReceiveCall();
626 
627         run.RplVector result;
628         try {
629           // call the implementation
630           result = impl.run_ModelCluster_nodelist_set_(p0);
631         } catch (Throwable ex) {
632           // marshal the server-side exception
633           c.openSendResult(false);
634           c.sendObject(ex);
635           return;
636         }
637 
638         // marshal the return value
639         c.openSendResult(true);
640         c.sendObject(result);
641         return;
642       }
643 
644       case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_nodetable_get_$: {
645         // unmarshal parameters
646         c.closeReceiveCall();
647 
648         java.util.Hashtable result;
649         try {
650           // call the implementation
651           result = impl.run_ModelCluster_nodetable_get_();
652         } catch (Throwable ex) {
653           // marshal the server-side exception
654           c.openSendResult(false);
655           c.sendObject(ex);
656           return;
657         }
658 
659         // marshal the return value
660         c.openSendResult(true);
661         c.sendObject(result);
662         return;
663       }
664 
665       case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_nodetable_set_$java_util_Hashtable: {
666         // unmarshal parameters
667         java.util.Hashtable p0 = (java.util.Hashtable) c.receiveObject();
668         c.closeReceiveCall();
669 
670         java.util.Hashtable result;
671         try {
672           // call the implementation
673           result = impl.run_ModelCluster_nodetable_set_(p0);
674         } catch (Throwable ex) {
675           // marshal the server-side exception
676           c.openSendResult(false);
677           c.sendObject(ex);
678           return;
679         }
680 
681         // marshal the return value
682         c.openSendResult(true);
683         c.sendObject(result);
684         return;
685       }
686 
687       case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_elementlist_get_$: {
688         // unmarshal parameters
689         c.closeReceiveCall();
690 
691         run.RplVector result;
692         try {
693           // call the implementation
694           result = impl.run_ModelCluster_elementlist_get_();
695         } catch (Throwable ex) {
696           // marshal the server-side exception
697           c.openSendResult(false);
698           c.sendObject(ex);
699           return;
700         }
701 
702         // marshal the return value
703         c.openSendResult(true);
704         c.sendObject(result);
705         return;
706       }
707 
708       case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_elementlist_set_$run_RplVector: {
709         // unmarshal parameters
710         run.RplVector p0 = (run.RplVector) c.receiveObject();
711         c.closeReceiveCall();
712 
713         run.RplVector result;
714         try {
715           // call the implementation
716           result = impl.run_ModelCluster_elementlist_set_(p0);
717         } catch (Throwable ex) {
718           // marshal the server-side exception
719           c.openSendResult(false);
720           c.sendObject(ex);
721           return;
722         }
723 
724         // marshal the return value
725         c.openSendResult(true);
726         c.sendObject(result);
727         return;
728       }
729 
730       case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_trackerlist_get_$: {
731         // unmarshal parameters
732         c.closeReceiveCall();
733 
734         run.RplVector result;
735         try {
736           // call the implementation
737           result = impl.run_ModelCluster_trackerlist_get_();
738         } catch (Throwable ex) {
739           // marshal the server-side exception
740           c.openSendResult(false);
741           c.sendObject(ex);
742           return;
743         }
744 
745         // marshal the return value
746         c.openSendResult(true);
747         c.sendObject(result);
748         return;
749       }
750 
751       case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_trackerlist_set_$run_RplVector: {
752         // unmarshal parameters
753         run.RplVector p0 = (run.RplVector) c.receiveObject();
754         c.closeReceiveCall();
755 
756         run.RplVector result;
757         try {
758           // call the implementation
759           result = impl.run_ModelCluster_trackerlist_set_(p0);
760         } catch (Throwable ex) {
761           // marshal the server-side exception
762           c.openSendResult(false);
763           c.sendObject(ex);
764           return;
765         }
766 
767         // marshal the return value
768         c.openSendResult(true);
769         c.sendObject(result);
770         return;
771       }
772 
773       case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_materiallist_get_$: {
774         // unmarshal parameters
775         c.closeReceiveCall();
776 
777         run.RplVector result;
778         try {
779           // call the implementation
780           result = impl.run_ModelCluster_materiallist_get_();
781         } catch (Throwable ex) {
782           // marshal the server-side exception
783           c.openSendResult(false);
784           c.sendObject(ex);
785           return;
786         }
787 
788         // marshal the return value
789         c.openSendResult(true);
790         c.sendObject(result);
791         return;
792       }
793 
794       case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_materiallist_set_$run_RplVector: {
795         // unmarshal parameters
796         run.RplVector p0 = (run.RplVector) c.receiveObject();
797         c.closeReceiveCall();
798 
799         run.RplVector result;
800         try {
801           // call the implementation
802           result = impl.run_ModelCluster_materiallist_set_(p0);
803         } catch (Throwable ex) {
804           // marshal the server-side exception
805           c.openSendResult(false);
806           c.sendObject(ex);
807           return;
808         }
809 
810         // marshal the return value
811         c.openSendResult(true);
812         c.sendObject(result);
813         return;
814       }
815 
816       case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_shareddata_get_$: {
817         // unmarshal parameters
818         c.closeReceiveCall();
819 
820         run.SharedData result;
821         try {
822           // call the implementation
823           result = impl.run_ModelCluster_shareddata_get_();
824         } catch (Throwable ex) {
825           // marshal the server-side exception
826           c.openSendResult(false);
827           c.sendObject(ex);
828           return;
829         }
830 
831         // marshal the return value
832         c.openSendResult(true);
833         c.sendObject(result);
834         return;
835       }
836 
837       case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_shareddata_set_$run_SharedData: {
838         // unmarshal parameters
839         run.SharedData p0 = (run.SharedData) c.receiveObject();
840         c.closeReceiveCall();
841 
842         run.SharedData result;
843         try {
844           // call the implementation
845           result = impl.run_ModelCluster_shareddata_set_(p0);
846         } catch (Throwable ex) {
847           // marshal the server-side exception
848           c.openSendResult(false);
849           c.sendObject(ex);
850           return;
851         }
852 
853         // marshal the return value
854         c.openSendResult(true);
855         c.sendObject(result);
856         return;
857       }
858 
859       case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_time_get_$: {
860         // unmarshal parameters
861         c.closeReceiveCall();
862 
863         double result;
864         try {
865           // call the implementation
866           result = impl.run_ModelCluster_time_get_();
867         } catch (Throwable ex) {
868           // marshal the server-side exception
869           c.openSendResult(false);
870           c.sendObject(ex);
871           return;
872         }
873 
874         // marshal the return value
875         c.openSendResult(true);
876         c.sendSingleDouble(result);
877         return;
878       }
879 
880       case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_time_set_$double: {
881         // unmarshal parameters
882         c.openReceivePrimitive(8);
883         double p0 = c.receiveDouble();
884         c.closeReceivePrimitive(8);
885         c.closeReceiveCall();
886 
887         double result;
888         try {
889           // call the implementation
890           result = impl.run_ModelCluster_time_set_(p0);
891         } catch (Throwable ex) {
892           // marshal the server-side exception
893           c.openSendResult(false);
894           c.sendObject(ex);
895           return;
896         }
897 
898         // marshal the return value
899         c.openSendResult(true);
900         c.sendSingleDouble(result);
901         return;
902       }
903 
904       case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_time_inc_$double$boolean: {
905         // unmarshal parameters
906         c.openReceivePrimitive(9);
907         double p0 = c.receiveDouble();
908         boolean p1 = c.receiveBoolean();
909         c.closeReceivePrimitive(9);
910         c.closeReceiveCall();
911 
912         double result;
913         try {
914           // call the implementation
915           result = impl.run_ModelCluster_time_inc_(p0, p1);
916         } catch (Throwable ex) {
917           // marshal the server-side exception
918           c.openSendResult(false);
919           c.sendObject(ex);
920           return;
921         }
922 
923         // marshal the return value
924         c.openSendResult(true);
925         c.sendSingleDouble(result);
926         return;
927       }
928 
929       case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_ttemp_get_$: {
930         // unmarshal parameters
931         c.closeReceiveCall();
932 
933         double result;
934         try {
935           // call the implementation
936           result = impl.run_ModelCluster_ttemp_get_();
937         } catch (Throwable ex) {
938           // marshal the server-side exception
939           c.openSendResult(false);
940           c.sendObject(ex);
941           return;
942         }
943 
944         // marshal the return value
945         c.openSendResult(true);
946         c.sendSingleDouble(result);
947         return;
948       }
949 
950       case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_ttemp_set_$double: {
951         // unmarshal parameters
952         c.openReceivePrimitive(8);
953         double p0 = c.receiveDouble();
954         c.closeReceivePrimitive(8);
955         c.closeReceiveCall();
956 
957         double result;
958         try {
959           // call the implementation
960           result = impl.run_ModelCluster_ttemp_set_(p0);
961         } catch (Throwable ex) {
962           // marshal the server-side exception
963           c.openSendResult(false);
964           c.sendObject(ex);
965           return;
966         }
967 
968         // marshal the return value
969         c.openSendResult(true);
970         c.sendSingleDouble(result);
971         return;
972       }
973 
974       case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_ttemp_inc_$double$boolean: {
975         // unmarshal parameters
976         c.openReceivePrimitive(9);
977         double p0 = c.receiveDouble();
978         boolean p1 = c.receiveBoolean();
979         c.closeReceivePrimitive(9);
980         c.closeReceiveCall();
981 
982         double result;
983         try {
984           // call the implementation
985           result = impl.run_ModelCluster_ttemp_inc_(p0, p1);
986         } catch (Throwable ex) {
987           // marshal the server-side exception
988           c.openSendResult(false);
989           c.sendObject(ex);
990           return;
991         }
992 
993         // marshal the return value
994         c.openSendResult(true);
995         c.sendSingleDouble(result);
996         return;
997       }
998 
999       case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_exported_ttemp_get_$: {
1000         // unmarshal parameters
1001         c.closeReceiveCall();
1002 
1003         double result;
1004         try {
1005           // call the implementation
1006           result = impl.run_ModelCluster_exported_ttemp_get_();
1007         } catch (Throwable ex) {
1008           // marshal the server-side exception
1009           c.openSendResult(false);
1010           c.sendObject(ex);
1011           return;
1012         }
1013 
1014         // marshal the return value
1015         c.openSendResult(true);
1016         c.sendSingleDouble(result);
1017         return;
1018       }
1019 
1020       case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_exported_ttemp_set_$double: {
1021         // unmarshal parameters
1022         c.openReceivePrimitive(8);
1023         double p0 = c.receiveDouble();
1024         c.closeReceivePrimitive(8);
1025         c.closeReceiveCall();
1026 
1027         double result;
1028         try {
1029           // call the implementation
1030           result = impl.run_ModelCluster_exported_ttemp_set_(p0);
1031         } catch (Throwable ex) {
1032           // marshal the server-side exception
1033           c.openSendResult(false);
1034           c.sendObject(ex);
1035           return;
1036         }
1037 
1038         // marshal the return value
1039         c.openSendResult(true);
1040         c.sendSingleDouble(result);
1041         return;
1042       }
1043 
1044       case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_exported_ttemp_inc_$double$boolean: {
1045         // unmarshal parameters
1046         c.openReceivePrimitive(9);
1047         double p0 = c.receiveDouble();
1048         boolean p1 = c.receiveBoolean();
1049         c.closeReceivePrimitive(9);
1050         c.closeReceiveCall();
1051 
1052         double result;
1053         try {
1054           // call the implementation
1055           result = impl.run_ModelCluster_exported_ttemp_inc_(p0, p1);
1056         } catch (Throwable ex) {
1057           // marshal the server-side exception
1058           c.openSendResult(false);
1059           c.sendObject(ex);
1060           return;
1061         }
1062 
1063         // marshal the return value
1064         c.openSendResult(true);
1065         c.sendSingleDouble(result);
1066         return;
1067       }
1068 
1069       case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_i_get_$: {
1070         // unmarshal parameters
1071         c.closeReceiveCall();
1072 
1073         int result;
1074         try {
1075           // call the implementation
1076           result = impl.run_ModelCluster_i_get_();
1077         } catch (Throwable ex) {
1078           // marshal the server-side exception
1079           c.openSendResult(false);
1080           c.sendObject(ex);
1081           return;
1082         }
1083 
1084         // marshal the return value
1085         c.openSendResult(true);
1086         c.sendSingleInt(result);
1087         return;
1088       }
1089 
1090       case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_i_set_$int: {
1091         // unmarshal parameters
1092         c.openReceivePrimitive(4);
1093         int p0 = c.receiveInt();
1094         c.closeReceivePrimitive(4);
1095         c.closeReceiveCall();
1096 
1097         int result;
1098         try {
1099           // call the implementation
1100           result = impl.run_ModelCluster_i_set_(p0);
1101         } catch (Throwable ex) {
1102           // marshal the server-side exception
1103           c.openSendResult(false);
1104           c.sendObject(ex);
1105           return;
1106         }
1107 
1108         // marshal the return value
1109         c.openSendResult(true);
1110         c.sendSingleInt(result);
1111         return;
1112       }
1113 
1114       case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_i_inc_$int$boolean: {
1115         // unmarshal parameters
1116         c.openReceivePrimitive(5);
1117         int p0 = c.receiveInt();
1118         boolean p1 = c.receiveBoolean();
1119         c.closeReceivePrimitive(5);
1120         c.closeReceiveCall();
1121 
1122         int result;
1123         try {
1124           // call the implementation
1125           result = impl.run_ModelCluster_i_inc_(p0, p1);
1126         } catch (Throwable ex) {
1127           // marshal the server-side exception
1128           c.openSendResult(false);
1129           c.sendObject(ex);
1130           return;
1131         }
1132 
1133         // marshal the return value
1134         c.openSendResult(true);
1135         c.sendSingleInt(result);
1136         return;
1137       }
1138 
1139       case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_controlset_get_$: {
1140         // unmarshal parameters
1141         c.closeReceiveCall();
1142 
1143         run.Controlset result;
1144         try {
1145           // call the implementation
1146           result = impl.run_ModelCluster_controlset_get_();
1147         } catch (Throwable ex) {
1148           // marshal the server-side exception
1149           c.openSendResult(false);
1150           c.sendObject(ex);
1151           return;
1152         }
1153 
1154         // marshal the return value
1155         c.openSendResult(true);
1156         c.sendObject(result);
1157         return;
1158       }
1159 
1160       case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_controlset_set_$run_Controlset: {
1161         // unmarshal parameters
1162         run.Controlset p0 = (run.Controlset) c.receiveObject();
1163         c.closeReceiveCall();
1164 
1165         run.Controlset result;
1166         try {
1167           // call the implementation
1168           result = impl.run_ModelCluster_controlset_set_(p0);
1169         } catch (Throwable ex) {
1170           // marshal the server-side exception
1171           c.openSendResult(false);
1172           c.sendObject(ex);
1173           return;
1174         }
1175 
1176         // marshal the return value
1177         c.openSendResult(true);
1178         c.sendObject(result);
1179         return;
1180       }
1181 
1182       case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_temporary_element_get_$: {
1183         // unmarshal parameters
1184         c.closeReceiveCall();
1185 
1186         run.Element result;
1187         try {
1188           // call the implementation
1189           result = impl.run_ModelCluster_temporary_element_get_();
1190         } catch (Throwable ex) {
1191           // marshal the server-side exception
1192           c.openSendResult(false);
1193           c.sendObject(ex);
1194           return;
1195         }
1196 
1197         // marshal the return value
1198         c.openSendResult(true);
1199         c.sendObject(result);
1200         return;
1201       }
1202 
1203       case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_temporary_element_set_$run_Element: {
1204         // unmarshal parameters
1205         run.Element p0 = (run.Element) c.receiveObject();
1206         c.closeReceiveCall();
1207 
1208         run.Element result;
1209         try {
1210           // call the implementation
1211           result = impl.run_ModelCluster_temporary_element_set_(p0);
1212         } catch (Throwable ex) {
1213           // marshal the server-side exception
1214           c.openSendResult(false);
1215           c.sendObject(ex);
1216           return;
1217         }
1218 
1219         // marshal the return value
1220         c.openSendResult(true);
1221         c.sendObject(result);
1222         return;
1223       }
1224 
1225       case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_temporary_tracker_get_$: {
1226         // unmarshal parameters
1227         c.closeReceiveCall();
1228 
1229         run.Tracker result;
1230         try {
1231           // call the implementation
1232           result = impl.run_ModelCluster_temporary_tracker_get_();
1233         } catch (Throwable ex) {
1234           // marshal the server-side exception
1235           c.openSendResult(false);
1236           c.sendObject(ex);
1237           return;
1238         }
1239 
1240         // marshal the return value
1241         c.openSendResult(true);
1242         c.sendObject(result);
1243         return;
1244       }
1245 
1246       case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_temporary_tracker_set_$run_Tracker: {
1247         // unmarshal parameters
1248         run.Tracker p0 = (run.Tracker) c.receiveObject();
1249         c.closeReceiveCall();
1250 
1251         run.Tracker result;
1252         try {
1253           // call the implementation
1254           result = impl.run_ModelCluster_temporary_tracker_set_(p0);
1255         } catch (Throwable ex) {
1256           // marshal the server-side exception
1257           c.openSendResult(false);
1258           c.sendObject(ex);
1259           return;
1260         }
1261 
1262         // marshal the return value
1263         c.openSendResult(true);
1264         c.sendObject(result);
1265         return;
1266       }
1267 
1268       case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_temporary_constraint_get_$: {
1269         // unmarshal parameters
1270         c.closeReceiveCall();
1271 
1272         run.Constraint result;
1273         try {
1274           // call the implementation
1275           result = impl.run_ModelCluster_temporary_constraint_get_();
1276         } catch (Throwable ex) {
1277           // marshal the server-side exception
1278           c.openSendResult(false);
1279           c.sendObject(ex);
1280           return;
1281         }
1282 
1283         // marshal the return value
1284         c.openSendResult(true);
1285         c.sendObject(result);
1286         return;
1287       }
1288 
1289       case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_temporary_constraint_set_$run_Constraint: {
1290         // unmarshal parameters
1291         run.Constraint p0 = (run.Constraint) c.receiveObject();
1292         c.closeReceiveCall();
1293 
1294         run.Constraint result;
1295         try {
1296           // call the implementation
1297           result = impl.run_ModelCluster_temporary_constraint_set_(p0);
1298         } catch (Throwable ex) {
1299           // marshal the server-side exception
1300           c.openSendResult(false);
1301           c.sendObject(ex);
1302           return;
1303         }
1304 
1305         // marshal the return value
1306         c.openSendResult(true);
1307         c.sendObject(result);
1308         return;
1309       }
1310 
1311       case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_temporary_node_get_$: {
1312         // unmarshal parameters
1313         c.closeReceiveCall();
1314 
1315         run.Node result;
1316         try {
1317           // call the implementation
1318           result = impl.run_ModelCluster_temporary_node_get_();
1319         } catch (Throwable ex) {
1320           // marshal the server-side exception
1321           c.openSendResult(false);
1322           c.sendObject(ex);
1323           return;
1324         }
1325 
1326         // marshal the return value
1327         c.openSendResult(true);
1328         c.sendObject(result);
1329         return;
1330       }
1331 
1332       case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_temporary_node_set_$run_Node: {
1333         // unmarshal parameters
1334         run.Node p0 = (run.Node) c.receiveObject();
1335         c.closeReceiveCall();
1336 
1337         run.Node result;
1338         try {
1339           // call the implementation
1340           result = impl.run_ModelCluster_temporary_node_set_(p0);
1341         } catch (Throwable ex) {
1342           // marshal the server-side exception
1343           c.openSendResult(false);
1344           c.sendObject(ex);
1345           return;
1346         }
1347 
1348         // marshal the return value
1349         c.openSendResult(true);
1350         c.sendObject(result);
1351         return;
1352       }
1353 
1354       case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_resultwriter_get_$: {
1355         // unmarshal parameters
1356         c.closeReceiveCall();
1357 
1358         run.Writer result;
1359         try {
1360           // call the implementation
1361           result = impl.run_ModelCluster_resultwriter_get_();
1362         } catch (Throwable ex) {
1363           // marshal the server-side exception
1364           c.openSendResult(false);
1365           c.sendObject(ex);
1366           return;
1367         }
1368 
1369         // marshal the return value
1370         c.openSendResult(true);
1371         c.sendObject(result);
1372         return;
1373       }
1374 
1375       case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_resultwriter_set_$run_Writer: {
1376         // unmarshal parameters
1377         run.Writer p0 = (run.Writer) c.receiveObject();
1378         c.closeReceiveCall();
1379 
1380         run.Writer result;
1381         try {
1382           // call the implementation
1383           result = impl.run_ModelCluster_resultwriter_set_(p0);
1384         } catch (Throwable ex) {
1385           // marshal the server-side exception
1386           c.openSendResult(false);
1387           c.sendObject(ex);
1388           return;
1389         }
1390 
1391         // marshal the return value
1392         c.openSendResult(true);
1393         c.sendObject(result);
1394         return;
1395       }
1396 
1397       case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_trackwriter_get_$: {
1398         // unmarshal parameters
1399         c.closeReceiveCall();
1400 
1401         run.TrackWriter result;
1402         try {
1403           // call the implementation
1404           result = impl.run_ModelCluster_trackwriter_get_();
1405         } catch (Throwable ex) {
1406           // marshal the server-side exception
1407           c.openSendResult(false);
1408           c.sendObject(ex);
1409           return;
1410         }
1411 
1412         // marshal the return value
1413         c.openSendResult(true);
1414         c.sendObject(result);
1415         return;
1416       }
1417 
1418       case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_trackwriter_set_$run_TrackWriter: {
1419         // unmarshal parameters
1420         run.TrackWriter p0 = (run.TrackWriter) c.receiveObject();
1421         c.closeReceiveCall();
1422 
1423         run.TrackWriter result;
1424         try {
1425           // call the implementation
1426           result = impl.run_ModelCluster_trackwriter_set_(p0);
1427         } catch (Throwable ex) {
1428           // marshal the server-side exception
1429           c.openSendResult(false);
1430           c.sendObject(ex);
1431           return;
1432         }
1433 
1434         // marshal the return value
1435         c.openSendResult(true);
1436         c.sendObject(result);
1437         return;
1438       }
1439 
1440       case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_filename_get_$: {
1441         // unmarshal parameters
1442         c.closeReceiveCall();
1443 
1444         java.lang.String result;
1445         try {
1446           // call the implementation
1447           result = impl.run_ModelCluster_filename_get_();
1448         } catch (Throwable ex) {
1449           // marshal the server-side exception
1450           c.openSendResult(false);
1451           c.sendObject(ex);
1452           return;
1453         }
1454 
1455         // marshal the return value
1456         c.openSendResult(true);
1457         c.sendObject(result);
1458         return;
1459       }
1460 
1461       case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_filename_set_$java_lang_String: {
1462         // unmarshal parameters
1463         java.lang.String p0 = (java.lang.String) c.receiveObject();
1464         c.closeReceiveCall();
1465 
1466         java.lang.String result;
1467         try {
1468           // call the implementation
1469           result = impl.run_ModelCluster_filename_set_(p0);
1470         } catch (Throwable ex) {
1471           // marshal the server-side exception
1472           c.openSendResult(false);
1473           c.sendObject(ex);
1474           return;
1475         }
1476 
1477         // marshal the return value
1478         c.openSendResult(true);
1479         c.sendObject(result);
1480         return;
1481       }
1482 
1483       case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_timestep_get_$: {
1484         // unmarshal parameters
1485         c.closeReceiveCall();
1486 
1487         double result;
1488         try {
1489           // call the implementation
1490           result = impl.run_ModelCluster_timestep_get_();
1491         } catch (Throwable ex) {
1492           // marshal the server-side exception
1493           c.openSendResult(false);
1494           c.sendObject(ex);
1495           return;
1496         }
1497 
1498         // marshal the return value
1499         c.openSendResult(true);
1500         c.sendSingleDouble(result);
1501         return;
1502       }
1503 
1504       case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_timestep_set_$double: {
1505         // unmarshal parameters
1506         c.openReceivePrimitive(8);
1507         double p0 = c.receiveDouble();
1508         c.closeReceivePrimitive(8);
1509         c.closeReceiveCall();
1510 
1511         double result;
1512         try {
1513           // call the implementation
1514           result = impl.run_ModelCluster_timestep_set_(p0);
1515         } catch (Throwable ex) {
1516           // marshal the server-side exception
1517           c.openSendResult(false);
1518           c.sendObject(ex);
1519           return;
1520         }
1521 
1522         // marshal the return value
1523         c.openSendResult(true);
1524         c.sendSingleDouble(result);
1525         return;
1526       }
1527 
1528       case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_timestep_inc_$double$boolean: {
1529         // unmarshal parameters
1530         c.openReceivePrimitive(9);
1531         double p0 = c.receiveDouble();
1532         boolean p1 = c.receiveBoolean();
1533         c.closeReceivePrimitive(9);
1534         c.closeReceiveCall();
1535 
1536         double result;
1537         try {
1538           // call the implementation
1539           result = impl.run_ModelCluster_timestep_inc_(p0, p1);
1540         } catch (Throwable ex) {
1541           // marshal the server-side exception
1542           c.openSendResult(false);
1543           c.sendObject(ex);
1544           return;
1545         }
1546 
1547         // marshal the return value
1548         c.openSendResult(true);
1549         c.sendSingleDouble(result);
1550         return;
1551       }
1552 
1553       case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_failure_is_set_get_$: {
1554         // unmarshal parameters
1555         c.closeReceiveCall();
1556 
1557         boolean result;
1558         try {
1559           // call the implementation
1560           result = impl.run_ModelCluster_failure_is_set_get_();
1561         } catch (Throwable ex) {
1562           // marshal the server-side exception
1563           c.openSendResult(false);
1564           c.sendObject(ex);
1565           return;
1566         }
1567 
1568         // marshal the return value
1569         c.openSendResult(true);
1570         c.sendSingleBoolean(result);
1571         return;
1572       }
1573 
1574       case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_failure_is_set_set_$boolean: {
1575         // unmarshal parameters
1576         c.openReceivePrimitive(1);
1577         boolean p0 = c.receiveBoolean();
1578         c.closeReceivePrimitive(1);
1579         c.closeReceiveCall();
1580 
1581         boolean result;
1582         try {
1583           // call the implementation
1584           result = impl.run_ModelCluster_failure_is_set_set_(p0);
1585         } catch (Throwable ex) {
1586           // marshal the server-side exception
1587           c.openSendResult(false);
1588           c.sendObject(ex);
1589           return;
1590         }
1591 
1592         // marshal the return value
1593         c.openSendResult(true);
1594         c.sendSingleBoolean(result);
1595         return;
1596       }
1597 
1598       case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_autostep_get_$: {
1599         // unmarshal parameters
1600         c.closeReceiveCall();
1601 
1602         boolean result;
1603         try {
1604           // call the implementation
1605           result = impl.run_ModelCluster_autostep_get_();
1606         } catch (Throwable ex) {
1607           // marshal the server-side exception
1608           c.openSendResult(false);
1609           c.sendObject(ex);
1610           return;
1611         }
1612 
1613         // marshal the return value
1614         c.openSendResult(true);
1615         c.sendSingleBoolean(result);
1616         return;
1617       }
1618 
1619       case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_autostep_set_$boolean: {
1620         // unmarshal parameters
1621         c.openReceivePrimitive(1);
1622         boolean p0 = c.receiveBoolean();
1623         c.closeReceivePrimitive(1);
1624         c.closeReceiveCall();
1625 
1626         boolean result;
1627         try {
1628           // call the implementation
1629           result = impl.run_ModelCluster_autostep_set_(p0);
1630         } catch (Throwable ex) {
1631           // marshal the server-side exception
1632           c.openSendResult(false);
1633           c.sendObject(ex);
1634           return;
1635         }
1636 
1637         // marshal the return value
1638         c.openSendResult(true);
1639         c.sendSingleBoolean(result);
1640         return;
1641       }
1642 
1643       case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_nr_of_CPUs_get_$: {
1644         // unmarshal parameters
1645         c.closeReceiveCall();
1646 
1647         int result;
1648         try {
1649           // call the implementation
1650           result = impl.run_ModelCluster_nr_of_CPUs_get_();
1651         } catch (Throwable ex) {
1652           // marshal the server-side exception
1653           c.openSendResult(false);
1654           c.sendObject(ex);
1655           return;
1656         }
1657 
1658         // marshal the return value
1659         c.openSendResult(true);
1660         c.sendSingleInt(result);
1661         return;
1662       }
1663 
1664       case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_nr_of_CPUs_set_$int: {
1665         // unmarshal parameters
1666         c.openReceivePrimitive(4);
1667         int p0 = c.receiveInt();
1668         c.closeReceivePrimitive(4);
1669         c.closeReceiveCall();
1670 
1671         int result;
1672         try {
1673           // call the implementation
1674           result = impl.run_ModelCluster_nr_of_CPUs_set_(p0);
1675         } catch (Throwable ex) {
1676           // marshal the server-side exception
1677           c.openSendResult(false);
1678           c.sendObject(ex);
1679           return;
1680         }
1681 
1682         // marshal the return value
1683         c.openSendResult(true);
1684         c.sendSingleInt(result);
1685         return;
1686       }
1687 
1688       case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_nr_of_CPUs_inc_$int$boolean: {
1689         // unmarshal parameters
1690         c.openReceivePrimitive(5);
1691         int p0 = c.receiveInt();
1692         boolean p1 = c.receiveBoolean();
1693         c.closeReceivePrimitive(5);
1694         c.closeReceiveCall();
1695 
1696         int result;
1697         try {
1698           // call the implementation
1699           result = impl.run_ModelCluster_nr_of_CPUs_inc_(p0, p1);
1700         } catch (Throwable ex) {
1701           // marshal the server-side exception
1702           c.openSendResult(false);
1703           c.sendObject(ex);
1704           return;
1705         }
1706 
1707         // marshal the return value
1708         c.openSendResult(true);
1709         c.sendSingleInt(result);
1710         return;
1711       }
1712 
1713       case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_client_nr_get_$: {
1714         // unmarshal parameters
1715         c.closeReceiveCall();
1716 
1717         int result;
1718         try {
1719           // call the implementation
1720           result = impl.run_ModelCluster_client_nr_get_();
1721         } catch (Throwable ex) {
1722           // marshal the server-side exception
1723           c.openSendResult(false);
1724           c.sendObject(ex);
1725           return;
1726         }
1727 
1728         // marshal the return value
1729         c.openSendResult(true);
1730         c.sendSingleInt(result);
1731         return;
1732       }
1733 
1734       case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_client_nr_set_$int: {
1735         // unmarshal parameters
1736         c.openReceivePrimitive(4);
1737         int p0 = c.receiveInt();
1738         c.closeReceivePrimitive(4);
1739         c.closeReceiveCall();
1740 
1741         int result;
1742         try {
1743           // call the implementation
1744           result = impl.run_ModelCluster_client_nr_set_(p0);
1745         } catch (Throwable ex) {
1746           // marshal the server-side exception
1747           c.openSendResult(false);
1748           c.sendObject(ex);
1749           return;
1750         }
1751 
1752         // marshal the return value
1753         c.openSendResult(true);
1754         c.sendSingleInt(result);
1755         return;
1756       }
1757 
1758       case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_client_nr_inc_$int$boolean: {
1759         // unmarshal parameters
1760         c.openReceivePrimitive(5);
1761         int p0 = c.receiveInt();
1762         boolean p1 = c.receiveBoolean();
1763         c.closeReceivePrimitive(5);
1764         c.closeReceiveCall();
1765 
1766         int result;
1767         try {
1768           // call the implementation
1769           result = impl.run_ModelCluster_client_nr_inc_(p0, p1);
1770         } catch (Throwable ex) {
1771           // marshal the server-side exception
1772           c.openSendResult(false);
1773           c.sendObject(ex);
1774           return;
1775         }
1776 
1777         // marshal the return value
1778         c.openSendResult(true);
1779         c.sendSingleInt(result);
1780         return;
1781       }
1782 
1783       case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_cluster_nodes_get_$: {
1784         // unmarshal parameters
1785         c.closeReceiveCall();
1786 
1787         run.ModelCluster[] result;
1788         try {
1789           // call the implementation
1790           result = impl.run_ModelCluster_cluster_nodes_get_();
1791         } catch (Throwable ex) {
1792           // marshal the server-side exception
1793           c.openSendResult(false);
1794           c.sendObject(ex);
1795           return;
1796         }
1797 
1798         // marshal the return value
1799         c.openSendResult(true);
1800         c.sendObject(result);
1801         return;
1802       }
1803 
1804       case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_cluster_nodes_set_$_run_ModelCluster: {
1805         // unmarshal parameters
1806         run.ModelCluster[] p0 = (run.ModelCluster[]) c.receiveObject();
1807         c.closeReceiveCall();
1808 
1809         run.ModelCluster[] result;
1810         try {
1811           // call the implementation
1812           result = impl.run_ModelCluster_cluster_nodes_set_(p0);
1813         } catch (Throwable ex) {
1814           // marshal the server-side exception
1815           c.openSendResult(false);
1816           c.sendObject(ex);
1817           return;
1818         }
1819 
1820         // marshal the return value
1821         c.openSendResult(true);
1822         c.sendObject(result);
1823         return;
1824       }
1825 
1826       case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_cluster_nodes_get_$int: {
1827         // unmarshal parameters
1828         c.openReceivePrimitive(4);
1829         int p0 = c.receiveInt();
1830         c.closeReceivePrimitive(4);
1831         c.closeReceiveCall();
1832 
1833         run.ModelCluster result;
1834         try {
1835           // call the implementation
1836           result = impl.run_ModelCluster_cluster_nodes_get_(p0);
1837         } catch (Throwable ex) {
1838           // marshal the server-side exception
1839           c.openSendResult(false);
1840           c.sendObject(ex);
1841           return;
1842         }
1843 
1844         // marshal the return value
1845         c.openSendResult(true);
1846         c.sendObject(result);
1847         return;
1848       }
1849 
1850       case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_cluster_nodes_set_$int$run_ModelCluster: {
1851         // unmarshal parameters
1852         c.openReceivePrimitive(4);
1853         int p0 = c.receiveInt();
1854         c.closeReceivePrimitive(4);
1855         run.ModelCluster p1 = (run.ModelCluster) c.receiveObject();
1856         c.closeReceiveCall();
1857 
1858         run.ModelCluster result;
1859         try {
1860           // call the implementation
1861           result = impl.run_ModelCluster_cluster_nodes_set_(p0, p1);
1862         } catch (Throwable ex) {
1863           // marshal the server-side exception
1864           c.openSendResult(false);
1865           c.sendObject(ex);
1866           return;
1867         }
1868 
1869         // marshal the return value
1870         c.openSendResult(true);
1871         c.sendObject(result);
1872         return;
1873       }
1874 
1875       case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_nodeindicies_get_$: {
1876         // unmarshal parameters
1877         c.closeReceiveCall();
1878 
1879         int[] result;
1880         try {
1881           // call the implementation
1882           result = impl.run_ModelCluster_nodeindicies_get_();
1883         } catch (Throwable ex) {
1884           // marshal the server-side exception
1885           c.openSendResult(false);
1886           c.sendObject(ex);
1887           return;
1888         }
1889 
1890         // marshal the return value
1891         c.openSendResult(true);
1892         c.sendObject(result);
1893         return;
1894       }
1895 
1896       case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_nodeindicies_set_$_int: {
1897         // unmarshal parameters
1898         int[] p0 = (int[]) c.receiveObject();
1899         c.closeReceiveCall();
1900 
1901         int[] result;
1902         try {
1903           // call the implementation
1904           result = impl.run_ModelCluster_nodeindicies_set_(p0);
1905         } catch (Throwable ex) {
1906           // marshal the server-side exception
1907           c.openSendResult(false);
1908           c.sendObject(ex);
1909           return;
1910         }
1911 
1912         // marshal the return value
1913         c.openSendResult(true);
1914         c.sendObject(result);
1915         return;
1916       }
1917 
1918       case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_nodeindicies_get_$int: {
1919         // unmarshal parameters
1920         c.openReceivePrimitive(4);
1921         int p0 = c.receiveInt();
1922         c.closeReceivePrimitive(4);
1923         c.closeReceiveCall();
1924 
1925         int result;
1926         try {
1927           // call the implementation
1928           result = impl.run_ModelCluster_nodeindicies_get_(p0);
1929         } catch (Throwable ex) {
1930           // marshal the server-side exception
1931           c.openSendResult(false);
1932           c.sendObject(ex);
1933           return;
1934         }
1935 
1936         // marshal the return value
1937         c.openSendResult(true);
1938         c.sendSingleInt(result);
1939         return;
1940       }
1941 
1942       case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_nodeindicies_set_$int$int: {
1943         // unmarshal parameters
1944         c.openReceivePrimitive(8);
1945         int p0 = c.receiveInt();
1946         int p1 = c.receiveInt();
1947         c.closeReceivePrimitive(8);
1948         c.closeReceiveCall();
1949 
1950         int result;
1951         try {
1952           // call the implementation
1953           result = impl.run_ModelCluster_nodeindicies_set_(p0, p1);
1954         } catch (Throwable ex) {
1955           // marshal the server-side exception
1956           c.openSendResult(false);
1957           c.sendObject(ex);
1958           return;
1959         }
1960 
1961         // marshal the return value
1962         c.openSendResult(true);
1963         c.sendSingleInt(result);
1964         return;
1965       }
1966 
1967       case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_nodeindicies_inc_$int$int$boolean: {
1968         // unmarshal parameters
1969         c.openReceivePrimitive(9);
1970         int p0 = c.receiveInt();
1971         int p1 = c.receiveInt();
1972         boolean p2 = c.receiveBoolean();
1973         c.closeReceivePrimitive(9);
1974         c.closeReceiveCall();
1975 
1976         int result;
1977         try {
1978           // call the implementation
1979           result = impl.run_ModelCluster_nodeindicies_inc_(p0, p1, p2);
1980         } catch (Throwable ex) {
1981           // marshal the server-side exception
1982           c.openSendResult(false);
1983           c.sendObject(ex);
1984           return;
1985         }
1986 
1987         // marshal the return value
1988         c.openSendResult(true);
1989         c.sendSingleInt(result);
1990         return;
1991       }
1992 
1993       case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_elementindicies_get_$: {
1994         // unmarshal parameters
1995         c.closeReceiveCall();
1996 
1997         int[] result;
1998         try {
1999           // call the implementation
2000           result = impl.run_ModelCluster_elementindicies_get_();
2001         } catch (Throwable ex) {
2002           // marshal the server-side exception
2003           c.openSendResult(false);
2004           c.sendObject(ex);
2005           return;
2006         }
2007 
2008         // marshal the return value
2009         c.openSendResult(true);
2010         c.sendObject(result);
2011         return;
2012       }
2013 
2014       case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_elementindicies_set_$_int: {
2015         // unmarshal parameters
2016         int[] p0 = (int[]) c.receiveObject();
2017         c.closeReceiveCall();
2018 
2019         int[] result;
2020         try {
2021           // call the implementation
2022           result = impl.run_ModelCluster_elementindicies_set_(p0);
2023         } catch (Throwable ex) {
2024           // marshal the server-side exception
2025           c.openSendResult(false);
2026           c.sendObject(ex);
2027           return;
2028         }
2029 
2030         // marshal the return value
2031         c.openSendResult(true);
2032         c.sendObject(result);
2033         return;
2034       }
2035 
2036       case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_elementindicies_get_$int: {
2037         // unmarshal parameters
2038         c.openReceivePrimitive(4);
2039         int p0 = c.receiveInt();
2040         c.closeReceivePrimitive(4);
2041         c.closeReceiveCall();
2042 
2043         int result;
2044         try {
2045           // call the implementation
2046           result = impl.run_ModelCluster_elementindicies_get_(p0);
2047         } catch (Throwable ex) {
2048           // marshal the server-side exception
2049           c.openSendResult(false);
2050           c.sendObject(ex);
2051           return;
2052         }
2053 
2054         // marshal the return value
2055         c.openSendResult(true);
2056         c.sendSingleInt(result);
2057         return;
2058       }
2059 
2060       case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_elementindicies_set_$int$int: {
2061         // unmarshal parameters
2062         c.openReceivePrimitive(8);
2063         int p0 = c.receiveInt();
2064         int p1 = c.receiveInt();
2065         c.closeReceivePrimitive(8);
2066         c.closeReceiveCall();
2067 
2068         int result;
2069         try {
2070           // call the implementation
2071           result = impl.run_ModelCluster_elementindicies_set_(p0, p1);
2072         } catch (Throwable ex) {
2073           // marshal the server-side exception
2074           c.openSendResult(false);
2075           c.sendObject(ex);
2076           return;
2077         }
2078 
2079         // marshal the return value
2080         c.openSendResult(true);
2081         c.sendSingleInt(result);
2082         return;
2083       }
2084 
2085       case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_elementindicies_inc_$int$int$boolean: {
2086         // unmarshal parameters
2087         c.openReceivePrimitive(9);
2088         int p0 = c.receiveInt();
2089         int p1 = c.receiveInt();
2090         boolean p2 = c.receiveBoolean();
2091         c.closeReceivePrimitive(9);
2092         c.closeReceiveCall();
2093 
2094         int result;
2095         try {
2096           // call the implementation
2097           result = impl.run_ModelCluster_elementindicies_inc_(p0, p1, p2);
2098         } catch (Throwable ex) {
2099           // marshal the server-side exception
2100           c.openSendResult(false);
2101           c.sendObject(ex);
2102           return;
2103         }
2104 
2105         // marshal the return value
2106         c.openSendResult(true);
2107         c.sendSingleInt(result);
2108         return;
2109       }
2110 
2111       case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_benchmark_get_$: {
2112         // unmarshal parameters
2113         c.closeReceiveCall();
2114 
2115         long result;
2116         try {
2117           // call the implementation
2118           result = impl.run_ModelCluster_benchmark_get_();
2119         } catch (Throwable ex) {
2120           // marshal the server-side exception
2121           c.openSendResult(false);
2122           c.sendObject(ex);
2123           return;
2124         }
2125 
2126         // marshal the return value
2127         c.openSendResult(true);
2128         c.sendSingleLong(result);
2129         return;
2130       }
2131 
2132       case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_benchmark_set_$long: {
2133         // unmarshal parameters
2134         c.openReceivePrimitive(8);
2135         long p0 = c.receiveLong();
2136         c.closeReceivePrimitive(8);
2137         c.closeReceiveCall();
2138 
2139         long result;
2140         try {
2141           // call the implementation
2142           result = impl.run_ModelCluster_benchmark_set_(p0);
2143         } catch (Throwable ex) {
2144           // marshal the server-side exception
2145           c.openSendResult(false);
2146           c.sendObject(ex);
2147           return;
2148         }
2149 
2150         // marshal the return value
2151         c.openSendResult(true);
2152         c.sendSingleLong(result);
2153         return;
2154       }
2155 
2156       case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_benchmark_inc_$long$boolean: {
2157         // unmarshal parameters
2158         c.openReceivePrimitive(9);
2159         long p0 = c.receiveLong();
2160         boolean p1 = c.receiveBoolean();
2161         c.closeReceivePrimitive(9);
2162         c.closeReceiveCall();
2163 
2164         long result;
2165         try {
2166           // call the implementation
2167           result = impl.run_ModelCluster_benchmark_inc_(p0, p1);
2168         } catch (Throwable ex) {
2169           // marshal the server-side exception
2170           c.openSendResult(false);
2171           c.sendObject(ex);
2172           return;
2173         }
2174 
2175         // marshal the return value
2176         c.openSendResult(true);
2177         c.sendSingleLong(result);
2178         return;
2179       }
2180 
2181       case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_barrier_get_$: {
2182         // unmarshal parameters
2183         c.closeReceiveCall();
2184 
2185         jp.sync.Barrier result;
2186         try {
2187           // call the implementation
2188           result = impl.run_ModelCluster_barrier_get_();
2189         } catch (Throwable ex) {
2190           // marshal the server-side exception
2191           c.openSendResult(false);
2192           c.sendObject(ex);
2193           return;
2194         }
2195 
2196         // marshal the return value
2197         c.openSendResult(true);
2198         c.sendObject(result);
2199         return;
2200       }
2201 
2202       case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_barrier_set_$jp_sync_Barrier: {
2203         // unmarshal parameters
2204         jp.sync.Barrier p0 = (jp.sync.Barrier) c.receiveObject();
2205         c.closeReceiveCall();
2206 
2207         jp.sync.Barrier result;
2208         try {
2209           // call the implementation
2210           result = impl.run_ModelCluster_barrier_set_(p0);
2211         } catch (Throwable ex) {
2212           // marshal the server-side exception
2213           c.openSendResult(false);
2214           c.sendObject(ex);
2215           return;
2216         }
2217 
2218         // marshal the return value
2219         c.openSendResult(true);
2220         c.sendObject(result);
2221         return;
2222       }
2223 
2224       case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_exception_listeners_get_$: {
2225         // unmarshal parameters
2226         c.closeReceiveCall();
2227 
2228         java.util.Set result;
2229         try {
2230           // call the implementation
2231           result = impl.run_ModelCluster_exception_listeners_get_();
2232         } catch (Throwable ex) {
2233           // marshal the server-side exception
2234           c.openSendResult(false);
2235           c.sendObject(ex);
2236           return;
2237         }
2238 
2239         // marshal the return value
2240         c.openSendResult(true);
2241         c.sendObject(result);
2242         return;
2243       }
2244 
2245       case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_exception_listeners_set_$java_util_Set: {
2246         // unmarshal parameters
2247         java.util.Set p0 = (java.util.Set) c.receiveObject();
2248         c.closeReceiveCall();
2249 
2250         java.util.Set result;
2251         try {
2252           // call the implementation
2253           result = impl.run_ModelCluster_exception_listeners_set_(p0);
2254         } catch (Throwable ex) {
2255           // marshal the server-side exception
2256           c.openSendResult(false);
2257           c.sendObject(ex);
2258           return;
2259         }
2260 
2261         // marshal the return value
2262         c.openSendResult(true);
2263         c.sendObject(result);
2264         return;
2265       }
2266 
2267       case run.ModelCluster_instance_impl_KStub.ID_assembleMassMatrix$: {
2268         // unmarshal parameters
2269         c.closeReceiveCall();
2270 
2271         try {
2272           // call the implementation
2273           impl.assembleMassMatrix();
2274         } catch (Throwable ex) {
2275           // marshal the server-side exception
2276           c.openSendResult(false);
2277           c.sendObject(ex);
2278           return;
2279         }
2280 
2281         // marshal the return value
2282         c.openSendResult(true);
2283         return;
2284       }
2285 
2286       case run.ModelCluster_instance_impl_KStub.ID_initialize$: {
2287         // unmarshal parameters
2288         c.closeReceiveCall();
2289 
2290         try {
2291           // call the implementation
2292           impl.initialize();
2293         } catch (Throwable ex) {
2294           // marshal the server-side exception
2295           c.openSendResult(false);
2296           c.sendObject(ex);
2297           return;
2298         }
2299 
2300         // marshal the return value
2301         c.openSendResult(true);
2302         return;
2303       }
2304 
2305       case run.ModelCluster_instance_impl_KStub.ID_post$: {
2306         // unmarshal parameters
2307         c.closeReceiveCall();
2308 
2309         try {
2310           // call the implementation
2311           impl.post();
2312         } catch (Throwable ex) {
2313           // marshal the server-side exception
2314           c.openSendResult(false);
2315           c.sendObject(ex);
2316           return;
2317         }
2318 
2319         // marshal the return value
2320         c.openSendResult(true);
2321         return;
2322       }
2323 
2324       case run.ModelCluster_instance_impl_KStub.ID_print$: {
2325         // unmarshal parameters
2326         c.closeReceiveCall();
2327 
2328         try {
2329           // call the implementation
2330           impl.print();
2331         } catch (Throwable ex) {
2332           // marshal the server-side exception
2333           c.openSendResult(false);
2334           c.sendObject(ex);
2335           return;
2336         }
2337 
2338         // marshal the return value
2339         c.openSendResult(true);
2340         return;
2341       }
2342 
2343       case run.ModelCluster_instance_impl_KStub.ID_setInitialConditions$: {
2344         // unmarshal parameters
2345         c.closeReceiveCall();
2346 
2347         try {
2348           // call the implementation
2349           impl.setInitialConditions();
2350         } catch (Throwable ex) {
2351           // marshal the server-side exception
2352           c.openSendResult(false);
2353           c.sendObject(ex);
2354           return;
2355         }
2356 
2357         // marshal the return value
2358         c.openSendResult(true);
2359         return;
2360       }
2361 
2362       case run.ModelCluster_instance_impl_KStub.ID_solve$jp_sync_Barrier: {
2363         // unmarshal parameters
2364         jp.sync.Barrier p0 = (jp.sync.Barrier) c.receiveObject();
2365         c.closeReceiveCall();
2366 
2367         try {
2368           // call the implementation
2369           impl.solve(p0);
2370         } catch (Throwable ex) {
2371           // marshal the server-side exception
2372           c.openSendResult(false);
2373           c.sendObject(ex);
2374           return;
2375         }
2376 
2377         // marshal the return value
2378         c.openSendResult(true);
2379         return;
2380       }
2381 
2382       case run.ModelCluster_instance_impl_KStub.ID_passReferences$: {
2383         // unmarshal parameters
2384         c.closeReceiveCall();
2385 
2386         try {
2387           // call the implementation
2388           impl.passReferences();
2389         } catch (Throwable ex) {
2390           // marshal the server-side exception
2391           c.openSendResult(false);
2392           c.sendObject(ex);
2393           return;
2394         }
2395 
2396         // marshal the return value
2397         c.openSendResult(true);
2398         return;
2399       }
2400 
2401       case run.ModelCluster_instance_impl_KStub.ID_setReferences$run_SharedData: {
2402         // unmarshal parameters
2403         run.SharedData p0 = (run.SharedData) c.receiveObject();
2404         c.closeReceiveCall();
2405 
2406         try {
2407           // call the implementation
2408           impl.setReferences(p0);
2409         } catch (Throwable ex) {
2410           // marshal the server-side exception
2411           c.openSendResult(false);
2412           c.sendObject(ex);
2413           return;
2414         }
2415 
2416         // marshal the return value
2417         c.openSendResult(true);
2418         return;
2419       }
2420 
2421       case run.ModelCluster_instance_impl_KStub.ID_getTtemp$: {
2422         // unmarshal parameters
2423         c.closeReceiveCall();
2424 
2425         double result;
2426         try {
2427           // call the implementation
2428           result = impl.getTtemp();
2429         } catch (Throwable ex) {
2430           // marshal the server-side exception
2431           c.openSendResult(false);
2432           c.sendObject(ex);
2433           return;
2434         }
2435 
2436         // marshal the return value
2437         c.openSendResult(true);
2438         c.sendSingleDouble(result);
2439         return;
2440       }
2441 
2442       case run.ModelCluster_instance_impl_KStub.ID_determineDistribution$: {
2443         // unmarshal parameters
2444         c.closeReceiveCall();
2445 
2446         try {
2447           // call the implementation
2448           impl.determineDistribution();
2449         } catch (Throwable ex) {
2450           // marshal the server-side exception
2451           c.openSendResult(false);
2452           c.sendObject(ex);
2453           return;
2454         }
2455 
2456         // marshal the return value
2457         c.openSendResult(true);
2458         return;
2459       }
2460 
2461       case run.ModelCluster_instance_impl_KStub.ID_referenceNodes$: {
2462         // unmarshal parameters
2463         c.closeReceiveCall();
2464 
2465         try {
2466           // call the implementation
2467           impl.referenceNodes();
2468         } catch (Throwable ex) {
2469           // marshal the server-side exception
2470           c.openSendResult(false);
2471           c.sendObject(ex);
2472           return;
2473         }
2474 
2475         // marshal the return value
2476         c.openSendResult(true);
2477         return;
2478       }
2479 
2480       case run.ModelCluster_instance_impl_KStub.ID_optimize$: {
2481         // unmarshal parameters
2482         c.closeReceiveCall();
2483 
2484         try {
2485           // call the implementation
2486           impl.optimize();
2487         } catch (Throwable ex) {
2488           // marshal the server-side exception
2489           c.openSendResult(false);
2490           c.sendObject(ex);
2491           return;
2492         }
2493 
2494         // marshal the return value
2495         c.openSendResult(true);
2496         return;
2497       }
2498 
2499       case run.ModelCluster_instance_impl_KStub.ID_getBenchmark$: {
2500         // unmarshal parameters
2501         c.closeReceiveCall();
2502 
2503         long result;
2504         try {
2505           // call the implementation
2506           result = impl.getBenchmark();
2507         } catch (Throwable ex) {
2508           // marshal the server-side exception
2509           c.openSendResult(false);
2510           c.sendObject(ex);
2511           return;
2512         }
2513 
2514         // marshal the return value
2515         c.openSendResult(true);
2516         c.sendSingleLong(result);
2517         return;
2518       }
2519 
2520       case run.ModelCluster_instance_impl_KStub.ID_run$: {
2521         // unmarshal parameters
2522         c.closeReceiveCall();
2523 
2524         try {
2525           // call the implementation
2526           impl.run();
2527         } catch (Throwable ex) {
2528           // marshal the server-side exception
2529           c.openSendResult(false);
2530           c.sendObject(ex);
2531           return;
2532         }
2533 
2534         // marshal the return value
2535         c.openSendResult(true);
2536         return;
2537       }
2538 
2539       case run.ModelCluster_instance_impl_KStub.ID_stopThreads$: {
2540         // unmarshal parameters
2541         c.closeReceiveCall();
2542 
2543         try {
2544           // call the implementation
2545           impl.stopThreads();
2546         } catch (Throwable ex) {
2547           // marshal the server-side exception
2548           c.openSendResult(false);
2549           c.sendObject(ex);
2550           return;
2551         }
2552 
2553         // marshal the return value
2554         c.openSendResult(true);
2555         return;
2556       }
2557 
2558       case run.ModelCluster_instance_impl_KStub.ID_sendException$java_lang_Exception: {
2559         // unmarshal parameters
2560         java.lang.Exception p0 = (java.lang.Exception) c.receiveObject();
2561         c.closeReceiveCall();
2562 
2563         try {
2564           // call the implementation
2565           impl.sendException(p0);
2566         } catch (Throwable ex) {
2567           // marshal the server-side exception
2568           c.openSendResult(false);
2569           c.sendObject(ex);
2570           return;
2571         }
2572 
2573         // marshal the return value
2574         c.openSendResult(true);
2575         return;
2576       }
2577 
2578       case run.ModelCluster_instance_impl_KStub.ID_addExceptionListener$run_ExceptionListener: {
2579         // unmarshal parameters
2580         run.ExceptionListener p0 = (run.ExceptionListener) c.receiveObject();
2581         c.closeReceiveCall();
2582 
2583         try {
2584           // call the implementation
2585           impl.addExceptionListener(p0);
2586         } catch (Throwable ex) {
2587           // marshal the server-side exception
2588           c.openSendResult(false);
2589           c.sendObject(ex);
2590           return;
2591         }
2592 
2593         // marshal the return value
2594         c.openSendResult(true);
2595         return;
2596       }
2597 
2598       case run.ModelCluster_instance_impl_KStub.ID_setCluster_nodes$_run_ModelCluster: {
2599         // unmarshal parameters
2600         run.ModelCluster[] p0 = (run.ModelCluster[]) c.receiveObject();
2601         c.closeReceiveCall();
2602 
2603         try {
2604           // call the implementation
2605           impl.setCluster_nodes(p0);
2606         } catch (Throwable ex) {
2607           // marshal the server-side exception
2608           c.openSendResult(false);
2609           c.sendObject(ex);
2610           return;
2611         }
2612 
2613         // marshal the return value
2614         c.openSendResult(true);
2615         return;
2616       }
2617 
2618       case run.ModelCluster_instance_impl_KStub.ID__wait$: {
2619         // unmarshal parameters
2620         c.closeReceiveCall();
2621 
2622         try {
2623           // call the implementation
2624           impl._wait();
2625         } catch (Throwable ex) {
2626           // marshal the server-side exception
2627           c.openSendResult(false);
2628           c.sendObject(ex);
2629           return;
2630         }
2631 
2632         // marshal the return value
2633         c.openSendResult(true);
2634         return;
2635       }
2636 
2637       case run.ModelCluster_instance_impl_KStub.ID__wait$long: {
2638         // unmarshal parameters
2639         c.openReceivePrimitive(8);
2640         long p0 = c.receiveLong();
2641         c.closeReceivePrimitive(8);
2642         c.closeReceiveCall();
2643 
2644         try {
2645           // call the implementation
2646           impl._wait(p0);
2647         } catch (Throwable ex) {
2648           // marshal the server-side exception
2649           c.openSendResult(false);
2650           c.sendObject(ex);
2651           return;
2652         }
2653 
2654         // marshal the return value
2655         c.openSendResult(true);
2656         return;
2657       }
2658 
2659       case run.ModelCluster_instance_impl_KStub.ID__wait$long$int: {
2660         // unmarshal parameters
2661         c.openReceivePrimitive(12);
2662         long p0 = c.receiveLong();
2663         int p1 = c.receiveInt();
2664         c.closeReceivePrimitive(12);
2665         c.closeReceiveCall();
2666 
2667         try {
2668           // call the implementation
2669           impl._wait(p0, p1);
2670         } catch (Throwable ex) {
2671           // marshal the server-side exception
2672           c.openSendResult(false);
2673           c.sendObject(ex);
2674           return;
2675         }
2676 
2677         // marshal the return value
2678         c.openSendResult(true);
2679         return;
2680       }
2681 
2682       case run.ModelCluster_instance_impl_KStub.ID__notify$: {
2683         // unmarshal parameters
2684         c.closeReceiveCall();
2685 
2686         try {
2687           // call the implementation
2688           impl._notify();
2689         } catch (Throwable ex) {
2690           // marshal the server-side exception
2691           c.openSendResult(false);
2692           c.sendObject(ex);
2693           return;
2694         }
2695 
2696         // marshal the return value
2697         c.openSendResult(true);
2698         return;
2699       }
2700 
2701       case run.ModelCluster_instance_impl_KStub.ID__notifyAll$: {
2702         // unmarshal parameters
2703         c.closeReceiveCall();
2704 
2705         try {
2706           // call the implementation
2707           impl._notifyAll();
2708         } catch (Throwable ex) {
2709           // marshal the server-side exception
2710           c.openSendResult(false);
2711           c.sendObject(ex);
2712           return;
2713         }
2714 
2715         // marshal the return value
2716         c.openSendResult(true);
2717         return;
2718       }
2719 
2720       case run.ModelCluster_instance_impl_KStub.ID__equals$java_lang_Object: {
2721         // unmarshal parameters
2722         java.lang.Object p0 = (java.lang.Object) c.receiveObject();
2723         c.closeReceiveCall();
2724 
2725         boolean result;
2726         try {
2727           // call the implementation
2728           result = impl._equals(p0);
2729         } catch (Throwable ex) {
2730           // marshal the server-side exception
2731           c.openSendResult(false);
2732           c.sendObject(ex);
2733           return;
2734         }
2735 
2736         // marshal the return value
2737         c.openSendResult(true);
2738         c.sendSingleBoolean(result);
2739         return;
2740       }
2741 
2742       case run.ModelCluster_instance_impl_KStub.ID__location$: {
2743         // unmarshal parameters
2744         c.closeReceiveCall();
2745 
2746         int result;
2747         try {
2748           // call the implementation
2749           result = impl._location();
2750         } catch (Throwable ex) {
2751           // marshal the server-side exception
2752           c.openSendResult(false);
2753           c.sendObject(ex);
2754           return;
2755         }
2756 
2757         // marshal the return value
2758         c.openSendResult(true);
2759         c.sendSingleInt(result);
2760         return;
2761       }
2762 
2763       case run.ModelCluster_instance_impl_KStub.ID__migrateTo$jp_lang_VirtualMachine: {
2764         // unmarshal parameters
2765         jp.lang.VirtualMachine p0 = (jp.lang.VirtualMachine) c.receiveObject();
2766         c.closeReceiveCall();
2767 
2768         java.lang.Object result;
2769         try {
2770           // call the implementation
2771           result = impl._migrateTo(p0);
2772         } catch (Throwable ex) {
2773           // marshal the server-side exception
2774           c.openSendResult(false);
2775           c.sendObject(ex);
2776           return;
2777         }
2778 
2779         // marshal the return value
2780         c.openSendResult(true);
2781         c.sendObject(result);
2782         return;
2783       }
2784 
2785       default:
2786         throw new InternalError("illegal method number (" + c.mid + ")");
2787       }
2788   }
2789 }
2790