Changeset 267


Ignore:
Timestamp:
Feb 2, 2014, 2:11:51 AM (10 years ago)
Author:
roman
Message:

Updated source code/copyright notice

Location:
trunk/DirectShowSpy
Files:
24 edited

Legend:

Unmodified
Added
Removed

  • trunk/DirectShowSpy/AboutDialog.h

    r233 r267  
    22// Copyright (C) Roman Ryltsov, 2008-2014
    33// Created by Roman Ryltsov roman@alax.info
     4//
     5// This source code is published to complement DirectShowSpy developer powertoy
     6// and demonstrate the internal use of APIs and tricks powering the tool. It is
     7// allowed to freely re-use the portions of the code in other projects, commercial or otherwise
     8// (provided that you don’t pretend that you wrote the original tool).
     9//
     10// Please keep in mind that DirectShowSpy is a developer tool, it is strongly recommended
     11// that it is not shipped with release grade software. The advise applies to hooking methods
     12// used by DirectShowSpy in general as well.
    413
    514#pragma once

  • trunk/DirectShowSpy/Common.h

    r196 r267  
    11////////////////////////////////////////////////////////////
    2 // Copyright (C) Roman Ryltsov, 2008-2011
     2// Copyright (C) Roman Ryltsov, 2008-2014
    33// Created by Roman Ryltsov roman@alax.info
     4//
     5// This source code is published to complement DirectShowSpy developer powertoy
     6// and demonstrate the internal use of APIs and tricks powering the tool. It is
     7// allowed to freely re-use the portions of the code in other projects, commercial or otherwise
     8// (provided that you don’t pretend that you wrote the original tool).
     9//
     10// Please keep in mind that DirectShowSpy is a developer tool, it is strongly recommended
     11// that it is not shipped with release grade software. The advise applies to hooking methods
     12// used by DirectShowSpy in general as well.
    413
    514#pragma once

  • trunk/DirectShowSpy/Configuration.cpp

    r231 r267  
    22// Copyright (C) Roman Ryltsov, 2008-2014
    33// Created by Roman Ryltsov roman@alax.info
     4//
     5// This source code is published to complement DirectShowSpy developer powertoy
     6// and demonstrate the internal use of APIs and tricks powering the tool. It is
     7// allowed to freely re-use the portions of the code in other projects, commercial or otherwise
     8// (provided that you don’t pretend that you wrote the original tool).
     9//
     10// Please keep in mind that DirectShowSpy is a developer tool, it is strongly recommended
     11// that it is not shipped with release grade software. The advise applies to hooking methods
     12// used by DirectShowSpy in general as well.
    413
    514#include "stdafx.h"

  • trunk/DirectShowSpy/Configuration.h

    r196 r267  
    11////////////////////////////////////////////////////////////
    2 // Copyright (C) Roman Ryltsov, 2008-2011
     2// Copyright (C) Roman Ryltsov, 2008-2014
    33// Created by Roman Ryltsov roman@alax.info
     4//
     5// This source code is published to complement DirectShowSpy developer powertoy
     6// and demonstrate the internal use of APIs and tricks powering the tool. It is
     7// allowed to freely re-use the portions of the code in other projects, commercial or otherwise
     8// (provided that you don’t pretend that you wrote the original tool).
     9//
     10// Please keep in mind that DirectShowSpy is a developer tool, it is strongly recommended
     11// that it is not shipped with release grade software. The advise applies to hooking methods
     12// used by DirectShowSpy in general as well.
    413
    514#pragma once

  • trunk/DirectShowSpy/DirectShowSpy.cpp

    r231 r267  
    22// Copyright (C) Roman Ryltsov, 2008-2014
    33// Created by Roman Ryltsov roman@alax.info
     4//
     5// This source code is published to complement DirectShowSpy developer powertoy
     6// and demonstrate the internal use of APIs and tricks powering the tool. It is
     7// allowed to freely re-use the portions of the code in other projects, commercial or otherwise
     8// (provided that you don’t pretend that you wrote the original tool).
     9//
     10// Please keep in mind that DirectShowSpy is a developer tool, it is strongly recommended
     11// that it is not shipped with release grade software. The advise applies to hooking methods
     12// used by DirectShowSpy in general as well.
    413
    514#include "stdafx.h"

  • trunk/DirectShowSpy/DirectShowSpy.idl

    r266 r267  
    22// Copyright (C) Roman Ryltsov, 2008-2014
    33// Created by Roman Ryltsov roman@alax.info
     4//
     5// This source code is published to complement DirectShowSpy developer powertoy
     6// and demonstrate the internal use of APIs and tricks powering the tool. It is
     7// allowed to freely re-use the portions of the code in other projects, commercial or otherwise
     8// (provided that you don’t pretend that you wrote the original tool).
     9//
     10// Please keep in mind that DirectShowSpy is a developer tool, it is strongly recommended
     11// that it is not shipped with release grade software. The advise applies to hooking methods
     12// used by DirectShowSpy in general as well.
    413
    514import "oaidl.idl";

  • trunk/DirectShowSpy/DirectShowSpy.rc

    r266 r267  
    6060
    6161VS_VERSION_INFO VERSIONINFO
    62  FILEVERSION  1, 0, 0, 1405
     62 FILEVERSION  1, 0, 0, 1411
    6363 PRODUCTVERSION 1,0,0,1
    6464 FILEFLAGSMASK 0x3fL
    … …  
    7979            VALUE "CompanyName", "Roman Ryltsov"
    8080            VALUE "FileDescription", "Alax.Info DirectShow Spy Module"
    81             VALUE "FileVersion",  "1, 0, 0, 1405\0"
     81            VALUE "FileVersion",  "1, 0, 0, 1411\0"
    8282            VALUE "InternalName", "DirectShowSpy.dll"
    8383            VALUE "LegalCopyright", "Copyright © Alax.Info, Roman Ryltsov, 2008-2014"

  • trunk/DirectShowSpy/DirectShowSpy_i.c

    r266 r267  
    77
    88 /* File created by MIDL compiler version 7.00.0555 */
    9 /* at Sun Feb 02 11:24:37 2014
     9/* at Sun Feb 02 11:37:18 2014
    1010 */
    1111/* Compiler settings for DirectShowSpy.idl:
    12     Oicf, W1, Zp8, env=Win32 (32b run), target_arch=X86 7.00.0555
     12    Oicf, W1, Zp8, env=Win64 (32b run), target_arch=AMD64 7.00.0555
    1313    protocol : dce , ms_ext, c_ext, robust
    1414    error checks: allocation ref bounds_check enum stub_data

  • trunk/DirectShowSpy/DirectShowSpy_i.h

    r266 r267  
    55
    66 /* File created by MIDL compiler version 7.00.0555 */
    7 /* at Sun Feb 02 11:24:37 2014
     7/* at Sun Feb 02 11:37:18 2014
    88 */
    99/* Compiler settings for DirectShowSpy.idl:
    10     Oicf, W1, Zp8, env=Win32 (32b run), target_arch=X86 7.00.0555
     10    Oicf, W1, Zp8, env=Win64 (32b run), target_arch=AMD64 7.00.0555
    1111    protocol : dce , ms_ext, c_ext, robust
    1212    error checks: allocation ref bounds_check enum stub_data

  • trunk/DirectShowSpy/DirectShowSpy_p.c

    r266 r267  
    55
    66 /* File created by MIDL compiler version 7.00.0555 */
    7 /* at Sun Feb 02 11:24:37 2014
     7/* at Sun Feb 02 11:37:18 2014
    88 */
    99/* Compiler settings for DirectShowSpy.idl:
    10     Oicf, W1, Zp8, env=Win32 (32b run), target_arch=X86 7.00.0555
     10    Oicf, W1, Zp8, env=Win64 (32b run), target_arch=AMD64 7.00.0555
    1111    protocol : dce , ms_ext, c_ext, robust
    1212    error checks: allocation ref bounds_check enum stub_data
    … …  
    1717/* @@MIDL_FILE_HEADING(  ) */
    1818
    19 #if !defined(_M_IA64) && !defined(_M_AMD64)
     19#if defined(_M_AMD64)
    2020
    2121
    … …  
    2929#pragma warning( disable: 4024 )  /* array to pointer mapping*/
    3030#pragma warning( disable: 4152 )  /* function/data pointer conversion in expression */
    31 #pragma warning( disable: 4100 ) /* unreferenced arguments in x86 call */
    32 
    33 #pragma optimize("", off )
    3431
    3532#define USE_STUBLESS_PROXY
    … …  
    5047#include "DirectShowSpy_i.h"
    5148
    52 #define TYPE_FORMAT_STRING_SIZE   1079                             
    53 #define PROC_FORMAT_STRING_SIZE   553                               
     49#define TYPE_FORMAT_STRING_SIZE   1029                             
     50#define PROC_FORMAT_STRING_SIZE   581                               
    5451#define EXPR_FORMAT_STRING_SIZE   1                                 
    5552#define TRANSMIT_AS_TABLE_SIZE    0           
    … …  
    114111extern const USER_MARSHAL_ROUTINE_QUADRUPLE UserMarshalRoutines[ WIRE_MARSHAL_TABLE_SIZE ];
    115112
    116 #if !defined(__RPC_WIN32__)
     113#if !defined(__RPC_WIN64__)
    117114#error  Invalid build platform for this stub.
    118115#endif
    119 
    120 #if !(TARGET_IS_NT50_OR_LATER)
    121 #error You need Windows 2000 or later to run this stub because it uses these features:
    122 #error   /robust command line switch.
    123 #error However, your C/C++ compilation flags indicate you intend to run this app on earlier systems.
    124 #error This app will fail with the RPC_X_WRONG_STUB_VERSION error.
    125 #endif
    126 
    127116
    128117static const DirectShowSpy_MIDL_PROC_FORMAT_STRING DirectShowSpy__MIDL_ProcFormatString =
    … …  
    137126/*  2 */        NdrFcLong( 0x0 ),       /* 0 */
    138127/*  6 */        NdrFcShort( 0x7 ),      /* 7 */
    139 /*  8 */        NdrFcShort( 0xc ),      /* x86 Stack size/offset = 12 */
     128/*  8 */        NdrFcShort( 0x18 ),     /* X64 Stack size/offset = 24 */
    140129/* 10 */        NdrFcShort( 0x0 ),      /* 0 */
    141130/* 12 */        NdrFcShort( 0x8 ),      /* 8 */
    142131/* 14 */        0x45,           /* Oi2 Flags:  srv must size, has return, has ext, */
    143132                        0x2,            /* 2 */
    144 /* 16 */        0x8,            /* 8 */
     133/* 16 */        0xa,            /* 10 */
    145134                        0x3,            /* Ext Flags:  new corr desc, clt corr check, */
    146135/* 18 */        NdrFcShort( 0x1 ),      /* 1 */
    147136/* 20 */        NdrFcShort( 0x0 ),      /* 0 */
    148137/* 22 */        NdrFcShort( 0x0 ),      /* 0 */
     138/* 24 */        NdrFcShort( 0x0 ),      /* 0 */
    149139
    150140        /* Parameter psMonikerDisplayName */
    151141
    152 /* 24 */        NdrFcShort( 0x2113 ),   /* Flags:  must size, must free, out, simple ref, srv alloc size=8 */
    153 /* 26 */        NdrFcShort( 0x4 ),      /* x86 Stack size/offset = 4 */
    154 /* 28 */        NdrFcShort( 0x20 ),     /* Type Offset=32 */
     142/* 26 */        NdrFcShort( 0x2113 ),   /* Flags:  must size, must free, out, simple ref, srv alloc size=8 */
     143/* 28 */        NdrFcShort( 0x8 ),      /* X64 Stack size/offset = 8 */
     144/* 30 */        NdrFcShort( 0x20 ),     /* Type Offset=32 */
    155145
    156146        /* Return value */
    157147
    158 /* 30 */        NdrFcShort( 0x70 ),     /* Flags:  out, return, base type, */
    159 /* 32 */        NdrFcShort( 0x8 ),      /* x86 Stack size/offset = 8 */
    160 /* 34 */        0x8,            /* FC_LONG */
     148/* 32 */        NdrFcShort( 0x70 ),     /* Flags:  out, return, base type, */
     149/* 34 */        NdrFcShort( 0x10 ),     /* X64 Stack size/offset = 16 */
     150/* 36 */        0x8,            /* FC_LONG */
    161151                        0x0,            /* 0 */
    162152
    163153        /* Procedure get_CreationTime */
    164154
    165 /* 36 */        0x33,           /* FC_AUTO_HANDLE */
     155/* 38 */        0x33,           /* FC_AUTO_HANDLE */
    166156                        0x6c,           /* Old Flags:  object, Oi2 */
    167 /* 38 */        NdrFcLong( 0x0 ),       /* 0 */
    168 /* 42 */        NdrFcShort( 0x8 ),      /* 8 */
    169 /* 44 */        NdrFcShort( 0xc ),      /* x86 Stack size/offset = 12 */
    170 /* 46 */        NdrFcShort( 0x0 ),      /* 0 */
    171 /* 48 */        NdrFcShort( 0x2c ),     /* 44 */
    172 /* 50 */        0x44,           /* Oi2 Flags:  has return, has ext, */
     157/* 40 */        NdrFcLong( 0x0 ),       /* 0 */
     158/* 44 */        NdrFcShort( 0x8 ),      /* 8 */
     159/* 46 */        NdrFcShort( 0x18 ),     /* X64 Stack size/offset = 24 */
     160/* 48 */        NdrFcShort( 0x0 ),      /* 0 */
     161/* 50 */        NdrFcShort( 0x2c ),     /* 44 */
     162/* 52 */        0x44,           /* Oi2 Flags:  has return, has ext, */
    173163                        0x2,            /* 2 */
    174 /* 52 */        0x8,            /* 8 */
     164/* 54 */        0xa,            /* 10 */
    175165                        0x1,            /* Ext Flags:  new corr desc, */
    176 /* 54 */        NdrFcShort( 0x0 ),      /* 0 */
    177166/* 56 */        NdrFcShort( 0x0 ),      /* 0 */
    178167/* 58 */        NdrFcShort( 0x0 ),      /* 0 */
     168/* 60 */        NdrFcShort( 0x0 ),      /* 0 */
     169/* 62 */        NdrFcShort( 0x0 ),      /* 0 */
    179170
    180171        /* Parameter pfTime */
    181172
    182 /* 60 */        NdrFcShort( 0x2150 ),   /* Flags:  out, base type, simple ref, srv alloc size=8 */
    183 /* 62 */        NdrFcShort( 0x4 ),      /* x86 Stack size/offset = 4 */
    184 /* 64 */        0xc,            /* FC_DOUBLE */
     173/* 64 */        NdrFcShort( 0x2150 ),   /* Flags:  out, base type, simple ref, srv alloc size=8 */
     174/* 66 */        NdrFcShort( 0x8 ),      /* X64 Stack size/offset = 8 */
     175/* 68 */        0xc,            /* FC_DOUBLE */
    185176                        0x0,            /* 0 */
    186177
    187178        /* Return value */
    188179
    189 /* 66 */        NdrFcShort( 0x70 ),     /* Flags:  out, return, base type, */
    190 /* 68 */        NdrFcShort( 0x8 ),      /* x86 Stack size/offset = 8 */
    191 /* 70 */        0x8,            /* FC_LONG */
     180/* 70 */        NdrFcShort( 0x70 ),     /* Flags:  out, return, base type, */
     181/* 72 */        NdrFcShort( 0x10 ),     /* X64 Stack size/offset = 16 */
     182/* 74 */        0x8,            /* FC_LONG */
    192183                        0x0,            /* 0 */
    193184
    … …  
    197188        /* Procedure get_FriendlyName */
    198189
    199 /* 72 */        0x33,           /* FC_AUTO_HANDLE */
     190/* 76 */        0x33,           /* FC_AUTO_HANDLE */
    200191                        0x6c,           /* Old Flags:  object, Oi2 */
    201 /* 74 */        NdrFcLong( 0x0 ),       /* 0 */
    202 /* 78 */        NdrFcShort( 0x9 ),      /* 9 */
    203 /* 80 */        NdrFcShort( 0xc ),      /* x86 Stack size/offset = 12 */
    204 /* 82 */        NdrFcShort( 0x0 ),      /* 0 */
    205 /* 84 */        NdrFcShort( 0x8 ),      /* 8 */
    206 /* 86 */        0x45,           /* Oi2 Flags:  srv must size, has return, has ext, */
     192/* 78 */        NdrFcLong( 0x0 ),       /* 0 */
     193/* 82 */        NdrFcShort( 0x9 ),      /* 9 */
     194/* 84 */        NdrFcShort( 0x18 ),     /* X64 Stack size/offset = 24 */
     195/* 86 */        NdrFcShort( 0x0 ),      /* 0 */
     196/* 88 */        NdrFcShort( 0x8 ),      /* 8 */
     197/* 90 */        0x45,           /* Oi2 Flags:  srv must size, has return, has ext, */
    207198                        0x2,            /* 2 */
    208 /* 88 */        0x8,            /* 8 */
     199/* 92 */        0xa,            /* 10 */
    209200                        0x3,            /* Ext Flags:  new corr desc, clt corr check, */
    210 /* 90 */        NdrFcShort( 0x1 ),      /* 1 */
    211 /* 92 */        NdrFcShort( 0x0 ),      /* 0 */
    212 /* 94 */        NdrFcShort( 0x0 ),      /* 0 */
     201/* 94 */        NdrFcShort( 0x1 ),      /* 1 */
     202/* 96 */        NdrFcShort( 0x0 ),      /* 0 */
     203/* 98 */        NdrFcShort( 0x0 ),      /* 0 */
     204/* 100 */       NdrFcShort( 0x0 ),      /* 0 */
    213205
    214206        /* Parameter psText */
    … …  
    217209        /* Parameter psFriendlyName */
    218210
    219 /* 96 */        NdrFcShort( 0x2113 ),   /* Flags:  must size, must free, out, simple ref, srv alloc size=8 */
    220 /* 98 */        NdrFcShort( 0x4 ),      /* x86 Stack size/offset = 4 */
    221 /* 100 */       NdrFcShort( 0x20 ),     /* Type Offset=32 */
     211/* 102 */       NdrFcShort( 0x2113 ),   /* Flags:  must size, must free, out, simple ref, srv alloc size=8 */
     212/* 104 */       NdrFcShort( 0x8 ),      /* X64 Stack size/offset = 8 */
     213/* 106 */       NdrFcShort( 0x20 ),     /* Type Offset=32 */
    222214
    223215        /* Return value */
    … …  
    226218        /* Return value */
    227219
    228 /* 102 */       NdrFcShort( 0x70 ),     /* Flags:  out, return, base type, */
    229 /* 104 */       NdrFcShort( 0x8 ),      /* x86 Stack size/offset = 8 */
    230 /* 106 */       0x8,            /* FC_LONG */
     220/* 108 */       NdrFcShort( 0x70 ),     /* Flags:  out, return, base type, */
     221/* 110 */       NdrFcShort( 0x10 ),     /* X64 Stack size/offset = 16 */
     222/* 112 */       0x8,            /* FC_LONG */
    231223                        0x0,            /* 0 */
    232224
    233225        /* Procedure put_FriendlyName */
    234226
    235 /* 108 */       0x33,           /* FC_AUTO_HANDLE */
     227/* 114 */       0x33,           /* FC_AUTO_HANDLE */
    236228                        0x6c,           /* Old Flags:  object, Oi2 */
    237 /* 110 */       NdrFcLong( 0x0 ),       /* 0 */
    238 /* 114 */       NdrFcShort( 0xa ),      /* 10 */
    239 /* 116 */       NdrFcShort( 0xc ),      /* x86 Stack size/offset = 12 */
    240 /* 118 */       NdrFcShort( 0x0 ),      /* 0 */
    241 /* 120 */       NdrFcShort( 0x8 ),      /* 8 */
    242 /* 122 */       0x46,           /* Oi2 Flags:  clt must size, has return, has ext, */
     229/* 116 */       NdrFcLong( 0x0 ),       /* 0 */
     230/* 120 */       NdrFcShort( 0xa ),      /* 10 */
     231/* 122 */       NdrFcShort( 0x18 ),     /* X64 Stack size/offset = 24 */
     232/* 124 */       NdrFcShort( 0x0 ),      /* 0 */
     233/* 126 */       NdrFcShort( 0x8 ),      /* 8 */
     234/* 128 */       0x46,           /* Oi2 Flags:  clt must size, has return, has ext, */
    243235                        0x2,            /* 2 */
    244 /* 124 */       0x8,            /* 8 */
     236/* 130 */       0xa,            /* 10 */
    245237                        0x5,            /* Ext Flags:  new corr desc, srv corr check, */
    246 /* 126 */       NdrFcShort( 0x0 ),      /* 0 */
    247 /* 128 */       NdrFcShort( 0x1 ),      /* 1 */
    248 /* 130 */       NdrFcShort( 0x0 ),      /* 0 */
     238/* 132 */       NdrFcShort( 0x0 ),      /* 0 */
     239/* 134 */       NdrFcShort( 0x1 ),      /* 1 */
     240/* 136 */       NdrFcShort( 0x0 ),      /* 0 */
     241/* 138 */       NdrFcShort( 0x0 ),      /* 0 */
    249242
    250243        /* Parameter sFriendlyName */
    251244
    252 /* 132 */       NdrFcShort( 0x8b ),     /* Flags:  must size, must free, in, by val, */
    253 /* 134 */       NdrFcShort( 0x4 ),      /* x86 Stack size/offset = 4 */
    254 /* 136 */       NdrFcShort( 0x32 ),     /* Type Offset=50 */
     245/* 140 */       NdrFcShort( 0x8b ),     /* Flags:  must size, must free, in, by val, */
     246/* 142 */       NdrFcShort( 0x8 ),      /* X64 Stack size/offset = 8 */
     247/* 144 */       NdrFcShort( 0x32 ),     /* Type Offset=50 */
    255248
    256249        /* Return value */
    257250
    258 /* 138 */       NdrFcShort( 0x70 ),     /* Flags:  out, return, base type, */
    259 /* 140 */       NdrFcShort( 0x8 ),      /* x86 Stack size/offset = 8 */
    260 /* 142 */       0x8,            /* FC_LONG */
     251/* 146 */       NdrFcShort( 0x70 ),     /* Flags:  out, return, base type, */
     252/* 148 */       NdrFcShort( 0x10 ),     /* X64 Stack size/offset = 16 */
     253/* 150 */       0x8,            /* FC_LONG */
    261254                        0x0,            /* 0 */
    262255
    … …  
    266259        /* Procedure DoPropertyFrameModal */
    267260
    268 /* 144 */       0x33,           /* FC_AUTO_HANDLE */
     261/* 152 */       0x33,           /* FC_AUTO_HANDLE */
    269262                        0x6c,           /* Old Flags:  object, Oi2 */
    270 /* 146 */       NdrFcLong( 0x0 ),       /* 0 */
    271 /* 150 */       NdrFcShort( 0xb ),      /* 11 */
    272 /* 152 */       NdrFcShort( 0xc ),      /* x86 Stack size/offset = 12 */
    273 /* 154 */       NdrFcShort( 0x8 ),      /* 8 */
    274 /* 156 */       NdrFcShort( 0x8 ),      /* 8 */
    275 /* 158 */       0x44,           /* Oi2 Flags:  has return, has ext, */
     263/* 154 */       NdrFcLong( 0x0 ),       /* 0 */
     264/* 158 */       NdrFcShort( 0xb ),      /* 11 */
     265/* 160 */       NdrFcShort( 0x18 ),     /* X64 Stack size/offset = 24 */
     266/* 162 */       NdrFcShort( 0x8 ),      /* 8 */
     267/* 164 */       NdrFcShort( 0x8 ),      /* 8 */
     268/* 166 */       0x44,           /* Oi2 Flags:  has return, has ext, */
    276269                        0x2,            /* 2 */
    277 /* 160 */       0x8,            /* 8 */
     270/* 168 */       0xa,            /* 10 */
    278271                        0x1,            /* Ext Flags:  new corr desc, */
    279 /* 162 */       NdrFcShort( 0x0 ),      /* 0 */
    280 /* 164 */       NdrFcShort( 0x0 ),      /* 0 */
    281 /* 166 */       NdrFcShort( 0x0 ),      /* 0 */
     272/* 170 */       NdrFcShort( 0x0 ),      /* 0 */
     273/* 172 */       NdrFcShort( 0x0 ),      /* 0 */
     274/* 174 */       NdrFcShort( 0x0 ),      /* 0 */
     275/* 176 */       NdrFcShort( 0x0 ),      /* 0 */
    282276
    283277        /* Parameter nParentWindowHandle */
    … …  
    286280        /* Parameter nParentWindowHandle */
    287281
    288 /* 168 */       NdrFcShort( 0x48 ),     /* Flags:  in, base type, */
    289 /* 170 */       NdrFcShort( 0x4 ),      /* x86 Stack size/offset = 4 */
    290 /* 172 */       0x8,            /* FC_LONG */
     282/* 178 */       NdrFcShort( 0x48 ),     /* Flags:  in, base type, */
     283/* 180 */       NdrFcShort( 0x8 ),      /* X64 Stack size/offset = 8 */
     284/* 182 */       0x8,            /* FC_LONG */
    291285                        0x0,            /* 0 */
    292286
    … …  
    296290        /* Return value */
    297291
    298 /* 174 */       NdrFcShort( 0x70 ),     /* Flags:  out, return, base type, */
    299 /* 176 */       NdrFcShort( 0x8 ),      /* x86 Stack size/offset = 8 */
    300 /* 178 */       0x8,            /* FC_LONG */
     292/* 184 */       NdrFcShort( 0x70 ),     /* Flags:  out, return, base type, */
     293/* 186 */       NdrFcShort( 0x10 ),     /* X64 Stack size/offset = 16 */
     294/* 188 */       0x8,            /* FC_LONG */
    301295                        0x0,            /* 0 */
    302296
    303297        /* Procedure DoFilterGraphListModal */
    304298
    305 /* 180 */       0x33,           /* FC_AUTO_HANDLE */
     299/* 190 */       0x33,           /* FC_AUTO_HANDLE */
    306300                        0x6c,           /* Old Flags:  object, Oi2 */
    307 /* 182 */       NdrFcLong( 0x0 ),       /* 0 */
    308 /* 186 */       NdrFcShort( 0xc ),      /* 12 */
    309 /* 188 */       NdrFcShort( 0xc ),      /* x86 Stack size/offset = 12 */
    310 /* 190 */       NdrFcShort( 0x8 ),      /* 8 */
    311 /* 192 */       NdrFcShort( 0x8 ),      /* 8 */
    312 /* 194 */       0x44,           /* Oi2 Flags:  has return, has ext, */
     301/* 192 */       NdrFcLong( 0x0 ),       /* 0 */
     302/* 196 */       NdrFcShort( 0xc ),      /* 12 */
     303/* 198 */       NdrFcShort( 0x18 ),     /* X64 Stack size/offset = 24 */
     304/* 200 */       NdrFcShort( 0x8 ),      /* 8 */
     305/* 202 */       NdrFcShort( 0x8 ),      /* 8 */
     306/* 204 */       0x44,           /* Oi2 Flags:  has return, has ext, */
    313307                        0x2,            /* 2 */
    314 /* 196 */       0x8,            /* 8 */
     308/* 206 */       0xa,            /* 10 */
    315309                        0x1,            /* Ext Flags:  new corr desc, */
    316 /* 198 */       NdrFcShort( 0x0 ),      /* 0 */
    317 /* 200 */       NdrFcShort( 0x0 ),      /* 0 */
    318 /* 202 */       NdrFcShort( 0x0 ),      /* 0 */
     310/* 208 */       NdrFcShort( 0x0 ),      /* 0 */
     311/* 210 */       NdrFcShort( 0x0 ),      /* 0 */
     312/* 212 */       NdrFcShort( 0x0 ),      /* 0 */
     313/* 214 */       NdrFcShort( 0x0 ),      /* 0 */
    319314
    320315        /* Parameter nParentWindowHandle */
    321316
    322 /* 204 */       NdrFcShort( 0x48 ),     /* Flags:  in, base type, */
    323 /* 206 */       NdrFcShort( 0x4 ),      /* x86 Stack size/offset = 4 */
    324 /* 208 */       0x8,            /* FC_LONG */
     317/* 216 */       NdrFcShort( 0x48 ),     /* Flags:  in, base type, */
     318/* 218 */       NdrFcShort( 0x8 ),      /* X64 Stack size/offset = 8 */
     319/* 220 */       0x8,            /* FC_LONG */
    325320                        0x0,            /* 0 */
    326321
    327322        /* Return value */
    328323
    329 /* 210 */       NdrFcShort( 0x70 ),     /* Flags:  out, return, base type, */
    330 /* 212 */       NdrFcShort( 0x8 ),      /* x86 Stack size/offset = 8 */
    331 /* 214 */       0x8,            /* FC_LONG */
     324/* 222 */       NdrFcShort( 0x70 ),     /* Flags:  out, return, base type, */
     325/* 224 */       NdrFcShort( 0x10 ),     /* X64 Stack size/offset = 16 */
     326/* 226 */       0x8,            /* FC_LONG */
    332327                        0x0,            /* 0 */
    333328
    334329        /* Procedure OpenGraphStudioNext */
    335330
    336 /* 216 */       0x33,           /* FC_AUTO_HANDLE */
     331/* 228 */       0x33,           /* FC_AUTO_HANDLE */
    337332                        0x6c,           /* Old Flags:  object, Oi2 */
    338 /* 218 */       NdrFcLong( 0x0 ),       /* 0 */
    339 /* 222 */       NdrFcShort( 0xd ),      /* 13 */
    340 /* 224 */       NdrFcShort( 0x10 ),     /* x86 Stack size/offset = 16 */
    341 /* 226 */       NdrFcShort( 0x8 ),      /* 8 */
    342 /* 228 */       NdrFcShort( 0x22 ),     /* 34 */
    343 /* 230 */       0x44,           /* Oi2 Flags:  has return, has ext, */
    344                         0x3,            /* 3 */
    345 /* 232 */       0x8,            /* 8 */
     333/* 230 */       NdrFcLong( 0x0 ),       /* 0 */
     334/* 234 */       NdrFcShort( 0xd ),      /* 13 */
     335/* 236 */       NdrFcShort( 0x20 ),     /* X64 Stack size/offset = 32 */
     336/* 238 */       NdrFcShort( 0x8 ),      /* 8 */
     337/* 240 */       NdrFcShort( 0x22 ),     /* 34 */
     338/* 242 */       0x44,           /* Oi2 Flags:  has return, has ext, */
     339                        0x3,            /* 3 */
     340/* 244 */       0xa,            /* 10 */
    346341                        0x1,            /* Ext Flags:  new corr desc, */
    347 /* 234 */       NdrFcShort( 0x0 ),      /* 0 */
    348 /* 236 */       NdrFcShort( 0x0 ),      /* 0 */
    349 /* 238 */       NdrFcShort( 0x0 ),      /* 0 */
     342/* 246 */       NdrFcShort( 0x0 ),      /* 0 */
     343/* 248 */       NdrFcShort( 0x0 ),      /* 0 */
     344/* 250 */       NdrFcShort( 0x0 ),      /* 0 */
     345/* 252 */       NdrFcShort( 0x0 ),      /* 0 */
    350346
    351347        /* Parameter nParentWindowHandle */
    352348
    353 /* 240 */       NdrFcShort( 0x48 ),     /* Flags:  in, base type, */
    354 /* 242 */       NdrFcShort( 0x4 ),      /* x86 Stack size/offset = 4 */
    355 /* 244 */       0x8,            /* FC_LONG */
     349/* 254 */       NdrFcShort( 0x48 ),     /* Flags:  in, base type, */
     350/* 256 */       NdrFcShort( 0x8 ),      /* X64 Stack size/offset = 8 */
     351/* 258 */       0x8,            /* FC_LONG */
    356352                        0x0,            /* 0 */
    357353
    358354        /* Parameter pbResult */
    359355
    360 /* 246 */       NdrFcShort( 0x2150 ),   /* Flags:  out, base type, simple ref, srv alloc size=8 */
    361 /* 248 */       NdrFcShort( 0x8 ),      /* x86 Stack size/offset = 8 */
    362 /* 250 */       0x6,            /* FC_SHORT */
     356/* 260 */       NdrFcShort( 0x2150 ),   /* Flags:  out, base type, simple ref, srv alloc size=8 */
     357/* 262 */       NdrFcShort( 0x10 ),     /* X64 Stack size/offset = 16 */
     358/* 264 */       0x6,            /* FC_SHORT */
    363359                        0x0,            /* 0 */
    364360
    365361        /* Return value */
    366362
    367 /* 252 */       NdrFcShort( 0x70 ),     /* Flags:  out, return, base type, */
    368 /* 254 */       NdrFcShort( 0xc ),      /* x86 Stack size/offset = 12 */
    369 /* 256 */       0x8,            /* FC_LONG */
     363/* 266 */       NdrFcShort( 0x70 ),     /* Flags:  out, return, base type, */
     364/* 268 */       NdrFcShort( 0x18 ),     /* X64 Stack size/offset = 24 */
     365/* 270 */       0x8,            /* FC_LONG */
    370366                        0x0,            /* 0 */
    371367
    372368        /* Procedure OpenGraphEdit */
    373369
    374 /* 258 */       0x33,           /* FC_AUTO_HANDLE */
     370/* 272 */       0x33,           /* FC_AUTO_HANDLE */
    375371                        0x6c,           /* Old Flags:  object, Oi2 */
    376 /* 260 */       NdrFcLong( 0x0 ),       /* 0 */
    377 /* 264 */       NdrFcShort( 0xe ),      /* 14 */
    378 /* 266 */       NdrFcShort( 0x10 ),     /* x86 Stack size/offset = 16 */
    379 /* 268 */       NdrFcShort( 0x8 ),      /* 8 */
    380 /* 270 */       NdrFcShort( 0x22 ),     /* 34 */
    381 /* 272 */       0x44,           /* Oi2 Flags:  has return, has ext, */
    382                         0x3,            /* 3 */
    383 /* 274 */       0x8,            /* 8 */
     372/* 274 */       NdrFcLong( 0x0 ),       /* 0 */
     373/* 278 */       NdrFcShort( 0xe ),      /* 14 */
     374/* 280 */       NdrFcShort( 0x20 ),     /* X64 Stack size/offset = 32 */
     375/* 282 */       NdrFcShort( 0x8 ),      /* 8 */
     376/* 284 */       NdrFcShort( 0x22 ),     /* 34 */
     377/* 286 */       0x44,           /* Oi2 Flags:  has return, has ext, */
     378                        0x3,            /* 3 */
     379/* 288 */       0xa,            /* 10 */
    384380                        0x1,            /* Ext Flags:  new corr desc, */
    385 /* 276 */       NdrFcShort( 0x0 ),      /* 0 */
    386 /* 278 */       NdrFcShort( 0x0 ),      /* 0 */
    387 /* 280 */       NdrFcShort( 0x0 ),      /* 0 */
     381/* 290 */       NdrFcShort( 0x0 ),      /* 0 */
     382/* 292 */       NdrFcShort( 0x0 ),      /* 0 */
     383/* 294 */       NdrFcShort( 0x0 ),      /* 0 */
     384/* 296 */       NdrFcShort( 0x0 ),      /* 0 */
    388385
    389386        /* Parameter nParentWindowHandle */
    390387
    391 /* 282 */       NdrFcShort( 0x48 ),     /* Flags:  in, base type, */
    392 /* 284 */       NdrFcShort( 0x4 ),      /* x86 Stack size/offset = 4 */
    393 /* 286 */       0x8,            /* FC_LONG */
     388/* 298 */       NdrFcShort( 0x48 ),     /* Flags:  in, base type, */
     389/* 300 */       NdrFcShort( 0x8 ),      /* X64 Stack size/offset = 8 */
     390/* 302 */       0x8,            /* FC_LONG */
    394391                        0x0,            /* 0 */
    395392
    396393        /* Parameter pbResult */
    397394
    398 /* 288 */       NdrFcShort( 0x2150 ),   /* Flags:  out, base type, simple ref, srv alloc size=8 */
    399 /* 290 */       NdrFcShort( 0x8 ),      /* x86 Stack size/offset = 8 */
    400 /* 292 */       0x6,            /* FC_SHORT */
     395/* 304 */       NdrFcShort( 0x2150 ),   /* Flags:  out, base type, simple ref, srv alloc size=8 */
     396/* 306 */       NdrFcShort( 0x10 ),     /* X64 Stack size/offset = 16 */
     397/* 308 */       0x6,            /* FC_SHORT */
    401398                        0x0,            /* 0 */
    402399
    403400        /* Return value */
    404401
    405 /* 294 */       NdrFcShort( 0x70 ),     /* Flags:  out, return, base type, */
    406 /* 296 */       NdrFcShort( 0xc ),      /* x86 Stack size/offset = 12 */
    407 /* 298 */       0x8,            /* FC_LONG */
     402/* 310 */       NdrFcShort( 0x70 ),     /* Flags:  out, return, base type, */
     403/* 312 */       NdrFcShort( 0x18 ),     /* X64 Stack size/offset = 24 */
     404/* 314 */       0x8,            /* FC_LONG */
    408405                        0x0,            /* 0 */
    409406
    410407        /* Procedure ReadRunPropertyBag */
    411408
    412 /* 300 */       0x33,           /* FC_AUTO_HANDLE */
     409/* 316 */       0x33,           /* FC_AUTO_HANDLE */
    413410                        0x6c,           /* Old Flags:  object, Oi2 */
    414 /* 302 */       NdrFcLong( 0x0 ),       /* 0 */
    415 /* 306 */       NdrFcShort( 0xf ),      /* 15 */
    416 /* 308 */       NdrFcShort( 0x14 ),     /* x86 Stack size/offset = 20 */
    417 /* 310 */       NdrFcShort( 0x6 ),      /* 6 */
    418 /* 312 */       NdrFcShort( 0x8 ),      /* 8 */
    419 /* 314 */       0x47,           /* Oi2 Flags:  srv must size, clt must size, has return, has ext, */
     411/* 318 */       NdrFcLong( 0x0 ),       /* 0 */
     412/* 322 */       NdrFcShort( 0xf ),      /* 15 */
     413/* 324 */       NdrFcShort( 0x28 ),     /* X64 Stack size/offset = 40 */
     414/* 326 */       NdrFcShort( 0x6 ),      /* 6 */
     415/* 328 */       NdrFcShort( 0x8 ),      /* 8 */
     416/* 330 */       0x47,           /* Oi2 Flags:  srv must size, clt must size, has return, has ext, */
    420417                        0x4,            /* 4 */
    421 /* 316 */       0x8,            /* 8 */
     418/* 332 */       0xa,            /* 10 */
    422419                        0x3,            /* Ext Flags:  new corr desc, clt corr check, */
    423 /* 318 */       NdrFcShort( 0x1 ),      /* 1 */
    424 /* 320 */       NdrFcShort( 0x0 ),      /* 0 */
    425 /* 322 */       NdrFcShort( 0x0 ),      /* 0 */
     420/* 334 */       NdrFcShort( 0x1 ),      /* 1 */
     421/* 336 */       NdrFcShort( 0x0 ),      /* 0 */
     422/* 338 */       NdrFcShort( 0x0 ),      /* 0 */
     423/* 340 */       NdrFcShort( 0x0 ),      /* 0 */
    426424
    427425        /* Parameter pBaseFilterUnknown */
    428426
    429 /* 324 */       NdrFcShort( 0xb ),      /* Flags:  must size, must free, in, */
    430 /* 326 */       NdrFcShort( 0x4 ),      /* x86 Stack size/offset = 4 */
    431 /* 328 */       NdrFcShort( 0x40 ),     /* Type Offset=64 */
     427/* 342 */       NdrFcShort( 0xb ),      /* Flags:  must size, must free, in, */
     428/* 344 */       NdrFcShort( 0x8 ),      /* X64 Stack size/offset = 8 */
     429/* 346 */       NdrFcShort( 0x40 ),     /* Type Offset=64 */
    432430
    433431        /* Parameter bAllowExtension */
    434432
    435 /* 330 */       NdrFcShort( 0x48 ),     /* Flags:  in, base type, */
    436 /* 332 */       NdrFcShort( 0x8 ),      /* x86 Stack size/offset = 8 */
    437 /* 334 */       0x6,            /* FC_SHORT */
     433/* 348 */       NdrFcShort( 0x48 ),     /* Flags:  in, base type, */
     434/* 350 */       NdrFcShort( 0x10 ),     /* X64 Stack size/offset = 16 */
     435/* 352 */       0x6,            /* FC_SHORT */
    438436                        0x0,            /* 0 */
    439437
    440438        /* Parameter pvValue */
    441439
    442 /* 336 */       NdrFcShort( 0x4113 ),   /* Flags:  must size, must free, out, simple ref, srv alloc size=16 */
    443 /* 338 */       NdrFcShort( 0xc ),      /* x86 Stack size/offset = 12 */
    444 /* 340 */       NdrFcShort( 0x428 ),    /* Type Offset=1064 */
     440/* 354 */       NdrFcShort( 0x6113 ),   /* Flags:  must size, must free, out, simple ref, srv alloc size=24 */
     441/* 356 */       NdrFcShort( 0x18 ),     /* X64 Stack size/offset = 24 */
     442/* 358 */       NdrFcShort( 0x3f6 ),    /* Type Offset=1014 */
    445443
    446444        /* Return value */
    447445
    448 /* 342 */       NdrFcShort( 0x70 ),     /* Flags:  out, return, base type, */
    449 /* 344 */       NdrFcShort( 0x10 ),     /* x86 Stack size/offset = 16 */
    450 /* 346 */       0x8,            /* FC_LONG */
     446/* 360 */       NdrFcShort( 0x70 ),     /* Flags:  out, return, base type, */
     447/* 362 */       NdrFcShort( 0x20 ),     /* X64 Stack size/offset = 32 */
     448/* 364 */       0x8,            /* FC_LONG */
    451449                        0x0,            /* 0 */
    452450
    453451        /* Procedure get_FilterGraph */
    454452
    455 /* 348 */       0x33,           /* FC_AUTO_HANDLE */
     453/* 366 */       0x33,           /* FC_AUTO_HANDLE */
    456454                        0x6c,           /* Old Flags:  object, Oi2 */
    457 /* 350 */       NdrFcLong( 0x0 ),       /* 0 */
    458 /* 354 */       NdrFcShort( 0x7 ),      /* 7 */
    459 /* 356 */       NdrFcShort( 0xc ),      /* x86 Stack size/offset = 12 */
    460 /* 358 */       NdrFcShort( 0x0 ),      /* 0 */
    461 /* 360 */       NdrFcShort( 0x8 ),      /* 8 */
    462 /* 362 */       0x45,           /* Oi2 Flags:  srv must size, has return, has ext, */
     455/* 368 */       NdrFcLong( 0x0 ),       /* 0 */
     456/* 372 */       NdrFcShort( 0x7 ),      /* 7 */
     457/* 374 */       NdrFcShort( 0x18 ),     /* X64 Stack size/offset = 24 */
     458/* 376 */       NdrFcShort( 0x0 ),      /* 0 */
     459/* 378 */       NdrFcShort( 0x8 ),      /* 8 */
     460/* 380 */       0x45,           /* Oi2 Flags:  srv must size, has return, has ext, */
    463461                        0x2,            /* 2 */
    464 /* 364 */       0x8,            /* 8 */
     462/* 382 */       0xa,            /* 10 */
    465463                        0x1,            /* Ext Flags:  new corr desc, */
    466 /* 366 */       NdrFcShort( 0x0 ),      /* 0 */
    467 /* 368 */       NdrFcShort( 0x0 ),      /* 0 */
    468 /* 370 */       NdrFcShort( 0x0 ),      /* 0 */
     464/* 384 */       NdrFcShort( 0x0 ),      /* 0 */
     465/* 386 */       NdrFcShort( 0x0 ),      /* 0 */
     466/* 388 */       NdrFcShort( 0x0 ),      /* 0 */
     467/* 390 */       NdrFcShort( 0x0 ),      /* 0 */
    469468
    470469        /* Parameter ppFilterGraphUnknown */
    471470
    472 /* 372 */       NdrFcShort( 0x13 ),     /* Flags:  must size, must free, out, */
    473 /* 374 */       NdrFcShort( 0x4 ),      /* x86 Stack size/offset = 4 */
    474 /* 376 */       NdrFcShort( 0x432 ),    /* Type Offset=1074 */
     471/* 392 */       NdrFcShort( 0x13 ),     /* Flags:  must size, must free, out, */
     472/* 394 */       NdrFcShort( 0x8 ),      /* X64 Stack size/offset = 8 */
     473/* 396 */       NdrFcShort( 0x400 ),    /* Type Offset=1024 */
    475474
    476475        /* Return value */
    477476
    478 /* 378 */       NdrFcShort( 0x70 ),     /* Flags:  out, return, base type, */
    479 /* 380 */       NdrFcShort( 0x8 ),      /* x86 Stack size/offset = 8 */
    480 /* 382 */       0x8,            /* FC_LONG */
     477/* 398 */       NdrFcShort( 0x70 ),     /* Flags:  out, return, base type, */
     478/* 400 */       NdrFcShort( 0x10 ),     /* X64 Stack size/offset = 16 */
     479/* 402 */       0x8,            /* FC_LONG */
    481480                        0x0,            /* 0 */
    482481
    483482        /* Procedure put_FilterGraph */
    484483
    485 /* 384 */       0x33,           /* FC_AUTO_HANDLE */
     484/* 404 */       0x33,           /* FC_AUTO_HANDLE */
    486485                        0x6c,           /* Old Flags:  object, Oi2 */
    487 /* 386 */       NdrFcLong( 0x0 ),       /* 0 */
    488 /* 390 */       NdrFcShort( 0x8 ),      /* 8 */
    489 /* 392 */       NdrFcShort( 0xc ),      /* x86 Stack size/offset = 12 */
    490 /* 394 */       NdrFcShort( 0x0 ),      /* 0 */
    491 /* 396 */       NdrFcShort( 0x8 ),      /* 8 */
    492 /* 398 */       0x46,           /* Oi2 Flags:  clt must size, has return, has ext, */
     486/* 406 */       NdrFcLong( 0x0 ),       /* 0 */
     487/* 410 */       NdrFcShort( 0x8 ),      /* 8 */
     488/* 412 */       NdrFcShort( 0x18 ),     /* X64 Stack size/offset = 24 */
     489/* 414 */       NdrFcShort( 0x0 ),      /* 0 */
     490/* 416 */       NdrFcShort( 0x8 ),      /* 8 */
     491/* 418 */       0x46,           /* Oi2 Flags:  clt must size, has return, has ext, */
    493492                        0x2,            /* 2 */
    494 /* 400 */       0x8,            /* 8 */
     493/* 420 */       0xa,            /* 10 */
    495494                        0x1,            /* Ext Flags:  new corr desc, */
    496 /* 402 */       NdrFcShort( 0x0 ),      /* 0 */
    497 /* 404 */       NdrFcShort( 0x0 ),      /* 0 */
    498 /* 406 */       NdrFcShort( 0x0 ),      /* 0 */
     495/* 422 */       NdrFcShort( 0x0 ),      /* 0 */
     496/* 424 */       NdrFcShort( 0x0 ),      /* 0 */
     497/* 426 */       NdrFcShort( 0x0 ),      /* 0 */
     498/* 428 */       NdrFcShort( 0x0 ),      /* 0 */
    499499
    500500        /* Parameter pFilterGraphUnknown */
    501501
    502 /* 408 */       NdrFcShort( 0xb ),      /* Flags:  must size, must free, in, */
    503 /* 410 */       NdrFcShort( 0x4 ),      /* x86 Stack size/offset = 4 */
    504 /* 412 */       NdrFcShort( 0x40 ),     /* Type Offset=64 */
     502/* 430 */       NdrFcShort( 0xb ),      /* Flags:  must size, must free, in, */
     503/* 432 */       NdrFcShort( 0x8 ),      /* X64 Stack size/offset = 8 */
     504/* 434 */       NdrFcShort( 0x40 ),     /* Type Offset=64 */
    505505
    506506        /* Return value */
    507507
    508 /* 414 */       NdrFcShort( 0x70 ),     /* Flags:  out, return, base type, */
    509 /* 416 */       NdrFcShort( 0x8 ),      /* x86 Stack size/offset = 8 */
    510 /* 418 */       0x8,            /* FC_LONG */
     508/* 436 */       NdrFcShort( 0x70 ),     /* Flags:  out, return, base type, */
     509/* 438 */       NdrFcShort( 0x10 ),     /* X64 Stack size/offset = 16 */
     510/* 440 */       0x8,            /* FC_LONG */
    511511                        0x0,            /* 0 */
    512512
    513513        /* Procedure DoPropertyFrameModal */
    514514
    515 /* 420 */       0x33,           /* FC_AUTO_HANDLE */
     515/* 442 */       0x33,           /* FC_AUTO_HANDLE */
    516516                        0x6c,           /* Old Flags:  object, Oi2 */
    517 /* 422 */       NdrFcLong( 0x0 ),       /* 0 */
    518 /* 426 */       NdrFcShort( 0xa ),      /* 10 */
    519 /* 428 */       NdrFcShort( 0xc ),      /* x86 Stack size/offset = 12 */
    520 /* 430 */       NdrFcShort( 0x8 ),      /* 8 */
    521 /* 432 */       NdrFcShort( 0x8 ),      /* 8 */
    522 /* 434 */       0x44,           /* Oi2 Flags:  has return, has ext, */
     517/* 444 */       NdrFcLong( 0x0 ),       /* 0 */
     518/* 448 */       NdrFcShort( 0xa ),      /* 10 */
     519/* 450 */       NdrFcShort( 0x18 ),     /* X64 Stack size/offset = 24 */
     520/* 452 */       NdrFcShort( 0x8 ),      /* 8 */
     521/* 454 */       NdrFcShort( 0x8 ),      /* 8 */
     522/* 456 */       0x44,           /* Oi2 Flags:  has return, has ext, */
    523523                        0x2,            /* 2 */
    524 /* 436 */       0x8,            /* 8 */
     524/* 458 */       0xa,            /* 10 */
    525525                        0x1,            /* Ext Flags:  new corr desc, */
    526 /* 438 */       NdrFcShort( 0x0 ),      /* 0 */
    527 /* 440 */       NdrFcShort( 0x0 ),      /* 0 */
    528 /* 442 */       NdrFcShort( 0x0 ),      /* 0 */
     526/* 460 */       NdrFcShort( 0x0 ),      /* 0 */
     527/* 462 */       NdrFcShort( 0x0 ),      /* 0 */
     528/* 464 */       NdrFcShort( 0x0 ),      /* 0 */
     529/* 466 */       NdrFcShort( 0x0 ),      /* 0 */
    529530
    530531        /* Parameter nParentWindowHandle */
    531532
    532 /* 444 */       NdrFcShort( 0x48 ),     /* Flags:  in, base type, */
    533 /* 446 */       NdrFcShort( 0x4 ),      /* x86 Stack size/offset = 4 */
    534 /* 448 */       0x8,            /* FC_LONG */
     533/* 468 */       NdrFcShort( 0x48 ),     /* Flags:  in, base type, */
     534/* 470 */       NdrFcShort( 0x8 ),      /* X64 Stack size/offset = 8 */
     535/* 472 */       0x8,            /* FC_LONG */
    535536                        0x0,            /* 0 */
    536537
    537538        /* Return value */
    538539
    539 /* 450 */       NdrFcShort( 0x70 ),     /* Flags:  out, return, base type, */
    540 /* 452 */       NdrFcShort( 0x8 ),      /* x86 Stack size/offset = 8 */
    541 /* 454 */       0x8,            /* FC_LONG */
     540/* 474 */       NdrFcShort( 0x70 ),     /* Flags:  out, return, base type, */
     541/* 476 */       NdrFcShort( 0x10 ),     /* X64 Stack size/offset = 16 */
     542/* 478 */       0x8,            /* FC_LONG */
    542543                        0x0,            /* 0 */
    543544
    544545        /* Procedure OpenGraphStudioNext */
    545546
    546 /* 456 */       0x33,           /* FC_AUTO_HANDLE */
     547/* 480 */       0x33,           /* FC_AUTO_HANDLE */
    547548                        0x6c,           /* Old Flags:  object, Oi2 */
    548 /* 458 */       NdrFcLong( 0x0 ),       /* 0 */
    549 /* 462 */       NdrFcShort( 0xc ),      /* 12 */
    550 /* 464 */       NdrFcShort( 0x14 ),     /* x86 Stack size/offset = 20 */
    551 /* 466 */       NdrFcShort( 0x8 ),      /* 8 */
    552 /* 468 */       NdrFcShort( 0x22 ),     /* 34 */
    553 /* 470 */       0x46,           /* Oi2 Flags:  clt must size, has return, has ext, */
     549/* 482 */       NdrFcLong( 0x0 ),       /* 0 */
     550/* 486 */       NdrFcShort( 0xc ),      /* 12 */
     551/* 488 */       NdrFcShort( 0x28 ),     /* X64 Stack size/offset = 40 */
     552/* 490 */       NdrFcShort( 0x8 ),      /* 8 */
     553/* 492 */       NdrFcShort( 0x22 ),     /* 34 */
     554/* 494 */       0x46,           /* Oi2 Flags:  clt must size, has return, has ext, */
    554555                        0x4,            /* 4 */
    555 /* 472 */       0x8,            /* 8 */
     556/* 496 */       0xa,            /* 10 */
    556557                        0x5,            /* Ext Flags:  new corr desc, srv corr check, */
    557 /* 474 */       NdrFcShort( 0x0 ),      /* 0 */
    558 /* 476 */       NdrFcShort( 0x1 ),      /* 1 */
    559 /* 478 */       NdrFcShort( 0x0 ),      /* 0 */
     558/* 498 */       NdrFcShort( 0x0 ),      /* 0 */
     559/* 500 */       NdrFcShort( 0x1 ),      /* 1 */
     560/* 502 */       NdrFcShort( 0x0 ),      /* 0 */
     561/* 504 */       NdrFcShort( 0x0 ),      /* 0 */
    560562
    561563        /* Parameter nParentWindowHandle */
    562564
    563 /* 480 */       NdrFcShort( 0x48 ),     /* Flags:  in, base type, */
    564 /* 482 */       NdrFcShort( 0x4 ),      /* x86 Stack size/offset = 4 */
    565 /* 484 */       0x8,            /* FC_LONG */
     565/* 506 */       NdrFcShort( 0x48 ),     /* Flags:  in, base type, */
     566/* 508 */       NdrFcShort( 0x8 ),      /* X64 Stack size/offset = 8 */
     567/* 510 */       0x8,            /* FC_LONG */
    566568                        0x0,            /* 0 */
    567569
    568570        /* Parameter sMonikerDisplayName */
    569571
    570 /* 486 */       NdrFcShort( 0x8b ),     /* Flags:  must size, must free, in, by val, */
    571 /* 488 */       NdrFcShort( 0x8 ),      /* x86 Stack size/offset = 8 */
    572 /* 490 */       NdrFcShort( 0x32 ),     /* Type Offset=50 */
     572/* 512 */       NdrFcShort( 0x8b ),     /* Flags:  must size, must free, in, by val, */
     573/* 514 */       NdrFcShort( 0x10 ),     /* X64 Stack size/offset = 16 */
     574/* 516 */       NdrFcShort( 0x32 ),     /* Type Offset=50 */
    573575
    574576        /* Parameter pbResult */
    575577
    576 /* 492 */       NdrFcShort( 0x2150 ),   /* Flags:  out, base type, simple ref, srv alloc size=8 */
    577 /* 494 */       NdrFcShort( 0xc ),      /* x86 Stack size/offset = 12 */
    578 /* 496 */       0x6,            /* FC_SHORT */
     578/* 518 */       NdrFcShort( 0x2150 ),   /* Flags:  out, base type, simple ref, srv alloc size=8 */
     579/* 520 */       NdrFcShort( 0x18 ),     /* X64 Stack size/offset = 24 */
     580/* 522 */       0x6,            /* FC_SHORT */
    579581                        0x0,            /* 0 */
    580582
    581583        /* Return value */
    582584
    583 /* 498 */       NdrFcShort( 0x70 ),     /* Flags:  out, return, base type, */
    584 /* 500 */       NdrFcShort( 0x10 ),     /* x86 Stack size/offset = 16 */
    585 /* 502 */       0x8,            /* FC_LONG */
     585/* 524 */       NdrFcShort( 0x70 ),     /* Flags:  out, return, base type, */
     586/* 526 */       NdrFcShort( 0x20 ),     /* X64 Stack size/offset = 32 */
     587/* 528 */       0x8,            /* FC_LONG */
    586588                        0x0,            /* 0 */
    587589
    588590        /* Procedure OpenGraphEdit */
    589591
    590 /* 504 */       0x33,           /* FC_AUTO_HANDLE */
     592/* 530 */       0x33,           /* FC_AUTO_HANDLE */
    591593                        0x6c,           /* Old Flags:  object, Oi2 */
    592 /* 506 */       NdrFcLong( 0x0 ),       /* 0 */
    593 /* 510 */       NdrFcShort( 0xd ),      /* 13 */
    594 /* 512 */       NdrFcShort( 0x14 ),     /* x86 Stack size/offset = 20 */
    595 /* 514 */       NdrFcShort( 0x8 ),      /* 8 */
    596 /* 516 */       NdrFcShort( 0x22 ),     /* 34 */
    597 /* 518 */       0x46,           /* Oi2 Flags:  clt must size, has return, has ext, */
     594/* 532 */       NdrFcLong( 0x0 ),       /* 0 */
     595/* 536 */       NdrFcShort( 0xd ),      /* 13 */
     596/* 538 */       NdrFcShort( 0x28 ),     /* X64 Stack size/offset = 40 */
     597/* 540 */       NdrFcShort( 0x8 ),      /* 8 */
     598/* 542 */       NdrFcShort( 0x22 ),     /* 34 */
     599/* 544 */       0x46,           /* Oi2 Flags:  clt must size, has return, has ext, */
    598600                        0x4,            /* 4 */
    599 /* 520 */       0x8,            /* 8 */
     601/* 546 */       0xa,            /* 10 */
    600602                        0x5,            /* Ext Flags:  new corr desc, srv corr check, */
    601 /* 522 */       NdrFcShort( 0x0 ),      /* 0 */
    602 /* 524 */       NdrFcShort( 0x1 ),      /* 1 */
    603 /* 526 */       NdrFcShort( 0x0 ),      /* 0 */
     603/* 548 */       NdrFcShort( 0x0 ),      /* 0 */
     604/* 550 */       NdrFcShort( 0x1 ),      /* 1 */
     605/* 552 */       NdrFcShort( 0x0 ),      /* 0 */
     606/* 554 */       NdrFcShort( 0x0 ),      /* 0 */
    604607
    605608        /* Parameter nParentWindowHandle */
    606609
    607 /* 528 */       NdrFcShort( 0x48 ),     /* Flags:  in, base type, */
    608 /* 530 */       NdrFcShort( 0x4 ),      /* x86 Stack size/offset = 4 */
    609 /* 532 */       0x8,            /* FC_LONG */
     610/* 556 */       NdrFcShort( 0x48 ),     /* Flags:  in, base type, */
     611/* 558 */       NdrFcShort( 0x8 ),      /* X64 Stack size/offset = 8 */
     612/* 560 */       0x8,            /* FC_LONG */
    610613                        0x0,            /* 0 */
    611614
    612615        /* Parameter sMonikerDisplayName */
    613616
    614 /* 534 */       NdrFcShort( 0x8b ),     /* Flags:  must size, must free, in, by val, */
    615 /* 536 */       NdrFcShort( 0x8 ),      /* x86 Stack size/offset = 8 */
    616 /* 538 */       NdrFcShort( 0x32 ),     /* Type Offset=50 */
     617/* 562 */       NdrFcShort( 0x8b ),     /* Flags:  must size, must free, in, by val, */
     618/* 564 */       NdrFcShort( 0x10 ),     /* X64 Stack size/offset = 16 */
     619/* 566 */       NdrFcShort( 0x32 ),     /* Type Offset=50 */
    617620
    618621        /* Parameter pbResult */
    619622
    620 /* 540 */       NdrFcShort( 0x2150 ),   /* Flags:  out, base type, simple ref, srv alloc size=8 */
    621 /* 542 */       NdrFcShort( 0xc ),      /* x86 Stack size/offset = 12 */
    622 /* 544 */       0x6,            /* FC_SHORT */
     623/* 568 */       NdrFcShort( 0x2150 ),   /* Flags:  out, base type, simple ref, srv alloc size=8 */
     624/* 570 */       NdrFcShort( 0x18 ),     /* X64 Stack size/offset = 24 */
     625/* 572 */       0x6,            /* FC_SHORT */
    623626                        0x0,            /* 0 */
    624627
    625628        /* Return value */
    626629
    627 /* 546 */       NdrFcShort( 0x70 ),     /* Flags:  out, return, base type, */
    628 /* 548 */       NdrFcShort( 0x10 ),     /* x86 Stack size/offset = 16 */
    629 /* 550 */       0x8,            /* FC_LONG */
     630/* 574 */       NdrFcShort( 0x70 ),     /* Flags:  out, return, base type, */
     631/* 576 */       NdrFcShort( 0x20 ),     /* X64 Stack size/offset = 32 */
     632/* 578 */       0x8,            /* FC_LONG */
    630633                        0x0,            /* 0 */
    631634
    … …  
    667670                        0x83,           /* 131 */
    668671/* 34 */        NdrFcShort( 0x0 ),      /* 0 */
    669 /* 36 */        NdrFcShort( 0x4 ),      /* 4 */
     672/* 36 */        NdrFcShort( 0x8 ),      /* 8 */
    670673/* 38 */        NdrFcShort( 0x0 ),      /* 0 */
    671674/* 40 */        NdrFcShort( 0xffde ),   /* Offset= -34 (6) */
    … …  
    680683                        0x83,           /* 131 */
    681684/* 52 */        NdrFcShort( 0x0 ),      /* 0 */
    682 /* 54 */        NdrFcShort( 0x4 ),      /* 4 */
     685/* 54 */        NdrFcShort( 0x8 ),      /* 8 */
    683686/* 56 */        NdrFcShort( 0x0 ),      /* 0 */
    684687/* 58 */        NdrFcShort( 0xfff4 ),   /* Offset= -12 (46) */
    … …  
    703706/* 82 */       
    704707                        0x11, 0x4,      /* FC_RP [alloced_on_stack] */
    705 /* 84 */        NdrFcShort( 0x3d4 ),    /* Offset= 980 (1064) */
     708/* 84 */        NdrFcShort( 0x3a2 ),    /* Offset= 930 (1014) */
    706709/* 86 */       
    707710                        0x13, 0x0,      /* FC_OP */
    708 /* 88 */        NdrFcShort( 0x3bc ),    /* Offset= 956 (1044) */
     711/* 88 */        NdrFcShort( 0x38a ),    /* Offset= 906 (994) */
    709712/* 90 */       
    710713                        0x2b,           /* FC_NON_ENCAPSULATED_UNION */
    … …  
    746749/* 186 */       NdrFcShort( 0xe2 ),     /* Offset= 226 (412) */
    747750/* 188 */       NdrFcLong( 0x24 ),      /* 36 */
    748 /* 192 */       NdrFcShort( 0x30a ),    /* Offset= 778 (970) */
     751/* 192 */       NdrFcShort( 0x2d8 ),    /* Offset= 728 (920) */
    749752/* 194 */       NdrFcLong( 0x4024 ),    /* 16420 */
    750 /* 198 */       NdrFcShort( 0x304 ),    /* Offset= 772 (970) */
     753/* 198 */       NdrFcShort( 0x2d2 ),    /* Offset= 722 (920) */
    751754/* 200 */       NdrFcLong( 0x4011 ),    /* 16401 */
    752 /* 204 */       NdrFcShort( 0x302 ),    /* Offset= 770 (974) */
     755/* 204 */       NdrFcShort( 0x2d0 ),    /* Offset= 720 (924) */
    753756/* 206 */       NdrFcLong( 0x4002 ),    /* 16386 */
    754 /* 210 */       NdrFcShort( 0x300 ),    /* Offset= 768 (978) */
     757/* 210 */       NdrFcShort( 0x2ce ),    /* Offset= 718 (928) */
    755758/* 212 */       NdrFcLong( 0x4003 ),    /* 16387 */
    756 /* 216 */       NdrFcShort( 0x2fe ),    /* Offset= 766 (982) */
     759/* 216 */       NdrFcShort( 0x2cc ),    /* Offset= 716 (932) */
    757760/* 218 */       NdrFcLong( 0x4014 ),    /* 16404 */
    758 /* 222 */       NdrFcShort( 0x2fc ),    /* Offset= 764 (986) */
     761/* 222 */       NdrFcShort( 0x2ca ),    /* Offset= 714 (936) */
    759762/* 224 */       NdrFcLong( 0x4004 ),    /* 16388 */
    760 /* 228 */       NdrFcShort( 0x2fa ),    /* Offset= 762 (990) */
     763/* 228 */       NdrFcShort( 0x2c8 ),    /* Offset= 712 (940) */
    761764/* 230 */       NdrFcLong( 0x4005 ),    /* 16389 */
    762 /* 234 */       NdrFcShort( 0x2f8 ),    /* Offset= 760 (994) */
     765/* 234 */       NdrFcShort( 0x2c6 ),    /* Offset= 710 (944) */
    763766/* 236 */       NdrFcLong( 0x400b ),    /* 16395 */
    764 /* 240 */       NdrFcShort( 0x2e2 ),    /* Offset= 738 (978) */
     767/* 240 */       NdrFcShort( 0x2b0 ),    /* Offset= 688 (928) */
    765768/* 242 */       NdrFcLong( 0x400a ),    /* 16394 */
    766 /* 246 */       NdrFcShort( 0x2e0 ),    /* Offset= 736 (982) */
     769/* 246 */       NdrFcShort( 0x2ae ),    /* Offset= 686 (932) */
    767770/* 248 */       NdrFcLong( 0x4006 ),    /* 16390 */
    768 /* 252 */       NdrFcShort( 0x2ea ),    /* Offset= 746 (998) */
     771/* 252 */       NdrFcShort( 0x2b8 ),    /* Offset= 696 (948) */
    769772/* 254 */       NdrFcLong( 0x4007 ),    /* 16391 */
    770 /* 258 */       NdrFcShort( 0x2e0 ),    /* Offset= 736 (994) */
     773/* 258 */       NdrFcShort( 0x2ae ),    /* Offset= 686 (944) */
    771774/* 260 */       NdrFcLong( 0x4008 ),    /* 16392 */
    772 /* 264 */       NdrFcShort( 0x2e2 ),    /* Offset= 738 (1002) */
     775/* 264 */       NdrFcShort( 0x2b0 ),    /* Offset= 688 (952) */
    773776/* 266 */       NdrFcLong( 0x400d ),    /* 16397 */
    774 /* 270 */       NdrFcShort( 0x2e0 ),    /* Offset= 736 (1006) */
     777/* 270 */       NdrFcShort( 0x2ae ),    /* Offset= 686 (956) */
    775778/* 272 */       NdrFcLong( 0x4009 ),    /* 16393 */
    776 /* 276 */       NdrFcShort( 0x2de ),    /* Offset= 734 (1010) */
     779/* 276 */       NdrFcShort( 0x2ac ),    /* Offset= 684 (960) */
    777780/* 278 */       NdrFcLong( 0x6000 ),    /* 24576 */
    778 /* 282 */       NdrFcShort( 0x2dc ),    /* Offset= 732 (1014) */
     781/* 282 */       NdrFcShort( 0x2aa ),    /* Offset= 682 (964) */
    779782/* 284 */       NdrFcLong( 0x400c ),    /* 16396 */
    780 /* 288 */       NdrFcShort( 0x2da ),    /* Offset= 730 (1018) */
     783/* 288 */       NdrFcShort( 0x2a8 ),    /* Offset= 680 (968) */
    781784/* 290 */       NdrFcLong( 0x10 ),      /* 16 */
    782785/* 294 */       NdrFcShort( 0x8002 ),   /* Simple arm type: FC_CHAR */
    … …  
    792795/* 324 */       NdrFcShort( 0x8008 ),   /* Simple arm type: FC_LONG */
    793796/* 326 */       NdrFcLong( 0xe ),       /* 14 */
    794 /* 330 */       NdrFcShort( 0x2b8 ),    /* Offset= 696 (1026) */
     797/* 330 */       NdrFcShort( 0x286 ),    /* Offset= 646 (976) */
    795798/* 332 */       NdrFcLong( 0x400e ),    /* 16398 */
    796 /* 336 */       NdrFcShort( 0x2bc ),    /* Offset= 700 (1036) */
     799/* 336 */       NdrFcShort( 0x28a ),    /* Offset= 650 (986) */
    797800/* 338 */       NdrFcLong( 0x4010 ),    /* 16400 */
    798 /* 342 */       NdrFcShort( 0x2ba ),    /* Offset= 698 (1040) */
     801/* 342 */       NdrFcShort( 0x288 ),    /* Offset= 648 (990) */
    799802/* 344 */       NdrFcLong( 0x4012 ),    /* 16402 */
    800 /* 348 */       NdrFcShort( 0x276 ),    /* Offset= 630 (978) */
     803/* 348 */       NdrFcShort( 0x244 ),    /* Offset= 580 (928) */
    801804/* 350 */       NdrFcLong( 0x4013 ),    /* 16403 */
    802 /* 354 */       NdrFcShort( 0x274 ),    /* Offset= 628 (982) */
     805/* 354 */       NdrFcShort( 0x242 ),    /* Offset= 578 (932) */
    803806/* 356 */       NdrFcLong( 0x4015 ),    /* 16405 */
    804 /* 360 */       NdrFcShort( 0x272 ),    /* Offset= 626 (986) */
     807/* 360 */       NdrFcShort( 0x240 ),    /* Offset= 576 (936) */
    805808/* 362 */       NdrFcLong( 0x4016 ),    /* 16406 */
    806 /* 366 */       NdrFcShort( 0x268 ),    /* Offset= 616 (982) */
     809/* 366 */       NdrFcShort( 0x236 ),    /* Offset= 566 (932) */
    807810/* 368 */       NdrFcLong( 0x4017 ),    /* 16407 */
    808 /* 372 */       NdrFcShort( 0x262 ),    /* Offset= 610 (982) */
     811/* 372 */       NdrFcShort( 0x230 ),    /* Offset= 560 (932) */
    809812/* 374 */       NdrFcLong( 0x0 ),       /* 0 */
    810813/* 378 */       NdrFcShort( 0x0 ),      /* Offset= 0 (378) */
    … …  
    837840/* 416 */       
    838841                        0x13, 0x0,      /* FC_OP */
    839 /* 418 */       NdrFcShort( 0x216 ),    /* Offset= 534 (952) */
     842/* 418 */       NdrFcShort( 0x1e4 ),    /* Offset= 484 (902) */
    840843/* 420 */       
    841844                        0x2a,           /* FC_ENCAPSULATED_UNION */
    842                         0x49,           /* 73 */
    843 /* 422 */       NdrFcShort( 0x18 ),     /* 24 */
     845                        0x89,           /* 137 */
     846/* 422 */       NdrFcShort( 0x20 ),     /* 32 */
    844847/* 424 */       NdrFcShort( 0xa ),      /* 10 */
    845848/* 426 */       NdrFcLong( 0x8 ),       /* 8 */
    846 /* 430 */       NdrFcShort( 0x5a ),     /* Offset= 90 (520) */
     849/* 430 */       NdrFcShort( 0x50 ),     /* Offset= 80 (510) */
    847850/* 432 */       NdrFcLong( 0xd ),       /* 13 */
    848 /* 436 */       NdrFcShort( 0x7e ),     /* Offset= 126 (562) */
     851/* 436 */       NdrFcShort( 0x70 ),     /* Offset= 112 (548) */
    849852/* 438 */       NdrFcLong( 0x9 ),       /* 9 */
    850 /* 442 */       NdrFcShort( 0x9e ),     /* Offset= 158 (600) */
     853/* 442 */       NdrFcShort( 0x90 ),     /* Offset= 144 (586) */
    851854/* 444 */       NdrFcLong( 0xc ),       /* 12 */
    852 /* 448 */       NdrFcShort( 0xc8 ),     /* Offset= 200 (648) */
     855/* 448 */       NdrFcShort( 0xb0 ),     /* Offset= 176 (624) */
    853856/* 450 */       NdrFcLong( 0x24 ),      /* 36 */
    854 /* 454 */       NdrFcShort( 0x124 ),    /* Offset= 292 (746) */
     857/* 454 */       NdrFcShort( 0x102 ),    /* Offset= 258 (712) */
    855858/* 456 */       NdrFcLong( 0x800d ),    /* 32781 */
    856 /* 460 */       NdrFcShort( 0x140 ),    /* Offset= 320 (780) */
     859/* 460 */       NdrFcShort( 0x11e ),    /* Offset= 286 (746) */
    857860/* 462 */       NdrFcLong( 0x10 ),      /* 16 */
    858 /* 466 */       NdrFcShort( 0x15a ),    /* Offset= 346 (812) */
     861/* 466 */       NdrFcShort( 0x138 ),    /* Offset= 312 (778) */
    859862/* 468 */       NdrFcLong( 0x2 ),       /* 2 */
    860 /* 472 */       NdrFcShort( 0x174 ),    /* Offset= 372 (844) */
     863/* 472 */       NdrFcShort( 0x14e ),    /* Offset= 334 (806) */
    861864/* 474 */       NdrFcLong( 0x3 ),       /* 3 */
    862 /* 478 */       NdrFcShort( 0x18e ),    /* Offset= 398 (876) */
     865/* 478 */       NdrFcShort( 0x164 ),    /* Offset= 356 (834) */
    863866/* 480 */       NdrFcLong( 0x14 ),      /* 20 */
    864 /* 484 */       NdrFcShort( 0x1a8 ),    /* Offset= 424 (908) */
     867/* 484 */       NdrFcShort( 0x17a ),    /* Offset= 378 (862) */
    865868/* 486 */       NdrFcShort( 0xffff ),   /* Offset= -1 (485) */
    866869/* 488 */       
    867                         0x1b,           /* FC_CARRAY */
    868                         0x3,            /* 3 */
    869 /* 490 */       NdrFcShort( 0x4 ),      /* 4 */
     870                        0x21,           /* FC_BOGUS_ARRAY */
     871                        0x3,            /* 3 */
     872/* 490 */       NdrFcShort( 0x0 ),      /* 0 */
    870873/* 492 */       0x19,           /* Corr desc:  field pointer, FC_ULONG */
    871874                        0x0,            /*  */
    872875/* 494 */       NdrFcShort( 0x0 ),      /* 0 */
    873876/* 496 */       NdrFcShort( 0x1 ),      /* Corr flags:  early, */
    874 /* 498 */       
    875                         0x4b,           /* FC_PP */
    876                         0x5c,           /* FC_PAD */
    877 /* 500 */       
    878                         0x48,           /* FC_VARIABLE_REPEAT */
    879                         0x49,           /* FC_FIXED_OFFSET */
    880 /* 502 */       NdrFcShort( 0x4 ),      /* 4 */
    881 /* 504 */       NdrFcShort( 0x0 ),      /* 0 */
    882 /* 506 */       NdrFcShort( 0x1 ),      /* 1 */
    883 /* 508 */       NdrFcShort( 0x0 ),      /* 0 */
    884 /* 510 */       NdrFcShort( 0x0 ),      /* 0 */
    885 /* 512 */       0x13, 0x0,      /* FC_OP */
    886 /* 514 */       NdrFcShort( 0xfe14 ),   /* Offset= -492 (22) */
    887 /* 516 */       
    888                         0x5b,           /* FC_END */
    889 
    890                         0x8,            /* FC_LONG */
    891 /* 518 */       0x5c,           /* FC_PAD */
    892                         0x5b,           /* FC_END */
    893 /* 520 */       
    894                         0x16,           /* FC_PSTRUCT */
    895                         0x3,            /* 3 */
    896 /* 522 */       NdrFcShort( 0x8 ),      /* 8 */
    897 /* 524 */       
    898                         0x4b,           /* FC_PP */
    899                         0x5c,           /* FC_PAD */
     877/* 498 */       NdrFcLong( 0xffffffff ),        /* -1 */
     878/* 502 */       NdrFcShort( 0x0 ),      /* Corr flags:  */
     879/* 504 */       
     880                        0x13, 0x0,      /* FC_OP */
     881/* 506 */       NdrFcShort( 0xfe1c ),   /* Offset= -484 (22) */
     882/* 508 */       0x5c,           /* FC_PAD */
     883                        0x5b,           /* FC_END */
     884/* 510 */       
     885                        0x1a,           /* FC_BOGUS_STRUCT */
     886                        0x3,            /* 3 */
     887/* 512 */       NdrFcShort( 0x10 ),     /* 16 */
     888/* 514 */       NdrFcShort( 0x0 ),      /* 0 */
     889/* 516 */       NdrFcShort( 0x6 ),      /* Offset= 6 (522) */
     890/* 518 */       0x8,            /* FC_LONG */
     891                        0x40,           /* FC_STRUCTPAD4 */
     892/* 520 */       0x36,           /* FC_POINTER */
     893                        0x5b,           /* FC_END */
     894/* 522 */       
     895                        0x11, 0x0,      /* FC_RP */
     896/* 524 */       NdrFcShort( 0xffdc ),   /* Offset= -36 (488) */
    900897/* 526 */       
    901                         0x46,           /* FC_NO_REPEAT */
    902                         0x5c,           /* FC_PAD */
    903 /* 528 */       NdrFcShort( 0x4 ),      /* 4 */
    904 /* 530 */       NdrFcShort( 0x4 ),      /* 4 */
    905 /* 532 */       0x11, 0x0,      /* FC_RP */
    906 /* 534 */       NdrFcShort( 0xffd2 ),   /* Offset= -46 (488) */
    907 /* 536 */       
    908                         0x5b,           /* FC_END */
    909 
    910                         0x8,            /* FC_LONG */
    911 /* 538 */       0x8,            /* FC_LONG */
    912                         0x5b,           /* FC_END */
    913 /* 540 */       
    914898                        0x21,           /* FC_BOGUS_ARRAY */
    915899                        0x3,            /* 3 */
    916 /* 542 */       NdrFcShort( 0x0 ),      /* 0 */
    917 /* 544 */       0x19,           /* Corr desc:  field pointer, FC_ULONG */
     900/* 528 */       NdrFcShort( 0x0 ),      /* 0 */
     901/* 530 */       0x19,           /* Corr desc:  field pointer, FC_ULONG */
    918902                        0x0,            /*  */
    919 /* 546 */       NdrFcShort( 0x0 ),      /* 0 */
    920 /* 548 */       NdrFcShort( 0x1 ),      /* Corr flags:  early, */
    921 /* 550 */       NdrFcLong( 0xffffffff ),        /* -1 */
    922 /* 554 */       NdrFcShort( 0x0 ),      /* Corr flags:  */
    923 /* 556 */       0x4c,           /* FC_EMBEDDED_COMPLEX */
    924                         0x0,            /* 0 */
    925 /* 558 */       NdrFcShort( 0xfe12 ),   /* Offset= -494 (64) */
    926 /* 560 */       0x5c,           /* FC_PAD */
    927                         0x5b,           /* FC_END */
    928 /* 562 */       
     903/* 532 */       NdrFcShort( 0x0 ),      /* 0 */
     904/* 534 */       NdrFcShort( 0x1 ),      /* Corr flags:  early, */
     905/* 536 */       NdrFcLong( 0xffffffff ),        /* -1 */
     906/* 540 */       NdrFcShort( 0x0 ),      /* Corr flags:  */
     907/* 542 */       0x4c,           /* FC_EMBEDDED_COMPLEX */
     908                        0x0,            /* 0 */
     909/* 544 */       NdrFcShort( 0xfe20 ),   /* Offset= -480 (64) */
     910/* 546 */       0x5c,           /* FC_PAD */
     911                        0x5b,           /* FC_END */
     912/* 548 */       
    929913                        0x1a,           /* FC_BOGUS_STRUCT */
    930914                        0x3,            /* 3 */
    931 /* 564 */       NdrFcShort( 0x8 ),      /* 8 */
     915/* 550 */       NdrFcShort( 0x10 ),     /* 16 */
     916/* 552 */       NdrFcShort( 0x0 ),      /* 0 */
     917/* 554 */       NdrFcShort( 0x6 ),      /* Offset= 6 (560) */
     918/* 556 */       0x8,            /* FC_LONG */
     919                        0x40,           /* FC_STRUCTPAD4 */
     920/* 558 */       0x36,           /* FC_POINTER */
     921                        0x5b,           /* FC_END */
     922/* 560 */       
     923                        0x11, 0x0,      /* FC_RP */
     924/* 562 */       NdrFcShort( 0xffdc ),   /* Offset= -36 (526) */
     925/* 564 */       
     926                        0x21,           /* FC_BOGUS_ARRAY */
     927                        0x3,            /* 3 */
    932928/* 566 */       NdrFcShort( 0x0 ),      /* 0 */
    933 /* 568 */       NdrFcShort( 0x6 ),      /* Offset= 6 (574) */
    934 /* 570 */       0x8,            /* FC_LONG */
    935                         0x36,           /* FC_POINTER */
    936 /* 572 */       0x5c,           /* FC_PAD */
    937                         0x5b,           /* FC_END */
    938 /* 574 */       
     929/* 568 */       0x19,           /* Corr desc:  field pointer, FC_ULONG */
     930                        0x0,            /*  */
     931/* 570 */       NdrFcShort( 0x0 ),      /* 0 */
     932/* 572 */       NdrFcShort( 0x1 ),      /* Corr flags:  early, */
     933/* 574 */       NdrFcLong( 0xffffffff ),        /* -1 */
     934/* 578 */       NdrFcShort( 0x0 ),      /* Corr flags:  */
     935/* 580 */       0x4c,           /* FC_EMBEDDED_COMPLEX */
     936                        0x0,            /* 0 */
     937/* 582 */       NdrFcShort( 0xff44 ),   /* Offset= -188 (394) */
     938/* 584 */       0x5c,           /* FC_PAD */
     939                        0x5b,           /* FC_END */
     940/* 586 */       
     941                        0x1a,           /* FC_BOGUS_STRUCT */
     942                        0x3,            /* 3 */
     943/* 588 */       NdrFcShort( 0x10 ),     /* 16 */
     944/* 590 */       NdrFcShort( 0x0 ),      /* 0 */
     945/* 592 */       NdrFcShort( 0x6 ),      /* Offset= 6 (598) */
     946/* 594 */       0x8,            /* FC_LONG */
     947                        0x40,           /* FC_STRUCTPAD4 */
     948/* 596 */       0x36,           /* FC_POINTER */
     949                        0x5b,           /* FC_END */
     950/* 598 */       
    939951                        0x11, 0x0,      /* FC_RP */
    940 /* 576 */       NdrFcShort( 0xffdc ),   /* Offset= -36 (540) */
    941 /* 578 */       
     952/* 600 */       NdrFcShort( 0xffdc ),   /* Offset= -36 (564) */
     953/* 602 */       
    942954                        0x21,           /* FC_BOGUS_ARRAY */
    943955                        0x3,            /* 3 */
    944 /* 580 */       NdrFcShort( 0x0 ),      /* 0 */
    945 /* 582 */       0x19,           /* Corr desc:  field pointer, FC_ULONG */
     956/* 604 */       NdrFcShort( 0x0 ),      /* 0 */
     957/* 606 */       0x19,           /* Corr desc:  field pointer, FC_ULONG */
    946958                        0x0,            /*  */
    947 /* 584 */       NdrFcShort( 0x0 ),      /* 0 */
    948 /* 586 */       NdrFcShort( 0x1 ),      /* Corr flags:  early, */
    949 /* 588 */       NdrFcLong( 0xffffffff ),        /* -1 */
    950 /* 592 */       NdrFcShort( 0x0 ),      /* Corr flags:  */
    951 /* 594 */       0x4c,           /* FC_EMBEDDED_COMPLEX */
    952                         0x0,            /* 0 */
    953 /* 596 */       NdrFcShort( 0xff36 ),   /* Offset= -202 (394) */
    954 /* 598 */       0x5c,           /* FC_PAD */
    955                         0x5b,           /* FC_END */
    956 /* 600 */       
     959/* 608 */       NdrFcShort( 0x0 ),      /* 0 */
     960/* 610 */       NdrFcShort( 0x1 ),      /* Corr flags:  early, */
     961/* 612 */       NdrFcLong( 0xffffffff ),        /* -1 */
     962/* 616 */       NdrFcShort( 0x0 ),      /* Corr flags:  */
     963/* 618 */       
     964                        0x13, 0x0,      /* FC_OP */
     965/* 620 */       NdrFcShort( 0x176 ),    /* Offset= 374 (994) */
     966/* 622 */       0x5c,           /* FC_PAD */
     967                        0x5b,           /* FC_END */
     968/* 624 */       
    957969                        0x1a,           /* FC_BOGUS_STRUCT */
    958970                        0x3,            /* 3 */
    959 /* 602 */       NdrFcShort( 0x8 ),      /* 8 */
    960 /* 604 */       NdrFcShort( 0x0 ),      /* 0 */
    961 /* 606 */       NdrFcShort( 0x6 ),      /* Offset= 6 (612) */
    962 /* 608 */       0x8,            /* FC_LONG */
    963                         0x36,           /* FC_POINTER */
    964 /* 610 */       0x5c,           /* FC_PAD */
    965                         0x5b,           /* FC_END */
    966 /* 612 */       
     971/* 626 */       NdrFcShort( 0x10 ),     /* 16 */
     972/* 628 */       NdrFcShort( 0x0 ),      /* 0 */
     973/* 630 */       NdrFcShort( 0x6 ),      /* Offset= 6 (636) */
     974/* 632 */       0x8,            /* FC_LONG */
     975                        0x40,           /* FC_STRUCTPAD4 */
     976/* 634 */       0x36,           /* FC_POINTER */
     977                        0x5b,           /* FC_END */
     978/* 636 */       
    967979                        0x11, 0x0,      /* FC_RP */
    968 /* 614 */       NdrFcShort( 0xffdc ),   /* Offset= -36 (578) */
    969 /* 616 */       
    970                         0x1b,           /* FC_CARRAY */
    971                         0x3,            /* 3 */
    972 /* 618 */       NdrFcShort( 0x4 ),      /* 4 */
    973 /* 620 */       0x19,           /* Corr desc:  field pointer, FC_ULONG */
    974                         0x0,            /*  */
    975 /* 622 */       NdrFcShort( 0x0 ),      /* 0 */
    976 /* 624 */       NdrFcShort( 0x1 ),      /* Corr flags:  early, */
    977 /* 626 */       
    978                         0x4b,           /* FC_PP */
    979                         0x5c,           /* FC_PAD */
    980 /* 628 */       
    981                         0x48,           /* FC_VARIABLE_REPEAT */
    982                         0x49,           /* FC_FIXED_OFFSET */
    983 /* 630 */       NdrFcShort( 0x4 ),      /* 4 */
    984 /* 632 */       NdrFcShort( 0x0 ),      /* 0 */
    985 /* 634 */       NdrFcShort( 0x1 ),      /* 1 */
    986 /* 636 */       NdrFcShort( 0x0 ),      /* 0 */
    987 /* 638 */       NdrFcShort( 0x0 ),      /* 0 */
    988 /* 640 */       0x13, 0x0,      /* FC_OP */
    989 /* 642 */       NdrFcShort( 0x192 ),    /* Offset= 402 (1044) */
    990 /* 644 */       
    991                         0x5b,           /* FC_END */
    992 
    993                         0x8,            /* FC_LONG */
    994 /* 646 */       0x5c,           /* FC_PAD */
    995                         0x5b,           /* FC_END */
    996 /* 648 */       
    997                         0x1a,           /* FC_BOGUS_STRUCT */
    998                         0x3,            /* 3 */
    999 /* 650 */       NdrFcShort( 0x8 ),      /* 8 */
    1000 /* 652 */       NdrFcShort( 0x0 ),      /* 0 */
    1001 /* 654 */       NdrFcShort( 0x6 ),      /* Offset= 6 (660) */
    1002 /* 656 */       0x8,            /* FC_LONG */
    1003                         0x36,           /* FC_POINTER */
    1004 /* 658 */       0x5c,           /* FC_PAD */
    1005                         0x5b,           /* FC_END */
    1006 /* 660 */       
    1007                         0x11, 0x0,      /* FC_RP */
    1008 /* 662 */       NdrFcShort( 0xffd2 ),   /* Offset= -46 (616) */
    1009 /* 664 */       
     980/* 638 */       NdrFcShort( 0xffdc ),   /* Offset= -36 (602) */
     981/* 640 */       
    1010982                        0x2f,           /* FC_IP */
    1011983                        0x5a,           /* FC_CONSTANT_IID */
    1012 /* 666 */       NdrFcLong( 0x2f ),      /* 47 */
    1013 /* 670 */       NdrFcShort( 0x0 ),      /* 0 */
    1014 /* 672 */       NdrFcShort( 0x0 ),      /* 0 */
    1015 /* 674 */       0xc0,           /* 192 */
    1016                         0x0,            /* 0 */
    1017 /* 676 */       0x0,            /* 0 */
    1018                         0x0,            /* 0 */
    1019 /* 678 */       0x0,            /* 0 */
    1020                         0x0,            /* 0 */
    1021 /* 680 */       0x0,            /* 0 */
     984/* 642 */       NdrFcLong( 0x2f ),      /* 47 */
     985/* 646 */       NdrFcShort( 0x0 ),      /* 0 */
     986/* 648 */       NdrFcShort( 0x0 ),      /* 0 */
     987/* 650 */       0xc0,           /* 192 */
     988                        0x0,            /* 0 */
     989/* 652 */       0x0,            /* 0 */
     990                        0x0,            /* 0 */
     991/* 654 */       0x0,            /* 0 */
     992                        0x0,            /* 0 */
     993/* 656 */       0x0,            /* 0 */
    1022994                        0x46,           /* 70 */
    1023 /* 682 */       
     995/* 658 */       
    1024996                        0x1b,           /* FC_CARRAY */
    1025997                        0x0,            /* 0 */
    1026 /* 684 */       NdrFcShort( 0x1 ),      /* 1 */
    1027 /* 686 */       0x19,           /* Corr desc:  field pointer, FC_ULONG */
     998/* 660 */       NdrFcShort( 0x1 ),      /* 1 */
     999/* 662 */       0x19,           /* Corr desc:  field pointer, FC_ULONG */
    10281000                        0x0,            /*  */
    1029 /* 688 */       NdrFcShort( 0x4 ),      /* 4 */
    1030 /* 690 */       NdrFcShort( 0x1 ),      /* Corr flags:  early, */
    1031 /* 692 */       0x1,            /* FC_BYTE */
    1032                         0x5b,           /* FC_END */
    1033 /* 694 */       
     1001/* 664 */       NdrFcShort( 0x4 ),      /* 4 */
     1002/* 666 */       NdrFcShort( 0x1 ),      /* Corr flags:  early, */
     1003/* 668 */       0x1,            /* FC_BYTE */
     1004                        0x5b,           /* FC_END */
     1005/* 670 */       
    10341006                        0x1a,           /* FC_BOGUS_STRUCT */
    10351007                        0x3,            /* 3 */
    1036 /* 696 */       NdrFcShort( 0x10 ),     /* 16 */
    1037 /* 698 */       NdrFcShort( 0x0 ),      /* 0 */
    1038 /* 700 */       NdrFcShort( 0xa ),      /* Offset= 10 (710) */
    1039 /* 702 */       0x8,            /* FC_LONG */
     1008/* 672 */       NdrFcShort( 0x18 ),     /* 24 */
     1009/* 674 */       NdrFcShort( 0x0 ),      /* 0 */
     1010/* 676 */       NdrFcShort( 0xa ),      /* Offset= 10 (686) */
     1011/* 678 */       0x8,            /* FC_LONG */
    10401012                        0x8,            /* FC_LONG */
    1041 /* 704 */       0x4c,           /* FC_EMBEDDED_COMPLEX */
    1042                         0x0,            /* 0 */
    1043 /* 706 */       NdrFcShort( 0xffd6 ),   /* Offset= -42 (664) */
    1044 /* 708 */       0x36,           /* FC_POINTER */
    1045                         0x5b,           /* FC_END */
    1046 /* 710 */       
     1013/* 680 */       0x4c,           /* FC_EMBEDDED_COMPLEX */
     1014                        0x0,            /* 0 */
     1015/* 682 */       NdrFcShort( 0xffd6 ),   /* Offset= -42 (640) */
     1016/* 684 */       0x36,           /* FC_POINTER */
     1017                        0x5b,           /* FC_END */
     1018/* 686 */       
    10471019                        0x13, 0x0,      /* FC_OP */
    1048 /* 712 */       NdrFcShort( 0xffe2 ),   /* Offset= -30 (682) */
    1049 /* 714 */       
    1050                         0x1b,           /* FC_CARRAY */
    1051                         0x3,            /* 3 */
    1052 /* 716 */       NdrFcShort( 0x4 ),      /* 4 */
    1053 /* 718 */       0x19,           /* Corr desc:  field pointer, FC_ULONG */
     1020/* 688 */       NdrFcShort( 0xffe2 ),   /* Offset= -30 (658) */
     1021/* 690 */       
     1022                        0x21,           /* FC_BOGUS_ARRAY */
     1023                        0x3,            /* 3 */
     1024/* 692 */       NdrFcShort( 0x0 ),      /* 0 */
     1025/* 694 */       0x19,           /* Corr desc:  field pointer, FC_ULONG */
    10541026                        0x0,            /*  */
    1055 /* 720 */       NdrFcShort( 0x0 ),      /* 0 */
    1056 /* 722 */       NdrFcShort( 0x1 ),      /* Corr flags:  early, */
     1027/* 696 */       NdrFcShort( 0x0 ),      /* 0 */
     1028/* 698 */       NdrFcShort( 0x1 ),      /* Corr flags:  early, */
     1029/* 700 */       NdrFcLong( 0xffffffff ),        /* -1 */
     1030/* 704 */       NdrFcShort( 0x0 ),      /* Corr flags:  */
     1031/* 706 */       
     1032                        0x13, 0x0,      /* FC_OP */
     1033/* 708 */       NdrFcShort( 0xffda ),   /* Offset= -38 (670) */
     1034/* 710 */       0x5c,           /* FC_PAD */
     1035                        0x5b,           /* FC_END */
     1036/* 712 */       
     1037                        0x1a,           /* FC_BOGUS_STRUCT */
     1038                        0x3,            /* 3 */
     1039/* 714 */       NdrFcShort( 0x10 ),     /* 16 */
     1040/* 716 */       NdrFcShort( 0x0 ),      /* 0 */
     1041/* 718 */       NdrFcShort( 0x6 ),      /* Offset= 6 (724) */
     1042/* 720 */       0x8,            /* FC_LONG */
     1043                        0x40,           /* FC_STRUCTPAD4 */
     1044/* 722 */       0x36,           /* FC_POINTER */
     1045                        0x5b,           /* FC_END */
    10571046/* 724 */       
    1058                         0x4b,           /* FC_PP */
    1059                         0x5c,           /* FC_PAD */
    1060 /* 726 */       
    1061                         0x48,           /* FC_VARIABLE_REPEAT */
    1062                         0x49,           /* FC_FIXED_OFFSET */
    1063 /* 728 */       NdrFcShort( 0x4 ),      /* 4 */
    1064 /* 730 */       NdrFcShort( 0x0 ),      /* 0 */
    1065 /* 732 */       NdrFcShort( 0x1 ),      /* 1 */
    1066 /* 734 */       NdrFcShort( 0x0 ),      /* 0 */
    1067 /* 736 */       NdrFcShort( 0x0 ),      /* 0 */
    1068 /* 738 */       0x13, 0x0,      /* FC_OP */
    1069 /* 740 */       NdrFcShort( 0xffd2 ),   /* Offset= -46 (694) */
    1070 /* 742 */       
    1071                         0x5b,           /* FC_END */
    1072 
    1073                         0x8,            /* FC_LONG */
    1074 /* 744 */       0x5c,           /* FC_PAD */
     1047                        0x11, 0x0,      /* FC_RP */
     1048/* 726 */       NdrFcShort( 0xffdc ),   /* Offset= -36 (690) */
     1049/* 728 */       
     1050                        0x1d,           /* FC_SMFARRAY */
     1051                        0x0,            /* 0 */
     1052/* 730 */       NdrFcShort( 0x8 ),      /* 8 */
     1053/* 732 */       0x1,            /* FC_BYTE */
     1054                        0x5b,           /* FC_END */
     1055/* 734 */       
     1056                        0x15,           /* FC_STRUCT */
     1057                        0x3,            /* 3 */
     1058/* 736 */       NdrFcShort( 0x10 ),     /* 16 */
     1059/* 738 */       0x8,            /* FC_LONG */
     1060                        0x6,            /* FC_SHORT */
     1061/* 740 */       0x6,            /* FC_SHORT */
     1062                        0x4c,           /* FC_EMBEDDED_COMPLEX */
     1063/* 742 */       0x0,            /* 0 */
     1064                        NdrFcShort( 0xfff1 ),   /* Offset= -15 (728) */
    10751065                        0x5b,           /* FC_END */
    10761066/* 746 */       
    10771067                        0x1a,           /* FC_BOGUS_STRUCT */
    10781068                        0x3,            /* 3 */
    1079 /* 748 */       NdrFcShort( 0x8 ),      /* 8 */
     1069/* 748 */       NdrFcShort( 0x20 ),     /* 32 */
    10801070/* 750 */       NdrFcShort( 0x0 ),      /* 0 */
    1081 /* 752 */       NdrFcShort( 0x6 ),      /* Offset= 6 (758) */
     1071/* 752 */       NdrFcShort( 0xa ),      /* Offset= 10 (762) */
    10821072/* 754 */       0x8,            /* FC_LONG */
    1083                         0x36,           /* FC_POINTER */
    1084 /* 756 */       0x5c,           /* FC_PAD */
    1085                         0x5b,           /* FC_END */
    1086 /* 758 */       
     1073                        0x40,           /* FC_STRUCTPAD4 */
     1074/* 756 */       0x36,           /* FC_POINTER */
     1075                        0x4c,           /* FC_EMBEDDED_COMPLEX */
     1076/* 758 */       0x0,            /* 0 */
     1077                        NdrFcShort( 0xffe7 ),   /* Offset= -25 (734) */
     1078                        0x5b,           /* FC_END */
     1079/* 762 */       
    10871080                        0x11, 0x0,      /* FC_RP */
    1088 /* 760 */       NdrFcShort( 0xffd2 ),   /* Offset= -46 (714) */
    1089 /* 762 */       
    1090                         0x1d,           /* FC_SMFARRAY */
    1091                         0x0,            /* 0 */
    1092 /* 764 */       NdrFcShort( 0x8 ),      /* 8 */
    1093 /* 766 */       0x1,            /* FC_BYTE */
    1094                         0x5b,           /* FC_END */
    1095 /* 768 */       
    1096                         0x15,           /* FC_STRUCT */
    1097                         0x3,            /* 3 */
    1098 /* 770 */       NdrFcShort( 0x10 ),     /* 16 */
    1099 /* 772 */       0x8,            /* FC_LONG */
    1100                         0x6,            /* FC_SHORT */
    1101 /* 774 */       0x6,            /* FC_SHORT */
    1102                         0x4c,           /* FC_EMBEDDED_COMPLEX */
    1103 /* 776 */       0x0,            /* 0 */
    1104                         NdrFcShort( 0xfff1 ),   /* Offset= -15 (762) */
    1105                         0x5b,           /* FC_END */
    1106 /* 780 */       
     1081/* 764 */       NdrFcShort( 0xff12 ),   /* Offset= -238 (526) */
     1082/* 766 */       
     1083                        0x1b,           /* FC_CARRAY */
     1084                        0x0,            /* 0 */
     1085/* 768 */       NdrFcShort( 0x1 ),      /* 1 */
     1086/* 770 */       0x19,           /* Corr desc:  field pointer, FC_ULONG */
     1087                        0x0,            /*  */
     1088/* 772 */       NdrFcShort( 0x0 ),      /* 0 */
     1089/* 774 */       NdrFcShort( 0x1 ),      /* Corr flags:  early, */
     1090/* 776 */       0x1,            /* FC_BYTE */
     1091                        0x5b,           /* FC_END */
     1092/* 778 */       
    11071093                        0x1a,           /* FC_BOGUS_STRUCT */
    11081094                        0x3,            /* 3 */
    1109 /* 782 */       NdrFcShort( 0x18 ),     /* 24 */
    1110 /* 784 */       NdrFcShort( 0x0 ),      /* 0 */
    1111 /* 786 */       NdrFcShort( 0xa ),      /* Offset= 10 (796) */
    1112 /* 788 */       0x8,            /* FC_LONG */
    1113                         0x36,           /* FC_POINTER */
    1114 /* 790 */       0x4c,           /* FC_EMBEDDED_COMPLEX */
    1115                         0x0,            /* 0 */
    1116 /* 792 */       NdrFcShort( 0xffe8 ),   /* Offset= -24 (768) */
    1117 /* 794 */       0x5c,           /* FC_PAD */
    1118                         0x5b,           /* FC_END */
    1119 /* 796 */       
    1120                         0x11, 0x0,      /* FC_RP */
    1121 /* 798 */       NdrFcShort( 0xfefe ),   /* Offset= -258 (540) */
    1122 /* 800 */       
    1123                         0x1b,           /* FC_CARRAY */
    1124                         0x0,            /* 0 */
    1125 /* 802 */       NdrFcShort( 0x1 ),      /* 1 */
    1126 /* 804 */       0x19,           /* Corr desc:  field pointer, FC_ULONG */
    1127                         0x0,            /*  */
    1128 /* 806 */       NdrFcShort( 0x0 ),      /* 0 */
    1129 /* 808 */       NdrFcShort( 0x1 ),      /* Corr flags:  early, */
    1130 /* 810 */       0x1,            /* FC_BYTE */
    1131                         0x5b,           /* FC_END */
    1132 /* 812 */       
    1133                         0x16,           /* FC_PSTRUCT */
    1134                         0x3,            /* 3 */
    1135 /* 814 */       NdrFcShort( 0x8 ),      /* 8 */
    1136 /* 816 */       
    1137                         0x4b,           /* FC_PP */
    1138                         0x5c,           /* FC_PAD */
    1139 /* 818 */       
    1140                         0x46,           /* FC_NO_REPEAT */
    1141                         0x5c,           /* FC_PAD */
    1142 /* 820 */       NdrFcShort( 0x4 ),      /* 4 */
    1143 /* 822 */       NdrFcShort( 0x4 ),      /* 4 */
    1144 /* 824 */       0x13, 0x0,      /* FC_OP */
    1145 /* 826 */       NdrFcShort( 0xffe6 ),   /* Offset= -26 (800) */
    1146 /* 828 */       
    1147                         0x5b,           /* FC_END */
    1148 
    1149                         0x8,            /* FC_LONG */
    1150 /* 830 */       0x8,            /* FC_LONG */
    1151                         0x5b,           /* FC_END */
    1152 /* 832 */       
     1095/* 780 */       NdrFcShort( 0x10 ),     /* 16 */
     1096/* 782 */       NdrFcShort( 0x0 ),      /* 0 */
     1097/* 784 */       NdrFcShort( 0x6 ),      /* Offset= 6 (790) */
     1098/* 786 */       0x8,            /* FC_LONG */
     1099                        0x40,           /* FC_STRUCTPAD4 */
     1100/* 788 */       0x36,           /* FC_POINTER */
     1101                        0x5b,           /* FC_END */
     1102/* 790 */       
     1103                        0x13, 0x0,      /* FC_OP */
     1104/* 792 */       NdrFcShort( 0xffe6 ),   /* Offset= -26 (766) */
     1105/* 794 */       
    11531106                        0x1b,           /* FC_CARRAY */
    11541107                        0x1,            /* 1 */
    1155 /* 834 */       NdrFcShort( 0x2 ),      /* 2 */
    1156 /* 836 */       0x19,           /* Corr desc:  field pointer, FC_ULONG */
     1108/* 796 */       NdrFcShort( 0x2 ),      /* 2 */
     1109/* 798 */       0x19,           /* Corr desc:  field pointer, FC_ULONG */
    11571110                        0x0,            /*  */
     1111/* 800 */       NdrFcShort( 0x0 ),      /* 0 */
     1112/* 802 */       NdrFcShort( 0x1 ),      /* Corr flags:  early, */
     1113/* 804 */       0x6,            /* FC_SHORT */
     1114                        0x5b,           /* FC_END */
     1115/* 806 */       
     1116                        0x1a,           /* FC_BOGUS_STRUCT */
     1117                        0x3,            /* 3 */
     1118/* 808 */       NdrFcShort( 0x10 ),     /* 16 */
     1119/* 810 */       NdrFcShort( 0x0 ),      /* 0 */
     1120/* 812 */       NdrFcShort( 0x6 ),      /* Offset= 6 (818) */
     1121/* 814 */       0x8,            /* FC_LONG */
     1122                        0x40,           /* FC_STRUCTPAD4 */
     1123/* 816 */       0x36,           /* FC_POINTER */
     1124                        0x5b,           /* FC_END */
     1125/* 818 */       
     1126                        0x13, 0x0,      /* FC_OP */
     1127/* 820 */       NdrFcShort( 0xffe6 ),   /* Offset= -26 (794) */
     1128/* 822 */       
     1129                        0x1b,           /* FC_CARRAY */
     1130                        0x3,            /* 3 */
     1131/* 824 */       NdrFcShort( 0x4 ),      /* 4 */
     1132/* 826 */       0x19,           /* Corr desc:  field pointer, FC_ULONG */
     1133                        0x0,            /*  */
     1134/* 828 */       NdrFcShort( 0x0 ),      /* 0 */
     1135/* 830 */       NdrFcShort( 0x1 ),      /* Corr flags:  early, */
     1136/* 832 */       0x8,            /* FC_LONG */
     1137                        0x5b,           /* FC_END */
     1138/* 834 */       
     1139                        0x1a,           /* FC_BOGUS_STRUCT */
     1140                        0x3,            /* 3 */
     1141/* 836 */       NdrFcShort( 0x10 ),     /* 16 */
    11581142/* 838 */       NdrFcShort( 0x0 ),      /* 0 */
    1159 /* 840 */       NdrFcShort( 0x1 ),      /* Corr flags:  early, */
    1160 /* 842 */       0x6,            /* FC_SHORT */
    1161                         0x5b,           /* FC_END */
    1162 /* 844 */       
    1163                         0x16,           /* FC_PSTRUCT */
    1164                         0x3,            /* 3 */
    1165 /* 846 */       NdrFcShort( 0x8 ),      /* 8 */
    1166 /* 848 */       
    1167                         0x4b,           /* FC_PP */
    1168                         0x5c,           /* FC_PAD */
     1143/* 840 */       NdrFcShort( 0x6 ),      /* Offset= 6 (846) */
     1144/* 842 */       0x8,            /* FC_LONG */
     1145                        0x40,           /* FC_STRUCTPAD4 */
     1146/* 844 */       0x36,           /* FC_POINTER */
     1147                        0x5b,           /* FC_END */
     1148/* 846 */       
     1149                        0x13, 0x0,      /* FC_OP */
     1150/* 848 */       NdrFcShort( 0xffe6 ),   /* Offset= -26 (822) */
    11691151/* 850 */       
    1170                         0x46,           /* FC_NO_REPEAT */
    1171                         0x5c,           /* FC_PAD */
    1172 /* 852 */       NdrFcShort( 0x4 ),      /* 4 */
    1173 /* 854 */       NdrFcShort( 0x4 ),      /* 4 */
    1174 /* 856 */       0x13, 0x0,      /* FC_OP */
    1175 /* 858 */       NdrFcShort( 0xffe6 ),   /* Offset= -26 (832) */
    1176 /* 860 */       
    1177                         0x5b,           /* FC_END */
    1178 
    1179                         0x8,            /* FC_LONG */
    1180 /* 862 */       0x8,            /* FC_LONG */
    1181                         0x5b,           /* FC_END */
    1182 /* 864 */       
    1183                         0x1b,           /* FC_CARRAY */
    1184                         0x3,            /* 3 */
    1185 /* 866 */       NdrFcShort( 0x4 ),      /* 4 */
    1186 /* 868 */       0x19,           /* Corr desc:  field pointer, FC_ULONG */
    1187                         0x0,            /*  */
    1188 /* 870 */       NdrFcShort( 0x0 ),      /* 0 */
    1189 /* 872 */       NdrFcShort( 0x1 ),      /* Corr flags:  early, */
    1190 /* 874 */       0x8,            /* FC_LONG */
    1191                         0x5b,           /* FC_END */
    1192 /* 876 */       
    1193                         0x16,           /* FC_PSTRUCT */
    1194                         0x3,            /* 3 */
    1195 /* 878 */       NdrFcShort( 0x8 ),      /* 8 */
    1196 /* 880 */       
    1197                         0x4b,           /* FC_PP */
    1198                         0x5c,           /* FC_PAD */
    1199 /* 882 */       
    1200                         0x46,           /* FC_NO_REPEAT */
    1201                         0x5c,           /* FC_PAD */
    1202 /* 884 */       NdrFcShort( 0x4 ),      /* 4 */
    1203 /* 886 */       NdrFcShort( 0x4 ),      /* 4 */
    1204 /* 888 */       0x13, 0x0,      /* FC_OP */
    1205 /* 890 */       NdrFcShort( 0xffe6 ),   /* Offset= -26 (864) */
    1206 /* 892 */       
    1207                         0x5b,           /* FC_END */
    1208 
    1209                         0x8,            /* FC_LONG */
    1210 /* 894 */       0x8,            /* FC_LONG */
    1211                         0x5b,           /* FC_END */
    1212 /* 896 */       
    12131152                        0x1b,           /* FC_CARRAY */
    12141153                        0x7,            /* 7 */
    1215 /* 898 */       NdrFcShort( 0x8 ),      /* 8 */
    1216 /* 900 */       0x19,           /* Corr desc:  field pointer, FC_ULONG */
     1154/* 852 */       NdrFcShort( 0x8 ),      /* 8 */
     1155/* 854 */       0x19,           /* Corr desc:  field pointer, FC_ULONG */
    12171156                        0x0,            /*  */
    1218 /* 902 */       NdrFcShort( 0x0 ),      /* 0 */
    1219 /* 904 */       NdrFcShort( 0x1 ),      /* Corr flags:  early, */
    1220 /* 906 */       0xb,            /* FC_HYPER */
    1221                         0x5b,           /* FC_END */
    1222 /* 908 */       
    1223                         0x16,           /* FC_PSTRUCT */
    1224                         0x3,            /* 3 */
    1225 /* 910 */       NdrFcShort( 0x8 ),      /* 8 */
    1226 /* 912 */       
    1227                         0x4b,           /* FC_PP */
     1157/* 856 */       NdrFcShort( 0x0 ),      /* 0 */
     1158/* 858 */       NdrFcShort( 0x1 ),      /* Corr flags:  early, */
     1159/* 860 */       0xb,            /* FC_HYPER */
     1160                        0x5b,           /* FC_END */
     1161/* 862 */       
     1162                        0x1a,           /* FC_BOGUS_STRUCT */
     1163                        0x3,            /* 3 */
     1164/* 864 */       NdrFcShort( 0x10 ),     /* 16 */
     1165/* 866 */       NdrFcShort( 0x0 ),      /* 0 */
     1166/* 868 */       NdrFcShort( 0x6 ),      /* Offset= 6 (874) */
     1167/* 870 */       0x8,            /* FC_LONG */
     1168                        0x40,           /* FC_STRUCTPAD4 */
     1169/* 872 */       0x36,           /* FC_POINTER */
     1170                        0x5b,           /* FC_END */
     1171/* 874 */       
     1172                        0x13, 0x0,      /* FC_OP */
     1173/* 876 */       NdrFcShort( 0xffe6 ),   /* Offset= -26 (850) */
     1174/* 878 */       
     1175                        0x15,           /* FC_STRUCT */
     1176                        0x3,            /* 3 */
     1177/* 880 */       NdrFcShort( 0x8 ),      /* 8 */
     1178/* 882 */       0x8,            /* FC_LONG */
     1179                        0x8,            /* FC_LONG */
     1180/* 884 */       0x5c,           /* FC_PAD */
     1181                        0x5b,           /* FC_END */
     1182/* 886 */       
     1183                        0x1b,           /* FC_CARRAY */
     1184                        0x3,            /* 3 */
     1185/* 888 */       NdrFcShort( 0x8 ),      /* 8 */
     1186/* 890 */       0x7,            /* Corr desc: FC_USHORT */
     1187                        0x0,            /*  */
     1188/* 892 */       NdrFcShort( 0xffc8 ),   /* -56 */
     1189/* 894 */       NdrFcShort( 0x1 ),      /* Corr flags:  early, */
     1190/* 896 */       0x4c,           /* FC_EMBEDDED_COMPLEX */
     1191                        0x0,            /* 0 */
     1192/* 898 */       NdrFcShort( 0xffec ),   /* Offset= -20 (878) */
     1193/* 900 */       0x5c,           /* FC_PAD */
     1194                        0x5b,           /* FC_END */
     1195/* 902 */       
     1196                        0x1a,           /* FC_BOGUS_STRUCT */
     1197                        0x3,            /* 3 */
     1198/* 904 */       NdrFcShort( 0x38 ),     /* 56 */
     1199/* 906 */       NdrFcShort( 0xffec ),   /* Offset= -20 (886) */
     1200/* 908 */       NdrFcShort( 0x0 ),      /* Offset= 0 (908) */
     1201/* 910 */       0x6,            /* FC_SHORT */
     1202                        0x6,            /* FC_SHORT */
     1203/* 912 */       0x8,            /* FC_LONG */
     1204                        0x8,            /* FC_LONG */
     1205/* 914 */       0x40,           /* FC_STRUCTPAD4 */
     1206                        0x4c,           /* FC_EMBEDDED_COMPLEX */
     1207/* 916 */       0x0,            /* 0 */
     1208                        NdrFcShort( 0xfe0f ),   /* Offset= -497 (420) */
     1209                        0x5b,           /* FC_END */
     1210/* 920 */       
     1211                        0x13, 0x0,      /* FC_OP */
     1212/* 922 */       NdrFcShort( 0xff04 ),   /* Offset= -252 (670) */
     1213/* 924 */       
     1214                        0x13, 0x8,      /* FC_OP [simple_pointer] */
     1215/* 926 */       0x1,            /* FC_BYTE */
    12281216                        0x5c,           /* FC_PAD */
    1229 /* 914 */       
    1230                         0x46,           /* FC_NO_REPEAT */
     1217/* 928 */       
     1218                        0x13, 0x8,      /* FC_OP [simple_pointer] */
     1219/* 930 */       0x6,            /* FC_SHORT */
    12311220                        0x5c,           /* FC_PAD */
    1232 /* 916 */       NdrFcShort( 0x4 ),      /* 4 */
    1233 /* 918 */       NdrFcShort( 0x4 ),      /* 4 */
    1234 /* 920 */       0x13, 0x0,      /* FC_OP */
    1235 /* 922 */       NdrFcShort( 0xffe6 ),   /* Offset= -26 (896) */
    1236 /* 924 */       
    1237                         0x5b,           /* FC_END */
    1238 
     1221/* 932 */       
     1222                        0x13, 0x8,      /* FC_OP [simple_pointer] */
     1223/* 934 */       0x8,            /* FC_LONG */
     1224                        0x5c,           /* FC_PAD */
     1225/* 936 */       
     1226                        0x13, 0x8,      /* FC_OP [simple_pointer] */
     1227/* 938 */       0xb,            /* FC_HYPER */
     1228                        0x5c,           /* FC_PAD */
     1229/* 940 */       
     1230                        0x13, 0x8,      /* FC_OP [simple_pointer] */
     1231/* 942 */       0xa,            /* FC_FLOAT */
     1232                        0x5c,           /* FC_PAD */
     1233/* 944 */       
     1234                        0x13, 0x8,      /* FC_OP [simple_pointer] */
     1235/* 946 */       0xc,            /* FC_DOUBLE */
     1236                        0x5c,           /* FC_PAD */
     1237/* 948 */       
     1238                        0x13, 0x0,      /* FC_OP */
     1239/* 950 */       NdrFcShort( 0xfdce ),   /* Offset= -562 (388) */
     1240/* 952 */       
     1241                        0x13, 0x10,     /* FC_OP [pointer_deref] */
     1242/* 954 */       NdrFcShort( 0xfc4c ),   /* Offset= -948 (6) */
     1243/* 956 */       
     1244                        0x13, 0x10,     /* FC_OP [pointer_deref] */
     1245/* 958 */       NdrFcShort( 0xfc82 ),   /* Offset= -894 (64) */
     1246/* 960 */       
     1247                        0x13, 0x10,     /* FC_OP [pointer_deref] */
     1248/* 962 */       NdrFcShort( 0xfdc8 ),   /* Offset= -568 (394) */
     1249/* 964 */       
     1250                        0x13, 0x10,     /* FC_OP [pointer_deref] */
     1251/* 966 */       NdrFcShort( 0xfdd6 ),   /* Offset= -554 (412) */
     1252/* 968 */       
     1253                        0x13, 0x10,     /* FC_OP [pointer_deref] */
     1254/* 970 */       NdrFcShort( 0x2 ),      /* Offset= 2 (972) */
     1255/* 972 */       
     1256                        0x13, 0x0,      /* FC_OP */
     1257/* 974 */       NdrFcShort( 0x14 ),     /* Offset= 20 (994) */
     1258/* 976 */       
     1259                        0x15,           /* FC_STRUCT */
     1260                        0x7,            /* 7 */
     1261/* 978 */       NdrFcShort( 0x10 ),     /* 16 */
     1262/* 980 */       0x6,            /* FC_SHORT */
     1263                        0x1,            /* FC_BYTE */
     1264/* 982 */       0x1,            /* FC_BYTE */
    12391265                        0x8,            /* FC_LONG */
    1240 /* 926 */       0x8,            /* FC_LONG */
    1241                         0x5b,           /* FC_END */
    1242 /* 928 */       
    1243                         0x15,           /* FC_STRUCT */
    1244                         0x3,            /* 3 */
    1245 /* 930 */       NdrFcShort( 0x8 ),      /* 8 */
    1246 /* 932 */       0x8,            /* FC_LONG */
    1247                         0x8,            /* FC_LONG */
    1248 /* 934 */       0x5c,           /* FC_PAD */
    1249                         0x5b,           /* FC_END */
    1250 /* 936 */       
    1251                         0x1b,           /* FC_CARRAY */
    1252                         0x3,            /* 3 */
    1253 /* 938 */       NdrFcShort( 0x8 ),      /* 8 */
    1254 /* 940 */       0x7,            /* Corr desc: FC_USHORT */
    1255                         0x0,            /*  */
    1256 /* 942 */       NdrFcShort( 0xffd8 ),   /* -40 */
    1257 /* 944 */       NdrFcShort( 0x1 ),      /* Corr flags:  early, */
    1258 /* 946 */       0x4c,           /* FC_EMBEDDED_COMPLEX */
    1259                         0x0,            /* 0 */
    1260 /* 948 */       NdrFcShort( 0xffec ),   /* Offset= -20 (928) */
    1261 /* 950 */       0x5c,           /* FC_PAD */
    1262                         0x5b,           /* FC_END */
    1263 /* 952 */       
    1264                         0x1a,           /* FC_BOGUS_STRUCT */
    1265                         0x3,            /* 3 */
    1266 /* 954 */       NdrFcShort( 0x28 ),     /* 40 */
    1267 /* 956 */       NdrFcShort( 0xffec ),   /* Offset= -20 (936) */
    1268 /* 958 */       NdrFcShort( 0x0 ),      /* Offset= 0 (958) */
    1269 /* 960 */       0x6,            /* FC_SHORT */
    1270                         0x6,            /* FC_SHORT */
    1271 /* 962 */       0x8,            /* FC_LONG */
    1272                         0x8,            /* FC_LONG */
    1273 /* 964 */       0x4c,           /* FC_EMBEDDED_COMPLEX */
    1274                         0x0,            /* 0 */
    1275 /* 966 */       NdrFcShort( 0xfdde ),   /* Offset= -546 (420) */
    1276 /* 968 */       0x5c,           /* FC_PAD */
    1277                         0x5b,           /* FC_END */
    1278 /* 970 */       
     1266/* 984 */       0xb,            /* FC_HYPER */
     1267                        0x5b,           /* FC_END */
     1268/* 986 */       
    12791269                        0x13, 0x0,      /* FC_OP */
    1280 /* 972 */       NdrFcShort( 0xfeea ),   /* Offset= -278 (694) */
    1281 /* 974 */       
    1282                         0x13, 0x8,      /* FC_OP [simple_pointer] */
    1283 /* 976 */       0x1,            /* FC_BYTE */
    1284                         0x5c,           /* FC_PAD */
    1285 /* 978 */       
    1286                         0x13, 0x8,      /* FC_OP [simple_pointer] */
    1287 /* 980 */       0x6,            /* FC_SHORT */
    1288                         0x5c,           /* FC_PAD */
    1289 /* 982 */       
    1290                         0x13, 0x8,      /* FC_OP [simple_pointer] */
    1291 /* 984 */       0x8,            /* FC_LONG */
    1292                         0x5c,           /* FC_PAD */
    1293 /* 986 */       
    1294                         0x13, 0x8,      /* FC_OP [simple_pointer] */
    1295 /* 988 */       0xb,            /* FC_HYPER */
    1296                         0x5c,           /* FC_PAD */
     1270/* 988 */       NdrFcShort( 0xfff4 ),   /* Offset= -12 (976) */
    12971271/* 990 */       
    12981272                        0x13, 0x8,      /* FC_OP [simple_pointer] */
    1299 /* 992 */       0xa,            /* FC_FLOAT */
     1273/* 992 */       0x2,            /* FC_CHAR */
    13001274                        0x5c,           /* FC_PAD */
    13011275/* 994 */       
    1302                         0x13, 0x8,      /* FC_OP [simple_pointer] */
    1303 /* 996 */       0xc,            /* FC_DOUBLE */
    1304                         0x5c,           /* FC_PAD */
    1305 /* 998 */       
    1306                         0x13, 0x0,      /* FC_OP */
    1307 /* 1000 */      NdrFcShort( 0xfd9c ),   /* Offset= -612 (388) */
    1308 /* 1002 */     
    1309                         0x13, 0x10,     /* FC_OP [pointer_deref] */
    1310 /* 1004 */      NdrFcShort( 0xfc1a ),   /* Offset= -998 (6) */
    1311 /* 1006 */     
    1312                         0x13, 0x10,     /* FC_OP [pointer_deref] */
    1313 /* 1008 */      NdrFcShort( 0xfc50 ),   /* Offset= -944 (64) */
    1314 /* 1010 */     
    1315                         0x13, 0x10,     /* FC_OP [pointer_deref] */
    1316 /* 1012 */      NdrFcShort( 0xfd96 ),   /* Offset= -618 (394) */
    1317 /* 1014 */     
    1318                         0x13, 0x10,     /* FC_OP [pointer_deref] */
    1319 /* 1016 */      NdrFcShort( 0xfda4 ),   /* Offset= -604 (412) */
    1320 /* 1018 */     
    1321                         0x13, 0x10,     /* FC_OP [pointer_deref] */
    1322 /* 1020 */      NdrFcShort( 0x2 ),      /* Offset= 2 (1022) */
    1323 /* 1022 */     
    1324                         0x13, 0x0,      /* FC_OP */
    1325 /* 1024 */      NdrFcShort( 0x14 ),     /* Offset= 20 (1044) */
    1326 /* 1026 */     
    1327                         0x15,           /* FC_STRUCT */
    1328                         0x7,            /* 7 */
    1329 /* 1028 */      NdrFcShort( 0x10 ),     /* 16 */
    1330 /* 1030 */      0x6,            /* FC_SHORT */
    1331                         0x1,            /* FC_BYTE */
    1332 /* 1032 */      0x1,            /* FC_BYTE */
    1333                         0x8,            /* FC_LONG */
    1334 /* 1034 */      0xb,            /* FC_HYPER */
    1335                         0x5b,           /* FC_END */
    1336 /* 1036 */     
    1337                         0x13, 0x0,      /* FC_OP */
    1338 /* 1038 */      NdrFcShort( 0xfff4 ),   /* Offset= -12 (1026) */
    1339 /* 1040 */     
    1340                         0x13, 0x8,      /* FC_OP [simple_pointer] */
    1341 /* 1042 */      0x2,            /* FC_CHAR */
    1342                         0x5c,           /* FC_PAD */
    1343 /* 1044 */     
    13441276                        0x1a,           /* FC_BOGUS_STRUCT */
    13451277                        0x7,            /* 7 */
    1346 /* 1046 */      NdrFcShort( 0x20 ),     /* 32 */
    1347 /* 1048 */      NdrFcShort( 0x0 ),      /* 0 */
    1348 /* 1050 */      NdrFcShort( 0x0 ),      /* Offset= 0 (1050) */
    1349 /* 1052 */      0x8,            /* FC_LONG */
     1278/* 996 */       NdrFcShort( 0x20 ),     /* 32 */
     1279/* 998 */       NdrFcShort( 0x0 ),      /* 0 */
     1280/* 1000 */      NdrFcShort( 0x0 ),      /* Offset= 0 (1000) */
     1281/* 1002 */      0x8,            /* FC_LONG */
    13501282                        0x8,            /* FC_LONG */
    1351 /* 1054 */      0x6,            /* FC_SHORT */
     1283/* 1004 */      0x6,            /* FC_SHORT */
    13521284                        0x6,            /* FC_SHORT */
    1353 /* 1056 */      0x6,            /* FC_SHORT */
     1285/* 1006 */      0x6,            /* FC_SHORT */
    13541286                        0x6,            /* FC_SHORT */
    1355 /* 1058 */      0x4c,           /* FC_EMBEDDED_COMPLEX */
    1356                         0x0,            /* 0 */
    1357 /* 1060 */      NdrFcShort( 0xfc36 ),   /* Offset= -970 (90) */
    1358 /* 1062 */      0x5c,           /* FC_PAD */
    1359                         0x5b,           /* FC_END */
    1360 /* 1064 */      0xb4,           /* FC_USER_MARSHAL */
     1287/* 1008 */      0x4c,           /* FC_EMBEDDED_COMPLEX */
     1288                        0x0,            /* 0 */
     1289/* 1010 */      NdrFcShort( 0xfc68 ),   /* Offset= -920 (90) */
     1290/* 1012 */      0x5c,           /* FC_PAD */
     1291                        0x5b,           /* FC_END */
     1292/* 1014 */      0xb4,           /* FC_USER_MARSHAL */
    13611293                        0x83,           /* 131 */
    1362 /* 1066 */      NdrFcShort( 0x1 ),      /* 1 */
    1363 /* 1068 */      NdrFcShort( 0x10 ),     /* 16 */
    1364 /* 1070 */      NdrFcShort( 0x0 ),      /* 0 */
    1365 /* 1072 */      NdrFcShort( 0xfc26 ),   /* Offset= -986 (86) */
    1366 /* 1074 */     
     1294/* 1016 */      NdrFcShort( 0x1 ),      /* 1 */
     1295/* 1018 */      NdrFcShort( 0x18 ),     /* 24 */
     1296/* 1020 */      NdrFcShort( 0x0 ),      /* 0 */
     1297/* 1022 */      NdrFcShort( 0xfc58 ),   /* Offset= -936 (86) */
     1298/* 1024 */     
    13671299                        0x11, 0x10,     /* FC_RP [pointer_deref] */
    1368 /* 1076 */      NdrFcShort( 0xfc0c ),   /* Offset= -1012 (64) */
     1300/* 1026 */      NdrFcShort( 0xfc3e ),   /* Offset= -962 (64) */
    13691301
    13701302                        0x0
    … …  
    14111343    (unsigned short) -1,
    14121344    0,
    1413     36,
    1414     72,
    1415     108,
    1416     144,
    1417     180,
    1418     216,
    1419     258,
    1420     300
     1345    38,
     1346    76,
     1347    114,
     1348    152,
     1349    190,
     1350    228,
     1351    272,
     1352    316
    14211353    };
    14221354
    … …  
    16341566    (unsigned short) -1,
    16351567    (unsigned short) -1,
    1636     348,
    1637     384,
    1638     72,
    1639     420,
    1640     144,
    1641     456,
    1642     504
     1568    366,
     1569    404,
     1570    76,
     1571    442,
     1572    152,
     1573    480,
     1574    530
    16431575    };
    16441576
    … …  
    17961728    0  /* Filler3 */
    17971729};
    1798 #pragma optimize("", on )
    17991730#if _MSC_VER >= 1200
    18001731#pragma warning(pop)
    … …  
    18021733
    18031734
    1804 #endif /* !defined(_M_IA64) && !defined(_M_AMD64)*/
    1805 
     1735#endif /* defined(_M_AMD64)*/
     1736

  • trunk/DirectShowSpy/FilterGraphHelper.h

    r266 r267  
    22// Copyright (C) Roman Ryltsov, 2008-2014
    33// Created by Roman Ryltsov roman@alax.info
     4//
     5// This source code is published to complement DirectShowSpy developer powertoy
     6// and demonstrate the internal use of APIs and tricks powering the tool. It is
     7// allowed to freely re-use the portions of the code in other projects, commercial or otherwise
     8// (provided that you don’t pretend that you wrote the original tool).
     9//
     10// Please keep in mind that DirectShowSpy is a developer tool, it is strongly recommended
     11// that it is not shipped with release grade software. The advise applies to hooking methods
     12// used by DirectShowSpy in general as well.
    413
    514#pragma once

  • trunk/DirectShowSpy/FilterGraphList.h

    r242 r267  
    22// Copyright (C) Roman Ryltsov, 2008-2014
    33// Created by Roman Ryltsov roman@alax.info
     4//
     5// This source code is published to complement DirectShowSpy developer powertoy
     6// and demonstrate the internal use of APIs and tricks powering the tool. It is
     7// allowed to freely re-use the portions of the code in other projects, commercial or otherwise
     8// (provided that you don’t pretend that you wrote the original tool).
     9//
     10// Please keep in mind that DirectShowSpy is a developer tool, it is strongly recommended
     11// that it is not shipped with release grade software. The advise applies to hooking methods
     12// used by DirectShowSpy in general as well.
    413
    514#pragma once

  • trunk/DirectShowSpy/FilterGraphSpy.cpp

    r231 r267  
    22// Copyright (C) Roman Ryltsov, 2008-2014
    33// Created by Roman Ryltsov roman@alax.info
     4//
     5// This source code is published to complement DirectShowSpy developer powertoy
     6// and demonstrate the internal use of APIs and tricks powering the tool. It is
     7// allowed to freely re-use the portions of the code in other projects, commercial or otherwise
     8// (provided that you don’t pretend that you wrote the original tool).
     9//
     10// Please keep in mind that DirectShowSpy is a developer tool, it is strongly recommended
     11// that it is not shipped with release grade software. The advise applies to hooking methods
     12// used by DirectShowSpy in general as well.
    413
    514#include "stdafx.h"

  • trunk/DirectShowSpy/FilterGraphSpy.h

    r266 r267  
    11////////////////////////////////////////////////////////////
    2 // Copyright (C) Roman Ryltsov, 2008-2011
     2// Copyright (C) Roman Ryltsov, 2008-2014
    33// Created by Roman Ryltsov roman@alax.info
     4//
     5// This source code is published to complement DirectShowSpy developer powertoy
     6// and demonstrate the internal use of APIs and tricks powering the tool. It is
     7// allowed to freely re-use the portions of the code in other projects, commercial or otherwise
     8// (provided that you don’t pretend that you wrote the original tool).
     9//
     10// Please keep in mind that DirectShowSpy is a developer tool, it is strongly recommended
     11// that it is not shipped with release grade software. The advise applies to hooking methods
     12// used by DirectShowSpy in general as well.
    413
    514#pragma once

  • trunk/DirectShowSpy/FilterMapperSpy.h

    r196 r267  
    11////////////////////////////////////////////////////////////
    2 // Copyright (C) Roman Ryltsov, 2008-2011
     2// Copyright (C) Roman Ryltsov, 2008-2014
    33// Created by Roman Ryltsov roman@alax.info
     4//
     5// This source code is published to complement DirectShowSpy developer powertoy
     6// and demonstrate the internal use of APIs and tricks powering the tool. It is
     7// allowed to freely re-use the portions of the code in other projects, commercial or otherwise
     8// (provided that you don’t pretend that you wrote the original tool).
     9//
     10// Please keep in mind that DirectShowSpy is a developer tool, it is strongly recommended
     11// that it is not shipped with release grade software. The advise applies to hooking methods
     12// used by DirectShowSpy in general as well.
    413
    514#pragma once

  • trunk/DirectShowSpy/GraphBuilderCallbackPropertySheet.h

    r256 r267  
    22// Copyright (C) Roman Ryltsov, 2008-2014
    33// Created by Roman Ryltsov roman@alax.info
     4//
     5// This source code is published to complement DirectShowSpy developer powertoy
     6// and demonstrate the internal use of APIs and tricks powering the tool. It is
     7// allowed to freely re-use the portions of the code in other projects, commercial or otherwise
     8// (provided that you don’t pretend that you wrote the original tool).
     9//
     10// Please keep in mind that DirectShowSpy is a developer tool, it is strongly recommended
     11// that it is not shipped with release grade software. The advise applies to hooking methods
     12// used by DirectShowSpy in general as well.
    413
    514#pragma once

  • trunk/DirectShowSpy/Helper.cpp

    r242 r267  
    22// Copyright (C) Roman Ryltsov, 2008-2014
    33// Created by Roman Ryltsov roman@alax.info
     4//
     5// This source code is published to complement DirectShowSpy developer powertoy
     6// and demonstrate the internal use of APIs and tricks powering the tool. It is
     7// allowed to freely re-use the portions of the code in other projects, commercial or otherwise
     8// (provided that you don’t pretend that you wrote the original tool).
     9//
     10// Please keep in mind that DirectShowSpy is a developer tool, it is strongly recommended
     11// that it is not shipped with release grade software. The advise applies to hooking methods
     12// used by DirectShowSpy in general as well.
    413
    514#include "stdafx.h"

  • trunk/DirectShowSpy/PropertyBag.h

    r266 r267  
    22// Copyright (C) Roman Ryltsov, 2008-2014
    33// Created by Roman Ryltsov roman@alax.info
     4//
     5// This source code is published to complement DirectShowSpy developer powertoy
     6// and demonstrate the internal use of APIs and tricks powering the tool. It is
     7// allowed to freely re-use the portions of the code in other projects, commercial or otherwise
     8// (provided that you don’t pretend that you wrote the original tool).
     9//
     10// Please keep in mind that DirectShowSpy is a developer tool, it is strongly recommended
     11// that it is not shipped with release grade software. The advise applies to hooking methods
     12// used by DirectShowSpy in general as well.
    413
    514#pragma once

  • trunk/DirectShowSpy/SystemDeviceEnumeratorSpy.h

    r196 r267  
    11////////////////////////////////////////////////////////////
    2 // Copyright (C) Roman Ryltsov, 2008-2011
     2// Copyright (C) Roman Ryltsov, 2008-2014
    33// Created by Roman Ryltsov roman@alax.info
     4//
     5// This source code is published to complement DirectShowSpy developer powertoy
     6// and demonstrate the internal use of APIs and tricks powering the tool. It is
     7// allowed to freely re-use the portions of the code in other projects, commercial or otherwise
     8// (provided that you don’t pretend that you wrote the original tool).
     9//
     10// Please keep in mind that DirectShowSpy is a developer tool, it is strongly recommended
     11// that it is not shipped with release grade software. The advise applies to hooking methods
     12// used by DirectShowSpy in general as well.
    413
    514#pragma once

  • trunk/DirectShowSpy/dllmain.cpp

    r196 r267  
    11////////////////////////////////////////////////////////////
    2 // Copyright (C) Roman Ryltsov, 2008-2011
     2// Copyright (C) Roman Ryltsov, 2008-2014
    33// Created by Roman Ryltsov roman@alax.info
     4//
     5// This source code is published to complement DirectShowSpy developer powertoy
     6// and demonstrate the internal use of APIs and tricks powering the tool. It is
     7// allowed to freely re-use the portions of the code in other projects, commercial or otherwise
     8// (provided that you don’t pretend that you wrote the original tool).
     9//
     10// Please keep in mind that DirectShowSpy is a developer tool, it is strongly recommended
     11// that it is not shipped with release grade software. The advise applies to hooking methods
     12// used by DirectShowSpy in general as well.
    413
    514#include "stdafx.h"

  • trunk/DirectShowSpy/dllmain.h

    r196 r267  
    11////////////////////////////////////////////////////////////
    2 // Copyright (C) Roman Ryltsov, 2008-2011
     2// Copyright (C) Roman Ryltsov, 2008-2014
    33// Created by Roman Ryltsov roman@alax.info
     4//
     5// This source code is published to complement DirectShowSpy developer powertoy
     6// and demonstrate the internal use of APIs and tricks powering the tool. It is
     7// allowed to freely re-use the portions of the code in other projects, commercial or otherwise
     8// (provided that you don’t pretend that you wrote the original tool).
     9//
     10// Please keep in mind that DirectShowSpy is a developer tool, it is strongly recommended
     11// that it is not shipped with release grade software. The advise applies to hooking methods
     12// used by DirectShowSpy in general as well.
    413
    514#pragma once

  • trunk/DirectShowSpy/stdafx.cpp

    r196 r267  
    11////////////////////////////////////////////////////////////
    2 // Copyright (C) Roman Ryltsov, 2008-2011
     2// Copyright (C) Roman Ryltsov, 2008-2014
    33// Created by Roman Ryltsov roman@alax.info
     4//
     5// This source code is published to complement DirectShowSpy developer powertoy
     6// and demonstrate the internal use of APIs and tricks powering the tool. It is
     7// allowed to freely re-use the portions of the code in other projects, commercial or otherwise
     8// (provided that you don’t pretend that you wrote the original tool).
     9//
     10// Please keep in mind that DirectShowSpy is a developer tool, it is strongly recommended
     11// that it is not shipped with release grade software. The advise applies to hooking methods
     12// used by DirectShowSpy in general as well.
    413
    514#include "stdafx.h"

  • trunk/DirectShowSpy/stdafx.h

    r238 r267  
    11////////////////////////////////////////////////////////////
    2 // Copyright (C) Roman Ryltsov, 2008-2011
     2// Copyright (C) Roman Ryltsov, 2008-2014
    33// Created by Roman Ryltsov roman@alax.info
     4//
     5// This source code is published to complement DirectShowSpy developer powertoy
     6// and demonstrate the internal use of APIs and tricks powering the tool. It is
     7// allowed to freely re-use the portions of the code in other projects, commercial or otherwise
     8// (provided that you don’t pretend that you wrote the original tool).
     9//
     10// Please keep in mind that DirectShowSpy is a developer tool, it is strongly recommended
     11// that it is not shipped with release grade software. The advise applies to hooking methods
     12// used by DirectShowSpy in general as well.
    413
    514#pragma once

  • trunk/DirectShowSpy/targetver.h

    r196 r267  
    11////////////////////////////////////////////////////////////
    2 // Copyright (C) Roman Ryltsov, 2008-2011
     2// Copyright (C) Roman Ryltsov, 2008-2014
    33// Created by Roman Ryltsov roman@alax.info
     4//
     5// This source code is published to complement DirectShowSpy developer powertoy
     6// and demonstrate the internal use of APIs and tricks powering the tool. It is
     7// allowed to freely re-use the portions of the code in other projects, commercial or otherwise
     8// (provided that you don’t pretend that you wrote the original tool).
     9//
     10// Please keep in mind that DirectShowSpy is a developer tool, it is strongly recommended
     11// that it is not shipped with release grade software. The advise applies to hooking methods
     12// used by DirectShowSpy in general as well.
    413
    514#pragma once
Note: See TracChangeset for help on using the changeset viewer.