git.oblomov.eu Git - wine/blob - dlls/oleaut32/oaidl_p.c

   1 /* This file contains the proxy/stub code for core COM interfaces.
   2
   3    It is usually generated directly by MIDL, however this file has
   4    been tweaked since then to account for slight differences in the way
   5    gcc and MSVC++ compile it. In particular, in some functions REFIIDs
   6    declared on the stack have been converted to plain IID* in order to eliminate
   7    the constness of the REFIID type, ensuring that the zero initializer is not
   8    discarded.
   9
  10    Therefore, please do not regenerate this file.
  11 */
  12
  13 /* File created by MIDL compiler version 5.01.0164 */
  14 /* at Tue Jan 07 22:24:52 2003
  15  */
  16 /* Compiler settings for oaidl.idl:
  17     Os (OptLev=s), W1, Zp8, env=Win32, ms_ext, c_ext
  18     error checks: allocation ref bounds_check enum stub_data
  19 */
  20 /*@@MIDL_FILE_HEADING(  ) */
  21
  22
  23 /* verify that the <rpcproxy.h> version is high enough to compile this file*/
  24 #ifndef __REDQ_RPCPROXY_H_VERSION__
  25 #define __REQUIRED_RPCPROXY_H_VERSION__ 440
  26 #endif
  27
  28
  29 #include <stdarg.h>
  30
  31 #define COBJMACROS
  32
  33 #include "windef.h"
  34 #include "winbase.h"
  35 #include "objbase.h"
  36 #include "rpcproxy.h"
  37 #ifndef __RPCPROXY_H_VERSION__
  38 #error this stub requires an updated version of <rpcproxy.h>
  39 #endif /* __RPCPROXY_H_VERSION__ */
  40
  41
  42 #include "oaidl.h"
  43
  44 #define TYPE_FORMAT_STRING_SIZE   1907
  45 #define PROC_FORMAT_STRING_SIZE   495
  46
  47 typedef struct _MIDL_TYPE_FORMAT_STRING
  48     {
  49     short          Pad;
  50     unsigned char  Format[ TYPE_FORMAT_STRING_SIZE ];
  51     } MIDL_TYPE_FORMAT_STRING;
  52
  53 typedef struct _MIDL_PROC_FORMAT_STRING
  54     {
  55     short          Pad;
  56     unsigned char  Format[ PROC_FORMAT_STRING_SIZE ];
  57     } MIDL_PROC_FORMAT_STRING;
  58
  59
  60 static const MIDL_TYPE_FORMAT_STRING __MIDL_TypeFormatString;
  61 static const MIDL_PROC_FORMAT_STRING __MIDL_ProcFormatString;
  62
  63
  64 /* Standard interface: __MIDL_itf_oaidl_0000, ver. 0.0,
  65    GUID={0x00000000,0x0000,0x0000,{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00}} */
  66
  67
  68 /* Standard interface: IOleAutomationTypes, ver. 1.0,
  69    GUID={0x00000000,0x0000,0x0000,{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00}} */
  70
  71
  72 /* Object interface: IUnknown, ver. 0.0,
  73    GUID={0x00000000,0x0000,0x0000,{0xC0,0x00,0x00,0x00,0x00,0x00,0x00,0x46}} */
  74
  75
  76 /* Object interface: IDispatch, ver. 0.0,
  77    GUID={0x00020400,0x0000,0x0000,{0xC0,0x00,0x00,0x00,0x00,0x00,0x00,0x46}} */
  78
  79
  80 static const MIDL_STUB_DESC Object_StubDesc;
  81
  82
  83 HRESULT STDMETHODCALLTYPE IDispatch_GetTypeInfoCount_Proxy(
  84     IDispatch __RPC_FAR * This,
  85     /* [out] */ UINT __RPC_FAR *pctinfo)
  86 {
  87
  88     HRESULT _RetVal;
  89
  90     RPC_MESSAGE _RpcMessage;
  91
  92     MIDL_STUB_MESSAGE _StubMsg;
  93
  94     RpcTryExcept
  95         {
  96         NdrProxyInitialize(
  97                       ( void __RPC_FAR *  )This,
  98                       ( PRPC_MESSAGE  )&_RpcMessage,
  99                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
 100                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
 101                       3);
 102
 103
 104
 105         if(!pctinfo)
 106             {
 107             RpcRaiseException(RPC_X_NULL_REF_POINTER);
 108             }
 109         RpcTryFinally
 110             {
 111
 112             _StubMsg.BufferLength = 0U;
 113             NdrProxyGetBuffer(This, &_StubMsg);
 114             NdrProxySendReceive(This, &_StubMsg);
 115
 116             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
 117                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[0] );
 118
 119             *pctinfo = *( UINT __RPC_FAR * )_StubMsg.Buffer;
 120             _StubMsg.Buffer += sizeof(UINT);
 121
 122             _RetVal = *( HRESULT __RPC_FAR * )_StubMsg.Buffer;
 123             _StubMsg.Buffer += sizeof(HRESULT);
 124
 125             }
 126         RpcFinally
 127             {
 128             NdrProxyFreeBuffer(This, &_StubMsg);
 129
 130             }
 131         RpcEndFinally
 132
 133         }
 134     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
 135         {
 136         NdrClearOutParameters(
 137                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
 138                          ( PFORMAT_STRING  )&__MIDL_TypeFormatString.Format[2],
 139                          ( void __RPC_FAR * )pctinfo);
 140         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
 141         }
 142     RpcEndExcept
 143     return _RetVal;
 144 }
 145
 146 void __RPC_STUB IDispatch_GetTypeInfoCount_Stub(
 147     IRpcStubBuffer *This,
 148     IRpcChannelBuffer *_pRpcChannelBuffer,
 149     PRPC_MESSAGE _pRpcMessage,
 150     DWORD *_pdwStubPhase)
 151 {
 152     UINT _M0;
 153     HRESULT _RetVal;
 154     MIDL_STUB_MESSAGE _StubMsg;
 155     UINT __RPC_FAR *pctinfo;
 156
 157 NdrStubInitialize(
 158                      _pRpcMessage,
 159                      &_StubMsg,
 160                      &Object_StubDesc,
 161                      _pRpcChannelBuffer);
 162     pctinfo = 0;
 163     RpcTryFinally
 164         {
 165         pctinfo = &_M0;
 166
 167         *_pdwStubPhase = STUB_CALL_SERVER;
 168         _RetVal = (((IDispatch*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> GetTypeInfoCount((IDispatch *) ((CStdStubBuffer *)This)->pvServerObject,pctinfo);
 169
 170         *_pdwStubPhase = STUB_MARSHAL;
 171
 172         _StubMsg.BufferLength = 4U + 4U;
 173         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
 174         *( UINT __RPC_FAR * )_StubMsg.Buffer = *pctinfo;
 175         _StubMsg.Buffer += sizeof(UINT);
 176
 177         *( HRESULT __RPC_FAR * )_StubMsg.Buffer = _RetVal;
 178         _StubMsg.Buffer += sizeof(HRESULT);
 179
 180         }
 181     RpcFinally
 182         {
 183         }
 184     RpcEndFinally
 185     _pRpcMessage->BufferLength =
 186         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
 187
 188 }
 189
 190
 191 HRESULT STDMETHODCALLTYPE IDispatch_GetTypeInfo_Proxy(
 192     IDispatch __RPC_FAR * This,
 193     /* [in] */ UINT iTInfo,
 194     /* [in] */ LCID lcid,
 195     /* [out] */ ITypeInfo __RPC_FAR *__RPC_FAR *ppTInfo)
 196 {
 197
 198     HRESULT _RetVal;
 199
 200     RPC_MESSAGE _RpcMessage;
 201
 202     MIDL_STUB_MESSAGE _StubMsg;
 203
 204     if(ppTInfo)
 205         {
 206         MIDL_memset(
 207                ppTInfo,
 208                0,
 209                sizeof( ITypeInfo __RPC_FAR *__RPC_FAR * ));
 210         }
 211     RpcTryExcept
 212         {
 213         NdrProxyInitialize(
 214                       ( void __RPC_FAR *  )This,
 215                       ( PRPC_MESSAGE  )&_RpcMessage,
 216                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
 217                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
 218                       4);
 219
 220
 221
 222         if(!ppTInfo)
 223             {
 224             RpcRaiseException(RPC_X_NULL_REF_POINTER);
 225             }
 226         RpcTryFinally
 227             {
 228
 229             _StubMsg.BufferLength = 4U + 4U;
 230             NdrProxyGetBuffer(This, &_StubMsg);
 231             *( UINT __RPC_FAR * )_StubMsg.Buffer = iTInfo;
 232             _StubMsg.Buffer += sizeof(UINT);
 233
 234             *( LCID __RPC_FAR * )_StubMsg.Buffer = lcid;
 235             _StubMsg.Buffer += sizeof(LCID);
 236
 237             NdrProxySendReceive(This, &_StubMsg);
 238
 239             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
 240                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[6] );
 241
 242             NdrPointerUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
 243                                   (unsigned char __RPC_FAR * __RPC_FAR *)&ppTInfo,
 244                                   (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[6],
 245                                   (unsigned char)0 );
 246
 247             _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
 248             _RetVal = *( HRESULT __RPC_FAR * )_StubMsg.Buffer;
 249             _StubMsg.Buffer += sizeof(HRESULT);
 250
 251             }
 252         RpcFinally
 253             {
 254             NdrProxyFreeBuffer(This, &_StubMsg);
 255
 256             }
 257         RpcEndFinally
 258
 259         }
 260     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
 261         {
 262         NdrClearOutParameters(
 263                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
 264                          ( PFORMAT_STRING  )&__MIDL_TypeFormatString.Format[6],
 265                          ( void __RPC_FAR * )ppTInfo);
 266         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
 267         }
 268     RpcEndExcept
 269     return _RetVal;
 270 }
 271
 272 void __RPC_STUB IDispatch_GetTypeInfo_Stub(
 273     IRpcStubBuffer *This,
 274     IRpcChannelBuffer *_pRpcChannelBuffer,
 275     PRPC_MESSAGE _pRpcMessage,
 276     DWORD *_pdwStubPhase)
 277 {
 278     ITypeInfo __RPC_FAR *_M1;
 279     HRESULT _RetVal;
 280     MIDL_STUB_MESSAGE _StubMsg;
 281     UINT iTInfo;
 282     LCID lcid;
 283     ITypeInfo __RPC_FAR *__RPC_FAR *ppTInfo;
 284
 285 NdrStubInitialize(
 286                      _pRpcMessage,
 287                      &_StubMsg,
 288                      &Object_StubDesc,
 289                      _pRpcChannelBuffer);
 290     ppTInfo = 0;
 291     RpcTryFinally
 292         {
 293         if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
 294             NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[6] );
 295
 296         iTInfo = *( UINT __RPC_FAR * )_StubMsg.Buffer;
 297         _StubMsg.Buffer += sizeof(UINT);
 298
 299         lcid = *( LCID __RPC_FAR * )_StubMsg.Buffer;
 300         _StubMsg.Buffer += sizeof(LCID);
 301
 302         ppTInfo = &_M1;
 303         _M1 = 0;
 304
 305         *_pdwStubPhase = STUB_CALL_SERVER;
 306         _RetVal = (((IDispatch*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> GetTypeInfo(
 307                (IDispatch *) ((CStdStubBuffer *)This)->pvServerObject,
 308                iTInfo,
 309                lcid,
 310                ppTInfo);
 311
 312         *_pdwStubPhase = STUB_MARSHAL;
 313
 314         _StubMsg.BufferLength = 0U + 4U;
 315         NdrPointerBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
 316                               (unsigned char __RPC_FAR *)ppTInfo,
 317                               (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[6] );
 318
 319         _StubMsg.BufferLength += 16;
 320
 321         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
 322         NdrPointerMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
 323                             (unsigned char __RPC_FAR *)ppTInfo,
 324                             (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[6] );
 325
 326         _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
 327         *( HRESULT __RPC_FAR * )_StubMsg.Buffer = _RetVal;
 328         _StubMsg.Buffer += sizeof(HRESULT);
 329
 330         }
 331     RpcFinally
 332         {
 333         NdrPointerFree( &_StubMsg,
 334                         (unsigned char __RPC_FAR *)ppTInfo,
 335                         &__MIDL_TypeFormatString.Format[6] );
 336
 337         }
 338     RpcEndFinally
 339     _pRpcMessage->BufferLength =
 340         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
 341
 342 }
 343
 344
 345 HRESULT STDMETHODCALLTYPE IDispatch_GetIDsOfNames_Proxy(
 346     IDispatch __RPC_FAR * This,
 347     /* [in] */ REFIID riid,
 348     /* [size_is][in] */ LPOLESTR __RPC_FAR *rgszNames,
 349     /* [in] */ UINT cNames,
 350     /* [in] */ LCID lcid,
 351     /* [size_is][out] */ DISPID __RPC_FAR *rgDispId)
 352 {
 353
 354     HRESULT _RetVal;
 355
 356     RPC_MESSAGE _RpcMessage;
 357
 358     MIDL_STUB_MESSAGE _StubMsg;
 359
 360     RpcTryExcept
 361         {
 362         NdrProxyInitialize(
 363                       ( void __RPC_FAR *  )This,
 364                       ( PRPC_MESSAGE  )&_RpcMessage,
 365                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
 366                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
 367                       5);
 368
 369
 370
 371         if(!riid)
 372             {
 373             RpcRaiseException(RPC_X_NULL_REF_POINTER);
 374             }
 375         if(!rgszNames)
 376             {
 377             RpcRaiseException(RPC_X_NULL_REF_POINTER);
 378             }
 379         if(!rgDispId)
 380             {
 381             RpcRaiseException(RPC_X_NULL_REF_POINTER);
 382             }
 383         RpcTryFinally
 384             {
 385
 386             _StubMsg.BufferLength = 0U + 7U + 7U + 7U;
 387             NdrSimpleStructBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
 388                                        (unsigned char __RPC_FAR *)riid,
 389                                        (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[38] );
 390
 391             _StubMsg.MaxCount = cNames;
 392
 393             NdrConformantArrayBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
 394                                           (unsigned char __RPC_FAR *)rgszNames,
 395                                           (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[54] );
 396
 397             NdrProxyGetBuffer(This, &_StubMsg);
 398             NdrSimpleStructMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
 399                                      (unsigned char __RPC_FAR *)riid,
 400                                      (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[38] );
 401
 402             _StubMsg.MaxCount = cNames;
 403
 404             NdrConformantArrayMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
 405                                         (unsigned char __RPC_FAR *)rgszNames,
 406                                         (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[54] );
 407
 408             _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
 409             *( UINT __RPC_FAR * )_StubMsg.Buffer = cNames;
 410             _StubMsg.Buffer += sizeof(UINT);
 411
 412             *( LCID __RPC_FAR * )_StubMsg.Buffer = lcid;
 413             _StubMsg.Buffer += sizeof(LCID);
 414
 415             NdrProxySendReceive(This, &_StubMsg);
 416
 417             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
 418                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[16] );
 419
 420             NdrConformantArrayUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
 421                                           (unsigned char __RPC_FAR * __RPC_FAR *)&rgDispId,
 422                                           (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[88],
 423                                           (unsigned char)0 );
 424
 425             _RetVal = *( HRESULT __RPC_FAR * )_StubMsg.Buffer;
 426             _StubMsg.Buffer += sizeof(HRESULT);
 427
 428             }
 429         RpcFinally
 430             {
 431             NdrProxyFreeBuffer(This, &_StubMsg);
 432
 433             }
 434         RpcEndFinally
 435
 436         }
 437     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
 438         {
 439         _StubMsg.MaxCount = cNames;
 440
 441         NdrClearOutParameters(
 442                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
 443                          ( PFORMAT_STRING  )&__MIDL_TypeFormatString.Format[84],
 444                          ( void __RPC_FAR * )rgDispId);
 445         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
 446         }
 447     RpcEndExcept
 448     return _RetVal;
 449 }
 450
 451 void __RPC_STUB IDispatch_GetIDsOfNames_Stub(
 452     IRpcStubBuffer *This,
 453     IRpcChannelBuffer *_pRpcChannelBuffer,
 454     PRPC_MESSAGE _pRpcMessage,
 455     DWORD *_pdwStubPhase)
 456 {
 457     HRESULT _RetVal;
 458     MIDL_STUB_MESSAGE _StubMsg;
 459     UINT cNames;
 460     LCID lcid;
 461     DISPID __RPC_FAR *rgDispId;
 462     LPOLESTR __RPC_FAR *rgszNames;
 463     IID* riid = 0;
 464
 465 NdrStubInitialize(
 466                      _pRpcMessage,
 467                      &_StubMsg,
 468                      &Object_StubDesc,
 469                      _pRpcChannelBuffer);
 470     rgszNames = 0;
 471     rgDispId = 0;
 472     RpcTryFinally
 473         {
 474         if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
 475             NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[16] );
 476
 477         NdrSimpleStructUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
 478                                    (unsigned char __RPC_FAR * __RPC_FAR *)&riid,
 479                                    (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[38],
 480                                    (unsigned char)0 );
 481
 482         NdrConformantArrayUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
 483                                       (unsigned char __RPC_FAR * __RPC_FAR *)&rgszNames,
 484                                       (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[54],
 485                                       (unsigned char)0 );
 486
 487         _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
 488         cNames = *( UINT __RPC_FAR * )_StubMsg.Buffer;
 489         _StubMsg.Buffer += sizeof(UINT);
 490
 491
 492         lcid = *( LCID __RPC_FAR * )_StubMsg.Buffer;
 493         _StubMsg.Buffer += sizeof(LCID);
 494
 495         rgDispId = NdrAllocate(&_StubMsg,cNames * 4);
 496
 497         *_pdwStubPhase = STUB_CALL_SERVER;
 498         _RetVal = (((IDispatch*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> GetIDsOfNames(
 499                  (IDispatch *) ((CStdStubBuffer *)This)->pvServerObject,
 500                  riid,
 501                  rgszNames,
 502                  cNames,
 503                  lcid,
 504                  rgDispId);
 505
 506         *_pdwStubPhase = STUB_MARSHAL;
 507
 508         _StubMsg.BufferLength = 4U + 7U;
 509         _StubMsg.MaxCount = cNames;
 510
 511         NdrConformantArrayBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
 512                                       (unsigned char __RPC_FAR *)rgDispId,
 513                                       (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[88] );
 514
 515         _StubMsg.BufferLength += 16;
 516
 517         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
 518         _StubMsg.MaxCount = cNames;
 519
 520         NdrConformantArrayMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
 521                                     (unsigned char __RPC_FAR *)rgDispId,
 522                                     (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[88] );
 523
 524         *( HRESULT __RPC_FAR * )_StubMsg.Buffer = _RetVal;
 525         _StubMsg.Buffer += sizeof(HRESULT);
 526
 527         }
 528     RpcFinally
 529         {
 530         _StubMsg.MaxCount = cNames;
 531
 532         NdrPointerFree( &_StubMsg,
 533                         (unsigned char __RPC_FAR *)rgszNames,
 534                         &__MIDL_TypeFormatString.Format[50] );
 535
 536         if ( rgDispId )
 537             _StubMsg.pfnFree( rgDispId );
 538
 539         }
 540     RpcEndFinally
 541     _pRpcMessage->BufferLength =
 542         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
 543
 544 }
 545
 546
 547 /* [call_as] */ HRESULT STDMETHODCALLTYPE IDispatch_RemoteInvoke_Proxy(
 548     IDispatch __RPC_FAR * This,
 549     /* [in] */ DISPID dispIdMember,
 550     /* [in] */ REFIID riid,
 551     /* [in] */ LCID lcid,
 552     /* [in] */ DWORD dwFlags,
 553     /* [in] */ DISPPARAMS __RPC_FAR *pDispParams,
 554     /* [out] */ VARIANT __RPC_FAR *pVarResult,
 555     /* [out] */ EXCEPINFO __RPC_FAR *pExcepInfo,
 556     /* [out] */ UINT __RPC_FAR *pArgErr,
 557     /* [in] */ UINT cVarRef,
 558     /* [size_is][in] */ UINT __RPC_FAR *rgVarRefIdx,
 559     /* [size_is][out][in] */ VARIANTARG __RPC_FAR *rgVarRef)
 560 {
 561
 562     HRESULT _RetVal;
 563
 564     RPC_MESSAGE _RpcMessage;
 565
 566     MIDL_STUB_MESSAGE _StubMsg;
 567
 568     if(pVarResult)
 569         {
 570         MIDL_memset(
 571                pVarResult,
 572                0,
 573                sizeof( VARIANT  ));
 574         }
 575     if(pExcepInfo)
 576         {
 577         MIDL_memset(
 578                pExcepInfo,
 579                0,
 580                sizeof( EXCEPINFO  ));
 581         }
 582     RpcTryExcept
 583         {
 584         NdrProxyInitialize(
 585                       ( void __RPC_FAR *  )This,
 586                       ( PRPC_MESSAGE  )&_RpcMessage,
 587                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
 588                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
 589                       6);
 590
 591
 592
 593         if(!riid)
 594             {
 595             RpcRaiseException(RPC_X_NULL_REF_POINTER);
 596             }
 597         if(!pDispParams)
 598             {
 599             RpcRaiseException(RPC_X_NULL_REF_POINTER);
 600             }
 601         if(!pVarResult)
 602             {
 603             RpcRaiseException(RPC_X_NULL_REF_POINTER);
 604             }
 605         if(!pExcepInfo)
 606             {
 607             RpcRaiseException(RPC_X_NULL_REF_POINTER);
 608             }
 609         if(!pArgErr)
 610             {
 611             RpcRaiseException(RPC_X_NULL_REF_POINTER);
 612             }
 613         if(!rgVarRefIdx)
 614             {
 615             RpcRaiseException(RPC_X_NULL_REF_POINTER);
 616             }
 617         if(!rgVarRef)
 618             {
 619             RpcRaiseException(RPC_X_NULL_REF_POINTER);
 620             }
 621         RpcTryFinally
 622             {
 623
 624             _StubMsg.BufferLength = 4U + 4U + 11U + 7U + 4U + 11U + 7U + 7U;
 625             NdrSimpleStructBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
 626                                        (unsigned char __RPC_FAR *)riid,
 627                                        (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[38] );
 628
 629             NdrComplexStructBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
 630                                         (unsigned char __RPC_FAR *)pDispParams,
 631                                         (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1080] );
 632
 633             _StubMsg.MaxCount = cVarRef;
 634
 635             NdrConformantArrayBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
 636                                           (unsigned char __RPC_FAR *)rgVarRefIdx,
 637                                           (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1170] );
 638
 639             _StubMsg.MaxCount = cVarRef;
 640
 641             NdrComplexArrayBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
 642                                        (unsigned char __RPC_FAR *)rgVarRef,
 643                                        (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1184] );
 644
 645             NdrProxyGetBuffer(This, &_StubMsg);
 646             *( DISPID __RPC_FAR * )_StubMsg.Buffer = dispIdMember;
 647             _StubMsg.Buffer += sizeof(DISPID);
 648
 649             NdrSimpleStructMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
 650                                      (unsigned char __RPC_FAR *)riid,
 651                                      (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[38] );
 652
 653             *( LCID __RPC_FAR * )_StubMsg.Buffer = lcid;
 654             _StubMsg.Buffer += sizeof(LCID);
 655
 656             *( DWORD __RPC_FAR * )_StubMsg.Buffer = dwFlags;
 657             _StubMsg.Buffer += sizeof(DWORD);
 658
 659             NdrComplexStructMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
 660                                       (unsigned char __RPC_FAR *)pDispParams,
 661                                       (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1080] );
 662
 663             _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
 664             *( UINT __RPC_FAR * )_StubMsg.Buffer = cVarRef;
 665             _StubMsg.Buffer += sizeof(UINT);
 666
 667             _StubMsg.MaxCount = cVarRef;
 668
 669             NdrConformantArrayMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
 670                                         (unsigned char __RPC_FAR *)rgVarRefIdx,
 671                                         (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1170] );
 672
 673             _StubMsg.MaxCount = cVarRef;
 674
 675             NdrComplexArrayMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
 676                                      (unsigned char __RPC_FAR *)rgVarRef,
 677                                      (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1184] );
 678
 679             NdrProxySendReceive(This, &_StubMsg);
 680
 681             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
 682                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[34] );
 683
 684             NdrUserMarshalUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
 685                                       (unsigned char __RPC_FAR * __RPC_FAR *)&pVarResult,
 686                                       (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1110],
 687                                       (unsigned char)0 );
 688
 689             NdrComplexStructUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
 690                                         (unsigned char __RPC_FAR * __RPC_FAR *)&pExcepInfo,
 691                                         (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1138],
 692                                         (unsigned char)0 );
 693
 694             _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
 695             *pArgErr = *( UINT __RPC_FAR * )_StubMsg.Buffer;
 696             _StubMsg.Buffer += sizeof(UINT);
 697
 698             NdrComplexArrayUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
 699                                        (unsigned char __RPC_FAR * __RPC_FAR *)&rgVarRef,
 700                                        (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1184],
 701                                        (unsigned char)0 );
 702
 703             _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
 704             _RetVal = *( HRESULT __RPC_FAR * )_StubMsg.Buffer;
 705             _StubMsg.Buffer += sizeof(HRESULT);
 706
 707             }
 708         RpcFinally
 709             {
 710             NdrProxyFreeBuffer(This, &_StubMsg);
 711
 712             }
 713         RpcEndFinally
 714
 715         }
 716     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
 717         {
 718         NdrClearOutParameters(
 719                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
 720                          ( PFORMAT_STRING  )&__MIDL_TypeFormatString.Format[1102],
 721                          ( void __RPC_FAR * )pVarResult);
 722         NdrClearOutParameters(
 723                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
 724                          ( PFORMAT_STRING  )&__MIDL_TypeFormatString.Format[1120],
 725                          ( void __RPC_FAR * )pExcepInfo);
 726         NdrClearOutParameters(
 727                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
 728                          ( PFORMAT_STRING  )&__MIDL_TypeFormatString.Format[2],
 729                          ( void __RPC_FAR * )pArgErr);
 730         _StubMsg.MaxCount = cVarRef;
 731
 732         NdrClearOutParameters(
 733                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
 734                          ( PFORMAT_STRING  )&__MIDL_TypeFormatString.Format[1180],
 735                          ( void __RPC_FAR * )rgVarRef);
 736         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
 737         }
 738     RpcEndExcept
 739     return _RetVal;
 740 }
 741
 742 void __RPC_STUB IDispatch_RemoteInvoke_Stub(
 743     IRpcStubBuffer *This,
 744     IRpcChannelBuffer *_pRpcChannelBuffer,
 745     PRPC_MESSAGE _pRpcMessage,
 746     DWORD *_pdwStubPhase)
 747 {
 748     VARIANT _M6;
 749     UINT _M7;
 750     HRESULT _RetVal;
 751     MIDL_STUB_MESSAGE _StubMsg;
 752     EXCEPINFO _pExcepInfoM;
 753     UINT cVarRef;
 754     DISPID dispIdMember;
 755     DWORD dwFlags;
 756     LCID lcid;
 757     UINT __RPC_FAR *pArgErr;
 758     DISPPARAMS __RPC_FAR *pDispParams;
 759     EXCEPINFO __RPC_FAR *pExcepInfo;
 760     VARIANT __RPC_FAR *pVarResult;
 761     VARIANTARG __RPC_FAR *rgVarRef;
 762     UINT __RPC_FAR *rgVarRefIdx;
 763     IID* riid = 0;
 764
 765 NdrStubInitialize(
 766                      _pRpcMessage,
 767                      &_StubMsg,
 768                      &Object_StubDesc,
 769                      _pRpcChannelBuffer);
 770     pDispParams = 0;
 771     pVarResult = 0;
 772     pExcepInfo = 0;
 773     pArgErr = 0;
 774     rgVarRefIdx = 0;
 775     rgVarRef = 0;
 776     RpcTryFinally
 777         {
 778         if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
 779             NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[34] );
 780
 781         dispIdMember = *( DISPID __RPC_FAR * )_StubMsg.Buffer;
 782         _StubMsg.Buffer += sizeof(DISPID);
 783
 784         NdrSimpleStructUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
 785                                    (unsigned char __RPC_FAR * __RPC_FAR *)&riid,
 786                                    (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[38],
 787                                    (unsigned char)0 );
 788
 789         lcid = *( LCID __RPC_FAR * )_StubMsg.Buffer;
 790         _StubMsg.Buffer += sizeof(LCID);
 791
 792         dwFlags = *( DWORD __RPC_FAR * )_StubMsg.Buffer;
 793         _StubMsg.Buffer += sizeof(DWORD);
 794
 795         NdrComplexStructUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
 796                                     (unsigned char __RPC_FAR * __RPC_FAR *)&pDispParams,
 797                                     (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1080],
 798                                     (unsigned char)0 );
 799
 800         _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
 801         cVarRef = *( UINT __RPC_FAR * )_StubMsg.Buffer;
 802         _StubMsg.Buffer += sizeof(UINT);
 803
 804         NdrConformantArrayUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
 805                                       (unsigned char __RPC_FAR * __RPC_FAR *)&rgVarRefIdx,
 806                                       (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1170],
 807                                       (unsigned char)0 );
 808
 809         NdrComplexArrayUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
 810                                    (unsigned char __RPC_FAR * __RPC_FAR *)&rgVarRef,
 811                                    (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1184],
 812                                    (unsigned char)0 );
 813
 814         pVarResult = &_M6;
 815         MIDL_memset(
 816                pVarResult,
 817                0,
 818                sizeof( VARIANT  ));
 819         pExcepInfo = &_pExcepInfoM;
 820         pArgErr = &_M7;
 821
 822         *_pdwStubPhase = STUB_CALL_SERVER;
 823
 824
 825         _RetVal = IDispatch_Invoke_Stub(
 826                                 (IDispatch *) ((CStdStubBuffer *)This)->pvServerObject,
 827                                 dispIdMember,
 828                                 riid,
 829                                 lcid,
 830                                 dwFlags,
 831                                 pDispParams,
 832                                 pVarResult,
 833                                 pExcepInfo,
 834                                 pArgErr,
 835                                 cVarRef,
 836                                 rgVarRefIdx,
 837                                 rgVarRef);
 838
 839         *_pdwStubPhase = STUB_MARSHAL;
 840
 841         _StubMsg.BufferLength = 8U + 7U + 11U + 7U + 7U;
 842         NdrUserMarshalBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
 843                                   (unsigned char __RPC_FAR *)pVarResult,
 844                                   (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1110] );
 845
 846         NdrComplexStructBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
 847                                     (unsigned char __RPC_FAR *)pExcepInfo,
 848                                     (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1138] );
 849
 850         _StubMsg.MaxCount = cVarRef;
 851
 852         NdrComplexArrayBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
 853                                    (unsigned char __RPC_FAR *)rgVarRef,
 854                                    (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1184] );
 855
 856         _StubMsg.BufferLength += 16;
 857
 858         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
 859         NdrUserMarshalMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
 860                                 (unsigned char __RPC_FAR *)pVarResult,
 861                                 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1110] );
 862
 863         NdrComplexStructMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
 864                                   (unsigned char __RPC_FAR *)pExcepInfo,
 865                                   (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1138] );
 866
 867         _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
 868         *( UINT __RPC_FAR * )_StubMsg.Buffer = *pArgErr;
 869         _StubMsg.Buffer += sizeof(UINT);
 870
 871         _StubMsg.MaxCount = cVarRef;
 872
 873         NdrComplexArrayMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
 874                                  (unsigned char __RPC_FAR *)rgVarRef,
 875                                  (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1184] );
 876
 877         _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
 878         *( HRESULT __RPC_FAR * )_StubMsg.Buffer = _RetVal;
 879         _StubMsg.Buffer += sizeof(HRESULT);
 880
 881         }
 882     RpcFinally
 883         {
 884         NdrPointerFree( &_StubMsg,
 885                         (unsigned char __RPC_FAR *)pDispParams,
 886                         &__MIDL_TypeFormatString.Format[98] );
 887
 888         NdrPointerFree( &_StubMsg,
 889                         (unsigned char __RPC_FAR *)pVarResult,
 890                         &__MIDL_TypeFormatString.Format[1102] );
 891
 892         NdrPointerFree( &_StubMsg,
 893                         (unsigned char __RPC_FAR *)pExcepInfo,
 894                         &__MIDL_TypeFormatString.Format[1120] );
 895
 896         _StubMsg.MaxCount = cVarRef;
 897
 898         NdrPointerFree( &_StubMsg,
 899                         (unsigned char __RPC_FAR *)rgVarRef,
 900                         &__MIDL_TypeFormatString.Format[1180] );
 901
 902         }
 903     RpcEndFinally
 904     _pRpcMessage->BufferLength =
 905         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
 906
 907 }
 908
 909 static const CINTERFACE_PROXY_VTABLE(7) _IDispatchProxyVtbl =
 910 {
 911     { &IID_IDispatch },
 912     {
 913         IUnknown_QueryInterface_Proxy,
 914         IUnknown_AddRef_Proxy,
 915         IUnknown_Release_Proxy ,
 916         IDispatch_GetTypeInfoCount_Proxy ,
 917         IDispatch_GetTypeInfo_Proxy ,
 918         IDispatch_GetIDsOfNames_Proxy ,
 919         IDispatch_Invoke_Proxy
 920     }
 921 };
 922
 923
 924 static const PRPC_STUB_FUNCTION IDispatch_table[] =
 925 {
 926     IDispatch_GetTypeInfoCount_Stub,
 927     IDispatch_GetTypeInfo_Stub,
 928     IDispatch_GetIDsOfNames_Stub,
 929     IDispatch_RemoteInvoke_Stub
 930 };
 931
 932 static const CInterfaceStubVtbl _IDispatchStubVtbl =
 933 {
 934     {
 935         &IID_IDispatch,
 936         0,
 937         7,
 938         &IDispatch_table[-3]
 939     },
 940     { CStdStubBuffer_METHODS }
 941 };
 942
 943
 944 /* Object interface: IEnumVARIANT, ver. 0.0,
 945    GUID={0x00020404,0x0000,0x0000,{0xC0,0x00,0x00,0x00,0x00,0x00,0x00,0x46}} */
 946
 947
 948 extern const MIDL_STUB_DESC Object_StubDesc;
 949
 950
 951 /* [call_as] */ HRESULT STDMETHODCALLTYPE IEnumVARIANT_RemoteNext_Proxy(
 952     IEnumVARIANT __RPC_FAR * This,
 953     /* [in] */ ULONG celt,
 954     /* [length_is][size_is][out] */ VARIANT __RPC_FAR *rgVar,
 955     /* [out] */ ULONG __RPC_FAR *pCeltFetched)
 956 {
 957
 958     HRESULT _RetVal;
 959
 960     RPC_MESSAGE _RpcMessage;
 961
 962     MIDL_STUB_MESSAGE _StubMsg;
 963
 964     if(rgVar)
 965         {
 966         MIDL_memset(
 967                rgVar,
 968                0,
 969                celt * sizeof( VARIANT  ));
 970         }
 971     RpcTryExcept
 972         {
 973         NdrProxyInitialize(
 974                       ( void __RPC_FAR *  )This,
 975                       ( PRPC_MESSAGE  )&_RpcMessage,
 976                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
 977                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
 978                       3);
 979
 980
 981
 982         if(!rgVar)
 983             {
 984             RpcRaiseException(RPC_X_NULL_REF_POINTER);
 985             }
 986         if(!pCeltFetched)
 987             {
 988             RpcRaiseException(RPC_X_NULL_REF_POINTER);
 989             }
 990         RpcTryFinally
 991             {
 992
 993             _StubMsg.BufferLength = 4U;
 994             NdrProxyGetBuffer(This, &_StubMsg);
 995             *( ULONG __RPC_FAR * )_StubMsg.Buffer = celt;
 996             _StubMsg.Buffer += sizeof(ULONG);
 997
 998             NdrProxySendReceive(This, &_StubMsg);
 999
1000             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
1001                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[72] );
1002
1003             NdrComplexArrayUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
1004                                        (unsigned char __RPC_FAR * __RPC_FAR *)&rgVar,
1005                                        (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1206],
1006                                        (unsigned char)0 );
1007
1008             _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
1009             *pCeltFetched = *( ULONG __RPC_FAR * )_StubMsg.Buffer;
1010             _StubMsg.Buffer += sizeof(ULONG);
1011
1012             _RetVal = *( HRESULT __RPC_FAR * )_StubMsg.Buffer;
1013             _StubMsg.Buffer += sizeof(HRESULT);
1014
1015             }
1016         RpcFinally
1017             {
1018             NdrProxyFreeBuffer(This, &_StubMsg);
1019
1020             }
1021         RpcEndFinally
1022
1023         }
1024     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
1025         {
1026         _StubMsg.MaxCount = celt;
1027         _StubMsg.Offset = 0;
1028         _StubMsg.ActualCount = _StubMsg.MaxCount;
1029
1030         NdrClearOutParameters(
1031                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
1032                          ( PFORMAT_STRING  )&__MIDL_TypeFormatString.Format[1202],
1033                          ( void __RPC_FAR * )rgVar);
1034         NdrClearOutParameters(
1035                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
1036                          ( PFORMAT_STRING  )&__MIDL_TypeFormatString.Format[2],
1037                          ( void __RPC_FAR * )pCeltFetched);
1038         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
1039         }
1040     RpcEndExcept
1041     return _RetVal;
1042 }
1043
1044 void __RPC_STUB IEnumVARIANT_RemoteNext_Stub(
1045     IRpcStubBuffer *This,
1046     IRpcChannelBuffer *_pRpcChannelBuffer,
1047     PRPC_MESSAGE _pRpcMessage,
1048     DWORD *_pdwStubPhase)
1049 {
1050     ULONG _M11;
1051     HRESULT _RetVal;
1052     MIDL_STUB_MESSAGE _StubMsg;
1053     ULONG celt;
1054     ULONG __RPC_FAR *pCeltFetched;
1055     VARIANT __RPC_FAR *rgVar;
1056
1057 NdrStubInitialize(
1058                      _pRpcMessage,
1059                      &_StubMsg,
1060                      &Object_StubDesc,
1061                      _pRpcChannelBuffer);
1062     rgVar = 0;
1063     pCeltFetched = 0;
1064     RpcTryFinally
1065         {
1066         if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
1067             NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[72] );
1068
1069         celt = *( ULONG __RPC_FAR * )_StubMsg.Buffer;
1070         _StubMsg.Buffer += sizeof(ULONG);
1071
1072         rgVar = NdrAllocate(&_StubMsg,celt * 16);
1073         pCeltFetched = &_M11;
1074
1075         *_pdwStubPhase = STUB_CALL_SERVER;
1076
1077
1078         _RetVal = IEnumVARIANT_Next_Stub(
1079                                  (IEnumVARIANT *) ((CStdStubBuffer *)This)->pvServerObject,
1080                                  celt,
1081                                  rgVar,
1082                                  pCeltFetched);
1083
1084         *_pdwStubPhase = STUB_MARSHAL;
1085
1086         _StubMsg.BufferLength = 12U + 7U + 7U;
1087         _StubMsg.MaxCount = celt;
1088         _StubMsg.Offset = 0;
1089         _StubMsg.ActualCount = pCeltFetched ? *pCeltFetched : 0;
1090
1091         NdrComplexArrayBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
1092                                    (unsigned char __RPC_FAR *)rgVar,
1093                                    (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1206] );
1094
1095         _StubMsg.BufferLength += 16;
1096
1097         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
1098         _StubMsg.MaxCount = celt;
1099         _StubMsg.Offset = 0;
1100         _StubMsg.ActualCount = pCeltFetched ? *pCeltFetched : 0;
1101
1102         NdrComplexArrayMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
1103                                  (unsigned char __RPC_FAR *)rgVar,
1104                                  (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1206] );
1105
1106         _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
1107         *( ULONG __RPC_FAR * )_StubMsg.Buffer = *pCeltFetched;
1108         _StubMsg.Buffer += sizeof(ULONG);
1109
1110         *( HRESULT __RPC_FAR * )_StubMsg.Buffer = _RetVal;
1111         _StubMsg.Buffer += sizeof(HRESULT);
1112
1113         }
1114     RpcFinally
1115         {
1116         _StubMsg.MaxCount = celt;
1117         _StubMsg.Offset = 0;
1118         _StubMsg.ActualCount = pCeltFetched ? *pCeltFetched : 0;
1119
1120         NdrPointerFree( &_StubMsg,
1121                         (unsigned char __RPC_FAR *)rgVar,
1122                         &__MIDL_TypeFormatString.Format[1202] );
1123
1124         }
1125     RpcEndFinally
1126     _pRpcMessage->BufferLength =
1127         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
1128
1129 }
1130
1131
1132 HRESULT STDMETHODCALLTYPE IEnumVARIANT_Skip_Proxy(
1133     IEnumVARIANT __RPC_FAR * This,
1134     /* [in] */ ULONG celt)
1135 {
1136
1137     HRESULT _RetVal;
1138
1139     RPC_MESSAGE _RpcMessage;
1140
1141     MIDL_STUB_MESSAGE _StubMsg;
1142
1143     RpcTryExcept
1144         {
1145         NdrProxyInitialize(
1146                       ( void __RPC_FAR *  )This,
1147                       ( PRPC_MESSAGE  )&_RpcMessage,
1148                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
1149                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
1150                       4);
1151
1152
1153
1154         RpcTryFinally
1155             {
1156
1157             _StubMsg.BufferLength = 4U;
1158             NdrProxyGetBuffer(This, &_StubMsg);
1159             *( ULONG __RPC_FAR * )_StubMsg.Buffer = celt;
1160             _StubMsg.Buffer += sizeof(ULONG);
1161
1162             NdrProxySendReceive(This, &_StubMsg);
1163
1164             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
1165                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[84] );
1166
1167             _RetVal = *( HRESULT __RPC_FAR * )_StubMsg.Buffer;
1168             _StubMsg.Buffer += sizeof(HRESULT);
1169
1170             }
1171         RpcFinally
1172             {
1173             NdrProxyFreeBuffer(This, &_StubMsg);
1174
1175             }
1176         RpcEndFinally
1177
1178         }
1179     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
1180         {
1181         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
1182         }
1183     RpcEndExcept
1184     return _RetVal;
1185 }
1186
1187 void __RPC_STUB IEnumVARIANT_Skip_Stub(
1188     IRpcStubBuffer *This,
1189     IRpcChannelBuffer *_pRpcChannelBuffer,
1190     PRPC_MESSAGE _pRpcMessage,
1191     DWORD *_pdwStubPhase)
1192 {
1193     HRESULT _RetVal;
1194     MIDL_STUB_MESSAGE _StubMsg;
1195     ULONG celt;
1196
1197 NdrStubInitialize(
1198                      _pRpcMessage,
1199                      &_StubMsg,
1200                      &Object_StubDesc,
1201                      _pRpcChannelBuffer);
1202     RpcTryFinally
1203         {
1204         if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
1205             NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[84] );
1206
1207         celt = *( ULONG __RPC_FAR * )_StubMsg.Buffer;
1208         _StubMsg.Buffer += sizeof(ULONG);
1209
1210         *_pdwStubPhase = STUB_CALL_SERVER;
1211         _RetVal = (((IEnumVARIANT*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> Skip((IEnumVARIANT *) ((CStdStubBuffer *)This)->pvServerObject,celt);
1212
1213         *_pdwStubPhase = STUB_MARSHAL;
1214
1215         _StubMsg.BufferLength = 4U;
1216         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
1217         *( HRESULT __RPC_FAR * )_StubMsg.Buffer = _RetVal;
1218         _StubMsg.Buffer += sizeof(HRESULT);
1219
1220         }
1221     RpcFinally
1222         {
1223         }
1224     RpcEndFinally
1225     _pRpcMessage->BufferLength =
1226         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
1227
1228 }
1229
1230
1231 HRESULT STDMETHODCALLTYPE IEnumVARIANT_Reset_Proxy(
1232     IEnumVARIANT __RPC_FAR * This)
1233 {
1234
1235     HRESULT _RetVal;
1236
1237     RPC_MESSAGE _RpcMessage;
1238
1239     MIDL_STUB_MESSAGE _StubMsg;
1240
1241     RpcTryExcept
1242         {
1243         NdrProxyInitialize(
1244                       ( void __RPC_FAR *  )This,
1245                       ( PRPC_MESSAGE  )&_RpcMessage,
1246                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
1247                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
1248                       5);
1249
1250
1251
1252         RpcTryFinally
1253             {
1254
1255             _StubMsg.BufferLength = 0U;
1256             NdrProxyGetBuffer(This, &_StubMsg);
1257             NdrProxySendReceive(This, &_StubMsg);
1258
1259             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
1260                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[88] );
1261
1262             _RetVal = *( HRESULT __RPC_FAR * )_StubMsg.Buffer;
1263             _StubMsg.Buffer += sizeof(HRESULT);
1264
1265             }
1266         RpcFinally
1267             {
1268             NdrProxyFreeBuffer(This, &_StubMsg);
1269
1270             }
1271         RpcEndFinally
1272
1273         }
1274     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
1275         {
1276         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
1277         }
1278     RpcEndExcept
1279     return _RetVal;
1280 }
1281
1282 void __RPC_STUB IEnumVARIANT_Reset_Stub(
1283     IRpcStubBuffer *This,
1284     IRpcChannelBuffer *_pRpcChannelBuffer,
1285     PRPC_MESSAGE _pRpcMessage,
1286     DWORD *_pdwStubPhase)
1287 {
1288     HRESULT _RetVal;
1289     MIDL_STUB_MESSAGE _StubMsg;
1290
1291 NdrStubInitialize(
1292                      _pRpcMessage,
1293                      &_StubMsg,
1294                      &Object_StubDesc,
1295                      _pRpcChannelBuffer);
1296     RpcTryFinally
1297         {
1298
1299         *_pdwStubPhase = STUB_CALL_SERVER;
1300         _RetVal = (((IEnumVARIANT*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> Reset((IEnumVARIANT *) ((CStdStubBuffer *)This)->pvServerObject);
1301
1302         *_pdwStubPhase = STUB_MARSHAL;
1303
1304         _StubMsg.BufferLength = 4U;
1305         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
1306         *( HRESULT __RPC_FAR * )_StubMsg.Buffer = _RetVal;
1307         _StubMsg.Buffer += sizeof(HRESULT);
1308
1309         }
1310     RpcFinally
1311         {
1312         }
1313     RpcEndFinally
1314     _pRpcMessage->BufferLength =
1315         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
1316
1317 }
1318
1319
1320 HRESULT STDMETHODCALLTYPE IEnumVARIANT_Clone_Proxy(
1321     IEnumVARIANT __RPC_FAR * This,
1322     /* [out] */ IEnumVARIANT __RPC_FAR *__RPC_FAR *ppEnum)
1323 {
1324
1325     HRESULT _RetVal;
1326
1327     RPC_MESSAGE _RpcMessage;
1328
1329     MIDL_STUB_MESSAGE _StubMsg;
1330
1331     if(ppEnum)
1332         {
1333         MIDL_memset(
1334                ppEnum,
1335                0,
1336                sizeof( IEnumVARIANT __RPC_FAR *__RPC_FAR * ));
1337         }
1338     RpcTryExcept
1339         {
1340         NdrProxyInitialize(
1341                       ( void __RPC_FAR *  )This,
1342                       ( PRPC_MESSAGE  )&_RpcMessage,
1343                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
1344                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
1345                       6);
1346
1347
1348
1349         if(!ppEnum)
1350             {
1351             RpcRaiseException(RPC_X_NULL_REF_POINTER);
1352             }
1353         RpcTryFinally
1354             {
1355
1356             _StubMsg.BufferLength = 0U;
1357             NdrProxyGetBuffer(This, &_StubMsg);
1358             NdrProxySendReceive(This, &_StubMsg);
1359
1360             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
1361                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[90] );
1362
1363             NdrPointerUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
1364                                   (unsigned char __RPC_FAR * __RPC_FAR *)&ppEnum,
1365                                   (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1224],
1366                                   (unsigned char)0 );
1367
1368             _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
1369             _RetVal = *( HRESULT __RPC_FAR * )_StubMsg.Buffer;
1370             _StubMsg.Buffer += sizeof(HRESULT);
1371
1372             }
1373         RpcFinally
1374             {
1375             NdrProxyFreeBuffer(This, &_StubMsg);
1376
1377             }
1378         RpcEndFinally
1379
1380         }
1381     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
1382         {
1383         NdrClearOutParameters(
1384                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
1385                          ( PFORMAT_STRING  )&__MIDL_TypeFormatString.Format[1224],
1386                          ( void __RPC_FAR * )ppEnum);
1387         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
1388         }
1389     RpcEndExcept
1390     return _RetVal;
1391 }
1392
1393 void __RPC_STUB IEnumVARIANT_Clone_Stub(
1394     IRpcStubBuffer *This,
1395     IRpcChannelBuffer *_pRpcChannelBuffer,
1396     PRPC_MESSAGE _pRpcMessage,
1397     DWORD *_pdwStubPhase)
1398 {
1399     IEnumVARIANT __RPC_FAR *_M12;
1400     HRESULT _RetVal;
1401     MIDL_STUB_MESSAGE _StubMsg;
1402     IEnumVARIANT __RPC_FAR *__RPC_FAR *ppEnum;
1403
1404 NdrStubInitialize(
1405                      _pRpcMessage,
1406                      &_StubMsg,
1407                      &Object_StubDesc,
1408                      _pRpcChannelBuffer);
1409     ppEnum = 0;
1410     RpcTryFinally
1411         {
1412         ppEnum = &_M12;
1413         _M12 = 0;
1414
1415         *_pdwStubPhase = STUB_CALL_SERVER;
1416         _RetVal = (((IEnumVARIANT*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> Clone((IEnumVARIANT *) ((CStdStubBuffer *)This)->pvServerObject,ppEnum);
1417
1418         *_pdwStubPhase = STUB_MARSHAL;
1419
1420         _StubMsg.BufferLength = 0U + 4U;
1421         NdrPointerBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
1422                               (unsigned char __RPC_FAR *)ppEnum,
1423                               (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1224] );
1424
1425         _StubMsg.BufferLength += 16;
1426
1427         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
1428         NdrPointerMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
1429                             (unsigned char __RPC_FAR *)ppEnum,
1430                             (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1224] );
1431
1432         _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
1433         *( HRESULT __RPC_FAR * )_StubMsg.Buffer = _RetVal;
1434         _StubMsg.Buffer += sizeof(HRESULT);
1435
1436         }
1437     RpcFinally
1438         {
1439         NdrPointerFree( &_StubMsg,
1440                         (unsigned char __RPC_FAR *)ppEnum,
1441                         &__MIDL_TypeFormatString.Format[1224] );
1442
1443         }
1444     RpcEndFinally
1445     _pRpcMessage->BufferLength =
1446         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
1447
1448 }
1449
1450 static const CINTERFACE_PROXY_VTABLE(7) _IEnumVARIANTProxyVtbl =
1451 {
1452     { &IID_IEnumVARIANT },
1453     {
1454         IUnknown_QueryInterface_Proxy,
1455         IUnknown_AddRef_Proxy,
1456         IUnknown_Release_Proxy ,
1457         IEnumVARIANT_Next_Proxy ,
1458         IEnumVARIANT_Skip_Proxy ,
1459         IEnumVARIANT_Reset_Proxy ,
1460         IEnumVARIANT_Clone_Proxy
1461     }
1462 };
1463
1464
1465 static const PRPC_STUB_FUNCTION IEnumVARIANT_table[] =
1466 {
1467     IEnumVARIANT_RemoteNext_Stub,
1468     IEnumVARIANT_Skip_Stub,
1469     IEnumVARIANT_Reset_Stub,
1470     IEnumVARIANT_Clone_Stub
1471 };
1472
1473 static const CInterfaceStubVtbl _IEnumVARIANTStubVtbl =
1474 {
1475     {
1476         &IID_IEnumVARIANT,
1477         0,
1478         7,
1479         &IEnumVARIANT_table[-3]
1480     },
1481     { CStdStubBuffer_METHODS }
1482 };
1483
1484
1485 /* Object interface: ITypeComp, ver. 0.0,
1486    GUID={0x00020403,0x0000,0x0000,{0xC0,0x00,0x00,0x00,0x00,0x00,0x00,0x46}} */
1487
1488
1489 extern const MIDL_STUB_DESC Object_StubDesc;
1490
1491
1492 /* [call_as] */ HRESULT STDMETHODCALLTYPE ITypeComp_RemoteBind_Proxy(
1493     ITypeComp __RPC_FAR * This,
1494     /* [in] */ LPOLESTR szName,
1495     /* [in] */ ULONG lHashVal,
1496     /* [in] */ WORD wFlags,
1497     /* [out] */ ITypeInfo __RPC_FAR *__RPC_FAR *ppTInfo,
1498     /* [out] */ DESCKIND __RPC_FAR *pDescKind,
1499     /* [out] */ LPFUNCDESC __RPC_FAR *ppFuncDesc,
1500     /* [out] */ LPVARDESC __RPC_FAR *ppVarDesc,
1501     /* [out] */ ITypeComp __RPC_FAR *__RPC_FAR *ppTypeComp,
1502     /* [out] */ CLEANLOCALSTORAGE __RPC_FAR *pDummy)
1503 {
1504
1505     HRESULT _RetVal;
1506
1507     RPC_MESSAGE _RpcMessage;
1508
1509     MIDL_STUB_MESSAGE _StubMsg;
1510
1511     if(ppTInfo)
1512         {
1513         MIDL_memset(
1514                ppTInfo,
1515                0,
1516                sizeof( ITypeInfo __RPC_FAR *__RPC_FAR * ));
1517         }
1518     if(ppFuncDesc)
1519         {
1520         *ppFuncDesc = 0;
1521         }
1522     if(ppVarDesc)
1523         {
1524         *ppVarDesc = 0;
1525         }
1526     if(ppTypeComp)
1527         {
1528         MIDL_memset(
1529                ppTypeComp,
1530                0,
1531                sizeof( ITypeComp __RPC_FAR *__RPC_FAR * ));
1532         }
1533     if(pDummy)
1534         {
1535         MIDL_memset(
1536                pDummy,
1537                0,
1538                sizeof( CLEANLOCALSTORAGE  ));
1539         }
1540     RpcTryExcept
1541         {
1542         NdrProxyInitialize(
1543                       ( void __RPC_FAR *  )This,
1544                       ( PRPC_MESSAGE  )&_RpcMessage,
1545                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
1546                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
1547                       3);
1548
1549
1550
1551         if(!szName)
1552             {
1553             RpcRaiseException(RPC_X_NULL_REF_POINTER);
1554             }
1555         if(!ppTInfo)
1556             {
1557             RpcRaiseException(RPC_X_NULL_REF_POINTER);
1558             }
1559         if(!pDescKind)
1560             {
1561             RpcRaiseException(RPC_X_NULL_REF_POINTER);
1562             }
1563         if(!ppFuncDesc)
1564             {
1565             RpcRaiseException(RPC_X_NULL_REF_POINTER);
1566             }
1567         if(!ppVarDesc)
1568             {
1569             RpcRaiseException(RPC_X_NULL_REF_POINTER);
1570             }
1571         if(!ppTypeComp)
1572             {
1573             RpcRaiseException(RPC_X_NULL_REF_POINTER);
1574             }
1575         if(!pDummy)
1576             {
1577             RpcRaiseException(RPC_X_NULL_REF_POINTER);
1578             }
1579         RpcTryFinally
1580             {
1581
1582             _StubMsg.BufferLength = 12U + 10U + 4U;
1583             NdrConformantStringBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
1584                                            (unsigned char __RPC_FAR *)szName,
1585                                            (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1248] );
1586
1587             NdrProxyGetBuffer(This, &_StubMsg);
1588             NdrConformantStringMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
1589                                          (unsigned char __RPC_FAR *)szName,
1590                                          (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1248] );
1591
1592             _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
1593             *( ULONG __RPC_FAR * )_StubMsg.Buffer = lHashVal;
1594             _StubMsg.Buffer += sizeof(ULONG);
1595
1596             *( WORD __RPC_FAR * )_StubMsg.Buffer = wFlags;
1597             _StubMsg.Buffer += sizeof(WORD);
1598
1599             NdrProxySendReceive(This, &_StubMsg);
1600
1601             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
1602                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[96] );
1603
1604             NdrPointerUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
1605                                   (unsigned char __RPC_FAR * __RPC_FAR *)&ppTInfo,
1606                                   (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[6],
1607                                   (unsigned char)0 );
1608
1609             NdrPointerUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
1610                                   (unsigned char __RPC_FAR * __RPC_FAR *)&pDescKind,
1611                                   (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1250],
1612                                   (unsigned char)0 );
1613
1614             NdrPointerUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
1615                                   (unsigned char __RPC_FAR * __RPC_FAR *)&ppFuncDesc,
1616                                   (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1254],
1617                                   (unsigned char)0 );
1618
1619             NdrPointerUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
1620                                   (unsigned char __RPC_FAR * __RPC_FAR *)&ppVarDesc,
1621                                   (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1464],
1622                                   (unsigned char)0 );
1623
1624             NdrPointerUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
1625                                   (unsigned char __RPC_FAR * __RPC_FAR *)&ppTypeComp,
1626                                   (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1540],
1627                                   (unsigned char)0 );
1628
1629             NdrUserMarshalUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
1630                                       (unsigned char __RPC_FAR * __RPC_FAR *)&pDummy,
1631                                       (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1568],
1632                                       (unsigned char)0 );
1633
1634             _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
1635             _RetVal = *( HRESULT __RPC_FAR * )_StubMsg.Buffer;
1636             _StubMsg.Buffer += sizeof(HRESULT);
1637
1638             }
1639         RpcFinally
1640             {
1641             NdrProxyFreeBuffer(This, &_StubMsg);
1642
1643             }
1644         RpcEndFinally
1645
1646         }
1647     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
1648         {
1649         NdrClearOutParameters(
1650                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
1651                          ( PFORMAT_STRING  )&__MIDL_TypeFormatString.Format[6],
1652                          ( void __RPC_FAR * )ppTInfo);
1653         NdrClearOutParameters(
1654                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
1655                          ( PFORMAT_STRING  )&__MIDL_TypeFormatString.Format[1250],
1656                          ( void __RPC_FAR * )pDescKind);
1657         NdrClearOutParameters(
1658                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
1659                          ( PFORMAT_STRING  )&__MIDL_TypeFormatString.Format[1254],
1660                          ( void __RPC_FAR * )ppFuncDesc);
1661         NdrClearOutParameters(
1662                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
1663                          ( PFORMAT_STRING  )&__MIDL_TypeFormatString.Format[1464],
1664                          ( void __RPC_FAR * )ppVarDesc);
1665         NdrClearOutParameters(
1666                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
1667                          ( PFORMAT_STRING  )&__MIDL_TypeFormatString.Format[1540],
1668                          ( void __RPC_FAR * )ppTypeComp);
1669         NdrClearOutParameters(
1670                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
1671                          ( PFORMAT_STRING  )&__MIDL_TypeFormatString.Format[1562],
1672                          ( void __RPC_FAR * )pDummy);
1673         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
1674         }
1675     RpcEndExcept
1676     return _RetVal;
1677 }
1678
1679 void __RPC_STUB ITypeComp_RemoteBind_Stub(
1680     IRpcStubBuffer *This,
1681     IRpcChannelBuffer *_pRpcChannelBuffer,
1682     PRPC_MESSAGE _pRpcMessage,
1683     DWORD *_pdwStubPhase)
1684 {
1685     ITypeInfo __RPC_FAR *_M15;
1686     DESCKIND _M16;
1687     LPFUNCDESC _M17;
1688     LPVARDESC _M18;
1689     ITypeComp __RPC_FAR *_M19;
1690     CLEANLOCALSTORAGE _M20;
1691     HRESULT _RetVal;
1692     MIDL_STUB_MESSAGE _StubMsg;
1693     ULONG lHashVal;
1694     DESCKIND __RPC_FAR *pDescKind;
1695     CLEANLOCALSTORAGE __RPC_FAR *pDummy;
1696     LPFUNCDESC __RPC_FAR *ppFuncDesc;
1697     ITypeInfo __RPC_FAR *__RPC_FAR *ppTInfo;
1698     ITypeComp __RPC_FAR *__RPC_FAR *ppTypeComp;
1699     LPVARDESC __RPC_FAR *ppVarDesc;
1700     LPOLESTR szName;
1701     WORD wFlags;
1702
1703 NdrStubInitialize(
1704                      _pRpcMessage,
1705                      &_StubMsg,
1706                      &Object_StubDesc,
1707                      _pRpcChannelBuffer);
1708     szName = 0;
1709     ppTInfo = 0;
1710     pDescKind = 0;
1711     ppFuncDesc = 0;
1712     ppVarDesc = 0;
1713     ppTypeComp = 0;
1714     pDummy = 0;
1715     RpcTryFinally
1716         {
1717         if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
1718             NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[96] );
1719
1720         NdrConformantStringUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
1721                                        (unsigned char __RPC_FAR * __RPC_FAR *)&szName,
1722                                        (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1248],
1723                                        (unsigned char)0 );
1724
1725         _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
1726         lHashVal = *( ULONG __RPC_FAR * )_StubMsg.Buffer;
1727         _StubMsg.Buffer += sizeof(ULONG);
1728
1729         wFlags = *( WORD __RPC_FAR * )_StubMsg.Buffer;
1730         _StubMsg.Buffer += sizeof(WORD);
1731
1732         ppTInfo = &_M15;
1733         _M15 = 0;
1734         pDescKind = &_M16;
1735         ppFuncDesc = &_M17;
1736         _M17 = 0;
1737         ppVarDesc = &_M18;
1738         _M18 = 0;
1739         ppTypeComp = &_M19;
1740         _M19 = 0;
1741         pDummy = &_M20;
1742         MIDL_memset(
1743                pDummy,
1744                0,
1745                sizeof( CLEANLOCALSTORAGE  ));
1746
1747         *_pdwStubPhase = STUB_CALL_SERVER;
1748
1749
1750         _RetVal = ITypeComp_Bind_Stub(
1751                               (ITypeComp *) ((CStdStubBuffer *)This)->pvServerObject,
1752                               szName,
1753                               lHashVal,
1754                               wFlags,
1755                               ppTInfo,
1756                               pDescKind,
1757                               ppFuncDesc,
1758                               ppVarDesc,
1759                               ppTypeComp,
1760                               pDummy);
1761
1762         *_pdwStubPhase = STUB_MARSHAL;
1763
1764         _StubMsg.BufferLength = 0U + 4U + 4U + 15U + 0U + 11U + 7U;
1765         NdrPointerBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
1766                               (unsigned char __RPC_FAR *)ppTInfo,
1767                               (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[6] );
1768
1769         NdrPointerBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
1770                               (unsigned char __RPC_FAR *)ppFuncDesc,
1771                               (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1254] );
1772
1773         NdrPointerBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
1774                               (unsigned char __RPC_FAR *)ppVarDesc,
1775                               (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1464] );
1776
1777         NdrPointerBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
1778                               (unsigned char __RPC_FAR *)ppTypeComp,
1779                               (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1540] );
1780
1781         _StubMsg.BufferLength += 16;
1782
1783         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
1784         NdrPointerMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
1785                             (unsigned char __RPC_FAR *)ppTInfo,
1786                             (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[6] );
1787
1788         NdrPointerMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
1789                             (unsigned char __RPC_FAR *)pDescKind,
1790                             (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1250] );
1791
1792         NdrPointerMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
1793                             (unsigned char __RPC_FAR *)ppFuncDesc,
1794                             (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1254] );
1795
1796         NdrPointerMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
1797                             (unsigned char __RPC_FAR *)ppVarDesc,
1798                             (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1464] );
1799
1800         NdrPointerMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
1801                             (unsigned char __RPC_FAR *)ppTypeComp,
1802                             (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1540] );
1803
1804         NdrUserMarshalMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
1805                                 (unsigned char __RPC_FAR *)pDummy,
1806                                 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1568] );
1807
1808         _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
1809         *( HRESULT __RPC_FAR * )_StubMsg.Buffer = _RetVal;
1810         _StubMsg.Buffer += sizeof(HRESULT);
1811
1812         }
1813     RpcFinally
1814         {
1815         NdrPointerFree( &_StubMsg,
1816                         (unsigned char __RPC_FAR *)ppTInfo,
1817                         &__MIDL_TypeFormatString.Format[6] );
1818
1819         NdrPointerFree( &_StubMsg,
1820                         (unsigned char __RPC_FAR *)ppFuncDesc,
1821                         &__MIDL_TypeFormatString.Format[1254] );
1822
1823         NdrPointerFree( &_StubMsg,
1824                         (unsigned char __RPC_FAR *)ppVarDesc,
1825                         &__MIDL_TypeFormatString.Format[1464] );
1826
1827         NdrPointerFree( &_StubMsg,
1828                         (unsigned char __RPC_FAR *)ppTypeComp,
1829                         &__MIDL_TypeFormatString.Format[1540] );
1830
1831         NdrPointerFree( &_StubMsg,
1832                         (unsigned char __RPC_FAR *)pDummy,
1833                         &__MIDL_TypeFormatString.Format[1562] );
1834
1835         }
1836     RpcEndFinally
1837     _pRpcMessage->BufferLength =
1838         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
1839
1840 }
1841
1842
1843 /* [call_as] */ HRESULT STDMETHODCALLTYPE ITypeComp_RemoteBindType_Proxy(
1844     ITypeComp __RPC_FAR * This,
1845     /* [in] */ LPOLESTR szName,
1846     /* [in] */ ULONG lHashVal,
1847     /* [out] */ ITypeInfo __RPC_FAR *__RPC_FAR *ppTInfo)
1848 {
1849
1850     HRESULT _RetVal;
1851
1852     RPC_MESSAGE _RpcMessage;
1853
1854     MIDL_STUB_MESSAGE _StubMsg;
1855
1856     if(ppTInfo)
1857         {
1858         MIDL_memset(
1859                ppTInfo,
1860                0,
1861                sizeof( ITypeInfo __RPC_FAR *__RPC_FAR * ));
1862         }
1863     RpcTryExcept
1864         {
1865         NdrProxyInitialize(
1866                       ( void __RPC_FAR *  )This,
1867                       ( PRPC_MESSAGE  )&_RpcMessage,
1868                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
1869                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
1870                       4);
1871
1872
1873
1874         if(!szName)
1875             {
1876             RpcRaiseException(RPC_X_NULL_REF_POINTER);
1877             }
1878         if(!ppTInfo)
1879             {
1880             RpcRaiseException(RPC_X_NULL_REF_POINTER);
1881             }
1882         RpcTryFinally
1883             {
1884
1885             _StubMsg.BufferLength = 12U + 10U;
1886             NdrConformantStringBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
1887                                            (unsigned char __RPC_FAR *)szName,
1888                                            (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1248] );
1889
1890             NdrProxyGetBuffer(This, &_StubMsg);
1891             NdrConformantStringMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
1892                                          (unsigned char __RPC_FAR *)szName,
1893                                          (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1248] );
1894
1895             _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
1896             *( ULONG __RPC_FAR * )_StubMsg.Buffer = lHashVal;
1897             _StubMsg.Buffer += sizeof(ULONG);
1898
1899             NdrProxySendReceive(This, &_StubMsg);
1900
1901             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
1902                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[130] );
1903
1904             NdrPointerUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
1905                                   (unsigned char __RPC_FAR * __RPC_FAR *)&ppTInfo,
1906                                   (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[6],
1907                                   (unsigned char)0 );
1908
1909             _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
1910             _RetVal = *( HRESULT __RPC_FAR * )_StubMsg.Buffer;
1911             _StubMsg.Buffer += sizeof(HRESULT);
1912
1913             }
1914         RpcFinally
1915             {
1916             NdrProxyFreeBuffer(This, &_StubMsg);
1917
1918             }
1919         RpcEndFinally
1920
1921         }
1922     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
1923         {
1924         NdrClearOutParameters(
1925                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
1926                          ( PFORMAT_STRING  )&__MIDL_TypeFormatString.Format[6],
1927                          ( void __RPC_FAR * )ppTInfo);
1928         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
1929         }
1930     RpcEndExcept
1931     return _RetVal;
1932 }
1933
1934 void __RPC_STUB ITypeComp_RemoteBindType_Stub(
1935     IRpcStubBuffer *This,
1936     IRpcChannelBuffer *_pRpcChannelBuffer,
1937     PRPC_MESSAGE _pRpcMessage,
1938     DWORD *_pdwStubPhase)
1939 {
1940     ITypeInfo __RPC_FAR *_M23;
1941     HRESULT _RetVal;
1942     MIDL_STUB_MESSAGE _StubMsg;
1943     ULONG lHashVal;
1944     ITypeInfo __RPC_FAR *__RPC_FAR *ppTInfo;
1945     LPOLESTR szName;
1946
1947 NdrStubInitialize(
1948                      _pRpcMessage,
1949                      &_StubMsg,
1950                      &Object_StubDesc,
1951                      _pRpcChannelBuffer);
1952     szName = 0;
1953     ppTInfo = 0;
1954     RpcTryFinally
1955         {
1956         if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
1957             NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[130] );
1958
1959         NdrConformantStringUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
1960                                        (unsigned char __RPC_FAR * __RPC_FAR *)&szName,
1961                                        (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1248],
1962                                        (unsigned char)0 );
1963
1964         _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
1965         lHashVal = *( ULONG __RPC_FAR * )_StubMsg.Buffer;
1966         _StubMsg.Buffer += sizeof(ULONG);
1967
1968         ppTInfo = &_M23;
1969         _M23 = 0;
1970
1971         *_pdwStubPhase = STUB_CALL_SERVER;
1972
1973
1974         _RetVal = ITypeComp_BindType_Stub(
1975                                   (ITypeComp *) ((CStdStubBuffer *)This)->pvServerObject,
1976                                   szName,
1977                                   lHashVal,
1978                                   ppTInfo);
1979
1980         *_pdwStubPhase = STUB_MARSHAL;
1981
1982         _StubMsg.BufferLength = 0U + 4U;
1983         NdrPointerBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
1984                               (unsigned char __RPC_FAR *)ppTInfo,
1985                               (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[6] );
1986
1987         _StubMsg.BufferLength += 16;
1988
1989         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
1990         NdrPointerMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
1991                             (unsigned char __RPC_FAR *)ppTInfo,
1992                             (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[6] );
1993
1994         _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
1995         *( HRESULT __RPC_FAR * )_StubMsg.Buffer = _RetVal;
1996         _StubMsg.Buffer += sizeof(HRESULT);
1997
1998         }
1999     RpcFinally
2000         {
2001         NdrPointerFree( &_StubMsg,
2002                         (unsigned char __RPC_FAR *)ppTInfo,
2003                         &__MIDL_TypeFormatString.Format[6] );
2004
2005         }
2006     RpcEndFinally
2007     _pRpcMessage->BufferLength =
2008         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
2009
2010 }
2011
2012 static const CINTERFACE_PROXY_VTABLE(5) _ITypeCompProxyVtbl =
2013 {
2014     { &IID_ITypeComp },
2015     {
2016         IUnknown_QueryInterface_Proxy,
2017         IUnknown_AddRef_Proxy,
2018         IUnknown_Release_Proxy ,
2019         ITypeComp_Bind_Proxy ,
2020         ITypeComp_BindType_Proxy
2021     }
2022 };
2023
2024
2025 static const PRPC_STUB_FUNCTION ITypeComp_table[] =
2026 {
2027     ITypeComp_RemoteBind_Stub,
2028     ITypeComp_RemoteBindType_Stub
2029 };
2030
2031 static const CInterfaceStubVtbl _ITypeCompStubVtbl =
2032 {
2033     {
2034         &IID_ITypeComp,
2035         0,
2036         5,
2037         &ITypeComp_table[-3]
2038     },
2039     { CStdStubBuffer_METHODS }
2040 };
2041
2042
2043 /* Object interface: ITypeInfo, ver. 0.0,
2044    GUID={0x00020401,0x0000,0x0000,{0xC0,0x00,0x00,0x00,0x00,0x00,0x00,0x46}} */
2045
2046
2047 extern const MIDL_STUB_DESC Object_StubDesc;
2048
2049
2050 /* [call_as] */ HRESULT STDMETHODCALLTYPE ITypeInfo_RemoteGetTypeAttr_Proxy(
2051     ITypeInfo __RPC_FAR * This,
2052     /* [out] */ LPTYPEATTR __RPC_FAR *ppTypeAttr,
2053     /* [out] */ CLEANLOCALSTORAGE __RPC_FAR *pDummy)
2054 {
2055
2056     HRESULT _RetVal;
2057
2058     RPC_MESSAGE _RpcMessage;
2059
2060     MIDL_STUB_MESSAGE _StubMsg;
2061
2062     if(ppTypeAttr)
2063         {
2064         *ppTypeAttr = 0;
2065         }
2066     if(pDummy)
2067         {
2068         MIDL_memset(
2069                pDummy,
2070                0,
2071                sizeof( CLEANLOCALSTORAGE  ));
2072         }
2073     RpcTryExcept
2074         {
2075         NdrProxyInitialize(
2076                       ( void __RPC_FAR *  )This,
2077                       ( PRPC_MESSAGE  )&_RpcMessage,
2078                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
2079                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
2080                       3);
2081
2082
2083
2084         if(!ppTypeAttr)
2085             {
2086             RpcRaiseException(RPC_X_NULL_REF_POINTER);
2087             }
2088         if(!pDummy)
2089             {
2090             RpcRaiseException(RPC_X_NULL_REF_POINTER);
2091             }
2092         RpcTryFinally
2093             {
2094
2095             _StubMsg.BufferLength = 0U;
2096             NdrProxyGetBuffer(This, &_StubMsg);
2097             NdrProxySendReceive(This, &_StubMsg);
2098
2099             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
2100                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[142] );
2101
2102             NdrPointerUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
2103                                   (unsigned char __RPC_FAR * __RPC_FAR *)&ppTypeAttr,
2104                                   (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1578],
2105                                   (unsigned char)0 );
2106
2107             NdrUserMarshalUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
2108                                       (unsigned char __RPC_FAR * __RPC_FAR *)&pDummy,
2109                                       (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1644],
2110                                       (unsigned char)0 );
2111
2112             _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
2113             _RetVal = *( HRESULT __RPC_FAR * )_StubMsg.Buffer;
2114             _StubMsg.Buffer += sizeof(HRESULT);
2115
2116             }
2117         RpcFinally
2118             {
2119             NdrProxyFreeBuffer(This, &_StubMsg);
2120
2121             }
2122         RpcEndFinally
2123
2124         }
2125     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
2126         {
2127         NdrClearOutParameters(
2128                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
2129                          ( PFORMAT_STRING  )&__MIDL_TypeFormatString.Format[1578],
2130                          ( void __RPC_FAR * )ppTypeAttr);
2131         NdrClearOutParameters(
2132                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
2133                          ( PFORMAT_STRING  )&__MIDL_TypeFormatString.Format[1638],
2134                          ( void __RPC_FAR * )pDummy);
2135         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
2136         }
2137     RpcEndExcept
2138     return _RetVal;
2139 }
2140
2141 void __RPC_STUB ITypeInfo_RemoteGetTypeAttr_Stub(
2142     IRpcStubBuffer *This,
2143     IRpcChannelBuffer *_pRpcChannelBuffer,
2144     PRPC_MESSAGE _pRpcMessage,
2145     DWORD *_pdwStubPhase)
2146 {
2147     LPTYPEATTR _M24;
2148     CLEANLOCALSTORAGE _M25;
2149     HRESULT _RetVal;
2150     MIDL_STUB_MESSAGE _StubMsg;
2151     CLEANLOCALSTORAGE __RPC_FAR *pDummy;
2152     LPTYPEATTR __RPC_FAR *ppTypeAttr;
2153
2154 NdrStubInitialize(
2155                      _pRpcMessage,
2156                      &_StubMsg,
2157                      &Object_StubDesc,
2158                      _pRpcChannelBuffer);
2159     ppTypeAttr = 0;
2160     pDummy = 0;
2161     RpcTryFinally
2162         {
2163         ppTypeAttr = &_M24;
2164         _M24 = 0;
2165         pDummy = &_M25;
2166         MIDL_memset(
2167                pDummy,
2168                0,
2169                sizeof( CLEANLOCALSTORAGE  ));
2170
2171         *_pdwStubPhase = STUB_CALL_SERVER;
2172
2173
2174         _RetVal = ITypeInfo_GetTypeAttr_Stub(
2175                                      (ITypeInfo *) ((CStdStubBuffer *)This)->pvServerObject,
2176                                      ppTypeAttr,
2177                                      pDummy);
2178
2179         *_pdwStubPhase = STUB_MARSHAL;
2180
2181         _StubMsg.BufferLength = 8U + 11U + 7U;
2182         NdrPointerBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
2183                               (unsigned char __RPC_FAR *)ppTypeAttr,
2184                               (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1578] );
2185
2186         _StubMsg.BufferLength += 16;
2187
2188         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
2189         NdrPointerMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
2190                             (unsigned char __RPC_FAR *)ppTypeAttr,
2191                             (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1578] );
2192
2193         NdrUserMarshalMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
2194                                 (unsigned char __RPC_FAR *)pDummy,
2195                                 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1644] );
2196
2197         _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
2198         *( HRESULT __RPC_FAR * )_StubMsg.Buffer = _RetVal;
2199         _StubMsg.Buffer += sizeof(HRESULT);
2200
2201         }
2202     RpcFinally
2203         {
2204         NdrPointerFree( &_StubMsg,
2205                         (unsigned char __RPC_FAR *)ppTypeAttr,
2206                         &__MIDL_TypeFormatString.Format[1578] );
2207
2208         NdrPointerFree( &_StubMsg,
2209                         (unsigned char __RPC_FAR *)pDummy,
2210                         &__MIDL_TypeFormatString.Format[1638] );
2211
2212         }
2213     RpcEndFinally
2214     _pRpcMessage->BufferLength =
2215         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
2216
2217 }
2218
2219
2220 HRESULT STDMETHODCALLTYPE ITypeInfo_GetTypeComp_Proxy(
2221     ITypeInfo __RPC_FAR * This,
2222     /* [out] */ ITypeComp __RPC_FAR *__RPC_FAR *ppTComp)
2223 {
2224
2225     HRESULT _RetVal;
2226
2227     RPC_MESSAGE _RpcMessage;
2228
2229     MIDL_STUB_MESSAGE _StubMsg;
2230
2231     if(ppTComp)
2232         {
2233         MIDL_memset(
2234                ppTComp,
2235                0,
2236                sizeof( ITypeComp __RPC_FAR *__RPC_FAR * ));
2237         }
2238     RpcTryExcept
2239         {
2240         NdrProxyInitialize(
2241                       ( void __RPC_FAR *  )This,
2242                       ( PRPC_MESSAGE  )&_RpcMessage,
2243                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
2244                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
2245                       4);
2246
2247
2248
2249         if(!ppTComp)
2250             {
2251             RpcRaiseException(RPC_X_NULL_REF_POINTER);
2252             }
2253         RpcTryFinally
2254             {
2255
2256             _StubMsg.BufferLength = 0U;
2257             NdrProxyGetBuffer(This, &_StubMsg);
2258             NdrProxySendReceive(This, &_StubMsg);
2259
2260             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
2261                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[152] );
2262
2263             NdrPointerUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
2264                                   (unsigned char __RPC_FAR * __RPC_FAR *)&ppTComp,
2265                                   (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1540],
2266                                   (unsigned char)0 );
2267
2268             _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
2269             _RetVal = *( HRESULT __RPC_FAR * )_StubMsg.Buffer;
2270             _StubMsg.Buffer += sizeof(HRESULT);
2271
2272             }
2273         RpcFinally
2274             {
2275             NdrProxyFreeBuffer(This, &_StubMsg);
2276
2277             }
2278         RpcEndFinally
2279
2280         }
2281     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
2282         {
2283         NdrClearOutParameters(
2284                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
2285                          ( PFORMAT_STRING  )&__MIDL_TypeFormatString.Format[1540],
2286                          ( void __RPC_FAR * )ppTComp);
2287         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
2288         }
2289     RpcEndExcept
2290     return _RetVal;
2291 }
2292
2293 void __RPC_STUB ITypeInfo_GetTypeComp_Stub(
2294     IRpcStubBuffer *This,
2295     IRpcChannelBuffer *_pRpcChannelBuffer,
2296     PRPC_MESSAGE _pRpcMessage,
2297     DWORD *_pdwStubPhase)
2298 {
2299     ITypeComp __RPC_FAR *_M26;
2300     HRESULT _RetVal;
2301     MIDL_STUB_MESSAGE _StubMsg;
2302     ITypeComp __RPC_FAR *__RPC_FAR *ppTComp;
2303
2304 NdrStubInitialize(
2305                      _pRpcMessage,
2306                      &_StubMsg,
2307                      &Object_StubDesc,
2308                      _pRpcChannelBuffer);
2309     ppTComp = 0;
2310     RpcTryFinally
2311         {
2312         ppTComp = &_M26;
2313         _M26 = 0;
2314
2315         *_pdwStubPhase = STUB_CALL_SERVER;
2316         _RetVal = (((ITypeInfo*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> GetTypeComp((ITypeInfo *) ((CStdStubBuffer *)This)->pvServerObject,ppTComp);
2317
2318         *_pdwStubPhase = STUB_MARSHAL;
2319
2320         _StubMsg.BufferLength = 0U + 4U;
2321         NdrPointerBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
2322                               (unsigned char __RPC_FAR *)ppTComp,
2323                               (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1540] );
2324
2325         _StubMsg.BufferLength += 16;
2326
2327         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
2328         NdrPointerMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
2329                             (unsigned char __RPC_FAR *)ppTComp,
2330                             (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1540] );
2331
2332         _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
2333         *( HRESULT __RPC_FAR * )_StubMsg.Buffer = _RetVal;
2334         _StubMsg.Buffer += sizeof(HRESULT);
2335
2336         }
2337     RpcFinally
2338         {
2339         NdrPointerFree( &_StubMsg,
2340                         (unsigned char __RPC_FAR *)ppTComp,
2341                         &__MIDL_TypeFormatString.Format[1540] );
2342
2343         }
2344     RpcEndFinally
2345     _pRpcMessage->BufferLength =
2346         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
2347
2348 }
2349
2350
2351 /* [call_as] */ HRESULT STDMETHODCALLTYPE ITypeInfo_RemoteGetFuncDesc_Proxy(
2352     ITypeInfo __RPC_FAR * This,
2353     /* [in] */ UINT index,
2354     /* [out] */ LPFUNCDESC __RPC_FAR *ppFuncDesc,
2355     /* [out] */ CLEANLOCALSTORAGE __RPC_FAR *pDummy)
2356 {
2357
2358     HRESULT _RetVal;
2359
2360     RPC_MESSAGE _RpcMessage;
2361
2362     MIDL_STUB_MESSAGE _StubMsg;
2363
2364     if(ppFuncDesc)
2365         {
2366         *ppFuncDesc = 0;
2367         }
2368     if(pDummy)
2369         {
2370         MIDL_memset(
2371                pDummy,
2372                0,
2373                sizeof( CLEANLOCALSTORAGE  ));
2374         }
2375     RpcTryExcept
2376         {
2377         NdrProxyInitialize(
2378                       ( void __RPC_FAR *  )This,
2379                       ( PRPC_MESSAGE  )&_RpcMessage,
2380                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
2381                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
2382                       5);
2383
2384
2385
2386         if(!ppFuncDesc)
2387             {
2388             RpcRaiseException(RPC_X_NULL_REF_POINTER);
2389             }
2390         if(!pDummy)
2391             {
2392             RpcRaiseException(RPC_X_NULL_REF_POINTER);
2393             }
2394         RpcTryFinally
2395             {
2396
2397             _StubMsg.BufferLength = 4U;
2398             NdrProxyGetBuffer(This, &_StubMsg);
2399             *( UINT __RPC_FAR * )_StubMsg.Buffer = index;
2400             _StubMsg.Buffer += sizeof(UINT);
2401
2402             NdrProxySendReceive(This, &_StubMsg);
2403
2404             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
2405                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[158] );
2406
2407             NdrPointerUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
2408                                   (unsigned char __RPC_FAR * __RPC_FAR *)&ppFuncDesc,
2409                                   (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1254],
2410                                   (unsigned char)0 );
2411
2412             NdrUserMarshalUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
2413                                       (unsigned char __RPC_FAR * __RPC_FAR *)&pDummy,
2414                                       (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1660],
2415                                       (unsigned char)0 );
2416
2417             _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
2418             _RetVal = *( HRESULT __RPC_FAR * )_StubMsg.Buffer;
2419             _StubMsg.Buffer += sizeof(HRESULT);
2420
2421             }
2422         RpcFinally
2423             {
2424             NdrProxyFreeBuffer(This, &_StubMsg);
2425
2426             }
2427         RpcEndFinally
2428
2429         }
2430     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
2431         {
2432         NdrClearOutParameters(
2433                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
2434                          ( PFORMAT_STRING  )&__MIDL_TypeFormatString.Format[1254],
2435                          ( void __RPC_FAR * )ppFuncDesc);
2436         NdrClearOutParameters(
2437                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
2438                          ( PFORMAT_STRING  )&__MIDL_TypeFormatString.Format[1654],
2439                          ( void __RPC_FAR * )pDummy);
2440         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
2441         }
2442     RpcEndExcept
2443     return _RetVal;
2444 }
2445
2446 void __RPC_STUB ITypeInfo_RemoteGetFuncDesc_Stub(
2447     IRpcStubBuffer *This,
2448     IRpcChannelBuffer *_pRpcChannelBuffer,
2449     PRPC_MESSAGE _pRpcMessage,
2450     DWORD *_pdwStubPhase)
2451 {
2452     LPFUNCDESC _M27;
2453     CLEANLOCALSTORAGE _M28;
2454     HRESULT _RetVal;
2455     MIDL_STUB_MESSAGE _StubMsg;
2456     UINT index;
2457     CLEANLOCALSTORAGE __RPC_FAR *pDummy;
2458     LPFUNCDESC __RPC_FAR *ppFuncDesc;
2459
2460 NdrStubInitialize(
2461                      _pRpcMessage,
2462                      &_StubMsg,
2463                      &Object_StubDesc,
2464                      _pRpcChannelBuffer);
2465     ppFuncDesc = 0;
2466     pDummy = 0;
2467     RpcTryFinally
2468         {
2469         if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
2470             NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[158] );
2471
2472         index = *( UINT __RPC_FAR * )_StubMsg.Buffer;
2473         _StubMsg.Buffer += sizeof(UINT);
2474
2475         ppFuncDesc = &_M27;
2476         _M27 = 0;
2477         pDummy = &_M28;
2478         MIDL_memset(
2479                pDummy,
2480                0,
2481                sizeof( CLEANLOCALSTORAGE  ));
2482
2483         *_pdwStubPhase = STUB_CALL_SERVER;
2484
2485
2486         _RetVal = ITypeInfo_GetFuncDesc_Stub(
2487                                      (ITypeInfo *) ((CStdStubBuffer *)This)->pvServerObject,
2488                                      index,
2489                                      ppFuncDesc,
2490                                      pDummy);
2491
2492         *_pdwStubPhase = STUB_MARSHAL;
2493
2494         _StubMsg.BufferLength = 8U + 11U + 7U;
2495         NdrPointerBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
2496                               (unsigned char __RPC_FAR *)ppFuncDesc,
2497                               (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1254] );
2498
2499         _StubMsg.BufferLength += 16;
2500
2501         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
2502         NdrPointerMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
2503                             (unsigned char __RPC_FAR *)ppFuncDesc,
2504                             (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1254] );
2505
2506         NdrUserMarshalMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
2507                                 (unsigned char __RPC_FAR *)pDummy,
2508                                 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1660] );
2509
2510         _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
2511         *( HRESULT __RPC_FAR * )_StubMsg.Buffer = _RetVal;
2512         _StubMsg.Buffer += sizeof(HRESULT);
2513
2514         }
2515     RpcFinally
2516         {
2517         NdrPointerFree( &_StubMsg,
2518                         (unsigned char __RPC_FAR *)ppFuncDesc,
2519                         &__MIDL_TypeFormatString.Format[1254] );
2520
2521         NdrPointerFree( &_StubMsg,
2522                         (unsigned char __RPC_FAR *)pDummy,
2523                         &__MIDL_TypeFormatString.Format[1654] );
2524
2525         }
2526     RpcEndFinally
2527     _pRpcMessage->BufferLength =
2528         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
2529
2530 }
2531
2532
2533 /* [call_as] */ HRESULT STDMETHODCALLTYPE ITypeInfo_RemoteGetVarDesc_Proxy(
2534     ITypeInfo __RPC_FAR * This,
2535     /* [in] */ UINT index,
2536     /* [out] */ LPVARDESC __RPC_FAR *ppVarDesc,
2537     /* [out] */ CLEANLOCALSTORAGE __RPC_FAR *pDummy)
2538 {
2539
2540     HRESULT _RetVal;
2541
2542     RPC_MESSAGE _RpcMessage;
2543
2544     MIDL_STUB_MESSAGE _StubMsg;
2545
2546     if(ppVarDesc)
2547         {
2548         *ppVarDesc = 0;
2549         }
2550     if(pDummy)
2551         {
2552         MIDL_memset(
2553                pDummy,
2554                0,
2555                sizeof( CLEANLOCALSTORAGE  ));
2556         }
2557     RpcTryExcept
2558         {
2559         NdrProxyInitialize(
2560                       ( void __RPC_FAR *  )This,
2561                       ( PRPC_MESSAGE  )&_RpcMessage,
2562                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
2563                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
2564                       6);
2565
2566
2567
2568         if(!ppVarDesc)
2569             {
2570             RpcRaiseException(RPC_X_NULL_REF_POINTER);
2571             }
2572         if(!pDummy)
2573             {
2574             RpcRaiseException(RPC_X_NULL_REF_POINTER);
2575             }
2576         RpcTryFinally
2577             {
2578
2579             _StubMsg.BufferLength = 4U;
2580             NdrProxyGetBuffer(This, &_StubMsg);
2581             *( UINT __RPC_FAR * )_StubMsg.Buffer = index;
2582             _StubMsg.Buffer += sizeof(UINT);
2583
2584             NdrProxySendReceive(This, &_StubMsg);
2585
2586             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
2587                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[170] );
2588
2589             NdrPointerUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
2590                                   (unsigned char __RPC_FAR * __RPC_FAR *)&ppVarDesc,
2591                                   (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1464],
2592                                   (unsigned char)0 );
2593
2594             NdrUserMarshalUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
2595                                       (unsigned char __RPC_FAR * __RPC_FAR *)&pDummy,
2596                                       (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1676],
2597                                       (unsigned char)0 );
2598
2599             _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
2600             _RetVal = *( HRESULT __RPC_FAR * )_StubMsg.Buffer;
2601             _StubMsg.Buffer += sizeof(HRESULT);
2602
2603             }
2604         RpcFinally
2605             {
2606             NdrProxyFreeBuffer(This, &_StubMsg);
2607
2608             }
2609         RpcEndFinally
2610
2611         }
2612     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
2613         {
2614         NdrClearOutParameters(
2615                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
2616                          ( PFORMAT_STRING  )&__MIDL_TypeFormatString.Format[1464],
2617                          ( void __RPC_FAR * )ppVarDesc);
2618         NdrClearOutParameters(
2619                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
2620                          ( PFORMAT_STRING  )&__MIDL_TypeFormatString.Format[1670],
2621                          ( void __RPC_FAR * )pDummy);
2622         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
2623         }
2624     RpcEndExcept
2625     return _RetVal;
2626 }
2627
2628 void __RPC_STUB ITypeInfo_RemoteGetVarDesc_Stub(
2629     IRpcStubBuffer *This,
2630     IRpcChannelBuffer *_pRpcChannelBuffer,
2631     PRPC_MESSAGE _pRpcMessage,
2632     DWORD *_pdwStubPhase)
2633 {
2634     LPVARDESC _M29;
2635     CLEANLOCALSTORAGE _M30;
2636     HRESULT _RetVal;
2637     MIDL_STUB_MESSAGE _StubMsg;
2638     UINT index;
2639     CLEANLOCALSTORAGE __RPC_FAR *pDummy;
2640     LPVARDESC __RPC_FAR *ppVarDesc;
2641
2642 NdrStubInitialize(
2643                      _pRpcMessage,
2644                      &_StubMsg,
2645                      &Object_StubDesc,
2646                      _pRpcChannelBuffer);
2647     ppVarDesc = 0;
2648     pDummy = 0;
2649     RpcTryFinally
2650         {
2651         if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
2652             NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[170] );
2653
2654         index = *( UINT __RPC_FAR * )_StubMsg.Buffer;
2655         _StubMsg.Buffer += sizeof(UINT);
2656
2657         ppVarDesc = &_M29;
2658         _M29 = 0;
2659         pDummy = &_M30;
2660         MIDL_memset(
2661                pDummy,
2662                0,
2663                sizeof( CLEANLOCALSTORAGE  ));
2664
2665         *_pdwStubPhase = STUB_CALL_SERVER;
2666
2667
2668         _RetVal = ITypeInfo_GetVarDesc_Stub(
2669                                     (ITypeInfo *) ((CStdStubBuffer *)This)->pvServerObject,
2670                                     index,
2671                                     ppVarDesc,
2672                                     pDummy);
2673
2674         *_pdwStubPhase = STUB_MARSHAL;
2675
2676         _StubMsg.BufferLength = 8U + 11U + 7U;
2677         NdrPointerBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
2678                               (unsigned char __RPC_FAR *)ppVarDesc,
2679                               (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1464] );
2680
2681         _StubMsg.BufferLength += 16;
2682
2683         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
2684         NdrPointerMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
2685                             (unsigned char __RPC_FAR *)ppVarDesc,
2686                             (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1464] );
2687
2688         NdrUserMarshalMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
2689                                 (unsigned char __RPC_FAR *)pDummy,
2690                                 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1676] );
2691
2692         _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
2693         *( HRESULT __RPC_FAR * )_StubMsg.Buffer = _RetVal;
2694         _StubMsg.Buffer += sizeof(HRESULT);
2695
2696         }
2697     RpcFinally
2698         {
2699         NdrPointerFree( &_StubMsg,
2700                         (unsigned char __RPC_FAR *)ppVarDesc,
2701                         &__MIDL_TypeFormatString.Format[1464] );
2702
2703         NdrPointerFree( &_StubMsg,
2704                         (unsigned char __RPC_FAR *)pDummy,
2705                         &__MIDL_TypeFormatString.Format[1670] );
2706
2707         }
2708     RpcEndFinally
2709     _pRpcMessage->BufferLength =
2710         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
2711
2712 }
2713
2714
2715 /* [call_as] */ HRESULT STDMETHODCALLTYPE ITypeInfo_RemoteGetNames_Proxy(
2716     ITypeInfo __RPC_FAR * This,
2717     /* [in] */ MEMBERID memid,
2718     /* [length_is][size_is][out] */ BSTR __RPC_FAR *rgBstrNames,
2719     /* [in] */ UINT cMaxNames,
2720     /* [out] */ UINT __RPC_FAR *pcNames)
2721 {
2722
2723     HRESULT _RetVal;
2724
2725     RPC_MESSAGE _RpcMessage;
2726
2727     MIDL_STUB_MESSAGE _StubMsg;
2728
2729     if(rgBstrNames)
2730         {
2731         MIDL_memset(
2732                rgBstrNames,
2733                0,
2734                cMaxNames * sizeof( BSTR  ));
2735         }
2736     RpcTryExcept
2737         {
2738         NdrProxyInitialize(
2739                       ( void __RPC_FAR *  )This,
2740                       ( PRPC_MESSAGE  )&_RpcMessage,
2741                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
2742                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
2743                       7);
2744
2745
2746
2747         if(!rgBstrNames)
2748             {
2749             RpcRaiseException(RPC_X_NULL_REF_POINTER);
2750             }
2751         if(!pcNames)
2752             {
2753             RpcRaiseException(RPC_X_NULL_REF_POINTER);
2754             }
2755         RpcTryFinally
2756             {
2757
2758             _StubMsg.BufferLength = 4U + 4U;
2759             NdrProxyGetBuffer(This, &_StubMsg);
2760             *( MEMBERID __RPC_FAR * )_StubMsg.Buffer = memid;
2761             _StubMsg.Buffer += sizeof(MEMBERID);
2762
2763             *( UINT __RPC_FAR * )_StubMsg.Buffer = cMaxNames;
2764             _StubMsg.Buffer += sizeof(UINT);
2765
2766             NdrProxySendReceive(This, &_StubMsg);
2767
2768             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
2769                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[182] );
2770
2771             NdrComplexArrayUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
2772                                        (unsigned char __RPC_FAR * __RPC_FAR *)&rgBstrNames,
2773                                        (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1690],
2774                                        (unsigned char)0 );
2775
2776             _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
2777             *pcNames = *( UINT __RPC_FAR * )_StubMsg.Buffer;
2778             _StubMsg.Buffer += sizeof(UINT);
2779
2780             _RetVal = *( HRESULT __RPC_FAR * )_StubMsg.Buffer;
2781             _StubMsg.Buffer += sizeof(HRESULT);
2782
2783             }
2784         RpcFinally
2785             {
2786             NdrProxyFreeBuffer(This, &_StubMsg);
2787
2788             }
2789         RpcEndFinally
2790
2791         }
2792     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
2793         {
2794         _StubMsg.MaxCount = cMaxNames;
2795         _StubMsg.Offset = 0;
2796         _StubMsg.ActualCount = _StubMsg.MaxCount;
2797
2798         NdrClearOutParameters(
2799                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
2800                          ( PFORMAT_STRING  )&__MIDL_TypeFormatString.Format[1686],
2801                          ( void __RPC_FAR * )rgBstrNames);
2802         NdrClearOutParameters(
2803                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
2804                          ( PFORMAT_STRING  )&__MIDL_TypeFormatString.Format[2],
2805                          ( void __RPC_FAR * )pcNames);
2806         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
2807         }
2808     RpcEndExcept
2809     return _RetVal;
2810 }
2811
2812 void __RPC_STUB ITypeInfo_RemoteGetNames_Stub(
2813     IRpcStubBuffer *This,
2814     IRpcChannelBuffer *_pRpcChannelBuffer,
2815     PRPC_MESSAGE _pRpcMessage,
2816     DWORD *_pdwStubPhase)
2817 {
2818     UINT _M34;
2819     HRESULT _RetVal;
2820     MIDL_STUB_MESSAGE _StubMsg;
2821     UINT cMaxNames;
2822     MEMBERID memid;
2823     UINT __RPC_FAR *pcNames;
2824     BSTR __RPC_FAR *rgBstrNames;
2825
2826 NdrStubInitialize(
2827                      _pRpcMessage,
2828                      &_StubMsg,
2829                      &Object_StubDesc,
2830                      _pRpcChannelBuffer);
2831     rgBstrNames = 0;
2832     pcNames = 0;
2833     RpcTryFinally
2834         {
2835         if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
2836             NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[182] );
2837
2838         memid = *( MEMBERID __RPC_FAR * )_StubMsg.Buffer;
2839         _StubMsg.Buffer += sizeof(MEMBERID);
2840
2841         cMaxNames = *( UINT __RPC_FAR * )_StubMsg.Buffer;
2842         _StubMsg.Buffer += sizeof(UINT);
2843
2844         rgBstrNames = NdrAllocate(&_StubMsg,cMaxNames * 4);
2845         pcNames = &_M34;
2846
2847         *_pdwStubPhase = STUB_CALL_SERVER;
2848
2849
2850         _RetVal = ITypeInfo_GetNames_Stub(
2851                                   (ITypeInfo *) ((CStdStubBuffer *)This)->pvServerObject,
2852                                   memid,
2853                                   rgBstrNames,
2854                                   cMaxNames,
2855                                   pcNames);
2856
2857         *_pdwStubPhase = STUB_MARSHAL;
2858
2859         _StubMsg.BufferLength = 12U + 7U + 7U;
2860         _StubMsg.MaxCount = cMaxNames;
2861         _StubMsg.Offset = 0;
2862         _StubMsg.ActualCount = pcNames ? *pcNames : 0;
2863
2864         NdrComplexArrayBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
2865                                    (unsigned char __RPC_FAR *)rgBstrNames,
2866                                    (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1690] );
2867
2868         _StubMsg.BufferLength += 16;
2869
2870         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
2871         _StubMsg.MaxCount = cMaxNames;
2872         _StubMsg.Offset = 0;
2873         _StubMsg.ActualCount = pcNames ? *pcNames : 0;
2874
2875         NdrComplexArrayMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
2876                                  (unsigned char __RPC_FAR *)rgBstrNames,
2877                                  (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1690] );
2878
2879         _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
2880         *( UINT __RPC_FAR * )_StubMsg.Buffer = *pcNames;
2881         _StubMsg.Buffer += sizeof(UINT);
2882
2883         *( HRESULT __RPC_FAR * )_StubMsg.Buffer = _RetVal;
2884         _StubMsg.Buffer += sizeof(HRESULT);
2885
2886         }
2887     RpcFinally
2888         {
2889         _StubMsg.MaxCount = cMaxNames;
2890         _StubMsg.Offset = 0;
2891         _StubMsg.ActualCount = pcNames ? *pcNames : 0;
2892
2893         NdrPointerFree( &_StubMsg,
2894                         (unsigned char __RPC_FAR *)rgBstrNames,
2895                         &__MIDL_TypeFormatString.Format[1686] );
2896
2897         }
2898     RpcEndFinally
2899     _pRpcMessage->BufferLength =
2900         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
2901
2902 }
2903
2904
2905 HRESULT STDMETHODCALLTYPE ITypeInfo_GetRefTypeOfImplType_Proxy(
2906     ITypeInfo __RPC_FAR * This,
2907     /* [in] */ UINT index,
2908     /* [out] */ HREFTYPE __RPC_FAR *pRefType)
2909 {
2910
2911     HRESULT _RetVal;
2912
2913     RPC_MESSAGE _RpcMessage;
2914
2915     MIDL_STUB_MESSAGE _StubMsg;
2916
2917     RpcTryExcept
2918         {
2919         NdrProxyInitialize(
2920                       ( void __RPC_FAR *  )This,
2921                       ( PRPC_MESSAGE  )&_RpcMessage,
2922                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
2923                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
2924                       8);
2925
2926
2927
2928         if(!pRefType)
2929             {
2930             RpcRaiseException(RPC_X_NULL_REF_POINTER);
2931             }
2932         RpcTryFinally
2933             {
2934
2935             _StubMsg.BufferLength = 4U;
2936             NdrProxyGetBuffer(This, &_StubMsg);
2937             *( UINT __RPC_FAR * )_StubMsg.Buffer = index;
2938             _StubMsg.Buffer += sizeof(UINT);
2939
2940             NdrProxySendReceive(This, &_StubMsg);
2941
2942             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
2943                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[196] );
2944
2945             *pRefType = *( HREFTYPE __RPC_FAR * )_StubMsg.Buffer;
2946             _StubMsg.Buffer += sizeof(HREFTYPE);
2947
2948             _RetVal = *( HRESULT __RPC_FAR * )_StubMsg.Buffer;
2949             _StubMsg.Buffer += sizeof(HRESULT);
2950
2951             }
2952         RpcFinally
2953             {
2954             NdrProxyFreeBuffer(This, &_StubMsg);
2955
2956             }
2957         RpcEndFinally
2958
2959         }
2960     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
2961         {
2962         NdrClearOutParameters(
2963                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
2964                          ( PFORMAT_STRING  )&__MIDL_TypeFormatString.Format[2],
2965                          ( void __RPC_FAR * )pRefType);
2966         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
2967         }
2968     RpcEndExcept
2969     return _RetVal;
2970 }
2971
2972 void __RPC_STUB ITypeInfo_GetRefTypeOfImplType_Stub(
2973     IRpcStubBuffer *This,
2974     IRpcChannelBuffer *_pRpcChannelBuffer,
2975     PRPC_MESSAGE _pRpcMessage,
2976     DWORD *_pdwStubPhase)
2977 {
2978     HREFTYPE _M35;
2979     HRESULT _RetVal;
2980     MIDL_STUB_MESSAGE _StubMsg;
2981     UINT index;
2982     HREFTYPE __RPC_FAR *pRefType;
2983
2984 NdrStubInitialize(
2985                      _pRpcMessage,
2986                      &_StubMsg,
2987                      &Object_StubDesc,
2988                      _pRpcChannelBuffer);
2989     pRefType = 0;
2990     RpcTryFinally
2991         {
2992         if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
2993             NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[196] );
2994
2995         index = *( UINT __RPC_FAR * )_StubMsg.Buffer;
2996         _StubMsg.Buffer += sizeof(UINT);
2997
2998         pRefType = &_M35;
2999
3000         *_pdwStubPhase = STUB_CALL_SERVER;
3001         _RetVal = (((ITypeInfo*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> GetRefTypeOfImplType(
3002                         (ITypeInfo *) ((CStdStubBuffer *)This)->pvServerObject,
3003                         index,
3004                         pRefType);
3005
3006         *_pdwStubPhase = STUB_MARSHAL;
3007
3008         _StubMsg.BufferLength = 4U + 4U;
3009         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
3010         *( HREFTYPE __RPC_FAR * )_StubMsg.Buffer = *pRefType;
3011         _StubMsg.Buffer += sizeof(HREFTYPE);
3012
3013         *( HRESULT __RPC_FAR * )_StubMsg.Buffer = _RetVal;
3014         _StubMsg.Buffer += sizeof(HRESULT);
3015
3016         }
3017     RpcFinally
3018         {
3019         }
3020     RpcEndFinally
3021     _pRpcMessage->BufferLength =
3022         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
3023
3024 }
3025
3026
3027 HRESULT STDMETHODCALLTYPE ITypeInfo_GetImplTypeFlags_Proxy(
3028     ITypeInfo __RPC_FAR * This,
3029     /* [in] */ UINT index,
3030     /* [out] */ INT __RPC_FAR *pImplTypeFlags)
3031 {
3032
3033     HRESULT _RetVal;
3034
3035     RPC_MESSAGE _RpcMessage;
3036
3037     MIDL_STUB_MESSAGE _StubMsg;
3038
3039     RpcTryExcept
3040         {
3041         NdrProxyInitialize(
3042                       ( void __RPC_FAR *  )This,
3043                       ( PRPC_MESSAGE  )&_RpcMessage,
3044                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
3045                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
3046                       9);
3047
3048
3049
3050         if(!pImplTypeFlags)
3051             {
3052             RpcRaiseException(RPC_X_NULL_REF_POINTER);
3053             }
3054         RpcTryFinally
3055             {
3056
3057             _StubMsg.BufferLength = 4U;
3058             NdrProxyGetBuffer(This, &_StubMsg);
3059             *( UINT __RPC_FAR * )_StubMsg.Buffer = index;
3060             _StubMsg.Buffer += sizeof(UINT);
3061
3062             NdrProxySendReceive(This, &_StubMsg);
3063
3064             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
3065                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[196] );
3066
3067             *pImplTypeFlags = *( INT __RPC_FAR * )_StubMsg.Buffer;
3068             _StubMsg.Buffer += sizeof(INT);
3069
3070             _RetVal = *( HRESULT __RPC_FAR * )_StubMsg.Buffer;
3071             _StubMsg.Buffer += sizeof(HRESULT);
3072
3073             }
3074         RpcFinally
3075             {
3076             NdrProxyFreeBuffer(This, &_StubMsg);
3077
3078             }
3079         RpcEndFinally
3080
3081         }
3082     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
3083         {
3084         NdrClearOutParameters(
3085                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
3086                          ( PFORMAT_STRING  )&__MIDL_TypeFormatString.Format[2],
3087                          ( void __RPC_FAR * )pImplTypeFlags);
3088         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
3089         }
3090     RpcEndExcept
3091     return _RetVal;
3092 }
3093
3094 void __RPC_STUB ITypeInfo_GetImplTypeFlags_Stub(
3095     IRpcStubBuffer *This,
3096     IRpcChannelBuffer *_pRpcChannelBuffer,
3097     PRPC_MESSAGE _pRpcMessage,
3098     DWORD *_pdwStubPhase)
3099 {
3100     INT _M36;
3101     HRESULT _RetVal;
3102     MIDL_STUB_MESSAGE _StubMsg;
3103     UINT index;
3104     INT __RPC_FAR *pImplTypeFlags;
3105
3106 NdrStubInitialize(
3107                      _pRpcMessage,
3108                      &_StubMsg,
3109                      &Object_StubDesc,
3110                      _pRpcChannelBuffer);
3111     pImplTypeFlags = 0;
3112     RpcTryFinally
3113         {
3114         if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
3115             NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[196] );
3116
3117         index = *( UINT __RPC_FAR * )_StubMsg.Buffer;
3118         _StubMsg.Buffer += sizeof(UINT);
3119
3120         pImplTypeFlags = &_M36;
3121
3122         *_pdwStubPhase = STUB_CALL_SERVER;
3123         _RetVal = (((ITypeInfo*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> GetImplTypeFlags(
3124                     (ITypeInfo *) ((CStdStubBuffer *)This)->pvServerObject,
3125                     index,
3126                     pImplTypeFlags);
3127
3128         *_pdwStubPhase = STUB_MARSHAL;
3129
3130         _StubMsg.BufferLength = 4U + 4U;
3131         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
3132         *( INT __RPC_FAR * )_StubMsg.Buffer = *pImplTypeFlags;
3133         _StubMsg.Buffer += sizeof(INT);
3134
3135         *( HRESULT __RPC_FAR * )_StubMsg.Buffer = _RetVal;
3136         _StubMsg.Buffer += sizeof(HRESULT);
3137
3138         }
3139     RpcFinally
3140         {
3141         }
3142     RpcEndFinally
3143     _pRpcMessage->BufferLength =
3144         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
3145
3146 }
3147
3148
3149 /* [call_as] */ HRESULT STDMETHODCALLTYPE ITypeInfo_LocalGetIDsOfNames_Proxy(
3150     ITypeInfo __RPC_FAR * This)
3151 {
3152
3153     HRESULT _RetVal;
3154
3155     RPC_MESSAGE _RpcMessage;
3156
3157     MIDL_STUB_MESSAGE _StubMsg;
3158
3159     RpcTryExcept
3160         {
3161         NdrProxyInitialize(
3162                       ( void __RPC_FAR *  )This,
3163                       ( PRPC_MESSAGE  )&_RpcMessage,
3164                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
3165                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
3166                       10);
3167
3168
3169
3170         RpcTryFinally
3171             {
3172
3173             _StubMsg.BufferLength = 0U;
3174             NdrProxyGetBuffer(This, &_StubMsg);
3175             NdrProxySendReceive(This, &_StubMsg);
3176
3177             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
3178                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[88] );
3179
3180             _RetVal = *( HRESULT __RPC_FAR * )_StubMsg.Buffer;
3181             _StubMsg.Buffer += sizeof(HRESULT);
3182
3183             }
3184         RpcFinally
3185             {
3186             NdrProxyFreeBuffer(This, &_StubMsg);
3187
3188             }
3189         RpcEndFinally
3190
3191         }
3192     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
3193         {
3194         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
3195         }
3196     RpcEndExcept
3197     return _RetVal;
3198 }
3199
3200 void __RPC_STUB ITypeInfo_LocalGetIDsOfNames_Stub(
3201     IRpcStubBuffer *This,
3202     IRpcChannelBuffer *_pRpcChannelBuffer,
3203     PRPC_MESSAGE _pRpcMessage,
3204     DWORD *_pdwStubPhase)
3205 {
3206     HRESULT _RetVal;
3207     MIDL_STUB_MESSAGE _StubMsg;
3208
3209 NdrStubInitialize(
3210                      _pRpcMessage,
3211                      &_StubMsg,
3212                      &Object_StubDesc,
3213                      _pRpcChannelBuffer);
3214     RpcTryFinally
3215         {
3216
3217         *_pdwStubPhase = STUB_CALL_SERVER;
3218
3219
3220         _RetVal = ITypeInfo_GetIDsOfNames_Stub((ITypeInfo *) ((CStdStubBuffer *)This)->pvServerObject);
3221
3222         *_pdwStubPhase = STUB_MARSHAL;
3223
3224         _StubMsg.BufferLength = 4U;
3225         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
3226         *( HRESULT __RPC_FAR * )_StubMsg.Buffer = _RetVal;
3227         _StubMsg.Buffer += sizeof(HRESULT);
3228
3229         }
3230     RpcFinally
3231         {
3232         }
3233     RpcEndFinally
3234     _pRpcMessage->BufferLength =
3235         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
3236
3237 }
3238
3239
3240 /* [call_as] */ HRESULT STDMETHODCALLTYPE ITypeInfo_LocalInvoke_Proxy(
3241     ITypeInfo __RPC_FAR * This)
3242 {
3243
3244     HRESULT _RetVal;
3245
3246     RPC_MESSAGE _RpcMessage;
3247
3248     MIDL_STUB_MESSAGE _StubMsg;
3249
3250     RpcTryExcept
3251         {
3252         NdrProxyInitialize(
3253                       ( void __RPC_FAR *  )This,
3254                       ( PRPC_MESSAGE  )&_RpcMessage,
3255                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
3256                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
3257                       11);
3258
3259
3260
3261         RpcTryFinally
3262             {
3263
3264             _StubMsg.BufferLength = 0U;
3265             NdrProxyGetBuffer(This, &_StubMsg);
3266             NdrProxySendReceive(This, &_StubMsg);
3267
3268             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
3269                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[88] );
3270
3271             _RetVal = *( HRESULT __RPC_FAR * )_StubMsg.Buffer;
3272             _StubMsg.Buffer += sizeof(HRESULT);
3273
3274             }
3275         RpcFinally
3276             {
3277             NdrProxyFreeBuffer(This, &_StubMsg);
3278
3279             }
3280         RpcEndFinally
3281
3282         }
3283     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
3284         {
3285         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
3286         }
3287     RpcEndExcept
3288     return _RetVal;
3289 }
3290
3291 void __RPC_STUB ITypeInfo_LocalInvoke_Stub(
3292     IRpcStubBuffer *This,
3293     IRpcChannelBuffer *_pRpcChannelBuffer,
3294     PRPC_MESSAGE _pRpcMessage,
3295     DWORD *_pdwStubPhase)
3296 {
3297     HRESULT _RetVal;
3298     MIDL_STUB_MESSAGE _StubMsg;
3299
3300 NdrStubInitialize(
3301                      _pRpcMessage,
3302                      &_StubMsg,
3303                      &Object_StubDesc,
3304                      _pRpcChannelBuffer);
3305     RpcTryFinally
3306         {
3307
3308         *_pdwStubPhase = STUB_CALL_SERVER;
3309
3310
3311         _RetVal = ITypeInfo_Invoke_Stub((ITypeInfo *) ((CStdStubBuffer *)This)->pvServerObject);
3312
3313         *_pdwStubPhase = STUB_MARSHAL;
3314
3315         _StubMsg.BufferLength = 4U;
3316         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
3317         *( HRESULT __RPC_FAR * )_StubMsg.Buffer = _RetVal;
3318         _StubMsg.Buffer += sizeof(HRESULT);
3319
3320         }
3321     RpcFinally
3322         {
3323         }
3324     RpcEndFinally
3325     _pRpcMessage->BufferLength =
3326         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
3327
3328 }
3329
3330
3331 /* [call_as] */ HRESULT STDMETHODCALLTYPE ITypeInfo_RemoteGetDocumentation_Proxy(
3332     ITypeInfo __RPC_FAR * This,
3333     /* [in] */ MEMBERID memid,
3334     /* [in] */ DWORD refPtrFlags,
3335     /* [out] */ BSTR __RPC_FAR *pBstrName,
3336     /* [out] */ BSTR __RPC_FAR *pBstrDocString,
3337     /* [out] */ DWORD __RPC_FAR *pdwHelpContext,
3338     /* [out] */ BSTR __RPC_FAR *pBstrHelpFile)
3339 {
3340
3341     HRESULT _RetVal;
3342
3343     RPC_MESSAGE _RpcMessage;
3344
3345     MIDL_STUB_MESSAGE _StubMsg;
3346
3347     if(pBstrName)
3348         {
3349         MIDL_memset(
3350                pBstrName,
3351                0,
3352                sizeof( BSTR  ));
3353         }
3354     if(pBstrDocString)
3355         {
3356         MIDL_memset(
3357                pBstrDocString,
3358                0,
3359                sizeof( BSTR  ));
3360         }
3361     if(pBstrHelpFile)
3362         {
3363         MIDL_memset(
3364                pBstrHelpFile,
3365                0,
3366                sizeof( BSTR  ));
3367         }
3368     RpcTryExcept
3369         {
3370         NdrProxyInitialize(
3371                       ( void __RPC_FAR *  )This,
3372                       ( PRPC_MESSAGE  )&_RpcMessage,
3373                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
3374                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
3375                       12);
3376
3377
3378
3379         if(!pBstrName)
3380             {
3381             RpcRaiseException(RPC_X_NULL_REF_POINTER);
3382             }
3383         if(!pBstrDocString)
3384             {
3385             RpcRaiseException(RPC_X_NULL_REF_POINTER);
3386             }
3387         if(!pdwHelpContext)
3388             {
3389             RpcRaiseException(RPC_X_NULL_REF_POINTER);
3390             }
3391         if(!pBstrHelpFile)
3392             {
3393             RpcRaiseException(RPC_X_NULL_REF_POINTER);
3394             }
3395         RpcTryFinally
3396             {
3397
3398             _StubMsg.BufferLength = 4U + 4U;
3399             NdrProxyGetBuffer(This, &_StubMsg);
3400             *( MEMBERID __RPC_FAR * )_StubMsg.Buffer = memid;
3401             _StubMsg.Buffer += sizeof(MEMBERID);
3402
3403             *( DWORD __RPC_FAR * )_StubMsg.Buffer = refPtrFlags;
3404             _StubMsg.Buffer += sizeof(DWORD);
3405
3406             NdrProxySendReceive(This, &_StubMsg);
3407
3408             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
3409                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[204] );
3410
3411             NdrUserMarshalUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
3412                                       (unsigned char __RPC_FAR * __RPC_FAR *)&pBstrName,
3413                                       (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1128],
3414                                       (unsigned char)0 );
3415
3416             NdrUserMarshalUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
3417                                       (unsigned char __RPC_FAR * __RPC_FAR *)&pBstrDocString,
3418                                       (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1128],
3419                                       (unsigned char)0 );
3420
3421             _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
3422             *pdwHelpContext = *( DWORD __RPC_FAR * )_StubMsg.Buffer;
3423             _StubMsg.Buffer += sizeof(DWORD);
3424
3425             NdrUserMarshalUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
3426                                       (unsigned char __RPC_FAR * __RPC_FAR *)&pBstrHelpFile,
3427                                       (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1128],
3428                                       (unsigned char)0 );
3429
3430             _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
3431             _RetVal = *( HRESULT __RPC_FAR * )_StubMsg.Buffer;
3432             _StubMsg.Buffer += sizeof(HRESULT);
3433
3434             }
3435         RpcFinally
3436             {
3437             NdrProxyFreeBuffer(This, &_StubMsg);
3438
3439             }
3440         RpcEndFinally
3441
3442         }
3443     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
3444         {
3445         NdrClearOutParameters(
3446                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
3447                          ( PFORMAT_STRING  )&__MIDL_TypeFormatString.Format[1708],
3448                          ( void __RPC_FAR * )pBstrName);
3449         NdrClearOutParameters(
3450                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
3451                          ( PFORMAT_STRING  )&__MIDL_TypeFormatString.Format[1708],
3452                          ( void __RPC_FAR * )pBstrDocString);
3453         NdrClearOutParameters(
3454                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
3455                          ( PFORMAT_STRING  )&__MIDL_TypeFormatString.Format[2],
3456                          ( void __RPC_FAR * )pdwHelpContext);
3457         NdrClearOutParameters(
3458                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
3459                          ( PFORMAT_STRING  )&__MIDL_TypeFormatString.Format[1708],
3460                          ( void __RPC_FAR * )pBstrHelpFile);
3461         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
3462         }
3463     RpcEndExcept
3464     return _RetVal;
3465 }
3466
3467 void __RPC_STUB ITypeInfo_RemoteGetDocumentation_Stub(
3468     IRpcStubBuffer *This,
3469     IRpcChannelBuffer *_pRpcChannelBuffer,
3470     PRPC_MESSAGE _pRpcMessage,
3471     DWORD *_pdwStubPhase)
3472 {
3473     BSTR _M37;
3474     BSTR _M38;
3475     DWORD _M39;
3476     BSTR _M40;
3477     HRESULT _RetVal;
3478     MIDL_STUB_MESSAGE _StubMsg;
3479     MEMBERID memid;
3480     BSTR __RPC_FAR *pBstrDocString;
3481     BSTR __RPC_FAR *pBstrHelpFile;
3482     BSTR __RPC_FAR *pBstrName;
3483     DWORD __RPC_FAR *pdwHelpContext;
3484     DWORD refPtrFlags;
3485
3486 NdrStubInitialize(
3487                      _pRpcMessage,
3488                      &_StubMsg,
3489                      &Object_StubDesc,
3490                      _pRpcChannelBuffer);
3491     pBstrName = 0;
3492     pBstrDocString = 0;
3493     pdwHelpContext = 0;
3494     pBstrHelpFile = 0;
3495     RpcTryFinally
3496         {
3497         if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
3498             NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[204] );
3499
3500         memid = *( MEMBERID __RPC_FAR * )_StubMsg.Buffer;
3501         _StubMsg.Buffer += sizeof(MEMBERID);
3502
3503         refPtrFlags = *( DWORD __RPC_FAR * )_StubMsg.Buffer;
3504         _StubMsg.Buffer += sizeof(DWORD);
3505
3506         pBstrName = &_M37;
3507         MIDL_memset(
3508                pBstrName,
3509                0,
3510                sizeof( BSTR  ));
3511         pBstrDocString = &_M38;
3512         MIDL_memset(
3513                pBstrDocString,
3514                0,
3515                sizeof( BSTR  ));
3516         pdwHelpContext = &_M39;
3517         pBstrHelpFile = &_M40;
3518         MIDL_memset(
3519                pBstrHelpFile,
3520                0,
3521                sizeof( BSTR  ));
3522
3523         *_pdwStubPhase = STUB_CALL_SERVER;
3524
3525
3526         _RetVal = ITypeInfo_GetDocumentation_Stub(
3527                                           (ITypeInfo *) ((CStdStubBuffer *)This)->pvServerObject,
3528                                           memid,
3529                                           refPtrFlags,
3530                                           pBstrName,
3531                                           pBstrDocString,
3532                                           pdwHelpContext,
3533                                           pBstrHelpFile);
3534
3535         *_pdwStubPhase = STUB_MARSHAL;
3536
3537         _StubMsg.BufferLength = 8U + 15U + 11U + 11U + 11U;
3538         NdrUserMarshalBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
3539                                   (unsigned char __RPC_FAR *)pBstrName,
3540                                   (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1128] );
3541
3542         NdrUserMarshalBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
3543                                   (unsigned char __RPC_FAR *)pBstrDocString,
3544                                   (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1128] );
3545
3546         NdrUserMarshalBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
3547                                   (unsigned char __RPC_FAR *)pBstrHelpFile,
3548                                   (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1128] );
3549
3550         _StubMsg.BufferLength += 16;
3551
3552         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
3553         NdrUserMarshalMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
3554                                 (unsigned char __RPC_FAR *)pBstrName,
3555                                 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1128] );
3556
3557         NdrUserMarshalMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
3558                                 (unsigned char __RPC_FAR *)pBstrDocString,
3559                                 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1128] );
3560
3561         _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
3562         *( DWORD __RPC_FAR * )_StubMsg.Buffer = *pdwHelpContext;
3563         _StubMsg.Buffer += sizeof(DWORD);
3564
3565         NdrUserMarshalMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
3566                                 (unsigned char __RPC_FAR *)pBstrHelpFile,
3567                                 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1128] );
3568
3569         _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
3570         *( HRESULT __RPC_FAR * )_StubMsg.Buffer = _RetVal;
3571         _StubMsg.Buffer += sizeof(HRESULT);
3572
3573         }
3574     RpcFinally
3575         {
3576         NdrPointerFree( &_StubMsg,
3577                         (unsigned char __RPC_FAR *)pBstrName,
3578                         &__MIDL_TypeFormatString.Format[1708] );
3579
3580         NdrPointerFree( &_StubMsg,
3581                         (unsigned char __RPC_FAR *)pBstrDocString,
3582                         &__MIDL_TypeFormatString.Format[1708] );
3583
3584         NdrPointerFree( &_StubMsg,
3585                         (unsigned char __RPC_FAR *)pBstrHelpFile,
3586                         &__MIDL_TypeFormatString.Format[1708] );
3587
3588         }
3589     RpcEndFinally
3590     _pRpcMessage->BufferLength =
3591         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
3592
3593 }
3594
3595
3596 /* [call_as] */ HRESULT STDMETHODCALLTYPE ITypeInfo_RemoteGetDllEntry_Proxy(
3597     ITypeInfo __RPC_FAR * This,
3598     /* [in] */ MEMBERID memid,
3599     /* [in] */ INVOKEKIND invKind,
3600     /* [in] */ DWORD refPtrFlags,
3601     /* [out] */ BSTR __RPC_FAR *pBstrDllName,
3602     /* [out] */ BSTR __RPC_FAR *pBstrName,
3603     /* [out] */ WORD __RPC_FAR *pwOrdinal)
3604 {
3605
3606     HRESULT _RetVal;
3607
3608     RPC_MESSAGE _RpcMessage;
3609
3610     MIDL_STUB_MESSAGE _StubMsg;
3611
3612     if(pBstrDllName)
3613         {
3614         MIDL_memset(
3615                pBstrDllName,
3616                0,
3617                sizeof( BSTR  ));
3618         }
3619     if(pBstrName)
3620         {
3621         MIDL_memset(
3622                pBstrName,
3623                0,
3624                sizeof( BSTR  ));
3625         }
3626     RpcTryExcept
3627         {
3628         NdrProxyInitialize(
3629                       ( void __RPC_FAR *  )This,
3630                       ( PRPC_MESSAGE  )&_RpcMessage,
3631                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
3632                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
3633                       13);
3634
3635
3636
3637         if(!pBstrDllName)
3638             {
3639             RpcRaiseException(RPC_X_NULL_REF_POINTER);
3640             }
3641         if(!pBstrName)
3642             {
3643             RpcRaiseException(RPC_X_NULL_REF_POINTER);
3644             }
3645         if(!pwOrdinal)
3646             {
3647             RpcRaiseException(RPC_X_NULL_REF_POINTER);
3648             }
3649         RpcTryFinally
3650             {
3651
3652             _StubMsg.BufferLength = 4U + 4U + 4U;
3653             NdrProxyGetBuffer(This, &_StubMsg);
3654             *( MEMBERID __RPC_FAR * )_StubMsg.Buffer = memid;
3655             _StubMsg.Buffer += sizeof(MEMBERID);
3656
3657             NdrSimpleTypeMarshall(
3658                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
3659                          ( unsigned char __RPC_FAR * )&invKind,
3660                          14);
3661             *( DWORD __RPC_FAR * )_StubMsg.Buffer = refPtrFlags;
3662             _StubMsg.Buffer += sizeof(DWORD);
3663
3664             NdrProxySendReceive(This, &_StubMsg);
3665
3666             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
3667                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[226] );
3668
3669             NdrUserMarshalUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
3670                                       (unsigned char __RPC_FAR * __RPC_FAR *)&pBstrDllName,
3671                                       (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1128],
3672                                       (unsigned char)0 );
3673
3674             NdrUserMarshalUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
3675                                       (unsigned char __RPC_FAR * __RPC_FAR *)&pBstrName,
3676                                       (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1128],
3677                                       (unsigned char)0 );
3678
3679             _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 1) & ~ 0x1);
3680             *pwOrdinal = *( WORD __RPC_FAR * )_StubMsg.Buffer;
3681             _StubMsg.Buffer += sizeof(WORD);
3682
3683             _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
3684             _RetVal = *( HRESULT __RPC_FAR * )_StubMsg.Buffer;
3685             _StubMsg.Buffer += sizeof(HRESULT);
3686
3687             }
3688         RpcFinally
3689             {
3690             NdrProxyFreeBuffer(This, &_StubMsg);
3691
3692             }
3693         RpcEndFinally
3694
3695         }
3696     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
3697         {
3698         NdrClearOutParameters(
3699                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
3700                          ( PFORMAT_STRING  )&__MIDL_TypeFormatString.Format[1708],
3701                          ( void __RPC_FAR * )pBstrDllName);
3702         NdrClearOutParameters(
3703                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
3704                          ( PFORMAT_STRING  )&__MIDL_TypeFormatString.Format[1708],
3705                          ( void __RPC_FAR * )pBstrName);
3706         NdrClearOutParameters(
3707                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
3708                          ( PFORMAT_STRING  )&__MIDL_TypeFormatString.Format[1712],
3709                          ( void __RPC_FAR * )pwOrdinal);
3710         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
3711         }
3712     RpcEndExcept
3713     return _RetVal;
3714 }
3715
3716 void __RPC_STUB ITypeInfo_RemoteGetDllEntry_Stub(
3717     IRpcStubBuffer *This,
3718     IRpcChannelBuffer *_pRpcChannelBuffer,
3719     PRPC_MESSAGE _pRpcMessage,
3720     DWORD *_pdwStubPhase)
3721 {
3722     BSTR _M41;
3723     BSTR _M42;
3724     WORD _M43;
3725     HRESULT _RetVal;
3726     MIDL_STUB_MESSAGE _StubMsg;
3727     INVOKEKIND invKind;
3728     MEMBERID memid;
3729     BSTR __RPC_FAR *pBstrDllName;
3730     BSTR __RPC_FAR *pBstrName;
3731     WORD __RPC_FAR *pwOrdinal;
3732     DWORD refPtrFlags;
3733
3734 NdrStubInitialize(
3735                      _pRpcMessage,
3736                      &_StubMsg,
3737                      &Object_StubDesc,
3738                      _pRpcChannelBuffer);
3739     pBstrDllName = 0;
3740     pBstrName = 0;
3741     pwOrdinal = 0;
3742     RpcTryFinally
3743         {
3744         if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
3745             NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[226] );
3746
3747         memid = *( MEMBERID __RPC_FAR * )_StubMsg.Buffer;
3748         _StubMsg.Buffer += sizeof(MEMBERID);
3749
3750         NdrSimpleTypeUnmarshall(
3751                            ( PMIDL_STUB_MESSAGE  )&_StubMsg,
3752                            ( unsigned char __RPC_FAR * )&invKind,
3753                            14);
3754         refPtrFlags = *( DWORD __RPC_FAR * )_StubMsg.Buffer;
3755         _StubMsg.Buffer += sizeof(DWORD);
3756
3757         pBstrDllName = &_M41;
3758         MIDL_memset(
3759                pBstrDllName,
3760                0,
3761                sizeof( BSTR  ));
3762         pBstrName = &_M42;
3763         MIDL_memset(
3764                pBstrName,
3765                0,
3766                sizeof( BSTR  ));
3767         pwOrdinal = &_M43;
3768
3769         *_pdwStubPhase = STUB_CALL_SERVER;
3770
3771
3772         _RetVal = ITypeInfo_GetDllEntry_Stub(
3773                                      (ITypeInfo *) ((CStdStubBuffer *)This)->pvServerObject,
3774                                      memid,
3775                                      invKind,
3776                                      refPtrFlags,
3777                                      pBstrDllName,
3778                                      pBstrName,
3779                                      pwOrdinal);
3780
3781         *_pdwStubPhase = STUB_MARSHAL;
3782
3783         _StubMsg.BufferLength = 8U + 15U + 5U + 10U;
3784         NdrUserMarshalBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
3785                                   (unsigned char __RPC_FAR *)pBstrDllName,
3786                                   (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1128] );
3787
3788         NdrUserMarshalBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
3789                                   (unsigned char __RPC_FAR *)pBstrName,
3790                                   (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1128] );
3791
3792         _StubMsg.BufferLength += 16;
3793
3794         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
3795         NdrUserMarshalMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
3796                                 (unsigned char __RPC_FAR *)pBstrDllName,
3797                                 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1128] );
3798
3799         NdrUserMarshalMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
3800                                 (unsigned char __RPC_FAR *)pBstrName,
3801                                 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1128] );
3802
3803         _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 1) & ~ 0x1);
3804         *( WORD __RPC_FAR * )_StubMsg.Buffer = *pwOrdinal;
3805         _StubMsg.Buffer += sizeof(WORD);
3806
3807         _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
3808         *( HRESULT __RPC_FAR * )_StubMsg.Buffer = _RetVal;
3809         _StubMsg.Buffer += sizeof(HRESULT);
3810
3811         }
3812     RpcFinally
3813         {
3814         NdrPointerFree( &_StubMsg,
3815                         (unsigned char __RPC_FAR *)pBstrDllName,
3816                         &__MIDL_TypeFormatString.Format[1708] );
3817
3818         NdrPointerFree( &_StubMsg,
3819                         (unsigned char __RPC_FAR *)pBstrName,
3820                         &__MIDL_TypeFormatString.Format[1708] );
3821
3822         }
3823     RpcEndFinally
3824     _pRpcMessage->BufferLength =
3825         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
3826
3827 }
3828
3829
3830 HRESULT STDMETHODCALLTYPE ITypeInfo_GetRefTypeInfo_Proxy(
3831     ITypeInfo __RPC_FAR * This,
3832     /* [in] */ HREFTYPE hRefType,
3833     /* [out] */ ITypeInfo __RPC_FAR *__RPC_FAR *ppTInfo)
3834 {
3835
3836     HRESULT _RetVal;
3837
3838     RPC_MESSAGE _RpcMessage;
3839
3840     MIDL_STUB_MESSAGE _StubMsg;
3841
3842     if(ppTInfo)
3843         {
3844         MIDL_memset(
3845                ppTInfo,
3846                0,
3847                sizeof( ITypeInfo __RPC_FAR *__RPC_FAR * ));
3848         }
3849     RpcTryExcept
3850         {
3851         NdrProxyInitialize(
3852                       ( void __RPC_FAR *  )This,
3853                       ( PRPC_MESSAGE  )&_RpcMessage,
3854                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
3855                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
3856                       14);
3857
3858
3859
3860         if(!ppTInfo)
3861             {
3862             RpcRaiseException(RPC_X_NULL_REF_POINTER);
3863             }
3864         RpcTryFinally
3865             {
3866
3867             _StubMsg.BufferLength = 4U;
3868             NdrProxyGetBuffer(This, &_StubMsg);
3869             *( HREFTYPE __RPC_FAR * )_StubMsg.Buffer = hRefType;
3870             _StubMsg.Buffer += sizeof(HREFTYPE);
3871
3872             NdrProxySendReceive(This, &_StubMsg);
3873
3874             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
3875                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[246] );
3876
3877             NdrPointerUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
3878                                   (unsigned char __RPC_FAR * __RPC_FAR *)&ppTInfo,
3879                                   (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[6],
3880                                   (unsigned char)0 );
3881
3882             _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
3883             _RetVal = *( HRESULT __RPC_FAR * )_StubMsg.Buffer;
3884             _StubMsg.Buffer += sizeof(HRESULT);
3885
3886             }
3887         RpcFinally
3888             {
3889             NdrProxyFreeBuffer(This, &_StubMsg);
3890
3891             }
3892         RpcEndFinally
3893
3894         }
3895     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
3896         {
3897         NdrClearOutParameters(
3898                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
3899                          ( PFORMAT_STRING  )&__MIDL_TypeFormatString.Format[6],
3900                          ( void __RPC_FAR * )ppTInfo);
3901         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
3902         }
3903     RpcEndExcept
3904     return _RetVal;
3905 }
3906
3907 void __RPC_STUB ITypeInfo_GetRefTypeInfo_Stub(
3908     IRpcStubBuffer *This,
3909     IRpcChannelBuffer *_pRpcChannelBuffer,
3910     PRPC_MESSAGE _pRpcMessage,
3911     DWORD *_pdwStubPhase)
3912 {
3913     ITypeInfo __RPC_FAR *_M44;
3914     HRESULT _RetVal;
3915     MIDL_STUB_MESSAGE _StubMsg;
3916     HREFTYPE hRefType;
3917     ITypeInfo __RPC_FAR *__RPC_FAR *ppTInfo;
3918
3919 NdrStubInitialize(
3920                      _pRpcMessage,
3921                      &_StubMsg,
3922                      &Object_StubDesc,
3923                      _pRpcChannelBuffer);
3924     ppTInfo = 0;
3925     RpcTryFinally
3926         {
3927         if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
3928             NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[246] );
3929
3930         hRefType = *( HREFTYPE __RPC_FAR * )_StubMsg.Buffer;
3931         _StubMsg.Buffer += sizeof(HREFTYPE);
3932
3933         ppTInfo = &_M44;
3934         _M44 = 0;
3935
3936         *_pdwStubPhase = STUB_CALL_SERVER;
3937         _RetVal = (((ITypeInfo*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> GetRefTypeInfo(
3938                   (ITypeInfo *) ((CStdStubBuffer *)This)->pvServerObject,
3939                   hRefType,
3940                   ppTInfo);
3941
3942         *_pdwStubPhase = STUB_MARSHAL;
3943
3944         _StubMsg.BufferLength = 0U + 4U;
3945         NdrPointerBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
3946                               (unsigned char __RPC_FAR *)ppTInfo,
3947                               (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[6] );
3948
3949         _StubMsg.BufferLength += 16;
3950
3951         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
3952         NdrPointerMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
3953                             (unsigned char __RPC_FAR *)ppTInfo,
3954                             (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[6] );
3955
3956         _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
3957         *( HRESULT __RPC_FAR * )_StubMsg.Buffer = _RetVal;
3958         _StubMsg.Buffer += sizeof(HRESULT);
3959
3960         }
3961     RpcFinally
3962         {
3963         NdrPointerFree( &_StubMsg,
3964                         (unsigned char __RPC_FAR *)ppTInfo,
3965                         &__MIDL_TypeFormatString.Format[6] );
3966
3967         }
3968     RpcEndFinally
3969     _pRpcMessage->BufferLength =
3970         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
3971
3972 }
3973
3974
3975 /* [call_as] */ HRESULT STDMETHODCALLTYPE ITypeInfo_LocalAddressOfMember_Proxy(
3976     ITypeInfo __RPC_FAR * This)
3977 {
3978
3979     HRESULT _RetVal;
3980
3981     RPC_MESSAGE _RpcMessage;
3982
3983     MIDL_STUB_MESSAGE _StubMsg;
3984
3985     RpcTryExcept
3986         {
3987         NdrProxyInitialize(
3988                       ( void __RPC_FAR *  )This,
3989                       ( PRPC_MESSAGE  )&_RpcMessage,
3990                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
3991                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
3992                       15);
3993
3994
3995
3996         RpcTryFinally
3997             {
3998
3999             _StubMsg.BufferLength = 0U;
4000             NdrProxyGetBuffer(This, &_StubMsg);
4001             NdrProxySendReceive(This, &_StubMsg);
4002
4003             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
4004                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[88] );
4005
4006             _RetVal = *( HRESULT __RPC_FAR * )_StubMsg.Buffer;
4007             _StubMsg.Buffer += sizeof(HRESULT);
4008
4009             }
4010         RpcFinally
4011             {
4012             NdrProxyFreeBuffer(This, &_StubMsg);
4013
4014             }
4015         RpcEndFinally
4016
4017         }
4018     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
4019         {
4020         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
4021         }
4022     RpcEndExcept
4023     return _RetVal;
4024 }
4025
4026 void __RPC_STUB ITypeInfo_LocalAddressOfMember_Stub(
4027     IRpcStubBuffer *This,
4028     IRpcChannelBuffer *_pRpcChannelBuffer,
4029     PRPC_MESSAGE _pRpcMessage,
4030     DWORD *_pdwStubPhase)
4031 {
4032     HRESULT _RetVal;
4033     MIDL_STUB_MESSAGE _StubMsg;
4034
4035 NdrStubInitialize(
4036                      _pRpcMessage,
4037                      &_StubMsg,
4038                      &Object_StubDesc,
4039                      _pRpcChannelBuffer);
4040     RpcTryFinally
4041         {
4042
4043         *_pdwStubPhase = STUB_CALL_SERVER;
4044
4045
4046         _RetVal = ITypeInfo_AddressOfMember_Stub((ITypeInfo *) ((CStdStubBuffer *)This)->pvServerObject);
4047
4048         *_pdwStubPhase = STUB_MARSHAL;
4049
4050         _StubMsg.BufferLength = 4U;
4051         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
4052         *( HRESULT __RPC_FAR * )_StubMsg.Buffer = _RetVal;
4053         _StubMsg.Buffer += sizeof(HRESULT);
4054
4055         }
4056     RpcFinally
4057         {
4058         }
4059     RpcEndFinally
4060     _pRpcMessage->BufferLength =
4061         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
4062
4063 }
4064
4065
4066 /* [call_as] */ HRESULT STDMETHODCALLTYPE ITypeInfo_RemoteCreateInstance_Proxy(
4067     ITypeInfo __RPC_FAR * This,
4068     /* [in] */ REFIID riid,
4069     /* [iid_is][out] */ IUnknown __RPC_FAR *__RPC_FAR *ppvObj)
4070 {
4071
4072     HRESULT _RetVal;
4073
4074     RPC_MESSAGE _RpcMessage;
4075
4076     MIDL_STUB_MESSAGE _StubMsg;
4077
4078     if(ppvObj)
4079         {
4080         MIDL_memset(
4081                ppvObj,
4082                0,
4083                sizeof( IUnknown __RPC_FAR *__RPC_FAR * ));
4084         }
4085     RpcTryExcept
4086         {
4087         NdrProxyInitialize(
4088                       ( void __RPC_FAR *  )This,
4089                       ( PRPC_MESSAGE  )&_RpcMessage,
4090                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
4091                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
4092                       16);
4093
4094
4095
4096         if(!riid)
4097             {
4098             RpcRaiseException(RPC_X_NULL_REF_POINTER);
4099             }
4100         if(!ppvObj)
4101             {
4102             RpcRaiseException(RPC_X_NULL_REF_POINTER);
4103             }
4104         RpcTryFinally
4105             {
4106
4107             _StubMsg.BufferLength = 0U;
4108             NdrSimpleStructBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
4109                                        (unsigned char __RPC_FAR *)riid,
4110                                        (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[38] );
4111
4112             NdrProxyGetBuffer(This, &_StubMsg);
4113             NdrSimpleStructMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
4114                                      (unsigned char __RPC_FAR *)riid,
4115                                      (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[38] );
4116
4117             NdrProxySendReceive(This, &_StubMsg);
4118
4119             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
4120                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[254] );
4121
4122             NdrPointerUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
4123                                   (unsigned char __RPC_FAR * __RPC_FAR *)&ppvObj,
4124                                   (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1716],
4125                                   (unsigned char)0 );
4126
4127             _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
4128             _RetVal = *( HRESULT __RPC_FAR * )_StubMsg.Buffer;
4129             _StubMsg.Buffer += sizeof(HRESULT);
4130
4131             }
4132         RpcFinally
4133             {
4134             NdrProxyFreeBuffer(This, &_StubMsg);
4135
4136             }
4137         RpcEndFinally
4138
4139         }
4140     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
4141         {
4142         _StubMsg.MaxCount = (unsigned long) ( riid );
4143
4144         NdrClearOutParameters(
4145                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
4146                          ( PFORMAT_STRING  )&__MIDL_TypeFormatString.Format[1716],
4147                          ( void __RPC_FAR * )ppvObj);
4148         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
4149         }
4150     RpcEndExcept
4151     return _RetVal;
4152 }
4153
4154 void __RPC_STUB ITypeInfo_RemoteCreateInstance_Stub(
4155     IRpcStubBuffer *This,
4156     IRpcChannelBuffer *_pRpcChannelBuffer,
4157     PRPC_MESSAGE _pRpcMessage,
4158     DWORD *_pdwStubPhase)
4159 {
4160     IUnknown __RPC_FAR *__RPC_FAR *_M45;
4161     HRESULT _RetVal;
4162     MIDL_STUB_MESSAGE _StubMsg;
4163     IUnknown __RPC_FAR *__RPC_FAR *ppvObj;
4164     IID* riid = 0;
4165
4166 NdrStubInitialize(
4167                      _pRpcMessage,
4168                      &_StubMsg,
4169                      &Object_StubDesc,
4170                      _pRpcChannelBuffer);
4171     ppvObj = 0;
4172     RpcTryFinally
4173         {
4174         if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
4175             NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[254] );
4176
4177         NdrSimpleStructUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
4178                                    (unsigned char __RPC_FAR * __RPC_FAR *)&riid,
4179                                    (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[38],
4180                                    (unsigned char)0 );
4181
4182         ppvObj = (void *)&_M45;
4183         _M45 = 0;
4184
4185         *_pdwStubPhase = STUB_CALL_SERVER;
4186
4187
4188         _RetVal = ITypeInfo_CreateInstance_Stub(
4189                                         (ITypeInfo *) ((CStdStubBuffer *)This)->pvServerObject,
4190                                         riid,
4191                                         ppvObj);
4192
4193         *_pdwStubPhase = STUB_MARSHAL;
4194
4195         _StubMsg.BufferLength = 0U + 4U;
4196         _StubMsg.MaxCount = (unsigned long) ( riid );
4197
4198         NdrPointerBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
4199                               (unsigned char __RPC_FAR *)ppvObj,
4200                               (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1716] );
4201
4202         _StubMsg.BufferLength += 16;
4203
4204         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
4205         _StubMsg.MaxCount = (unsigned long) ( riid );
4206
4207         NdrPointerMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
4208                             (unsigned char __RPC_FAR *)ppvObj,
4209                             (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1716] );
4210
4211         _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
4212         *( HRESULT __RPC_FAR * )_StubMsg.Buffer = _RetVal;
4213         _StubMsg.Buffer += sizeof(HRESULT);
4214
4215         }
4216     RpcFinally
4217         {
4218         _StubMsg.MaxCount = (unsigned long) ( riid );
4219
4220         NdrPointerFree( &_StubMsg,
4221                         (unsigned char __RPC_FAR *)ppvObj,
4222                         &__MIDL_TypeFormatString.Format[1716] );
4223
4224         }
4225     RpcEndFinally
4226     _pRpcMessage->BufferLength =
4227         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
4228
4229 }
4230
4231
4232 HRESULT STDMETHODCALLTYPE ITypeInfo_GetMops_Proxy(
4233     ITypeInfo __RPC_FAR * This,
4234     /* [in] */ MEMBERID memid,
4235     /* [out] */ BSTR __RPC_FAR *pBstrMops)
4236 {
4237
4238     HRESULT _RetVal;
4239
4240     RPC_MESSAGE _RpcMessage;
4241
4242     MIDL_STUB_MESSAGE _StubMsg;
4243
4244     if(pBstrMops)
4245         {
4246         MIDL_memset(
4247                pBstrMops,
4248                0,
4249                sizeof( BSTR  ));
4250         }
4251     RpcTryExcept
4252         {
4253         NdrProxyInitialize(
4254                       ( void __RPC_FAR *  )This,
4255                       ( PRPC_MESSAGE  )&_RpcMessage,
4256                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
4257                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
4258                       17);
4259
4260
4261
4262         if(!pBstrMops)
4263             {
4264             RpcRaiseException(RPC_X_NULL_REF_POINTER);
4265             }
4266         RpcTryFinally
4267             {
4268
4269             _StubMsg.BufferLength = 4U;
4270             NdrProxyGetBuffer(This, &_StubMsg);
4271             *( MEMBERID __RPC_FAR * )_StubMsg.Buffer = memid;
4272             _StubMsg.Buffer += sizeof(MEMBERID);
4273
4274             NdrProxySendReceive(This, &_StubMsg);
4275
4276             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
4277                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[264] );
4278
4279             NdrUserMarshalUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
4280                                       (unsigned char __RPC_FAR * __RPC_FAR *)&pBstrMops,
4281                                       (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1128],
4282                                       (unsigned char)0 );
4283
4284             _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
4285             _RetVal = *( HRESULT __RPC_FAR * )_StubMsg.Buffer;
4286             _StubMsg.Buffer += sizeof(HRESULT);
4287
4288             }
4289         RpcFinally
4290             {
4291             NdrProxyFreeBuffer(This, &_StubMsg);
4292
4293             }
4294         RpcEndFinally
4295
4296         }
4297     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
4298         {
4299         NdrClearOutParameters(
4300                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
4301                          ( PFORMAT_STRING  )&__MIDL_TypeFormatString.Format[1708],
4302                          ( void __RPC_FAR * )pBstrMops);
4303         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
4304         }
4305     RpcEndExcept
4306     return _RetVal;
4307 }
4308
4309 void __RPC_STUB ITypeInfo_GetMops_Stub(
4310     IRpcStubBuffer *This,
4311     IRpcChannelBuffer *_pRpcChannelBuffer,
4312     PRPC_MESSAGE _pRpcMessage,
4313     DWORD *_pdwStubPhase)
4314 {
4315     BSTR _M46;
4316     HRESULT _RetVal;
4317     MIDL_STUB_MESSAGE _StubMsg;
4318     MEMBERID memid;
4319     BSTR __RPC_FAR *pBstrMops;
4320
4321 NdrStubInitialize(
4322                      _pRpcMessage,
4323                      &_StubMsg,
4324                      &Object_StubDesc,
4325                      _pRpcChannelBuffer);
4326     pBstrMops = 0;
4327     RpcTryFinally
4328         {
4329         if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
4330             NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[264] );
4331
4332         memid = *( MEMBERID __RPC_FAR * )_StubMsg.Buffer;
4333         _StubMsg.Buffer += sizeof(MEMBERID);
4334
4335         pBstrMops = &_M46;
4336         MIDL_memset(
4337                pBstrMops,
4338                0,
4339                sizeof( BSTR  ));
4340
4341         *_pdwStubPhase = STUB_CALL_SERVER;
4342         _RetVal = (((ITypeInfo*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> GetMops(
4343            (ITypeInfo *) ((CStdStubBuffer *)This)->pvServerObject,
4344            memid,
4345            pBstrMops);
4346
4347         *_pdwStubPhase = STUB_MARSHAL;
4348
4349         _StubMsg.BufferLength = 8U + 11U;
4350         NdrUserMarshalBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
4351                                   (unsigned char __RPC_FAR *)pBstrMops,
4352                                   (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1128] );
4353
4354         _StubMsg.BufferLength += 16;
4355
4356         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
4357         NdrUserMarshalMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
4358                                 (unsigned char __RPC_FAR *)pBstrMops,
4359                                 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1128] );
4360
4361         _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
4362         *( HRESULT __RPC_FAR * )_StubMsg.Buffer = _RetVal;
4363         _StubMsg.Buffer += sizeof(HRESULT);
4364
4365         }
4366     RpcFinally
4367         {
4368         NdrPointerFree( &_StubMsg,
4369                         (unsigned char __RPC_FAR *)pBstrMops,
4370                         &__MIDL_TypeFormatString.Format[1708] );
4371
4372         }
4373     RpcEndFinally
4374     _pRpcMessage->BufferLength =
4375         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
4376
4377 }
4378
4379
4380 /* [call_as] */ HRESULT STDMETHODCALLTYPE ITypeInfo_RemoteGetContainingTypeLib_Proxy(
4381     ITypeInfo __RPC_FAR * This,
4382     /* [out] */ ITypeLib __RPC_FAR *__RPC_FAR *ppTLib,
4383     /* [out] */ UINT __RPC_FAR *pIndex)
4384 {
4385
4386     HRESULT _RetVal;
4387
4388     RPC_MESSAGE _RpcMessage;
4389
4390     MIDL_STUB_MESSAGE _StubMsg;
4391
4392     if(ppTLib)
4393         {
4394         MIDL_memset(
4395                ppTLib,
4396                0,
4397                sizeof( ITypeLib __RPC_FAR *__RPC_FAR * ));
4398         }
4399     RpcTryExcept
4400         {
4401         NdrProxyInitialize(
4402                       ( void __RPC_FAR *  )This,
4403                       ( PRPC_MESSAGE  )&_RpcMessage,
4404                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
4405                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
4406                       18);
4407
4408
4409
4410         if(!ppTLib)
4411             {
4412             RpcRaiseException(RPC_X_NULL_REF_POINTER);
4413             }
4414         if(!pIndex)
4415             {
4416             RpcRaiseException(RPC_X_NULL_REF_POINTER);
4417             }
4418         RpcTryFinally
4419             {
4420
4421             _StubMsg.BufferLength = 0U;
4422             NdrProxyGetBuffer(This, &_StubMsg);
4423             NdrProxySendReceive(This, &_StubMsg);
4424
4425             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
4426                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[272] );
4427
4428             NdrPointerUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
4429                                   (unsigned char __RPC_FAR * __RPC_FAR *)&ppTLib,
4430                                   (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1726],
4431                                   (unsigned char)0 );
4432
4433             _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
4434             *pIndex = *( UINT __RPC_FAR * )_StubMsg.Buffer;
4435             _StubMsg.Buffer += sizeof(UINT);
4436
4437             _RetVal = *( HRESULT __RPC_FAR * )_StubMsg.Buffer;
4438             _StubMsg.Buffer += sizeof(HRESULT);
4439
4440             }
4441         RpcFinally
4442             {
4443             NdrProxyFreeBuffer(This, &_StubMsg);
4444
4445             }
4446         RpcEndFinally
4447
4448         }
4449     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
4450         {
4451         NdrClearOutParameters(
4452                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
4453                          ( PFORMAT_STRING  )&__MIDL_TypeFormatString.Format[1726],
4454                          ( void __RPC_FAR * )ppTLib);
4455         NdrClearOutParameters(
4456                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
4457                          ( PFORMAT_STRING  )&__MIDL_TypeFormatString.Format[2],
4458                          ( void __RPC_FAR * )pIndex);
4459         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
4460         }
4461     RpcEndExcept
4462     return _RetVal;
4463 }
4464
4465 void __RPC_STUB ITypeInfo_RemoteGetContainingTypeLib_Stub(
4466     IRpcStubBuffer *This,
4467     IRpcChannelBuffer *_pRpcChannelBuffer,
4468     PRPC_MESSAGE _pRpcMessage,
4469     DWORD *_pdwStubPhase)
4470 {
4471     ITypeLib __RPC_FAR *_M47;
4472     UINT _M48;
4473     HRESULT _RetVal;
4474     MIDL_STUB_MESSAGE _StubMsg;
4475     UINT __RPC_FAR *pIndex;
4476     ITypeLib __RPC_FAR *__RPC_FAR *ppTLib;
4477
4478 NdrStubInitialize(
4479                      _pRpcMessage,
4480                      &_StubMsg,
4481                      &Object_StubDesc,
4482                      _pRpcChannelBuffer);
4483     ppTLib = 0;
4484     pIndex = 0;
4485     RpcTryFinally
4486         {
4487         ppTLib = &_M47;
4488         _M47 = 0;
4489         pIndex = &_M48;
4490
4491         *_pdwStubPhase = STUB_CALL_SERVER;
4492
4493
4494         _RetVal = ITypeInfo_GetContainingTypeLib_Stub(
4495                                               (ITypeInfo *) ((CStdStubBuffer *)This)->pvServerObject,
4496                                               ppTLib,
4497                                               pIndex);
4498
4499         *_pdwStubPhase = STUB_MARSHAL;
4500
4501         _StubMsg.BufferLength = 0U + 4U + 4U;
4502         NdrPointerBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
4503                               (unsigned char __RPC_FAR *)ppTLib,
4504                               (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1726] );
4505
4506         _StubMsg.BufferLength += 16;
4507
4508         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
4509         NdrPointerMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
4510                             (unsigned char __RPC_FAR *)ppTLib,
4511                             (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1726] );
4512
4513         _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
4514         *( UINT __RPC_FAR * )_StubMsg.Buffer = *pIndex;
4515         _StubMsg.Buffer += sizeof(UINT);
4516
4517         *( HRESULT __RPC_FAR * )_StubMsg.Buffer = _RetVal;
4518         _StubMsg.Buffer += sizeof(HRESULT);
4519
4520         }
4521     RpcFinally
4522         {
4523         NdrPointerFree( &_StubMsg,
4524                         (unsigned char __RPC_FAR *)ppTLib,
4525                         &__MIDL_TypeFormatString.Format[1726] );
4526
4527         }
4528     RpcEndFinally
4529     _pRpcMessage->BufferLength =
4530         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
4531
4532 }
4533
4534
4535 /* [call_as] */ HRESULT STDMETHODCALLTYPE ITypeInfo_LocalReleaseTypeAttr_Proxy(
4536     ITypeInfo __RPC_FAR * This)
4537 {
4538
4539     HRESULT _RetVal;
4540
4541     RPC_MESSAGE _RpcMessage;
4542
4543     MIDL_STUB_MESSAGE _StubMsg;
4544
4545     RpcTryExcept
4546         {
4547         NdrProxyInitialize(
4548                       ( void __RPC_FAR *  )This,
4549                       ( PRPC_MESSAGE  )&_RpcMessage,
4550                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
4551                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
4552                       19);
4553
4554
4555
4556         RpcTryFinally
4557             {
4558
4559             _StubMsg.BufferLength = 0U;
4560             NdrProxyGetBuffer(This, &_StubMsg);
4561             NdrProxySendReceive(This, &_StubMsg);
4562
4563             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
4564                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[88] );
4565
4566             _RetVal = *( HRESULT __RPC_FAR * )_StubMsg.Buffer;
4567             _StubMsg.Buffer += sizeof(HRESULT);
4568
4569             }
4570         RpcFinally
4571             {
4572             NdrProxyFreeBuffer(This, &_StubMsg);
4573
4574             }
4575         RpcEndFinally
4576
4577         }
4578     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
4579         {
4580         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
4581         }
4582     RpcEndExcept
4583     return _RetVal;
4584 }
4585
4586 void __RPC_STUB ITypeInfo_LocalReleaseTypeAttr_Stub(
4587     IRpcStubBuffer *This,
4588     IRpcChannelBuffer *_pRpcChannelBuffer,
4589     PRPC_MESSAGE _pRpcMessage,
4590     DWORD *_pdwStubPhase)
4591 {
4592     HRESULT _RetVal;
4593     MIDL_STUB_MESSAGE _StubMsg;
4594
4595 NdrStubInitialize(
4596                      _pRpcMessage,
4597                      &_StubMsg,
4598                      &Object_StubDesc,
4599                      _pRpcChannelBuffer);
4600     RpcTryFinally
4601         {
4602
4603         *_pdwStubPhase = STUB_CALL_SERVER;
4604
4605
4606         _RetVal = ITypeInfo_ReleaseTypeAttr_Stub((ITypeInfo *) ((CStdStubBuffer *)This)->pvServerObject);
4607
4608         *_pdwStubPhase = STUB_MARSHAL;
4609
4610         _StubMsg.BufferLength = 4U;
4611         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
4612         *( HRESULT __RPC_FAR * )_StubMsg.Buffer = _RetVal;
4613         _StubMsg.Buffer += sizeof(HRESULT);
4614
4615         }
4616     RpcFinally
4617         {
4618         }
4619     RpcEndFinally
4620     _pRpcMessage->BufferLength =
4621         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
4622
4623 }
4624
4625
4626 /* [call_as] */ HRESULT STDMETHODCALLTYPE ITypeInfo_LocalReleaseFuncDesc_Proxy(
4627     ITypeInfo __RPC_FAR * This)
4628 {
4629
4630     HRESULT _RetVal;
4631
4632     RPC_MESSAGE _RpcMessage;
4633
4634     MIDL_STUB_MESSAGE _StubMsg;
4635
4636     RpcTryExcept
4637         {
4638         NdrProxyInitialize(
4639                       ( void __RPC_FAR *  )This,
4640                       ( PRPC_MESSAGE  )&_RpcMessage,
4641                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
4642                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
4643                       20);
4644
4645
4646
4647         RpcTryFinally
4648             {
4649
4650             _StubMsg.BufferLength = 0U;
4651             NdrProxyGetBuffer(This, &_StubMsg);
4652             NdrProxySendReceive(This, &_StubMsg);
4653
4654             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
4655                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[88] );
4656
4657             _RetVal = *( HRESULT __RPC_FAR * )_StubMsg.Buffer;
4658             _StubMsg.Buffer += sizeof(HRESULT);
4659
4660             }
4661         RpcFinally
4662             {
4663             NdrProxyFreeBuffer(This, &_StubMsg);
4664
4665             }
4666         RpcEndFinally
4667
4668         }
4669     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
4670         {
4671         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
4672         }
4673     RpcEndExcept
4674     return _RetVal;
4675 }
4676
4677 void __RPC_STUB ITypeInfo_LocalReleaseFuncDesc_Stub(
4678     IRpcStubBuffer *This,
4679     IRpcChannelBuffer *_pRpcChannelBuffer,
4680     PRPC_MESSAGE _pRpcMessage,
4681     DWORD *_pdwStubPhase)
4682 {
4683     HRESULT _RetVal;
4684     MIDL_STUB_MESSAGE _StubMsg;
4685
4686 NdrStubInitialize(
4687                      _pRpcMessage,
4688                      &_StubMsg,
4689                      &Object_StubDesc,
4690                      _pRpcChannelBuffer);
4691     RpcTryFinally
4692         {
4693
4694         *_pdwStubPhase = STUB_CALL_SERVER;
4695
4696
4697         _RetVal = ITypeInfo_ReleaseFuncDesc_Stub((ITypeInfo *) ((CStdStubBuffer *)This)->pvServerObject);
4698
4699         *_pdwStubPhase = STUB_MARSHAL;
4700
4701         _StubMsg.BufferLength = 4U;
4702         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
4703         *( HRESULT __RPC_FAR * )_StubMsg.Buffer = _RetVal;
4704         _StubMsg.Buffer += sizeof(HRESULT);
4705
4706         }
4707     RpcFinally
4708         {
4709         }
4710     RpcEndFinally
4711     _pRpcMessage->BufferLength =
4712         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
4713
4714 }
4715
4716
4717 /* [call_as] */ HRESULT STDMETHODCALLTYPE ITypeInfo_LocalReleaseVarDesc_Proxy(
4718     ITypeInfo __RPC_FAR * This)
4719 {
4720
4721     HRESULT _RetVal;
4722
4723     RPC_MESSAGE _RpcMessage;
4724
4725     MIDL_STUB_MESSAGE _StubMsg;
4726
4727     RpcTryExcept
4728         {
4729         NdrProxyInitialize(
4730                       ( void __RPC_FAR *  )This,
4731                       ( PRPC_MESSAGE  )&_RpcMessage,
4732                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
4733                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
4734                       21);
4735
4736
4737
4738         RpcTryFinally
4739             {
4740
4741             _StubMsg.BufferLength = 0U;
4742             NdrProxyGetBuffer(This, &_StubMsg);
4743             NdrProxySendReceive(This, &_StubMsg);
4744
4745             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
4746                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[88] );
4747
4748             _RetVal = *( HRESULT __RPC_FAR * )_StubMsg.Buffer;
4749             _StubMsg.Buffer += sizeof(HRESULT);
4750
4751             }
4752         RpcFinally
4753             {
4754             NdrProxyFreeBuffer(This, &_StubMsg);
4755
4756             }
4757         RpcEndFinally
4758
4759         }
4760     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
4761         {
4762         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
4763         }
4764     RpcEndExcept
4765     return _RetVal;
4766 }
4767
4768 void __RPC_STUB ITypeInfo_LocalReleaseVarDesc_Stub(
4769     IRpcStubBuffer *This,
4770     IRpcChannelBuffer *_pRpcChannelBuffer,
4771     PRPC_MESSAGE _pRpcMessage,
4772     DWORD *_pdwStubPhase)
4773 {
4774     HRESULT _RetVal;
4775     MIDL_STUB_MESSAGE _StubMsg;
4776
4777 NdrStubInitialize(
4778                      _pRpcMessage,
4779                      &_StubMsg,
4780                      &Object_StubDesc,
4781                      _pRpcChannelBuffer);
4782     RpcTryFinally
4783         {
4784
4785         *_pdwStubPhase = STUB_CALL_SERVER;
4786
4787
4788         _RetVal = ITypeInfo_ReleaseVarDesc_Stub((ITypeInfo *) ((CStdStubBuffer *)This)->pvServerObject);
4789
4790         *_pdwStubPhase = STUB_MARSHAL;
4791
4792         _StubMsg.BufferLength = 4U;
4793         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
4794         *( HRESULT __RPC_FAR * )_StubMsg.Buffer = _RetVal;
4795         _StubMsg.Buffer += sizeof(HRESULT);
4796
4797         }
4798     RpcFinally
4799         {
4800         }
4801     RpcEndFinally
4802     _pRpcMessage->BufferLength =
4803         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
4804
4805 }
4806
4807 static const CINTERFACE_PROXY_VTABLE(22) _ITypeInfoProxyVtbl =
4808 {
4809     { &IID_ITypeInfo },
4810     {
4811         IUnknown_QueryInterface_Proxy,
4812         IUnknown_AddRef_Proxy,
4813         IUnknown_Release_Proxy ,
4814         ITypeInfo_GetTypeAttr_Proxy ,
4815         ITypeInfo_GetTypeComp_Proxy ,
4816         ITypeInfo_GetFuncDesc_Proxy ,
4817         ITypeInfo_GetVarDesc_Proxy ,
4818         ITypeInfo_GetNames_Proxy ,
4819         ITypeInfo_GetRefTypeOfImplType_Proxy ,
4820         ITypeInfo_GetImplTypeFlags_Proxy ,
4821         ITypeInfo_GetIDsOfNames_Proxy ,
4822         ITypeInfo_Invoke_Proxy ,
4823         ITypeInfo_GetDocumentation_Proxy ,
4824         ITypeInfo_GetDllEntry_Proxy ,
4825         ITypeInfo_GetRefTypeInfo_Proxy ,
4826         ITypeInfo_AddressOfMember_Proxy ,
4827         ITypeInfo_CreateInstance_Proxy ,
4828         ITypeInfo_GetMops_Proxy ,
4829         ITypeInfo_GetContainingTypeLib_Proxy ,
4830         ITypeInfo_ReleaseTypeAttr_Proxy ,
4831         ITypeInfo_ReleaseFuncDesc_Proxy ,
4832         ITypeInfo_ReleaseVarDesc_Proxy
4833     }
4834 };
4835
4836
4837 static const PRPC_STUB_FUNCTION ITypeInfo_table[] =
4838 {
4839     ITypeInfo_RemoteGetTypeAttr_Stub,
4840     ITypeInfo_GetTypeComp_Stub,
4841     ITypeInfo_RemoteGetFuncDesc_Stub,
4842     ITypeInfo_RemoteGetVarDesc_Stub,
4843     ITypeInfo_RemoteGetNames_Stub,
4844     ITypeInfo_GetRefTypeOfImplType_Stub,
4845     ITypeInfo_GetImplTypeFlags_Stub,
4846     ITypeInfo_LocalGetIDsOfNames_Stub,
4847     ITypeInfo_LocalInvoke_Stub,
4848     ITypeInfo_RemoteGetDocumentation_Stub,
4849     ITypeInfo_RemoteGetDllEntry_Stub,
4850     ITypeInfo_GetRefTypeInfo_Stub,
4851     ITypeInfo_LocalAddressOfMember_Stub,
4852     ITypeInfo_RemoteCreateInstance_Stub,
4853     ITypeInfo_GetMops_Stub,
4854     ITypeInfo_RemoteGetContainingTypeLib_Stub,
4855     ITypeInfo_LocalReleaseTypeAttr_Stub,
4856     ITypeInfo_LocalReleaseFuncDesc_Stub,
4857     ITypeInfo_LocalReleaseVarDesc_Stub
4858 };
4859
4860 static const CInterfaceStubVtbl _ITypeInfoStubVtbl =
4861 {
4862     {
4863         &IID_ITypeInfo,
4864         0,
4865         22,
4866         &ITypeInfo_table[-3]
4867     },
4868     { CStdStubBuffer_METHODS }
4869 };
4870
4871
4872 /* Object interface: ITypeInfo2, ver. 0.0,
4873    GUID={0x00020412,0x0000,0x0000,{0xC0,0x00,0x00,0x00,0x00,0x00,0x00,0x46}} */
4874
4875
4876 extern const MIDL_STUB_DESC Object_StubDesc;
4877
4878
4879 HRESULT STDMETHODCALLTYPE ITypeInfo2_GetTypeKind_Proxy(
4880     ITypeInfo2 __RPC_FAR * This,
4881     /* [out] */ TYPEKIND __RPC_FAR *pTypeKind)
4882 {
4883
4884     HRESULT _RetVal;
4885
4886     RPC_MESSAGE _RpcMessage;
4887
4888     MIDL_STUB_MESSAGE _StubMsg;
4889
4890     RpcTryExcept
4891         {
4892         NdrProxyInitialize(
4893                       ( void __RPC_FAR *  )This,
4894                       ( PRPC_MESSAGE  )&_RpcMessage,
4895                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
4896                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
4897                       22);
4898
4899
4900
4901         if(!pTypeKind)
4902             {
4903             RpcRaiseException(RPC_X_NULL_REF_POINTER);
4904             }
4905         RpcTryFinally
4906             {
4907
4908             _StubMsg.BufferLength = 0U;
4909             NdrProxyGetBuffer(This, &_StubMsg);
4910             NdrProxySendReceive(This, &_StubMsg);
4911
4912             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
4913                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[282] );
4914
4915             NdrPointerUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
4916                                   (unsigned char __RPC_FAR * __RPC_FAR *)&pTypeKind,
4917                                   (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1250],
4918                                   (unsigned char)0 );
4919
4920             _RetVal = *( HRESULT __RPC_FAR * )_StubMsg.Buffer;
4921             _StubMsg.Buffer += sizeof(HRESULT);
4922
4923             }
4924         RpcFinally
4925             {
4926             NdrProxyFreeBuffer(This, &_StubMsg);
4927
4928             }
4929         RpcEndFinally
4930
4931         }
4932     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
4933         {
4934         NdrClearOutParameters(
4935                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
4936                          ( PFORMAT_STRING  )&__MIDL_TypeFormatString.Format[1250],
4937                          ( void __RPC_FAR * )pTypeKind);
4938         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
4939         }
4940     RpcEndExcept
4941     return _RetVal;
4942 }
4943
4944 void __RPC_STUB ITypeInfo2_GetTypeKind_Stub(
4945     IRpcStubBuffer *This,
4946     IRpcChannelBuffer *_pRpcChannelBuffer,
4947     PRPC_MESSAGE _pRpcMessage,
4948     DWORD *_pdwStubPhase)
4949 {
4950     TYPEKIND _M49;
4951     HRESULT _RetVal;
4952     MIDL_STUB_MESSAGE _StubMsg;
4953     TYPEKIND __RPC_FAR *pTypeKind;
4954
4955 NdrStubInitialize(
4956                      _pRpcMessage,
4957                      &_StubMsg,
4958                      &Object_StubDesc,
4959                      _pRpcChannelBuffer);
4960     pTypeKind = 0;
4961     RpcTryFinally
4962         {
4963         pTypeKind = &_M49;
4964
4965         *_pdwStubPhase = STUB_CALL_SERVER;
4966         _RetVal = (((ITypeInfo2*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> GetTypeKind((ITypeInfo2 *) ((CStdStubBuffer *)This)->pvServerObject,pTypeKind);
4967
4968         *_pdwStubPhase = STUB_MARSHAL;
4969
4970         _StubMsg.BufferLength = 4U + 4U;
4971         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
4972         NdrPointerMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
4973                             (unsigned char __RPC_FAR *)pTypeKind,
4974                             (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1250] );
4975
4976         *( HRESULT __RPC_FAR * )_StubMsg.Buffer = _RetVal;
4977         _StubMsg.Buffer += sizeof(HRESULT);
4978
4979         }
4980     RpcFinally
4981         {
4982         }
4983     RpcEndFinally
4984     _pRpcMessage->BufferLength =
4985         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
4986
4987 }
4988
4989
4990 HRESULT STDMETHODCALLTYPE ITypeInfo2_GetTypeFlags_Proxy(
4991     ITypeInfo2 __RPC_FAR * This,
4992     /* [out] */ ULONG __RPC_FAR *pTypeFlags)
4993 {
4994
4995     HRESULT _RetVal;
4996
4997     RPC_MESSAGE _RpcMessage;
4998
4999     MIDL_STUB_MESSAGE _StubMsg;
5000
5001     RpcTryExcept
5002         {
5003         NdrProxyInitialize(
5004                       ( void __RPC_FAR *  )This,
5005                       ( PRPC_MESSAGE  )&_RpcMessage,
5006                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
5007                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
5008                       23);
5009
5010
5011
5012         if(!pTypeFlags)
5013             {
5014             RpcRaiseException(RPC_X_NULL_REF_POINTER);
5015             }
5016         RpcTryFinally
5017             {
5018
5019             _StubMsg.BufferLength = 0U;
5020             NdrProxyGetBuffer(This, &_StubMsg);
5021             NdrProxySendReceive(This, &_StubMsg);
5022
5023             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
5024                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[0] );
5025
5026             *pTypeFlags = *( ULONG __RPC_FAR * )_StubMsg.Buffer;
5027             _StubMsg.Buffer += sizeof(ULONG);
5028
5029             _RetVal = *( HRESULT __RPC_FAR * )_StubMsg.Buffer;
5030             _StubMsg.Buffer += sizeof(HRESULT);
5031
5032             }
5033         RpcFinally
5034             {
5035             NdrProxyFreeBuffer(This, &_StubMsg);
5036
5037             }
5038         RpcEndFinally
5039
5040         }
5041     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
5042         {
5043         NdrClearOutParameters(
5044                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
5045                          ( PFORMAT_STRING  )&__MIDL_TypeFormatString.Format[2],
5046                          ( void __RPC_FAR * )pTypeFlags);
5047         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
5048         }
5049     RpcEndExcept
5050     return _RetVal;
5051 }
5052
5053 void __RPC_STUB ITypeInfo2_GetTypeFlags_Stub(
5054     IRpcStubBuffer *This,
5055     IRpcChannelBuffer *_pRpcChannelBuffer,
5056     PRPC_MESSAGE _pRpcMessage,
5057     DWORD *_pdwStubPhase)
5058 {
5059     ULONG _M50;
5060     HRESULT _RetVal;
5061     MIDL_STUB_MESSAGE _StubMsg;
5062     ULONG __RPC_FAR *pTypeFlags;
5063
5064 NdrStubInitialize(
5065                      _pRpcMessage,
5066                      &_StubMsg,
5067                      &Object_StubDesc,
5068                      _pRpcChannelBuffer);
5069     pTypeFlags = 0;
5070     RpcTryFinally
5071         {
5072         pTypeFlags = &_M50;
5073
5074         *_pdwStubPhase = STUB_CALL_SERVER;
5075         _RetVal = (((ITypeInfo2*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> GetTypeFlags((ITypeInfo2 *) ((CStdStubBuffer *)This)->pvServerObject,pTypeFlags);
5076
5077         *_pdwStubPhase = STUB_MARSHAL;
5078
5079         _StubMsg.BufferLength = 4U + 4U;
5080         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
5081         *( ULONG __RPC_FAR * )_StubMsg.Buffer = *pTypeFlags;
5082         _StubMsg.Buffer += sizeof(ULONG);
5083
5084         *( HRESULT __RPC_FAR * )_StubMsg.Buffer = _RetVal;
5085         _StubMsg.Buffer += sizeof(HRESULT);
5086
5087         }
5088     RpcFinally
5089         {
5090         }
5091     RpcEndFinally
5092     _pRpcMessage->BufferLength =
5093         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
5094
5095 }
5096
5097
5098 HRESULT STDMETHODCALLTYPE ITypeInfo2_GetFuncIndexOfMemId_Proxy(
5099     ITypeInfo2 __RPC_FAR * This,
5100     /* [in] */ MEMBERID memid,
5101     /* [in] */ INVOKEKIND invKind,
5102     /* [out] */ UINT __RPC_FAR *pFuncIndex)
5103 {
5104
5105     HRESULT _RetVal;
5106
5107     RPC_MESSAGE _RpcMessage;
5108
5109     MIDL_STUB_MESSAGE _StubMsg;
5110
5111     RpcTryExcept
5112         {
5113         NdrProxyInitialize(
5114                       ( void __RPC_FAR *  )This,
5115                       ( PRPC_MESSAGE  )&_RpcMessage,
5116                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
5117                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
5118                       24);
5119
5120
5121
5122         if(!pFuncIndex)
5123             {
5124             RpcRaiseException(RPC_X_NULL_REF_POINTER);
5125             }
5126         RpcTryFinally
5127             {
5128
5129             _StubMsg.BufferLength = 4U + 4U;
5130             NdrProxyGetBuffer(This, &_StubMsg);
5131             *( MEMBERID __RPC_FAR * )_StubMsg.Buffer = memid;
5132             _StubMsg.Buffer += sizeof(MEMBERID);
5133
5134             NdrSimpleTypeMarshall(
5135                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
5136                          ( unsigned char __RPC_FAR * )&invKind,
5137                          14);
5138             NdrProxySendReceive(This, &_StubMsg);
5139
5140             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
5141                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[288] );
5142
5143             *pFuncIndex = *( UINT __RPC_FAR * )_StubMsg.Buffer;
5144             _StubMsg.Buffer += sizeof(UINT);
5145
5146             _RetVal = *( HRESULT __RPC_FAR * )_StubMsg.Buffer;
5147             _StubMsg.Buffer += sizeof(HRESULT);
5148
5149             }
5150         RpcFinally
5151             {
5152             NdrProxyFreeBuffer(This, &_StubMsg);
5153
5154             }
5155         RpcEndFinally
5156
5157         }
5158     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
5159         {
5160         NdrClearOutParameters(
5161                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
5162                          ( PFORMAT_STRING  )&__MIDL_TypeFormatString.Format[2],
5163                          ( void __RPC_FAR * )pFuncIndex);
5164         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
5165         }
5166     RpcEndExcept
5167     return _RetVal;
5168 }
5169
5170 void __RPC_STUB ITypeInfo2_GetFuncIndexOfMemId_Stub(
5171     IRpcStubBuffer *This,
5172     IRpcChannelBuffer *_pRpcChannelBuffer,
5173     PRPC_MESSAGE _pRpcMessage,
5174     DWORD *_pdwStubPhase)
5175 {
5176     UINT _M51;
5177     HRESULT _RetVal;
5178     MIDL_STUB_MESSAGE _StubMsg;
5179     INVOKEKIND invKind;
5180     MEMBERID memid;
5181     UINT __RPC_FAR *pFuncIndex;
5182
5183 NdrStubInitialize(
5184                      _pRpcMessage,
5185                      &_StubMsg,
5186                      &Object_StubDesc,
5187                      _pRpcChannelBuffer);
5188     pFuncIndex = 0;
5189     RpcTryFinally
5190         {
5191         if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
5192             NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[288] );
5193
5194         memid = *( MEMBERID __RPC_FAR * )_StubMsg.Buffer;
5195         _StubMsg.Buffer += sizeof(MEMBERID);
5196
5197         NdrSimpleTypeUnmarshall(
5198                            ( PMIDL_STUB_MESSAGE  )&_StubMsg,
5199                            ( unsigned char __RPC_FAR * )&invKind,
5200                            14);
5201         pFuncIndex = &_M51;
5202
5203         *_pdwStubPhase = STUB_CALL_SERVER;
5204         _RetVal = (((ITypeInfo2*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> GetFuncIndexOfMemId(
5205                        (ITypeInfo2 *) ((CStdStubBuffer *)This)->pvServerObject,
5206                        memid,
5207                        invKind,
5208                        pFuncIndex);
5209
5210         *_pdwStubPhase = STUB_MARSHAL;
5211
5212         _StubMsg.BufferLength = 4U + 4U;
5213         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
5214         *( UINT __RPC_FAR * )_StubMsg.Buffer = *pFuncIndex;
5215         _StubMsg.Buffer += sizeof(UINT);
5216
5217         *( HRESULT __RPC_FAR * )_StubMsg.Buffer = _RetVal;
5218         _StubMsg.Buffer += sizeof(HRESULT);
5219
5220         }
5221     RpcFinally
5222         {
5223         }
5224     RpcEndFinally
5225     _pRpcMessage->BufferLength =
5226         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
5227
5228 }
5229
5230
5231 HRESULT STDMETHODCALLTYPE ITypeInfo2_GetVarIndexOfMemId_Proxy(
5232     ITypeInfo2 __RPC_FAR * This,
5233     /* [in] */ MEMBERID memid,
5234     /* [out] */ UINT __RPC_FAR *pVarIndex)
5235 {
5236
5237     HRESULT _RetVal;
5238
5239     RPC_MESSAGE _RpcMessage;
5240
5241     MIDL_STUB_MESSAGE _StubMsg;
5242
5243     RpcTryExcept
5244         {
5245         NdrProxyInitialize(
5246                       ( void __RPC_FAR *  )This,
5247                       ( PRPC_MESSAGE  )&_RpcMessage,
5248                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
5249                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
5250                       25);
5251
5252
5253
5254         if(!pVarIndex)
5255             {
5256             RpcRaiseException(RPC_X_NULL_REF_POINTER);
5257             }
5258         RpcTryFinally
5259             {
5260
5261             _StubMsg.BufferLength = 4U;
5262             NdrProxyGetBuffer(This, &_StubMsg);
5263             *( MEMBERID __RPC_FAR * )_StubMsg.Buffer = memid;
5264             _StubMsg.Buffer += sizeof(MEMBERID);
5265
5266             NdrProxySendReceive(This, &_StubMsg);
5267
5268             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
5269                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[196] );
5270
5271             *pVarIndex = *( UINT __RPC_FAR * )_StubMsg.Buffer;
5272             _StubMsg.Buffer += sizeof(UINT);
5273
5274             _RetVal = *( HRESULT __RPC_FAR * )_StubMsg.Buffer;
5275             _StubMsg.Buffer += sizeof(HRESULT);
5276
5277             }
5278         RpcFinally
5279             {
5280             NdrProxyFreeBuffer(This, &_StubMsg);
5281
5282             }
5283         RpcEndFinally
5284
5285         }
5286     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
5287         {
5288         NdrClearOutParameters(
5289                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
5290                          ( PFORMAT_STRING  )&__MIDL_TypeFormatString.Format[2],
5291                          ( void __RPC_FAR * )pVarIndex);
5292         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
5293         }
5294     RpcEndExcept
5295     return _RetVal;
5296 }
5297
5298 void __RPC_STUB ITypeInfo2_GetVarIndexOfMemId_Stub(
5299     IRpcStubBuffer *This,
5300     IRpcChannelBuffer *_pRpcChannelBuffer,
5301     PRPC_MESSAGE _pRpcMessage,
5302     DWORD *_pdwStubPhase)
5303 {
5304     UINT _M52;
5305     HRESULT _RetVal;
5306     MIDL_STUB_MESSAGE _StubMsg;
5307     MEMBERID memid;
5308     UINT __RPC_FAR *pVarIndex;
5309
5310 NdrStubInitialize(
5311                      _pRpcMessage,
5312                      &_StubMsg,
5313                      &Object_StubDesc,
5314                      _pRpcChannelBuffer);
5315     pVarIndex = 0;
5316     RpcTryFinally
5317         {
5318         if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
5319             NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[196] );
5320
5321         memid = *( MEMBERID __RPC_FAR * )_StubMsg.Buffer;
5322         _StubMsg.Buffer += sizeof(MEMBERID);
5323
5324         pVarIndex = &_M52;
5325
5326         *_pdwStubPhase = STUB_CALL_SERVER;
5327         _RetVal = (((ITypeInfo2*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> GetVarIndexOfMemId(
5328                       (ITypeInfo2 *) ((CStdStubBuffer *)This)->pvServerObject,
5329                       memid,
5330                       pVarIndex);
5331
5332         *_pdwStubPhase = STUB_MARSHAL;
5333
5334         _StubMsg.BufferLength = 4U + 4U;
5335         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
5336         *( UINT __RPC_FAR * )_StubMsg.Buffer = *pVarIndex;
5337         _StubMsg.Buffer += sizeof(UINT);
5338
5339         *( HRESULT __RPC_FAR * )_StubMsg.Buffer = _RetVal;
5340         _StubMsg.Buffer += sizeof(HRESULT);
5341
5342         }
5343     RpcFinally
5344         {
5345         }
5346     RpcEndFinally
5347     _pRpcMessage->BufferLength =
5348         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
5349
5350 }
5351
5352
5353 HRESULT STDMETHODCALLTYPE ITypeInfo2_GetCustData_Proxy(
5354     ITypeInfo2 __RPC_FAR * This,
5355     /* [in] */ REFGUID guid,
5356     /* [out] */ VARIANT __RPC_FAR *pVarVal)
5357 {
5358
5359     HRESULT _RetVal;
5360
5361     RPC_MESSAGE _RpcMessage;
5362
5363     MIDL_STUB_MESSAGE _StubMsg;
5364
5365     if(pVarVal)
5366         {
5367         MIDL_memset(
5368                pVarVal,
5369                0,
5370                sizeof( VARIANT  ));
5371         }
5372     RpcTryExcept
5373         {
5374         NdrProxyInitialize(
5375                       ( void __RPC_FAR *  )This,
5376                       ( PRPC_MESSAGE  )&_RpcMessage,
5377                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
5378                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
5379                       26);
5380
5381
5382
5383         if(!guid)
5384             {
5385             RpcRaiseException(RPC_X_NULL_REF_POINTER);
5386             }
5387         if(!pVarVal)
5388             {
5389             RpcRaiseException(RPC_X_NULL_REF_POINTER);
5390             }
5391         RpcTryFinally
5392             {
5393
5394             _StubMsg.BufferLength = 0U;
5395             NdrSimpleStructBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
5396                                        (unsigned char __RPC_FAR *)guid,
5397                                        (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[38] );
5398
5399             NdrProxyGetBuffer(This, &_StubMsg);
5400             NdrSimpleStructMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
5401                                      (unsigned char __RPC_FAR *)guid,
5402                                      (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[38] );
5403
5404             NdrProxySendReceive(This, &_StubMsg);
5405
5406             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
5407                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[298] );
5408
5409             NdrUserMarshalUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
5410                                       (unsigned char __RPC_FAR * __RPC_FAR *)&pVarVal,
5411                                       (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1110],
5412                                       (unsigned char)0 );
5413
5414             _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
5415             _RetVal = *( HRESULT __RPC_FAR * )_StubMsg.Buffer;
5416             _StubMsg.Buffer += sizeof(HRESULT);
5417
5418             }
5419         RpcFinally
5420             {
5421             NdrProxyFreeBuffer(This, &_StubMsg);
5422
5423             }
5424         RpcEndFinally
5425
5426         }
5427     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
5428         {
5429         NdrClearOutParameters(
5430                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
5431                          ( PFORMAT_STRING  )&__MIDL_TypeFormatString.Format[1102],
5432                          ( void __RPC_FAR * )pVarVal);
5433         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
5434         }
5435     RpcEndExcept
5436     return _RetVal;
5437 }
5438
5439 void __RPC_STUB ITypeInfo2_GetCustData_Stub(
5440     IRpcStubBuffer *This,
5441     IRpcChannelBuffer *_pRpcChannelBuffer,
5442     PRPC_MESSAGE _pRpcMessage,
5443     DWORD *_pdwStubPhase)
5444 {
5445     VARIANT _M53;
5446     HRESULT _RetVal;
5447     MIDL_STUB_MESSAGE _StubMsg;
5448     REFGUID guid = 0;
5449     VARIANT __RPC_FAR *pVarVal;
5450
5451 NdrStubInitialize(
5452                      _pRpcMessage,
5453                      &_StubMsg,
5454                      &Object_StubDesc,
5455                      _pRpcChannelBuffer);
5456     pVarVal = 0;
5457     RpcTryFinally
5458         {
5459         if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
5460             NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[298] );
5461
5462         NdrSimpleStructUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
5463                                    (unsigned char __RPC_FAR * __RPC_FAR *)&guid,
5464                                    (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[38],
5465                                    (unsigned char)0 );
5466
5467         pVarVal = &_M53;
5468         MIDL_memset(
5469                pVarVal,
5470                0,
5471                sizeof( VARIANT  ));
5472
5473         *_pdwStubPhase = STUB_CALL_SERVER;
5474         _RetVal = (((ITypeInfo2*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> GetCustData(
5475                (ITypeInfo2 *) ((CStdStubBuffer *)This)->pvServerObject,
5476                guid,
5477                pVarVal);
5478
5479         *_pdwStubPhase = STUB_MARSHAL;
5480
5481         _StubMsg.BufferLength = 8U + 11U;
5482         NdrUserMarshalBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
5483                                   (unsigned char __RPC_FAR *)pVarVal,
5484                                   (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1110] );
5485
5486         _StubMsg.BufferLength += 16;
5487
5488         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
5489         NdrUserMarshalMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
5490                                 (unsigned char __RPC_FAR *)pVarVal,
5491                                 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1110] );
5492
5493         _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
5494         *( HRESULT __RPC_FAR * )_StubMsg.Buffer = _RetVal;
5495         _StubMsg.Buffer += sizeof(HRESULT);
5496
5497         }
5498     RpcFinally
5499         {
5500         NdrPointerFree( &_StubMsg,
5501                         (unsigned char __RPC_FAR *)pVarVal,
5502                         &__MIDL_TypeFormatString.Format[1102] );
5503
5504         }
5505     RpcEndFinally
5506     _pRpcMessage->BufferLength =
5507         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
5508
5509 }
5510
5511
5512 HRESULT STDMETHODCALLTYPE ITypeInfo2_GetFuncCustData_Proxy(
5513     ITypeInfo2 __RPC_FAR * This,
5514     /* [in] */ UINT index,
5515     /* [in] */ REFGUID guid,
5516     /* [out] */ VARIANT __RPC_FAR *pVarVal)
5517 {
5518
5519     HRESULT _RetVal;
5520
5521     RPC_MESSAGE _RpcMessage;
5522
5523     MIDL_STUB_MESSAGE _StubMsg;
5524
5525     if(pVarVal)
5526         {
5527         MIDL_memset(
5528                pVarVal,
5529                0,
5530                sizeof( VARIANT  ));
5531         }
5532     RpcTryExcept
5533         {
5534         NdrProxyInitialize(
5535                       ( void __RPC_FAR *  )This,
5536                       ( PRPC_MESSAGE  )&_RpcMessage,
5537                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
5538                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
5539                       27);
5540
5541
5542
5543         if(!guid)
5544             {
5545             RpcRaiseException(RPC_X_NULL_REF_POINTER);
5546             }
5547         if(!pVarVal)
5548             {
5549             RpcRaiseException(RPC_X_NULL_REF_POINTER);
5550             }
5551         RpcTryFinally
5552             {
5553
5554             _StubMsg.BufferLength = 4U + 4U;
5555             NdrSimpleStructBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
5556                                        (unsigned char __RPC_FAR *)guid,
5557                                        (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[38] );
5558
5559             NdrProxyGetBuffer(This, &_StubMsg);
5560             *( UINT __RPC_FAR * )_StubMsg.Buffer = index;
5561             _StubMsg.Buffer += sizeof(UINT);
5562
5563             NdrSimpleStructMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
5564                                      (unsigned char __RPC_FAR *)guid,
5565                                      (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[38] );
5566
5567             NdrProxySendReceive(This, &_StubMsg);
5568
5569             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
5570                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[308] );
5571
5572             NdrUserMarshalUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
5573                                       (unsigned char __RPC_FAR * __RPC_FAR *)&pVarVal,
5574                                       (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1110],
5575                                       (unsigned char)0 );
5576
5577             _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
5578             _RetVal = *( HRESULT __RPC_FAR * )_StubMsg.Buffer;
5579             _StubMsg.Buffer += sizeof(HRESULT);
5580
5581             }
5582         RpcFinally
5583             {
5584             NdrProxyFreeBuffer(This, &_StubMsg);
5585
5586             }
5587         RpcEndFinally
5588
5589         }
5590     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
5591         {
5592         NdrClearOutParameters(
5593                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
5594                          ( PFORMAT_STRING  )&__MIDL_TypeFormatString.Format[1102],
5595                          ( void __RPC_FAR * )pVarVal);
5596         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
5597         }
5598     RpcEndExcept
5599     return _RetVal;
5600 }
5601
5602 void __RPC_STUB ITypeInfo2_GetFuncCustData_Stub(
5603     IRpcStubBuffer *This,
5604     IRpcChannelBuffer *_pRpcChannelBuffer,
5605     PRPC_MESSAGE _pRpcMessage,
5606     DWORD *_pdwStubPhase)
5607 {
5608     VARIANT _M54;
5609     HRESULT _RetVal;
5610     MIDL_STUB_MESSAGE _StubMsg;
5611     REFGUID guid = 0;
5612     UINT index;
5613     VARIANT __RPC_FAR *pVarVal;
5614
5615 NdrStubInitialize(
5616                      _pRpcMessage,
5617                      &_StubMsg,
5618                      &Object_StubDesc,
5619                      _pRpcChannelBuffer);
5620     pVarVal = 0;
5621     RpcTryFinally
5622         {
5623         if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
5624             NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[308] );
5625
5626         index = *( UINT __RPC_FAR * )_StubMsg.Buffer;
5627         _StubMsg.Buffer += sizeof(UINT);
5628
5629         NdrSimpleStructUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
5630                                    (unsigned char __RPC_FAR * __RPC_FAR *)&guid,
5631                                    (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[38],
5632                                    (unsigned char)0 );
5633
5634         pVarVal = &_M54;
5635         MIDL_memset(
5636                pVarVal,
5637                0,
5638                sizeof( VARIANT  ));
5639
5640         *_pdwStubPhase = STUB_CALL_SERVER;
5641         _RetVal = (((ITypeInfo2*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> GetFuncCustData(
5642                    (ITypeInfo2 *) ((CStdStubBuffer *)This)->pvServerObject,
5643                    index,
5644                    guid,
5645                    pVarVal);
5646
5647         *_pdwStubPhase = STUB_MARSHAL;
5648
5649         _StubMsg.BufferLength = 8U + 11U;
5650         NdrUserMarshalBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
5651                                   (unsigned char __RPC_FAR *)pVarVal,
5652                                   (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1110] );
5653
5654         _StubMsg.BufferLength += 16;
5655
5656         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
5657         NdrUserMarshalMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
5658                                 (unsigned char __RPC_FAR *)pVarVal,
5659                                 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1110] );
5660
5661         _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
5662         *( HRESULT __RPC_FAR * )_StubMsg.Buffer = _RetVal;
5663         _StubMsg.Buffer += sizeof(HRESULT);
5664
5665         }
5666     RpcFinally
5667         {
5668         NdrPointerFree( &_StubMsg,
5669                         (unsigned char __RPC_FAR *)pVarVal,
5670                         &__MIDL_TypeFormatString.Format[1102] );
5671
5672         }
5673     RpcEndFinally
5674     _pRpcMessage->BufferLength =
5675         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
5676
5677 }
5678
5679
5680 HRESULT STDMETHODCALLTYPE ITypeInfo2_GetParamCustData_Proxy(
5681     ITypeInfo2 __RPC_FAR * This,
5682     /* [in] */ UINT indexFunc,
5683     /* [in] */ UINT indexParam,
5684     /* [in] */ REFGUID guid,
5685     /* [out] */ VARIANT __RPC_FAR *pVarVal)
5686 {
5687
5688     HRESULT _RetVal;
5689
5690     RPC_MESSAGE _RpcMessage;
5691
5692     MIDL_STUB_MESSAGE _StubMsg;
5693
5694     if(pVarVal)
5695         {
5696         MIDL_memset(
5697                pVarVal,
5698                0,
5699                sizeof( VARIANT  ));
5700         }
5701     RpcTryExcept
5702         {
5703         NdrProxyInitialize(
5704                       ( void __RPC_FAR *  )This,
5705                       ( PRPC_MESSAGE  )&_RpcMessage,
5706                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
5707                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
5708                       28);
5709
5710
5711
5712         if(!guid)
5713             {
5714             RpcRaiseException(RPC_X_NULL_REF_POINTER);
5715             }
5716         if(!pVarVal)
5717             {
5718             RpcRaiseException(RPC_X_NULL_REF_POINTER);
5719             }
5720         RpcTryFinally
5721             {
5722
5723             _StubMsg.BufferLength = 4U + 4U + 0U;
5724             NdrSimpleStructBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
5725                                        (unsigned char __RPC_FAR *)guid,
5726                                        (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[38] );
5727
5728             NdrProxyGetBuffer(This, &_StubMsg);
5729             *( UINT __RPC_FAR * )_StubMsg.Buffer = indexFunc;
5730             _StubMsg.Buffer += sizeof(UINT);
5731
5732             *( UINT __RPC_FAR * )_StubMsg.Buffer = indexParam;
5733             _StubMsg.Buffer += sizeof(UINT);
5734
5735             NdrSimpleStructMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
5736                                      (unsigned char __RPC_FAR *)guid,
5737                                      (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[38] );
5738
5739             NdrProxySendReceive(This, &_StubMsg);
5740
5741             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
5742                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[320] );
5743
5744             NdrUserMarshalUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
5745                                       (unsigned char __RPC_FAR * __RPC_FAR *)&pVarVal,
5746                                       (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1110],
5747                                       (unsigned char)0 );
5748
5749             _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
5750             _RetVal = *( HRESULT __RPC_FAR * )_StubMsg.Buffer;
5751             _StubMsg.Buffer += sizeof(HRESULT);
5752
5753             }
5754         RpcFinally
5755             {
5756             NdrProxyFreeBuffer(This, &_StubMsg);
5757
5758             }
5759         RpcEndFinally
5760
5761         }
5762     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
5763         {
5764         NdrClearOutParameters(
5765                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
5766                          ( PFORMAT_STRING  )&__MIDL_TypeFormatString.Format[1102],
5767                          ( void __RPC_FAR * )pVarVal);
5768         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
5769         }
5770     RpcEndExcept
5771     return _RetVal;
5772 }
5773
5774 void __RPC_STUB ITypeInfo2_GetParamCustData_Stub(
5775     IRpcStubBuffer *This,
5776     IRpcChannelBuffer *_pRpcChannelBuffer,
5777     PRPC_MESSAGE _pRpcMessage,
5778     DWORD *_pdwStubPhase)
5779 {
5780     VARIANT _M55;
5781     HRESULT _RetVal;
5782     MIDL_STUB_MESSAGE _StubMsg;
5783     REFGUID guid = 0;
5784     UINT indexFunc;
5785     UINT indexParam;
5786     VARIANT __RPC_FAR *pVarVal;
5787
5788 NdrStubInitialize(
5789                      _pRpcMessage,
5790                      &_StubMsg,
5791                      &Object_StubDesc,
5792                      _pRpcChannelBuffer);
5793     pVarVal = 0;
5794     RpcTryFinally
5795         {
5796         if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
5797             NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[320] );
5798
5799         indexFunc = *( UINT __RPC_FAR * )_StubMsg.Buffer;
5800         _StubMsg.Buffer += sizeof(UINT);
5801
5802         indexParam = *( UINT __RPC_FAR * )_StubMsg.Buffer;
5803         _StubMsg.Buffer += sizeof(UINT);
5804
5805         NdrSimpleStructUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
5806                                    (unsigned char __RPC_FAR * __RPC_FAR *)&guid,
5807                                    (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[38],
5808                                    (unsigned char)0 );
5809
5810         pVarVal = &_M55;
5811         MIDL_memset(
5812                pVarVal,
5813                0,
5814                sizeof( VARIANT  ));
5815
5816         *_pdwStubPhase = STUB_CALL_SERVER;
5817         _RetVal = (((ITypeInfo2*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> GetParamCustData(
5818                     (ITypeInfo2 *) ((CStdStubBuffer *)This)->pvServerObject,
5819                     indexFunc,
5820                     indexParam,
5821                     guid,
5822                     pVarVal);
5823
5824         *_pdwStubPhase = STUB_MARSHAL;
5825
5826         _StubMsg.BufferLength = 8U + 11U;
5827         NdrUserMarshalBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
5828                                   (unsigned char __RPC_FAR *)pVarVal,
5829                                   (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1110] );
5830
5831         _StubMsg.BufferLength += 16;
5832
5833         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
5834         NdrUserMarshalMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
5835                                 (unsigned char __RPC_FAR *)pVarVal,
5836                                 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1110] );
5837
5838         _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
5839         *( HRESULT __RPC_FAR * )_StubMsg.Buffer = _RetVal;
5840         _StubMsg.Buffer += sizeof(HRESULT);
5841
5842         }
5843     RpcFinally
5844         {
5845         NdrPointerFree( &_StubMsg,
5846                         (unsigned char __RPC_FAR *)pVarVal,
5847                         &__MIDL_TypeFormatString.Format[1102] );
5848
5849         }
5850     RpcEndFinally
5851     _pRpcMessage->BufferLength =
5852         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
5853
5854 }
5855
5856
5857 HRESULT STDMETHODCALLTYPE ITypeInfo2_GetVarCustData_Proxy(
5858     ITypeInfo2 __RPC_FAR * This,
5859     /* [in] */ UINT index,
5860     /* [in] */ REFGUID guid,
5861     /* [out] */ VARIANT __RPC_FAR *pVarVal)
5862 {
5863
5864     HRESULT _RetVal;
5865
5866     RPC_MESSAGE _RpcMessage;
5867
5868     MIDL_STUB_MESSAGE _StubMsg;
5869
5870     if(pVarVal)
5871         {
5872         MIDL_memset(
5873                pVarVal,
5874                0,
5875                sizeof( VARIANT  ));
5876         }
5877     RpcTryExcept
5878         {
5879         NdrProxyInitialize(
5880                       ( void __RPC_FAR *  )This,
5881                       ( PRPC_MESSAGE  )&_RpcMessage,
5882                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
5883                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
5884                       29);
5885
5886
5887
5888         if(!guid)
5889             {
5890             RpcRaiseException(RPC_X_NULL_REF_POINTER);
5891             }
5892         if(!pVarVal)
5893             {
5894             RpcRaiseException(RPC_X_NULL_REF_POINTER);
5895             }
5896         RpcTryFinally
5897             {
5898
5899             _StubMsg.BufferLength = 4U + 4U;
5900             NdrSimpleStructBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
5901                                        (unsigned char __RPC_FAR *)guid,
5902                                        (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[38] );
5903
5904             NdrProxyGetBuffer(This, &_StubMsg);
5905             *( UINT __RPC_FAR * )_StubMsg.Buffer = index;
5906             _StubMsg.Buffer += sizeof(UINT);
5907
5908             NdrSimpleStructMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
5909                                      (unsigned char __RPC_FAR *)guid,
5910                                      (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[38] );
5911
5912             NdrProxySendReceive(This, &_StubMsg);
5913
5914             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
5915                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[308] );
5916
5917             NdrUserMarshalUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
5918                                       (unsigned char __RPC_FAR * __RPC_FAR *)&pVarVal,
5919                                       (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1110],
5920                                       (unsigned char)0 );
5921
5922             _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
5923             _RetVal = *( HRESULT __RPC_FAR * )_StubMsg.Buffer;
5924             _StubMsg.Buffer += sizeof(HRESULT);
5925
5926             }
5927         RpcFinally
5928             {
5929             NdrProxyFreeBuffer(This, &_StubMsg);
5930
5931             }
5932         RpcEndFinally
5933
5934         }
5935     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
5936         {
5937         NdrClearOutParameters(
5938                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
5939                          ( PFORMAT_STRING  )&__MIDL_TypeFormatString.Format[1102],
5940                          ( void __RPC_FAR * )pVarVal);
5941         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
5942         }
5943     RpcEndExcept
5944     return _RetVal;
5945 }
5946
5947 void __RPC_STUB ITypeInfo2_GetVarCustData_Stub(
5948     IRpcStubBuffer *This,
5949     IRpcChannelBuffer *_pRpcChannelBuffer,
5950     PRPC_MESSAGE _pRpcMessage,
5951     DWORD *_pdwStubPhase)
5952 {
5953     VARIANT _M56;
5954     HRESULT _RetVal;
5955     MIDL_STUB_MESSAGE _StubMsg;
5956     REFGUID guid = 0;
5957     UINT index;
5958     VARIANT __RPC_FAR *pVarVal;
5959
5960 NdrStubInitialize(
5961                      _pRpcMessage,
5962                      &_StubMsg,
5963                      &Object_StubDesc,
5964                      _pRpcChannelBuffer);
5965     pVarVal = 0;
5966     RpcTryFinally
5967         {
5968         if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
5969             NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[308] );
5970
5971         index = *( UINT __RPC_FAR * )_StubMsg.Buffer;
5972         _StubMsg.Buffer += sizeof(UINT);
5973
5974         NdrSimpleStructUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
5975                                    (unsigned char __RPC_FAR * __RPC_FAR *)&guid,
5976                                    (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[38],
5977                                    (unsigned char)0 );
5978
5979         pVarVal = &_M56;
5980         MIDL_memset(
5981                pVarVal,
5982                0,
5983                sizeof( VARIANT  ));
5984
5985         *_pdwStubPhase = STUB_CALL_SERVER;
5986         _RetVal = (((ITypeInfo2*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> GetVarCustData(
5987                   (ITypeInfo2 *) ((CStdStubBuffer *)This)->pvServerObject,
5988                   index,
5989                   guid,
5990                   pVarVal);
5991
5992         *_pdwStubPhase = STUB_MARSHAL;
5993
5994         _StubMsg.BufferLength = 8U + 11U;
5995         NdrUserMarshalBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
5996                                   (unsigned char __RPC_FAR *)pVarVal,
5997                                   (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1110] );
5998
5999         _StubMsg.BufferLength += 16;
6000
6001         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
6002         NdrUserMarshalMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
6003                                 (unsigned char __RPC_FAR *)pVarVal,
6004                                 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1110] );
6005
6006         _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
6007         *( HRESULT __RPC_FAR * )_StubMsg.Buffer = _RetVal;
6008         _StubMsg.Buffer += sizeof(HRESULT);
6009
6010         }
6011     RpcFinally
6012         {
6013         NdrPointerFree( &_StubMsg,
6014                         (unsigned char __RPC_FAR *)pVarVal,
6015                         &__MIDL_TypeFormatString.Format[1102] );
6016
6017         }
6018     RpcEndFinally
6019     _pRpcMessage->BufferLength =
6020         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
6021
6022 }
6023
6024
6025 HRESULT STDMETHODCALLTYPE ITypeInfo2_GetImplTypeCustData_Proxy(
6026     ITypeInfo2 __RPC_FAR * This,
6027     /* [in] */ UINT index,
6028     /* [in] */ REFGUID guid,
6029     /* [out] */ VARIANT __RPC_FAR *pVarVal)
6030 {
6031
6032     HRESULT _RetVal;
6033
6034     RPC_MESSAGE _RpcMessage;
6035
6036     MIDL_STUB_MESSAGE _StubMsg;
6037
6038     if(pVarVal)
6039         {
6040         MIDL_memset(
6041                pVarVal,
6042                0,
6043                sizeof( VARIANT  ));
6044         }
6045     RpcTryExcept
6046         {
6047         NdrProxyInitialize(
6048                       ( void __RPC_FAR *  )This,
6049                       ( PRPC_MESSAGE  )&_RpcMessage,
6050                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
6051                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
6052                       30);
6053
6054
6055
6056         if(!guid)
6057             {
6058             RpcRaiseException(RPC_X_NULL_REF_POINTER);
6059             }
6060         if(!pVarVal)
6061             {
6062             RpcRaiseException(RPC_X_NULL_REF_POINTER);
6063             }
6064         RpcTryFinally
6065             {
6066
6067             _StubMsg.BufferLength = 4U + 4U;
6068             NdrSimpleStructBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
6069                                        (unsigned char __RPC_FAR *)guid,
6070                                        (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[38] );
6071
6072             NdrProxyGetBuffer(This, &_StubMsg);
6073             *( UINT __RPC_FAR * )_StubMsg.Buffer = index;
6074             _StubMsg.Buffer += sizeof(UINT);
6075
6076             NdrSimpleStructMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
6077                                      (unsigned char __RPC_FAR *)guid,
6078                                      (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[38] );
6079
6080             NdrProxySendReceive(This, &_StubMsg);
6081
6082             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
6083                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[308] );
6084
6085             NdrUserMarshalUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
6086                                       (unsigned char __RPC_FAR * __RPC_FAR *)&pVarVal,
6087                                       (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1110],
6088                                       (unsigned char)0 );
6089
6090             _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
6091             _RetVal = *( HRESULT __RPC_FAR * )_StubMsg.Buffer;
6092             _StubMsg.Buffer += sizeof(HRESULT);
6093
6094             }
6095         RpcFinally
6096             {
6097             NdrProxyFreeBuffer(This, &_StubMsg);
6098
6099             }
6100         RpcEndFinally
6101
6102         }
6103     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
6104         {
6105         NdrClearOutParameters(
6106                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
6107                          ( PFORMAT_STRING  )&__MIDL_TypeFormatString.Format[1102],
6108                          ( void __RPC_FAR * )pVarVal);
6109         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
6110         }
6111     RpcEndExcept
6112     return _RetVal;
6113 }
6114
6115 void __RPC_STUB ITypeInfo2_GetImplTypeCustData_Stub(
6116     IRpcStubBuffer *This,
6117     IRpcChannelBuffer *_pRpcChannelBuffer,
6118     PRPC_MESSAGE _pRpcMessage,
6119     DWORD *_pdwStubPhase)
6120 {
6121     VARIANT _M57;
6122     HRESULT _RetVal;
6123     MIDL_STUB_MESSAGE _StubMsg;
6124     REFGUID guid = 0;
6125     UINT index;
6126     VARIANT __RPC_FAR *pVarVal;
6127
6128 NdrStubInitialize(
6129                      _pRpcMessage,
6130                      &_StubMsg,
6131                      &Object_StubDesc,
6132                      _pRpcChannelBuffer);
6133     pVarVal = 0;
6134     RpcTryFinally
6135         {
6136         if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
6137             NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[308] );
6138
6139         index = *( UINT __RPC_FAR * )_StubMsg.Buffer;
6140         _StubMsg.Buffer += sizeof(UINT);
6141
6142         NdrSimpleStructUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
6143                                    (unsigned char __RPC_FAR * __RPC_FAR *)&guid,
6144                                    (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[38],
6145                                    (unsigned char)0 );
6146
6147         pVarVal = &_M57;
6148         MIDL_memset(
6149                pVarVal,
6150                0,
6151                sizeof( VARIANT  ));
6152
6153         *_pdwStubPhase = STUB_CALL_SERVER;
6154         _RetVal = (((ITypeInfo2*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> GetImplTypeCustData(
6155                        (ITypeInfo2 *) ((CStdStubBuffer *)This)->pvServerObject,
6156                        index,
6157                        guid,
6158                        pVarVal);
6159
6160         *_pdwStubPhase = STUB_MARSHAL;
6161
6162         _StubMsg.BufferLength = 8U + 11U;
6163         NdrUserMarshalBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
6164                                   (unsigned char __RPC_FAR *)pVarVal,
6165                                   (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1110] );
6166
6167         _StubMsg.BufferLength += 16;
6168
6169         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
6170         NdrUserMarshalMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
6171                                 (unsigned char __RPC_FAR *)pVarVal,
6172                                 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1110] );
6173
6174         _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
6175         *( HRESULT __RPC_FAR * )_StubMsg.Buffer = _RetVal;
6176         _StubMsg.Buffer += sizeof(HRESULT);
6177
6178         }
6179     RpcFinally
6180         {
6181         NdrPointerFree( &_StubMsg,
6182                         (unsigned char __RPC_FAR *)pVarVal,
6183                         &__MIDL_TypeFormatString.Format[1102] );
6184
6185         }
6186     RpcEndFinally
6187     _pRpcMessage->BufferLength =
6188         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
6189
6190 }
6191
6192
6193 /* [call_as] */ HRESULT STDMETHODCALLTYPE ITypeInfo2_RemoteGetDocumentation2_Proxy(
6194     ITypeInfo2 __RPC_FAR * This,
6195     /* [in] */ MEMBERID memid,
6196     /* [in] */ LCID lcid,
6197     /* [in] */ DWORD refPtrFlags,
6198     /* [out] */ BSTR __RPC_FAR *pbstrHelpString,
6199     /* [out] */ DWORD __RPC_FAR *pdwHelpStringContext,
6200     /* [out] */ BSTR __RPC_FAR *pbstrHelpStringDll)
6201 {
6202
6203     HRESULT _RetVal;
6204
6205     RPC_MESSAGE _RpcMessage;
6206
6207     MIDL_STUB_MESSAGE _StubMsg;
6208
6209     if(pbstrHelpString)
6210         {
6211         MIDL_memset(
6212                pbstrHelpString,
6213                0,
6214                sizeof( BSTR  ));
6215         }
6216     if(pbstrHelpStringDll)
6217         {
6218         MIDL_memset(
6219                pbstrHelpStringDll,
6220                0,
6221                sizeof( BSTR  ));
6222         }
6223     RpcTryExcept
6224         {
6225         NdrProxyInitialize(
6226                       ( void __RPC_FAR *  )This,
6227                       ( PRPC_MESSAGE  )&_RpcMessage,
6228                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
6229                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
6230                       31);
6231
6232
6233
6234         if(!pbstrHelpString)
6235             {
6236             RpcRaiseException(RPC_X_NULL_REF_POINTER);
6237             }
6238         if(!pdwHelpStringContext)
6239             {
6240             RpcRaiseException(RPC_X_NULL_REF_POINTER);
6241             }
6242         if(!pbstrHelpStringDll)
6243             {
6244             RpcRaiseException(RPC_X_NULL_REF_POINTER);
6245             }
6246         RpcTryFinally
6247             {
6248
6249             _StubMsg.BufferLength = 4U + 4U + 4U;
6250             NdrProxyGetBuffer(This, &_StubMsg);
6251             *( MEMBERID __RPC_FAR * )_StubMsg.Buffer = memid;
6252             _StubMsg.Buffer += sizeof(MEMBERID);
6253
6254             *( LCID __RPC_FAR * )_StubMsg.Buffer = lcid;
6255             _StubMsg.Buffer += sizeof(LCID);
6256
6257             *( DWORD __RPC_FAR * )_StubMsg.Buffer = refPtrFlags;
6258             _StubMsg.Buffer += sizeof(DWORD);
6259
6260             NdrProxySendReceive(This, &_StubMsg);
6261
6262             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
6263                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[334] );
6264
6265             NdrUserMarshalUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
6266                                       (unsigned char __RPC_FAR * __RPC_FAR *)&pbstrHelpString,
6267                                       (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1128],
6268                                       (unsigned char)0 );
6269
6270             _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
6271             *pdwHelpStringContext = *( DWORD __RPC_FAR * )_StubMsg.Buffer;
6272             _StubMsg.Buffer += sizeof(DWORD);
6273
6274             NdrUserMarshalUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
6275                                       (unsigned char __RPC_FAR * __RPC_FAR *)&pbstrHelpStringDll,
6276                                       (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1128],
6277                                       (unsigned char)0 );
6278
6279             _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
6280             _RetVal = *( HRESULT __RPC_FAR * )_StubMsg.Buffer;
6281             _StubMsg.Buffer += sizeof(HRESULT);
6282
6283             }
6284         RpcFinally
6285             {
6286             NdrProxyFreeBuffer(This, &_StubMsg);
6287
6288             }
6289         RpcEndFinally
6290
6291         }
6292     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
6293         {
6294         NdrClearOutParameters(
6295                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
6296                          ( PFORMAT_STRING  )&__MIDL_TypeFormatString.Format[1708],
6297                          ( void __RPC_FAR * )pbstrHelpString);
6298         NdrClearOutParameters(
6299                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
6300                          ( PFORMAT_STRING  )&__MIDL_TypeFormatString.Format[2],
6301                          ( void __RPC_FAR * )pdwHelpStringContext);
6302         NdrClearOutParameters(
6303                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
6304                          ( PFORMAT_STRING  )&__MIDL_TypeFormatString.Format[1708],
6305                          ( void __RPC_FAR * )pbstrHelpStringDll);
6306         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
6307         }
6308     RpcEndExcept
6309     return _RetVal;
6310 }
6311
6312 void __RPC_STUB ITypeInfo2_RemoteGetDocumentation2_Stub(
6313     IRpcStubBuffer *This,
6314     IRpcChannelBuffer *_pRpcChannelBuffer,
6315     PRPC_MESSAGE _pRpcMessage,
6316     DWORD *_pdwStubPhase)
6317 {
6318     BSTR _M58;
6319     DWORD _M59;
6320     BSTR _M60;
6321     HRESULT _RetVal;
6322     MIDL_STUB_MESSAGE _StubMsg;
6323     LCID lcid;
6324     MEMBERID memid;
6325     BSTR __RPC_FAR *pbstrHelpString;
6326     BSTR __RPC_FAR *pbstrHelpStringDll;
6327     DWORD __RPC_FAR *pdwHelpStringContext;
6328     DWORD refPtrFlags;
6329
6330 NdrStubInitialize(
6331                      _pRpcMessage,
6332                      &_StubMsg,
6333                      &Object_StubDesc,
6334                      _pRpcChannelBuffer);
6335     pbstrHelpString = 0;
6336     pdwHelpStringContext = 0;
6337     pbstrHelpStringDll = 0;
6338     RpcTryFinally
6339         {
6340         if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
6341             NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[334] );
6342
6343         memid = *( MEMBERID __RPC_FAR * )_StubMsg.Buffer;
6344         _StubMsg.Buffer += sizeof(MEMBERID);
6345
6346         lcid = *( LCID __RPC_FAR * )_StubMsg.Buffer;
6347         _StubMsg.Buffer += sizeof(LCID);
6348
6349         refPtrFlags = *( DWORD __RPC_FAR * )_StubMsg.Buffer;
6350         _StubMsg.Buffer += sizeof(DWORD);
6351
6352         pbstrHelpString = &_M58;
6353         MIDL_memset(
6354                pbstrHelpString,
6355                0,
6356                sizeof( BSTR  ));
6357         pdwHelpStringContext = &_M59;
6358         pbstrHelpStringDll = &_M60;
6359         MIDL_memset(
6360                pbstrHelpStringDll,
6361                0,
6362                sizeof( BSTR  ));
6363
6364         *_pdwStubPhase = STUB_CALL_SERVER;
6365
6366
6367         _RetVal = ITypeInfo2_GetDocumentation2_Stub(
6368                                             (ITypeInfo2 *) ((CStdStubBuffer *)This)->pvServerObject,
6369                                             memid,
6370                                             lcid,
6371                                             refPtrFlags,
6372                                             pbstrHelpString,
6373                                             pdwHelpStringContext,
6374                                             pbstrHelpStringDll);
6375
6376         *_pdwStubPhase = STUB_MARSHAL;
6377
6378         _StubMsg.BufferLength = 8U + 11U + 11U + 11U;
6379         NdrUserMarshalBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
6380                                   (unsigned char __RPC_FAR *)pbstrHelpString,
6381                                   (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1128] );
6382
6383         NdrUserMarshalBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
6384                                   (unsigned char __RPC_FAR *)pbstrHelpStringDll,
6385                                   (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1128] );
6386
6387         _StubMsg.BufferLength += 16;
6388
6389         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
6390         NdrUserMarshalMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
6391                                 (unsigned char __RPC_FAR *)pbstrHelpString,
6392                                 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1128] );
6393
6394         _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
6395         *( DWORD __RPC_FAR * )_StubMsg.Buffer = *pdwHelpStringContext;
6396         _StubMsg.Buffer += sizeof(DWORD);
6397
6398         NdrUserMarshalMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
6399                                 (unsigned char __RPC_FAR *)pbstrHelpStringDll,
6400                                 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1128] );
6401
6402         _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
6403         *( HRESULT __RPC_FAR * )_StubMsg.Buffer = _RetVal;
6404         _StubMsg.Buffer += sizeof(HRESULT);
6405
6406         }
6407     RpcFinally
6408         {
6409         NdrPointerFree( &_StubMsg,
6410                         (unsigned char __RPC_FAR *)pbstrHelpString,
6411                         &__MIDL_TypeFormatString.Format[1708] );
6412
6413         NdrPointerFree( &_StubMsg,
6414                         (unsigned char __RPC_FAR *)pbstrHelpStringDll,
6415                         &__MIDL_TypeFormatString.Format[1708] );
6416
6417         }
6418     RpcEndFinally
6419     _pRpcMessage->BufferLength =
6420         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
6421
6422 }
6423
6424
6425 HRESULT STDMETHODCALLTYPE ITypeInfo2_GetAllCustData_Proxy(
6426     ITypeInfo2 __RPC_FAR * This,
6427     /* [out] */ CUSTDATA __RPC_FAR *pCustData)
6428 {
6429
6430     HRESULT _RetVal;
6431
6432     RPC_MESSAGE _RpcMessage;
6433
6434     MIDL_STUB_MESSAGE _StubMsg;
6435
6436     if(pCustData)
6437         {
6438         MIDL_memset(
6439                pCustData,
6440                0,
6441                sizeof( CUSTDATA  ));
6442         }
6443     RpcTryExcept
6444         {
6445         NdrProxyInitialize(
6446                       ( void __RPC_FAR *  )This,
6447                       ( PRPC_MESSAGE  )&_RpcMessage,
6448                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
6449                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
6450                       32);
6451
6452
6453
6454         if(!pCustData)
6455             {
6456             RpcRaiseException(RPC_X_NULL_REF_POINTER);
6457             }
6458         RpcTryFinally
6459             {
6460
6461             _StubMsg.BufferLength = 0U;
6462             NdrProxyGetBuffer(This, &_StubMsg);
6463             NdrProxySendReceive(This, &_StubMsg);
6464
6465             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
6466                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[354] );
6467
6468             NdrComplexStructUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
6469                                         (unsigned char __RPC_FAR * __RPC_FAR *)&pCustData,
6470                                         (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1788],
6471                                         (unsigned char)0 );
6472
6473             _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
6474             _RetVal = *( HRESULT __RPC_FAR * )_StubMsg.Buffer;
6475             _StubMsg.Buffer += sizeof(HRESULT);
6476
6477             }
6478         RpcFinally
6479             {
6480             NdrProxyFreeBuffer(This, &_StubMsg);
6481
6482             }
6483         RpcEndFinally
6484
6485         }
6486     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
6487         {
6488         NdrClearOutParameters(
6489                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
6490                          ( PFORMAT_STRING  )&__MIDL_TypeFormatString.Format[1748],
6491                          ( void __RPC_FAR * )pCustData);
6492         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
6493         }
6494     RpcEndExcept
6495     return _RetVal;
6496 }
6497
6498 void __RPC_STUB ITypeInfo2_GetAllCustData_Stub(
6499     IRpcStubBuffer *This,
6500     IRpcChannelBuffer *_pRpcChannelBuffer,
6501     PRPC_MESSAGE _pRpcMessage,
6502     DWORD *_pdwStubPhase)
6503 {
6504     HRESULT _RetVal;
6505     MIDL_STUB_MESSAGE _StubMsg;
6506     CUSTDATA _pCustDataM;
6507     CUSTDATA __RPC_FAR *pCustData;
6508
6509 NdrStubInitialize(
6510                      _pRpcMessage,
6511                      &_StubMsg,
6512                      &Object_StubDesc,
6513                      _pRpcChannelBuffer);
6514     pCustData = 0;
6515     RpcTryFinally
6516         {
6517         pCustData = &_pCustDataM;
6518         pCustData -> prgCustData = 0;
6519
6520         *_pdwStubPhase = STUB_CALL_SERVER;
6521         _RetVal = (((ITypeInfo2*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> GetAllCustData((ITypeInfo2 *) ((CStdStubBuffer *)This)->pvServerObject,pCustData);
6522
6523         *_pdwStubPhase = STUB_MARSHAL;
6524
6525         _StubMsg.BufferLength = 0U + 11U;
6526         NdrComplexStructBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
6527                                     (unsigned char __RPC_FAR *)pCustData,
6528                                     (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1788] );
6529
6530         _StubMsg.BufferLength += 16;
6531
6532         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
6533         NdrComplexStructMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
6534                                   (unsigned char __RPC_FAR *)pCustData,
6535                                   (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1788] );
6536
6537         _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
6538         *( HRESULT __RPC_FAR * )_StubMsg.Buffer = _RetVal;
6539         _StubMsg.Buffer += sizeof(HRESULT);
6540
6541         }
6542     RpcFinally
6543         {
6544         NdrPointerFree( &_StubMsg,
6545                         (unsigned char __RPC_FAR *)pCustData,
6546                         &__MIDL_TypeFormatString.Format[1748] );
6547
6548         }
6549     RpcEndFinally
6550     _pRpcMessage->BufferLength =
6551         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
6552
6553 }
6554
6555
6556 HRESULT STDMETHODCALLTYPE ITypeInfo2_GetAllFuncCustData_Proxy(
6557     ITypeInfo2 __RPC_FAR * This,
6558     /* [in] */ UINT index,
6559     /* [out] */ CUSTDATA __RPC_FAR *pCustData)
6560 {
6561
6562     HRESULT _RetVal;
6563
6564     RPC_MESSAGE _RpcMessage;
6565
6566     MIDL_STUB_MESSAGE _StubMsg;
6567
6568     if(pCustData)
6569         {
6570         MIDL_memset(
6571                pCustData,
6572                0,
6573                sizeof( CUSTDATA  ));
6574         }
6575     RpcTryExcept
6576         {
6577         NdrProxyInitialize(
6578                       ( void __RPC_FAR *  )This,
6579                       ( PRPC_MESSAGE  )&_RpcMessage,
6580                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
6581                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
6582                       33);
6583
6584
6585
6586         if(!pCustData)
6587             {
6588             RpcRaiseException(RPC_X_NULL_REF_POINTER);
6589             }
6590         RpcTryFinally
6591             {
6592
6593             _StubMsg.BufferLength = 4U;
6594             NdrProxyGetBuffer(This, &_StubMsg);
6595             *( UINT __RPC_FAR * )_StubMsg.Buffer = index;
6596             _StubMsg.Buffer += sizeof(UINT);
6597
6598             NdrProxySendReceive(This, &_StubMsg);
6599
6600             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
6601                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[360] );
6602
6603             NdrComplexStructUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
6604                                         (unsigned char __RPC_FAR * __RPC_FAR *)&pCustData,
6605                                         (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1788],
6606                                         (unsigned char)0 );
6607
6608             _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
6609             _RetVal = *( HRESULT __RPC_FAR * )_StubMsg.Buffer;
6610             _StubMsg.Buffer += sizeof(HRESULT);
6611
6612             }
6613         RpcFinally
6614             {
6615             NdrProxyFreeBuffer(This, &_StubMsg);
6616
6617             }
6618         RpcEndFinally
6619
6620         }
6621     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
6622         {
6623         NdrClearOutParameters(
6624                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
6625                          ( PFORMAT_STRING  )&__MIDL_TypeFormatString.Format[1748],
6626                          ( void __RPC_FAR * )pCustData);
6627         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
6628         }
6629     RpcEndExcept
6630     return _RetVal;
6631 }
6632
6633 void __RPC_STUB ITypeInfo2_GetAllFuncCustData_Stub(
6634     IRpcStubBuffer *This,
6635     IRpcChannelBuffer *_pRpcChannelBuffer,
6636     PRPC_MESSAGE _pRpcMessage,
6637     DWORD *_pdwStubPhase)
6638 {
6639     HRESULT _RetVal;
6640     MIDL_STUB_MESSAGE _StubMsg;
6641     CUSTDATA _pCustDataM;
6642     UINT index;
6643     CUSTDATA __RPC_FAR *pCustData;
6644
6645 NdrStubInitialize(
6646                      _pRpcMessage,
6647                      &_StubMsg,
6648                      &Object_StubDesc,
6649                      _pRpcChannelBuffer);
6650     pCustData = 0;
6651     RpcTryFinally
6652         {
6653         if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
6654             NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[360] );
6655
6656         index = *( UINT __RPC_FAR * )_StubMsg.Buffer;
6657         _StubMsg.Buffer += sizeof(UINT);
6658
6659         pCustData = &_pCustDataM;
6660         pCustData -> prgCustData = 0;
6661
6662         *_pdwStubPhase = STUB_CALL_SERVER;
6663         _RetVal = (((ITypeInfo2*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> GetAllFuncCustData(
6664                       (ITypeInfo2 *) ((CStdStubBuffer *)This)->pvServerObject,
6665                       index,
6666                       pCustData);
6667
6668         *_pdwStubPhase = STUB_MARSHAL;
6669
6670         _StubMsg.BufferLength = 0U + 11U;
6671         NdrComplexStructBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
6672                                     (unsigned char __RPC_FAR *)pCustData,
6673                                     (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1788] );
6674
6675         _StubMsg.BufferLength += 16;
6676
6677         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
6678         NdrComplexStructMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
6679                                   (unsigned char __RPC_FAR *)pCustData,
6680                                   (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1788] );
6681
6682         _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
6683         *( HRESULT __RPC_FAR * )_StubMsg.Buffer = _RetVal;
6684         _StubMsg.Buffer += sizeof(HRESULT);
6685
6686         }
6687     RpcFinally
6688         {
6689         NdrPointerFree( &_StubMsg,
6690                         (unsigned char __RPC_FAR *)pCustData,
6691                         &__MIDL_TypeFormatString.Format[1748] );
6692
6693         }
6694     RpcEndFinally
6695     _pRpcMessage->BufferLength =
6696         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
6697
6698 }
6699
6700
6701 HRESULT STDMETHODCALLTYPE ITypeInfo2_GetAllParamCustData_Proxy(
6702     ITypeInfo2 __RPC_FAR * This,
6703     /* [in] */ UINT indexFunc,
6704     /* [in] */ UINT indexParam,
6705     /* [out] */ CUSTDATA __RPC_FAR *pCustData)
6706 {
6707
6708     HRESULT _RetVal;
6709
6710     RPC_MESSAGE _RpcMessage;
6711
6712     MIDL_STUB_MESSAGE _StubMsg;
6713
6714     if(pCustData)
6715         {
6716         MIDL_memset(
6717                pCustData,
6718                0,
6719                sizeof( CUSTDATA  ));
6720         }
6721     RpcTryExcept
6722         {
6723         NdrProxyInitialize(
6724                       ( void __RPC_FAR *  )This,
6725                       ( PRPC_MESSAGE  )&_RpcMessage,
6726                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
6727                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
6728                       34);
6729
6730
6731
6732         if(!pCustData)
6733             {
6734             RpcRaiseException(RPC_X_NULL_REF_POINTER);
6735             }
6736         RpcTryFinally
6737             {
6738
6739             _StubMsg.BufferLength = 4U + 4U;
6740             NdrProxyGetBuffer(This, &_StubMsg);
6741             *( UINT __RPC_FAR * )_StubMsg.Buffer = indexFunc;
6742             _StubMsg.Buffer += sizeof(UINT);
6743
6744             *( UINT __RPC_FAR * )_StubMsg.Buffer = indexParam;
6745             _StubMsg.Buffer += sizeof(UINT);
6746
6747             NdrProxySendReceive(This, &_StubMsg);
6748
6749             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
6750                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[368] );
6751
6752             NdrComplexStructUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
6753                                         (unsigned char __RPC_FAR * __RPC_FAR *)&pCustData,
6754                                         (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1788],
6755                                         (unsigned char)0 );
6756
6757             _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
6758             _RetVal = *( HRESULT __RPC_FAR * )_StubMsg.Buffer;
6759             _StubMsg.Buffer += sizeof(HRESULT);
6760
6761             }
6762         RpcFinally
6763             {
6764             NdrProxyFreeBuffer(This, &_StubMsg);
6765
6766             }
6767         RpcEndFinally
6768
6769         }
6770     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
6771         {
6772         NdrClearOutParameters(
6773                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
6774                          ( PFORMAT_STRING  )&__MIDL_TypeFormatString.Format[1748],
6775                          ( void __RPC_FAR * )pCustData);
6776         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
6777         }
6778     RpcEndExcept
6779     return _RetVal;
6780 }
6781
6782 void __RPC_STUB ITypeInfo2_GetAllParamCustData_Stub(
6783     IRpcStubBuffer *This,
6784     IRpcChannelBuffer *_pRpcChannelBuffer,
6785     PRPC_MESSAGE _pRpcMessage,
6786     DWORD *_pdwStubPhase)
6787 {
6788     HRESULT _RetVal;
6789     MIDL_STUB_MESSAGE _StubMsg;
6790     CUSTDATA _pCustDataM;
6791     UINT indexFunc;
6792     UINT indexParam;
6793     CUSTDATA __RPC_FAR *pCustData;
6794
6795 NdrStubInitialize(
6796                      _pRpcMessage,
6797                      &_StubMsg,
6798                      &Object_StubDesc,
6799                      _pRpcChannelBuffer);
6800     pCustData = 0;
6801     RpcTryFinally
6802         {
6803         if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
6804             NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[368] );
6805
6806         indexFunc = *( UINT __RPC_FAR * )_StubMsg.Buffer;
6807         _StubMsg.Buffer += sizeof(UINT);
6808
6809         indexParam = *( UINT __RPC_FAR * )_StubMsg.Buffer;
6810         _StubMsg.Buffer += sizeof(UINT);
6811
6812         pCustData = &_pCustDataM;
6813         pCustData -> prgCustData = 0;
6814
6815         *_pdwStubPhase = STUB_CALL_SERVER;
6816         _RetVal = (((ITypeInfo2*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> GetAllParamCustData(
6817                        (ITypeInfo2 *) ((CStdStubBuffer *)This)->pvServerObject,
6818                        indexFunc,
6819                        indexParam,
6820                        pCustData);
6821
6822         *_pdwStubPhase = STUB_MARSHAL;
6823
6824         _StubMsg.BufferLength = 0U + 11U;
6825         NdrComplexStructBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
6826                                     (unsigned char __RPC_FAR *)pCustData,
6827                                     (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1788] );
6828
6829         _StubMsg.BufferLength += 16;
6830
6831         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
6832         NdrComplexStructMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
6833                                   (unsigned char __RPC_FAR *)pCustData,
6834                                   (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1788] );
6835
6836         _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
6837         *( HRESULT __RPC_FAR * )_StubMsg.Buffer = _RetVal;
6838         _StubMsg.Buffer += sizeof(HRESULT);
6839
6840         }
6841     RpcFinally
6842         {
6843         NdrPointerFree( &_StubMsg,
6844                         (unsigned char __RPC_FAR *)pCustData,
6845                         &__MIDL_TypeFormatString.Format[1748] );
6846
6847         }
6848     RpcEndFinally
6849     _pRpcMessage->BufferLength =
6850         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
6851
6852 }
6853
6854
6855 HRESULT STDMETHODCALLTYPE ITypeInfo2_GetAllVarCustData_Proxy(
6856     ITypeInfo2 __RPC_FAR * This,
6857     /* [in] */ UINT index,
6858     /* [out] */ CUSTDATA __RPC_FAR *pCustData)
6859 {
6860
6861     HRESULT _RetVal;
6862
6863     RPC_MESSAGE _RpcMessage;
6864
6865     MIDL_STUB_MESSAGE _StubMsg;
6866
6867     if(pCustData)
6868         {
6869         MIDL_memset(
6870                pCustData,
6871                0,
6872                sizeof( CUSTDATA  ));
6873         }
6874     RpcTryExcept
6875         {
6876         NdrProxyInitialize(
6877                       ( void __RPC_FAR *  )This,
6878                       ( PRPC_MESSAGE  )&_RpcMessage,
6879                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
6880                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
6881                       35);
6882
6883
6884
6885         if(!pCustData)
6886             {
6887             RpcRaiseException(RPC_X_NULL_REF_POINTER);
6888             }
6889         RpcTryFinally
6890             {
6891
6892             _StubMsg.BufferLength = 4U;
6893             NdrProxyGetBuffer(This, &_StubMsg);
6894             *( UINT __RPC_FAR * )_StubMsg.Buffer = index;
6895             _StubMsg.Buffer += sizeof(UINT);
6896
6897             NdrProxySendReceive(This, &_StubMsg);
6898
6899             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
6900                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[360] );
6901
6902             NdrComplexStructUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
6903                                         (unsigned char __RPC_FAR * __RPC_FAR *)&pCustData,
6904                                         (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1788],
6905                                         (unsigned char)0 );
6906
6907             _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
6908             _RetVal = *( HRESULT __RPC_FAR * )_StubMsg.Buffer;
6909             _StubMsg.Buffer += sizeof(HRESULT);
6910
6911             }
6912         RpcFinally
6913             {
6914             NdrProxyFreeBuffer(This, &_StubMsg);
6915
6916             }
6917         RpcEndFinally
6918
6919         }
6920     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
6921         {
6922         NdrClearOutParameters(
6923                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
6924                          ( PFORMAT_STRING  )&__MIDL_TypeFormatString.Format[1748],
6925                          ( void __RPC_FAR * )pCustData);
6926         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
6927         }
6928     RpcEndExcept
6929     return _RetVal;
6930 }
6931
6932 void __RPC_STUB ITypeInfo2_GetAllVarCustData_Stub(
6933     IRpcStubBuffer *This,
6934     IRpcChannelBuffer *_pRpcChannelBuffer,
6935     PRPC_MESSAGE _pRpcMessage,
6936     DWORD *_pdwStubPhase)
6937 {
6938     HRESULT _RetVal;
6939     MIDL_STUB_MESSAGE _StubMsg;
6940     CUSTDATA _pCustDataM;
6941     UINT index;
6942     CUSTDATA __RPC_FAR *pCustData;
6943
6944 NdrStubInitialize(
6945                      _pRpcMessage,
6946                      &_StubMsg,
6947                      &Object_StubDesc,
6948                      _pRpcChannelBuffer);
6949     pCustData = 0;
6950     RpcTryFinally
6951         {
6952         if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
6953             NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[360] );
6954
6955         index = *( UINT __RPC_FAR * )_StubMsg.Buffer;
6956         _StubMsg.Buffer += sizeof(UINT);
6957
6958         pCustData = &_pCustDataM;
6959         pCustData -> prgCustData = 0;
6960
6961         *_pdwStubPhase = STUB_CALL_SERVER;
6962         _RetVal = (((ITypeInfo2*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> GetAllVarCustData(
6963                      (ITypeInfo2 *) ((CStdStubBuffer *)This)->pvServerObject,
6964                      index,
6965                      pCustData);
6966
6967         *_pdwStubPhase = STUB_MARSHAL;
6968
6969         _StubMsg.BufferLength = 0U + 11U;
6970         NdrComplexStructBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
6971                                     (unsigned char __RPC_FAR *)pCustData,
6972                                     (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1788] );
6973
6974         _StubMsg.BufferLength += 16;
6975
6976         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
6977         NdrComplexStructMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
6978                                   (unsigned char __RPC_FAR *)pCustData,
6979                                   (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1788] );
6980
6981         _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
6982         *( HRESULT __RPC_FAR * )_StubMsg.Buffer = _RetVal;
6983         _StubMsg.Buffer += sizeof(HRESULT);
6984
6985         }
6986     RpcFinally
6987         {
6988         NdrPointerFree( &_StubMsg,
6989                         (unsigned char __RPC_FAR *)pCustData,
6990                         &__MIDL_TypeFormatString.Format[1748] );
6991
6992         }
6993     RpcEndFinally
6994     _pRpcMessage->BufferLength =
6995         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
6996
6997 }
6998
6999
7000 HRESULT STDMETHODCALLTYPE ITypeInfo2_GetAllImplTypeCustData_Proxy(
7001     ITypeInfo2 __RPC_FAR * This,
7002     /* [in] */ UINT index,
7003     /* [out] */ CUSTDATA __RPC_FAR *pCustData)
7004 {
7005
7006     HRESULT _RetVal;
7007
7008     RPC_MESSAGE _RpcMessage;
7009
7010     MIDL_STUB_MESSAGE _StubMsg;
7011
7012     if(pCustData)
7013         {
7014         MIDL_memset(
7015                pCustData,
7016                0,
7017                sizeof( CUSTDATA  ));
7018         }
7019     RpcTryExcept
7020         {
7021         NdrProxyInitialize(
7022                       ( void __RPC_FAR *  )This,
7023                       ( PRPC_MESSAGE  )&_RpcMessage,
7024                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
7025                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
7026                       36);
7027
7028
7029
7030         if(!pCustData)
7031             {
7032             RpcRaiseException(RPC_X_NULL_REF_POINTER);
7033             }
7034         RpcTryFinally
7035             {
7036
7037             _StubMsg.BufferLength = 4U;
7038             NdrProxyGetBuffer(This, &_StubMsg);
7039             *( UINT __RPC_FAR * )_StubMsg.Buffer = index;
7040             _StubMsg.Buffer += sizeof(UINT);
7041
7042             NdrProxySendReceive(This, &_StubMsg);
7043
7044             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
7045                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[360] );
7046
7047             NdrComplexStructUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
7048                                         (unsigned char __RPC_FAR * __RPC_FAR *)&pCustData,
7049                                         (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1788],
7050                                         (unsigned char)0 );
7051
7052             _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
7053             _RetVal = *( HRESULT __RPC_FAR * )_StubMsg.Buffer;
7054             _StubMsg.Buffer += sizeof(HRESULT);
7055
7056             }
7057         RpcFinally
7058             {
7059             NdrProxyFreeBuffer(This, &_StubMsg);
7060
7061             }
7062         RpcEndFinally
7063
7064         }
7065     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
7066         {
7067         NdrClearOutParameters(
7068                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
7069                          ( PFORMAT_STRING  )&__MIDL_TypeFormatString.Format[1748],
7070                          ( void __RPC_FAR * )pCustData);
7071         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
7072         }
7073     RpcEndExcept
7074     return _RetVal;
7075 }
7076
7077 void __RPC_STUB ITypeInfo2_GetAllImplTypeCustData_Stub(
7078     IRpcStubBuffer *This,
7079     IRpcChannelBuffer *_pRpcChannelBuffer,
7080     PRPC_MESSAGE _pRpcMessage,
7081     DWORD *_pdwStubPhase)
7082 {
7083     HRESULT _RetVal;
7084     MIDL_STUB_MESSAGE _StubMsg;
7085     CUSTDATA _pCustDataM;
7086     UINT index;
7087     CUSTDATA __RPC_FAR *pCustData;
7088
7089 NdrStubInitialize(
7090                      _pRpcMessage,
7091                      &_StubMsg,
7092                      &Object_StubDesc,
7093                      _pRpcChannelBuffer);
7094     pCustData = 0;
7095     RpcTryFinally
7096         {
7097         if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
7098             NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[360] );
7099
7100         index = *( UINT __RPC_FAR * )_StubMsg.Buffer;
7101         _StubMsg.Buffer += sizeof(UINT);
7102
7103         pCustData = &_pCustDataM;
7104         pCustData -> prgCustData = 0;
7105
7106         *_pdwStubPhase = STUB_CALL_SERVER;
7107         _RetVal = (((ITypeInfo2*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> GetAllImplTypeCustData(
7108                           (ITypeInfo2 *) ((CStdStubBuffer *)This)->pvServerObject,
7109                           index,
7110                           pCustData);
7111
7112         *_pdwStubPhase = STUB_MARSHAL;
7113
7114         _StubMsg.BufferLength = 0U + 11U;
7115         NdrComplexStructBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
7116                                     (unsigned char __RPC_FAR *)pCustData,
7117                                     (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1788] );
7118
7119         _StubMsg.BufferLength += 16;
7120
7121         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
7122         NdrComplexStructMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
7123                                   (unsigned char __RPC_FAR *)pCustData,
7124                                   (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1788] );
7125
7126         _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
7127         *( HRESULT __RPC_FAR * )_StubMsg.Buffer = _RetVal;
7128         _StubMsg.Buffer += sizeof(HRESULT);
7129
7130         }
7131     RpcFinally
7132         {
7133         NdrPointerFree( &_StubMsg,
7134                         (unsigned char __RPC_FAR *)pCustData,
7135                         &__MIDL_TypeFormatString.Format[1748] );
7136
7137         }
7138     RpcEndFinally
7139     _pRpcMessage->BufferLength =
7140         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
7141
7142 }
7143
7144 static const CINTERFACE_PROXY_VTABLE(37) _ITypeInfo2ProxyVtbl =
7145 {
7146     { &IID_ITypeInfo2 },
7147     {
7148         IUnknown_QueryInterface_Proxy,
7149         IUnknown_AddRef_Proxy,
7150         IUnknown_Release_Proxy ,
7151         ITypeInfo_GetTypeAttr_Proxy ,
7152         ITypeInfo_GetTypeComp_Proxy ,
7153         ITypeInfo_GetFuncDesc_Proxy ,
7154         ITypeInfo_GetVarDesc_Proxy ,
7155         ITypeInfo_GetNames_Proxy ,
7156         ITypeInfo_GetRefTypeOfImplType_Proxy ,
7157         ITypeInfo_GetImplTypeFlags_Proxy ,
7158         ITypeInfo_GetIDsOfNames_Proxy ,
7159         ITypeInfo_Invoke_Proxy ,
7160         ITypeInfo_GetDocumentation_Proxy ,
7161         ITypeInfo_GetDllEntry_Proxy ,
7162         ITypeInfo_GetRefTypeInfo_Proxy ,
7163         ITypeInfo_AddressOfMember_Proxy ,
7164         ITypeInfo_CreateInstance_Proxy ,
7165         ITypeInfo_GetMops_Proxy ,
7166         ITypeInfo_GetContainingTypeLib_Proxy ,
7167         ITypeInfo_ReleaseTypeAttr_Proxy ,
7168         ITypeInfo_ReleaseFuncDesc_Proxy ,
7169         ITypeInfo_ReleaseVarDesc_Proxy ,
7170         ITypeInfo2_GetTypeKind_Proxy ,
7171         ITypeInfo2_GetTypeFlags_Proxy ,
7172         ITypeInfo2_GetFuncIndexOfMemId_Proxy ,
7173         ITypeInfo2_GetVarIndexOfMemId_Proxy ,
7174         ITypeInfo2_GetCustData_Proxy ,
7175         ITypeInfo2_GetFuncCustData_Proxy ,
7176         ITypeInfo2_GetParamCustData_Proxy ,
7177         ITypeInfo2_GetVarCustData_Proxy ,
7178         ITypeInfo2_GetImplTypeCustData_Proxy ,
7179         ITypeInfo2_GetDocumentation2_Proxy ,
7180         ITypeInfo2_GetAllCustData_Proxy ,
7181         ITypeInfo2_GetAllFuncCustData_Proxy ,
7182         ITypeInfo2_GetAllParamCustData_Proxy ,
7183         ITypeInfo2_GetAllVarCustData_Proxy ,
7184         ITypeInfo2_GetAllImplTypeCustData_Proxy
7185     }
7186 };
7187
7188
7189 static const PRPC_STUB_FUNCTION ITypeInfo2_table[] =
7190 {
7191     ITypeInfo_RemoteGetTypeAttr_Stub,
7192     ITypeInfo_GetTypeComp_Stub,
7193     ITypeInfo_RemoteGetFuncDesc_Stub,
7194     ITypeInfo_RemoteGetVarDesc_Stub,
7195     ITypeInfo_RemoteGetNames_Stub,
7196     ITypeInfo_GetRefTypeOfImplType_Stub,
7197     ITypeInfo_GetImplTypeFlags_Stub,
7198     ITypeInfo_LocalGetIDsOfNames_Stub,
7199     ITypeInfo_LocalInvoke_Stub,
7200     ITypeInfo_RemoteGetDocumentation_Stub,
7201     ITypeInfo_RemoteGetDllEntry_Stub,
7202     ITypeInfo_GetRefTypeInfo_Stub,
7203     ITypeInfo_LocalAddressOfMember_Stub,
7204     ITypeInfo_RemoteCreateInstance_Stub,
7205     ITypeInfo_GetMops_Stub,
7206     ITypeInfo_RemoteGetContainingTypeLib_Stub,
7207     ITypeInfo_LocalReleaseTypeAttr_Stub,
7208     ITypeInfo_LocalReleaseFuncDesc_Stub,
7209     ITypeInfo_LocalReleaseVarDesc_Stub,
7210     ITypeInfo2_GetTypeKind_Stub,
7211     ITypeInfo2_GetTypeFlags_Stub,
7212     ITypeInfo2_GetFuncIndexOfMemId_Stub,
7213     ITypeInfo2_GetVarIndexOfMemId_Stub,
7214     ITypeInfo2_GetCustData_Stub,
7215     ITypeInfo2_GetFuncCustData_Stub,
7216     ITypeInfo2_GetParamCustData_Stub,
7217     ITypeInfo2_GetVarCustData_Stub,
7218     ITypeInfo2_GetImplTypeCustData_Stub,
7219     ITypeInfo2_RemoteGetDocumentation2_Stub,
7220     ITypeInfo2_GetAllCustData_Stub,
7221     ITypeInfo2_GetAllFuncCustData_Stub,
7222     ITypeInfo2_GetAllParamCustData_Stub,
7223     ITypeInfo2_GetAllVarCustData_Stub,
7224     ITypeInfo2_GetAllImplTypeCustData_Stub
7225 };
7226
7227 static const CInterfaceStubVtbl _ITypeInfo2StubVtbl =
7228 {
7229     {
7230         &IID_ITypeInfo2,
7231         0,
7232         37,
7233         &ITypeInfo2_table[-3]
7234     },
7235     { CStdStubBuffer_METHODS }
7236 };
7237
7238
7239 /* Object interface: ITypeLib, ver. 0.0,
7240    GUID={0x00020402,0x0000,0x0000,{0xC0,0x00,0x00,0x00,0x00,0x00,0x00,0x46}} */
7241
7242
7243 extern const MIDL_STUB_DESC Object_StubDesc;
7244
7245
7246 /* [call_as] */ HRESULT STDMETHODCALLTYPE ITypeLib_RemoteGetTypeInfoCount_Proxy(
7247     ITypeLib __RPC_FAR * This,
7248     /* [out] */ UINT __RPC_FAR *pcTInfo)
7249 {
7250
7251     HRESULT _RetVal;
7252
7253     RPC_MESSAGE _RpcMessage;
7254
7255     MIDL_STUB_MESSAGE _StubMsg;
7256
7257     RpcTryExcept
7258         {
7259         NdrProxyInitialize(
7260                       ( void __RPC_FAR *  )This,
7261                       ( PRPC_MESSAGE  )&_RpcMessage,
7262                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
7263                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
7264                       3);
7265
7266
7267
7268         if(!pcTInfo)
7269             {
7270             RpcRaiseException(RPC_X_NULL_REF_POINTER);
7271             }
7272         RpcTryFinally
7273             {
7274
7275             _StubMsg.BufferLength = 0U;
7276             NdrProxyGetBuffer(This, &_StubMsg);
7277             NdrProxySendReceive(This, &_StubMsg);
7278
7279             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
7280                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[0] );
7281
7282             *pcTInfo = *( UINT __RPC_FAR * )_StubMsg.Buffer;
7283             _StubMsg.Buffer += sizeof(UINT);
7284
7285             _RetVal = *( HRESULT __RPC_FAR * )_StubMsg.Buffer;
7286             _StubMsg.Buffer += sizeof(HRESULT);
7287
7288             }
7289         RpcFinally
7290             {
7291             NdrProxyFreeBuffer(This, &_StubMsg);
7292
7293             }
7294         RpcEndFinally
7295
7296         }
7297     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
7298         {
7299         NdrClearOutParameters(
7300                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
7301                          ( PFORMAT_STRING  )&__MIDL_TypeFormatString.Format[2],
7302                          ( void __RPC_FAR * )pcTInfo);
7303         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
7304         }
7305     RpcEndExcept
7306     return _RetVal;
7307 }
7308
7309 void __RPC_STUB ITypeLib_RemoteGetTypeInfoCount_Stub(
7310     IRpcStubBuffer *This,
7311     IRpcChannelBuffer *_pRpcChannelBuffer,
7312     PRPC_MESSAGE _pRpcMessage,
7313     DWORD *_pdwStubPhase)
7314 {
7315     UINT _M61;
7316     HRESULT _RetVal;
7317     MIDL_STUB_MESSAGE _StubMsg;
7318     UINT __RPC_FAR *pcTInfo;
7319
7320 NdrStubInitialize(
7321                      _pRpcMessage,
7322                      &_StubMsg,
7323                      &Object_StubDesc,
7324                      _pRpcChannelBuffer);
7325     pcTInfo = 0;
7326     RpcTryFinally
7327         {
7328         pcTInfo = &_M61;
7329
7330         *_pdwStubPhase = STUB_CALL_SERVER;
7331
7332
7333         _RetVal = ITypeLib_GetTypeInfoCount_Stub((ITypeLib *) ((CStdStubBuffer *)This)->pvServerObject,pcTInfo);
7334
7335         *_pdwStubPhase = STUB_MARSHAL;
7336
7337         _StubMsg.BufferLength = 4U + 4U;
7338         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
7339         *( UINT __RPC_FAR * )_StubMsg.Buffer = *pcTInfo;
7340         _StubMsg.Buffer += sizeof(UINT);
7341
7342         *( HRESULT __RPC_FAR * )_StubMsg.Buffer = _RetVal;
7343         _StubMsg.Buffer += sizeof(HRESULT);
7344
7345         }
7346     RpcFinally
7347         {
7348         }
7349     RpcEndFinally
7350     _pRpcMessage->BufferLength =
7351         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
7352
7353 }
7354
7355
7356 HRESULT STDMETHODCALLTYPE ITypeLib_GetTypeInfo_Proxy(
7357     ITypeLib __RPC_FAR * This,
7358     /* [in] */ UINT index,
7359     /* [out] */ ITypeInfo __RPC_FAR *__RPC_FAR *ppTInfo)
7360 {
7361
7362     HRESULT _RetVal;
7363
7364     RPC_MESSAGE _RpcMessage;
7365
7366     MIDL_STUB_MESSAGE _StubMsg;
7367
7368     if(ppTInfo)
7369         {
7370         MIDL_memset(
7371                ppTInfo,
7372                0,
7373                sizeof( ITypeInfo __RPC_FAR *__RPC_FAR * ));
7374         }
7375     RpcTryExcept
7376         {
7377         NdrProxyInitialize(
7378                       ( void __RPC_FAR *  )This,
7379                       ( PRPC_MESSAGE  )&_RpcMessage,
7380                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
7381                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
7382                       4);
7383
7384
7385
7386         if(!ppTInfo)
7387             {
7388             RpcRaiseException(RPC_X_NULL_REF_POINTER);
7389             }
7390         RpcTryFinally
7391             {
7392
7393             _StubMsg.BufferLength = 4U;
7394             NdrProxyGetBuffer(This, &_StubMsg);
7395             *( UINT __RPC_FAR * )_StubMsg.Buffer = index;
7396             _StubMsg.Buffer += sizeof(UINT);
7397
7398             NdrProxySendReceive(This, &_StubMsg);
7399
7400             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
7401                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[246] );
7402
7403             NdrPointerUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
7404                                   (unsigned char __RPC_FAR * __RPC_FAR *)&ppTInfo,
7405                                   (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[6],
7406                                   (unsigned char)0 );
7407
7408             _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
7409             _RetVal = *( HRESULT __RPC_FAR * )_StubMsg.Buffer;
7410             _StubMsg.Buffer += sizeof(HRESULT);
7411
7412             }
7413         RpcFinally
7414             {
7415             NdrProxyFreeBuffer(This, &_StubMsg);
7416
7417             }
7418         RpcEndFinally
7419
7420         }
7421     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
7422         {
7423         NdrClearOutParameters(
7424                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
7425                          ( PFORMAT_STRING  )&__MIDL_TypeFormatString.Format[6],
7426                          ( void __RPC_FAR * )ppTInfo);
7427         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
7428         }
7429     RpcEndExcept
7430     return _RetVal;
7431 }
7432
7433 void __RPC_STUB ITypeLib_GetTypeInfo_Stub(
7434     IRpcStubBuffer *This,
7435     IRpcChannelBuffer *_pRpcChannelBuffer,
7436     PRPC_MESSAGE _pRpcMessage,
7437     DWORD *_pdwStubPhase)
7438 {
7439     ITypeInfo __RPC_FAR *_M62;
7440     HRESULT _RetVal;
7441     MIDL_STUB_MESSAGE _StubMsg;
7442     UINT index;
7443     ITypeInfo __RPC_FAR *__RPC_FAR *ppTInfo;
7444
7445 NdrStubInitialize(
7446                      _pRpcMessage,
7447                      &_StubMsg,
7448                      &Object_StubDesc,
7449                      _pRpcChannelBuffer);
7450     ppTInfo = 0;
7451     RpcTryFinally
7452         {
7453         if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
7454             NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[246] );
7455
7456         index = *( UINT __RPC_FAR * )_StubMsg.Buffer;
7457         _StubMsg.Buffer += sizeof(UINT);
7458
7459         ppTInfo = &_M62;
7460         _M62 = 0;
7461
7462         *_pdwStubPhase = STUB_CALL_SERVER;
7463         _RetVal = (((ITypeLib*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> GetTypeInfo(
7464                (ITypeLib *) ((CStdStubBuffer *)This)->pvServerObject,
7465                index,
7466                ppTInfo);
7467
7468         *_pdwStubPhase = STUB_MARSHAL;
7469
7470         _StubMsg.BufferLength = 0U + 4U;
7471         NdrPointerBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
7472                               (unsigned char __RPC_FAR *)ppTInfo,
7473                               (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[6] );
7474
7475         _StubMsg.BufferLength += 16;
7476
7477         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
7478         NdrPointerMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
7479                             (unsigned char __RPC_FAR *)ppTInfo,
7480                             (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[6] );
7481
7482         _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
7483         *( HRESULT __RPC_FAR * )_StubMsg.Buffer = _RetVal;
7484         _StubMsg.Buffer += sizeof(HRESULT);
7485
7486         }
7487     RpcFinally
7488         {
7489         NdrPointerFree( &_StubMsg,
7490                         (unsigned char __RPC_FAR *)ppTInfo,
7491                         &__MIDL_TypeFormatString.Format[6] );
7492
7493         }
7494     RpcEndFinally
7495     _pRpcMessage->BufferLength =
7496         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
7497
7498 }
7499
7500
7501 HRESULT STDMETHODCALLTYPE ITypeLib_GetTypeInfoType_Proxy(
7502     ITypeLib __RPC_FAR * This,
7503     /* [in] */ UINT index,
7504     /* [out] */ TYPEKIND __RPC_FAR *pTKind)
7505 {
7506
7507     HRESULT _RetVal;
7508
7509     RPC_MESSAGE _RpcMessage;
7510
7511     MIDL_STUB_MESSAGE _StubMsg;
7512
7513     RpcTryExcept
7514         {
7515         NdrProxyInitialize(
7516                       ( void __RPC_FAR *  )This,
7517                       ( PRPC_MESSAGE  )&_RpcMessage,
7518                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
7519                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
7520                       5);
7521
7522
7523
7524         if(!pTKind)
7525             {
7526             RpcRaiseException(RPC_X_NULL_REF_POINTER);
7527             }
7528         RpcTryFinally
7529             {
7530
7531             _StubMsg.BufferLength = 4U;
7532             NdrProxyGetBuffer(This, &_StubMsg);
7533             *( UINT __RPC_FAR * )_StubMsg.Buffer = index;
7534             _StubMsg.Buffer += sizeof(UINT);
7535
7536             NdrProxySendReceive(This, &_StubMsg);
7537
7538             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
7539                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[378] );
7540
7541             NdrPointerUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
7542                                   (unsigned char __RPC_FAR * __RPC_FAR *)&pTKind,
7543                                   (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1250],
7544                                   (unsigned char)0 );
7545
7546             _RetVal = *( HRESULT __RPC_FAR * )_StubMsg.Buffer;
7547             _StubMsg.Buffer += sizeof(HRESULT);
7548
7549             }
7550         RpcFinally
7551             {
7552             NdrProxyFreeBuffer(This, &_StubMsg);
7553
7554             }
7555         RpcEndFinally
7556
7557         }
7558     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
7559         {
7560         NdrClearOutParameters(
7561                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
7562                          ( PFORMAT_STRING  )&__MIDL_TypeFormatString.Format[1250],
7563                          ( void __RPC_FAR * )pTKind);
7564         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
7565         }
7566     RpcEndExcept
7567     return _RetVal;
7568 }
7569
7570 void __RPC_STUB ITypeLib_GetTypeInfoType_Stub(
7571     IRpcStubBuffer *This,
7572     IRpcChannelBuffer *_pRpcChannelBuffer,
7573     PRPC_MESSAGE _pRpcMessage,
7574     DWORD *_pdwStubPhase)
7575 {
7576     TYPEKIND _M63;
7577     HRESULT _RetVal;
7578     MIDL_STUB_MESSAGE _StubMsg;
7579     UINT index;
7580     TYPEKIND __RPC_FAR *pTKind;
7581
7582 NdrStubInitialize(
7583                      _pRpcMessage,
7584                      &_StubMsg,
7585                      &Object_StubDesc,
7586                      _pRpcChannelBuffer);
7587     pTKind = 0;
7588     RpcTryFinally
7589         {
7590         if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
7591             NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[378] );
7592
7593         index = *( UINT __RPC_FAR * )_StubMsg.Buffer;
7594         _StubMsg.Buffer += sizeof(UINT);
7595
7596         pTKind = &_M63;
7597
7598         *_pdwStubPhase = STUB_CALL_SERVER;
7599         _RetVal = (((ITypeLib*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> GetTypeInfoType(
7600                    (ITypeLib *) ((CStdStubBuffer *)This)->pvServerObject,
7601                    index,
7602                    pTKind);
7603
7604         *_pdwStubPhase = STUB_MARSHAL;
7605
7606         _StubMsg.BufferLength = 4U + 4U;
7607         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
7608         NdrPointerMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
7609                             (unsigned char __RPC_FAR *)pTKind,
7610                             (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1250] );
7611
7612         *( HRESULT __RPC_FAR * )_StubMsg.Buffer = _RetVal;
7613         _StubMsg.Buffer += sizeof(HRESULT);
7614
7615         }
7616     RpcFinally
7617         {
7618         }
7619     RpcEndFinally
7620     _pRpcMessage->BufferLength =
7621         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
7622
7623 }
7624
7625
7626 HRESULT STDMETHODCALLTYPE ITypeLib_GetTypeInfoOfGuid_Proxy(
7627     ITypeLib __RPC_FAR * This,
7628     /* [in] */ REFGUID guid,
7629     /* [out] */ ITypeInfo __RPC_FAR *__RPC_FAR *ppTinfo)
7630 {
7631
7632     HRESULT _RetVal;
7633
7634     RPC_MESSAGE _RpcMessage;
7635
7636     MIDL_STUB_MESSAGE _StubMsg;
7637
7638     if(ppTinfo)
7639         {
7640         MIDL_memset(
7641                ppTinfo,
7642                0,
7643                sizeof( ITypeInfo __RPC_FAR *__RPC_FAR * ));
7644         }
7645     RpcTryExcept
7646         {
7647         NdrProxyInitialize(
7648                       ( void __RPC_FAR *  )This,
7649                       ( PRPC_MESSAGE  )&_RpcMessage,
7650                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
7651                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
7652                       6);
7653
7654
7655
7656         if(!guid)
7657             {
7658             RpcRaiseException(RPC_X_NULL_REF_POINTER);
7659             }
7660         if(!ppTinfo)
7661             {
7662             RpcRaiseException(RPC_X_NULL_REF_POINTER);
7663             }
7664         RpcTryFinally
7665             {
7666
7667             _StubMsg.BufferLength = 0U;
7668             NdrSimpleStructBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
7669                                        (unsigned char __RPC_FAR *)guid,
7670                                        (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[38] );
7671
7672             NdrProxyGetBuffer(This, &_StubMsg);
7673             NdrSimpleStructMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
7674                                      (unsigned char __RPC_FAR *)guid,
7675                                      (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[38] );
7676
7677             NdrProxySendReceive(This, &_StubMsg);
7678
7679             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
7680                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[386] );
7681
7682             NdrPointerUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
7683                                   (unsigned char __RPC_FAR * __RPC_FAR *)&ppTinfo,
7684                                   (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[6],
7685                                   (unsigned char)0 );
7686
7687             _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
7688             _RetVal = *( HRESULT __RPC_FAR * )_StubMsg.Buffer;
7689             _StubMsg.Buffer += sizeof(HRESULT);
7690
7691             }
7692         RpcFinally
7693             {
7694             NdrProxyFreeBuffer(This, &_StubMsg);
7695
7696             }
7697         RpcEndFinally
7698
7699         }
7700     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
7701         {
7702         NdrClearOutParameters(
7703                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
7704                          ( PFORMAT_STRING  )&__MIDL_TypeFormatString.Format[6],
7705                          ( void __RPC_FAR * )ppTinfo);
7706         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
7707         }
7708     RpcEndExcept
7709     return _RetVal;
7710 }
7711
7712 void __RPC_STUB ITypeLib_GetTypeInfoOfGuid_Stub(
7713     IRpcStubBuffer *This,
7714     IRpcChannelBuffer *_pRpcChannelBuffer,
7715     PRPC_MESSAGE _pRpcMessage,
7716     DWORD *_pdwStubPhase)
7717 {
7718     ITypeInfo __RPC_FAR *_M64;
7719     HRESULT _RetVal;
7720     MIDL_STUB_MESSAGE _StubMsg;
7721     REFGUID guid = 0;
7722     ITypeInfo __RPC_FAR *__RPC_FAR *ppTinfo;
7723
7724 NdrStubInitialize(
7725                      _pRpcMessage,
7726                      &_StubMsg,
7727                      &Object_StubDesc,
7728                      _pRpcChannelBuffer);
7729     ppTinfo = 0;
7730     RpcTryFinally
7731         {
7732         if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
7733             NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[386] );
7734
7735         NdrSimpleStructUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
7736                                    (unsigned char __RPC_FAR * __RPC_FAR *)&guid,
7737                                    (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[38],
7738                                    (unsigned char)0 );
7739
7740         ppTinfo = &_M64;
7741         _M64 = 0;
7742
7743         *_pdwStubPhase = STUB_CALL_SERVER;
7744         _RetVal = (((ITypeLib*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> GetTypeInfoOfGuid(
7745                      (ITypeLib *) ((CStdStubBuffer *)This)->pvServerObject,
7746                      guid,
7747                      ppTinfo);
7748
7749         *_pdwStubPhase = STUB_MARSHAL;
7750
7751         _StubMsg.BufferLength = 0U + 4U;
7752         NdrPointerBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
7753                               (unsigned char __RPC_FAR *)ppTinfo,
7754                               (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[6] );
7755
7756         _StubMsg.BufferLength += 16;
7757
7758         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
7759         NdrPointerMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
7760                             (unsigned char __RPC_FAR *)ppTinfo,
7761                             (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[6] );
7762
7763         _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
7764         *( HRESULT __RPC_FAR * )_StubMsg.Buffer = _RetVal;
7765         _StubMsg.Buffer += sizeof(HRESULT);
7766
7767         }
7768     RpcFinally
7769         {
7770         NdrPointerFree( &_StubMsg,
7771                         (unsigned char __RPC_FAR *)ppTinfo,
7772                         &__MIDL_TypeFormatString.Format[6] );
7773
7774         }
7775     RpcEndFinally
7776     _pRpcMessage->BufferLength =
7777         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
7778
7779 }
7780
7781
7782 /* [call_as] */ HRESULT STDMETHODCALLTYPE ITypeLib_RemoteGetLibAttr_Proxy(
7783     ITypeLib __RPC_FAR * This,
7784     /* [out] */ LPTLIBATTR __RPC_FAR *ppTLibAttr,
7785     /* [out] */ CLEANLOCALSTORAGE __RPC_FAR *pDummy)
7786 {
7787
7788     HRESULT _RetVal;
7789
7790     RPC_MESSAGE _RpcMessage;
7791
7792     MIDL_STUB_MESSAGE _StubMsg;
7793
7794     if(ppTLibAttr)
7795         {
7796         *ppTLibAttr = 0;
7797         }
7798     if(pDummy)
7799         {
7800         MIDL_memset(
7801                pDummy,
7802                0,
7803                sizeof( CLEANLOCALSTORAGE  ));
7804         }
7805     RpcTryExcept
7806         {
7807         NdrProxyInitialize(
7808                       ( void __RPC_FAR *  )This,
7809                       ( PRPC_MESSAGE  )&_RpcMessage,
7810                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
7811                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
7812                       7);
7813
7814
7815
7816         if(!ppTLibAttr)
7817             {
7818             RpcRaiseException(RPC_X_NULL_REF_POINTER);
7819             }
7820         if(!pDummy)
7821             {
7822             RpcRaiseException(RPC_X_NULL_REF_POINTER);
7823             }
7824         RpcTryFinally
7825             {
7826
7827             _StubMsg.BufferLength = 0U;
7828             NdrProxyGetBuffer(This, &_StubMsg);
7829             NdrProxySendReceive(This, &_StubMsg);
7830
7831             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
7832                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[396] );
7833
7834             NdrPointerUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
7835                                   (unsigned char __RPC_FAR * __RPC_FAR *)&ppTLibAttr,
7836                                   (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1804],
7837                                   (unsigned char)0 );
7838
7839             NdrUserMarshalUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
7840                                       (unsigned char __RPC_FAR * __RPC_FAR *)&pDummy,
7841                                       (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1838],
7842                                       (unsigned char)0 );
7843
7844             _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
7845             _RetVal = *( HRESULT __RPC_FAR * )_StubMsg.Buffer;
7846             _StubMsg.Buffer += sizeof(HRESULT);
7847
7848             }
7849         RpcFinally
7850             {
7851             NdrProxyFreeBuffer(This, &_StubMsg);
7852
7853             }
7854         RpcEndFinally
7855
7856         }
7857     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
7858         {
7859         NdrClearOutParameters(
7860                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
7861                          ( PFORMAT_STRING  )&__MIDL_TypeFormatString.Format[1804],
7862                          ( void __RPC_FAR * )ppTLibAttr);
7863         NdrClearOutParameters(
7864                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
7865                          ( PFORMAT_STRING  )&__MIDL_TypeFormatString.Format[1832],
7866                          ( void __RPC_FAR * )pDummy);
7867         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
7868         }
7869     RpcEndExcept
7870     return _RetVal;
7871 }
7872
7873 void __RPC_STUB ITypeLib_RemoteGetLibAttr_Stub(
7874     IRpcStubBuffer *This,
7875     IRpcChannelBuffer *_pRpcChannelBuffer,
7876     PRPC_MESSAGE _pRpcMessage,
7877     DWORD *_pdwStubPhase)
7878 {
7879     LPTLIBATTR _M65;
7880     CLEANLOCALSTORAGE _M66;
7881     HRESULT _RetVal;
7882     MIDL_STUB_MESSAGE _StubMsg;
7883     CLEANLOCALSTORAGE __RPC_FAR *pDummy;
7884     LPTLIBATTR __RPC_FAR *ppTLibAttr;
7885
7886 NdrStubInitialize(
7887                      _pRpcMessage,
7888                      &_StubMsg,
7889                      &Object_StubDesc,
7890                      _pRpcChannelBuffer);
7891     ppTLibAttr = 0;
7892     pDummy = 0;
7893     RpcTryFinally
7894         {
7895         ppTLibAttr = &_M65;
7896         _M65 = 0;
7897         pDummy = &_M66;
7898         MIDL_memset(
7899                pDummy,
7900                0,
7901                sizeof( CLEANLOCALSTORAGE  ));
7902
7903         *_pdwStubPhase = STUB_CALL_SERVER;
7904
7905
7906         _RetVal = ITypeLib_GetLibAttr_Stub(
7907                                    (ITypeLib *) ((CStdStubBuffer *)This)->pvServerObject,
7908                                    ppTLibAttr,
7909                                    pDummy);
7910
7911         *_pdwStubPhase = STUB_MARSHAL;
7912
7913         _StubMsg.BufferLength = 8U + 11U + 7U;
7914         NdrPointerBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
7915                               (unsigned char __RPC_FAR *)ppTLibAttr,
7916                               (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1804] );
7917
7918         _StubMsg.BufferLength += 16;
7919
7920         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
7921         NdrPointerMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
7922                             (unsigned char __RPC_FAR *)ppTLibAttr,
7923                             (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1804] );
7924
7925         NdrUserMarshalMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
7926                                 (unsigned char __RPC_FAR *)pDummy,
7927                                 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1838] );
7928
7929         _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
7930         *( HRESULT __RPC_FAR * )_StubMsg.Buffer = _RetVal;
7931         _StubMsg.Buffer += sizeof(HRESULT);
7932
7933         }
7934     RpcFinally
7935         {
7936         NdrPointerFree( &_StubMsg,
7937                         (unsigned char __RPC_FAR *)ppTLibAttr,
7938                         &__MIDL_TypeFormatString.Format[1804] );
7939
7940         NdrPointerFree( &_StubMsg,
7941                         (unsigned char __RPC_FAR *)pDummy,
7942                         &__MIDL_TypeFormatString.Format[1832] );
7943
7944         }
7945     RpcEndFinally
7946     _pRpcMessage->BufferLength =
7947         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
7948
7949 }
7950
7951
7952 HRESULT STDMETHODCALLTYPE ITypeLib_GetTypeComp_Proxy(
7953     ITypeLib __RPC_FAR * This,
7954     /* [out] */ ITypeComp __RPC_FAR *__RPC_FAR *ppTComp)
7955 {
7956
7957     HRESULT _RetVal;
7958
7959     RPC_MESSAGE _RpcMessage;
7960
7961     MIDL_STUB_MESSAGE _StubMsg;
7962
7963     if(ppTComp)
7964         {
7965         MIDL_memset(
7966                ppTComp,
7967                0,
7968                sizeof( ITypeComp __RPC_FAR *__RPC_FAR * ));
7969         }
7970     RpcTryExcept
7971         {
7972         NdrProxyInitialize(
7973                       ( void __RPC_FAR *  )This,
7974                       ( PRPC_MESSAGE  )&_RpcMessage,
7975                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
7976                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
7977                       8);
7978
7979
7980
7981         if(!ppTComp)
7982             {
7983             RpcRaiseException(RPC_X_NULL_REF_POINTER);
7984             }
7985         RpcTryFinally
7986             {
7987
7988             _StubMsg.BufferLength = 0U;
7989             NdrProxyGetBuffer(This, &_StubMsg);
7990             NdrProxySendReceive(This, &_StubMsg);
7991
7992             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
7993                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[152] );
7994
7995             NdrPointerUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
7996                                   (unsigned char __RPC_FAR * __RPC_FAR *)&ppTComp,
7997                                   (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1540],
7998                                   (unsigned char)0 );
7999
8000             _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
8001             _RetVal = *( HRESULT __RPC_FAR * )_StubMsg.Buffer;
8002             _StubMsg.Buffer += sizeof(HRESULT);
8003
8004             }
8005         RpcFinally
8006             {
8007             NdrProxyFreeBuffer(This, &_StubMsg);
8008
8009             }
8010         RpcEndFinally
8011
8012         }
8013     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
8014         {
8015         NdrClearOutParameters(
8016                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
8017                          ( PFORMAT_STRING  )&__MIDL_TypeFormatString.Format[1540],
8018                          ( void __RPC_FAR * )ppTComp);
8019         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
8020         }
8021     RpcEndExcept
8022     return _RetVal;
8023 }
8024
8025 void __RPC_STUB ITypeLib_GetTypeComp_Stub(
8026     IRpcStubBuffer *This,
8027     IRpcChannelBuffer *_pRpcChannelBuffer,
8028     PRPC_MESSAGE _pRpcMessage,
8029     DWORD *_pdwStubPhase)
8030 {
8031     ITypeComp __RPC_FAR *_M67;
8032     HRESULT _RetVal;
8033     MIDL_STUB_MESSAGE _StubMsg;
8034     ITypeComp __RPC_FAR *__RPC_FAR *ppTComp;
8035
8036 NdrStubInitialize(
8037                      _pRpcMessage,
8038                      &_StubMsg,
8039                      &Object_StubDesc,
8040                      _pRpcChannelBuffer);
8041     ppTComp = 0;
8042     RpcTryFinally
8043         {
8044         ppTComp = &_M67;
8045         _M67 = 0;
8046
8047         *_pdwStubPhase = STUB_CALL_SERVER;
8048         _RetVal = (((ITypeLib*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> GetTypeComp((ITypeLib *) ((CStdStubBuffer *)This)->pvServerObject,ppTComp);
8049
8050         *_pdwStubPhase = STUB_MARSHAL;
8051
8052         _StubMsg.BufferLength = 0U + 4U;
8053         NdrPointerBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
8054                               (unsigned char __RPC_FAR *)ppTComp,
8055                               (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1540] );
8056
8057         _StubMsg.BufferLength += 16;
8058
8059         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
8060         NdrPointerMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
8061                             (unsigned char __RPC_FAR *)ppTComp,
8062                             (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1540] );
8063
8064         _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
8065         *( HRESULT __RPC_FAR * )_StubMsg.Buffer = _RetVal;
8066         _StubMsg.Buffer += sizeof(HRESULT);
8067
8068         }
8069     RpcFinally
8070         {
8071         NdrPointerFree( &_StubMsg,
8072                         (unsigned char __RPC_FAR *)ppTComp,
8073                         &__MIDL_TypeFormatString.Format[1540] );
8074
8075         }
8076     RpcEndFinally
8077     _pRpcMessage->BufferLength =
8078         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
8079
8080 }
8081
8082
8083 /* [call_as] */ HRESULT STDMETHODCALLTYPE ITypeLib_RemoteGetDocumentation_Proxy(
8084     ITypeLib __RPC_FAR * This,
8085     /* [in] */ INT index,
8086     /* [in] */ DWORD refPtrFlags,
8087     /* [out] */ BSTR __RPC_FAR *pBstrName,
8088     /* [out] */ BSTR __RPC_FAR *pBstrDocString,
8089     /* [out] */ DWORD __RPC_FAR *pdwHelpContext,
8090     /* [out] */ BSTR __RPC_FAR *pBstrHelpFile)
8091 {
8092
8093     HRESULT _RetVal;
8094
8095     RPC_MESSAGE _RpcMessage;
8096
8097     MIDL_STUB_MESSAGE _StubMsg;
8098
8099     if(pBstrName)
8100         {
8101         MIDL_memset(
8102                pBstrName,
8103                0,
8104                sizeof( BSTR  ));
8105         }
8106     if(pBstrDocString)
8107         {
8108         MIDL_memset(
8109                pBstrDocString,
8110                0,
8111                sizeof( BSTR  ));
8112         }
8113     if(pBstrHelpFile)
8114         {
8115         MIDL_memset(
8116                pBstrHelpFile,
8117                0,
8118                sizeof( BSTR  ));
8119         }
8120     RpcTryExcept
8121         {
8122         NdrProxyInitialize(
8123                       ( void __RPC_FAR *  )This,
8124                       ( PRPC_MESSAGE  )&_RpcMessage,
8125                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
8126                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
8127                       9);
8128
8129
8130
8131         if(!pBstrName)
8132             {
8133             RpcRaiseException(RPC_X_NULL_REF_POINTER);
8134             }
8135         if(!pBstrDocString)
8136             {
8137             RpcRaiseException(RPC_X_NULL_REF_POINTER);
8138             }
8139         if(!pdwHelpContext)
8140             {
8141             RpcRaiseException(RPC_X_NULL_REF_POINTER);
8142             }
8143         if(!pBstrHelpFile)
8144             {
8145             RpcRaiseException(RPC_X_NULL_REF_POINTER);
8146             }
8147         RpcTryFinally
8148             {
8149
8150             _StubMsg.BufferLength = 4U + 4U;
8151             NdrProxyGetBuffer(This, &_StubMsg);
8152             *( INT __RPC_FAR * )_StubMsg.Buffer = index;
8153             _StubMsg.Buffer += sizeof(INT);
8154
8155             *( DWORD __RPC_FAR * )_StubMsg.Buffer = refPtrFlags;
8156             _StubMsg.Buffer += sizeof(DWORD);
8157
8158             NdrProxySendReceive(This, &_StubMsg);
8159
8160             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
8161                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[204] );
8162
8163             NdrUserMarshalUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
8164                                       (unsigned char __RPC_FAR * __RPC_FAR *)&pBstrName,
8165                                       (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1128],
8166                                       (unsigned char)0 );
8167
8168             NdrUserMarshalUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
8169                                       (unsigned char __RPC_FAR * __RPC_FAR *)&pBstrDocString,
8170                                       (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1128],
8171                                       (unsigned char)0 );
8172
8173             _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
8174             *pdwHelpContext = *( DWORD __RPC_FAR * )_StubMsg.Buffer;
8175             _StubMsg.Buffer += sizeof(DWORD);
8176
8177             NdrUserMarshalUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
8178                                       (unsigned char __RPC_FAR * __RPC_FAR *)&pBstrHelpFile,
8179                                       (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1128],
8180                                       (unsigned char)0 );
8181
8182             _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
8183             _RetVal = *( HRESULT __RPC_FAR * )_StubMsg.Buffer;
8184             _StubMsg.Buffer += sizeof(HRESULT);
8185
8186             }
8187         RpcFinally
8188             {
8189             NdrProxyFreeBuffer(This, &_StubMsg);
8190
8191             }
8192         RpcEndFinally
8193
8194         }
8195     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
8196         {
8197         NdrClearOutParameters(
8198                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
8199                          ( PFORMAT_STRING  )&__MIDL_TypeFormatString.Format[1708],
8200                          ( void __RPC_FAR * )pBstrName);
8201         NdrClearOutParameters(
8202                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
8203                          ( PFORMAT_STRING  )&__MIDL_TypeFormatString.Format[1708],
8204                          ( void __RPC_FAR * )pBstrDocString);
8205         NdrClearOutParameters(
8206                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
8207                          ( PFORMAT_STRING  )&__MIDL_TypeFormatString.Format[2],
8208                          ( void __RPC_FAR * )pdwHelpContext);
8209         NdrClearOutParameters(
8210                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
8211                          ( PFORMAT_STRING  )&__MIDL_TypeFormatString.Format[1708],
8212                          ( void __RPC_FAR * )pBstrHelpFile);
8213         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
8214         }
8215     RpcEndExcept
8216     return _RetVal;
8217 }
8218
8219 void __RPC_STUB ITypeLib_RemoteGetDocumentation_Stub(
8220     IRpcStubBuffer *This,
8221     IRpcChannelBuffer *_pRpcChannelBuffer,
8222     PRPC_MESSAGE _pRpcMessage,
8223     DWORD *_pdwStubPhase)
8224 {
8225     BSTR _M68;
8226     BSTR _M69;
8227     DWORD _M70;
8228     BSTR _M71;
8229     HRESULT _RetVal;
8230     MIDL_STUB_MESSAGE _StubMsg;
8231     INT index;
8232     BSTR __RPC_FAR *pBstrDocString;
8233     BSTR __RPC_FAR *pBstrHelpFile;
8234     BSTR __RPC_FAR *pBstrName;
8235     DWORD __RPC_FAR *pdwHelpContext;
8236     DWORD refPtrFlags;
8237
8238 NdrStubInitialize(
8239                      _pRpcMessage,
8240                      &_StubMsg,
8241                      &Object_StubDesc,
8242                      _pRpcChannelBuffer);
8243     pBstrName = 0;
8244     pBstrDocString = 0;
8245     pdwHelpContext = 0;
8246     pBstrHelpFile = 0;
8247     RpcTryFinally
8248         {
8249         if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
8250             NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[204] );
8251
8252         index = *( INT __RPC_FAR * )_StubMsg.Buffer;
8253         _StubMsg.Buffer += sizeof(INT);
8254
8255         refPtrFlags = *( DWORD __RPC_FAR * )_StubMsg.Buffer;
8256         _StubMsg.Buffer += sizeof(DWORD);
8257
8258         pBstrName = &_M68;
8259         MIDL_memset(
8260                pBstrName,
8261                0,
8262                sizeof( BSTR  ));
8263         pBstrDocString = &_M69;
8264         MIDL_memset(
8265                pBstrDocString,
8266                0,
8267                sizeof( BSTR  ));
8268         pdwHelpContext = &_M70;
8269         pBstrHelpFile = &_M71;
8270         MIDL_memset(
8271                pBstrHelpFile,
8272                0,
8273                sizeof( BSTR  ));
8274
8275         *_pdwStubPhase = STUB_CALL_SERVER;
8276
8277
8278         _RetVal = ITypeLib_GetDocumentation_Stub(
8279                                          (ITypeLib *) ((CStdStubBuffer *)This)->pvServerObject,
8280                                          index,
8281                                          refPtrFlags,
8282                                          pBstrName,
8283                                          pBstrDocString,
8284                                          pdwHelpContext,
8285                                          pBstrHelpFile);
8286
8287         *_pdwStubPhase = STUB_MARSHAL;
8288
8289         _StubMsg.BufferLength = 8U + 15U + 11U + 11U + 11U;
8290         NdrUserMarshalBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
8291                                   (unsigned char __RPC_FAR *)pBstrName,
8292                                   (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1128] );
8293
8294         NdrUserMarshalBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
8295                                   (unsigned char __RPC_FAR *)pBstrDocString,
8296                                   (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1128] );
8297
8298         NdrUserMarshalBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
8299                                   (unsigned char __RPC_FAR *)pBstrHelpFile,
8300                                   (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1128] );
8301
8302         _StubMsg.BufferLength += 16;
8303
8304         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
8305         NdrUserMarshalMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
8306                                 (unsigned char __RPC_FAR *)pBstrName,
8307                                 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1128] );
8308
8309         NdrUserMarshalMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
8310                                 (unsigned char __RPC_FAR *)pBstrDocString,
8311                                 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1128] );
8312
8313         _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
8314         *( DWORD __RPC_FAR * )_StubMsg.Buffer = *pdwHelpContext;
8315         _StubMsg.Buffer += sizeof(DWORD);
8316
8317         NdrUserMarshalMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
8318                                 (unsigned char __RPC_FAR *)pBstrHelpFile,
8319                                 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1128] );
8320
8321         _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
8322         *( HRESULT __RPC_FAR * )_StubMsg.Buffer = _RetVal;
8323         _StubMsg.Buffer += sizeof(HRESULT);
8324
8325         }
8326     RpcFinally
8327         {
8328         NdrPointerFree( &_StubMsg,
8329                         (unsigned char __RPC_FAR *)pBstrName,
8330                         &__MIDL_TypeFormatString.Format[1708] );
8331
8332         NdrPointerFree( &_StubMsg,
8333                         (unsigned char __RPC_FAR *)pBstrDocString,
8334                         &__MIDL_TypeFormatString.Format[1708] );
8335
8336         NdrPointerFree( &_StubMsg,
8337                         (unsigned char __RPC_FAR *)pBstrHelpFile,
8338                         &__MIDL_TypeFormatString.Format[1708] );
8339
8340         }
8341     RpcEndFinally
8342     _pRpcMessage->BufferLength =
8343         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
8344
8345 }
8346
8347
8348 /* [call_as] */ HRESULT STDMETHODCALLTYPE ITypeLib_RemoteIsName_Proxy(
8349     ITypeLib __RPC_FAR * This,
8350     /* [in] */ LPOLESTR szNameBuf,
8351     /* [in] */ ULONG lHashVal,
8352     /* [out] */ BOOL __RPC_FAR *pfName,
8353     /* [out] */ BSTR __RPC_FAR *pBstrLibName)
8354 {
8355
8356     HRESULT _RetVal;
8357
8358     RPC_MESSAGE _RpcMessage;
8359
8360     MIDL_STUB_MESSAGE _StubMsg;
8361
8362     if(pBstrLibName)
8363         {
8364         MIDL_memset(
8365                pBstrLibName,
8366                0,
8367                sizeof( BSTR  ));
8368         }
8369     RpcTryExcept
8370         {
8371         NdrProxyInitialize(
8372                       ( void __RPC_FAR *  )This,
8373                       ( PRPC_MESSAGE  )&_RpcMessage,
8374                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
8375                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
8376                       10);
8377
8378
8379
8380         if(!szNameBuf)
8381             {
8382             RpcRaiseException(RPC_X_NULL_REF_POINTER);
8383             }
8384         if(!pfName)
8385             {
8386             RpcRaiseException(RPC_X_NULL_REF_POINTER);
8387             }
8388         if(!pBstrLibName)
8389             {
8390             RpcRaiseException(RPC_X_NULL_REF_POINTER);
8391             }
8392         RpcTryFinally
8393             {
8394
8395             _StubMsg.BufferLength = 12U + 10U;
8396             NdrConformantStringBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
8397                                            (unsigned char __RPC_FAR *)szNameBuf,
8398                                            (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1248] );
8399
8400             NdrProxyGetBuffer(This, &_StubMsg);
8401             NdrConformantStringMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
8402                                          (unsigned char __RPC_FAR *)szNameBuf,
8403                                          (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1248] );
8404
8405             _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
8406             *( ULONG __RPC_FAR * )_StubMsg.Buffer = lHashVal;
8407             _StubMsg.Buffer += sizeof(ULONG);
8408
8409             NdrProxySendReceive(This, &_StubMsg);
8410
8411             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
8412                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[406] );
8413
8414             *pfName = *( BOOL __RPC_FAR * )_StubMsg.Buffer;
8415             _StubMsg.Buffer += sizeof(BOOL);
8416
8417             NdrUserMarshalUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
8418                                       (unsigned char __RPC_FAR * __RPC_FAR *)&pBstrLibName,
8419                                       (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1128],
8420                                       (unsigned char)0 );
8421
8422             _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
8423             _RetVal = *( HRESULT __RPC_FAR * )_StubMsg.Buffer;
8424             _StubMsg.Buffer += sizeof(HRESULT);
8425
8426             }
8427         RpcFinally
8428             {
8429             NdrProxyFreeBuffer(This, &_StubMsg);
8430
8431             }
8432         RpcEndFinally
8433
8434         }
8435     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
8436         {
8437         NdrClearOutParameters(
8438                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
8439                          ( PFORMAT_STRING  )&__MIDL_TypeFormatString.Format[2],
8440                          ( void __RPC_FAR * )pfName);
8441         NdrClearOutParameters(
8442                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
8443                          ( PFORMAT_STRING  )&__MIDL_TypeFormatString.Format[1708],
8444                          ( void __RPC_FAR * )pBstrLibName);
8445         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
8446         }
8447     RpcEndExcept
8448     return _RetVal;
8449 }
8450
8451 void __RPC_STUB ITypeLib_RemoteIsName_Stub(
8452     IRpcStubBuffer *This,
8453     IRpcChannelBuffer *_pRpcChannelBuffer,
8454     PRPC_MESSAGE _pRpcMessage,
8455     DWORD *_pdwStubPhase)
8456 {
8457     BOOL _M74;
8458     BSTR _M75;
8459     HRESULT _RetVal;
8460     MIDL_STUB_MESSAGE _StubMsg;
8461     ULONG lHashVal;
8462     BSTR __RPC_FAR *pBstrLibName;
8463     BOOL __RPC_FAR *pfName;
8464     LPOLESTR szNameBuf;
8465
8466 NdrStubInitialize(
8467                      _pRpcMessage,
8468                      &_StubMsg,
8469                      &Object_StubDesc,
8470                      _pRpcChannelBuffer);
8471     szNameBuf = 0;
8472     pfName = 0;
8473     pBstrLibName = 0;
8474     RpcTryFinally
8475         {
8476         if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
8477             NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[406] );
8478
8479         NdrConformantStringUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
8480                                        (unsigned char __RPC_FAR * __RPC_FAR *)&szNameBuf,
8481                                        (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1248],
8482                                        (unsigned char)0 );
8483
8484         _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
8485         lHashVal = *( ULONG __RPC_FAR * )_StubMsg.Buffer;
8486         _StubMsg.Buffer += sizeof(ULONG);
8487
8488         pfName = &_M74;
8489         pBstrLibName = &_M75;
8490         MIDL_memset(
8491                pBstrLibName,
8492                0,
8493                sizeof( BSTR  ));
8494
8495         *_pdwStubPhase = STUB_CALL_SERVER;
8496
8497
8498         _RetVal = ITypeLib_IsName_Stub(
8499                                (ITypeLib *) ((CStdStubBuffer *)This)->pvServerObject,
8500                                szNameBuf,
8501                                lHashVal,
8502                                pfName,
8503                                pBstrLibName);
8504
8505         *_pdwStubPhase = STUB_MARSHAL;
8506
8507         _StubMsg.BufferLength = 4U + 4U + 11U;
8508         NdrUserMarshalBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
8509                                   (unsigned char __RPC_FAR *)pBstrLibName,
8510                                   (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1128] );
8511
8512         _StubMsg.BufferLength += 16;
8513
8514         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
8515         *( BOOL __RPC_FAR * )_StubMsg.Buffer = *pfName;
8516         _StubMsg.Buffer += sizeof(BOOL);
8517
8518         NdrUserMarshalMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
8519                                 (unsigned char __RPC_FAR *)pBstrLibName,
8520                                 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1128] );
8521
8522         _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
8523         *( HRESULT __RPC_FAR * )_StubMsg.Buffer = _RetVal;
8524         _StubMsg.Buffer += sizeof(HRESULT);
8525
8526         }
8527     RpcFinally
8528         {
8529         NdrPointerFree( &_StubMsg,
8530                         (unsigned char __RPC_FAR *)pBstrLibName,
8531                         &__MIDL_TypeFormatString.Format[1708] );
8532
8533         }
8534     RpcEndFinally
8535     _pRpcMessage->BufferLength =
8536         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
8537
8538 }
8539
8540
8541 /* [call_as] */ HRESULT STDMETHODCALLTYPE ITypeLib_RemoteFindName_Proxy(
8542     ITypeLib __RPC_FAR * This,
8543     /* [in] */ LPOLESTR szNameBuf,
8544     /* [in] */ ULONG lHashVal,
8545     /* [length_is][size_is][out] */ ITypeInfo __RPC_FAR *__RPC_FAR *ppTInfo,
8546     /* [length_is][size_is][out] */ MEMBERID __RPC_FAR *rgMemId,
8547     /* [out][in] */ USHORT __RPC_FAR *pcFound,
8548     /* [out] */ BSTR __RPC_FAR *pBstrLibName)
8549 {
8550
8551     HRESULT _RetVal;
8552
8553     RPC_MESSAGE _RpcMessage;
8554
8555     MIDL_STUB_MESSAGE _StubMsg;
8556
8557     if(ppTInfo)
8558         {
8559         MIDL_memset(
8560                ppTInfo,
8561                0,
8562                *pcFound * sizeof( ITypeInfo __RPC_FAR *__RPC_FAR * ));
8563         }
8564     if(pBstrLibName)
8565         {
8566         MIDL_memset(
8567                pBstrLibName,
8568                0,
8569                sizeof( BSTR  ));
8570         }
8571     RpcTryExcept
8572         {
8573         NdrProxyInitialize(
8574                       ( void __RPC_FAR *  )This,
8575                       ( PRPC_MESSAGE  )&_RpcMessage,
8576                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
8577                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
8578                       11);
8579
8580
8581
8582         if(!szNameBuf)
8583             {
8584             RpcRaiseException(RPC_X_NULL_REF_POINTER);
8585             }
8586         if(!ppTInfo)
8587             {
8588             RpcRaiseException(RPC_X_NULL_REF_POINTER);
8589             }
8590         if(!rgMemId)
8591             {
8592             RpcRaiseException(RPC_X_NULL_REF_POINTER);
8593             }
8594         if(!pcFound)
8595             {
8596             RpcRaiseException(RPC_X_NULL_REF_POINTER);
8597             }
8598         if(!pBstrLibName)
8599             {
8600             RpcRaiseException(RPC_X_NULL_REF_POINTER);
8601             }
8602         RpcTryFinally
8603             {
8604
8605             _StubMsg.BufferLength = 12U + 10U + 4U;
8606             NdrConformantStringBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
8607                                            (unsigned char __RPC_FAR *)szNameBuf,
8608                                            (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1248] );
8609
8610             NdrProxyGetBuffer(This, &_StubMsg);
8611             NdrConformantStringMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
8612                                          (unsigned char __RPC_FAR *)szNameBuf,
8613                                          (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1248] );
8614
8615             _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
8616             *( ULONG __RPC_FAR * )_StubMsg.Buffer = lHashVal;
8617             _StubMsg.Buffer += sizeof(ULONG);
8618
8619             *( USHORT __RPC_FAR * )_StubMsg.Buffer = *pcFound;
8620             _StubMsg.Buffer += sizeof(USHORT);
8621
8622             NdrProxySendReceive(This, &_StubMsg);
8623
8624             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
8625                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[422] );
8626
8627             NdrComplexArrayUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
8628                                        (unsigned char __RPC_FAR * __RPC_FAR *)&ppTInfo,
8629                                        (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1852],
8630                                        (unsigned char)0 );
8631
8632             NdrConformantVaryingArrayUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
8633                                                  (unsigned char __RPC_FAR * __RPC_FAR *)&rgMemId,
8634                                                  (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1874],
8635                                                  (unsigned char)0 );
8636
8637             *pcFound = *( USHORT __RPC_FAR * )_StubMsg.Buffer;
8638             _StubMsg.Buffer += sizeof(USHORT);
8639
8640             NdrUserMarshalUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
8641                                       (unsigned char __RPC_FAR * __RPC_FAR *)&pBstrLibName,
8642                                       (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1128],
8643                                       (unsigned char)0 );
8644
8645             _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
8646             _RetVal = *( HRESULT __RPC_FAR * )_StubMsg.Buffer;
8647             _StubMsg.Buffer += sizeof(HRESULT);
8648
8649             }
8650         RpcFinally
8651             {
8652             NdrProxyFreeBuffer(This, &_StubMsg);
8653
8654             }
8655         RpcEndFinally
8656
8657         }
8658     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
8659         {
8660         _StubMsg.MaxCount = pcFound ? *pcFound : 0;
8661         _StubMsg.Offset = 0;
8662         _StubMsg.ActualCount = _StubMsg.MaxCount;
8663
8664         NdrClearOutParameters(
8665                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
8666                          ( PFORMAT_STRING  )&__MIDL_TypeFormatString.Format[1848],
8667                          ( void __RPC_FAR * )ppTInfo);
8668         _StubMsg.MaxCount = pcFound ? *pcFound : 0;
8669         _StubMsg.Offset = 0;
8670         _StubMsg.ActualCount = _StubMsg.MaxCount;
8671
8672         NdrClearOutParameters(
8673                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
8674                          ( PFORMAT_STRING  )&__MIDL_TypeFormatString.Format[1870],
8675                          ( void __RPC_FAR * )rgMemId);
8676         NdrClearOutParameters(
8677                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
8678                          ( PFORMAT_STRING  )&__MIDL_TypeFormatString.Format[1888],
8679                          ( void __RPC_FAR * )pcFound);
8680         NdrClearOutParameters(
8681                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
8682                          ( PFORMAT_STRING  )&__MIDL_TypeFormatString.Format[1708],
8683                          ( void __RPC_FAR * )pBstrLibName);
8684         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
8685         }
8686     RpcEndExcept
8687     return _RetVal;
8688 }
8689
8690 void __RPC_STUB ITypeLib_RemoteFindName_Stub(
8691     IRpcStubBuffer *This,
8692     IRpcChannelBuffer *_pRpcChannelBuffer,
8693     PRPC_MESSAGE _pRpcMessage,
8694     DWORD *_pdwStubPhase)
8695 {
8696     BSTR _M84;
8697     HRESULT _RetVal;
8698     MIDL_STUB_MESSAGE _StubMsg;
8699     ULONG lHashVal;
8700     BSTR __RPC_FAR *pBstrLibName;
8701     USHORT __RPC_FAR *pcFound;
8702     ITypeInfo __RPC_FAR *__RPC_FAR *ppTInfo;
8703     MEMBERID __RPC_FAR *rgMemId;
8704     LPOLESTR szNameBuf;
8705
8706 NdrStubInitialize(
8707                      _pRpcMessage,
8708                      &_StubMsg,
8709                      &Object_StubDesc,
8710                      _pRpcChannelBuffer);
8711     szNameBuf = 0;
8712     ppTInfo = 0;
8713     rgMemId = 0;
8714     pcFound = 0;
8715     pBstrLibName = 0;
8716     RpcTryFinally
8717         {
8718         if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
8719             NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[422] );
8720
8721         NdrConformantStringUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
8722                                        (unsigned char __RPC_FAR * __RPC_FAR *)&szNameBuf,
8723                                        (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1248],
8724                                        (unsigned char)0 );
8725
8726         _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
8727         lHashVal = *( ULONG __RPC_FAR * )_StubMsg.Buffer;
8728         _StubMsg.Buffer += sizeof(ULONG);
8729
8730         pcFound = ( USHORT __RPC_FAR * )_StubMsg.Buffer;
8731         _StubMsg.Buffer += sizeof( USHORT  );
8732
8733         ppTInfo = NdrAllocate(&_StubMsg,*pcFound * 4);
8734         rgMemId = NdrAllocate(&_StubMsg,*pcFound * 4);
8735         pBstrLibName = &_M84;
8736         MIDL_memset(
8737                pBstrLibName,
8738                0,
8739                sizeof( BSTR  ));
8740
8741         *_pdwStubPhase = STUB_CALL_SERVER;
8742
8743
8744         _RetVal = ITypeLib_FindName_Stub(
8745                                  (ITypeLib *) ((CStdStubBuffer *)This)->pvServerObject,
8746                                  szNameBuf,
8747                                  lHashVal,
8748                                  ppTInfo,
8749                                  rgMemId,
8750                                  pcFound,
8751                                  pBstrLibName);
8752
8753         *_pdwStubPhase = STUB_MARSHAL;
8754
8755         _StubMsg.BufferLength = 12U + 15U + 4U + 14U + 11U;
8756         _StubMsg.MaxCount = pcFound ? *pcFound : 0;
8757         _StubMsg.Offset = 0;
8758         _StubMsg.ActualCount = pcFound ? *pcFound : 0;
8759
8760         NdrComplexArrayBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
8761                                    (unsigned char __RPC_FAR *)ppTInfo,
8762                                    (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1852] );
8763
8764         _StubMsg.MaxCount = pcFound ? *pcFound : 0;
8765         _StubMsg.Offset = 0;
8766         _StubMsg.ActualCount = pcFound ? *pcFound : 0;
8767
8768         NdrConformantVaryingArrayBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
8769                                              (unsigned char __RPC_FAR *)rgMemId,
8770                                              (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1874] );
8771
8772         NdrUserMarshalBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
8773                                   (unsigned char __RPC_FAR *)pBstrLibName,
8774                                   (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1128] );
8775
8776         _StubMsg.BufferLength += 16;
8777
8778         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
8779         _StubMsg.MaxCount = pcFound ? *pcFound : 0;
8780         _StubMsg.Offset = 0;
8781         _StubMsg.ActualCount = pcFound ? *pcFound : 0;
8782
8783         NdrComplexArrayMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
8784                                  (unsigned char __RPC_FAR *)ppTInfo,
8785                                  (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1852] );
8786
8787         _StubMsg.MaxCount = pcFound ? *pcFound : 0;
8788         _StubMsg.Offset = 0;
8789         _StubMsg.ActualCount = pcFound ? *pcFound : 0;
8790
8791         NdrConformantVaryingArrayMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
8792                                            (unsigned char __RPC_FAR *)rgMemId,
8793                                            (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1874] );
8794
8795         *( USHORT __RPC_FAR * )_StubMsg.Buffer = *pcFound;
8796         _StubMsg.Buffer += sizeof(USHORT);
8797
8798         NdrUserMarshalMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
8799                                 (unsigned char __RPC_FAR *)pBstrLibName,
8800                                 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1128] );
8801
8802         _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
8803         *( HRESULT __RPC_FAR * )_StubMsg.Buffer = _RetVal;
8804         _StubMsg.Buffer += sizeof(HRESULT);
8805
8806         }
8807     RpcFinally
8808         {
8809         _StubMsg.MaxCount = pcFound ? *pcFound : 0;
8810         _StubMsg.Offset = 0;
8811         _StubMsg.ActualCount = pcFound ? *pcFound : 0;
8812
8813         NdrPointerFree( &_StubMsg,
8814                         (unsigned char __RPC_FAR *)ppTInfo,
8815                         &__MIDL_TypeFormatString.Format[1848] );
8816
8817         _StubMsg.MaxCount = pcFound ? *pcFound : 0;
8818         _StubMsg.Offset = 0;
8819         _StubMsg.ActualCount = pcFound ? *pcFound : 0;
8820
8821         NdrPointerFree( &_StubMsg,
8822                         (unsigned char __RPC_FAR *)rgMemId,
8823                         &__MIDL_TypeFormatString.Format[1870] );
8824
8825         NdrPointerFree( &_StubMsg,
8826                         (unsigned char __RPC_FAR *)pBstrLibName,
8827                         &__MIDL_TypeFormatString.Format[1708] );
8828
8829         }
8830     RpcEndFinally
8831     _pRpcMessage->BufferLength =
8832         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
8833
8834 }
8835
8836
8837 /* [call_as] */ HRESULT STDMETHODCALLTYPE ITypeLib_LocalReleaseTLibAttr_Proxy(
8838     ITypeLib __RPC_FAR * This)
8839 {
8840
8841     HRESULT _RetVal;
8842
8843     RPC_MESSAGE _RpcMessage;
8844
8845     MIDL_STUB_MESSAGE _StubMsg;
8846
8847     RpcTryExcept
8848         {
8849         NdrProxyInitialize(
8850                       ( void __RPC_FAR *  )This,
8851                       ( PRPC_MESSAGE  )&_RpcMessage,
8852                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
8853                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
8854                       12);
8855
8856
8857
8858         RpcTryFinally
8859             {
8860
8861             _StubMsg.BufferLength = 0U;
8862             NdrProxyGetBuffer(This, &_StubMsg);
8863             NdrProxySendReceive(This, &_StubMsg);
8864
8865             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
8866                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[88] );
8867
8868             _RetVal = *( HRESULT __RPC_FAR * )_StubMsg.Buffer;
8869             _StubMsg.Buffer += sizeof(HRESULT);
8870
8871             }
8872         RpcFinally
8873             {
8874             NdrProxyFreeBuffer(This, &_StubMsg);
8875
8876             }
8877         RpcEndFinally
8878
8879         }
8880     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
8881         {
8882         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
8883         }
8884     RpcEndExcept
8885     return _RetVal;
8886 }
8887
8888 void __RPC_STUB ITypeLib_LocalReleaseTLibAttr_Stub(
8889     IRpcStubBuffer *This,
8890     IRpcChannelBuffer *_pRpcChannelBuffer,
8891     PRPC_MESSAGE _pRpcMessage,
8892     DWORD *_pdwStubPhase)
8893 {
8894     HRESULT _RetVal;
8895     MIDL_STUB_MESSAGE _StubMsg;
8896
8897 NdrStubInitialize(
8898                      _pRpcMessage,
8899                      &_StubMsg,
8900                      &Object_StubDesc,
8901                      _pRpcChannelBuffer);
8902     RpcTryFinally
8903         {
8904
8905         *_pdwStubPhase = STUB_CALL_SERVER;
8906
8907
8908         _RetVal = ITypeLib_ReleaseTLibAttr_Stub((ITypeLib *) ((CStdStubBuffer *)This)->pvServerObject);
8909
8910         *_pdwStubPhase = STUB_MARSHAL;
8911
8912         _StubMsg.BufferLength = 4U;
8913         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
8914         *( HRESULT __RPC_FAR * )_StubMsg.Buffer = _RetVal;
8915         _StubMsg.Buffer += sizeof(HRESULT);
8916
8917         }
8918     RpcFinally
8919         {
8920         }
8921     RpcEndFinally
8922     _pRpcMessage->BufferLength =
8923         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
8924
8925 }
8926
8927 static const CINTERFACE_PROXY_VTABLE(13) _ITypeLibProxyVtbl =
8928 {
8929     { &IID_ITypeLib },
8930     {
8931         IUnknown_QueryInterface_Proxy,
8932         IUnknown_AddRef_Proxy,
8933         IUnknown_Release_Proxy ,
8934         ITypeLib_GetTypeInfoCount_Proxy ,
8935         ITypeLib_GetTypeInfo_Proxy ,
8936         ITypeLib_GetTypeInfoType_Proxy ,
8937         ITypeLib_GetTypeInfoOfGuid_Proxy ,
8938         ITypeLib_GetLibAttr_Proxy ,
8939         ITypeLib_GetTypeComp_Proxy ,
8940         ITypeLib_GetDocumentation_Proxy ,
8941         ITypeLib_IsName_Proxy ,
8942         ITypeLib_FindName_Proxy ,
8943         ITypeLib_ReleaseTLibAttr_Proxy
8944     }
8945 };
8946
8947
8948 static const PRPC_STUB_FUNCTION ITypeLib_table[] =
8949 {
8950     ITypeLib_RemoteGetTypeInfoCount_Stub,
8951     ITypeLib_GetTypeInfo_Stub,
8952     ITypeLib_GetTypeInfoType_Stub,
8953     ITypeLib_GetTypeInfoOfGuid_Stub,
8954     ITypeLib_RemoteGetLibAttr_Stub,
8955     ITypeLib_GetTypeComp_Stub,
8956     ITypeLib_RemoteGetDocumentation_Stub,
8957     ITypeLib_RemoteIsName_Stub,
8958     ITypeLib_RemoteFindName_Stub,
8959     ITypeLib_LocalReleaseTLibAttr_Stub
8960 };
8961
8962 static const CInterfaceStubVtbl _ITypeLibStubVtbl =
8963 {
8964     {
8965         &IID_ITypeLib,
8966         0,
8967         13,
8968         &ITypeLib_table[-3]
8969     },
8970     { CStdStubBuffer_METHODS }
8971 };
8972
8973
8974 /* Object interface: ITypeLib2, ver. 0.0,
8975    GUID={0x00020411,0x0000,0x0000,{0xC0,0x00,0x00,0x00,0x00,0x00,0x00,0x46}} */
8976
8977
8978 extern const MIDL_STUB_DESC Object_StubDesc;
8979
8980
8981 HRESULT STDMETHODCALLTYPE ITypeLib2_GetCustData_Proxy(
8982     ITypeLib2 __RPC_FAR * This,
8983     /* [in] */ REFGUID guid,
8984     /* [out] */ VARIANT __RPC_FAR *pVarVal)
8985 {
8986
8987     HRESULT _RetVal;
8988
8989     RPC_MESSAGE _RpcMessage;
8990
8991     MIDL_STUB_MESSAGE _StubMsg;
8992
8993     if(pVarVal)
8994         {
8995         MIDL_memset(
8996                pVarVal,
8997                0,
8998                sizeof( VARIANT  ));
8999         }
9000     RpcTryExcept
9001         {
9002         NdrProxyInitialize(
9003                       ( void __RPC_FAR *  )This,
9004                       ( PRPC_MESSAGE  )&_RpcMessage,
9005                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
9006                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
9007                       13);
9008
9009
9010
9011         if(!guid)
9012             {
9013             RpcRaiseException(RPC_X_NULL_REF_POINTER);
9014             }
9015         if(!pVarVal)
9016             {
9017             RpcRaiseException(RPC_X_NULL_REF_POINTER);
9018             }
9019         RpcTryFinally
9020             {
9021
9022             _StubMsg.BufferLength = 0U;
9023             NdrSimpleStructBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
9024                                        (unsigned char __RPC_FAR *)guid,
9025                                        (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[38] );
9026
9027             NdrProxyGetBuffer(This, &_StubMsg);
9028             NdrSimpleStructMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
9029                                      (unsigned char __RPC_FAR *)guid,
9030                                      (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[38] );
9031
9032             NdrProxySendReceive(This, &_StubMsg);
9033
9034             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
9035                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[298] );
9036
9037             NdrUserMarshalUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
9038                                       (unsigned char __RPC_FAR * __RPC_FAR *)&pVarVal,
9039                                       (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1110],
9040                                       (unsigned char)0 );
9041
9042             _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
9043             _RetVal = *( HRESULT __RPC_FAR * )_StubMsg.Buffer;
9044             _StubMsg.Buffer += sizeof(HRESULT);
9045
9046             }
9047         RpcFinally
9048             {
9049             NdrProxyFreeBuffer(This, &_StubMsg);
9050
9051             }
9052         RpcEndFinally
9053
9054         }
9055     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
9056         {
9057         NdrClearOutParameters(
9058                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
9059                          ( PFORMAT_STRING  )&__MIDL_TypeFormatString.Format[1102],
9060                          ( void __RPC_FAR * )pVarVal);
9061         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
9062         }
9063     RpcEndExcept
9064     return _RetVal;
9065 }
9066
9067 void __RPC_STUB ITypeLib2_GetCustData_Stub(
9068     IRpcStubBuffer *This,
9069     IRpcChannelBuffer *_pRpcChannelBuffer,
9070     PRPC_MESSAGE _pRpcMessage,
9071     DWORD *_pdwStubPhase)
9072 {
9073     VARIANT _M85;
9074     HRESULT _RetVal;
9075     MIDL_STUB_MESSAGE _StubMsg;
9076     REFGUID guid = 0;
9077     VARIANT __RPC_FAR *pVarVal;
9078
9079 NdrStubInitialize(
9080                      _pRpcMessage,
9081                      &_StubMsg,
9082                      &Object_StubDesc,
9083                      _pRpcChannelBuffer);
9084     pVarVal = 0;
9085     RpcTryFinally
9086         {
9087         if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
9088             NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[298] );
9089
9090         NdrSimpleStructUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
9091                                    (unsigned char __RPC_FAR * __RPC_FAR *)&guid,
9092                                    (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[38],
9093                                    (unsigned char)0 );
9094
9095         pVarVal = &_M85;
9096         MIDL_memset(
9097                pVarVal,
9098                0,
9099                sizeof( VARIANT  ));
9100
9101         *_pdwStubPhase = STUB_CALL_SERVER;
9102         _RetVal = (((ITypeLib2*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> GetCustData(
9103                (ITypeLib2 *) ((CStdStubBuffer *)This)->pvServerObject,
9104                guid,
9105                pVarVal);
9106
9107         *_pdwStubPhase = STUB_MARSHAL;
9108
9109         _StubMsg.BufferLength = 8U + 11U;
9110         NdrUserMarshalBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
9111                                   (unsigned char __RPC_FAR *)pVarVal,
9112                                   (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1110] );
9113
9114         _StubMsg.BufferLength += 16;
9115
9116         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
9117         NdrUserMarshalMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
9118                                 (unsigned char __RPC_FAR *)pVarVal,
9119                                 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1110] );
9120
9121         _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
9122         *( HRESULT __RPC_FAR * )_StubMsg.Buffer = _RetVal;
9123         _StubMsg.Buffer += sizeof(HRESULT);
9124
9125         }
9126     RpcFinally
9127         {
9128         NdrPointerFree( &_StubMsg,
9129                         (unsigned char __RPC_FAR *)pVarVal,
9130                         &__MIDL_TypeFormatString.Format[1102] );
9131
9132         }
9133     RpcEndFinally
9134     _pRpcMessage->BufferLength =
9135         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
9136
9137 }
9138
9139
9140 /* [call_as] */ HRESULT STDMETHODCALLTYPE ITypeLib2_RemoteGetLibStatistics_Proxy(
9141     ITypeLib2 __RPC_FAR * This,
9142     /* [out] */ ULONG __RPC_FAR *pcUniqueNames,
9143     /* [out] */ ULONG __RPC_FAR *pcchUniqueNames)
9144 {
9145
9146     HRESULT _RetVal;
9147
9148     RPC_MESSAGE _RpcMessage;
9149
9150     MIDL_STUB_MESSAGE _StubMsg;
9151
9152     RpcTryExcept
9153         {
9154         NdrProxyInitialize(
9155                       ( void __RPC_FAR *  )This,
9156                       ( PRPC_MESSAGE  )&_RpcMessage,
9157                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
9158                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
9159                       14);
9160
9161
9162
9163         if(!pcUniqueNames)
9164             {
9165             RpcRaiseException(RPC_X_NULL_REF_POINTER);
9166             }
9167         if(!pcchUniqueNames)
9168             {
9169             RpcRaiseException(RPC_X_NULL_REF_POINTER);
9170             }
9171         RpcTryFinally
9172             {
9173
9174             _StubMsg.BufferLength = 0U;
9175             NdrProxyGetBuffer(This, &_StubMsg);
9176             NdrProxySendReceive(This, &_StubMsg);
9177
9178             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
9179                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[446] );
9180
9181             *pcUniqueNames = *( ULONG __RPC_FAR * )_StubMsg.Buffer;
9182             _StubMsg.Buffer += sizeof(ULONG);
9183
9184             *pcchUniqueNames = *( ULONG __RPC_FAR * )_StubMsg.Buffer;
9185             _StubMsg.Buffer += sizeof(ULONG);
9186
9187             _RetVal = *( HRESULT __RPC_FAR * )_StubMsg.Buffer;
9188             _StubMsg.Buffer += sizeof(HRESULT);
9189
9190             }
9191         RpcFinally
9192             {
9193             NdrProxyFreeBuffer(This, &_StubMsg);
9194
9195             }
9196         RpcEndFinally
9197
9198         }
9199     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
9200         {
9201         NdrClearOutParameters(
9202                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
9203                          ( PFORMAT_STRING  )&__MIDL_TypeFormatString.Format[2],
9204                          ( void __RPC_FAR * )pcUniqueNames);
9205         NdrClearOutParameters(
9206                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
9207                          ( PFORMAT_STRING  )&__MIDL_TypeFormatString.Format[2],
9208                          ( void __RPC_FAR * )pcchUniqueNames);
9209         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
9210         }
9211     RpcEndExcept
9212     return _RetVal;
9213 }
9214
9215 void __RPC_STUB ITypeLib2_RemoteGetLibStatistics_Stub(
9216     IRpcStubBuffer *This,
9217     IRpcChannelBuffer *_pRpcChannelBuffer,
9218     PRPC_MESSAGE _pRpcMessage,
9219     DWORD *_pdwStubPhase)
9220 {
9221     ULONG _M86;
9222     ULONG _M87;
9223     HRESULT _RetVal;
9224     MIDL_STUB_MESSAGE _StubMsg;
9225     ULONG __RPC_FAR *pcUniqueNames;
9226     ULONG __RPC_FAR *pcchUniqueNames;
9227
9228 NdrStubInitialize(
9229                      _pRpcMessage,
9230                      &_StubMsg,
9231                      &Object_StubDesc,
9232                      _pRpcChannelBuffer);
9233     pcUniqueNames = 0;
9234     pcchUniqueNames = 0;
9235     RpcTryFinally
9236         {
9237         pcUniqueNames = &_M86;
9238         pcchUniqueNames = &_M87;
9239
9240         *_pdwStubPhase = STUB_CALL_SERVER;
9241
9242
9243         _RetVal = ITypeLib2_GetLibStatistics_Stub(
9244                                           (ITypeLib2 *) ((CStdStubBuffer *)This)->pvServerObject,
9245                                           pcUniqueNames,
9246                                           pcchUniqueNames);
9247
9248         *_pdwStubPhase = STUB_MARSHAL;
9249
9250         _StubMsg.BufferLength = 4U + 4U + 4U;
9251         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
9252         *( ULONG __RPC_FAR * )_StubMsg.Buffer = *pcUniqueNames;
9253         _StubMsg.Buffer += sizeof(ULONG);
9254
9255         *( ULONG __RPC_FAR * )_StubMsg.Buffer = *pcchUniqueNames;
9256         _StubMsg.Buffer += sizeof(ULONG);
9257
9258         *( HRESULT __RPC_FAR * )_StubMsg.Buffer = _RetVal;
9259         _StubMsg.Buffer += sizeof(HRESULT);
9260
9261         }
9262     RpcFinally
9263         {
9264         }
9265     RpcEndFinally
9266     _pRpcMessage->BufferLength =
9267         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
9268
9269 }
9270
9271
9272 /* [call_as] */ HRESULT STDMETHODCALLTYPE ITypeLib2_RemoteGetDocumentation2_Proxy(
9273     ITypeLib2 __RPC_FAR * This,
9274     /* [in] */ INT index,
9275     /* [in] */ LCID lcid,
9276     /* [in] */ DWORD refPtrFlags,
9277     /* [out] */ BSTR __RPC_FAR *pbstrHelpString,
9278     /* [out] */ DWORD __RPC_FAR *pdwHelpStringContext,
9279     /* [out] */ BSTR __RPC_FAR *pbstrHelpStringDll)
9280 {
9281
9282     HRESULT _RetVal;
9283
9284     RPC_MESSAGE _RpcMessage;
9285
9286     MIDL_STUB_MESSAGE _StubMsg;
9287
9288     if(pbstrHelpString)
9289         {
9290         MIDL_memset(
9291                pbstrHelpString,
9292                0,
9293                sizeof( BSTR  ));
9294         }
9295     if(pbstrHelpStringDll)
9296         {
9297         MIDL_memset(
9298                pbstrHelpStringDll,
9299                0,
9300                sizeof( BSTR  ));
9301         }
9302     RpcTryExcept
9303         {
9304         NdrProxyInitialize(
9305                       ( void __RPC_FAR *  )This,
9306                       ( PRPC_MESSAGE  )&_RpcMessage,
9307                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
9308                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
9309                       15);
9310
9311
9312
9313         if(!pbstrHelpString)
9314             {
9315             RpcRaiseException(RPC_X_NULL_REF_POINTER);
9316             }
9317         if(!pdwHelpStringContext)
9318             {
9319             RpcRaiseException(RPC_X_NULL_REF_POINTER);
9320             }
9321         if(!pbstrHelpStringDll)
9322             {
9323             RpcRaiseException(RPC_X_NULL_REF_POINTER);
9324             }
9325         RpcTryFinally
9326             {
9327
9328             _StubMsg.BufferLength = 4U + 4U + 4U;
9329             NdrProxyGetBuffer(This, &_StubMsg);
9330             *( INT __RPC_FAR * )_StubMsg.Buffer = index;
9331             _StubMsg.Buffer += sizeof(INT);
9332
9333             *( LCID __RPC_FAR * )_StubMsg.Buffer = lcid;
9334             _StubMsg.Buffer += sizeof(LCID);
9335
9336             *( DWORD __RPC_FAR * )_StubMsg.Buffer = refPtrFlags;
9337             _StubMsg.Buffer += sizeof(DWORD);
9338
9339             NdrProxySendReceive(This, &_StubMsg);
9340
9341             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
9342                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[334] );
9343
9344             NdrUserMarshalUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
9345                                       (unsigned char __RPC_FAR * __RPC_FAR *)&pbstrHelpString,
9346                                       (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1128],
9347                                       (unsigned char)0 );
9348
9349             _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
9350             *pdwHelpStringContext = *( DWORD __RPC_FAR * )_StubMsg.Buffer;
9351             _StubMsg.Buffer += sizeof(DWORD);
9352
9353             NdrUserMarshalUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
9354                                       (unsigned char __RPC_FAR * __RPC_FAR *)&pbstrHelpStringDll,
9355                                       (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1128],
9356                                       (unsigned char)0 );
9357
9358             _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
9359             _RetVal = *( HRESULT __RPC_FAR * )_StubMsg.Buffer;
9360             _StubMsg.Buffer += sizeof(HRESULT);
9361
9362             }
9363         RpcFinally
9364             {
9365             NdrProxyFreeBuffer(This, &_StubMsg);
9366
9367             }
9368         RpcEndFinally
9369
9370         }
9371     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
9372         {
9373         NdrClearOutParameters(
9374                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
9375                          ( PFORMAT_STRING  )&__MIDL_TypeFormatString.Format[1708],
9376                          ( void __RPC_FAR * )pbstrHelpString);
9377         NdrClearOutParameters(
9378                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
9379                          ( PFORMAT_STRING  )&__MIDL_TypeFormatString.Format[2],
9380                          ( void __RPC_FAR * )pdwHelpStringContext);
9381         NdrClearOutParameters(
9382                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
9383                          ( PFORMAT_STRING  )&__MIDL_TypeFormatString.Format[1708],
9384                          ( void __RPC_FAR * )pbstrHelpStringDll);
9385         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
9386         }
9387     RpcEndExcept
9388     return _RetVal;
9389 }
9390
9391 void __RPC_STUB ITypeLib2_RemoteGetDocumentation2_Stub(
9392     IRpcStubBuffer *This,
9393     IRpcChannelBuffer *_pRpcChannelBuffer,
9394     PRPC_MESSAGE _pRpcMessage,
9395     DWORD *_pdwStubPhase)
9396 {
9397     BSTR _M88;
9398     DWORD _M89;
9399     BSTR _M90;
9400     HRESULT _RetVal;
9401     MIDL_STUB_MESSAGE _StubMsg;
9402     INT index;
9403     LCID lcid;
9404     BSTR __RPC_FAR *pbstrHelpString;
9405     BSTR __RPC_FAR *pbstrHelpStringDll;
9406     DWORD __RPC_FAR *pdwHelpStringContext;
9407     DWORD refPtrFlags;
9408
9409 NdrStubInitialize(
9410                      _pRpcMessage,
9411                      &_StubMsg,
9412                      &Object_StubDesc,
9413                      _pRpcChannelBuffer);
9414     pbstrHelpString = 0;
9415     pdwHelpStringContext = 0;
9416     pbstrHelpStringDll = 0;
9417     RpcTryFinally
9418         {
9419         if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
9420             NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[334] );
9421
9422         index = *( INT __RPC_FAR * )_StubMsg.Buffer;
9423         _StubMsg.Buffer += sizeof(INT);
9424
9425         lcid = *( LCID __RPC_FAR * )_StubMsg.Buffer;
9426         _StubMsg.Buffer += sizeof(LCID);
9427
9428         refPtrFlags = *( DWORD __RPC_FAR * )_StubMsg.Buffer;
9429         _StubMsg.Buffer += sizeof(DWORD);
9430
9431         pbstrHelpString = &_M88;
9432         MIDL_memset(
9433                pbstrHelpString,
9434                0,
9435                sizeof( BSTR  ));
9436         pdwHelpStringContext = &_M89;
9437         pbstrHelpStringDll = &_M90;
9438         MIDL_memset(
9439                pbstrHelpStringDll,
9440                0,
9441                sizeof( BSTR  ));
9442
9443         *_pdwStubPhase = STUB_CALL_SERVER;
9444
9445
9446         _RetVal = ITypeLib2_GetDocumentation2_Stub(
9447                                            (ITypeLib2 *) ((CStdStubBuffer *)This)->pvServerObject,
9448                                            index,
9449                                            lcid,
9450                                            refPtrFlags,
9451                                            pbstrHelpString,
9452                                            pdwHelpStringContext,
9453                                            pbstrHelpStringDll);
9454
9455         *_pdwStubPhase = STUB_MARSHAL;
9456
9457         _StubMsg.BufferLength = 8U + 11U + 11U + 11U;
9458         NdrUserMarshalBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
9459                                   (unsigned char __RPC_FAR *)pbstrHelpString,
9460                                   (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1128] );
9461
9462         NdrUserMarshalBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
9463                                   (unsigned char __RPC_FAR *)pbstrHelpStringDll,
9464                                   (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1128] );
9465
9466         _StubMsg.BufferLength += 16;
9467
9468         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
9469         NdrUserMarshalMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
9470                                 (unsigned char __RPC_FAR *)pbstrHelpString,
9471                                 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1128] );
9472
9473         _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
9474         *( DWORD __RPC_FAR * )_StubMsg.Buffer = *pdwHelpStringContext;
9475         _StubMsg.Buffer += sizeof(DWORD);
9476
9477         NdrUserMarshalMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
9478                                 (unsigned char __RPC_FAR *)pbstrHelpStringDll,
9479                                 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1128] );
9480
9481         _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
9482         *( HRESULT __RPC_FAR * )_StubMsg.Buffer = _RetVal;
9483         _StubMsg.Buffer += sizeof(HRESULT);
9484
9485         }
9486     RpcFinally
9487         {
9488         NdrPointerFree( &_StubMsg,
9489                         (unsigned char __RPC_FAR *)pbstrHelpString,
9490                         &__MIDL_TypeFormatString.Format[1708] );
9491
9492         NdrPointerFree( &_StubMsg,
9493                         (unsigned char __RPC_FAR *)pbstrHelpStringDll,
9494                         &__MIDL_TypeFormatString.Format[1708] );
9495
9496         }
9497     RpcEndFinally
9498     _pRpcMessage->BufferLength =
9499         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
9500
9501 }
9502
9503
9504 HRESULT STDMETHODCALLTYPE ITypeLib2_GetAllCustData_Proxy(
9505     ITypeLib2 __RPC_FAR * This,
9506     /* [out] */ CUSTDATA __RPC_FAR *pCustData)
9507 {
9508
9509     HRESULT _RetVal;
9510
9511     RPC_MESSAGE _RpcMessage;
9512
9513     MIDL_STUB_MESSAGE _StubMsg;
9514
9515     if(pCustData)
9516         {
9517         MIDL_memset(
9518                pCustData,
9519                0,
9520                sizeof( CUSTDATA  ));
9521         }
9522     RpcTryExcept
9523         {
9524         NdrProxyInitialize(
9525                       ( void __RPC_FAR *  )This,
9526                       ( PRPC_MESSAGE  )&_RpcMessage,
9527                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
9528                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
9529                       16);
9530
9531
9532
9533         if(!pCustData)
9534             {
9535             RpcRaiseException(RPC_X_NULL_REF_POINTER);
9536             }
9537         RpcTryFinally
9538             {
9539
9540             _StubMsg.BufferLength = 0U;
9541             NdrProxyGetBuffer(This, &_StubMsg);
9542             NdrProxySendReceive(This, &_StubMsg);
9543
9544             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
9545                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[354] );
9546
9547             NdrComplexStructUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
9548                                         (unsigned char __RPC_FAR * __RPC_FAR *)&pCustData,
9549                                         (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1788],
9550                                         (unsigned char)0 );
9551
9552             _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
9553             _RetVal = *( HRESULT __RPC_FAR * )_StubMsg.Buffer;
9554             _StubMsg.Buffer += sizeof(HRESULT);
9555
9556             }
9557         RpcFinally
9558             {
9559             NdrProxyFreeBuffer(This, &_StubMsg);
9560
9561             }
9562         RpcEndFinally
9563
9564         }
9565     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
9566         {
9567         NdrClearOutParameters(
9568                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
9569                          ( PFORMAT_STRING  )&__MIDL_TypeFormatString.Format[1748],
9570                          ( void __RPC_FAR * )pCustData);
9571         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
9572         }
9573     RpcEndExcept
9574     return _RetVal;
9575 }
9576
9577 void __RPC_STUB ITypeLib2_GetAllCustData_Stub(
9578     IRpcStubBuffer *This,
9579     IRpcChannelBuffer *_pRpcChannelBuffer,
9580     PRPC_MESSAGE _pRpcMessage,
9581     DWORD *_pdwStubPhase)
9582 {
9583     HRESULT _RetVal;
9584     MIDL_STUB_MESSAGE _StubMsg;
9585     CUSTDATA _pCustDataM;
9586     CUSTDATA __RPC_FAR *pCustData;
9587
9588 NdrStubInitialize(
9589                      _pRpcMessage,
9590                      &_StubMsg,
9591                      &Object_StubDesc,
9592                      _pRpcChannelBuffer);
9593     pCustData = 0;
9594     RpcTryFinally
9595         {
9596         pCustData = &_pCustDataM;
9597         pCustData -> prgCustData = 0;
9598
9599         *_pdwStubPhase = STUB_CALL_SERVER;
9600         _RetVal = (((ITypeLib2*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> GetAllCustData((ITypeLib2 *) ((CStdStubBuffer *)This)->pvServerObject,pCustData);
9601
9602         *_pdwStubPhase = STUB_MARSHAL;
9603
9604         _StubMsg.BufferLength = 0U + 11U;
9605         NdrComplexStructBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
9606                                     (unsigned char __RPC_FAR *)pCustData,
9607                                     (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1788] );
9608
9609         _StubMsg.BufferLength += 16;
9610
9611         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
9612         NdrComplexStructMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
9613                                   (unsigned char __RPC_FAR *)pCustData,
9614                                   (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1788] );
9615
9616         _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
9617         *( HRESULT __RPC_FAR * )_StubMsg.Buffer = _RetVal;
9618         _StubMsg.Buffer += sizeof(HRESULT);
9619
9620         }
9621     RpcFinally
9622         {
9623         NdrPointerFree( &_StubMsg,
9624                         (unsigned char __RPC_FAR *)pCustData,
9625                         &__MIDL_TypeFormatString.Format[1748] );
9626
9627         }
9628     RpcEndFinally
9629     _pRpcMessage->BufferLength =
9630         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
9631
9632 }
9633
9634 static const CINTERFACE_PROXY_VTABLE(17) _ITypeLib2ProxyVtbl =
9635 {
9636     { &IID_ITypeLib2 },
9637     {
9638         IUnknown_QueryInterface_Proxy,
9639         IUnknown_AddRef_Proxy,
9640         IUnknown_Release_Proxy ,
9641         ITypeLib_GetTypeInfoCount_Proxy ,
9642         ITypeLib_GetTypeInfo_Proxy ,
9643         ITypeLib_GetTypeInfoType_Proxy ,
9644         ITypeLib_GetTypeInfoOfGuid_Proxy ,
9645         ITypeLib_GetLibAttr_Proxy ,
9646         ITypeLib_GetTypeComp_Proxy ,
9647         ITypeLib_GetDocumentation_Proxy ,
9648         ITypeLib_IsName_Proxy ,
9649         ITypeLib_FindName_Proxy ,
9650         ITypeLib_ReleaseTLibAttr_Proxy ,
9651         ITypeLib2_GetCustData_Proxy ,
9652         ITypeLib2_GetLibStatistics_Proxy ,
9653         ITypeLib2_GetDocumentation2_Proxy ,
9654         ITypeLib2_GetAllCustData_Proxy
9655     }
9656 };
9657
9658
9659 static const PRPC_STUB_FUNCTION ITypeLib2_table[] =
9660 {
9661     ITypeLib_RemoteGetTypeInfoCount_Stub,
9662     ITypeLib_GetTypeInfo_Stub,
9663     ITypeLib_GetTypeInfoType_Stub,
9664     ITypeLib_GetTypeInfoOfGuid_Stub,
9665     ITypeLib_RemoteGetLibAttr_Stub,
9666     ITypeLib_GetTypeComp_Stub,
9667     ITypeLib_RemoteGetDocumentation_Stub,
9668     ITypeLib_RemoteIsName_Stub,
9669     ITypeLib_RemoteFindName_Stub,
9670     ITypeLib_LocalReleaseTLibAttr_Stub,
9671     ITypeLib2_GetCustData_Stub,
9672     ITypeLib2_RemoteGetLibStatistics_Stub,
9673     ITypeLib2_RemoteGetDocumentation2_Stub,
9674     ITypeLib2_GetAllCustData_Stub
9675 };
9676
9677 const CInterfaceStubVtbl _ITypeLib2StubVtbl =
9678 {
9679     {
9680         &IID_ITypeLib2,
9681         0,
9682         17,
9683         &ITypeLib2_table[-3]
9684     },
9685     { CStdStubBuffer_METHODS }
9686 };
9687
9688
9689 /* Object interface: ITypeChangeEvents, ver. 0.0,
9690    GUID={0x00020410,0x0000,0x0000,{0xC0,0x00,0x00,0x00,0x00,0x00,0x00,0x46}} */
9691
9692
9693 /* Object interface: IErrorInfo, ver. 0.0,
9694    GUID={0x1CF2B120,0x547D,0x101B,{0x8E,0x65,0x08,0x00,0x2B,0x2B,0xD1,0x19}} */
9695
9696
9697 extern const MIDL_STUB_DESC Object_StubDesc;
9698
9699
9700 HRESULT STDMETHODCALLTYPE IErrorInfo_GetGUID_Proxy(
9701     IErrorInfo __RPC_FAR * This,
9702     /* [out] */ GUID __RPC_FAR *pGUID)
9703 {
9704
9705     HRESULT _RetVal;
9706
9707     RPC_MESSAGE _RpcMessage;
9708
9709     MIDL_STUB_MESSAGE _StubMsg;
9710
9711     if(pGUID)
9712         {
9713         MIDL_memset(
9714                pGUID,
9715                0,
9716                sizeof( IID  ));
9717         }
9718     RpcTryExcept
9719         {
9720         NdrProxyInitialize(
9721                       ( void __RPC_FAR *  )This,
9722                       ( PRPC_MESSAGE  )&_RpcMessage,
9723                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
9724                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
9725                       3);
9726
9727
9728
9729         if(!pGUID)
9730             {
9731             RpcRaiseException(RPC_X_NULL_REF_POINTER);
9732             }
9733         RpcTryFinally
9734             {
9735
9736             _StubMsg.BufferLength = 0U;
9737             NdrProxyGetBuffer(This, &_StubMsg);
9738             NdrProxySendReceive(This, &_StubMsg);
9739
9740             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
9741                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[456] );
9742
9743             NdrSimpleStructUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
9744                                        (unsigned char __RPC_FAR * __RPC_FAR *)&pGUID,
9745                                        (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[38],
9746                                        (unsigned char)0 );
9747
9748             _RetVal = *( HRESULT __RPC_FAR * )_StubMsg.Buffer;
9749             _StubMsg.Buffer += sizeof(HRESULT);
9750
9751             }
9752         RpcFinally
9753             {
9754             NdrProxyFreeBuffer(This, &_StubMsg);
9755
9756             }
9757         RpcEndFinally
9758
9759         }
9760     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
9761         {
9762         NdrClearOutParameters(
9763                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
9764                          ( PFORMAT_STRING  )&__MIDL_TypeFormatString.Format[1892],
9765                          ( void __RPC_FAR * )pGUID);
9766         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
9767         }
9768     RpcEndExcept
9769     return _RetVal;
9770 }
9771
9772 void __RPC_STUB IErrorInfo_GetGUID_Stub(
9773     IRpcStubBuffer *This,
9774     IRpcChannelBuffer *_pRpcChannelBuffer,
9775     PRPC_MESSAGE _pRpcMessage,
9776     DWORD *_pdwStubPhase)
9777 {
9778     HRESULT _RetVal;
9779     MIDL_STUB_MESSAGE _StubMsg;
9780     IID _pGUIDM;
9781     GUID __RPC_FAR *pGUID;
9782
9783 NdrStubInitialize(
9784                      _pRpcMessage,
9785                      &_StubMsg,
9786                      &Object_StubDesc,
9787                      _pRpcChannelBuffer);
9788     pGUID = 0;
9789     RpcTryFinally
9790         {
9791         pGUID = &_pGUIDM;
9792
9793         *_pdwStubPhase = STUB_CALL_SERVER;
9794         _RetVal = (((IErrorInfo*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> GetGUID((IErrorInfo *) ((CStdStubBuffer *)This)->pvServerObject,pGUID);
9795
9796         *_pdwStubPhase = STUB_MARSHAL;
9797
9798         _StubMsg.BufferLength = 0U + 11U;
9799         NdrSimpleStructBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
9800                                    (unsigned char __RPC_FAR *)pGUID,
9801                                    (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[38] );
9802
9803         _StubMsg.BufferLength += 16;
9804
9805         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
9806         NdrSimpleStructMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
9807                                  (unsigned char __RPC_FAR *)pGUID,
9808                                  (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[38] );
9809
9810         *( HRESULT __RPC_FAR * )_StubMsg.Buffer = _RetVal;
9811         _StubMsg.Buffer += sizeof(HRESULT);
9812
9813         }
9814     RpcFinally
9815         {
9816         }
9817     RpcEndFinally
9818     _pRpcMessage->BufferLength =
9819         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
9820
9821 }
9822
9823
9824 HRESULT STDMETHODCALLTYPE IErrorInfo_GetSource_Proxy(
9825     IErrorInfo __RPC_FAR * This,
9826     /* [out] */ BSTR __RPC_FAR *pBstrSource)
9827 {
9828
9829     HRESULT _RetVal;
9830
9831     RPC_MESSAGE _RpcMessage;
9832
9833     MIDL_STUB_MESSAGE _StubMsg;
9834
9835     if(pBstrSource)
9836         {
9837         MIDL_memset(
9838                pBstrSource,
9839                0,
9840                sizeof( BSTR  ));
9841         }
9842     RpcTryExcept
9843         {
9844         NdrProxyInitialize(
9845                       ( void __RPC_FAR *  )This,
9846                       ( PRPC_MESSAGE  )&_RpcMessage,
9847                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
9848                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
9849                       4);
9850
9851
9852
9853         if(!pBstrSource)
9854             {
9855             RpcRaiseException(RPC_X_NULL_REF_POINTER);
9856             }
9857         RpcTryFinally
9858             {
9859
9860             _StubMsg.BufferLength = 0U;
9861             NdrProxyGetBuffer(This, &_StubMsg);
9862             NdrProxySendReceive(This, &_StubMsg);
9863
9864             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
9865                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[462] );
9866
9867             NdrUserMarshalUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
9868                                       (unsigned char __RPC_FAR * __RPC_FAR *)&pBstrSource,
9869                                       (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1128],
9870                                       (unsigned char)0 );
9871
9872             _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
9873             _RetVal = *( HRESULT __RPC_FAR * )_StubMsg.Buffer;
9874             _StubMsg.Buffer += sizeof(HRESULT);
9875
9876             }
9877         RpcFinally
9878             {
9879             NdrProxyFreeBuffer(This, &_StubMsg);
9880
9881             }
9882         RpcEndFinally
9883
9884         }
9885     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
9886         {
9887         NdrClearOutParameters(
9888                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
9889                          ( PFORMAT_STRING  )&__MIDL_TypeFormatString.Format[1708],
9890                          ( void __RPC_FAR * )pBstrSource);
9891         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
9892         }
9893     RpcEndExcept
9894     return _RetVal;
9895 }
9896
9897 void __RPC_STUB IErrorInfo_GetSource_Stub(
9898     IRpcStubBuffer *This,
9899     IRpcChannelBuffer *_pRpcChannelBuffer,
9900     PRPC_MESSAGE _pRpcMessage,
9901     DWORD *_pdwStubPhase)
9902 {
9903     BSTR _M91;
9904     HRESULT _RetVal;
9905     MIDL_STUB_MESSAGE _StubMsg;
9906     BSTR __RPC_FAR *pBstrSource;
9907
9908 NdrStubInitialize(
9909                      _pRpcMessage,
9910                      &_StubMsg,
9911                      &Object_StubDesc,
9912                      _pRpcChannelBuffer);
9913     pBstrSource = 0;
9914     RpcTryFinally
9915         {
9916         pBstrSource = &_M91;
9917         MIDL_memset(
9918                pBstrSource,
9919                0,
9920                sizeof( BSTR  ));
9921
9922         *_pdwStubPhase = STUB_CALL_SERVER;
9923         _RetVal = (((IErrorInfo*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> GetSource((IErrorInfo *) ((CStdStubBuffer *)This)->pvServerObject,pBstrSource);
9924
9925         *_pdwStubPhase = STUB_MARSHAL;
9926
9927         _StubMsg.BufferLength = 8U + 11U;
9928         NdrUserMarshalBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
9929                                   (unsigned char __RPC_FAR *)pBstrSource,
9930                                   (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1128] );
9931
9932         _StubMsg.BufferLength += 16;
9933
9934         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
9935         NdrUserMarshalMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
9936                                 (unsigned char __RPC_FAR *)pBstrSource,
9937                                 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1128] );
9938
9939         _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
9940         *( HRESULT __RPC_FAR * )_StubMsg.Buffer = _RetVal;
9941         _StubMsg.Buffer += sizeof(HRESULT);
9942
9943         }
9944     RpcFinally
9945         {
9946         NdrPointerFree( &_StubMsg,
9947                         (unsigned char __RPC_FAR *)pBstrSource,
9948                         &__MIDL_TypeFormatString.Format[1708] );
9949
9950         }
9951     RpcEndFinally
9952     _pRpcMessage->BufferLength =
9953         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
9954
9955 }
9956
9957
9958 HRESULT STDMETHODCALLTYPE IErrorInfo_GetDescription_Proxy(
9959     IErrorInfo __RPC_FAR * This,
9960     /* [out] */ BSTR __RPC_FAR *pBstrDescription)
9961 {
9962
9963     HRESULT _RetVal;
9964
9965     RPC_MESSAGE _RpcMessage;
9966
9967     MIDL_STUB_MESSAGE _StubMsg;
9968
9969     if(pBstrDescription)
9970         {
9971         MIDL_memset(
9972                pBstrDescription,
9973                0,
9974                sizeof( BSTR  ));
9975         }
9976     RpcTryExcept
9977         {
9978         NdrProxyInitialize(
9979                       ( void __RPC_FAR *  )This,
9980                       ( PRPC_MESSAGE  )&_RpcMessage,
9981                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
9982                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
9983                       5);
9984
9985
9986
9987         if(!pBstrDescription)
9988             {
9989             RpcRaiseException(RPC_X_NULL_REF_POINTER);
9990             }
9991         RpcTryFinally
9992             {
9993
9994             _StubMsg.BufferLength = 0U;
9995             NdrProxyGetBuffer(This, &_StubMsg);
9996             NdrProxySendReceive(This, &_StubMsg);
9997
9998             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
9999                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[462] );
10000
10001             NdrUserMarshalUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
10002                                       (unsigned char __RPC_FAR * __RPC_FAR *)&pBstrDescription,
10003                                       (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1128],
10004                                       (unsigned char)0 );
10005
10006             _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
10007             _RetVal = *( HRESULT __RPC_FAR * )_StubMsg.Buffer;
10008             _StubMsg.Buffer += sizeof(HRESULT);
10009
10010             }
10011         RpcFinally
10012             {
10013             NdrProxyFreeBuffer(This, &_StubMsg);
10014
10015             }
10016         RpcEndFinally
10017
10018         }
10019     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
10020         {
10021         NdrClearOutParameters(
10022                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
10023                          ( PFORMAT_STRING  )&__MIDL_TypeFormatString.Format[1708],
10024                          ( void __RPC_FAR * )pBstrDescription);
10025         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
10026         }
10027     RpcEndExcept
10028     return _RetVal;
10029 }
10030
10031 void __RPC_STUB IErrorInfo_GetDescription_Stub(
10032     IRpcStubBuffer *This,
10033     IRpcChannelBuffer *_pRpcChannelBuffer,
10034     PRPC_MESSAGE _pRpcMessage,
10035     DWORD *_pdwStubPhase)
10036 {
10037     BSTR _M92;
10038     HRESULT _RetVal;
10039     MIDL_STUB_MESSAGE _StubMsg;
10040     BSTR __RPC_FAR *pBstrDescription;
10041
10042 NdrStubInitialize(
10043                      _pRpcMessage,
10044                      &_StubMsg,
10045                      &Object_StubDesc,
10046                      _pRpcChannelBuffer);
10047     pBstrDescription = 0;
10048     RpcTryFinally
10049         {
10050         pBstrDescription = &_M92;
10051         MIDL_memset(
10052                pBstrDescription,
10053                0,
10054                sizeof( BSTR  ));
10055
10056         *_pdwStubPhase = STUB_CALL_SERVER;
10057         _RetVal = (((IErrorInfo*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> GetDescription((IErrorInfo *) ((CStdStubBuffer *)This)->pvServerObject,pBstrDescription);
10058
10059         *_pdwStubPhase = STUB_MARSHAL;
10060
10061         _StubMsg.BufferLength = 8U + 11U;
10062         NdrUserMarshalBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
10063                                   (unsigned char __RPC_FAR *)pBstrDescription,
10064                                   (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1128] );
10065
10066         _StubMsg.BufferLength += 16;
10067
10068         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
10069         NdrUserMarshalMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
10070                                 (unsigned char __RPC_FAR *)pBstrDescription,
10071                                 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1128] );
10072
10073         _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
10074         *( HRESULT __RPC_FAR * )_StubMsg.Buffer = _RetVal;
10075         _StubMsg.Buffer += sizeof(HRESULT);
10076
10077         }
10078     RpcFinally
10079         {
10080         NdrPointerFree( &_StubMsg,
10081                         (unsigned char __RPC_FAR *)pBstrDescription,
10082                         &__MIDL_TypeFormatString.Format[1708] );
10083
10084         }
10085     RpcEndFinally
10086     _pRpcMessage->BufferLength =
10087         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
10088
10089 }
10090
10091
10092 HRESULT STDMETHODCALLTYPE IErrorInfo_GetHelpFile_Proxy(
10093     IErrorInfo __RPC_FAR * This,
10094     /* [out] */ BSTR __RPC_FAR *pBstrHelpFile)
10095 {
10096
10097     HRESULT _RetVal;
10098
10099     RPC_MESSAGE _RpcMessage;
10100
10101     MIDL_STUB_MESSAGE _StubMsg;
10102
10103     if(pBstrHelpFile)
10104         {
10105         MIDL_memset(
10106                pBstrHelpFile,
10107                0,
10108                sizeof( BSTR  ));
10109         }
10110     RpcTryExcept
10111         {
10112         NdrProxyInitialize(
10113                       ( void __RPC_FAR *  )This,
10114                       ( PRPC_MESSAGE  )&_RpcMessage,
10115                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
10116                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
10117                       6);
10118
10119
10120
10121         if(!pBstrHelpFile)
10122             {
10123             RpcRaiseException(RPC_X_NULL_REF_POINTER);
10124             }
10125         RpcTryFinally
10126             {
10127
10128             _StubMsg.BufferLength = 0U;
10129             NdrProxyGetBuffer(This, &_StubMsg);
10130             NdrProxySendReceive(This, &_StubMsg);
10131
10132             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
10133                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[462] );
10134
10135             NdrUserMarshalUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
10136                                       (unsigned char __RPC_FAR * __RPC_FAR *)&pBstrHelpFile,
10137                                       (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1128],
10138                                       (unsigned char)0 );
10139
10140             _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
10141             _RetVal = *( HRESULT __RPC_FAR * )_StubMsg.Buffer;
10142             _StubMsg.Buffer += sizeof(HRESULT);
10143
10144             }
10145         RpcFinally
10146             {
10147             NdrProxyFreeBuffer(This, &_StubMsg);
10148
10149             }
10150         RpcEndFinally
10151
10152         }
10153     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
10154         {
10155         NdrClearOutParameters(
10156                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
10157                          ( PFORMAT_STRING  )&__MIDL_TypeFormatString.Format[1708],
10158                          ( void __RPC_FAR * )pBstrHelpFile);
10159         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
10160         }
10161     RpcEndExcept
10162     return _RetVal;
10163 }
10164
10165 void __RPC_STUB IErrorInfo_GetHelpFile_Stub(
10166     IRpcStubBuffer *This,
10167     IRpcChannelBuffer *_pRpcChannelBuffer,
10168     PRPC_MESSAGE _pRpcMessage,
10169     DWORD *_pdwStubPhase)
10170 {
10171     BSTR _M93;
10172     HRESULT _RetVal;
10173     MIDL_STUB_MESSAGE _StubMsg;
10174     BSTR __RPC_FAR *pBstrHelpFile;
10175
10176 NdrStubInitialize(
10177                      _pRpcMessage,
10178                      &_StubMsg,
10179                      &Object_StubDesc,
10180                      _pRpcChannelBuffer);
10181     pBstrHelpFile = 0;
10182     RpcTryFinally
10183         {
10184         pBstrHelpFile = &_M93;
10185         MIDL_memset(
10186                pBstrHelpFile,
10187                0,
10188                sizeof( BSTR  ));
10189
10190         *_pdwStubPhase = STUB_CALL_SERVER;
10191         _RetVal = (((IErrorInfo*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> GetHelpFile((IErrorInfo *) ((CStdStubBuffer *)This)->pvServerObject,pBstrHelpFile);
10192
10193         *_pdwStubPhase = STUB_MARSHAL;
10194
10195         _StubMsg.BufferLength = 8U + 11U;
10196         NdrUserMarshalBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
10197                                   (unsigned char __RPC_FAR *)pBstrHelpFile,
10198                                   (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1128] );
10199
10200         _StubMsg.BufferLength += 16;
10201
10202         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
10203         NdrUserMarshalMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
10204                                 (unsigned char __RPC_FAR *)pBstrHelpFile,
10205                                 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1128] );
10206
10207         _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
10208         *( HRESULT __RPC_FAR * )_StubMsg.Buffer = _RetVal;
10209         _StubMsg.Buffer += sizeof(HRESULT);
10210
10211         }
10212     RpcFinally
10213         {
10214         NdrPointerFree( &_StubMsg,
10215                         (unsigned char __RPC_FAR *)pBstrHelpFile,
10216                         &__MIDL_TypeFormatString.Format[1708] );
10217
10218         }
10219     RpcEndFinally
10220     _pRpcMessage->BufferLength =
10221         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
10222
10223 }
10224
10225
10226 HRESULT STDMETHODCALLTYPE IErrorInfo_GetHelpContext_Proxy(
10227     IErrorInfo __RPC_FAR * This,
10228     /* [out] */ DWORD __RPC_FAR *pdwHelpContext)
10229 {
10230
10231     HRESULT _RetVal;
10232
10233     RPC_MESSAGE _RpcMessage;
10234
10235     MIDL_STUB_MESSAGE _StubMsg;
10236
10237     RpcTryExcept
10238         {
10239         NdrProxyInitialize(
10240                       ( void __RPC_FAR *  )This,
10241                       ( PRPC_MESSAGE  )&_RpcMessage,
10242                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
10243                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
10244                       7);
10245
10246
10247
10248         if(!pdwHelpContext)
10249             {
10250             RpcRaiseException(RPC_X_NULL_REF_POINTER);
10251             }
10252         RpcTryFinally
10253             {
10254
10255             _StubMsg.BufferLength = 0U;
10256             NdrProxyGetBuffer(This, &_StubMsg);
10257             NdrProxySendReceive(This, &_StubMsg);
10258
10259             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
10260                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[0] );
10261
10262             *pdwHelpContext = *( DWORD __RPC_FAR * )_StubMsg.Buffer;
10263             _StubMsg.Buffer += sizeof(DWORD);
10264
10265             _RetVal = *( HRESULT __RPC_FAR * )_StubMsg.Buffer;
10266             _StubMsg.Buffer += sizeof(HRESULT);
10267
10268             }
10269         RpcFinally
10270             {
10271             NdrProxyFreeBuffer(This, &_StubMsg);
10272
10273             }
10274         RpcEndFinally
10275
10276         }
10277     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
10278         {
10279         NdrClearOutParameters(
10280                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
10281                          ( PFORMAT_STRING  )&__MIDL_TypeFormatString.Format[2],
10282                          ( void __RPC_FAR * )pdwHelpContext);
10283         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
10284         }
10285     RpcEndExcept
10286     return _RetVal;
10287 }
10288
10289 void __RPC_STUB IErrorInfo_GetHelpContext_Stub(
10290     IRpcStubBuffer *This,
10291     IRpcChannelBuffer *_pRpcChannelBuffer,
10292     PRPC_MESSAGE _pRpcMessage,
10293     DWORD *_pdwStubPhase)
10294 {
10295     DWORD _M94;
10296     HRESULT _RetVal;
10297     MIDL_STUB_MESSAGE _StubMsg;
10298     DWORD __RPC_FAR *pdwHelpContext;
10299
10300 NdrStubInitialize(
10301                      _pRpcMessage,
10302                      &_StubMsg,
10303                      &Object_StubDesc,
10304                      _pRpcChannelBuffer);
10305     pdwHelpContext = 0;
10306     RpcTryFinally
10307         {
10308         pdwHelpContext = &_M94;
10309
10310         *_pdwStubPhase = STUB_CALL_SERVER;
10311         _RetVal = (((IErrorInfo*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> GetHelpContext((IErrorInfo *) ((CStdStubBuffer *)This)->pvServerObject,pdwHelpContext);
10312
10313         *_pdwStubPhase = STUB_MARSHAL;
10314
10315         _StubMsg.BufferLength = 4U + 4U;
10316         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
10317         *( DWORD __RPC_FAR * )_StubMsg.Buffer = *pdwHelpContext;
10318         _StubMsg.Buffer += sizeof(DWORD);
10319
10320         *( HRESULT __RPC_FAR * )_StubMsg.Buffer = _RetVal;
10321         _StubMsg.Buffer += sizeof(HRESULT);
10322
10323         }
10324     RpcFinally
10325         {
10326         }
10327     RpcEndFinally
10328     _pRpcMessage->BufferLength =
10329         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
10330
10331 }
10332
10333 static const CINTERFACE_PROXY_VTABLE(8) _IErrorInfoProxyVtbl =
10334 {
10335     { &IID_IErrorInfo },
10336     {
10337         IUnknown_QueryInterface_Proxy,
10338         IUnknown_AddRef_Proxy,
10339         IUnknown_Release_Proxy ,
10340         IErrorInfo_GetGUID_Proxy ,
10341         IErrorInfo_GetSource_Proxy ,
10342         IErrorInfo_GetDescription_Proxy ,
10343         IErrorInfo_GetHelpFile_Proxy ,
10344         IErrorInfo_GetHelpContext_Proxy
10345     }
10346 };
10347
10348
10349 static const PRPC_STUB_FUNCTION IErrorInfo_table[] =
10350 {
10351     IErrorInfo_GetGUID_Stub,
10352     IErrorInfo_GetSource_Stub,
10353     IErrorInfo_GetDescription_Stub,
10354     IErrorInfo_GetHelpFile_Stub,
10355     IErrorInfo_GetHelpContext_Stub
10356 };
10357
10358 static const CInterfaceStubVtbl _IErrorInfoStubVtbl =
10359 {
10360     {
10361         &IID_IErrorInfo,
10362         0,
10363         8,
10364         &IErrorInfo_table[-3]
10365     },
10366     { CStdStubBuffer_METHODS }
10367 };
10368
10369
10370 /* Object interface: ICreateErrorInfo, ver. 0.0,
10371    GUID={0x22F03340,0x547D,0x101B,{0x8E,0x65,0x08,0x00,0x2B,0x2B,0xD1,0x19}} */
10372
10373
10374 extern const MIDL_STUB_DESC Object_StubDesc;
10375
10376
10377 HRESULT STDMETHODCALLTYPE ICreateErrorInfo_SetGUID_Proxy(
10378     ICreateErrorInfo __RPC_FAR * This,
10379     /* [in] */ REFGUID rguid)
10380 {
10381
10382     HRESULT _RetVal;
10383
10384     RPC_MESSAGE _RpcMessage;
10385
10386     MIDL_STUB_MESSAGE _StubMsg;
10387
10388     RpcTryExcept
10389         {
10390         NdrProxyInitialize(
10391                       ( void __RPC_FAR *  )This,
10392                       ( PRPC_MESSAGE  )&_RpcMessage,
10393                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
10394                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
10395                       3);
10396
10397
10398
10399         if(!rguid)
10400             {
10401             RpcRaiseException(RPC_X_NULL_REF_POINTER);
10402             }
10403         RpcTryFinally
10404             {
10405
10406             _StubMsg.BufferLength = 0U;
10407             NdrSimpleStructBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
10408                                        (unsigned char __RPC_FAR *)rguid,
10409                                        (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[38] );
10410
10411             NdrProxyGetBuffer(This, &_StubMsg);
10412             NdrSimpleStructMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
10413                                      (unsigned char __RPC_FAR *)rguid,
10414                                      (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[38] );
10415
10416             NdrProxySendReceive(This, &_StubMsg);
10417
10418             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
10419                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[468] );
10420
10421             _RetVal = *( HRESULT __RPC_FAR * )_StubMsg.Buffer;
10422             _StubMsg.Buffer += sizeof(HRESULT);
10423
10424             }
10425         RpcFinally
10426             {
10427             NdrProxyFreeBuffer(This, &_StubMsg);
10428
10429             }
10430         RpcEndFinally
10431
10432         }
10433     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
10434         {
10435         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
10436         }
10437     RpcEndExcept
10438     return _RetVal;
10439 }
10440
10441 void __RPC_STUB ICreateErrorInfo_SetGUID_Stub(
10442     IRpcStubBuffer *This,
10443     IRpcChannelBuffer *_pRpcChannelBuffer,
10444     PRPC_MESSAGE _pRpcMessage,
10445     DWORD *_pdwStubPhase)
10446 {
10447     HRESULT _RetVal;
10448     MIDL_STUB_MESSAGE _StubMsg;
10449     REFGUID rguid = 0;
10450
10451 NdrStubInitialize(
10452                      _pRpcMessage,
10453                      &_StubMsg,
10454                      &Object_StubDesc,
10455                      _pRpcChannelBuffer);
10456     RpcTryFinally
10457         {
10458         if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
10459             NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[468] );
10460
10461         NdrSimpleStructUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
10462                                    (unsigned char __RPC_FAR * __RPC_FAR *)&rguid,
10463                                    (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[38],
10464                                    (unsigned char)0 );
10465
10466
10467         *_pdwStubPhase = STUB_CALL_SERVER;
10468         _RetVal = (((ICreateErrorInfo*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> SetGUID((ICreateErrorInfo *) ((CStdStubBuffer *)This)->pvServerObject,rguid);
10469
10470         *_pdwStubPhase = STUB_MARSHAL;
10471
10472         _StubMsg.BufferLength = 4U;
10473         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
10474         *( HRESULT __RPC_FAR * )_StubMsg.Buffer = _RetVal;
10475         _StubMsg.Buffer += sizeof(HRESULT);
10476
10477         }
10478     RpcFinally
10479         {
10480         }
10481     RpcEndFinally
10482     _pRpcMessage->BufferLength =
10483         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
10484
10485 }
10486
10487
10488 HRESULT STDMETHODCALLTYPE ICreateErrorInfo_SetSource_Proxy(
10489     ICreateErrorInfo __RPC_FAR * This,
10490     /* [in] */ LPOLESTR szSource)
10491 {
10492
10493     HRESULT _RetVal;
10494
10495     RPC_MESSAGE _RpcMessage;
10496
10497     MIDL_STUB_MESSAGE _StubMsg;
10498
10499     RpcTryExcept
10500         {
10501         NdrProxyInitialize(
10502                       ( void __RPC_FAR *  )This,
10503                       ( PRPC_MESSAGE  )&_RpcMessage,
10504                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
10505                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
10506                       4);
10507
10508
10509
10510         if(!szSource)
10511             {
10512             RpcRaiseException(RPC_X_NULL_REF_POINTER);
10513             }
10514         RpcTryFinally
10515             {
10516
10517             _StubMsg.BufferLength = 12U;
10518             NdrConformantStringBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
10519                                            (unsigned char __RPC_FAR *)szSource,
10520                                            (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1248] );
10521
10522             NdrProxyGetBuffer(This, &_StubMsg);
10523             NdrConformantStringMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
10524                                          (unsigned char __RPC_FAR *)szSource,
10525                                          (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1248] );
10526
10527             NdrProxySendReceive(This, &_StubMsg);
10528
10529             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
10530                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[474] );
10531
10532             _RetVal = *( HRESULT __RPC_FAR * )_StubMsg.Buffer;
10533             _StubMsg.Buffer += sizeof(HRESULT);
10534
10535             }
10536         RpcFinally
10537             {
10538             NdrProxyFreeBuffer(This, &_StubMsg);
10539
10540             }
10541         RpcEndFinally
10542
10543         }
10544     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
10545         {
10546         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
10547         }
10548     RpcEndExcept
10549     return _RetVal;
10550 }
10551
10552 void __RPC_STUB ICreateErrorInfo_SetSource_Stub(
10553     IRpcStubBuffer *This,
10554     IRpcChannelBuffer *_pRpcChannelBuffer,
10555     PRPC_MESSAGE _pRpcMessage,
10556     DWORD *_pdwStubPhase)
10557 {
10558     HRESULT _RetVal;
10559     MIDL_STUB_MESSAGE _StubMsg;
10560     LPOLESTR szSource;
10561
10562 NdrStubInitialize(
10563                      _pRpcMessage,
10564                      &_StubMsg,
10565                      &Object_StubDesc,
10566                      _pRpcChannelBuffer);
10567     szSource = 0;
10568     RpcTryFinally
10569         {
10570         if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
10571             NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[474] );
10572
10573         NdrConformantStringUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
10574                                        (unsigned char __RPC_FAR * __RPC_FAR *)&szSource,
10575                                        (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1248],
10576                                        (unsigned char)0 );
10577
10578
10579         *_pdwStubPhase = STUB_CALL_SERVER;
10580         _RetVal = (((ICreateErrorInfo*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> SetSource((ICreateErrorInfo *) ((CStdStubBuffer *)This)->pvServerObject,szSource);
10581
10582         *_pdwStubPhase = STUB_MARSHAL;
10583
10584         _StubMsg.BufferLength = 4U;
10585         _StubMsg.BufferLength += 16;
10586
10587         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
10588         *( HRESULT __RPC_FAR * )_StubMsg.Buffer = _RetVal;
10589         _StubMsg.Buffer += sizeof(HRESULT);
10590
10591         }
10592     RpcFinally
10593         {
10594         }
10595     RpcEndFinally
10596     _pRpcMessage->BufferLength =
10597         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
10598
10599 }
10600
10601
10602 HRESULT STDMETHODCALLTYPE ICreateErrorInfo_SetDescription_Proxy(
10603     ICreateErrorInfo __RPC_FAR * This,
10604     /* [in] */ LPOLESTR szDescription)
10605 {
10606
10607     HRESULT _RetVal;
10608
10609     RPC_MESSAGE _RpcMessage;
10610
10611     MIDL_STUB_MESSAGE _StubMsg;
10612
10613     RpcTryExcept
10614         {
10615         NdrProxyInitialize(
10616                       ( void __RPC_FAR *  )This,
10617                       ( PRPC_MESSAGE  )&_RpcMessage,
10618                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
10619                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
10620                       5);
10621
10622
10623
10624         if(!szDescription)
10625             {
10626             RpcRaiseException(RPC_X_NULL_REF_POINTER);
10627             }
10628         RpcTryFinally
10629             {
10630
10631             _StubMsg.BufferLength = 12U;
10632             NdrConformantStringBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
10633                                            (unsigned char __RPC_FAR *)szDescription,
10634                                            (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1248] );
10635
10636             NdrProxyGetBuffer(This, &_StubMsg);
10637             NdrConformantStringMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
10638                                          (unsigned char __RPC_FAR *)szDescription,
10639                                          (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1248] );
10640
10641             NdrProxySendReceive(This, &_StubMsg);
10642
10643             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
10644                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[474] );
10645
10646             _RetVal = *( HRESULT __RPC_FAR * )_StubMsg.Buffer;
10647             _StubMsg.Buffer += sizeof(HRESULT);
10648
10649             }
10650         RpcFinally
10651             {
10652             NdrProxyFreeBuffer(This, &_StubMsg);
10653
10654             }
10655         RpcEndFinally
10656
10657         }
10658     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
10659         {
10660         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
10661         }
10662     RpcEndExcept
10663     return _RetVal;
10664 }
10665
10666 void __RPC_STUB ICreateErrorInfo_SetDescription_Stub(
10667     IRpcStubBuffer *This,
10668     IRpcChannelBuffer *_pRpcChannelBuffer,
10669     PRPC_MESSAGE _pRpcMessage,
10670     DWORD *_pdwStubPhase)
10671 {
10672     HRESULT _RetVal;
10673     MIDL_STUB_MESSAGE _StubMsg;
10674     LPOLESTR szDescription;
10675
10676 NdrStubInitialize(
10677                      _pRpcMessage,
10678                      &_StubMsg,
10679                      &Object_StubDesc,
10680                      _pRpcChannelBuffer);
10681     szDescription = 0;
10682     RpcTryFinally
10683         {
10684         if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
10685             NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[474] );
10686
10687         NdrConformantStringUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
10688                                        (unsigned char __RPC_FAR * __RPC_FAR *)&szDescription,
10689                                        (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1248],
10690                                        (unsigned char)0 );
10691
10692
10693         *_pdwStubPhase = STUB_CALL_SERVER;
10694         _RetVal = (((ICreateErrorInfo*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> SetDescription((ICreateErrorInfo *) ((CStdStubBuffer *)This)->pvServerObject,szDescription);
10695
10696         *_pdwStubPhase = STUB_MARSHAL;
10697
10698         _StubMsg.BufferLength = 4U;
10699         _StubMsg.BufferLength += 16;
10700
10701         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
10702         *( HRESULT __RPC_FAR * )_StubMsg.Buffer = _RetVal;
10703         _StubMsg.Buffer += sizeof(HRESULT);
10704
10705         }
10706     RpcFinally
10707         {
10708         }
10709     RpcEndFinally
10710     _pRpcMessage->BufferLength =
10711         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
10712
10713 }
10714
10715
10716 HRESULT STDMETHODCALLTYPE ICreateErrorInfo_SetHelpFile_Proxy(
10717     ICreateErrorInfo __RPC_FAR * This,
10718     /* [in] */ LPOLESTR szHelpFile)
10719 {
10720
10721     HRESULT _RetVal;
10722
10723     RPC_MESSAGE _RpcMessage;
10724
10725     MIDL_STUB_MESSAGE _StubMsg;
10726
10727     RpcTryExcept
10728         {
10729         NdrProxyInitialize(
10730                       ( void __RPC_FAR *  )This,
10731                       ( PRPC_MESSAGE  )&_RpcMessage,
10732                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
10733                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
10734                       6);
10735
10736
10737
10738         if(!szHelpFile)
10739             {
10740             RpcRaiseException(RPC_X_NULL_REF_POINTER);
10741             }
10742         RpcTryFinally
10743             {
10744
10745             _StubMsg.BufferLength = 12U;
10746             NdrConformantStringBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
10747                                            (unsigned char __RPC_FAR *)szHelpFile,
10748                                            (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1248] );
10749
10750             NdrProxyGetBuffer(This, &_StubMsg);
10751             NdrConformantStringMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
10752                                          (unsigned char __RPC_FAR *)szHelpFile,
10753                                          (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1248] );
10754
10755             NdrProxySendReceive(This, &_StubMsg);
10756
10757             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
10758                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[474] );
10759
10760             _RetVal = *( HRESULT __RPC_FAR * )_StubMsg.Buffer;
10761             _StubMsg.Buffer += sizeof(HRESULT);
10762
10763             }
10764         RpcFinally
10765             {
10766             NdrProxyFreeBuffer(This, &_StubMsg);
10767
10768             }
10769         RpcEndFinally
10770
10771         }
10772     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
10773         {
10774         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
10775         }
10776     RpcEndExcept
10777     return _RetVal;
10778 }
10779
10780 void __RPC_STUB ICreateErrorInfo_SetHelpFile_Stub(
10781     IRpcStubBuffer *This,
10782     IRpcChannelBuffer *_pRpcChannelBuffer,
10783     PRPC_MESSAGE _pRpcMessage,
10784     DWORD *_pdwStubPhase)
10785 {
10786     HRESULT _RetVal;
10787     MIDL_STUB_MESSAGE _StubMsg;
10788     LPOLESTR szHelpFile;
10789
10790 NdrStubInitialize(
10791                      _pRpcMessage,
10792                      &_StubMsg,
10793                      &Object_StubDesc,
10794                      _pRpcChannelBuffer);
10795     szHelpFile = 0;
10796     RpcTryFinally
10797         {
10798         if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
10799             NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[474] );
10800
10801         NdrConformantStringUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
10802                                        (unsigned char __RPC_FAR * __RPC_FAR *)&szHelpFile,
10803                                        (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1248],
10804                                        (unsigned char)0 );
10805
10806
10807         *_pdwStubPhase = STUB_CALL_SERVER;
10808         _RetVal = (((ICreateErrorInfo*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> SetHelpFile((ICreateErrorInfo *) ((CStdStubBuffer *)This)->pvServerObject,szHelpFile);
10809
10810         *_pdwStubPhase = STUB_MARSHAL;
10811
10812         _StubMsg.BufferLength = 4U;
10813         _StubMsg.BufferLength += 16;
10814
10815         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
10816         *( HRESULT __RPC_FAR * )_StubMsg.Buffer = _RetVal;
10817         _StubMsg.Buffer += sizeof(HRESULT);
10818
10819         }
10820     RpcFinally
10821         {
10822         }
10823     RpcEndFinally
10824     _pRpcMessage->BufferLength =
10825         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
10826
10827 }
10828
10829
10830 HRESULT STDMETHODCALLTYPE ICreateErrorInfo_SetHelpContext_Proxy(
10831     ICreateErrorInfo __RPC_FAR * This,
10832     /* [in] */ DWORD dwHelpContext)
10833 {
10834
10835     HRESULT _RetVal;
10836
10837     RPC_MESSAGE _RpcMessage;
10838
10839     MIDL_STUB_MESSAGE _StubMsg;
10840
10841     RpcTryExcept
10842         {
10843         NdrProxyInitialize(
10844                       ( void __RPC_FAR *  )This,
10845                       ( PRPC_MESSAGE  )&_RpcMessage,
10846                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
10847                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
10848                       7);
10849
10850
10851
10852         RpcTryFinally
10853             {
10854
10855             _StubMsg.BufferLength = 4U;
10856             NdrProxyGetBuffer(This, &_StubMsg);
10857             *( DWORD __RPC_FAR * )_StubMsg.Buffer = dwHelpContext;
10858             _StubMsg.Buffer += sizeof(DWORD);
10859
10860             NdrProxySendReceive(This, &_StubMsg);
10861
10862             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
10863                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[84] );
10864
10865             _RetVal = *( HRESULT __RPC_FAR * )_StubMsg.Buffer;
10866             _StubMsg.Buffer += sizeof(HRESULT);
10867
10868             }
10869         RpcFinally
10870             {
10871             NdrProxyFreeBuffer(This, &_StubMsg);
10872
10873             }
10874         RpcEndFinally
10875
10876         }
10877     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
10878         {
10879         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
10880         }
10881     RpcEndExcept
10882     return _RetVal;
10883 }
10884
10885 void __RPC_STUB ICreateErrorInfo_SetHelpContext_Stub(
10886     IRpcStubBuffer *This,
10887     IRpcChannelBuffer *_pRpcChannelBuffer,
10888     PRPC_MESSAGE _pRpcMessage,
10889     DWORD *_pdwStubPhase)
10890 {
10891     HRESULT _RetVal;
10892     MIDL_STUB_MESSAGE _StubMsg;
10893     DWORD dwHelpContext;
10894
10895 NdrStubInitialize(
10896                      _pRpcMessage,
10897                      &_StubMsg,
10898                      &Object_StubDesc,
10899                      _pRpcChannelBuffer);
10900     RpcTryFinally
10901         {
10902         if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
10903             NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[84] );
10904
10905         dwHelpContext = *( DWORD __RPC_FAR * )_StubMsg.Buffer;
10906         _StubMsg.Buffer += sizeof(DWORD);
10907
10908
10909         *_pdwStubPhase = STUB_CALL_SERVER;
10910         _RetVal = (((ICreateErrorInfo*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> SetHelpContext((ICreateErrorInfo *) ((CStdStubBuffer *)This)->pvServerObject,dwHelpContext);
10911
10912         *_pdwStubPhase = STUB_MARSHAL;
10913
10914         _StubMsg.BufferLength = 4U;
10915         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
10916         *( HRESULT __RPC_FAR * )_StubMsg.Buffer = _RetVal;
10917         _StubMsg.Buffer += sizeof(HRESULT);
10918
10919         }
10920     RpcFinally
10921         {
10922         }
10923     RpcEndFinally
10924     _pRpcMessage->BufferLength =
10925         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
10926
10927 }
10928
10929 static const CINTERFACE_PROXY_VTABLE(8) _ICreateErrorInfoProxyVtbl =
10930 {
10931     { &IID_ICreateErrorInfo },
10932     {
10933         IUnknown_QueryInterface_Proxy,
10934         IUnknown_AddRef_Proxy,
10935         IUnknown_Release_Proxy ,
10936         ICreateErrorInfo_SetGUID_Proxy ,
10937         ICreateErrorInfo_SetSource_Proxy ,
10938         ICreateErrorInfo_SetDescription_Proxy ,
10939         ICreateErrorInfo_SetHelpFile_Proxy ,
10940         ICreateErrorInfo_SetHelpContext_Proxy
10941     }
10942 };
10943
10944
10945 static const PRPC_STUB_FUNCTION ICreateErrorInfo_table[] =
10946 {
10947     ICreateErrorInfo_SetGUID_Stub,
10948     ICreateErrorInfo_SetSource_Stub,
10949     ICreateErrorInfo_SetDescription_Stub,
10950     ICreateErrorInfo_SetHelpFile_Stub,
10951     ICreateErrorInfo_SetHelpContext_Stub
10952 };
10953
10954 static const CInterfaceStubVtbl _ICreateErrorInfoStubVtbl =
10955 {
10956     {
10957         &IID_ICreateErrorInfo,
10958         0,
10959         8,
10960         &ICreateErrorInfo_table[-3]
10961     },
10962     { CStdStubBuffer_METHODS }
10963 };
10964
10965
10966 /* Object interface: ISupportErrorInfo, ver. 0.0,
10967    GUID={0xDF0B3D60,0x548F,0x101B,{0x8E,0x65,0x08,0x00,0x2B,0x2B,0xD1,0x19}} */
10968
10969
10970 extern const MIDL_STUB_DESC Object_StubDesc;
10971
10972
10973 HRESULT STDMETHODCALLTYPE ISupportErrorInfo_InterfaceSupportsErrorInfo_Proxy(
10974     ISupportErrorInfo __RPC_FAR * This,
10975     /* [in] */ REFIID riid)
10976 {
10977
10978     HRESULT _RetVal;
10979
10980     RPC_MESSAGE _RpcMessage;
10981
10982     MIDL_STUB_MESSAGE _StubMsg;
10983
10984     RpcTryExcept
10985         {
10986         NdrProxyInitialize(
10987                       ( void __RPC_FAR *  )This,
10988                       ( PRPC_MESSAGE  )&_RpcMessage,
10989                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
10990                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
10991                       3);
10992
10993
10994
10995         if(!riid)
10996             {
10997             RpcRaiseException(RPC_X_NULL_REF_POINTER);
10998             }
10999         RpcTryFinally
11000             {
11001
11002             _StubMsg.BufferLength = 0U;
11003             NdrSimpleStructBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
11004                                        (unsigned char __RPC_FAR *)riid,
11005                                        (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[38] );
11006
11007             NdrProxyGetBuffer(This, &_StubMsg);
11008             NdrSimpleStructMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
11009                                      (unsigned char __RPC_FAR *)riid,
11010                                      (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[38] );
11011
11012             NdrProxySendReceive(This, &_StubMsg);
11013
11014             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
11015                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[468] );
11016
11017             _RetVal = *( HRESULT __RPC_FAR * )_StubMsg.Buffer;
11018             _StubMsg.Buffer += sizeof(HRESULT);
11019
11020             }
11021         RpcFinally
11022             {
11023             NdrProxyFreeBuffer(This, &_StubMsg);
11024
11025             }
11026         RpcEndFinally
11027
11028         }
11029     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
11030         {
11031         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
11032         }
11033     RpcEndExcept
11034     return _RetVal;
11035 }
11036
11037 void __RPC_STUB ISupportErrorInfo_InterfaceSupportsErrorInfo_Stub(
11038     IRpcStubBuffer *This,
11039     IRpcChannelBuffer *_pRpcChannelBuffer,
11040     PRPC_MESSAGE _pRpcMessage,
11041     DWORD *_pdwStubPhase)
11042 {
11043     HRESULT _RetVal;
11044     MIDL_STUB_MESSAGE _StubMsg;
11045     IID* riid = 0;
11046
11047 NdrStubInitialize(
11048                      _pRpcMessage,
11049                      &_StubMsg,
11050                      &Object_StubDesc,
11051                      _pRpcChannelBuffer);
11052     RpcTryFinally
11053         {
11054         if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
11055             NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[468] );
11056
11057         NdrSimpleStructUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
11058                                    (unsigned char __RPC_FAR * __RPC_FAR *)&riid,
11059                                    (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[38],
11060                                    (unsigned char)0 );
11061
11062
11063         *_pdwStubPhase = STUB_CALL_SERVER;
11064         _RetVal = (((ISupportErrorInfo*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> InterfaceSupportsErrorInfo((ISupportErrorInfo *) ((CStdStubBuffer *)This)->pvServerObject,riid);
11065
11066         *_pdwStubPhase = STUB_MARSHAL;
11067
11068         _StubMsg.BufferLength = 4U;
11069         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
11070         *( HRESULT __RPC_FAR * )_StubMsg.Buffer = _RetVal;
11071         _StubMsg.Buffer += sizeof(HRESULT);
11072
11073         }
11074     RpcFinally
11075         {
11076         }
11077     RpcEndFinally
11078     _pRpcMessage->BufferLength =
11079         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
11080
11081 }
11082
11083 static const CINTERFACE_PROXY_VTABLE(4) _ISupportErrorInfoProxyVtbl =
11084 {
11085     { &IID_ISupportErrorInfo },
11086     {
11087         IUnknown_QueryInterface_Proxy,
11088         IUnknown_AddRef_Proxy,
11089         IUnknown_Release_Proxy ,
11090         ISupportErrorInfo_InterfaceSupportsErrorInfo_Proxy
11091     }
11092 };
11093
11094
11095 static const PRPC_STUB_FUNCTION ISupportErrorInfo_table[] =
11096 {
11097     ISupportErrorInfo_InterfaceSupportsErrorInfo_Stub
11098 };
11099
11100 static const CInterfaceStubVtbl _ISupportErrorInfoStubVtbl =
11101 {
11102     {
11103         &IID_ISupportErrorInfo,
11104         0,
11105         4,
11106         &ISupportErrorInfo_table[-3]
11107     },
11108     { CStdStubBuffer_METHODS }
11109 };
11110
11111
11112 /* Object interface: ITypeFactory, ver. 0.0,
11113    GUID={0x0000002E,0x0000,0x0000,{0xC0,0x00,0x00,0x00,0x00,0x00,0x00,0x46}} */
11114
11115
11116 extern const MIDL_STUB_DESC Object_StubDesc;
11117
11118
11119 HRESULT STDMETHODCALLTYPE ITypeFactory_CreateFromTypeInfo_Proxy(
11120     ITypeFactory __RPC_FAR * This,
11121     /* [in] */ ITypeInfo __RPC_FAR *pTypeInfo,
11122     /* [in] */ REFIID riid,
11123     /* [iid_is][out] */ IUnknown __RPC_FAR *__RPC_FAR *ppv)
11124 {
11125
11126     HRESULT _RetVal;
11127
11128     RPC_MESSAGE _RpcMessage;
11129
11130     MIDL_STUB_MESSAGE _StubMsg;
11131
11132     if(ppv)
11133         {
11134         MIDL_memset(
11135                ppv,
11136                0,
11137                sizeof( IUnknown __RPC_FAR *__RPC_FAR * ));
11138         }
11139     RpcTryExcept
11140         {
11141         NdrProxyInitialize(
11142                       ( void __RPC_FAR *  )This,
11143                       ( PRPC_MESSAGE  )&_RpcMessage,
11144                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
11145                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
11146                       3);
11147
11148
11149
11150         if(!riid)
11151             {
11152             RpcRaiseException(RPC_X_NULL_REF_POINTER);
11153             }
11154         if(!ppv)
11155             {
11156             RpcRaiseException(RPC_X_NULL_REF_POINTER);
11157             }
11158         RpcTryFinally
11159             {
11160
11161             _StubMsg.BufferLength = 0U + 0U;
11162             NdrInterfacePointerBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
11163                                            (unsigned char __RPC_FAR *)pTypeInfo,
11164                                            (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[10] );
11165
11166             NdrSimpleStructBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
11167                                        (unsigned char __RPC_FAR *)riid,
11168                                        (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[38] );
11169
11170             NdrProxyGetBuffer(This, &_StubMsg);
11171             NdrInterfacePointerMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
11172                                          (unsigned char __RPC_FAR *)pTypeInfo,
11173                                          (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[10] );
11174
11175             NdrSimpleStructMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
11176                                      (unsigned char __RPC_FAR *)riid,
11177                                      (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[38] );
11178
11179             NdrProxySendReceive(This, &_StubMsg);
11180
11181             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
11182                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[480] );
11183
11184             NdrPointerUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
11185                                   (unsigned char __RPC_FAR * __RPC_FAR *)&ppv,
11186                                   (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1896],
11187                                   (unsigned char)0 );
11188
11189             _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
11190             _RetVal = *( HRESULT __RPC_FAR * )_StubMsg.Buffer;
11191             _StubMsg.Buffer += sizeof(HRESULT);
11192
11193             }
11194         RpcFinally
11195             {
11196             NdrProxyFreeBuffer(This, &_StubMsg);
11197
11198             }
11199         RpcEndFinally
11200
11201         }
11202     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
11203         {
11204         _StubMsg.MaxCount = (unsigned long) ( riid );
11205
11206         NdrClearOutParameters(
11207                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
11208                          ( PFORMAT_STRING  )&__MIDL_TypeFormatString.Format[1896],
11209                          ( void __RPC_FAR * )ppv);
11210         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
11211         }
11212     RpcEndExcept
11213     return _RetVal;
11214 }
11215
11216 void __RPC_STUB ITypeFactory_CreateFromTypeInfo_Stub(
11217     IRpcStubBuffer *This,
11218     IRpcChannelBuffer *_pRpcChannelBuffer,
11219     PRPC_MESSAGE _pRpcMessage,
11220     DWORD *_pdwStubPhase)
11221 {
11222     IUnknown __RPC_FAR *__RPC_FAR *_M101;
11223     HRESULT _RetVal;
11224     MIDL_STUB_MESSAGE _StubMsg;
11225     ITypeInfo __RPC_FAR *pTypeInfo;
11226     IUnknown __RPC_FAR *__RPC_FAR *ppv;
11227     IID* riid = 0;
11228
11229 NdrStubInitialize(
11230                      _pRpcMessage,
11231                      &_StubMsg,
11232                      &Object_StubDesc,
11233                      _pRpcChannelBuffer);
11234     pTypeInfo = 0;
11235     ppv = 0;
11236     RpcTryFinally
11237         {
11238         if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
11239             NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[480] );
11240
11241         NdrInterfacePointerUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
11242                                        (unsigned char __RPC_FAR * __RPC_FAR *)&pTypeInfo,
11243                                        (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[10],
11244                                        (unsigned char)0 );
11245
11246         NdrSimpleStructUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
11247                                    (unsigned char __RPC_FAR * __RPC_FAR *)&riid,
11248                                    (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[38],
11249                                    (unsigned char)0 );
11250
11251         ppv = (void *)&_M101;
11252         _M101 = 0;
11253
11254         *_pdwStubPhase = STUB_CALL_SERVER;
11255         _RetVal = (((ITypeFactory*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> CreateFromTypeInfo(
11256                       (ITypeFactory *) ((CStdStubBuffer *)This)->pvServerObject,
11257                       pTypeInfo,
11258                       riid,
11259                       ppv);
11260
11261         *_pdwStubPhase = STUB_MARSHAL;
11262
11263         _StubMsg.BufferLength = 0U + 4U;
11264         _StubMsg.MaxCount = (unsigned long) ( riid );
11265
11266         NdrPointerBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
11267                               (unsigned char __RPC_FAR *)ppv,
11268                               (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1896] );
11269
11270         _StubMsg.BufferLength += 16;
11271
11272         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
11273         _StubMsg.MaxCount = (unsigned long) ( riid );
11274
11275         NdrPointerMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
11276                             (unsigned char __RPC_FAR *)ppv,
11277                             (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1896] );
11278
11279         _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
11280         *( HRESULT __RPC_FAR * )_StubMsg.Buffer = _RetVal;
11281         _StubMsg.Buffer += sizeof(HRESULT);
11282
11283         }
11284     RpcFinally
11285         {
11286         NdrInterfacePointerFree( &_StubMsg,
11287                                  (unsigned char __RPC_FAR *)pTypeInfo,
11288                                  &__MIDL_TypeFormatString.Format[10] );
11289
11290         _StubMsg.MaxCount = (unsigned long) ( riid );
11291
11292         NdrPointerFree( &_StubMsg,
11293                         (unsigned char __RPC_FAR *)ppv,
11294                         &__MIDL_TypeFormatString.Format[1896] );
11295
11296         }
11297     RpcEndFinally
11298     _pRpcMessage->BufferLength =
11299         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
11300
11301 }
11302
11303 static const USER_MARSHAL_ROUTINE_QUADRUPLE UserMarshalRoutines[3] =
11304         {
11305             {
11306                 (USER_MARSHAL_SIZING_ROUTINE)VARIANT_UserSize,
11307                 (USER_MARSHAL_MARSHALLING_ROUTINE)VARIANT_UserMarshal,
11308                 (USER_MARSHAL_UNMARSHALLING_ROUTINE)VARIANT_UserUnmarshal,
11309                 (USER_MARSHAL_FREEING_ROUTINE)VARIANT_UserFree
11310             },
11311             {
11312                 (USER_MARSHAL_SIZING_ROUTINE)BSTR_UserSize,
11313                 (USER_MARSHAL_MARSHALLING_ROUTINE)BSTR_UserMarshal,
11314                 (USER_MARSHAL_UNMARSHALLING_ROUTINE)BSTR_UserUnmarshal,
11315                 (USER_MARSHAL_FREEING_ROUTINE)BSTR_UserFree
11316             },
11317             {
11318                 (USER_MARSHAL_SIZING_ROUTINE)CLEANLOCALSTORAGE_UserSize,
11319                 (USER_MARSHAL_MARSHALLING_ROUTINE)CLEANLOCALSTORAGE_UserMarshal,
11320                 (USER_MARSHAL_UNMARSHALLING_ROUTINE)CLEANLOCALSTORAGE_UserUnmarshal,
11321                 (USER_MARSHAL_FREEING_ROUTINE)CLEANLOCALSTORAGE_UserFree
11322             }
11323
11324         };
11325
11326 static const MIDL_STUB_DESC Object_StubDesc =
11327     {
11328     0,
11329     NdrOleAllocate,
11330     NdrOleFree,
11331     { 0 },
11332     0,
11333     0,
11334     0,
11335     0,
11336     __MIDL_TypeFormatString.Format,
11337     1, /* -error bounds_check flag */
11338     0x20000, /* Ndr library version */
11339     0,
11340     0x50100a4, /* MIDL Version 5.1.164 */
11341     0,
11342     UserMarshalRoutines,
11343     0,  /* notify & notify_flag routine table */
11344     1,  /* Flags */
11345     0,  /* Reserved3 */
11346     0,  /* Reserved4 */
11347     0   /* Reserved5 */
11348     };
11349
11350 static const CINTERFACE_PROXY_VTABLE(4) _ITypeFactoryProxyVtbl =
11351 {
11352     { &IID_ITypeFactory },
11353     {
11354         IUnknown_QueryInterface_Proxy,
11355         IUnknown_AddRef_Proxy,
11356         IUnknown_Release_Proxy ,
11357         ITypeFactory_CreateFromTypeInfo_Proxy
11358     }
11359 };
11360
11361
11362 static const PRPC_STUB_FUNCTION ITypeFactory_table[] =
11363 {
11364     ITypeFactory_CreateFromTypeInfo_Stub
11365 };
11366
11367 static const CInterfaceStubVtbl _ITypeFactoryStubVtbl =
11368 {
11369     {
11370         &IID_ITypeFactory,
11371         0,
11372         4,
11373         &ITypeFactory_table[-3]
11374     },
11375     { CStdStubBuffer_METHODS }
11376 };
11377
11378
11379 /* Object interface: ITypeMarshal, ver. 0.0,
11380    GUID={0x0000002D,0x0000,0x0000,{0xC0,0x00,0x00,0x00,0x00,0x00,0x00,0x46}} */
11381
11382
11383 /* Object interface: IRecordInfo, ver. 0.0,
11384    GUID={0x0000002F,0x0000,0x0000,{0xC0,0x00,0x00,0x00,0x00,0x00,0x00,0x46}} */
11385
11386
11387 /* Object interface: ICreateTypeInfo, ver. 0.0,
11388    GUID={0x00020405,0x0000,0x0000,{0xC0,0x00,0x00,0x00,0x00,0x00,0x00,0x46}} */
11389
11390
11391 /* Object interface: ICreateTypeInfo2, ver. 0.0,
11392    GUID={0x0002040E,0x0000,0x0000,{0xC0,0x00,0x00,0x00,0x00,0x00,0x00,0x46}} */
11393
11394
11395 /* Object interface: ICreateTypeLib, ver. 0.0,
11396    GUID={0x00020406,0x0000,0x0000,{0xC0,0x00,0x00,0x00,0x00,0x00,0x00,0x46}} */
11397
11398
11399 /* Object interface: ICreateTypeLib2, ver. 0.0,
11400    GUID={0x0002040F,0x0000,0x0000,{0xC0,0x00,0x00,0x00,0x00,0x00,0x00,0x46}} */
11401
11402 #if !defined(__RPC_WIN32__)
11403 #error  Invalid build platform for this stub.
11404 #endif
11405
11406 #if !(TARGET_IS_NT40_OR_LATER)
11407 #error You need a Windows NT 4.0 or later to run this stub because it uses these features:
11408 #error   [wire_marshal] or [user_marshal] attribute.
11409 #error However, your C/C++ compilation flags indicate you intend to run this app on earlier systems.
11410 #error This app will die there with the RPC_X_WRONG_STUB_VERSION error.
11411 #endif
11412
11413
11414 static const MIDL_PROC_FORMAT_STRING __MIDL_ProcFormatString =
11415     {
11416         0,
11417         {
11418
11419                         0x51,           /* FC_OUT_PARAM */
11420 #ifndef _ALPHA_
11421                         0x1,            /* x86, MIPS & PPC Stack size = 1 */
11422 #else
11423                         0x2,            /* Alpha Stack size = 2 */
11424 #endif
11425 /*  2 */        NdrFcShort( 0x2 ),      /* Type Offset=2 */
11426 /*  4 */        0x53,           /* FC_RETURN_PARAM_BASETYPE */
11427                         0x8,            /* FC_LONG */
11428 /*  6 */        0x4e,           /* FC_IN_PARAM_BASETYPE */
11429                         0x8,            /* FC_LONG */
11430 /*  8 */        0x4e,           /* FC_IN_PARAM_BASETYPE */
11431                         0x8,            /* FC_LONG */
11432 /* 10 */
11433                         0x51,           /* FC_OUT_PARAM */
11434 #ifndef _ALPHA_
11435                         0x1,            /* x86, MIPS & PPC Stack size = 1 */
11436 #else
11437                         0x2,            /* Alpha Stack size = 2 */
11438 #endif
11439 /* 12 */        NdrFcShort( 0x6 ),      /* Type Offset=6 */
11440 /* 14 */        0x53,           /* FC_RETURN_PARAM_BASETYPE */
11441                         0x8,            /* FC_LONG */
11442 /* 16 */
11443                         0x4d,           /* FC_IN_PARAM */
11444 #ifndef _ALPHA_
11445                         0x1,            /* x86, MIPS & PPC Stack size = 1 */
11446 #else
11447                         0x2,            /* Alpha Stack size = 2 */
11448 #endif
11449 /* 18 */        NdrFcShort( 0x1c ),     /* Type Offset=28 */
11450 /* 20 */
11451                         0x4d,           /* FC_IN_PARAM */
11452 #ifndef _ALPHA_
11453                         0x1,            /* x86, MIPS & PPC Stack size = 1 */
11454 #else
11455                         0x2,            /* Alpha Stack size = 2 */
11456 #endif
11457 /* 22 */        NdrFcShort( 0x32 ),     /* Type Offset=50 */
11458 /* 24 */        0x4e,           /* FC_IN_PARAM_BASETYPE */
11459                         0x8,            /* FC_LONG */
11460 /* 26 */        0x4e,           /* FC_IN_PARAM_BASETYPE */
11461                         0x8,            /* FC_LONG */
11462 /* 28 */
11463                         0x51,           /* FC_OUT_PARAM */
11464 #ifndef _ALPHA_
11465                         0x1,            /* x86, MIPS & PPC Stack size = 1 */
11466 #else
11467                         0x2,            /* Alpha Stack size = 2 */
11468 #endif
11469 /* 30 */        NdrFcShort( 0x54 ),     /* Type Offset=84 */
11470 /* 32 */        0x53,           /* FC_RETURN_PARAM_BASETYPE */
11471                         0x8,            /* FC_LONG */
11472 /* 34 */        0x4e,           /* FC_IN_PARAM_BASETYPE */
11473                         0x8,            /* FC_LONG */
11474 /* 36 */
11475                         0x4d,           /* FC_IN_PARAM */
11476 #ifndef _ALPHA_
11477                         0x1,            /* x86, MIPS & PPC Stack size = 1 */
11478 #else
11479                         0x2,            /* Alpha Stack size = 2 */
11480 #endif
11481 /* 38 */        NdrFcShort( 0x1c ),     /* Type Offset=28 */
11482 /* 40 */        0x4e,           /* FC_IN_PARAM_BASETYPE */
11483                         0x8,            /* FC_LONG */
11484 /* 42 */        0x4e,           /* FC_IN_PARAM_BASETYPE */
11485                         0x8,            /* FC_LONG */
11486 /* 44 */
11487                         0x4d,           /* FC_IN_PARAM */
11488 #ifndef _ALPHA_
11489                         0x1,            /* x86, MIPS & PPC Stack size = 1 */
11490 #else
11491                         0x2,            /* Alpha Stack size = 2 */
11492 #endif
11493 /* 46 */        NdrFcShort( 0x62 ),     /* Type Offset=98 */
11494 /* 48 */
11495                         0x51,           /* FC_OUT_PARAM */
11496 #ifndef _ALPHA_
11497                         0x1,            /* x86, MIPS & PPC Stack size = 1 */
11498 #else
11499                         0x2,            /* Alpha Stack size = 2 */
11500 #endif
11501 /* 50 */        NdrFcShort( 0x44e ),    /* Type Offset=1102 */
11502 /* 52 */
11503                         0x51,           /* FC_OUT_PARAM */
11504 #ifndef _ALPHA_
11505                         0x1,            /* x86, MIPS & PPC Stack size = 1 */
11506 #else
11507                         0x2,            /* Alpha Stack size = 2 */
11508 #endif
11509 /* 54 */        NdrFcShort( 0x460 ),    /* Type Offset=1120 */
11510 /* 56 */
11511                         0x51,           /* FC_OUT_PARAM */
11512 #ifndef _ALPHA_
11513                         0x1,            /* x86, MIPS & PPC Stack size = 1 */
11514 #else
11515                         0x2,            /* Alpha Stack size = 2 */
11516 #endif
11517 /* 58 */        NdrFcShort( 0x2 ),      /* Type Offset=2 */
11518 /* 60 */        0x4e,           /* FC_IN_PARAM_BASETYPE */
11519                         0x8,            /* FC_LONG */
11520 /* 62 */
11521                         0x4d,           /* FC_IN_PARAM */
11522 #ifndef _ALPHA_
11523                         0x1,            /* x86, MIPS & PPC Stack size = 1 */
11524 #else
11525                         0x2,            /* Alpha Stack size = 2 */
11526 #endif
11527 /* 64 */        NdrFcShort( 0x48e ),    /* Type Offset=1166 */
11528 /* 66 */
11529                         0x50,           /* FC_IN_OUT_PARAM */
11530 #ifndef _ALPHA_
11531                         0x1,            /* x86, MIPS & PPC Stack size = 1 */
11532 #else
11533                         0x2,            /* Alpha Stack size = 2 */
11534 #endif
11535 /* 68 */        NdrFcShort( 0x49c ),    /* Type Offset=1180 */
11536 /* 70 */        0x53,           /* FC_RETURN_PARAM_BASETYPE */
11537                         0x8,            /* FC_LONG */
11538 /* 72 */        0x4e,           /* FC_IN_PARAM_BASETYPE */
11539                         0x8,            /* FC_LONG */
11540 /* 74 */
11541                         0x51,           /* FC_OUT_PARAM */
11542 #ifndef _ALPHA_
11543                         0x1,            /* x86, MIPS & PPC Stack size = 1 */
11544 #else
11545                         0x2,            /* Alpha Stack size = 2 */
11546 #endif
11547 /* 76 */        NdrFcShort( 0x4b2 ),    /* Type Offset=1202 */
11548 /* 78 */
11549                         0x51,           /* FC_OUT_PARAM */
11550 #ifndef _ALPHA_
11551                         0x1,            /* x86, MIPS & PPC Stack size = 1 */
11552 #else
11553                         0x2,            /* Alpha Stack size = 2 */
11554 #endif
11555 /* 80 */        NdrFcShort( 0x2 ),      /* Type Offset=2 */
11556 /* 82 */        0x53,           /* FC_RETURN_PARAM_BASETYPE */
11557                         0x8,            /* FC_LONG */
11558 /* 84 */        0x4e,           /* FC_IN_PARAM_BASETYPE */
11559                         0x8,            /* FC_LONG */
11560 /* 86 */        0x53,           /* FC_RETURN_PARAM_BASETYPE */
11561                         0x8,            /* FC_LONG */
11562 /* 88 */        0x53,           /* FC_RETURN_PARAM_BASETYPE */
11563                         0x8,            /* FC_LONG */
11564 /* 90 */
11565                         0x51,           /* FC_OUT_PARAM */
11566 #ifndef _ALPHA_
11567                         0x1,            /* x86, MIPS & PPC Stack size = 1 */
11568 #else
11569                         0x2,            /* Alpha Stack size = 2 */
11570 #endif
11571 /* 92 */        NdrFcShort( 0x4c8 ),    /* Type Offset=1224 */
11572 /* 94 */        0x53,           /* FC_RETURN_PARAM_BASETYPE */
11573                         0x8,            /* FC_LONG */
11574 /* 96 */
11575                         0x4d,           /* FC_IN_PARAM */
11576 #ifndef _ALPHA_
11577                         0x1,            /* x86, MIPS & PPC Stack size = 1 */
11578 #else
11579                         0x2,            /* Alpha Stack size = 2 */
11580 #endif
11581 /* 98 */        NdrFcShort( 0x4de ),    /* Type Offset=1246 */
11582 /* 100 */       0x4e,           /* FC_IN_PARAM_BASETYPE */
11583                         0x8,            /* FC_LONG */
11584 /* 102 */       0x4e,           /* FC_IN_PARAM_BASETYPE */
11585                         0x6,            /* FC_SHORT */
11586 /* 104 */
11587                         0x51,           /* FC_OUT_PARAM */
11588 #ifndef _ALPHA_
11589                         0x1,            /* x86, MIPS & PPC Stack size = 1 */
11590 #else
11591                         0x2,            /* Alpha Stack size = 2 */
11592 #endif
11593 /* 106 */       NdrFcShort( 0x6 ),      /* Type Offset=6 */
11594 /* 108 */
11595                         0x51,           /* FC_OUT_PARAM */
11596 #ifndef _ALPHA_
11597                         0x1,            /* x86, MIPS & PPC Stack size = 1 */
11598 #else
11599                         0x2,            /* Alpha Stack size = 2 */
11600 #endif
11601 /* 110 */       NdrFcShort( 0x4e2 ),    /* Type Offset=1250 */
11602 /* 112 */
11603                         0x51,           /* FC_OUT_PARAM */
11604 #ifndef _ALPHA_
11605                         0x1,            /* x86, MIPS & PPC Stack size = 1 */
11606 #else
11607                         0x2,            /* Alpha Stack size = 2 */
11608 #endif
11609 /* 114 */       NdrFcShort( 0x4e6 ),    /* Type Offset=1254 */
11610 /* 116 */
11611                         0x51,           /* FC_OUT_PARAM */
11612 #ifndef _ALPHA_
11613                         0x1,            /* x86, MIPS & PPC Stack size = 1 */
11614 #else
11615                         0x2,            /* Alpha Stack size = 2 */
11616 #endif
11617 /* 118 */       NdrFcShort( 0x5b8 ),    /* Type Offset=1464 */
11618 /* 120 */
11619                         0x51,           /* FC_OUT_PARAM */
11620 #ifndef _ALPHA_
11621                         0x1,            /* x86, MIPS & PPC Stack size = 1 */
11622 #else
11623                         0x2,            /* Alpha Stack size = 2 */
11624 #endif
11625 /* 122 */       NdrFcShort( 0x604 ),    /* Type Offset=1540 */
11626 /* 124 */
11627                         0x51,           /* FC_OUT_PARAM */
11628 #ifndef _ALPHA_
11629                         0x1,            /* x86, MIPS & PPC Stack size = 1 */
11630 #else
11631                         0x2,            /* Alpha Stack size = 2 */
11632 #endif
11633 /* 126 */       NdrFcShort( 0x61a ),    /* Type Offset=1562 */
11634 /* 128 */       0x53,           /* FC_RETURN_PARAM_BASETYPE */
11635                         0x8,            /* FC_LONG */
11636 /* 130 */
11637                         0x4d,           /* FC_IN_PARAM */
11638 #ifndef _ALPHA_
11639                         0x1,            /* x86, MIPS & PPC Stack size = 1 */
11640 #else
11641                         0x2,            /* Alpha Stack size = 2 */
11642 #endif
11643 /* 132 */       NdrFcShort( 0x4de ),    /* Type Offset=1246 */
11644 /* 134 */       0x4e,           /* FC_IN_PARAM_BASETYPE */
11645                         0x8,            /* FC_LONG */
11646 /* 136 */
11647                         0x51,           /* FC_OUT_PARAM */
11648 #ifndef _ALPHA_
11649                         0x1,            /* x86, MIPS & PPC Stack size = 1 */
11650 #else
11651                         0x2,            /* Alpha Stack size = 2 */
11652 #endif
11653 /* 138 */       NdrFcShort( 0x6 ),      /* Type Offset=6 */
11654 /* 140 */       0x53,           /* FC_RETURN_PARAM_BASETYPE */
11655                         0x8,            /* FC_LONG */
11656 /* 142 */
11657                         0x51,           /* FC_OUT_PARAM */
11658 #ifndef _ALPHA_
11659                         0x1,            /* x86, MIPS & PPC Stack size = 1 */
11660 #else
11661                         0x2,            /* Alpha Stack size = 2 */
11662 #endif
11663 /* 144 */       NdrFcShort( 0x62a ),    /* Type Offset=1578 */
11664 /* 146 */
11665                         0x51,           /* FC_OUT_PARAM */
11666 #ifndef _ALPHA_
11667                         0x1,            /* x86, MIPS & PPC Stack size = 1 */
11668 #else
11669                         0x2,            /* Alpha Stack size = 2 */
11670 #endif
11671 /* 148 */       NdrFcShort( 0x666 ),    /* Type Offset=1638 */
11672 /* 150 */       0x53,           /* FC_RETURN_PARAM_BASETYPE */
11673                         0x8,            /* FC_LONG */
11674 /* 152 */
11675                         0x51,           /* FC_OUT_PARAM */
11676 #ifndef _ALPHA_
11677                         0x1,            /* x86, MIPS & PPC Stack size = 1 */
11678 #else
11679                         0x2,            /* Alpha Stack size = 2 */
11680 #endif
11681 /* 154 */       NdrFcShort( 0x604 ),    /* Type Offset=1540 */
11682 /* 156 */       0x53,           /* FC_RETURN_PARAM_BASETYPE */
11683                         0x8,            /* FC_LONG */
11684 /* 158 */       0x4e,           /* FC_IN_PARAM_BASETYPE */
11685                         0x8,            /* FC_LONG */
11686 /* 160 */
11687                         0x51,           /* FC_OUT_PARAM */
11688 #ifndef _ALPHA_
11689                         0x1,            /* x86, MIPS & PPC Stack size = 1 */
11690 #else
11691                         0x2,            /* Alpha Stack size = 2 */
11692 #endif
11693 /* 162 */       NdrFcShort( 0x4e6 ),    /* Type Offset=1254 */
11694 /* 164 */
11695                         0x51,           /* FC_OUT_PARAM */
11696 #ifndef _ALPHA_
11697                         0x1,            /* x86, MIPS & PPC Stack size = 1 */
11698 #else
11699                         0x2,            /* Alpha Stack size = 2 */
11700 #endif
11701 /* 166 */       NdrFcShort( 0x676 ),    /* Type Offset=1654 */
11702 /* 168 */       0x53,           /* FC_RETURN_PARAM_BASETYPE */
11703                         0x8,            /* FC_LONG */
11704 /* 170 */       0x4e,           /* FC_IN_PARAM_BASETYPE */
11705                         0x8,            /* FC_LONG */
11706 /* 172 */
11707                         0x51,           /* FC_OUT_PARAM */
11708 #ifndef _ALPHA_
11709                         0x1,            /* x86, MIPS & PPC Stack size = 1 */
11710 #else
11711                         0x2,            /* Alpha Stack size = 2 */
11712 #endif
11713 /* 174 */       NdrFcShort( 0x5b8 ),    /* Type Offset=1464 */
11714 /* 176 */
11715                         0x51,           /* FC_OUT_PARAM */
11716 #ifndef _ALPHA_
11717                         0x1,            /* x86, MIPS & PPC Stack size = 1 */
11718 #else
11719                         0x2,            /* Alpha Stack size = 2 */
11720 #endif
11721 /* 178 */       NdrFcShort( 0x686 ),    /* Type Offset=1670 */
11722 /* 180 */       0x53,           /* FC_RETURN_PARAM_BASETYPE */
11723                         0x8,            /* FC_LONG */
11724 /* 182 */       0x4e,           /* FC_IN_PARAM_BASETYPE */
11725                         0x8,            /* FC_LONG */
11726 /* 184 */
11727                         0x51,           /* FC_OUT_PARAM */
11728 #ifndef _ALPHA_
11729                         0x1,            /* x86, MIPS & PPC Stack size = 1 */
11730 #else
11731                         0x2,            /* Alpha Stack size = 2 */
11732 #endif
11733 /* 186 */       NdrFcShort( 0x696 ),    /* Type Offset=1686 */
11734 /* 188 */       0x4e,           /* FC_IN_PARAM_BASETYPE */
11735                         0x8,            /* FC_LONG */
11736 /* 190 */
11737                         0x51,           /* FC_OUT_PARAM */
11738 #ifndef _ALPHA_
11739                         0x1,            /* x86, MIPS & PPC Stack size = 1 */
11740 #else
11741                         0x2,            /* Alpha Stack size = 2 */
11742 #endif
11743 /* 192 */       NdrFcShort( 0x2 ),      /* Type Offset=2 */
11744 /* 194 */       0x53,           /* FC_RETURN_PARAM_BASETYPE */
11745                         0x8,            /* FC_LONG */
11746 /* 196 */       0x4e,           /* FC_IN_PARAM_BASETYPE */
11747                         0x8,            /* FC_LONG */
11748 /* 198 */
11749                         0x51,           /* FC_OUT_PARAM */
11750 #ifndef _ALPHA_
11751                         0x1,            /* x86, MIPS & PPC Stack size = 1 */
11752 #else
11753                         0x2,            /* Alpha Stack size = 2 */
11754 #endif
11755 /* 200 */       NdrFcShort( 0x2 ),      /* Type Offset=2 */
11756 /* 202 */       0x53,           /* FC_RETURN_PARAM_BASETYPE */
11757                         0x8,            /* FC_LONG */
11758 /* 204 */       0x4e,           /* FC_IN_PARAM_BASETYPE */
11759                         0x8,            /* FC_LONG */
11760 /* 206 */       0x4e,           /* FC_IN_PARAM_BASETYPE */
11761                         0x8,            /* FC_LONG */
11762 /* 208 */
11763                         0x51,           /* FC_OUT_PARAM */
11764 #ifndef _ALPHA_
11765                         0x1,            /* x86, MIPS & PPC Stack size = 1 */
11766 #else
11767                         0x2,            /* Alpha Stack size = 2 */
11768 #endif
11769 /* 210 */       NdrFcShort( 0x6ac ),    /* Type Offset=1708 */
11770 /* 212 */
11771                         0x51,           /* FC_OUT_PARAM */
11772 #ifndef _ALPHA_
11773                         0x1,            /* x86, MIPS & PPC Stack size = 1 */
11774 #else
11775                         0x2,            /* Alpha Stack size = 2 */
11776 #endif
11777 /* 214 */       NdrFcShort( 0x6ac ),    /* Type Offset=1708 */
11778 /* 216 */
11779                         0x51,           /* FC_OUT_PARAM */
11780 #ifndef _ALPHA_
11781                         0x1,            /* x86, MIPS & PPC Stack size = 1 */
11782 #else
11783                         0x2,            /* Alpha Stack size = 2 */
11784 #endif
11785 /* 218 */       NdrFcShort( 0x2 ),      /* Type Offset=2 */
11786 /* 220 */
11787                         0x51,           /* FC_OUT_PARAM */
11788 #ifndef _ALPHA_
11789                         0x1,            /* x86, MIPS & PPC Stack size = 1 */
11790 #else
11791                         0x2,            /* Alpha Stack size = 2 */
11792 #endif
11793 /* 222 */       NdrFcShort( 0x6ac ),    /* Type Offset=1708 */
11794 /* 224 */       0x53,           /* FC_RETURN_PARAM_BASETYPE */
11795                         0x8,            /* FC_LONG */
11796 /* 226 */       0x4e,           /* FC_IN_PARAM_BASETYPE */
11797                         0x8,            /* FC_LONG */
11798 /* 228 */       0x4e,           /* FC_IN_PARAM_BASETYPE */
11799                         0xe,            /* FC_ENUM32 */
11800 /* 230 */       0x4e,           /* FC_IN_PARAM_BASETYPE */
11801                         0x8,            /* FC_LONG */
11802 /* 232 */
11803                         0x51,           /* FC_OUT_PARAM */
11804 #ifndef _ALPHA_
11805                         0x1,            /* x86, MIPS & PPC Stack size = 1 */
11806 #else
11807                         0x2,            /* Alpha Stack size = 2 */
11808 #endif
11809 /* 234 */       NdrFcShort( 0x6ac ),    /* Type Offset=1708 */
11810 /* 236 */
11811                         0x51,           /* FC_OUT_PARAM */
11812 #ifndef _ALPHA_
11813                         0x1,            /* x86, MIPS & PPC Stack size = 1 */
11814 #else
11815                         0x2,            /* Alpha Stack size = 2 */
11816 #endif
11817 /* 238 */       NdrFcShort( 0x6ac ),    /* Type Offset=1708 */
11818 /* 240 */
11819                         0x51,           /* FC_OUT_PARAM */
11820 #ifndef _ALPHA_
11821                         0x1,            /* x86, MIPS & PPC Stack size = 1 */
11822 #else
11823                         0x2,            /* Alpha Stack size = 2 */
11824 #endif
11825 /* 242 */       NdrFcShort( 0x6b0 ),    /* Type Offset=1712 */
11826 /* 244 */       0x53,           /* FC_RETURN_PARAM_BASETYPE */
11827                         0x8,            /* FC_LONG */
11828 /* 246 */       0x4e,           /* FC_IN_PARAM_BASETYPE */
11829                         0x8,            /* FC_LONG */
11830 /* 248 */
11831                         0x51,           /* FC_OUT_PARAM */
11832 #ifndef _ALPHA_
11833                         0x1,            /* x86, MIPS & PPC Stack size = 1 */
11834 #else
11835                         0x2,            /* Alpha Stack size = 2 */
11836 #endif
11837 /* 250 */       NdrFcShort( 0x6 ),      /* Type Offset=6 */
11838 /* 252 */       0x53,           /* FC_RETURN_PARAM_BASETYPE */
11839                         0x8,            /* FC_LONG */
11840 /* 254 */
11841                         0x4d,           /* FC_IN_PARAM */
11842 #ifndef _ALPHA_
11843                         0x1,            /* x86, MIPS & PPC Stack size = 1 */
11844 #else
11845                         0x2,            /* Alpha Stack size = 2 */
11846 #endif
11847 /* 256 */       NdrFcShort( 0x1c ),     /* Type Offset=28 */
11848 /* 258 */
11849                         0x51,           /* FC_OUT_PARAM */
11850 #ifndef _ALPHA_
11851                         0x1,            /* x86, MIPS & PPC Stack size = 1 */
11852 #else
11853                         0x2,            /* Alpha Stack size = 2 */
11854 #endif
11855 /* 260 */       NdrFcShort( 0x6b4 ),    /* Type Offset=1716 */
11856 /* 262 */       0x53,           /* FC_RETURN_PARAM_BASETYPE */
11857                         0x8,            /* FC_LONG */
11858 /* 264 */       0x4e,           /* FC_IN_PARAM_BASETYPE */
11859                         0x8,            /* FC_LONG */
11860 /* 266 */
11861                         0x51,           /* FC_OUT_PARAM */
11862 #ifndef _ALPHA_
11863                         0x1,            /* x86, MIPS & PPC Stack size = 1 */
11864 #else
11865                         0x2,            /* Alpha Stack size = 2 */
11866 #endif
11867 /* 268 */       NdrFcShort( 0x6ac ),    /* Type Offset=1708 */
11868 /* 270 */       0x53,           /* FC_RETURN_PARAM_BASETYPE */
11869                         0x8,            /* FC_LONG */
11870 /* 272 */
11871                         0x51,           /* FC_OUT_PARAM */
11872 #ifndef _ALPHA_
11873                         0x1,            /* x86, MIPS & PPC Stack size = 1 */
11874 #else
11875                         0x2,            /* Alpha Stack size = 2 */
11876 #endif
11877 /* 274 */       NdrFcShort( 0x6be ),    /* Type Offset=1726 */
11878 /* 276 */
11879                         0x51,           /* FC_OUT_PARAM */
11880 #ifndef _ALPHA_
11881                         0x1,            /* x86, MIPS & PPC Stack size = 1 */
11882 #else
11883                         0x2,            /* Alpha Stack size = 2 */
11884 #endif
11885 /* 278 */       NdrFcShort( 0x2 ),      /* Type Offset=2 */
11886 /* 280 */       0x53,           /* FC_RETURN_PARAM_BASETYPE */
11887                         0x8,            /* FC_LONG */
11888 /* 282 */
11889                         0x51,           /* FC_OUT_PARAM */
11890 #ifndef _ALPHA_
11891                         0x1,            /* x86, MIPS & PPC Stack size = 1 */
11892 #else
11893                         0x2,            /* Alpha Stack size = 2 */
11894 #endif
11895 /* 284 */       NdrFcShort( 0x4e2 ),    /* Type Offset=1250 */
11896 /* 286 */       0x53,           /* FC_RETURN_PARAM_BASETYPE */
11897                         0x8,            /* FC_LONG */
11898 /* 288 */       0x4e,           /* FC_IN_PARAM_BASETYPE */
11899                         0x8,            /* FC_LONG */
11900 /* 290 */       0x4e,           /* FC_IN_PARAM_BASETYPE */
11901                         0xe,            /* FC_ENUM32 */
11902 /* 292 */
11903                         0x51,           /* FC_OUT_PARAM */
11904 #ifndef _ALPHA_
11905                         0x1,            /* x86, MIPS & PPC Stack size = 1 */
11906 #else
11907                         0x2,            /* Alpha Stack size = 2 */
11908 #endif
11909 /* 294 */       NdrFcShort( 0x2 ),      /* Type Offset=2 */
11910 /* 296 */       0x53,           /* FC_RETURN_PARAM_BASETYPE */
11911                         0x8,            /* FC_LONG */
11912 /* 298 */
11913                         0x4d,           /* FC_IN_PARAM */
11914 #ifndef _ALPHA_
11915                         0x1,            /* x86, MIPS & PPC Stack size = 1 */
11916 #else
11917                         0x2,            /* Alpha Stack size = 2 */
11918 #endif
11919 /* 300 */       NdrFcShort( 0x1c ),     /* Type Offset=28 */
11920 /* 302 */
11921                         0x51,           /* FC_OUT_PARAM */
11922 #ifndef _ALPHA_
11923                         0x1,            /* x86, MIPS & PPC Stack size = 1 */
11924 #else
11925                         0x2,            /* Alpha Stack size = 2 */
11926 #endif
11927 /* 304 */       NdrFcShort( 0x44e ),    /* Type Offset=1102 */
11928 /* 306 */       0x53,           /* FC_RETURN_PARAM_BASETYPE */
11929                         0x8,            /* FC_LONG */
11930 /* 308 */       0x4e,           /* FC_IN_PARAM_BASETYPE */
11931                         0x8,            /* FC_LONG */
11932 /* 310 */
11933                         0x4d,           /* FC_IN_PARAM */
11934 #ifndef _ALPHA_
11935                         0x1,            /* x86, MIPS & PPC Stack size = 1 */
11936 #else
11937                         0x2,            /* Alpha Stack size = 2 */
11938 #endif
11939 /* 312 */       NdrFcShort( 0x1c ),     /* Type Offset=28 */
11940 /* 314 */
11941                         0x51,           /* FC_OUT_PARAM */
11942 #ifndef _ALPHA_
11943                         0x1,            /* x86, MIPS & PPC Stack size = 1 */
11944 #else
11945                         0x2,            /* Alpha Stack size = 2 */
11946 #endif
11947 /* 316 */       NdrFcShort( 0x44e ),    /* Type Offset=1102 */
11948 /* 318 */       0x53,           /* FC_RETURN_PARAM_BASETYPE */
11949                         0x8,            /* FC_LONG */
11950 /* 320 */       0x4e,           /* FC_IN_PARAM_BASETYPE */
11951                         0x8,            /* FC_LONG */
11952 /* 322 */       0x4e,           /* FC_IN_PARAM_BASETYPE */
11953                         0x8,            /* FC_LONG */
11954 /* 324 */
11955                         0x4d,           /* FC_IN_PARAM */
11956 #ifndef _ALPHA_
11957                         0x1,            /* x86, MIPS & PPC Stack size = 1 */
11958 #else
11959                         0x2,            /* Alpha Stack size = 2 */
11960 #endif
11961 /* 326 */       NdrFcShort( 0x1c ),     /* Type Offset=28 */
11962 /* 328 */
11963                         0x51,           /* FC_OUT_PARAM */
11964 #ifndef _ALPHA_
11965                         0x1,            /* x86, MIPS & PPC Stack size = 1 */
11966 #else
11967                         0x2,            /* Alpha Stack size = 2 */
11968 #endif
11969 /* 330 */       NdrFcShort( 0x44e ),    /* Type Offset=1102 */
11970 /* 332 */       0x53,           /* FC_RETURN_PARAM_BASETYPE */
11971                         0x8,            /* FC_LONG */
11972 /* 334 */       0x4e,           /* FC_IN_PARAM_BASETYPE */
11973                         0x8,            /* FC_LONG */
11974 /* 336 */       0x4e,           /* FC_IN_PARAM_BASETYPE */
11975                         0x8,            /* FC_LONG */
11976 /* 338 */       0x4e,           /* FC_IN_PARAM_BASETYPE */
11977                         0x8,            /* FC_LONG */
11978 /* 340 */
11979                         0x51,           /* FC_OUT_PARAM */
11980 #ifndef _ALPHA_
11981                         0x1,            /* x86, MIPS & PPC Stack size = 1 */
11982 #else
11983                         0x2,            /* Alpha Stack size = 2 */
11984 #endif
11985 /* 342 */       NdrFcShort( 0x6ac ),    /* Type Offset=1708 */
11986 /* 344 */
11987                         0x51,           /* FC_OUT_PARAM */
11988 #ifndef _ALPHA_
11989                         0x1,            /* x86, MIPS & PPC Stack size = 1 */
11990 #else
11991                         0x2,            /* Alpha Stack size = 2 */
11992 #endif
11993 /* 346 */       NdrFcShort( 0x2 ),      /* Type Offset=2 */
11994 /* 348 */
11995                         0x51,           /* FC_OUT_PARAM */
11996 #ifndef _ALPHA_
11997                         0x1,            /* x86, MIPS & PPC Stack size = 1 */
11998 #else
11999                         0x2,            /* Alpha Stack size = 2 */
12000 #endif
12001 /* 350 */       NdrFcShort( 0x6ac ),    /* Type Offset=1708 */
12002 /* 352 */       0x53,           /* FC_RETURN_PARAM_BASETYPE */
12003                         0x8,            /* FC_LONG */
12004 /* 354 */
12005                         0x51,           /* FC_OUT_PARAM */
12006 #ifndef _ALPHA_
12007                         0x1,            /* x86, MIPS & PPC Stack size = 1 */
12008 #else
12009                         0x2,            /* Alpha Stack size = 2 */
12010 #endif
12011 /* 356 */       NdrFcShort( 0x6d4 ),    /* Type Offset=1748 */
12012 /* 358 */       0x53,           /* FC_RETURN_PARAM_BASETYPE */
12013                         0x8,            /* FC_LONG */
12014 /* 360 */       0x4e,           /* FC_IN_PARAM_BASETYPE */
12015                         0x8,            /* FC_LONG */
12016 /* 362 */
12017                         0x51,           /* FC_OUT_PARAM */
12018 #ifndef _ALPHA_
12019                         0x1,            /* x86, MIPS & PPC Stack size = 1 */
12020 #else
12021                         0x2,            /* Alpha Stack size = 2 */
12022 #endif
12023 /* 364 */       NdrFcShort( 0x6d4 ),    /* Type Offset=1748 */
12024 /* 366 */       0x53,           /* FC_RETURN_PARAM_BASETYPE */
12025                         0x8,            /* FC_LONG */
12026 /* 368 */       0x4e,           /* FC_IN_PARAM_BASETYPE */
12027                         0x8,            /* FC_LONG */
12028 /* 370 */       0x4e,           /* FC_IN_PARAM_BASETYPE */
12029                         0x8,            /* FC_LONG */
12030 /* 372 */
12031                         0x51,           /* FC_OUT_PARAM */
12032 #ifndef _ALPHA_
12033                         0x1,            /* x86, MIPS & PPC Stack size = 1 */
12034 #else
12035                         0x2,            /* Alpha Stack size = 2 */
12036 #endif
12037 /* 374 */       NdrFcShort( 0x6d4 ),    /* Type Offset=1748 */
12038 /* 376 */       0x53,           /* FC_RETURN_PARAM_BASETYPE */
12039                         0x8,            /* FC_LONG */
12040 /* 378 */       0x4e,           /* FC_IN_PARAM_BASETYPE */
12041                         0x8,            /* FC_LONG */
12042 /* 380 */
12043                         0x51,           /* FC_OUT_PARAM */
12044 #ifndef _ALPHA_
12045                         0x1,            /* x86, MIPS & PPC Stack size = 1 */
12046 #else
12047                         0x2,            /* Alpha Stack size = 2 */
12048 #endif
12049 /* 382 */       NdrFcShort( 0x4e2 ),    /* Type Offset=1250 */
12050 /* 384 */       0x53,           /* FC_RETURN_PARAM_BASETYPE */
12051                         0x8,            /* FC_LONG */
12052 /* 386 */
12053                         0x4d,           /* FC_IN_PARAM */
12054 #ifndef _ALPHA_
12055                         0x1,            /* x86, MIPS & PPC Stack size = 1 */
12056 #else
12057                         0x2,            /* Alpha Stack size = 2 */
12058 #endif
12059 /* 388 */       NdrFcShort( 0x1c ),     /* Type Offset=28 */
12060 /* 390 */
12061                         0x51,           /* FC_OUT_PARAM */
12062 #ifndef _ALPHA_
12063                         0x1,            /* x86, MIPS & PPC Stack size = 1 */
12064 #else
12065                         0x2,            /* Alpha Stack size = 2 */
12066 #endif
12067 /* 392 */       NdrFcShort( 0x6 ),      /* Type Offset=6 */
12068 /* 394 */       0x53,           /* FC_RETURN_PARAM_BASETYPE */
12069                         0x8,            /* FC_LONG */
12070 /* 396 */
12071                         0x51,           /* FC_OUT_PARAM */
12072 #ifndef _ALPHA_
12073                         0x1,            /* x86, MIPS & PPC Stack size = 1 */
12074 #else
12075                         0x2,            /* Alpha Stack size = 2 */
12076 #endif
12077 /* 398 */       NdrFcShort( 0x70c ),    /* Type Offset=1804 */
12078 /* 400 */
12079                         0x51,           /* FC_OUT_PARAM */
12080 #ifndef _ALPHA_
12081                         0x1,            /* x86, MIPS & PPC Stack size = 1 */
12082 #else
12083                         0x2,            /* Alpha Stack size = 2 */
12084 #endif
12085 /* 402 */       NdrFcShort( 0x728 ),    /* Type Offset=1832 */
12086 /* 404 */       0x53,           /* FC_RETURN_PARAM_BASETYPE */
12087                         0x8,            /* FC_LONG */
12088 /* 406 */
12089                         0x4d,           /* FC_IN_PARAM */
12090 #ifndef _ALPHA_
12091                         0x1,            /* x86, MIPS & PPC Stack size = 1 */
12092 #else
12093                         0x2,            /* Alpha Stack size = 2 */
12094 #endif
12095 /* 408 */       NdrFcShort( 0x4de ),    /* Type Offset=1246 */
12096 /* 410 */       0x4e,           /* FC_IN_PARAM_BASETYPE */
12097                         0x8,            /* FC_LONG */
12098 /* 412 */
12099                         0x51,           /* FC_OUT_PARAM */
12100 #ifndef _ALPHA_
12101                         0x1,            /* x86, MIPS & PPC Stack size = 1 */
12102 #else
12103                         0x2,            /* Alpha Stack size = 2 */
12104 #endif
12105 /* 414 */       NdrFcShort( 0x2 ),      /* Type Offset=2 */
12106 /* 416 */
12107                         0x51,           /* FC_OUT_PARAM */
12108 #ifndef _ALPHA_
12109                         0x1,            /* x86, MIPS & PPC Stack size = 1 */
12110 #else
12111                         0x2,            /* Alpha Stack size = 2 */
12112 #endif
12113 /* 418 */       NdrFcShort( 0x6ac ),    /* Type Offset=1708 */
12114 /* 420 */       0x53,           /* FC_RETURN_PARAM_BASETYPE */
12115                         0x8,            /* FC_LONG */
12116 /* 422 */
12117                         0x4d,           /* FC_IN_PARAM */
12118 #ifndef _ALPHA_
12119                         0x1,            /* x86, MIPS & PPC Stack size = 1 */
12120 #else
12121                         0x2,            /* Alpha Stack size = 2 */
12122 #endif
12123 /* 424 */       NdrFcShort( 0x4de ),    /* Type Offset=1246 */
12124 /* 426 */       0x4e,           /* FC_IN_PARAM_BASETYPE */
12125                         0x8,            /* FC_LONG */
12126 /* 428 */
12127                         0x51,           /* FC_OUT_PARAM */
12128 #ifndef _ALPHA_
12129                         0x1,            /* x86, MIPS & PPC Stack size = 1 */
12130 #else
12131                         0x2,            /* Alpha Stack size = 2 */
12132 #endif
12133 /* 430 */       NdrFcShort( 0x738 ),    /* Type Offset=1848 */
12134 /* 432 */
12135                         0x51,           /* FC_OUT_PARAM */
12136 #ifndef _ALPHA_
12137                         0x1,            /* x86, MIPS & PPC Stack size = 1 */
12138 #else
12139                         0x2,            /* Alpha Stack size = 2 */
12140 #endif
12141 /* 434 */       NdrFcShort( 0x74e ),    /* Type Offset=1870 */
12142 /* 436 */
12143                         0x50,           /* FC_IN_OUT_PARAM */
12144 #ifndef _ALPHA_
12145                         0x1,            /* x86, MIPS & PPC Stack size = 1 */
12146 #else
12147                         0x2,            /* Alpha Stack size = 2 */
12148 #endif
12149 /* 438 */       NdrFcShort( 0x760 ),    /* Type Offset=1888 */
12150 /* 440 */
12151                         0x51,           /* FC_OUT_PARAM */
12152 #ifndef _ALPHA_
12153                         0x1,            /* x86, MIPS & PPC Stack size = 1 */
12154 #else
12155                         0x2,            /* Alpha Stack size = 2 */
12156 #endif
12157 /* 442 */       NdrFcShort( 0x6ac ),    /* Type Offset=1708 */
12158 /* 444 */       0x53,           /* FC_RETURN_PARAM_BASETYPE */
12159                         0x8,            /* FC_LONG */
12160 /* 446 */
12161                         0x51,           /* FC_OUT_PARAM */
12162 #ifndef _ALPHA_
12163                         0x1,            /* x86, MIPS & PPC Stack size = 1 */
12164 #else
12165                         0x2,            /* Alpha Stack size = 2 */
12166 #endif
12167 /* 448 */       NdrFcShort( 0x2 ),      /* Type Offset=2 */
12168 /* 450 */
12169                         0x51,           /* FC_OUT_PARAM */
12170 #ifndef _ALPHA_
12171                         0x1,            /* x86, MIPS & PPC Stack size = 1 */
12172 #else
12173                         0x2,            /* Alpha Stack size = 2 */
12174 #endif
12175 /* 452 */       NdrFcShort( 0x2 ),      /* Type Offset=2 */
12176 /* 454 */       0x53,           /* FC_RETURN_PARAM_BASETYPE */
12177                         0x8,            /* FC_LONG */
12178 /* 456 */
12179                         0x51,           /* FC_OUT_PARAM */
12180 #ifndef _ALPHA_
12181                         0x1,            /* x86, MIPS & PPC Stack size = 1 */
12182 #else
12183                         0x2,            /* Alpha Stack size = 2 */
12184 #endif
12185 /* 458 */       NdrFcShort( 0x764 ),    /* Type Offset=1892 */
12186 /* 460 */       0x53,           /* FC_RETURN_PARAM_BASETYPE */
12187                         0x8,            /* FC_LONG */
12188 /* 462 */
12189                         0x51,           /* FC_OUT_PARAM */
12190 #ifndef _ALPHA_
12191                         0x1,            /* x86, MIPS & PPC Stack size = 1 */
12192 #else
12193                         0x2,            /* Alpha Stack size = 2 */
12194 #endif
12195 /* 464 */       NdrFcShort( 0x6ac ),    /* Type Offset=1708 */
12196 /* 466 */       0x53,           /* FC_RETURN_PARAM_BASETYPE */
12197                         0x8,            /* FC_LONG */
12198 /* 468 */
12199                         0x4d,           /* FC_IN_PARAM */
12200 #ifndef _ALPHA_
12201                         0x1,            /* x86, MIPS & PPC Stack size = 1 */
12202 #else
12203                         0x2,            /* Alpha Stack size = 2 */
12204 #endif
12205 /* 470 */       NdrFcShort( 0x1c ),     /* Type Offset=28 */
12206 /* 472 */       0x53,           /* FC_RETURN_PARAM_BASETYPE */
12207                         0x8,            /* FC_LONG */
12208 /* 474 */
12209                         0x4d,           /* FC_IN_PARAM */
12210 #ifndef _ALPHA_
12211                         0x1,            /* x86, MIPS & PPC Stack size = 1 */
12212 #else
12213                         0x2,            /* Alpha Stack size = 2 */
12214 #endif
12215 /* 476 */       NdrFcShort( 0x4de ),    /* Type Offset=1246 */
12216 /* 478 */       0x53,           /* FC_RETURN_PARAM_BASETYPE */
12217                         0x8,            /* FC_LONG */
12218 /* 480 */
12219                         0x4d,           /* FC_IN_PARAM */
12220 #ifndef _ALPHA_
12221                         0x1,            /* x86, MIPS & PPC Stack size = 1 */
12222 #else
12223                         0x2,            /* Alpha Stack size = 2 */
12224 #endif
12225 /* 482 */       NdrFcShort( 0xa ),      /* Type Offset=10 */
12226 /* 484 */
12227                         0x4d,           /* FC_IN_PARAM */
12228 #ifndef _ALPHA_
12229                         0x1,            /* x86, MIPS & PPC Stack size = 1 */
12230 #else
12231                         0x2,            /* Alpha Stack size = 2 */
12232 #endif
12233 /* 486 */       NdrFcShort( 0x1c ),     /* Type Offset=28 */
12234 /* 488 */
12235                         0x51,           /* FC_OUT_PARAM */
12236 #ifndef _ALPHA_
12237                         0x1,            /* x86, MIPS & PPC Stack size = 1 */
12238 #else
12239                         0x2,            /* Alpha Stack size = 2 */
12240 #endif
12241 /* 490 */       NdrFcShort( 0x768 ),    /* Type Offset=1896 */
12242 /* 492 */       0x53,           /* FC_RETURN_PARAM_BASETYPE */
12243                         0x8,            /* FC_LONG */
12244
12245                         0x0
12246         }
12247     };
12248
12249 static const MIDL_TYPE_FORMAT_STRING __MIDL_TypeFormatString =
12250     {
12251         0,
12252         {
12253                         NdrFcShort( 0x0 ),      /* 0 */
12254 /*  2 */
12255                         0x11, 0xc,      /* FC_RP [alloced_on_stack] [simple_pointer] */
12256 /*  4 */        0x8,            /* FC_LONG */
12257                         0x5c,           /* FC_PAD */
12258 /*  6 */
12259                         0x11, 0x14,     /* FC_RP [alloced_on_stack] */
12260 /*  8 */        NdrFcShort( 0x2 ),      /* Offset= 2 (10) */
12261 /* 10 */
12262                         0x2f,           /* FC_IP */
12263                         0x5a,           /* FC_CONSTANT_IID */
12264 /* 12 */        NdrFcLong( 0x20401 ),   /* 132097 */
12265 /* 16 */        NdrFcShort( 0x0 ),      /* 0 */
12266 /* 18 */        NdrFcShort( 0x0 ),      /* 0 */
12267 /* 20 */        0xc0,           /* 192 */
12268                         0x0,            /* 0 */
12269 /* 22 */        0x0,            /* 0 */
12270                         0x0,            /* 0 */
12271 /* 24 */        0x0,            /* 0 */
12272                         0x0,            /* 0 */
12273 /* 26 */        0x0,            /* 0 */
12274                         0x46,           /* 70 */
12275 /* 28 */
12276                         0x11, 0x0,      /* FC_RP */
12277 /* 30 */        NdrFcShort( 0x8 ),      /* Offset= 8 (38) */
12278 /* 32 */
12279                         0x1d,           /* FC_SMFARRAY */
12280                         0x0,            /* 0 */
12281 /* 34 */        NdrFcShort( 0x8 ),      /* 8 */
12282 /* 36 */        0x2,            /* FC_CHAR */
12283                         0x5b,           /* FC_END */
12284 /* 38 */
12285                         0x15,           /* FC_STRUCT */
12286                         0x3,            /* 3 */
12287 /* 40 */        NdrFcShort( 0x10 ),     /* 16 */
12288 /* 42 */        0x8,            /* FC_LONG */
12289                         0x6,            /* FC_SHORT */
12290 /* 44 */        0x6,            /* FC_SHORT */
12291                         0x4c,           /* FC_EMBEDDED_COMPLEX */
12292 /* 46 */        0x0,            /* 0 */
12293                         NdrFcShort( 0xfffffff1 ),       /* Offset= -15 (32) */
12294                         0x5b,           /* FC_END */
12295 /* 50 */
12296                         0x11, 0x0,      /* FC_RP */
12297 /* 52 */        NdrFcShort( 0x2 ),      /* Offset= 2 (54) */
12298 /* 54 */
12299                         0x1b,           /* FC_CARRAY */
12300                         0x3,            /* 3 */
12301 /* 56 */        NdrFcShort( 0x4 ),      /* 4 */
12302 /* 58 */        0x29,           /* Corr desc:  parameter, FC_ULONG */
12303                         0x0,            /*  */
12304 #ifndef _ALPHA_
12305 /* 60 */        NdrFcShort( 0xc ),      /* x86, MIPS, PPC Stack size/offset = 12 */
12306 #else
12307                         NdrFcShort( 0x18 ),     /* Alpha Stack size/offset = 24 */
12308 #endif
12309 /* 62 */
12310                         0x4b,           /* FC_PP */
12311                         0x5c,           /* FC_PAD */
12312 /* 64 */
12313                         0x48,           /* FC_VARIABLE_REPEAT */
12314                         0x49,           /* FC_FIXED_OFFSET */
12315 /* 66 */        NdrFcShort( 0x4 ),      /* 4 */
12316 /* 68 */        NdrFcShort( 0x0 ),      /* 0 */
12317 /* 70 */        NdrFcShort( 0x1 ),      /* 1 */
12318 /* 72 */        NdrFcShort( 0x0 ),      /* 0 */
12319 /* 74 */        NdrFcShort( 0x0 ),      /* 0 */
12320 /* 76 */        0x12, 0x8,      /* FC_UP [simple_pointer] */
12321 /* 78 */
12322                         0x25,           /* FC_C_WSTRING */
12323                         0x5c,           /* FC_PAD */
12324 /* 80 */
12325                         0x5b,           /* FC_END */
12326
12327                         0x8,            /* FC_LONG */
12328 /* 82 */        0x5c,           /* FC_PAD */
12329                         0x5b,           /* FC_END */
12330 /* 84 */
12331                         0x11, 0x0,      /* FC_RP */
12332 /* 86 */        NdrFcShort( 0x2 ),      /* Offset= 2 (88) */
12333 /* 88 */
12334                         0x1b,           /* FC_CARRAY */
12335                         0x3,            /* 3 */
12336 /* 90 */        NdrFcShort( 0x4 ),      /* 4 */
12337 /* 92 */        0x29,           /* Corr desc:  parameter, FC_ULONG */
12338                         0x0,            /*  */
12339 #ifndef _ALPHA_
12340 /* 94 */        NdrFcShort( 0xc ),      /* x86, MIPS, PPC Stack size/offset = 12 */
12341 #else
12342                         NdrFcShort( 0x18 ),     /* Alpha Stack size/offset = 24 */
12343 #endif
12344 /* 96 */        0x8,            /* FC_LONG */
12345                         0x5b,           /* FC_END */
12346 /* 98 */
12347                         0x11, 0x0,      /* FC_RP */
12348 /* 100 */       NdrFcShort( 0x3d4 ),    /* Offset= 980 (1080) */
12349 /* 102 */
12350                         0x12, 0x0,      /* FC_UP */
12351 /* 104 */       NdrFcShort( 0x396 ),    /* Offset= 918 (1022) */
12352 /* 106 */
12353                         0x2b,           /* FC_NON_ENCAPSULATED_UNION */
12354                         0x7,            /* FC_USHORT */
12355 /* 108 */       0x7,            /* Corr desc: FC_USHORT */
12356                         0x0,            /*  */
12357 /* 110 */       NdrFcShort( 0xfff8 ),   /* -8 */
12358 /* 112 */       NdrFcShort( 0x2 ),      /* Offset= 2 (114) */
12359 /* 114 */       NdrFcShort( 0x10 ),     /* 16 */
12360 /* 116 */       NdrFcShort( 0x2b ),     /* 43 */
12361 /* 118 */       NdrFcLong( 0x0 ),       /* 0 */
12362 /* 122 */       NdrFcShort( 0x0 ),      /* Offset= 0 (122) */
12363 /* 124 */       NdrFcLong( 0x1 ),       /* 1 */
12364 /* 128 */       NdrFcShort( 0x0 ),      /* Offset= 0 (128) */
12365 /* 130 */       NdrFcLong( 0x10 ),      /* 16 */
12366 /* 134 */       NdrFcShort( 0x8002 ),   /* Simple arm type: FC_CHAR */
12367 /* 136 */       NdrFcLong( 0x12 ),      /* 18 */
12368 /* 140 */       NdrFcShort( 0x8006 ),   /* Simple arm type: FC_SHORT */
12369 /* 142 */       NdrFcLong( 0x13 ),      /* 19 */
12370 /* 146 */       NdrFcShort( 0x8008 ),   /* Simple arm type: FC_LONG */
12371 /* 148 */       NdrFcLong( 0x16 ),      /* 22 */
12372 /* 152 */       NdrFcShort( 0x8008 ),   /* Simple arm type: FC_LONG */
12373 /* 154 */       NdrFcLong( 0x17 ),      /* 23 */
12374 /* 158 */       NdrFcShort( 0x8008 ),   /* Simple arm type: FC_LONG */
12375 /* 160 */       NdrFcLong( 0x11 ),      /* 17 */
12376 /* 164 */       NdrFcShort( 0x8002 ),   /* Simple arm type: FC_CHAR */
12377 /* 166 */       NdrFcLong( 0x2 ),       /* 2 */
12378 /* 170 */       NdrFcShort( 0x8006 ),   /* Simple arm type: FC_SHORT */
12379 /* 172 */       NdrFcLong( 0x3 ),       /* 3 */
12380 /* 176 */       NdrFcShort( 0x8008 ),   /* Simple arm type: FC_LONG */
12381 /* 178 */       NdrFcLong( 0x4 ),       /* 4 */
12382 /* 182 */       NdrFcShort( 0x800a ),   /* Simple arm type: FC_FLOAT */
12383 /* 184 */       NdrFcLong( 0x5 ),       /* 5 */
12384 /* 188 */       NdrFcShort( 0x800c ),   /* Simple arm type: FC_DOUBLE */
12385 /* 190 */       NdrFcLong( 0xb ),       /* 11 */
12386 /* 194 */       NdrFcShort( 0x8006 ),   /* Simple arm type: FC_SHORT */
12387 /* 196 */       NdrFcLong( 0xa ),       /* 10 */
12388 /* 200 */       NdrFcShort( 0x8008 ),   /* Simple arm type: FC_LONG */
12389 /* 202 */       NdrFcLong( 0x7 ),       /* 7 */
12390 /* 206 */       NdrFcShort( 0x800c ),   /* Simple arm type: FC_DOUBLE */
12391 /* 208 */       NdrFcLong( 0x8 ),       /* 8 */
12392 /* 212 */       NdrFcShort( 0xa6 ),     /* Offset= 166 (378) */
12393 /* 214 */       NdrFcLong( 0x6 ),       /* 6 */
12394 /* 218 */       NdrFcShort( 0xb8 ),     /* Offset= 184 (402) */
12395 /* 220 */       NdrFcLong( 0xe ),       /* 14 */
12396 /* 224 */       NdrFcShort( 0xb8 ),     /* Offset= 184 (408) */
12397 /* 226 */       NdrFcLong( 0xd ),       /* 13 */
12398 /* 230 */       NdrFcShort( 0xbe ),     /* Offset= 190 (420) */
12399 /* 232 */       NdrFcLong( 0x9 ),       /* 9 */
12400 /* 236 */       NdrFcShort( 0xca ),     /* Offset= 202 (438) */
12401 /* 238 */       NdrFcLong( 0x2000 ),    /* 8192 */
12402 /* 242 */       NdrFcShort( 0xd6 ),     /* Offset= 214 (456) */
12403 /* 244 */       NdrFcLong( 0x4010 ),    /* 16400 */
12404 /* 248 */       NdrFcShort( 0x2ce ),    /* Offset= 718 (966) */
12405 /* 250 */       NdrFcLong( 0x4012 ),    /* 16402 */
12406 /* 254 */       NdrFcShort( 0x2cc ),    /* Offset= 716 (970) */
12407 /* 256 */       NdrFcLong( 0x4013 ),    /* 16403 */
12408 /* 260 */       NdrFcShort( 0x2ca ),    /* Offset= 714 (974) */
12409 /* 262 */       NdrFcLong( 0x4016 ),    /* 16406 */
12410 /* 266 */       NdrFcShort( 0x2c4 ),    /* Offset= 708 (974) */
12411 /* 268 */       NdrFcLong( 0x4017 ),    /* 16407 */
12412 /* 272 */       NdrFcShort( 0x2be ),    /* Offset= 702 (974) */
12413 /* 274 */       NdrFcLong( 0x4011 ),    /* 16401 */
12414 /* 278 */       NdrFcShort( 0x2b0 ),    /* Offset= 688 (966) */
12415 /* 280 */       NdrFcLong( 0x4002 ),    /* 16386 */
12416 /* 284 */       NdrFcShort( 0x2ae ),    /* Offset= 686 (970) */
12417 /* 286 */       NdrFcLong( 0x4003 ),    /* 16387 */
12418 /* 290 */       NdrFcShort( 0x2ac ),    /* Offset= 684 (974) */
12419 /* 292 */       NdrFcLong( 0x4004 ),    /* 16388 */
12420 /* 296 */       NdrFcShort( 0x2aa ),    /* Offset= 682 (978) */
12421 /* 298 */       NdrFcLong( 0x4005 ),    /* 16389 */
12422 /* 302 */       NdrFcShort( 0x2a8 ),    /* Offset= 680 (982) */
12423 /* 304 */       NdrFcLong( 0x400b ),    /* 16395 */
12424 /* 308 */       NdrFcShort( 0x296 ),    /* Offset= 662 (970) */
12425 /* 310 */       NdrFcLong( 0x400a ),    /* 16394 */
12426 /* 314 */       NdrFcShort( 0x294 ),    /* Offset= 660 (974) */
12427 /* 316 */       NdrFcLong( 0x4007 ),    /* 16391 */
12428 /* 320 */       NdrFcShort( 0x296 ),    /* Offset= 662 (982) */
12429 /* 322 */       NdrFcLong( 0x4008 ),    /* 16392 */
12430 /* 326 */       NdrFcShort( 0x294 ),    /* Offset= 660 (986) */
12431 /* 328 */       NdrFcLong( 0x400c ),    /* 16396 */
12432 /* 332 */       NdrFcShort( 0x292 ),    /* Offset= 658 (990) */
12433 /* 334 */       NdrFcLong( 0x4006 ),    /* 16390 */
12434 /* 338 */       NdrFcShort( 0x294 ),    /* Offset= 660 (998) */
12435 /* 340 */       NdrFcLong( 0x400e ),    /* 16398 */
12436 /* 344 */       NdrFcShort( 0x292 ),    /* Offset= 658 (1002) */
12437 /* 346 */       NdrFcLong( 0x400d ),    /* 16397 */
12438 /* 350 */       NdrFcShort( 0x290 ),    /* Offset= 656 (1006) */
12439 /* 352 */       NdrFcLong( 0x4009 ),    /* 16393 */
12440 /* 356 */       NdrFcShort( 0x28e ),    /* Offset= 654 (1010) */
12441 /* 358 */       NdrFcLong( 0x6000 ),    /* 24576 */
12442 /* 362 */       NdrFcShort( 0x28c ),    /* Offset= 652 (1014) */
12443 /* 364 */       NdrFcLong( 0x24 ),      /* 36 */
12444 /* 368 */       NdrFcShort( 0x28a ),    /* Offset= 650 (1018) */
12445 /* 370 */       NdrFcLong( 0x4024 ),    /* 16420 */
12446 /* 374 */       NdrFcShort( 0x284 ),    /* Offset= 644 (1018) */
12447 /* 376 */       NdrFcShort( 0xffffffff ),       /* Offset= -1 (375) */
12448 /* 378 */
12449                         0x12, 0x0,      /* FC_UP */
12450 /* 380 */       NdrFcShort( 0xc ),      /* Offset= 12 (392) */
12451 /* 382 */
12452                         0x1b,           /* FC_CARRAY */
12453                         0x1,            /* 1 */
12454 /* 384 */       NdrFcShort( 0x2 ),      /* 2 */
12455 /* 386 */       0x9,            /* Corr desc: FC_ULONG */
12456                         0x0,            /*  */
12457 /* 388 */       NdrFcShort( 0xfffc ),   /* -4 */
12458 /* 390 */       0x6,            /* FC_SHORT */
12459                         0x5b,           /* FC_END */
12460 /* 392 */
12461                         0x17,           /* FC_CSTRUCT */
12462                         0x3,            /* 3 */
12463 /* 394 */       NdrFcShort( 0x8 ),      /* 8 */
12464 /* 396 */       NdrFcShort( 0xfffffff2 ),       /* Offset= -14 (382) */
12465 /* 398 */       0x8,            /* FC_LONG */
12466                         0x8,            /* FC_LONG */
12467 /* 400 */       0x5c,           /* FC_PAD */
12468                         0x5b,           /* FC_END */
12469 /* 402 */
12470                         0x15,           /* FC_STRUCT */
12471                         0x7,            /* 7 */
12472 /* 404 */       NdrFcShort( 0x8 ),      /* 8 */
12473 /* 406 */       0xb,            /* FC_HYPER */
12474                         0x5b,           /* FC_END */
12475 /* 408 */
12476                         0x15,           /* FC_STRUCT */
12477                         0x7,            /* 7 */
12478 /* 410 */       NdrFcShort( 0x10 ),     /* 16 */
12479 /* 412 */       0x6,            /* FC_SHORT */
12480                         0x2,            /* FC_CHAR */
12481 /* 414 */       0x2,            /* FC_CHAR */
12482                         0x38,           /* FC_ALIGNM4 */
12483 /* 416 */       0x8,            /* FC_LONG */
12484                         0x39,           /* FC_ALIGNM8 */
12485 /* 418 */       0xb,            /* FC_HYPER */
12486                         0x5b,           /* FC_END */
12487 /* 420 */
12488                         0x2f,           /* FC_IP */
12489                         0x5a,           /* FC_CONSTANT_IID */
12490 /* 422 */       NdrFcLong( 0x0 ),       /* 0 */
12491 /* 426 */       NdrFcShort( 0x0 ),      /* 0 */
12492 /* 428 */       NdrFcShort( 0x0 ),      /* 0 */
12493 /* 430 */       0xc0,           /* 192 */
12494                         0x0,            /* 0 */
12495 /* 432 */       0x0,            /* 0 */
12496                         0x0,            /* 0 */
12497 /* 434 */       0x0,            /* 0 */
12498                         0x0,            /* 0 */
12499 /* 436 */       0x0,            /* 0 */
12500                         0x46,           /* 70 */
12501 /* 438 */
12502                         0x2f,           /* FC_IP */
12503                         0x5a,           /* FC_CONSTANT_IID */
12504 /* 440 */       NdrFcLong( 0x20400 ),   /* 132096 */
12505 /* 444 */       NdrFcShort( 0x0 ),      /* 0 */
12506 /* 446 */       NdrFcShort( 0x0 ),      /* 0 */
12507 /* 448 */       0xc0,           /* 192 */
12508                         0x0,            /* 0 */
12509 /* 450 */       0x0,            /* 0 */
12510                         0x0,            /* 0 */
12511 /* 452 */       0x0,            /* 0 */
12512                         0x0,            /* 0 */
12513 /* 454 */       0x0,            /* 0 */
12514                         0x46,           /* 70 */
12515 /* 456 */
12516                         0x12, 0x0,      /* FC_UP */
12517 /* 458 */       NdrFcShort( 0x1ea ),    /* Offset= 490 (948) */
12518 /* 460 */
12519                         0x2a,           /* FC_ENCAPSULATED_UNION */
12520                         0x49,           /* 73 */
12521 /* 462 */       NdrFcShort( 0x18 ),     /* 24 */
12522 /* 464 */       NdrFcShort( 0xa ),      /* 10 */
12523 /* 466 */       NdrFcLong( 0x8 ),       /* 8 */
12524 /* 470 */       NdrFcShort( 0x58 ),     /* Offset= 88 (558) */
12525 /* 472 */       NdrFcLong( 0xd ),       /* 13 */
12526 /* 476 */       NdrFcShort( 0x78 ),     /* Offset= 120 (596) */
12527 /* 478 */       NdrFcLong( 0x9 ),       /* 9 */
12528 /* 482 */       NdrFcShort( 0x94 ),     /* Offset= 148 (630) */
12529 /* 484 */       NdrFcLong( 0xc ),       /* 12 */
12530 /* 488 */       NdrFcShort( 0xbc ),     /* Offset= 188 (676) */
12531 /* 490 */       NdrFcLong( 0x24 ),      /* 36 */
12532 /* 494 */       NdrFcShort( 0x114 ),    /* Offset= 276 (770) */
12533 /* 496 */       NdrFcLong( 0x800d ),    /* 32781 */
12534 /* 500 */       NdrFcShort( 0x11e ),    /* Offset= 286 (786) */
12535 /* 502 */       NdrFcLong( 0x10 ),      /* 16 */
12536 /* 506 */       NdrFcShort( 0x136 ),    /* Offset= 310 (816) */
12537 /* 508 */       NdrFcLong( 0x2 ),       /* 2 */
12538 /* 512 */       NdrFcShort( 0x14e ),    /* Offset= 334 (846) */
12539 /* 514 */       NdrFcLong( 0x3 ),       /* 3 */
12540 /* 518 */       NdrFcShort( 0x166 ),    /* Offset= 358 (876) */
12541 /* 520 */       NdrFcLong( 0x14 ),      /* 20 */
12542 /* 524 */       NdrFcShort( 0x17e ),    /* Offset= 382 (906) */
12543 /* 526 */       NdrFcShort( 0xffffffff ),       /* Offset= -1 (525) */
12544 /* 528 */
12545                         0x1b,           /* FC_CARRAY */
12546                         0x3,            /* 3 */
12547 /* 530 */       NdrFcShort( 0x4 ),      /* 4 */
12548 /* 532 */       0x19,           /* Corr desc:  field pointer, FC_ULONG */
12549                         0x0,            /*  */
12550 /* 534 */       NdrFcShort( 0x0 ),      /* 0 */
12551 /* 536 */
12552                         0x4b,           /* FC_PP */
12553                         0x5c,           /* FC_PAD */
12554 /* 538 */
12555                         0x48,           /* FC_VARIABLE_REPEAT */
12556                         0x49,           /* FC_FIXED_OFFSET */
12557 /* 540 */       NdrFcShort( 0x4 ),      /* 4 */
12558 /* 542 */       NdrFcShort( 0x0 ),      /* 0 */
12559 /* 544 */       NdrFcShort( 0x1 ),      /* 1 */
12560 /* 546 */       NdrFcShort( 0x0 ),      /* 0 */
12561 /* 548 */       NdrFcShort( 0x0 ),      /* 0 */
12562 /* 550 */       0x12, 0x0,      /* FC_UP */
12563 /* 552 */       NdrFcShort( 0xffffff60 ),       /* Offset= -160 (392) */
12564 /* 554 */
12565                         0x5b,           /* FC_END */
12566
12567                         0x8,            /* FC_LONG */
12568 /* 556 */       0x5c,           /* FC_PAD */
12569                         0x5b,           /* FC_END */
12570 /* 558 */
12571                         0x16,           /* FC_PSTRUCT */
12572                         0x3,            /* 3 */
12573 /* 560 */       NdrFcShort( 0x8 ),      /* 8 */
12574 /* 562 */
12575                         0x4b,           /* FC_PP */
12576                         0x5c,           /* FC_PAD */
12577 /* 564 */
12578                         0x46,           /* FC_NO_REPEAT */
12579                         0x5c,           /* FC_PAD */
12580 /* 566 */       NdrFcShort( 0x4 ),      /* 4 */
12581 /* 568 */       NdrFcShort( 0x4 ),      /* 4 */
12582 /* 570 */       0x11, 0x0,      /* FC_RP */
12583 /* 572 */       NdrFcShort( 0xffffffd4 ),       /* Offset= -44 (528) */
12584 /* 574 */
12585                         0x5b,           /* FC_END */
12586
12587                         0x8,            /* FC_LONG */
12588 /* 576 */       0x8,            /* FC_LONG */
12589                         0x5b,           /* FC_END */
12590 /* 578 */
12591                         0x21,           /* FC_BOGUS_ARRAY */
12592                         0x3,            /* 3 */
12593 /* 580 */       NdrFcShort( 0x0 ),      /* 0 */
12594 /* 582 */       0x19,           /* Corr desc:  field pointer, FC_ULONG */
12595                         0x0,            /*  */
12596 /* 584 */       NdrFcShort( 0x0 ),      /* 0 */
12597 /* 586 */       NdrFcLong( 0xffffffff ),        /* -1 */
12598 /* 590 */       0x4c,           /* FC_EMBEDDED_COMPLEX */
12599                         0x0,            /* 0 */
12600 /* 592 */       NdrFcShort( 0xffffff54 ),       /* Offset= -172 (420) */
12601 /* 594 */       0x5c,           /* FC_PAD */
12602                         0x5b,           /* FC_END */
12603 /* 596 */
12604                         0x1a,           /* FC_BOGUS_STRUCT */
12605                         0x3,            /* 3 */
12606 /* 598 */       NdrFcShort( 0x8 ),      /* 8 */
12607 /* 600 */       NdrFcShort( 0x0 ),      /* 0 */
12608 /* 602 */       NdrFcShort( 0x6 ),      /* Offset= 6 (608) */
12609 /* 604 */       0x8,            /* FC_LONG */
12610                         0x36,           /* FC_POINTER */
12611 /* 606 */       0x5c,           /* FC_PAD */
12612                         0x5b,           /* FC_END */
12613 /* 608 */
12614                         0x11, 0x0,      /* FC_RP */
12615 /* 610 */       NdrFcShort( 0xffffffe0 ),       /* Offset= -32 (578) */
12616 /* 612 */
12617                         0x21,           /* FC_BOGUS_ARRAY */
12618                         0x3,            /* 3 */
12619 /* 614 */       NdrFcShort( 0x0 ),      /* 0 */
12620 /* 616 */       0x19,           /* Corr desc:  field pointer, FC_ULONG */
12621                         0x0,            /*  */
12622 /* 618 */       NdrFcShort( 0x0 ),      /* 0 */
12623 /* 620 */       NdrFcLong( 0xffffffff ),        /* -1 */
12624 /* 624 */       0x4c,           /* FC_EMBEDDED_COMPLEX */
12625                         0x0,            /* 0 */
12626 /* 626 */       NdrFcShort( 0xffffff44 ),       /* Offset= -188 (438) */
12627 /* 628 */       0x5c,           /* FC_PAD */
12628                         0x5b,           /* FC_END */
12629 /* 630 */
12630                         0x1a,           /* FC_BOGUS_STRUCT */
12631                         0x3,            /* 3 */
12632 /* 632 */       NdrFcShort( 0x8 ),      /* 8 */
12633 /* 634 */       NdrFcShort( 0x0 ),      /* 0 */
12634 /* 636 */       NdrFcShort( 0x6 ),      /* Offset= 6 (642) */
12635 /* 638 */       0x8,            /* FC_LONG */
12636                         0x36,           /* FC_POINTER */
12637 /* 640 */       0x5c,           /* FC_PAD */
12638                         0x5b,           /* FC_END */
12639 /* 642 */
12640                         0x11, 0x0,      /* FC_RP */
12641 /* 644 */       NdrFcShort( 0xffffffe0 ),       /* Offset= -32 (612) */
12642 /* 646 */
12643                         0x1b,           /* FC_CARRAY */
12644                         0x3,            /* 3 */
12645 /* 648 */       NdrFcShort( 0x4 ),      /* 4 */
12646 /* 650 */       0x19,           /* Corr desc:  field pointer, FC_ULONG */
12647                         0x0,            /*  */
12648 /* 652 */       NdrFcShort( 0x0 ),      /* 0 */
12649 /* 654 */
12650                         0x4b,           /* FC_PP */
12651                         0x5c,           /* FC_PAD */
12652 /* 656 */
12653                         0x48,           /* FC_VARIABLE_REPEAT */
12654                         0x49,           /* FC_FIXED_OFFSET */
12655 /* 658 */       NdrFcShort( 0x4 ),      /* 4 */
12656 /* 660 */       NdrFcShort( 0x0 ),      /* 0 */
12657 /* 662 */       NdrFcShort( 0x1 ),      /* 1 */
12658 /* 664 */       NdrFcShort( 0x0 ),      /* 0 */
12659 /* 666 */       NdrFcShort( 0x0 ),      /* 0 */
12660 /* 668 */       0x12, 0x0,      /* FC_UP */
12661 /* 670 */       NdrFcShort( 0x160 ),    /* Offset= 352 (1022) */
12662 /* 672 */
12663                         0x5b,           /* FC_END */
12664
12665                         0x8,            /* FC_LONG */
12666 /* 674 */       0x5c,           /* FC_PAD */
12667                         0x5b,           /* FC_END */
12668 /* 676 */
12669                         0x1a,           /* FC_BOGUS_STRUCT */
12670                         0x3,            /* 3 */
12671 /* 678 */       NdrFcShort( 0x8 ),      /* 8 */
12672 /* 680 */       NdrFcShort( 0x0 ),      /* 0 */
12673 /* 682 */       NdrFcShort( 0x6 ),      /* Offset= 6 (688) */
12674 /* 684 */       0x8,            /* FC_LONG */
12675                         0x36,           /* FC_POINTER */
12676 /* 686 */       0x5c,           /* FC_PAD */
12677                         0x5b,           /* FC_END */
12678 /* 688 */
12679                         0x11, 0x0,      /* FC_RP */
12680 /* 690 */       NdrFcShort( 0xffffffd4 ),       /* Offset= -44 (646) */
12681 /* 692 */
12682                         0x2f,           /* FC_IP */
12683                         0x5a,           /* FC_CONSTANT_IID */
12684 /* 694 */       NdrFcLong( 0x2f ),      /* 47 */
12685 /* 698 */       NdrFcShort( 0x0 ),      /* 0 */
12686 /* 700 */       NdrFcShort( 0x0 ),      /* 0 */
12687 /* 702 */       0xc0,           /* 192 */
12688                         0x0,            /* 0 */
12689 /* 704 */       0x0,            /* 0 */
12690                         0x0,            /* 0 */
12691 /* 706 */       0x0,            /* 0 */
12692                         0x0,            /* 0 */
12693 /* 708 */       0x0,            /* 0 */
12694                         0x46,           /* 70 */
12695 /* 710 */
12696                         0x1b,           /* FC_CARRAY */
12697                         0x0,            /* 0 */
12698 /* 712 */       NdrFcShort( 0x1 ),      /* 1 */
12699 /* 714 */       0x19,           /* Corr desc:  field pointer, FC_ULONG */
12700                         0x0,            /*  */
12701 /* 716 */       NdrFcShort( 0x4 ),      /* 4 */
12702 /* 718 */       0x1,            /* FC_BYTE */
12703                         0x5b,           /* FC_END */
12704 /* 720 */
12705                         0x1a,           /* FC_BOGUS_STRUCT */
12706                         0x3,            /* 3 */
12707 /* 722 */       NdrFcShort( 0x10 ),     /* 16 */
12708 /* 724 */       NdrFcShort( 0x0 ),      /* 0 */
12709 /* 726 */       NdrFcShort( 0xa ),      /* Offset= 10 (736) */
12710 /* 728 */       0x8,            /* FC_LONG */
12711                         0x8,            /* FC_LONG */
12712 /* 730 */       0x4c,           /* FC_EMBEDDED_COMPLEX */
12713                         0x0,            /* 0 */
12714 /* 732 */       NdrFcShort( 0xffffffd8 ),       /* Offset= -40 (692) */
12715 /* 734 */       0x36,           /* FC_POINTER */
12716                         0x5b,           /* FC_END */
12717 /* 736 */
12718                         0x12, 0x0,      /* FC_UP */
12719 /* 738 */       NdrFcShort( 0xffffffe4 ),       /* Offset= -28 (710) */
12720 /* 740 */
12721                         0x1b,           /* FC_CARRAY */
12722                         0x3,            /* 3 */
12723 /* 742 */       NdrFcShort( 0x4 ),      /* 4 */
12724 /* 744 */       0x19,           /* Corr desc:  field pointer, FC_ULONG */
12725                         0x0,            /*  */
12726 /* 746 */       NdrFcShort( 0x0 ),      /* 0 */
12727 /* 748 */
12728                         0x4b,           /* FC_PP */
12729                         0x5c,           /* FC_PAD */
12730 /* 750 */
12731                         0x48,           /* FC_VARIABLE_REPEAT */
12732                         0x49,           /* FC_FIXED_OFFSET */
12733 /* 752 */       NdrFcShort( 0x4 ),      /* 4 */
12734 /* 754 */       NdrFcShort( 0x0 ),      /* 0 */
12735 /* 756 */       NdrFcShort( 0x1 ),      /* 1 */
12736 /* 758 */       NdrFcShort( 0x0 ),      /* 0 */
12737 /* 760 */       NdrFcShort( 0x0 ),      /* 0 */
12738 /* 762 */       0x12, 0x0,      /* FC_UP */
12739 /* 764 */       NdrFcShort( 0xffffffd4 ),       /* Offset= -44 (720) */
12740 /* 766 */
12741                         0x5b,           /* FC_END */
12742
12743                         0x8,            /* FC_LONG */
12744 /* 768 */       0x5c,           /* FC_PAD */
12745                         0x5b,           /* FC_END */
12746 /* 770 */
12747                         0x1a,           /* FC_BOGUS_STRUCT */
12748                         0x3,            /* 3 */
12749 /* 772 */       NdrFcShort( 0x8 ),      /* 8 */
12750 /* 774 */       NdrFcShort( 0x0 ),      /* 0 */
12751 /* 776 */       NdrFcShort( 0x6 ),      /* Offset= 6 (782) */
12752 /* 778 */       0x8,            /* FC_LONG */
12753                         0x36,           /* FC_POINTER */
12754 /* 780 */       0x5c,           /* FC_PAD */
12755                         0x5b,           /* FC_END */
12756 /* 782 */
12757                         0x11, 0x0,      /* FC_RP */
12758 /* 784 */       NdrFcShort( 0xffffffd4 ),       /* Offset= -44 (740) */
12759 /* 786 */
12760                         0x1a,           /* FC_BOGUS_STRUCT */
12761                         0x3,            /* 3 */
12762 /* 788 */       NdrFcShort( 0x18 ),     /* 24 */
12763 /* 790 */       NdrFcShort( 0x0 ),      /* 0 */
12764 /* 792 */       NdrFcShort( 0xa ),      /* Offset= 10 (802) */
12765 /* 794 */       0x8,            /* FC_LONG */
12766                         0x36,           /* FC_POINTER */
12767 /* 796 */       0x4c,           /* FC_EMBEDDED_COMPLEX */
12768                         0x0,            /* 0 */
12769 /* 798 */       NdrFcShort( 0xfffffd08 ),       /* Offset= -760 (38) */
12770 /* 800 */       0x5c,           /* FC_PAD */
12771                         0x5b,           /* FC_END */
12772 /* 802 */
12773                         0x11, 0x0,      /* FC_RP */
12774 /* 804 */       NdrFcShort( 0xffffff1e ),       /* Offset= -226 (578) */
12775 /* 806 */
12776                         0x1b,           /* FC_CARRAY */
12777                         0x0,            /* 0 */
12778 /* 808 */       NdrFcShort( 0x1 ),      /* 1 */
12779 /* 810 */       0x19,           /* Corr desc:  field pointer, FC_ULONG */
12780                         0x0,            /*  */
12781 /* 812 */       NdrFcShort( 0x0 ),      /* 0 */
12782 /* 814 */       0x1,            /* FC_BYTE */
12783                         0x5b,           /* FC_END */
12784 /* 816 */
12785                         0x16,           /* FC_PSTRUCT */
12786                         0x3,            /* 3 */
12787 /* 818 */       NdrFcShort( 0x8 ),      /* 8 */
12788 /* 820 */
12789                         0x4b,           /* FC_PP */
12790                         0x5c,           /* FC_PAD */
12791 /* 822 */
12792                         0x46,           /* FC_NO_REPEAT */
12793                         0x5c,           /* FC_PAD */
12794 /* 824 */       NdrFcShort( 0x4 ),      /* 4 */
12795 /* 826 */       NdrFcShort( 0x4 ),      /* 4 */
12796 /* 828 */       0x12, 0x0,      /* FC_UP */
12797 /* 830 */       NdrFcShort( 0xffffffe8 ),       /* Offset= -24 (806) */
12798 /* 832 */
12799                         0x5b,           /* FC_END */
12800
12801                         0x8,            /* FC_LONG */
12802 /* 834 */       0x8,            /* FC_LONG */
12803                         0x5b,           /* FC_END */
12804 /* 836 */
12805                         0x1b,           /* FC_CARRAY */
12806                         0x1,            /* 1 */
12807 /* 838 */       NdrFcShort( 0x2 ),      /* 2 */
12808 /* 840 */       0x19,           /* Corr desc:  field pointer, FC_ULONG */
12809                         0x0,            /*  */
12810 /* 842 */       NdrFcShort( 0x0 ),      /* 0 */
12811 /* 844 */       0x6,            /* FC_SHORT */
12812                         0x5b,           /* FC_END */
12813 /* 846 */
12814                         0x16,           /* FC_PSTRUCT */
12815                         0x3,            /* 3 */
12816 /* 848 */       NdrFcShort( 0x8 ),      /* 8 */
12817 /* 850 */
12818                         0x4b,           /* FC_PP */
12819                         0x5c,           /* FC_PAD */
12820 /* 852 */
12821                         0x46,           /* FC_NO_REPEAT */
12822                         0x5c,           /* FC_PAD */
12823 /* 854 */       NdrFcShort( 0x4 ),      /* 4 */
12824 /* 856 */       NdrFcShort( 0x4 ),      /* 4 */
12825 /* 858 */       0x12, 0x0,      /* FC_UP */
12826 /* 860 */       NdrFcShort( 0xffffffe8 ),       /* Offset= -24 (836) */
12827 /* 862 */
12828                         0x5b,           /* FC_END */
12829
12830                         0x8,            /* FC_LONG */
12831 /* 864 */       0x8,            /* FC_LONG */
12832                         0x5b,           /* FC_END */
12833 /* 866 */
12834                         0x1b,           /* FC_CARRAY */
12835                         0x3,            /* 3 */
12836 /* 868 */       NdrFcShort( 0x4 ),      /* 4 */
12837 /* 870 */       0x19,           /* Corr desc:  field pointer, FC_ULONG */
12838                         0x0,            /*  */
12839 /* 872 */       NdrFcShort( 0x0 ),      /* 0 */
12840 /* 874 */       0x8,            /* FC_LONG */
12841                         0x5b,           /* FC_END */
12842 /* 876 */
12843                         0x16,           /* FC_PSTRUCT */
12844                         0x3,            /* 3 */
12845 /* 878 */       NdrFcShort( 0x8 ),      /* 8 */
12846 /* 880 */
12847                         0x4b,           /* FC_PP */
12848                         0x5c,           /* FC_PAD */
12849 /* 882 */
12850                         0x46,           /* FC_NO_REPEAT */
12851                         0x5c,           /* FC_PAD */
12852 /* 884 */       NdrFcShort( 0x4 ),      /* 4 */
12853 /* 886 */       NdrFcShort( 0x4 ),      /* 4 */
12854 /* 888 */       0x12, 0x0,      /* FC_UP */
12855 /* 890 */       NdrFcShort( 0xffffffe8 ),       /* Offset= -24 (866) */
12856 /* 892 */
12857                         0x5b,           /* FC_END */
12858
12859                         0x8,            /* FC_LONG */
12860 /* 894 */       0x8,            /* FC_LONG */
12861                         0x5b,           /* FC_END */
12862 /* 896 */
12863                         0x1b,           /* FC_CARRAY */
12864                         0x7,            /* 7 */
12865 /* 898 */       NdrFcShort( 0x8 ),      /* 8 */
12866 /* 900 */       0x19,           /* Corr desc:  field pointer, FC_ULONG */
12867                         0x0,            /*  */
12868 /* 902 */       NdrFcShort( 0x0 ),      /* 0 */
12869 /* 904 */       0xb,            /* FC_HYPER */
12870                         0x5b,           /* FC_END */
12871 /* 906 */
12872                         0x16,           /* FC_PSTRUCT */
12873                         0x3,            /* 3 */
12874 /* 908 */       NdrFcShort( 0x8 ),      /* 8 */
12875 /* 910 */
12876                         0x4b,           /* FC_PP */
12877                         0x5c,           /* FC_PAD */
12878 /* 912 */
12879                         0x46,           /* FC_NO_REPEAT */
12880                         0x5c,           /* FC_PAD */
12881 /* 914 */       NdrFcShort( 0x4 ),      /* 4 */
12882 /* 916 */       NdrFcShort( 0x4 ),      /* 4 */
12883 /* 918 */       0x12, 0x0,      /* FC_UP */
12884 /* 920 */       NdrFcShort( 0xffffffe8 ),       /* Offset= -24 (896) */
12885 /* 922 */
12886                         0x5b,           /* FC_END */
12887
12888                         0x8,            /* FC_LONG */
12889 /* 924 */       0x8,            /* FC_LONG */
12890                         0x5b,           /* FC_END */
12891 /* 926 */
12892                         0x15,           /* FC_STRUCT */
12893                         0x3,            /* 3 */
12894 /* 928 */       NdrFcShort( 0x8 ),      /* 8 */
12895 /* 930 */       0x8,            /* FC_LONG */
12896                         0x8,            /* FC_LONG */
12897 /* 932 */       0x5c,           /* FC_PAD */
12898                         0x5b,           /* FC_END */
12899 /* 934 */
12900                         0x1b,           /* FC_CARRAY */
12901                         0x3,            /* 3 */
12902 /* 936 */       NdrFcShort( 0x8 ),      /* 8 */
12903 /* 938 */       0x7,            /* Corr desc: FC_USHORT */
12904                         0x0,            /*  */
12905 /* 940 */       NdrFcShort( 0xffd8 ),   /* -40 */
12906 /* 942 */       0x4c,           /* FC_EMBEDDED_COMPLEX */
12907                         0x0,            /* 0 */
12908 /* 944 */       NdrFcShort( 0xffffffee ),       /* Offset= -18 (926) */
12909 /* 946 */       0x5c,           /* FC_PAD */
12910                         0x5b,           /* FC_END */
12911 /* 948 */
12912                         0x1a,           /* FC_BOGUS_STRUCT */
12913                         0x3,            /* 3 */
12914 /* 950 */       NdrFcShort( 0x28 ),     /* 40 */
12915 /* 952 */       NdrFcShort( 0xffffffee ),       /* Offset= -18 (934) */
12916 /* 954 */       NdrFcShort( 0x0 ),      /* Offset= 0 (954) */
12917 /* 956 */       0x6,            /* FC_SHORT */
12918                         0x6,            /* FC_SHORT */
12919 /* 958 */       0x38,           /* FC_ALIGNM4 */
12920                         0x8,            /* FC_LONG */
12921 /* 960 */       0x8,            /* FC_LONG */
12922                         0x4c,           /* FC_EMBEDDED_COMPLEX */
12923 /* 962 */       0x0,            /* 0 */
12924                         NdrFcShort( 0xfffffe09 ),       /* Offset= -503 (460) */
12925                         0x5b,           /* FC_END */
12926 /* 966 */
12927                         0x12, 0x8,      /* FC_UP [simple_pointer] */
12928 /* 968 */       0x2,            /* FC_CHAR */
12929                         0x5c,           /* FC_PAD */
12930 /* 970 */
12931                         0x12, 0x8,      /* FC_UP [simple_pointer] */
12932 /* 972 */       0x6,            /* FC_SHORT */
12933                         0x5c,           /* FC_PAD */
12934 /* 974 */
12935                         0x12, 0x8,      /* FC_UP [simple_pointer] */
12936 /* 976 */       0x8,            /* FC_LONG */
12937                         0x5c,           /* FC_PAD */
12938 /* 978 */
12939                         0x12, 0x8,      /* FC_UP [simple_pointer] */
12940 /* 980 */       0xa,            /* FC_FLOAT */
12941                         0x5c,           /* FC_PAD */
12942 /* 982 */
12943                         0x12, 0x8,      /* FC_UP [simple_pointer] */
12944 /* 984 */       0xc,            /* FC_DOUBLE */
12945                         0x5c,           /* FC_PAD */
12946 /* 986 */
12947                         0x12, 0x10,     /* FC_UP */
12948 /* 988 */       NdrFcShort( 0xfffffd9e ),       /* Offset= -610 (378) */
12949 /* 990 */
12950                         0x12, 0x10,     /* FC_UP */
12951 /* 992 */       NdrFcShort( 0x2 ),      /* Offset= 2 (994) */
12952 /* 994 */
12953                         0x12, 0x0,      /* FC_UP */
12954 /* 996 */       NdrFcShort( 0xfffffc1c ),       /* Offset= -996 (0) */
12955 /* 998 */
12956                         0x12, 0x0,      /* FC_UP */
12957 /* 1000 */      NdrFcShort( 0xfffffdaa ),       /* Offset= -598 (402) */
12958 /* 1002 */
12959                         0x12, 0x0,      /* FC_UP */
12960 /* 1004 */      NdrFcShort( 0xfffffdac ),       /* Offset= -596 (408) */
12961 /* 1006 */
12962                         0x12, 0x10,     /* FC_UP */
12963 /* 1008 */      NdrFcShort( 0xfffffdb4 ),       /* Offset= -588 (420) */
12964 /* 1010 */
12965                         0x12, 0x10,     /* FC_UP */
12966 /* 1012 */      NdrFcShort( 0xfffffdc2 ),       /* Offset= -574 (438) */
12967 /* 1014 */
12968                         0x12, 0x10,     /* FC_UP */
12969 /* 1016 */      NdrFcShort( 0xfffffdd0 ),       /* Offset= -560 (456) */
12970 /* 1018 */
12971                         0x12, 0x0,      /* FC_UP */
12972 /* 1020 */      NdrFcShort( 0xfffffed4 ),       /* Offset= -300 (720) */
12973 /* 1022 */
12974                         0x1a,           /* FC_BOGUS_STRUCT */
12975                         0x7,            /* 7 */
12976 /* 1024 */      NdrFcShort( 0x20 ),     /* 32 */
12977 /* 1026 */      NdrFcShort( 0x0 ),      /* 0 */
12978 /* 1028 */      NdrFcShort( 0x0 ),      /* Offset= 0 (1028) */
12979 /* 1030 */      0x8,            /* FC_LONG */
12980                         0x8,            /* FC_LONG */
12981 /* 1032 */      0x6,            /* FC_SHORT */
12982                         0x6,            /* FC_SHORT */
12983 /* 1034 */      0x6,            /* FC_SHORT */
12984                         0x6,            /* FC_SHORT */
12985 /* 1036 */      0x4c,           /* FC_EMBEDDED_COMPLEX */
12986                         0x0,            /* 0 */
12987 /* 1038 */      NdrFcShort( 0xfffffc5c ),       /* Offset= -932 (106) */
12988 /* 1040 */      0x5c,           /* FC_PAD */
12989                         0x5b,           /* FC_END */
12990 /* 1042 */      0xb4,           /* FC_USER_MARSHAL */
12991                         0x83,           /* 131 */
12992 /* 1044 */      NdrFcShort( 0x0 ),      /* 0 */
12993 /* 1046 */      NdrFcShort( 0x10 ),     /* 16 */
12994 /* 1048 */      NdrFcShort( 0x0 ),      /* 0 */
12995 /* 1050 */      NdrFcShort( 0xfffffc4c ),       /* Offset= -948 (102) */
12996 /* 1052 */
12997                         0x21,           /* FC_BOGUS_ARRAY */
12998                         0x3,            /* 3 */
12999 /* 1054 */      NdrFcShort( 0x0 ),      /* 0 */
13000 /* 1056 */      0x19,           /* Corr desc:  field pointer, FC_ULONG */
13001                         0x0,            /*  */
13002 /* 1058 */      NdrFcShort( 0x8 ),      /* 8 */
13003 /* 1060 */      NdrFcLong( 0xffffffff ),        /* -1 */
13004 /* 1064 */      0x4c,           /* FC_EMBEDDED_COMPLEX */
13005                         0x0,            /* 0 */
13006 /* 1066 */      NdrFcShort( 0xffffffe8 ),       /* Offset= -24 (1042) */
13007 /* 1068 */      0x5c,           /* FC_PAD */
13008                         0x5b,           /* FC_END */
13009 /* 1070 */
13010                         0x1b,           /* FC_CARRAY */
13011                         0x3,            /* 3 */
13012 /* 1072 */      NdrFcShort( 0x4 ),      /* 4 */
13013 /* 1074 */      0x19,           /* Corr desc:  field pointer, FC_ULONG */
13014                         0x0,            /*  */
13015 /* 1076 */      NdrFcShort( 0xc ),      /* 12 */
13016 /* 1078 */      0x8,            /* FC_LONG */
13017                         0x5b,           /* FC_END */
13018 /* 1080 */
13019                         0x1a,           /* FC_BOGUS_STRUCT */
13020                         0x3,            /* 3 */
13021 /* 1082 */      NdrFcShort( 0x10 ),     /* 16 */
13022 /* 1084 */      NdrFcShort( 0x0 ),      /* 0 */
13023 /* 1086 */      NdrFcShort( 0x8 ),      /* Offset= 8 (1094) */
13024 /* 1088 */      0x36,           /* FC_POINTER */
13025                         0x36,           /* FC_POINTER */
13026 /* 1090 */      0x8,            /* FC_LONG */
13027                         0x8,            /* FC_LONG */
13028 /* 1092 */      0x5c,           /* FC_PAD */
13029                         0x5b,           /* FC_END */
13030 /* 1094 */
13031                         0x12, 0x0,      /* FC_UP */
13032 /* 1096 */      NdrFcShort( 0xffffffd4 ),       /* Offset= -44 (1052) */
13033 /* 1098 */
13034                         0x12, 0x0,      /* FC_UP */
13035 /* 1100 */      NdrFcShort( 0xffffffe2 ),       /* Offset= -30 (1070) */
13036 /* 1102 */
13037                         0x11, 0x4,      /* FC_RP [alloced_on_stack] */
13038 /* 1104 */      NdrFcShort( 0x6 ),      /* Offset= 6 (1110) */
13039 /* 1106 */
13040                         0x13, 0x0,      /* FC_OP */
13041 /* 1108 */      NdrFcShort( 0xffffffaa ),       /* Offset= -86 (1022) */
13042 /* 1110 */      0xb4,           /* FC_USER_MARSHAL */
13043                         0x83,           /* 131 */
13044 /* 1112 */      NdrFcShort( 0x0 ),      /* 0 */
13045 /* 1114 */      NdrFcShort( 0x10 ),     /* 16 */
13046 /* 1116 */      NdrFcShort( 0x0 ),      /* 0 */
13047 /* 1118 */      NdrFcShort( 0xfffffff4 ),       /* Offset= -12 (1106) */
13048 /* 1120 */
13049                         0x11, 0x4,      /* FC_RP [alloced_on_stack] */
13050 /* 1122 */      NdrFcShort( 0x10 ),     /* Offset= 16 (1138) */
13051 /* 1124 */
13052                         0x13, 0x0,      /* FC_OP */
13053 /* 1126 */      NdrFcShort( 0xfffffd22 ),       /* Offset= -734 (392) */
13054 /* 1128 */      0xb4,           /* FC_USER_MARSHAL */
13055                         0x83,           /* 131 */
13056 /* 1130 */      NdrFcShort( 0x1 ),      /* 1 */
13057 /* 1132 */      NdrFcShort( 0x4 ),      /* 4 */
13058 /* 1134 */      NdrFcShort( 0x0 ),      /* 0 */
13059 /* 1136 */      NdrFcShort( 0xfffffff4 ),       /* Offset= -12 (1124) */
13060 /* 1138 */
13061                         0x1a,           /* FC_BOGUS_STRUCT */
13062                         0x3,            /* 3 */
13063 /* 1140 */      NdrFcShort( 0x20 ),     /* 32 */
13064 /* 1142 */      NdrFcShort( 0x0 ),      /* 0 */
13065 /* 1144 */      NdrFcShort( 0x0 ),      /* Offset= 0 (1144) */
13066 /* 1146 */      0x6,            /* FC_SHORT */
13067                         0x6,            /* FC_SHORT */
13068 /* 1148 */      0x4c,           /* FC_EMBEDDED_COMPLEX */
13069                         0x0,            /* 0 */
13070 /* 1150 */      NdrFcShort( 0xffffffea ),       /* Offset= -22 (1128) */
13071 /* 1152 */      0x4c,           /* FC_EMBEDDED_COMPLEX */
13072                         0x0,            /* 0 */
13073 /* 1154 */      NdrFcShort( 0xffffffe6 ),       /* Offset= -26 (1128) */
13074 /* 1156 */      0x4c,           /* FC_EMBEDDED_COMPLEX */
13075                         0x0,            /* 0 */
13076 /* 1158 */      NdrFcShort( 0xffffffe2 ),       /* Offset= -30 (1128) */
13077 /* 1160 */      0x38,           /* FC_ALIGNM4 */
13078                         0x8,            /* FC_LONG */
13079 /* 1162 */      0x8,            /* FC_LONG */
13080                         0x8,            /* FC_LONG */
13081 /* 1164 */      0x8,            /* FC_LONG */
13082                         0x5b,           /* FC_END */
13083 /* 1166 */
13084                         0x11, 0x0,      /* FC_RP */
13085 /* 1168 */      NdrFcShort( 0x2 ),      /* Offset= 2 (1170) */
13086 /* 1170 */
13087                         0x1b,           /* FC_CARRAY */
13088                         0x3,            /* 3 */
13089 /* 1172 */      NdrFcShort( 0x4 ),      /* 4 */
13090 /* 1174 */      0x29,           /* Corr desc:  parameter, FC_ULONG */
13091                         0x0,            /*  */
13092 #ifndef _ALPHA_
13093 /* 1176 */      NdrFcShort( 0x24 ),     /* x86, MIPS, PPC Stack size/offset = 36 */
13094 #else
13095                         NdrFcShort( 0x48 ),     /* Alpha Stack size/offset = 72 */
13096 #endif
13097 /* 1178 */      0x8,            /* FC_LONG */
13098                         0x5b,           /* FC_END */
13099 /* 1180 */
13100                         0x11, 0x0,      /* FC_RP */
13101 /* 1182 */      NdrFcShort( 0x2 ),      /* Offset= 2 (1184) */
13102 /* 1184 */
13103                         0x21,           /* FC_BOGUS_ARRAY */
13104                         0x3,            /* 3 */
13105 /* 1186 */      NdrFcShort( 0x0 ),      /* 0 */
13106 /* 1188 */      0x29,           /* Corr desc:  parameter, FC_ULONG */
13107                         0x0,            /*  */
13108 #ifndef _ALPHA_
13109 /* 1190 */      NdrFcShort( 0x24 ),     /* x86, MIPS, PPC Stack size/offset = 36 */
13110 #else
13111                         NdrFcShort( 0x48 ),     /* Alpha Stack size/offset = 72 */
13112 #endif
13113 /* 1192 */      NdrFcLong( 0xffffffff ),        /* -1 */
13114 /* 1196 */      0x4c,           /* FC_EMBEDDED_COMPLEX */
13115                         0x0,            /* 0 */
13116 /* 1198 */      NdrFcShort( 0xffffffa8 ),       /* Offset= -88 (1110) */
13117 /* 1200 */      0x5c,           /* FC_PAD */
13118                         0x5b,           /* FC_END */
13119 /* 1202 */
13120                         0x11, 0x0,      /* FC_RP */
13121 /* 1204 */      NdrFcShort( 0x2 ),      /* Offset= 2 (1206) */
13122 /* 1206 */
13123                         0x21,           /* FC_BOGUS_ARRAY */
13124                         0x3,            /* 3 */
13125 /* 1208 */      NdrFcShort( 0x0 ),      /* 0 */
13126 /* 1210 */      0x29,           /* Corr desc:  parameter, FC_ULONG */
13127                         0x0,            /*  */
13128 #ifndef _ALPHA_
13129 /* 1212 */      NdrFcShort( 0x4 ),      /* x86, MIPS, PPC Stack size/offset = 4 */
13130 #else
13131                         NdrFcShort( 0x8 ),      /* Alpha Stack size/offset = 8 */
13132 #endif
13133 /* 1214 */      0x29,           /* Corr desc:  parameter, FC_ULONG */
13134                         0x54,           /* FC_DEREFERENCE */
13135 #ifndef _ALPHA_
13136 /* 1216 */      NdrFcShort( 0xc ),      /* x86, MIPS, PPC Stack size/offset = 12 */
13137 #else
13138                         NdrFcShort( 0x18 ),     /* Alpha Stack size/offset = 24 */
13139 #endif
13140 /* 1218 */      0x4c,           /* FC_EMBEDDED_COMPLEX */
13141                         0x0,            /* 0 */
13142 /* 1220 */      NdrFcShort( 0xffffff92 ),       /* Offset= -110 (1110) */
13143 /* 1222 */      0x5c,           /* FC_PAD */
13144                         0x5b,           /* FC_END */
13145 /* 1224 */
13146                         0x11, 0x14,     /* FC_RP [alloced_on_stack] */
13147 /* 1226 */      NdrFcShort( 0x2 ),      /* Offset= 2 (1228) */
13148 /* 1228 */
13149                         0x2f,           /* FC_IP */
13150                         0x5a,           /* FC_CONSTANT_IID */
13151 /* 1230 */      NdrFcLong( 0x20404 ),   /* 132100 */
13152 /* 1234 */      NdrFcShort( 0x0 ),      /* 0 */
13153 /* 1236 */      NdrFcShort( 0x0 ),      /* 0 */
13154 /* 1238 */      0xc0,           /* 192 */
13155                         0x0,            /* 0 */
13156 /* 1240 */      0x0,            /* 0 */
13157                         0x0,            /* 0 */
13158 /* 1242 */      0x0,            /* 0 */
13159                         0x0,            /* 0 */
13160 /* 1244 */      0x0,            /* 0 */
13161                         0x46,           /* 70 */
13162 /* 1246 */
13163                         0x11, 0x8,      /* FC_RP [simple_pointer] */
13164 /* 1248 */
13165                         0x25,           /* FC_C_WSTRING */
13166                         0x5c,           /* FC_PAD */
13167 /* 1250 */
13168                         0x11, 0xc,      /* FC_RP [alloced_on_stack] [simple_pointer] */
13169 /* 1252 */      0xe,            /* FC_ENUM32 */
13170                         0x5c,           /* FC_PAD */
13171 /* 1254 */
13172                         0x11, 0x14,     /* FC_RP [alloced_on_stack] */
13173 /* 1256 */      NdrFcShort( 0x2 ),      /* Offset= 2 (1258) */
13174 /* 1258 */
13175                         0x13, 0x0,      /* FC_OP */
13176 /* 1260 */      NdrFcShort( 0xaa ),     /* Offset= 170 (1430) */
13177 /* 1262 */
13178                         0x2b,           /* FC_NON_ENCAPSULATED_UNION */
13179                         0x7,            /* FC_USHORT */
13180 /* 1264 */      0x7,            /* Corr desc: FC_USHORT */
13181                         0x0,            /*  */
13182 /* 1266 */      NdrFcShort( 0x4 ),      /* 4 */
13183 /* 1268 */      NdrFcShort( 0x2 ),      /* Offset= 2 (1270) */
13184 /* 1270 */      NdrFcShort( 0x4 ),      /* 4 */
13185 /* 1272 */      NdrFcShort( 0x4 ),      /* 4 */
13186 /* 1274 */      NdrFcLong( 0x1a ),      /* 26 */
13187 /* 1278 */      NdrFcShort( 0x16 ),     /* Offset= 22 (1300) */
13188 /* 1280 */      NdrFcLong( 0x1b ),      /* 27 */
13189 /* 1284 */      NdrFcShort( 0x10 ),     /* Offset= 16 (1300) */
13190 /* 1286 */      NdrFcLong( 0x1c ),      /* 28 */
13191 /* 1290 */      NdrFcShort( 0xe ),      /* Offset= 14 (1304) */
13192 /* 1292 */      NdrFcLong( 0x1d ),      /* 29 */
13193 /* 1296 */      NdrFcShort( 0x8008 ),   /* Simple arm type: FC_LONG */
13194 /* 1298 */      NdrFcShort( 0x0 ),      /* Offset= 0 (1298) */
13195 /* 1300 */
13196                         0x13, 0x0,      /* FC_OP */
13197 /* 1302 */      NdrFcShort( 0x24 ),     /* Offset= 36 (1338) */
13198 /* 1304 */
13199                         0x13, 0x0,      /* FC_OP */
13200 /* 1306 */      NdrFcShort( 0x10 ),     /* Offset= 16 (1322) */
13201 /* 1308 */
13202                         0x1b,           /* FC_CARRAY */
13203                         0x3,            /* 3 */
13204 /* 1310 */      NdrFcShort( 0x8 ),      /* 8 */
13205 /* 1312 */      0x7,            /* Corr desc: FC_USHORT */
13206                         0x0,            /*  */
13207 /* 1314 */      NdrFcShort( 0xfffc ),   /* -4 */
13208 /* 1316 */      0x4c,           /* FC_EMBEDDED_COMPLEX */
13209                         0x0,            /* 0 */
13210 /* 1318 */      NdrFcShort( 0xfffffe78 ),       /* Offset= -392 (926) */
13211 /* 1320 */      0x5c,           /* FC_PAD */
13212                         0x5b,           /* FC_END */
13213 /* 1322 */
13214                         0x1a,           /* FC_BOGUS_STRUCT */
13215                         0x3,            /* 3 */
13216 /* 1324 */      NdrFcShort( 0x4 ),      /* 4 */
13217 /* 1326 */      NdrFcShort( 0xffffffee ),       /* Offset= -18 (1308) */
13218 /* 1328 */      NdrFcShort( 0x0 ),      /* Offset= 0 (1328) */
13219 /* 1330 */      0x4c,           /* FC_EMBEDDED_COMPLEX */
13220                         0x0,            /* 0 */
13221 /* 1332 */      NdrFcShort( 0x6 ),      /* Offset= 6 (1338) */
13222 /* 1334 */      0x6,            /* FC_SHORT */
13223                         0x3e,           /* FC_STRUCTPAD2 */
13224 /* 1336 */      0x5c,           /* FC_PAD */
13225                         0x5b,           /* FC_END */
13226 /* 1338 */
13227                         0x1a,           /* FC_BOGUS_STRUCT */
13228                         0x3,            /* 3 */
13229 /* 1340 */      NdrFcShort( 0x8 ),      /* 8 */
13230 /* 1342 */      NdrFcShort( 0x0 ),      /* 0 */
13231 /* 1344 */      NdrFcShort( 0x0 ),      /* Offset= 0 (1344) */
13232 /* 1346 */      0x4c,           /* FC_EMBEDDED_COMPLEX */
13233                         0x0,            /* 0 */
13234 /* 1348 */      NdrFcShort( 0xffffffaa ),       /* Offset= -86 (1262) */
13235 /* 1350 */      0x6,            /* FC_SHORT */
13236                         0x3e,           /* FC_STRUCTPAD2 */
13237 /* 1352 */      0x5c,           /* FC_PAD */
13238                         0x5b,           /* FC_END */
13239 /* 1354 */
13240                         0x1a,           /* FC_BOGUS_STRUCT */
13241                         0x3,            /* 3 */
13242 /* 1356 */      NdrFcShort( 0x18 ),     /* 24 */
13243 /* 1358 */      NdrFcShort( 0x0 ),      /* 0 */
13244 /* 1360 */      NdrFcShort( 0x0 ),      /* Offset= 0 (1360) */
13245 /* 1362 */      0x8,            /* FC_LONG */
13246                         0x4c,           /* FC_EMBEDDED_COMPLEX */
13247 /* 1364 */      0x4,            /* 4 */
13248                         NdrFcShort( 0xffffff01 ),       /* Offset= -255 (1110) */
13249                         0x5b,           /* FC_END */
13250 /* 1368 */
13251                         0x1a,           /* FC_BOGUS_STRUCT */
13252                         0x3,            /* 3 */
13253 /* 1370 */      NdrFcShort( 0x8 ),      /* 8 */
13254 /* 1372 */      NdrFcShort( 0x0 ),      /* 0 */
13255 /* 1374 */      NdrFcShort( 0x6 ),      /* Offset= 6 (1380) */
13256 /* 1376 */      0x36,           /* FC_POINTER */
13257                         0x6,            /* FC_SHORT */
13258 /* 1378 */      0x3e,           /* FC_STRUCTPAD2 */
13259                         0x5b,           /* FC_END */
13260 /* 1380 */
13261                         0x13, 0x0,      /* FC_OP */
13262 /* 1382 */      NdrFcShort( 0xffffffe4 ),       /* Offset= -28 (1354) */
13263 /* 1384 */
13264                         0x1a,           /* FC_BOGUS_STRUCT */
13265                         0x3,            /* 3 */
13266 /* 1386 */      NdrFcShort( 0x10 ),     /* 16 */
13267 /* 1388 */      NdrFcShort( 0x0 ),      /* 0 */
13268 /* 1390 */      NdrFcShort( 0x0 ),      /* Offset= 0 (1390) */
13269 /* 1392 */      0x4c,           /* FC_EMBEDDED_COMPLEX */
13270                         0x0,            /* 0 */
13271 /* 1394 */      NdrFcShort( 0xffffffc8 ),       /* Offset= -56 (1338) */
13272 /* 1396 */      0x4c,           /* FC_EMBEDDED_COMPLEX */
13273                         0x0,            /* 0 */
13274 /* 1398 */      NdrFcShort( 0xffffffe2 ),       /* Offset= -30 (1368) */
13275 /* 1400 */      0x5c,           /* FC_PAD */
13276                         0x5b,           /* FC_END */
13277 /* 1402 */
13278                         0x1b,           /* FC_CARRAY */
13279                         0x3,            /* 3 */
13280 /* 1404 */      NdrFcShort( 0x4 ),      /* 4 */
13281 /* 1406 */      0x16,           /* Corr desc:  field pointer, FC_SHORT */
13282                         0x0,            /*  */
13283 /* 1408 */      NdrFcShort( 0x1e ),     /* 30 */
13284 /* 1410 */      0x8,            /* FC_LONG */
13285                         0x5b,           /* FC_END */
13286 /* 1412 */
13287                         0x21,           /* FC_BOGUS_ARRAY */
13288                         0x3,            /* 3 */
13289 /* 1414 */      NdrFcShort( 0x0 ),      /* 0 */
13290 /* 1416 */      0x16,           /* Corr desc:  field pointer, FC_SHORT */
13291                         0x0,            /*  */
13292 /* 1418 */      NdrFcShort( 0x18 ),     /* 24 */
13293 /* 1420 */      NdrFcLong( 0xffffffff ),        /* -1 */
13294 /* 1424 */      0x4c,           /* FC_EMBEDDED_COMPLEX */
13295                         0x0,            /* 0 */
13296 /* 1426 */      NdrFcShort( 0xffffffd6 ),       /* Offset= -42 (1384) */
13297 /* 1428 */      0x5c,           /* FC_PAD */
13298                         0x5b,           /* FC_END */
13299 /* 1430 */
13300                         0x1a,           /* FC_BOGUS_STRUCT */
13301                         0x3,            /* 3 */
13302 /* 1432 */      NdrFcShort( 0x34 ),     /* 52 */
13303 /* 1434 */      NdrFcShort( 0x0 ),      /* 0 */
13304 /* 1436 */      NdrFcShort( 0x14 ),     /* Offset= 20 (1456) */
13305 /* 1438 */      0x8,            /* FC_LONG */
13306                         0x36,           /* FC_POINTER */
13307 /* 1440 */      0x36,           /* FC_POINTER */
13308                         0xe,            /* FC_ENUM32 */
13309 /* 1442 */      0xe,            /* FC_ENUM32 */
13310                         0xe,            /* FC_ENUM32 */
13311 /* 1444 */      0x6,            /* FC_SHORT */
13312                         0x6,            /* FC_SHORT */
13313 /* 1446 */      0x6,            /* FC_SHORT */
13314                         0x6,            /* FC_SHORT */
13315 /* 1448 */      0x4c,           /* FC_EMBEDDED_COMPLEX */
13316                         0x0,            /* 0 */
13317 /* 1450 */      NdrFcShort( 0xffffffbe ),       /* Offset= -66 (1384) */
13318 /* 1452 */      0x6,            /* FC_SHORT */
13319                         0x3e,           /* FC_STRUCTPAD2 */
13320 /* 1454 */      0x5c,           /* FC_PAD */
13321                         0x5b,           /* FC_END */
13322 /* 1456 */
13323                         0x13, 0x0,      /* FC_OP */
13324 /* 1458 */      NdrFcShort( 0xffffffc8 ),       /* Offset= -56 (1402) */
13325 /* 1460 */
13326                         0x13, 0x0,      /* FC_OP */
13327 /* 1462 */      NdrFcShort( 0xffffffce ),       /* Offset= -50 (1412) */
13328 /* 1464 */
13329                         0x11, 0x14,     /* FC_RP [alloced_on_stack] */
13330 /* 1466 */      NdrFcShort( 0x2 ),      /* Offset= 2 (1468) */
13331 /* 1468 */
13332                         0x13, 0x0,      /* FC_OP */
13333 /* 1470 */      NdrFcShort( 0x2c ),     /* Offset= 44 (1514) */
13334 /* 1472 */
13335                         0x2b,           /* FC_NON_ENCAPSULATED_UNION */
13336                         0x8,            /* FC_LONG */
13337 /* 1474 */      0x8,            /* Corr desc: FC_LONG */
13338                         0x0,            /*  */
13339 /* 1476 */      NdrFcShort( 0x18 ),     /* 24 */
13340 /* 1478 */      NdrFcShort( 0x2 ),      /* Offset= 2 (1480) */
13341 /* 1480 */      NdrFcShort( 0x4 ),      /* 4 */
13342 /* 1482 */      NdrFcShort( 0x4 ),      /* 4 */
13343 /* 1484 */      NdrFcLong( 0x0 ),       /* 0 */
13344 /* 1488 */      NdrFcShort( 0x8008 ),   /* Simple arm type: FC_LONG */
13345 /* 1490 */      NdrFcLong( 0x3 ),       /* 3 */
13346 /* 1494 */      NdrFcShort( 0x8008 ),   /* Simple arm type: FC_LONG */
13347 /* 1496 */      NdrFcLong( 0x1 ),       /* 1 */
13348 /* 1500 */      NdrFcShort( 0x8008 ),   /* Simple arm type: FC_LONG */
13349 /* 1502 */      NdrFcLong( 0x2 ),       /* 2 */
13350 /* 1506 */      NdrFcShort( 0x4 ),      /* Offset= 4 (1510) */
13351 /* 1508 */      NdrFcShort( 0xffffffff ),       /* Offset= -1 (1507) */
13352 /* 1510 */
13353                         0x13, 0x0,      /* FC_OP */
13354 /* 1512 */      NdrFcShort( 0xfffffe6e ),       /* Offset= -402 (1110) */
13355 /* 1514 */
13356                         0x1a,           /* FC_BOGUS_STRUCT */
13357                         0x3,            /* 3 */
13358 /* 1516 */      NdrFcShort( 0x24 ),     /* 36 */
13359 /* 1518 */      NdrFcShort( 0x0 ),      /* 0 */
13360 /* 1520 */      NdrFcShort( 0x10 ),     /* Offset= 16 (1536) */
13361 /* 1522 */      0x8,            /* FC_LONG */
13362                         0x36,           /* FC_POINTER */
13363 /* 1524 */      0x4c,           /* FC_EMBEDDED_COMPLEX */
13364                         0x0,            /* 0 */
13365 /* 1526 */      NdrFcShort( 0xffffffca ),       /* Offset= -54 (1472) */
13366 /* 1528 */      0x4c,           /* FC_EMBEDDED_COMPLEX */
13367                         0x0,            /* 0 */
13368 /* 1530 */      NdrFcShort( 0xffffff6e ),       /* Offset= -146 (1384) */
13369 /* 1532 */      0x6,            /* FC_SHORT */
13370                         0x38,           /* FC_ALIGNM4 */
13371 /* 1534 */      0xe,            /* FC_ENUM32 */
13372                         0x5b,           /* FC_END */
13373 /* 1536 */
13374                         0x13, 0x8,      /* FC_OP [simple_pointer] */
13375 /* 1538 */
13376                         0x25,           /* FC_C_WSTRING */
13377                         0x5c,           /* FC_PAD */
13378 /* 1540 */
13379                         0x11, 0x14,     /* FC_RP [alloced_on_stack] */
13380 /* 1542 */      NdrFcShort( 0x2 ),      /* Offset= 2 (1544) */
13381 /* 1544 */
13382                         0x2f,           /* FC_IP */
13383                         0x5a,           /* FC_CONSTANT_IID */
13384 /* 1546 */      NdrFcLong( 0x20403 ),   /* 132099 */
13385 /* 1550 */      NdrFcShort( 0x0 ),      /* 0 */
13386 /* 1552 */      NdrFcShort( 0x0 ),      /* 0 */
13387 /* 1554 */      0xc0,           /* 192 */
13388                         0x0,            /* 0 */
13389 /* 1556 */      0x0,            /* 0 */
13390                         0x0,            /* 0 */
13391 /* 1558 */      0x0,            /* 0 */
13392                         0x0,            /* 0 */
13393 /* 1560 */      0x0,            /* 0 */
13394                         0x46,           /* 70 */
13395 /* 1562 */
13396                         0x11, 0x4,      /* FC_RP [alloced_on_stack] */
13397 /* 1564 */      NdrFcShort( 0x4 ),      /* Offset= 4 (1568) */
13398 /* 1566 */      0x8,            /* FC_LONG */
13399                         0x5c,           /* FC_PAD */
13400 /* 1568 */      0xb4,           /* FC_USER_MARSHAL */
13401                         0x3,            /* 3 */
13402 /* 1570 */      NdrFcShort( 0x2 ),      /* 2 */
13403 /* 1572 */      NdrFcShort( 0xc ),      /* 12 */
13404 /* 1574 */      NdrFcShort( 0x4 ),      /* 4 */
13405 /* 1576 */      NdrFcShort( 0xfffffff6 ),       /* Offset= -10 (1566) */
13406 /* 1578 */
13407                         0x11, 0x14,     /* FC_RP [alloced_on_stack] */
13408 /* 1580 */      NdrFcShort( 0x2 ),      /* Offset= 2 (1582) */
13409 /* 1582 */
13410                         0x13, 0x0,      /* FC_OP */
13411 /* 1584 */      NdrFcShort( 0xe ),      /* Offset= 14 (1598) */
13412 /* 1586 */
13413                         0x1a,           /* FC_BOGUS_STRUCT */
13414                         0x3,            /* 3 */
13415 /* 1588 */      NdrFcShort( 0x8 ),      /* 8 */
13416 /* 1590 */      NdrFcShort( 0x0 ),      /* 0 */
13417 /* 1592 */      NdrFcShort( 0x0 ),      /* Offset= 0 (1592) */
13418 /* 1594 */      0x8,            /* FC_LONG */
13419                         0x6,            /* FC_SHORT */
13420 /* 1596 */      0x3e,           /* FC_STRUCTPAD2 */
13421                         0x5b,           /* FC_END */
13422 /* 1598 */
13423                         0x1a,           /* FC_BOGUS_STRUCT */
13424                         0x3,            /* 3 */
13425 /* 1600 */      NdrFcShort( 0x4c ),     /* 76 */
13426 /* 1602 */      NdrFcShort( 0x0 ),      /* 0 */
13427 /* 1604 */      NdrFcShort( 0x1e ),     /* Offset= 30 (1634) */
13428 /* 1606 */      0x4c,           /* FC_EMBEDDED_COMPLEX */
13429                         0x0,            /* 0 */
13430 /* 1608 */      NdrFcShort( 0xfffff9de ),       /* Offset= -1570 (38) */
13431 /* 1610 */      0x8,            /* FC_LONG */
13432                         0x8,            /* FC_LONG */
13433 /* 1612 */      0x8,            /* FC_LONG */
13434                         0x8,            /* FC_LONG */
13435 /* 1614 */      0x36,           /* FC_POINTER */
13436                         0x8,            /* FC_LONG */
13437 /* 1616 */      0xe,            /* FC_ENUM32 */
13438                         0x6,            /* FC_SHORT */
13439 /* 1618 */      0x6,            /* FC_SHORT */
13440                         0x6,            /* FC_SHORT */
13441 /* 1620 */      0x6,            /* FC_SHORT */
13442                         0x6,            /* FC_SHORT */
13443 /* 1622 */      0x6,            /* FC_SHORT */
13444                         0x6,            /* FC_SHORT */
13445 /* 1624 */      0x6,            /* FC_SHORT */
13446                         0x4c,           /* FC_EMBEDDED_COMPLEX */
13447 /* 1626 */      0x0,            /* 0 */
13448                         NdrFcShort( 0xfffffedf ),       /* Offset= -289 (1338) */
13449                         0x4c,           /* FC_EMBEDDED_COMPLEX */
13450 /* 1630 */      0x0,            /* 0 */
13451                         NdrFcShort( 0xffffffd3 ),       /* Offset= -45 (1586) */
13452                         0x5b,           /* FC_END */
13453 /* 1634 */
13454                         0x13, 0x8,      /* FC_OP [simple_pointer] */
13455 /* 1636 */
13456                         0x25,           /* FC_C_WSTRING */
13457                         0x5c,           /* FC_PAD */
13458 /* 1638 */
13459                         0x11, 0x4,      /* FC_RP [alloced_on_stack] */
13460 /* 1640 */      NdrFcShort( 0x4 ),      /* Offset= 4 (1644) */
13461 /* 1642 */      0x8,            /* FC_LONG */
13462                         0x5c,           /* FC_PAD */
13463 /* 1644 */      0xb4,           /* FC_USER_MARSHAL */
13464                         0x3,            /* 3 */
13465 /* 1646 */      NdrFcShort( 0x2 ),      /* 2 */
13466 /* 1648 */      NdrFcShort( 0xc ),      /* 12 */
13467 /* 1650 */      NdrFcShort( 0x4 ),      /* 4 */
13468 /* 1652 */      NdrFcShort( 0xfffffff6 ),       /* Offset= -10 (1642) */
13469 /* 1654 */
13470                         0x11, 0x4,      /* FC_RP [alloced_on_stack] */
13471 /* 1656 */      NdrFcShort( 0x4 ),      /* Offset= 4 (1660) */
13472 /* 1658 */      0x8,            /* FC_LONG */
13473                         0x5c,           /* FC_PAD */
13474 /* 1660 */      0xb4,           /* FC_USER_MARSHAL */
13475                         0x3,            /* 3 */
13476 /* 1662 */      NdrFcShort( 0x2 ),      /* 2 */
13477 /* 1664 */      NdrFcShort( 0xc ),      /* 12 */
13478 /* 1666 */      NdrFcShort( 0x4 ),      /* 4 */
13479 /* 1668 */      NdrFcShort( 0xfffffff6 ),       /* Offset= -10 (1658) */
13480 /* 1670 */
13481                         0x11, 0x4,      /* FC_RP [alloced_on_stack] */
13482 /* 1672 */      NdrFcShort( 0x4 ),      /* Offset= 4 (1676) */
13483 /* 1674 */      0x8,            /* FC_LONG */
13484                         0x5c,           /* FC_PAD */
13485 /* 1676 */      0xb4,           /* FC_USER_MARSHAL */
13486                         0x3,            /* 3 */
13487 /* 1678 */      NdrFcShort( 0x2 ),      /* 2 */
13488 /* 1680 */      NdrFcShort( 0xc ),      /* 12 */
13489 /* 1682 */      NdrFcShort( 0x4 ),      /* 4 */
13490 /* 1684 */      NdrFcShort( 0xfffffff6 ),       /* Offset= -10 (1674) */
13491 /* 1686 */
13492                         0x11, 0x0,      /* FC_RP */
13493 /* 1688 */      NdrFcShort( 0x2 ),      /* Offset= 2 (1690) */
13494 /* 1690 */
13495                         0x21,           /* FC_BOGUS_ARRAY */
13496                         0x3,            /* 3 */
13497 /* 1692 */      NdrFcShort( 0x0 ),      /* 0 */
13498 /* 1694 */      0x29,           /* Corr desc:  parameter, FC_ULONG */
13499                         0x0,            /*  */
13500 #ifndef _ALPHA_
13501 /* 1696 */      NdrFcShort( 0xc ),      /* x86, MIPS, PPC Stack size/offset = 12 */
13502 #else
13503                         NdrFcShort( 0x18 ),     /* Alpha Stack size/offset = 24 */
13504 #endif
13505 /* 1698 */      0x29,           /* Corr desc:  parameter, FC_ULONG */
13506                         0x54,           /* FC_DEREFERENCE */
13507 #ifndef _ALPHA_
13508 /* 1700 */      NdrFcShort( 0x10 ),     /* x86, MIPS, PPC Stack size/offset = 16 */
13509 #else
13510                         NdrFcShort( 0x20 ),     /* Alpha Stack size/offset = 32 */
13511 #endif
13512 /* 1702 */      0x4c,           /* FC_EMBEDDED_COMPLEX */
13513                         0x0,            /* 0 */
13514 /* 1704 */      NdrFcShort( 0xfffffdc0 ),       /* Offset= -576 (1128) */
13515 /* 1706 */      0x5c,           /* FC_PAD */
13516                         0x5b,           /* FC_END */
13517 /* 1708 */
13518                         0x11, 0x4,      /* FC_RP [alloced_on_stack] */
13519 /* 1710 */      NdrFcShort( 0xfffffdba ),       /* Offset= -582 (1128) */
13520 /* 1712 */
13521                         0x11, 0xc,      /* FC_RP [alloced_on_stack] [simple_pointer] */
13522 /* 1714 */      0x6,            /* FC_SHORT */
13523                         0x5c,           /* FC_PAD */
13524 /* 1716 */
13525                         0x11, 0x14,     /* FC_RP [alloced_on_stack] */
13526 /* 1718 */      NdrFcShort( 0x2 ),      /* Offset= 2 (1720) */
13527 /* 1720 */
13528                         0x2f,           /* FC_IP */
13529                         0x5c,           /* FC_PAD */
13530 /* 1722 */      0x28,           /* Corr desc:  parameter, FC_LONG */
13531                         0x0,            /*  */
13532 #ifndef _ALPHA_
13533 /* 1724 */      NdrFcShort( 0x4 ),      /* x86, MIPS, PPC Stack size/offset = 4 */
13534 #else
13535                         NdrFcShort( 0x8 ),      /* Alpha Stack size/offset = 8 */
13536 #endif
13537 /* 1726 */
13538                         0x11, 0x14,     /* FC_RP [alloced_on_stack] */
13539 /* 1728 */      NdrFcShort( 0x2 ),      /* Offset= 2 (1730) */
13540 /* 1730 */
13541                         0x2f,           /* FC_IP */
13542                         0x5a,           /* FC_CONSTANT_IID */
13543 /* 1732 */      NdrFcLong( 0x20402 ),   /* 132098 */
13544 /* 1736 */      NdrFcShort( 0x0 ),      /* 0 */
13545 /* 1738 */      NdrFcShort( 0x0 ),      /* 0 */
13546 /* 1740 */      0xc0,           /* 192 */
13547                         0x0,            /* 0 */
13548 /* 1742 */      0x0,            /* 0 */
13549                         0x0,            /* 0 */
13550 /* 1744 */      0x0,            /* 0 */
13551                         0x0,            /* 0 */
13552 /* 1746 */      0x0,            /* 0 */
13553                         0x46,           /* 70 */
13554 /* 1748 */
13555                         0x11, 0x4,      /* FC_RP [alloced_on_stack] */
13556 /* 1750 */      NdrFcShort( 0x26 ),     /* Offset= 38 (1788) */
13557 /* 1752 */
13558                         0x1a,           /* FC_BOGUS_STRUCT */
13559                         0x3,            /* 3 */
13560 /* 1754 */      NdrFcShort( 0x20 ),     /* 32 */
13561 /* 1756 */      NdrFcShort( 0x0 ),      /* 0 */
13562 /* 1758 */      NdrFcShort( 0x0 ),      /* Offset= 0 (1758) */
13563 /* 1760 */      0x4c,           /* FC_EMBEDDED_COMPLEX */
13564                         0x0,            /* 0 */
13565 /* 1762 */      NdrFcShort( 0xfffff944 ),       /* Offset= -1724 (38) */
13566 /* 1764 */      0x4c,           /* FC_EMBEDDED_COMPLEX */
13567                         0x0,            /* 0 */
13568 /* 1766 */      NdrFcShort( 0xfffffd70 ),       /* Offset= -656 (1110) */
13569 /* 1768 */      0x5c,           /* FC_PAD */
13570                         0x5b,           /* FC_END */
13571 /* 1770 */
13572                         0x21,           /* FC_BOGUS_ARRAY */
13573                         0x3,            /* 3 */
13574 /* 1772 */      NdrFcShort( 0x0 ),      /* 0 */
13575 /* 1774 */      0x19,           /* Corr desc:  field pointer, FC_ULONG */
13576                         0x0,            /*  */
13577 /* 1776 */      NdrFcShort( 0x0 ),      /* 0 */
13578 /* 1778 */      NdrFcLong( 0xffffffff ),        /* -1 */
13579 /* 1782 */      0x4c,           /* FC_EMBEDDED_COMPLEX */
13580                         0x0,            /* 0 */
13581 /* 1784 */      NdrFcShort( 0xffffffe0 ),       /* Offset= -32 (1752) */
13582 /* 1786 */      0x5c,           /* FC_PAD */
13583                         0x5b,           /* FC_END */
13584 /* 1788 */
13585                         0x1a,           /* FC_BOGUS_STRUCT */
13586                         0x3,            /* 3 */
13587 /* 1790 */      NdrFcShort( 0x8 ),      /* 8 */
13588 /* 1792 */      NdrFcShort( 0x0 ),      /* 0 */
13589 /* 1794 */      NdrFcShort( 0x6 ),      /* Offset= 6 (1800) */
13590 /* 1796 */      0x8,            /* FC_LONG */
13591                         0x36,           /* FC_POINTER */
13592 /* 1798 */      0x5c,           /* FC_PAD */
13593                         0x5b,           /* FC_END */
13594 /* 1800 */
13595                         0x13, 0x0,      /* FC_OP */
13596 /* 1802 */      NdrFcShort( 0xffffffe0 ),       /* Offset= -32 (1770) */
13597 /* 1804 */
13598                         0x11, 0x14,     /* FC_RP [alloced_on_stack] */
13599 /* 1806 */      NdrFcShort( 0x2 ),      /* Offset= 2 (1808) */
13600 /* 1808 */
13601                         0x13, 0x0,      /* FC_OP */
13602 /* 1810 */      NdrFcShort( 0x2 ),      /* Offset= 2 (1812) */
13603 /* 1812 */
13604                         0x1a,           /* FC_BOGUS_STRUCT */
13605                         0x3,            /* 3 */
13606 /* 1814 */      NdrFcShort( 0x20 ),     /* 32 */
13607 /* 1816 */      NdrFcShort( 0x0 ),      /* 0 */
13608 /* 1818 */      NdrFcShort( 0x0 ),      /* Offset= 0 (1818) */
13609 /* 1820 */      0x4c,           /* FC_EMBEDDED_COMPLEX */
13610                         0x0,            /* 0 */
13611 /* 1822 */      NdrFcShort( 0xfffff908 ),       /* Offset= -1784 (38) */
13612 /* 1824 */      0x8,            /* FC_LONG */
13613                         0xe,            /* FC_ENUM32 */
13614 /* 1826 */      0x6,            /* FC_SHORT */
13615                         0x6,            /* FC_SHORT */
13616 /* 1828 */      0x6,            /* FC_SHORT */
13617                         0x3e,           /* FC_STRUCTPAD2 */
13618 /* 1830 */      0x5c,           /* FC_PAD */
13619                         0x5b,           /* FC_END */
13620 /* 1832 */
13621                         0x11, 0x4,      /* FC_RP [alloced_on_stack] */
13622 /* 1834 */      NdrFcShort( 0x4 ),      /* Offset= 4 (1838) */
13623 /* 1836 */      0x8,            /* FC_LONG */
13624                         0x5c,           /* FC_PAD */
13625 /* 1838 */      0xb4,           /* FC_USER_MARSHAL */
13626                         0x3,            /* 3 */
13627 /* 1840 */      NdrFcShort( 0x2 ),      /* 2 */
13628 /* 1842 */      NdrFcShort( 0xc ),      /* 12 */
13629 /* 1844 */      NdrFcShort( 0x4 ),      /* 4 */
13630 /* 1846 */      NdrFcShort( 0xfffffff6 ),       /* Offset= -10 (1836) */
13631 /* 1848 */
13632                         0x11, 0x0,      /* FC_RP */
13633 /* 1850 */      NdrFcShort( 0x2 ),      /* Offset= 2 (1852) */
13634 /* 1852 */
13635                         0x21,           /* FC_BOGUS_ARRAY */
13636                         0x3,            /* 3 */
13637 /* 1854 */      NdrFcShort( 0x0 ),      /* 0 */
13638 /* 1856 */      0x27,           /* Corr desc:  parameter, FC_USHORT */
13639                         0x54,           /* FC_DEREFERENCE */
13640 #ifndef _ALPHA_
13641 /* 1858 */      NdrFcShort( 0x14 ),     /* x86, MIPS, PPC Stack size/offset = 20 */
13642 #else
13643                         NdrFcShort( 0x28 ),     /* Alpha Stack size/offset = 40 */
13644 #endif
13645 /* 1860 */      0x27,           /* Corr desc:  parameter, FC_USHORT */
13646                         0x54,           /* FC_DEREFERENCE */
13647 #ifndef _ALPHA_
13648 /* 1862 */      NdrFcShort( 0x14 ),     /* x86, MIPS, PPC Stack size/offset = 20 */
13649 #else
13650                         NdrFcShort( 0x28 ),     /* Alpha Stack size/offset = 40 */
13651 #endif
13652 /* 1864 */      0x4c,           /* FC_EMBEDDED_COMPLEX */
13653                         0x0,            /* 0 */
13654 /* 1866 */      NdrFcShort( 0xfffff8c0 ),       /* Offset= -1856 (10) */
13655 /* 1868 */      0x5c,           /* FC_PAD */
13656                         0x5b,           /* FC_END */
13657 /* 1870 */
13658                         0x11, 0x0,      /* FC_RP */
13659 /* 1872 */      NdrFcShort( 0x2 ),      /* Offset= 2 (1874) */
13660 /* 1874 */
13661                         0x1c,           /* FC_CVARRAY */
13662                         0x3,            /* 3 */
13663 /* 1876 */      NdrFcShort( 0x4 ),      /* 4 */
13664 /* 1878 */      0x27,           /* Corr desc:  parameter, FC_USHORT */
13665                         0x54,           /* FC_DEREFERENCE */
13666 #ifndef _ALPHA_
13667 /* 1880 */      NdrFcShort( 0x14 ),     /* x86, MIPS, PPC Stack size/offset = 20 */
13668 #else
13669                         NdrFcShort( 0x28 ),     /* Alpha Stack size/offset = 40 */
13670 #endif
13671 /* 1882 */      0x27,           /* Corr desc:  parameter, FC_USHORT */
13672                         0x54,           /* FC_DEREFERENCE */
13673 #ifndef _ALPHA_
13674 /* 1884 */      NdrFcShort( 0x14 ),     /* x86, MIPS, PPC Stack size/offset = 20 */
13675 #else
13676                         NdrFcShort( 0x28 ),     /* Alpha Stack size/offset = 40 */
13677 #endif
13678 /* 1886 */      0x8,            /* FC_LONG */
13679                         0x5b,           /* FC_END */
13680 /* 1888 */
13681                         0x11, 0x8,      /* FC_RP [simple_pointer] */
13682 /* 1890 */      0x6,            /* FC_SHORT */
13683                         0x5c,           /* FC_PAD */
13684 /* 1892 */
13685                         0x11, 0x4,      /* FC_RP [alloced_on_stack] */
13686 /* 1894 */      NdrFcShort( 0xfffff8c0 ),       /* Offset= -1856 (38) */
13687 /* 1896 */
13688                         0x11, 0x14,     /* FC_RP [alloced_on_stack] */
13689 /* 1898 */      NdrFcShort( 0x2 ),      /* Offset= 2 (1900) */
13690 /* 1900 */
13691                         0x2f,           /* FC_IP */
13692                         0x5c,           /* FC_PAD */
13693 /* 1902 */      0x28,           /* Corr desc:  parameter, FC_LONG */
13694                         0x0,            /*  */
13695 #ifndef _ALPHA_
13696 /* 1904 */      NdrFcShort( 0x8 ),      /* x86, MIPS, PPC Stack size/offset = 8 */
13697 #else
13698                         NdrFcShort( 0x10 ),     /* Alpha Stack size/offset = 16 */
13699 #endif
13700
13701                         0x0
13702         }
13703     };
13704
13705 static const CInterfaceProxyVtbl * const _oaidl_ProxyVtblList[] =
13706 {
13707     ( const CInterfaceProxyVtbl *) &_IDispatchProxyVtbl,
13708     ( const CInterfaceProxyVtbl *) &_ITypeInfoProxyVtbl,
13709     ( const CInterfaceProxyVtbl *) &_ITypeLibProxyVtbl,
13710     ( const CInterfaceProxyVtbl *) &_ITypeCompProxyVtbl,
13711     ( const CInterfaceProxyVtbl *) &_IEnumVARIANTProxyVtbl,
13712     ( const CInterfaceProxyVtbl *) &_ITypeLib2ProxyVtbl,
13713     ( const CInterfaceProxyVtbl *) &_ITypeInfo2ProxyVtbl,
13714     ( const CInterfaceProxyVtbl *) &_IErrorInfoProxyVtbl,
13715     ( const CInterfaceProxyVtbl *) &_ITypeFactoryProxyVtbl,
13716     ( const CInterfaceProxyVtbl *) &_ICreateErrorInfoProxyVtbl,
13717     ( const CInterfaceProxyVtbl *) &_ISupportErrorInfoProxyVtbl,
13718     0
13719 };
13720
13721 static const CInterfaceStubVtbl * const _oaidl_StubVtblList[] =
13722 {
13723     ( const CInterfaceStubVtbl *) &_IDispatchStubVtbl,
13724     ( const CInterfaceStubVtbl *) &_ITypeInfoStubVtbl,
13725     ( const CInterfaceStubVtbl *) &_ITypeLibStubVtbl,
13726     ( const CInterfaceStubVtbl *) &_ITypeCompStubVtbl,
13727     ( const CInterfaceStubVtbl *) &_IEnumVARIANTStubVtbl,
13728     ( const CInterfaceStubVtbl *) &_ITypeLib2StubVtbl,
13729     ( const CInterfaceStubVtbl *) &_ITypeInfo2StubVtbl,
13730     ( const CInterfaceStubVtbl *) &_IErrorInfoStubVtbl,
13731     ( const CInterfaceStubVtbl *) &_ITypeFactoryStubVtbl,
13732     ( const CInterfaceStubVtbl *) &_ICreateErrorInfoStubVtbl,
13733     ( const CInterfaceStubVtbl *) &_ISupportErrorInfoStubVtbl,
13734     0
13735 };
13736
13737 static const PCInterfaceName _oaidl_InterfaceNamesList[] =
13738 {
13739     "IDispatch",
13740     "ITypeInfo",
13741     "ITypeLib",
13742     "ITypeComp",
13743     "IEnumVARIANT",
13744     "ITypeLib2",
13745     "ITypeInfo2",
13746     "IErrorInfo",
13747     "ITypeFactory",
13748     "ICreateErrorInfo",
13749     "ISupportErrorInfo",
13750     0
13751 };
13752
13753
13754 #define _oaidl_CHECK_IID(n)     IID_GENERIC_CHECK_IID( _oaidl, pIID, n)
13755
13756 int __stdcall _oaidl_IID_Lookup( const IID * pIID, int * pIndex )
13757 {
13758     IID_BS_LOOKUP_SETUP
13759
13760     IID_BS_LOOKUP_INITIAL_TEST( _oaidl, 11, 8 )
13761     IID_BS_LOOKUP_NEXT_TEST( _oaidl, 4 )
13762     IID_BS_LOOKUP_NEXT_TEST( _oaidl, 2 )
13763     IID_BS_LOOKUP_NEXT_TEST( _oaidl, 1 )
13764     IID_BS_LOOKUP_RETURN_RESULT( _oaidl, 11, *pIndex )
13765
13766 }
13767
13768 const ExtendedProxyFileInfo oaidl_ProxyFileInfo =
13769 {
13770     (const PCInterfaceProxyVtblList *) & _oaidl_ProxyVtblList,
13771     (const PCInterfaceStubVtblList *) & _oaidl_StubVtblList,
13772     (const PCInterfaceName * ) & _oaidl_InterfaceNamesList,
13773     0, /* no delegation */
13774     & _oaidl_IID_Lookup,
13775     11,
13776     1,
13777     0, /* table of [async_uuid] interfaces */
13778     0, /* Filler1 */
13779     0, /* Filler2 */
13780     0  /* Filler3 */
13781 };