crypto/weakcrypto/source/cryptoswitch/cryptography_stubs.h
changeset 72 de46a57f75fb
equal deleted inserted replaced
65:970c0057d9bc 72:de46a57f75fb
       
     1 /*
       
     2 * Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies).
       
     3 * All rights reserved.
       
     4 * This component and the accompanying materials are made available
       
     5 * under the terms of the License "Eclipse Public License v1.0"
       
     6 * which accompanies this distribution, and is available
       
     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".
       
     8 *
       
     9 * Initial Contributors:
       
    10 * Nokia Corporation - initial contribution.
       
    11 *
       
    12 * Contributors:
       
    13 *
       
    14 * Description: 
       
    15 * Generated from cryptographyU.def
       
    16 *
       
    17 */
       
    18 
       
    19 
       
    20 
       
    21 
       
    22 /**
       
    23  @file
       
    24  @internalComponent 
       
    25 */
       
    26 
       
    27 extern "C" {
       
    28 
       
    29 void common_dispatch();
       
    30 
       
    31 	
       
    32 __declspec(dllexport)
       
    33 __declspec(naked)
       
    34 void call_vector_1 ()
       
    35 	{
       
    36 	// ; protected: __thiscall CBlockChainingMode::CBlockChainingMode(void)
       
    37 	_asm mov eax, 1
       
    38 	_asm jmp common_dispatch
       
    39 	}
       
    40 
       
    41 	
       
    42 __declspec(dllexport)
       
    43 __declspec(naked)
       
    44 void call_vector_2 ()
       
    45 	{
       
    46 	// ; protected: __thiscall CDH::CDH(class CDHPrivateKey const &)
       
    47 	_asm mov eax, 2
       
    48 	_asm jmp common_dispatch
       
    49 	}
       
    50 
       
    51 	
       
    52 __declspec(dllexport)
       
    53 __declspec(naked)
       
    54 void call_vector_3 ()
       
    55 	{
       
    56 	// ; protected: __thiscall CDHKeyPair::CDHKeyPair(void)
       
    57 	_asm mov eax, 3
       
    58 	_asm jmp common_dispatch
       
    59 	}
       
    60 
       
    61 	
       
    62 __declspec(dllexport)
       
    63 __declspec(naked)
       
    64 void call_vector_4 ()
       
    65 	{
       
    66 	// ; protected: __thiscall CDHParameters::CDHParameters(class RInteger &,class RInteger &)
       
    67 	_asm mov eax, 4
       
    68 	_asm jmp common_dispatch
       
    69 	}
       
    70 
       
    71 	
       
    72 __declspec(dllexport)
       
    73 __declspec(naked)
       
    74 void call_vector_5 ()
       
    75 	{
       
    76 	// ; protected: __thiscall CDHParameters::CDHParameters(void)
       
    77 	_asm mov eax, 5
       
    78 	_asm jmp common_dispatch
       
    79 	}
       
    80 
       
    81 	
       
    82 __declspec(dllexport)
       
    83 __declspec(naked)
       
    84 void call_vector_6 ()
       
    85 	{
       
    86 	// ; protected: __thiscall CDHPrivateKey::CDHPrivateKey(class RInteger &,class RInteger &,class RInteger &)
       
    87 	_asm mov eax, 6
       
    88 	_asm jmp common_dispatch
       
    89 	}
       
    90 
       
    91 	
       
    92 __declspec(dllexport)
       
    93 __declspec(naked)
       
    94 void call_vector_7 ()
       
    95 	{
       
    96 	// ; protected: __thiscall CDHPrivateKey::CDHPrivateKey(void)
       
    97 	_asm mov eax, 7
       
    98 	_asm jmp common_dispatch
       
    99 	}
       
   100 
       
   101 	
       
   102 __declspec(dllexport)
       
   103 __declspec(naked)
       
   104 void call_vector_8 ()
       
   105 	{
       
   106 	// ; protected: __thiscall CDHPublicKey::CDHPublicKey(class RInteger &,class RInteger &,class RInteger &)
       
   107 	_asm mov eax, 8
       
   108 	_asm jmp common_dispatch
       
   109 	}
       
   110 
       
   111 	
       
   112 __declspec(dllexport)
       
   113 __declspec(naked)
       
   114 void call_vector_9 ()
       
   115 	{
       
   116 	// ; protected: __thiscall CDHPublicKey::CDHPublicKey(void)
       
   117 	_asm mov eax, 9
       
   118 	_asm jmp common_dispatch
       
   119 	}
       
   120 
       
   121 	
       
   122 __declspec(dllexport)
       
   123 __declspec(naked)
       
   124 void call_vector_10 ()
       
   125 	{
       
   126 	// ; protected: __thiscall CDSAKeyPair::CDSAKeyPair(void)
       
   127 	_asm mov eax, 10
       
   128 	_asm jmp common_dispatch
       
   129 	}
       
   130 
       
   131 	
       
   132 __declspec(dllexport)
       
   133 __declspec(naked)
       
   134 void call_vector_11 ()
       
   135 	{
       
   136 	// ; protected: __thiscall CDSAParameters::CDSAParameters(class RInteger &,class RInteger &,class RInteger &)
       
   137 	_asm mov eax, 11
       
   138 	_asm jmp common_dispatch
       
   139 	}
       
   140 
       
   141 	
       
   142 __declspec(dllexport)
       
   143 __declspec(naked)
       
   144 void call_vector_12 ()
       
   145 	{
       
   146 	// ; protected: __thiscall CDSAParameters::CDSAParameters(void)
       
   147 	_asm mov eax, 12
       
   148 	_asm jmp common_dispatch
       
   149 	}
       
   150 
       
   151 	
       
   152 __declspec(dllexport)
       
   153 __declspec(naked)
       
   154 void call_vector_13 ()
       
   155 	{
       
   156 	// ; protected: __thiscall CDSAPrimeCertificate::CDSAPrimeCertificate(unsigned int)
       
   157 	_asm mov eax, 13
       
   158 	_asm jmp common_dispatch
       
   159 	}
       
   160 
       
   161 	
       
   162 __declspec(dllexport)
       
   163 __declspec(naked)
       
   164 void call_vector_14 ()
       
   165 	{
       
   166 	// ; protected: __thiscall CDSAPrimeCertificate::CDSAPrimeCertificate(void)
       
   167 	_asm mov eax, 14
       
   168 	_asm jmp common_dispatch
       
   169 	}
       
   170 
       
   171 	
       
   172 __declspec(dllexport)
       
   173 __declspec(naked)
       
   174 void call_vector_15 ()
       
   175 	{
       
   176 	// ; protected: __thiscall CDSAPrivateKey::CDSAPrivateKey(class RInteger &,class RInteger &,class RInteger &,class RInteger &)
       
   177 	_asm mov eax, 15
       
   178 	_asm jmp common_dispatch
       
   179 	}
       
   180 
       
   181 	
       
   182 __declspec(dllexport)
       
   183 __declspec(naked)
       
   184 void call_vector_16 ()
       
   185 	{
       
   186 	// ; protected: __thiscall CDSAPrivateKey::CDSAPrivateKey(void)
       
   187 	_asm mov eax, 16
       
   188 	_asm jmp common_dispatch
       
   189 	}
       
   190 
       
   191 	
       
   192 __declspec(dllexport)
       
   193 __declspec(naked)
       
   194 void call_vector_17 ()
       
   195 	{
       
   196 	// ; protected: __thiscall CDSAPublicKey::CDSAPublicKey(class RInteger &,class RInteger &,class RInteger &,class RInteger &)
       
   197 	_asm mov eax, 17
       
   198 	_asm jmp common_dispatch
       
   199 	}
       
   200 
       
   201 	
       
   202 __declspec(dllexport)
       
   203 __declspec(naked)
       
   204 void call_vector_18 ()
       
   205 	{
       
   206 	// ; protected: __thiscall CDSAPublicKey::CDSAPublicKey(void)
       
   207 	_asm mov eax, 18
       
   208 	_asm jmp common_dispatch
       
   209 	}
       
   210 
       
   211 	
       
   212 __declspec(dllexport)
       
   213 __declspec(naked)
       
   214 void call_vector_19 ()
       
   215 	{
       
   216 	// ; protected: __thiscall CDSASignature::CDSASignature(class RInteger &,class RInteger &)
       
   217 	_asm mov eax, 19
       
   218 	_asm jmp common_dispatch
       
   219 	}
       
   220 
       
   221 	
       
   222 __declspec(dllexport)
       
   223 __declspec(naked)
       
   224 void call_vector_20 ()
       
   225 	{
       
   226 	// ; protected: __thiscall CDSASignature::CDSASignature(void)
       
   227 	_asm mov eax, 20
       
   228 	_asm jmp common_dispatch
       
   229 	}
       
   230 
       
   231 	
       
   232 __declspec(dllexport)
       
   233 __declspec(naked)
       
   234 void call_vector_21 ()
       
   235 	{
       
   236 	// ; protected: __thiscall CPadding::CPadding(int)
       
   237 	_asm mov eax, 21
       
   238 	_asm jmp common_dispatch
       
   239 	}
       
   240 
       
   241 	
       
   242 __declspec(dllexport)
       
   243 __declspec(naked)
       
   244 void call_vector_22 ()
       
   245 	{
       
   246 	// ; protected: __thiscall CPaddingNone::CPaddingNone(int)
       
   247 	_asm mov eax, 22
       
   248 	_asm jmp common_dispatch
       
   249 	}
       
   250 
       
   251 	
       
   252 __declspec(dllexport)
       
   253 __declspec(naked)
       
   254 void call_vector_23 ()
       
   255 	{
       
   256 	// ; protected: __thiscall CPaddingPKCS1Encryption::CPaddingPKCS1Encryption(int)
       
   257 	_asm mov eax, 23
       
   258 	_asm jmp common_dispatch
       
   259 	}
       
   260 
       
   261 	
       
   262 __declspec(dllexport)
       
   263 __declspec(naked)
       
   264 void call_vector_24 ()
       
   265 	{
       
   266 	// ; protected: __thiscall CPaddingPKCS1Signature::CPaddingPKCS1Signature(int)
       
   267 	_asm mov eax, 24
       
   268 	_asm jmp common_dispatch
       
   269 	}
       
   270 
       
   271 	
       
   272 __declspec(dllexport)
       
   273 __declspec(naked)
       
   274 void call_vector_25 ()
       
   275 	{
       
   276 	// ; protected: __thiscall CPaddingSSLv3::CPaddingSSLv3(int)
       
   277 	_asm mov eax, 25
       
   278 	_asm jmp common_dispatch
       
   279 	}
       
   280 
       
   281 	
       
   282 __declspec(dllexport)
       
   283 __declspec(naked)
       
   284 void call_vector_26 ()
       
   285 	{
       
   286 	// ; protected: __thiscall CRSAKeyPair::CRSAKeyPair(void)
       
   287 	_asm mov eax, 26
       
   288 	_asm jmp common_dispatch
       
   289 	}
       
   290 
       
   291 	
       
   292 __declspec(dllexport)
       
   293 __declspec(naked)
       
   294 void call_vector_27 ()
       
   295 	{
       
   296 	// ; protected: __thiscall CRSAParameters::CRSAParameters(class RInteger &)
       
   297 	_asm mov eax, 27
       
   298 	_asm jmp common_dispatch
       
   299 	}
       
   300 
       
   301 	
       
   302 __declspec(dllexport)
       
   303 __declspec(naked)
       
   304 void call_vector_28 ()
       
   305 	{
       
   306 	// ; protected: __thiscall CRSAParameters::CRSAParameters(void)
       
   307 	_asm mov eax, 28
       
   308 	_asm jmp common_dispatch
       
   309 	}
       
   310 
       
   311 	
       
   312 __declspec(dllexport)
       
   313 __declspec(naked)
       
   314 void call_vector_29 ()
       
   315 	{
       
   316 	// ; protected: __thiscall CRSAPrivateKeyCRT::CRSAPrivateKeyCRT(class RInteger &,class RInteger &,class RInteger &,class RInteger &,class RInteger &,class RInteger &)
       
   317 	_asm mov eax, 29
       
   318 	_asm jmp common_dispatch
       
   319 	}
       
   320 
       
   321 	
       
   322 __declspec(dllexport)
       
   323 __declspec(naked)
       
   324 void call_vector_30 ()
       
   325 	{
       
   326 	// ; protected: __thiscall CRSAPrivateKeyStandard::CRSAPrivateKeyStandard(class RInteger &,class RInteger &)
       
   327 	_asm mov eax, 30
       
   328 	_asm jmp common_dispatch
       
   329 	}
       
   330 
       
   331 	
       
   332 __declspec(dllexport)
       
   333 __declspec(naked)
       
   334 void call_vector_31 ()
       
   335 	{
       
   336 	// ; protected: __thiscall CRSAPublicKey::CRSAPublicKey(class RInteger &,class RInteger &)
       
   337 	_asm mov eax, 31
       
   338 	_asm jmp common_dispatch
       
   339 	}
       
   340 
       
   341 	
       
   342 __declspec(dllexport)
       
   343 __declspec(naked)
       
   344 void call_vector_32 ()
       
   345 	{
       
   346 	// ; protected: __thiscall CRSAPublicKey::CRSAPublicKey(void)
       
   347 	_asm mov eax, 32
       
   348 	_asm jmp common_dispatch
       
   349 	}
       
   350 
       
   351 	
       
   352 __declspec(dllexport)
       
   353 __declspec(naked)
       
   354 void call_vector_33 ()
       
   355 	{
       
   356 	// ; protected: __thiscall CRSASignature::CRSASignature(class RInteger &)
       
   357 	_asm mov eax, 33
       
   358 	_asm jmp common_dispatch
       
   359 	}
       
   360 
       
   361 	
       
   362 __declspec(dllexport)
       
   363 __declspec(naked)
       
   364 void call_vector_34 ()
       
   365 	{
       
   366 	// ; protected: __thiscall CRijndael::CRijndael(void)
       
   367 	_asm mov eax, 34
       
   368 	_asm jmp common_dispatch
       
   369 	}
       
   370 
       
   371 	
       
   372 __declspec(dllexport)
       
   373 __declspec(naked)
       
   374 void call_vector_35 ()
       
   375 	{
       
   376 	// ; protected: __thiscall MCryptoSystem::MCryptoSystem(void)
       
   377 	_asm mov eax, 35
       
   378 	_asm jmp common_dispatch
       
   379 	}
       
   380 
       
   381 	
       
   382 __declspec(dllexport)
       
   383 __declspec(naked)
       
   384 void call_vector_36 ()
       
   385 	{
       
   386 	// ; protected: __thiscall CDecryptor::CDecryptor(void)
       
   387 	_asm mov eax, 36
       
   388 	_asm jmp common_dispatch
       
   389 	}
       
   390 
       
   391 	
       
   392 __declspec(dllexport)
       
   393 __declspec(naked)
       
   394 void call_vector_37 ()
       
   395 	{
       
   396 	// ; protected: __thiscall CEncryptor::CEncryptor(void)
       
   397 	_asm mov eax, 37
       
   398 	_asm jmp common_dispatch
       
   399 	}
       
   400 
       
   401 	
       
   402 __declspec(dllexport)
       
   403 __declspec(naked)
       
   404 void call_vector_38 ()
       
   405 	{
       
   406 	// ; protected: __thiscall MSignatureSystem::MSignatureSystem(void)
       
   407 	_asm mov eax, 38
       
   408 	_asm jmp common_dispatch
       
   409 	}
       
   410 
       
   411 	
       
   412 __declspec(dllexport)
       
   413 __declspec(naked)
       
   414 void call_vector_39 ()
       
   415 	{
       
   416 	// ; public: __thiscall RInteger::RInteger(void)
       
   417 	_asm mov eax, 39
       
   418 	_asm jmp common_dispatch
       
   419 	}
       
   420 
       
   421 	
       
   422 __declspec(dllexport)
       
   423 __declspec(naked)
       
   424 void call_vector_40 ()
       
   425 	{
       
   426 	// ; protected: __thiscall TInteger::TInteger(void)
       
   427 	_asm mov eax, 40
       
   428 	_asm jmp common_dispatch
       
   429 	}
       
   430 
       
   431 	
       
   432 __declspec(dllexport)
       
   433 __declspec(naked)
       
   434 void call_vector_41 ()
       
   435 	{
       
   436 	// ; protected: virtual __thiscall CBlockChainingMode::~CBlockChainingMode(void)
       
   437 	_asm mov eax, 41
       
   438 	_asm jmp common_dispatch
       
   439 	}
       
   440 
       
   441 	
       
   442 __declspec(dllexport)
       
   443 __declspec(naked)
       
   444 void call_vector_42 ()
       
   445 	{
       
   446 	// ; public: virtual __thiscall CBufferedTransformation::~CBufferedTransformation(void)
       
   447 	_asm mov eax, 42
       
   448 	_asm jmp common_dispatch
       
   449 	}
       
   450 
       
   451 	
       
   452 __declspec(dllexport)
       
   453 __declspec(naked)
       
   454 void call_vector_43 ()
       
   455 	{
       
   456 	// ; public: virtual __thiscall CDHKeyPair::~CDHKeyPair(void)
       
   457 	_asm mov eax, 43
       
   458 	_asm jmp common_dispatch
       
   459 	}
       
   460 
       
   461 	
       
   462 __declspec(dllexport)
       
   463 __declspec(naked)
       
   464 void call_vector_44 ()
       
   465 	{
       
   466 	// ; public: virtual __thiscall CDHParameters::~CDHParameters(void)
       
   467 	_asm mov eax, 44
       
   468 	_asm jmp common_dispatch
       
   469 	}
       
   470 
       
   471 	
       
   472 __declspec(dllexport)
       
   473 __declspec(naked)
       
   474 void call_vector_45 ()
       
   475 	{
       
   476 	// ; public: virtual __thiscall CDHPrivateKey::~CDHPrivateKey(void)
       
   477 	_asm mov eax, 45
       
   478 	_asm jmp common_dispatch
       
   479 	}
       
   480 
       
   481 	
       
   482 __declspec(dllexport)
       
   483 __declspec(naked)
       
   484 void call_vector_46 ()
       
   485 	{
       
   486 	// ; public: virtual __thiscall CDHPublicKey::~CDHPublicKey(void)
       
   487 	_asm mov eax, 46
       
   488 	_asm jmp common_dispatch
       
   489 	}
       
   490 
       
   491 	
       
   492 __declspec(dllexport)
       
   493 __declspec(naked)
       
   494 void call_vector_47 ()
       
   495 	{
       
   496 	// ; public: virtual __thiscall CDSAKeyPair::~CDSAKeyPair(void)
       
   497 	_asm mov eax, 47
       
   498 	_asm jmp common_dispatch
       
   499 	}
       
   500 
       
   501 	
       
   502 __declspec(dllexport)
       
   503 __declspec(naked)
       
   504 void call_vector_48 ()
       
   505 	{
       
   506 	// ; public: virtual __thiscall CDSAParameters::~CDSAParameters(void)
       
   507 	_asm mov eax, 48
       
   508 	_asm jmp common_dispatch
       
   509 	}
       
   510 
       
   511 	
       
   512 __declspec(dllexport)
       
   513 __declspec(naked)
       
   514 void call_vector_49 ()
       
   515 	{
       
   516 	// ; public: virtual __thiscall CDSAPrimeCertificate::~CDSAPrimeCertificate(void)
       
   517 	_asm mov eax, 49
       
   518 	_asm jmp common_dispatch
       
   519 	}
       
   520 
       
   521 	
       
   522 __declspec(dllexport)
       
   523 __declspec(naked)
       
   524 void call_vector_50 ()
       
   525 	{
       
   526 	// ; public: virtual __thiscall CDSAPrivateKey::~CDSAPrivateKey(void)
       
   527 	_asm mov eax, 50
       
   528 	_asm jmp common_dispatch
       
   529 	}
       
   530 
       
   531 	
       
   532 __declspec(dllexport)
       
   533 __declspec(naked)
       
   534 void call_vector_51 ()
       
   535 	{
       
   536 	// ; public: virtual __thiscall CDSAPublicKey::~CDSAPublicKey(void)
       
   537 	_asm mov eax, 51
       
   538 	_asm jmp common_dispatch
       
   539 	}
       
   540 
       
   541 	
       
   542 __declspec(dllexport)
       
   543 __declspec(naked)
       
   544 void call_vector_52 ()
       
   545 	{
       
   546 	// ; public: virtual __thiscall CDSASignature::~CDSASignature(void)
       
   547 	_asm mov eax, 52
       
   548 	_asm jmp common_dispatch
       
   549 	}
       
   550 
       
   551 	
       
   552 __declspec(dllexport)
       
   553 __declspec(naked)
       
   554 void call_vector_53 ()
       
   555 	{
       
   556 	// ; public: virtual __thiscall CRSAKeyPair::~CRSAKeyPair(void)
       
   557 	_asm mov eax, 53
       
   558 	_asm jmp common_dispatch
       
   559 	}
       
   560 
       
   561 	
       
   562 __declspec(dllexport)
       
   563 __declspec(naked)
       
   564 void call_vector_54 ()
       
   565 	{
       
   566 	// ; public: virtual __thiscall CRSAParameters::~CRSAParameters(void)
       
   567 	_asm mov eax, 54
       
   568 	_asm jmp common_dispatch
       
   569 	}
       
   570 
       
   571 	
       
   572 __declspec(dllexport)
       
   573 __declspec(naked)
       
   574 void call_vector_55 ()
       
   575 	{
       
   576 	// ; public: virtual __thiscall CRSAPrivateKeyCRT::~CRSAPrivateKeyCRT(void)
       
   577 	_asm mov eax, 55
       
   578 	_asm jmp common_dispatch
       
   579 	}
       
   580 
       
   581 	
       
   582 __declspec(dllexport)
       
   583 __declspec(naked)
       
   584 void call_vector_56 ()
       
   585 	{
       
   586 	// ; public: virtual __thiscall CRSAPrivateKeyStandard::~CRSAPrivateKeyStandard(void)
       
   587 	_asm mov eax, 56
       
   588 	_asm jmp common_dispatch
       
   589 	}
       
   590 
       
   591 	
       
   592 __declspec(dllexport)
       
   593 __declspec(naked)
       
   594 void call_vector_57 ()
       
   595 	{
       
   596 	// ; public: virtual __thiscall CRSAPublicKey::~CRSAPublicKey(void)
       
   597 	_asm mov eax, 57
       
   598 	_asm jmp common_dispatch
       
   599 	}
       
   600 
       
   601 	
       
   602 __declspec(dllexport)
       
   603 __declspec(naked)
       
   604 void call_vector_58 ()
       
   605 	{
       
   606 	// ; public: virtual __thiscall CRSASignature::~CRSASignature(void)
       
   607 	_asm mov eax, 58
       
   608 	_asm jmp common_dispatch
       
   609 	}
       
   610 
       
   611 	
       
   612 __declspec(dllexport)
       
   613 __declspec(naked)
       
   614 void call_vector_59 ()
       
   615 	{
       
   616 	// ; public: virtual __thiscall CRijndael::~CRijndael(void)
       
   617 	_asm mov eax, 59
       
   618 	_asm jmp common_dispatch
       
   619 	}
       
   620 
       
   621 	
       
   622 __declspec(dllexport)
       
   623 __declspec(naked)
       
   624 void call_vector_60 ()
       
   625 	{
       
   626 	// ; public: int __thiscall TInteger::operator!(void)const 
       
   627 	_asm mov eax, 60
       
   628 	_asm jmp common_dispatch
       
   629 	}
       
   630 
       
   631 	
       
   632 __declspec(dllexport)
       
   633 __declspec(naked)
       
   634 void call_vector_61 ()
       
   635 	{
       
   636 	// ; public: int __thiscall CDSASignature::operator==(class CDSASignature const &)const 
       
   637 	_asm mov eax, 61
       
   638 	_asm jmp common_dispatch
       
   639 	}
       
   640 
       
   641 	
       
   642 __declspec(dllexport)
       
   643 __declspec(naked)
       
   644 void call_vector_62 ()
       
   645 	{
       
   646 	// ; public: int __thiscall CRSASignature::operator==(class CRSASignature const &)const 
       
   647 	_asm mov eax, 62
       
   648 	_asm jmp common_dispatch
       
   649 	}
       
   650 
       
   651 	
       
   652 __declspec(dllexport)
       
   653 __declspec(naked)
       
   654 void call_vector_63 ()
       
   655 	{
       
   656 	// ; public: __thiscall RInteger::operator class TCleanupItem(void)
       
   657 	_asm mov eax, 63
       
   658 	_asm jmp common_dispatch
       
   659 	}
       
   660 
       
   661 	
       
   662 __declspec(dllexport)
       
   663 __declspec(naked)
       
   664 void call_vector_64 ()
       
   665 	{
       
   666 	// ; public: class HBufC8 const * __thiscall CDH::AgreeL(class CDHPublicKey const &)const 
       
   667 	_asm mov eax, 64
       
   668 	_asm jmp common_dispatch
       
   669 	}
       
   670 
       
   671 	
       
   672 __declspec(dllexport)
       
   673 __declspec(naked)
       
   674 void call_vector_65 ()
       
   675 	{
       
   676 	// ; public: unsigned int __thiscall TInteger::BitCount(void)const 
       
   677 	_asm mov eax, 65
       
   678 	_asm jmp common_dispatch
       
   679 	}
       
   680 
       
   681 	
       
   682 __declspec(dllexport)
       
   683 __declspec(naked)
       
   684 void call_vector_66 ()
       
   685 	{
       
   686 	// ; public: int __thiscall CPadding::BlockSize(void)const 
       
   687 	_asm mov eax, 66
       
   688 	_asm jmp common_dispatch
       
   689 	}
       
   690 
       
   691 	
       
   692 __declspec(dllexport)
       
   693 __declspec(naked)
       
   694 void call_vector_67 ()
       
   695 	{
       
   696 	// ; public: virtual int __thiscall CStreamCipher::BlockSize(void)const 
       
   697 	_asm mov eax, 67
       
   698 	_asm jmp common_dispatch
       
   699 	}
       
   700 
       
   701 	
       
   702 __declspec(dllexport)
       
   703 __declspec(naked)
       
   704 void call_vector_68 ()
       
   705 	{
       
   706 	// ; public: class CBlockTransformation * __thiscall CBufferedTransformation::BlockTransformer(void)const 
       
   707 	_asm mov eax, 68
       
   708 	_asm jmp common_dispatch
       
   709 	}
       
   710 
       
   711 	
       
   712 __declspec(dllexport)
       
   713 __declspec(naked)
       
   714 void call_vector_69 ()
       
   715 	{
       
   716 	// ; public: class HBufC8 * __thiscall TInteger::BufferLC(void)const 
       
   717 	_asm mov eax, 69
       
   718 	_asm jmp common_dispatch
       
   719 	}
       
   720 
       
   721 	
       
   722 __declspec(dllexport)
       
   723 __declspec(naked)
       
   724 void call_vector_70 ()
       
   725 	{
       
   726 	// ; public: unsigned int __thiscall TInteger::ByteCount(void)const 
       
   727 	_asm mov eax, 70
       
   728 	_asm jmp common_dispatch
       
   729 	}
       
   730 
       
   731 	
       
   732 __declspec(dllexport)
       
   733 __declspec(naked)
       
   734 void call_vector_71 ()
       
   735 	{
       
   736 	// ; public: static void __cdecl RInteger::CallClose(void *)
       
   737 	_asm mov eax, 71
       
   738 	_asm jmp common_dispatch
       
   739 	}
       
   740 
       
   741 	
       
   742 __declspec(dllexport)
       
   743 __declspec(naked)
       
   744 void call_vector_72 ()
       
   745 	{
       
   746 	// ; public: void __thiscall RInteger::Close(void)
       
   747 	_asm mov eax, 72
       
   748 	_asm jmp common_dispatch
       
   749 	}
       
   750 
       
   751 	
       
   752 __declspec(dllexport)
       
   753 __declspec(naked)
       
   754 void call_vector_73 ()
       
   755 	{
       
   756 	// ; protected: void __thiscall CBlockChainingMode::ConstructL(class CBlockTransformation *,class TDesC8 const &)
       
   757 	_asm mov eax, 73
       
   758 	_asm jmp common_dispatch
       
   759 	}
       
   760 
       
   761 	
       
   762 __declspec(dllexport)
       
   763 __declspec(naked)
       
   764 void call_vector_74 ()
       
   765 	{
       
   766 	// ; protected: void __thiscall CDHKeyPair::ConstructL(class RInteger &,class RInteger &,class RInteger &)
       
   767 	_asm mov eax, 74
       
   768 	_asm jmp common_dispatch
       
   769 	}
       
   770 
       
   771 	
       
   772 __declspec(dllexport)
       
   773 __declspec(naked)
       
   774 void call_vector_75 ()
       
   775 	{
       
   776 	// ; protected: void __thiscall CDHKeyPair::ConstructL(class RInteger &,class RInteger &)
       
   777 	_asm mov eax, 75
       
   778 	_asm jmp common_dispatch
       
   779 	}
       
   780 
       
   781 	
       
   782 __declspec(dllexport)
       
   783 __declspec(naked)
       
   784 void call_vector_76 ()
       
   785 	{
       
   786 	// ; public: unsigned int __thiscall CDSAPrimeCertificate::Counter(void)const 
       
   787 	_asm mov eax, 76
       
   788 	_asm jmp common_dispatch
       
   789 	}
       
   790 
       
   791 	
       
   792 __declspec(dllexport)
       
   793 __declspec(naked)
       
   794 void call_vector_77 ()
       
   795 	{
       
   796 	// ; public: class TInteger const & __thiscall CRSAPrivateKeyStandard::D(void)const 
       
   797 	_asm mov eax, 77
       
   798 	_asm jmp common_dispatch
       
   799 	}
       
   800 
       
   801 	
       
   802 __declspec(dllexport)
       
   803 __declspec(naked)
       
   804 void call_vector_78 ()
       
   805 	{
       
   806 	// ; public: class TInteger const & __thiscall CRSAPrivateKeyCRT::DP(void)const 
       
   807 	_asm mov eax, 78
       
   808 	_asm jmp common_dispatch
       
   809 	}
       
   810 
       
   811 	
       
   812 __declspec(dllexport)
       
   813 __declspec(naked)
       
   814 void call_vector_79 ()
       
   815 	{
       
   816 	// ; public: class TInteger const & __thiscall CRSAPrivateKeyCRT::DQ(void)const 
       
   817 	_asm mov eax, 79
       
   818 	_asm jmp common_dispatch
       
   819 	}
       
   820 
       
   821 	
       
   822 __declspec(dllexport)
       
   823 __declspec(naked)
       
   824 void call_vector_80 ()
       
   825 	{
       
   826 	// ; public: class TInteger const & __thiscall CRSAPublicKey::E(void)const 
       
   827 	_asm mov eax, 80
       
   828 	_asm jmp common_dispatch
       
   829 	}
       
   830 
       
   831 	
       
   832 __declspec(dllexport)
       
   833 __declspec(naked)
       
   834 void call_vector_81 ()
       
   835 	{
       
   836 	// ; public: class TInteger const & __thiscall CDHParameters::G(void)const 
       
   837 	_asm mov eax, 81
       
   838 	_asm jmp common_dispatch
       
   839 	}
       
   840 
       
   841 	
       
   842 __declspec(dllexport)
       
   843 __declspec(naked)
       
   844 void call_vector_82 ()
       
   845 	{
       
   846 	// ; public: class TInteger const & __thiscall CDSAParameters::G(void)const 
       
   847 	_asm mov eax, 82
       
   848 	_asm jmp common_dispatch
       
   849 	}
       
   850 
       
   851 	
       
   852 __declspec(dllexport)
       
   853 __declspec(naked)
       
   854 void call_vector_83 ()
       
   855 	{
       
   856 	// ; protected: __thiscall CRSASigner::CRSASigner(void)
       
   857 	_asm mov eax, 83
       
   858 	_asm jmp common_dispatch
       
   859 	}
       
   860 
       
   861 	
       
   862 __declspec(dllexport)
       
   863 __declspec(naked)
       
   864 void call_vector_84 ()
       
   865 	{
       
   866 	// ; public: virtual int __thiscall CStreamCipher::MaxFinalOutputLength(int)const 
       
   867 	_asm mov eax, 84
       
   868 	_asm jmp common_dispatch
       
   869 	}
       
   870 
       
   871 	
       
   872 __declspec(dllexport)
       
   873 __declspec(naked)
       
   874 void call_vector_85 ()
       
   875 	{
       
   876 	// ; protected: __thiscall CRSAVerifier::CRSAVerifier(void)
       
   877 	_asm mov eax, 85
       
   878 	_asm jmp common_dispatch
       
   879 	}
       
   880 
       
   881 	
       
   882 __declspec(dllexport)
       
   883 __declspec(naked)
       
   884 void call_vector_86 ()
       
   885 	{
       
   886 	// ; public virtual int CRSAVerifer::VerifyL(class TDesC8 const &,class CRSASignature const &)const
       
   887 	_asm mov eax, 86
       
   888 	_asm jmp common_dispatch
       
   889 	}
       
   890 
       
   891 	
       
   892 __declspec(dllexport)
       
   893 __declspec(naked)
       
   894 void call_vector_87 ()
       
   895 	{
       
   896 	// ; public: virtual int __thiscall CStreamCipher::MaxOutputLength(int)const 
       
   897 	_asm mov eax, 87
       
   898 	_asm jmp common_dispatch
       
   899 	}
       
   900 
       
   901 	
       
   902 __declspec(dllexport)
       
   903 __declspec(naked)
       
   904 void call_vector_88 ()
       
   905 	{
       
   906 	// ; public: virtual int __thiscall CPadding::MaxPaddedLength(int)const 
       
   907 	_asm mov eax, 88
       
   908 	_asm jmp common_dispatch
       
   909 	}
       
   910 
       
   911 	
       
   912 __declspec(dllexport)
       
   913 __declspec(naked)
       
   914 void call_vector_89 ()
       
   915 	{
       
   916 	// ; public: virtual int __thiscall CPadding::MaxUnPaddedLength(int)const 
       
   917 	_asm mov eax, 89
       
   918 	_asm jmp common_dispatch
       
   919 	}
       
   920 
       
   921 	
       
   922 __declspec(dllexport)
       
   923 __declspec(naked)
       
   924 void call_vector_90 ()
       
   925 	{
       
   926 	// ; public: static class RInteger  __cdecl TInteger::ModularExponentiateL(class TInteger const &,class TInteger const &,class TInteger const &)
       
   927 	_asm mov eax, 90
       
   928 	_asm jmp common_dispatch
       
   929 	}
       
   930 
       
   931 	
       
   932 __declspec(dllexport)
       
   933 __declspec(naked)
       
   934 void call_vector_91 ()
       
   935 	{
       
   936 	// ; public: class TInteger const & __thiscall CDHParameters::N(void)const 
       
   937 	_asm mov eax, 91
       
   938 	_asm jmp common_dispatch
       
   939 	}
       
   940 
       
   941 	
       
   942 __declspec(dllexport)
       
   943 __declspec(naked)
       
   944 void call_vector_92 ()
       
   945 	{
       
   946 	// ; public: class TInteger const & __thiscall CRSAParameters::N(void)const 
       
   947 	_asm mov eax, 92
       
   948 	_asm jmp common_dispatch
       
   949 	}
       
   950 
       
   951 	
       
   952 __declspec(dllexport)
       
   953 __declspec(naked)
       
   954 void call_vector_93 ()
       
   955 	{
       
   956 	// ; public: static class RInteger  __cdecl RInteger::NewEmptyL(unsigned int)
       
   957 	_asm mov eax, 93
       
   958 	_asm jmp common_dispatch
       
   959 	}
       
   960 
       
   961 	
       
   962 __declspec(dllexport)
       
   963 __declspec(naked)
       
   964 void call_vector_94 ()
       
   965 	{
       
   966 	// ; public: static class C3DESDecryptor * __cdecl C3DESDecryptor::NewL(class TDesC8 const &)
       
   967 	_asm mov eax, 94
       
   968 	_asm jmp common_dispatch
       
   969 	}
       
   970 
       
   971 	
       
   972 __declspec(dllexport)
       
   973 __declspec(naked)
       
   974 void call_vector_95 ()
       
   975 	{
       
   976 	// ; public: static class C3DESEncryptor * __cdecl C3DESEncryptor::NewL(class TDesC8 const &)
       
   977 	_asm mov eax, 95
       
   978 	_asm jmp common_dispatch
       
   979 	}
       
   980 
       
   981 	
       
   982 __declspec(dllexport)
       
   983 __declspec(naked)
       
   984 void call_vector_96 ()
       
   985 	{
       
   986 	// ; public: static class CAESDecryptor * __cdecl CAESDecryptor::NewL(class TDesC8 const &)
       
   987 	_asm mov eax, 96
       
   988 	_asm jmp common_dispatch
       
   989 	}
       
   990 
       
   991 	
       
   992 __declspec(dllexport)
       
   993 __declspec(naked)
       
   994 void call_vector_97 ()
       
   995 	{
       
   996 	// ; public: static class CAESEncryptor * __cdecl CAESEncryptor::NewL(class TDesC8 const &)
       
   997 	_asm mov eax, 97
       
   998 	_asm jmp common_dispatch
       
   999 	}
       
  1000 
       
  1001 	
       
  1002 __declspec(dllexport)
       
  1003 __declspec(naked)
       
  1004 void call_vector_98 ()
       
  1005 	{
       
  1006 	// ; public: static class CARC4 * __cdecl CARC4::NewL(class TDesC8 const &,unsigned int)
       
  1007 	_asm mov eax, 98
       
  1008 	_asm jmp common_dispatch
       
  1009 	}
       
  1010 
       
  1011 	
       
  1012 __declspec(dllexport)
       
  1013 __declspec(naked)
       
  1014 void call_vector_99 ()
       
  1015 	{
       
  1016 	// ; public: static class CBufferedDecryptor * __cdecl CBufferedDecryptor::NewL(class CBlockTransformation *,class CPadding *)
       
  1017 	_asm mov eax, 99
       
  1018 	_asm jmp common_dispatch
       
  1019 	}
       
  1020 
       
  1021 	
       
  1022 __declspec(dllexport)
       
  1023 __declspec(naked)
       
  1024 void call_vector_100 ()
       
  1025 	{
       
  1026 	// ; public: static class CBufferedEncryptor * __cdecl CBufferedEncryptor::NewL(class CBlockTransformation *,class CPadding *)
       
  1027 	_asm mov eax, 100
       
  1028 	_asm jmp common_dispatch
       
  1029 	}
       
  1030 
       
  1031 	
       
  1032 __declspec(dllexport)
       
  1033 __declspec(naked)
       
  1034 void call_vector_101 ()
       
  1035 	{
       
  1036 	// ; public: static class CDESDecryptor * __cdecl CDESDecryptor::NewL(class TDesC8 const &,int)
       
  1037 	_asm mov eax, 101
       
  1038 	_asm jmp common_dispatch
       
  1039 	}
       
  1040 
       
  1041 	
       
  1042 __declspec(dllexport)
       
  1043 __declspec(naked)
       
  1044 void call_vector_102 ()
       
  1045 	{
       
  1046 	// ; public: static class CDESEncryptor * __cdecl CDESEncryptor::NewL(class TDesC8 const &,int)
       
  1047 	_asm mov eax, 102
       
  1048 	_asm jmp common_dispatch
       
  1049 	}
       
  1050 
       
  1051 	
       
  1052 __declspec(dllexport)
       
  1053 __declspec(naked)
       
  1054 void call_vector_103 ()
       
  1055 	{
       
  1056 	// ; public: static class CDH * __cdecl CDH::NewL(class CDHPrivateKey const &)
       
  1057 	_asm mov eax, 103
       
  1058 	_asm jmp common_dispatch
       
  1059 	}
       
  1060 
       
  1061 	
       
  1062 __declspec(dllexport)
       
  1063 __declspec(naked)
       
  1064 void call_vector_104 ()
       
  1065 	{
       
  1066 	// ; public: static class CDHKeyPair * __cdecl CDHKeyPair::NewL(class RInteger &,class RInteger &,class RInteger &)
       
  1067 	_asm mov eax, 104
       
  1068 	_asm jmp common_dispatch
       
  1069 	}
       
  1070 
       
  1071 	
       
  1072 __declspec(dllexport)
       
  1073 __declspec(naked)
       
  1074 void call_vector_105 ()
       
  1075 	{
       
  1076 	// ; public: static class CDHKeyPair * __cdecl CDHKeyPair::NewL(class RInteger &,class RInteger &)
       
  1077 	_asm mov eax, 105
       
  1078 	_asm jmp common_dispatch
       
  1079 	}
       
  1080 
       
  1081 	
       
  1082 __declspec(dllexport)
       
  1083 __declspec(naked)
       
  1084 void call_vector_106 ()
       
  1085 	{
       
  1086 	// ; public: static class CDHPrivateKey * __cdecl CDHPrivateKey::NewL(class RInteger &,class RInteger &,class RInteger &)
       
  1087 	_asm mov eax, 106
       
  1088 	_asm jmp common_dispatch
       
  1089 	}
       
  1090 
       
  1091 	
       
  1092 __declspec(dllexport)
       
  1093 __declspec(naked)
       
  1094 void call_vector_107 ()
       
  1095 	{
       
  1096 	// ; public: static class CDHPublicKey * __cdecl CDHPublicKey::NewL(class RInteger &,class RInteger &,class RInteger &)
       
  1097 	_asm mov eax, 107
       
  1098 	_asm jmp common_dispatch
       
  1099 	}
       
  1100 
       
  1101 	
       
  1102 __declspec(dllexport)
       
  1103 __declspec(naked)
       
  1104 void call_vector_108 ()
       
  1105 	{
       
  1106 	// ; public: static class CDSAKeyPair * __cdecl CDSAKeyPair::NewL(unsigned int)
       
  1107 	_asm mov eax, 108
       
  1108 	_asm jmp common_dispatch
       
  1109 	}
       
  1110 
       
  1111 	
       
  1112 __declspec(dllexport)
       
  1113 __declspec(naked)
       
  1114 void call_vector_109 ()
       
  1115 	{
       
  1116 	// ; public: static class CDSAParameters * __cdecl CDSAParameters::NewL(class RInteger &,class RInteger &,class RInteger &)
       
  1117 	_asm mov eax, 109
       
  1118 	_asm jmp common_dispatch
       
  1119 	}
       
  1120 
       
  1121 	
       
  1122 __declspec(dllexport)
       
  1123 __declspec(naked)
       
  1124 void call_vector_110 ()
       
  1125 	{
       
  1126 	// ; public: static class CDSAPrimeCertificate * __cdecl CDSAPrimeCertificate::NewL(class TDesC8 const &,unsigned int)
       
  1127 	_asm mov eax, 110
       
  1128 	_asm jmp common_dispatch
       
  1129 	}
       
  1130 
       
  1131 	
       
  1132 __declspec(dllexport)
       
  1133 __declspec(naked)
       
  1134 void call_vector_111 ()
       
  1135 	{
       
  1136 	// ; public: static class CDSAPrivateKey * __cdecl CDSAPrivateKey::NewL(class RInteger &,class RInteger &,class RInteger &,class RInteger &)
       
  1137 	_asm mov eax, 111
       
  1138 	_asm jmp common_dispatch
       
  1139 	}
       
  1140 
       
  1141 	
       
  1142 __declspec(dllexport)
       
  1143 __declspec(naked)
       
  1144 void call_vector_112 ()
       
  1145 	{
       
  1146 	// ; public: static class CDSAPublicKey * __cdecl CDSAPublicKey::NewL(class RInteger &,class RInteger &,class RInteger &,class RInteger &)
       
  1147 	_asm mov eax, 112
       
  1148 	_asm jmp common_dispatch
       
  1149 	}
       
  1150 
       
  1151 	
       
  1152 __declspec(dllexport)
       
  1153 __declspec(naked)
       
  1154 void call_vector_113 ()
       
  1155 	{
       
  1156 	// ; public: static class CDSASignature * __cdecl CDSASignature::NewL(class RInteger &,class RInteger &)
       
  1157 	_asm mov eax, 113
       
  1158 	_asm jmp common_dispatch
       
  1159 	}
       
  1160 
       
  1161 	
       
  1162 __declspec(dllexport)
       
  1163 __declspec(naked)
       
  1164 void call_vector_114 ()
       
  1165 	{
       
  1166 	// ; public: static class CDSASigner * __cdecl CDSASigner::NewL(class CDSAPrivateKey const &)
       
  1167 	_asm mov eax, 114
       
  1168 	_asm jmp common_dispatch
       
  1169 	}
       
  1170 
       
  1171 	
       
  1172 __declspec(dllexport)
       
  1173 __declspec(naked)
       
  1174 void call_vector_115 ()
       
  1175 	{
       
  1176 	// ; public: static class CDSAVerifier * __cdecl CDSAVerifier::NewL(class CDSAPublicKey const &)
       
  1177 	_asm mov eax, 115
       
  1178 	_asm jmp common_dispatch
       
  1179 	}
       
  1180 
       
  1181 	
       
  1182 __declspec(dllexport)
       
  1183 __declspec(naked)
       
  1184 void call_vector_116 ()
       
  1185 	{
       
  1186 	// ; public: static class CModeCBCDecryptor * __cdecl CModeCBCDecryptor::NewL(class CBlockTransformation *,class TDesC8 const &)
       
  1187 	_asm mov eax, 116
       
  1188 	_asm jmp common_dispatch
       
  1189 	}
       
  1190 
       
  1191 	
       
  1192 __declspec(dllexport)
       
  1193 __declspec(naked)
       
  1194 void call_vector_117 ()
       
  1195 	{
       
  1196 	// ; public: static class CModeCBCEncryptor * __cdecl CModeCBCEncryptor::NewL(class CBlockTransformation *,class TDesC8 const &)
       
  1197 	_asm mov eax, 117
       
  1198 	_asm jmp common_dispatch
       
  1199 	}
       
  1200 
       
  1201 	
       
  1202 __declspec(dllexport)
       
  1203 __declspec(naked)
       
  1204 void call_vector_118 ()
       
  1205 	{
       
  1206 	// ; public: static class CNullCipher * __cdecl CNullCipher::NewL(void)
       
  1207 	_asm mov eax, 118
       
  1208 	_asm jmp common_dispatch
       
  1209 	}
       
  1210 
       
  1211 	
       
  1212 __declspec(dllexport)
       
  1213 __declspec(naked)
       
  1214 void call_vector_119 ()
       
  1215 	{
       
  1216 	// ; public: static class CPaddingNone * __cdecl CPaddingNone::NewL(int)
       
  1217 	_asm mov eax, 119
       
  1218 	_asm jmp common_dispatch
       
  1219 	}
       
  1220 
       
  1221 	
       
  1222 __declspec(dllexport)
       
  1223 __declspec(naked)
       
  1224 void call_vector_120 ()
       
  1225 	{
       
  1226 	// ; public: static class CPaddingPKCS1Encryption * __cdecl CPaddingPKCS1Encryption::NewL(int)
       
  1227 	_asm mov eax, 120
       
  1228 	_asm jmp common_dispatch
       
  1229 	}
       
  1230 
       
  1231 	
       
  1232 __declspec(dllexport)
       
  1233 __declspec(naked)
       
  1234 void call_vector_121 ()
       
  1235 	{
       
  1236 	// ; public: static class CPaddingPKCS1Signature * __cdecl CPaddingPKCS1Signature::NewL(int)
       
  1237 	_asm mov eax, 121
       
  1238 	_asm jmp common_dispatch
       
  1239 	}
       
  1240 
       
  1241 	
       
  1242 __declspec(dllexport)
       
  1243 __declspec(naked)
       
  1244 void call_vector_122 ()
       
  1245 	{
       
  1246 	// ; public: static class CPaddingSSLv3 * __cdecl CPaddingSSLv3::NewL(int)
       
  1247 	_asm mov eax, 122
       
  1248 	_asm jmp common_dispatch
       
  1249 	}
       
  1250 
       
  1251 	
       
  1252 __declspec(dllexport)
       
  1253 __declspec(naked)
       
  1254 void call_vector_123 ()
       
  1255 	{
       
  1256 	// ; public: static class CRC2Decryptor * __cdecl CRC2Decryptor::NewL(class TDesC8 const &,int)
       
  1257 	_asm mov eax, 123
       
  1258 	_asm jmp common_dispatch
       
  1259 	}
       
  1260 
       
  1261 	
       
  1262 __declspec(dllexport)
       
  1263 __declspec(naked)
       
  1264 void call_vector_124 ()
       
  1265 	{
       
  1266 	// ; public: static class CRC2Encryptor * __cdecl CRC2Encryptor::NewL(class TDesC8 const &,int)
       
  1267 	_asm mov eax, 124
       
  1268 	_asm jmp common_dispatch
       
  1269 	}
       
  1270 
       
  1271 	
       
  1272 __declspec(dllexport)
       
  1273 __declspec(naked)
       
  1274 void call_vector_125 ()
       
  1275 	{
       
  1276 	// ; public: static class CRSAKeyPair * __cdecl CRSAKeyPair::NewL(unsigned int,enum TRSAPrivateKeyType)
       
  1277 	_asm mov eax, 125
       
  1278 	_asm jmp common_dispatch
       
  1279 	}
       
  1280 
       
  1281 	
       
  1282 __declspec(dllexport)
       
  1283 __declspec(naked)
       
  1284 void call_vector_126 ()
       
  1285 	{
       
  1286 	// ; public: static class CRSAPKCS1v15Decryptor * __cdecl CRSAPKCS1v15Decryptor::NewL(class CRSAPrivateKey const &)
       
  1287 	_asm mov eax, 126
       
  1288 	_asm jmp common_dispatch
       
  1289 	}
       
  1290 
       
  1291 	
       
  1292 __declspec(dllexport)
       
  1293 __declspec(naked)
       
  1294 void call_vector_127 ()
       
  1295 	{
       
  1296 	// ; public: static class CRSAPKCS1v15Encryptor * __cdecl CRSAPKCS1v15Encryptor::NewL(class CRSAPublicKey const &)
       
  1297 	_asm mov eax, 127
       
  1298 	_asm jmp common_dispatch
       
  1299 	}
       
  1300 
       
  1301 	
       
  1302 __declspec(dllexport)
       
  1303 __declspec(naked)
       
  1304 void call_vector_128 ()
       
  1305 	{
       
  1306 	// ; public: static class CRSAPKCS1v15Signer * __cdecl CRSAPKCS1v15Signer::NewL(class CRSAPrivateKey const &)
       
  1307 	_asm mov eax, 128
       
  1308 	_asm jmp common_dispatch
       
  1309 	}
       
  1310 
       
  1311 	
       
  1312 __declspec(dllexport)
       
  1313 __declspec(naked)
       
  1314 void call_vector_129 ()
       
  1315 	{
       
  1316 	// ; public: static class CRSAPKCS1v15Verifier * __cdecl CRSAPKCS1v15Verifier::NewL(class CRSAPublicKey const &)
       
  1317 	_asm mov eax, 129
       
  1318 	_asm jmp common_dispatch
       
  1319 	}
       
  1320 
       
  1321 	
       
  1322 __declspec(dllexport)
       
  1323 __declspec(naked)
       
  1324 void call_vector_130 ()
       
  1325 	{
       
  1326 	// ; public: static class CRSAPrivateKeyCRT * __cdecl CRSAPrivateKeyCRT::NewL(class RInteger &,class RInteger &,class RInteger &,class RInteger &,class RInteger &,class RInteger &)
       
  1327 	_asm mov eax, 130
       
  1328 	_asm jmp common_dispatch
       
  1329 	}
       
  1330 
       
  1331 	
       
  1332 __declspec(dllexport)
       
  1333 __declspec(naked)
       
  1334 void call_vector_131 ()
       
  1335 	{
       
  1336 	// ; public: static class CRSAPrivateKeyStandard * __cdecl CRSAPrivateKeyStandard::NewL(class RInteger &,class RInteger &)
       
  1337 	_asm mov eax, 131
       
  1338 	_asm jmp common_dispatch
       
  1339 	}
       
  1340 
       
  1341 	
       
  1342 __declspec(dllexport)
       
  1343 __declspec(naked)
       
  1344 void call_vector_132 ()
       
  1345 	{
       
  1346 	// ; public: static class CRSAPublicKey * __cdecl CRSAPublicKey::NewL(class RInteger &,class RInteger &)
       
  1347 	_asm mov eax, 132
       
  1348 	_asm jmp common_dispatch
       
  1349 	}
       
  1350 
       
  1351 	
       
  1352 __declspec(dllexport)
       
  1353 __declspec(naked)
       
  1354 void call_vector_133 ()
       
  1355 	{
       
  1356 	// ; public: static class CRSASignature * __cdecl CRSASignature::NewL(class RInteger &)
       
  1357 	_asm mov eax, 133
       
  1358 	_asm jmp common_dispatch
       
  1359 	}
       
  1360 
       
  1361 	
       
  1362 __declspec(dllexport)
       
  1363 __declspec(naked)
       
  1364 void call_vector_134 ()
       
  1365 	{
       
  1366 	// ; public: static class RInteger  __cdecl RInteger::NewL(class TDesC8 const &)
       
  1367 	_asm mov eax, 134
       
  1368 	_asm jmp common_dispatch
       
  1369 	}
       
  1370 
       
  1371 	
       
  1372 __declspec(dllexport)
       
  1373 __declspec(naked)
       
  1374 void call_vector_135 ()
       
  1375 	{
       
  1376 	// ; public: static class RInteger  __cdecl RInteger::NewL(class TInteger const &)
       
  1377 	_asm mov eax, 135
       
  1378 	_asm jmp common_dispatch
       
  1379 	}
       
  1380 
       
  1381 	
       
  1382 __declspec(dllexport)
       
  1383 __declspec(naked)
       
  1384 void call_vector_136 ()
       
  1385 	{
       
  1386 	// ; public: static class RInteger  __cdecl RInteger::NewL(int)
       
  1387 	_asm mov eax, 136
       
  1388 	_asm jmp common_dispatch
       
  1389 	}
       
  1390 
       
  1391 	
       
  1392 __declspec(dllexport)
       
  1393 __declspec(naked)
       
  1394 void call_vector_137 ()
       
  1395 	{
       
  1396 	// ; public: static class RInteger  __cdecl RInteger::NewL(unsigned int)
       
  1397 	_asm mov eax, 137
       
  1398 	_asm jmp common_dispatch
       
  1399 	}
       
  1400 
       
  1401 	
       
  1402 __declspec(dllexport)
       
  1403 __declspec(naked)
       
  1404 void call_vector_138 ()
       
  1405 	{
       
  1406 	// ; public: static class RInteger  __cdecl RInteger::NewL(void)
       
  1407 	_asm mov eax, 138
       
  1408 	_asm jmp common_dispatch
       
  1409 	}
       
  1410 
       
  1411 	
       
  1412 __declspec(dllexport)
       
  1413 __declspec(naked)
       
  1414 void call_vector_139 ()
       
  1415 	{
       
  1416 	// ; public: static class C3DESDecryptor * __cdecl C3DESDecryptor::NewLC(class TDesC8 const &)
       
  1417 	_asm mov eax, 139
       
  1418 	_asm jmp common_dispatch
       
  1419 	}
       
  1420 
       
  1421 	
       
  1422 __declspec(dllexport)
       
  1423 __declspec(naked)
       
  1424 void call_vector_140 ()
       
  1425 	{
       
  1426 	// ; public: static class C3DESEncryptor * __cdecl C3DESEncryptor::NewLC(class TDesC8 const &)
       
  1427 	_asm mov eax, 140
       
  1428 	_asm jmp common_dispatch
       
  1429 	}
       
  1430 
       
  1431 	
       
  1432 __declspec(dllexport)
       
  1433 __declspec(naked)
       
  1434 void call_vector_141 ()
       
  1435 	{
       
  1436 	// ; public: static class CAESDecryptor * __cdecl CAESDecryptor::NewLC(class TDesC8 const &)
       
  1437 	_asm mov eax, 141
       
  1438 	_asm jmp common_dispatch
       
  1439 	}
       
  1440 
       
  1441 	
       
  1442 __declspec(dllexport)
       
  1443 __declspec(naked)
       
  1444 void call_vector_142 ()
       
  1445 	{
       
  1446 	// ; public: static class CAESEncryptor * __cdecl CAESEncryptor::NewLC(class TDesC8 const &)
       
  1447 	_asm mov eax, 142
       
  1448 	_asm jmp common_dispatch
       
  1449 	}
       
  1450 
       
  1451 	
       
  1452 __declspec(dllexport)
       
  1453 __declspec(naked)
       
  1454 void call_vector_143 ()
       
  1455 	{
       
  1456 	// ; public: static class CARC4 * __cdecl CARC4::NewLC(class TDesC8 const &,unsigned int)
       
  1457 	_asm mov eax, 143
       
  1458 	_asm jmp common_dispatch
       
  1459 	}
       
  1460 
       
  1461 	
       
  1462 __declspec(dllexport)
       
  1463 __declspec(naked)
       
  1464 void call_vector_144 ()
       
  1465 	{
       
  1466 	// ; public: static class CBufferedDecryptor * __cdecl CBufferedDecryptor::NewLC(class CBlockTransformation *,class CPadding *)
       
  1467 	_asm mov eax, 144
       
  1468 	_asm jmp common_dispatch
       
  1469 	}
       
  1470 
       
  1471 	
       
  1472 __declspec(dllexport)
       
  1473 __declspec(naked)
       
  1474 void call_vector_145 ()
       
  1475 	{
       
  1476 	// ; public: static class CBufferedEncryptor * __cdecl CBufferedEncryptor::NewLC(class CBlockTransformation *,class CPadding *)
       
  1477 	_asm mov eax, 145
       
  1478 	_asm jmp common_dispatch
       
  1479 	}
       
  1480 
       
  1481 	
       
  1482 __declspec(dllexport)
       
  1483 __declspec(naked)
       
  1484 void call_vector_146 ()
       
  1485 	{
       
  1486 	// ; public: static class CDESDecryptor * __cdecl CDESDecryptor::NewLC(class TDesC8 const &,int)
       
  1487 	_asm mov eax, 146
       
  1488 	_asm jmp common_dispatch
       
  1489 	}
       
  1490 
       
  1491 	
       
  1492 __declspec(dllexport)
       
  1493 __declspec(naked)
       
  1494 void call_vector_147 ()
       
  1495 	{
       
  1496 	// ; public: static class CDESEncryptor * __cdecl CDESEncryptor::NewLC(class TDesC8 const &,int)
       
  1497 	_asm mov eax, 147
       
  1498 	_asm jmp common_dispatch
       
  1499 	}
       
  1500 
       
  1501 	
       
  1502 __declspec(dllexport)
       
  1503 __declspec(naked)
       
  1504 void call_vector_148 ()
       
  1505 	{
       
  1506 	// ; public: static class CDH * __cdecl CDH::NewLC(class CDHPrivateKey const &)
       
  1507 	_asm mov eax, 148
       
  1508 	_asm jmp common_dispatch
       
  1509 	}
       
  1510 
       
  1511 	
       
  1512 __declspec(dllexport)
       
  1513 __declspec(naked)
       
  1514 void call_vector_149 ()
       
  1515 	{
       
  1516 	// ; public: static class CDHKeyPair * __cdecl CDHKeyPair::NewLC(class RInteger &,class RInteger &,class RInteger &)
       
  1517 	_asm mov eax, 149
       
  1518 	_asm jmp common_dispatch
       
  1519 	}
       
  1520 
       
  1521 	
       
  1522 __declspec(dllexport)
       
  1523 __declspec(naked)
       
  1524 void call_vector_150 ()
       
  1525 	{
       
  1526 	// ; public: static class CDHKeyPair * __cdecl CDHKeyPair::NewLC(class RInteger &,class RInteger &)
       
  1527 	_asm mov eax, 150
       
  1528 	_asm jmp common_dispatch
       
  1529 	}
       
  1530 
       
  1531 	
       
  1532 __declspec(dllexport)
       
  1533 __declspec(naked)
       
  1534 void call_vector_151 ()
       
  1535 	{
       
  1536 	// ; public: static class CDHPrivateKey * __cdecl CDHPrivateKey::NewLC(class RInteger &,class RInteger &,class RInteger &)
       
  1537 	_asm mov eax, 151
       
  1538 	_asm jmp common_dispatch
       
  1539 	}
       
  1540 
       
  1541 	
       
  1542 __declspec(dllexport)
       
  1543 __declspec(naked)
       
  1544 void call_vector_152 ()
       
  1545 	{
       
  1546 	// ; public: static class CDHPublicKey * __cdecl CDHPublicKey::NewLC(class RInteger &,class RInteger &,class RInteger &)
       
  1547 	_asm mov eax, 152
       
  1548 	_asm jmp common_dispatch
       
  1549 	}
       
  1550 
       
  1551 	
       
  1552 __declspec(dllexport)
       
  1553 __declspec(naked)
       
  1554 void call_vector_153 ()
       
  1555 	{
       
  1556 	// ; public: static class CDSAKeyPair * __cdecl CDSAKeyPair::NewLC(unsigned int)
       
  1557 	_asm mov eax, 153
       
  1558 	_asm jmp common_dispatch
       
  1559 	}
       
  1560 
       
  1561 	
       
  1562 __declspec(dllexport)
       
  1563 __declspec(naked)
       
  1564 void call_vector_154 ()
       
  1565 	{
       
  1566 	// ; public: static class CDSAPrimeCertificate * __cdecl CDSAPrimeCertificate::NewLC(class TDesC8 const &,unsigned int)
       
  1567 	_asm mov eax, 154
       
  1568 	_asm jmp common_dispatch
       
  1569 	}
       
  1570 
       
  1571 	
       
  1572 __declspec(dllexport)
       
  1573 __declspec(naked)
       
  1574 void call_vector_155 ()
       
  1575 	{
       
  1576 	// ; public: static class CDSAPrivateKey * __cdecl CDSAPrivateKey::NewLC(class RInteger &,class RInteger &,class RInteger &,class RInteger &)
       
  1577 	_asm mov eax, 155
       
  1578 	_asm jmp common_dispatch
       
  1579 	}
       
  1580 
       
  1581 	
       
  1582 __declspec(dllexport)
       
  1583 __declspec(naked)
       
  1584 void call_vector_156 ()
       
  1585 	{
       
  1586 	// ; public: static class CDSAPublicKey * __cdecl CDSAPublicKey::NewLC(class RInteger &,class RInteger &,class RInteger &,class RInteger &)
       
  1587 	_asm mov eax, 156
       
  1588 	_asm jmp common_dispatch
       
  1589 	}
       
  1590 
       
  1591 	
       
  1592 __declspec(dllexport)
       
  1593 __declspec(naked)
       
  1594 void call_vector_157 ()
       
  1595 	{
       
  1596 	// ; public: static class CDSASignature * __cdecl CDSASignature::NewLC(class RInteger &,class RInteger &)
       
  1597 	_asm mov eax, 157
       
  1598 	_asm jmp common_dispatch
       
  1599 	}
       
  1600 
       
  1601 	
       
  1602 __declspec(dllexport)
       
  1603 __declspec(naked)
       
  1604 void call_vector_158 ()
       
  1605 	{
       
  1606 	// ; public: static class CDSASigner * __cdecl CDSASigner::NewLC(class CDSAPrivateKey const &)
       
  1607 	_asm mov eax, 158
       
  1608 	_asm jmp common_dispatch
       
  1609 	}
       
  1610 
       
  1611 	
       
  1612 __declspec(dllexport)
       
  1613 __declspec(naked)
       
  1614 void call_vector_159 ()
       
  1615 	{
       
  1616 	// ; public: static class CDSAVerifier * __cdecl CDSAVerifier::NewLC(class CDSAPublicKey const &)
       
  1617 	_asm mov eax, 159
       
  1618 	_asm jmp common_dispatch
       
  1619 	}
       
  1620 
       
  1621 	
       
  1622 __declspec(dllexport)
       
  1623 __declspec(naked)
       
  1624 void call_vector_160 ()
       
  1625 	{
       
  1626 	// ; public: static class CModeCBCDecryptor * __cdecl CModeCBCDecryptor::NewLC(class CBlockTransformation *,class TDesC8 const &)
       
  1627 	_asm mov eax, 160
       
  1628 	_asm jmp common_dispatch
       
  1629 	}
       
  1630 
       
  1631 	
       
  1632 __declspec(dllexport)
       
  1633 __declspec(naked)
       
  1634 void call_vector_161 ()
       
  1635 	{
       
  1636 	// ; public: static class CModeCBCEncryptor * __cdecl CModeCBCEncryptor::NewLC(class CBlockTransformation *,class TDesC8 const &)
       
  1637 	_asm mov eax, 161
       
  1638 	_asm jmp common_dispatch
       
  1639 	}
       
  1640 
       
  1641 	
       
  1642 __declspec(dllexport)
       
  1643 __declspec(naked)
       
  1644 void call_vector_162 ()
       
  1645 	{
       
  1646 	// ; public: static class CNullCipher * __cdecl CNullCipher::NewLC(void)
       
  1647 	_asm mov eax, 162
       
  1648 	_asm jmp common_dispatch
       
  1649 	}
       
  1650 
       
  1651 	
       
  1652 __declspec(dllexport)
       
  1653 __declspec(naked)
       
  1654 void call_vector_163 ()
       
  1655 	{
       
  1656 	// ; public: static class CPaddingNone * __cdecl CPaddingNone::NewLC(int)
       
  1657 	_asm mov eax, 163
       
  1658 	_asm jmp common_dispatch
       
  1659 	}
       
  1660 
       
  1661 	
       
  1662 __declspec(dllexport)
       
  1663 __declspec(naked)
       
  1664 void call_vector_164 ()
       
  1665 	{
       
  1666 	// ; public: static class CPaddingPKCS1Encryption * __cdecl CPaddingPKCS1Encryption::NewLC(int)
       
  1667 	_asm mov eax, 164
       
  1668 	_asm jmp common_dispatch
       
  1669 	}
       
  1670 
       
  1671 	
       
  1672 __declspec(dllexport)
       
  1673 __declspec(naked)
       
  1674 void call_vector_165 ()
       
  1675 	{
       
  1676 	// ; public: static class CPaddingPKCS1Signature * __cdecl CPaddingPKCS1Signature::NewLC(int)
       
  1677 	_asm mov eax, 165
       
  1678 	_asm jmp common_dispatch
       
  1679 	}
       
  1680 
       
  1681 	
       
  1682 __declspec(dllexport)
       
  1683 __declspec(naked)
       
  1684 void call_vector_166 ()
       
  1685 	{
       
  1686 	// ; public: static class CPaddingSSLv3 * __cdecl CPaddingSSLv3::NewLC(int)
       
  1687 	_asm mov eax, 166
       
  1688 	_asm jmp common_dispatch
       
  1689 	}
       
  1690 
       
  1691 	
       
  1692 __declspec(dllexport)
       
  1693 __declspec(naked)
       
  1694 void call_vector_167 ()
       
  1695 	{
       
  1696 	// ; public: static class CRC2Decryptor * __cdecl CRC2Decryptor::NewLC(class TDesC8 const &,int)
       
  1697 	_asm mov eax, 167
       
  1698 	_asm jmp common_dispatch
       
  1699 	}
       
  1700 
       
  1701 	
       
  1702 __declspec(dllexport)
       
  1703 __declspec(naked)
       
  1704 void call_vector_168 ()
       
  1705 	{
       
  1706 	// ; public: static class CRC2Encryptor * __cdecl CRC2Encryptor::NewLC(class TDesC8 const &,int)
       
  1707 	_asm mov eax, 168
       
  1708 	_asm jmp common_dispatch
       
  1709 	}
       
  1710 
       
  1711 	
       
  1712 __declspec(dllexport)
       
  1713 __declspec(naked)
       
  1714 void call_vector_169 ()
       
  1715 	{
       
  1716 	// ; public: static class CRSAKeyPair * __cdecl CRSAKeyPair::NewLC(unsigned int,enum TRSAPrivateKeyType)
       
  1717 	_asm mov eax, 169
       
  1718 	_asm jmp common_dispatch
       
  1719 	}
       
  1720 
       
  1721 	
       
  1722 __declspec(dllexport)
       
  1723 __declspec(naked)
       
  1724 void call_vector_170 ()
       
  1725 	{
       
  1726 	// ; public: static class CRSAPKCS1v15Decryptor * __cdecl CRSAPKCS1v15Decryptor::NewLC(class CRSAPrivateKey const &)
       
  1727 	_asm mov eax, 170
       
  1728 	_asm jmp common_dispatch
       
  1729 	}
       
  1730 
       
  1731 	
       
  1732 __declspec(dllexport)
       
  1733 __declspec(naked)
       
  1734 void call_vector_171 ()
       
  1735 	{
       
  1736 	// ; public: static class CRSAPKCS1v15Encryptor * __cdecl CRSAPKCS1v15Encryptor::NewLC(class CRSAPublicKey const &)
       
  1737 	_asm mov eax, 171
       
  1738 	_asm jmp common_dispatch
       
  1739 	}
       
  1740 
       
  1741 	
       
  1742 __declspec(dllexport)
       
  1743 __declspec(naked)
       
  1744 void call_vector_172 ()
       
  1745 	{
       
  1746 	// ; public: static class CRSAPKCS1v15Signer * __cdecl CRSAPKCS1v15Signer::NewLC(class CRSAPrivateKey const &)
       
  1747 	_asm mov eax, 172
       
  1748 	_asm jmp common_dispatch
       
  1749 	}
       
  1750 
       
  1751 	
       
  1752 __declspec(dllexport)
       
  1753 __declspec(naked)
       
  1754 void call_vector_173 ()
       
  1755 	{
       
  1756 	// ; public: static class CRSAPKCS1v15Verifier * __cdecl CRSAPKCS1v15Verifier::NewLC(class CRSAPublicKey const &)
       
  1757 	_asm mov eax, 173
       
  1758 	_asm jmp common_dispatch
       
  1759 	}
       
  1760 
       
  1761 	
       
  1762 __declspec(dllexport)
       
  1763 __declspec(naked)
       
  1764 void call_vector_174 ()
       
  1765 	{
       
  1766 	// ; public: static class CRSAPrivateKeyCRT * __cdecl CRSAPrivateKeyCRT::NewLC(class RInteger &,class RInteger &,class RInteger &,class RInteger &,class RInteger &,class RInteger &)
       
  1767 	_asm mov eax, 174
       
  1768 	_asm jmp common_dispatch
       
  1769 	}
       
  1770 
       
  1771 	
       
  1772 __declspec(dllexport)
       
  1773 __declspec(naked)
       
  1774 void call_vector_175 ()
       
  1775 	{
       
  1776 	// ; public: static class CRSAPrivateKeyStandard * __cdecl CRSAPrivateKeyStandard::NewLC(class RInteger &,class RInteger &)
       
  1777 	_asm mov eax, 175
       
  1778 	_asm jmp common_dispatch
       
  1779 	}
       
  1780 
       
  1781 	
       
  1782 __declspec(dllexport)
       
  1783 __declspec(naked)
       
  1784 void call_vector_176 ()
       
  1785 	{
       
  1786 	// ; public: static class CRSAPublicKey * __cdecl CRSAPublicKey::NewLC(class RInteger &,class RInteger &)
       
  1787 	_asm mov eax, 176
       
  1788 	_asm jmp common_dispatch
       
  1789 	}
       
  1790 
       
  1791 	
       
  1792 __declspec(dllexport)
       
  1793 __declspec(naked)
       
  1794 void call_vector_177 ()
       
  1795 	{
       
  1796 	// ; public: static class CRSASignature * __cdecl CRSASignature::NewLC(class RInteger &)
       
  1797 	_asm mov eax, 177
       
  1798 	_asm jmp common_dispatch
       
  1799 	}
       
  1800 
       
  1801 	
       
  1802 __declspec(dllexport)
       
  1803 __declspec(naked)
       
  1804 void call_vector_178 ()
       
  1805 	{
       
  1806 	// ; public: static class RInteger  __cdecl RInteger::NewPrimeL(unsigned int,int)
       
  1807 	_asm mov eax, 178
       
  1808 	_asm jmp common_dispatch
       
  1809 	}
       
  1810 
       
  1811 	
       
  1812 __declspec(dllexport)
       
  1813 __declspec(naked)
       
  1814 void call_vector_179 ()
       
  1815 	{
       
  1816 	// ; public: static class RInteger  __cdecl RInteger::NewRandomL(class TInteger const &,class TInteger const &)
       
  1817 	_asm mov eax, 179
       
  1818 	_asm jmp common_dispatch
       
  1819 	}
       
  1820 
       
  1821 	
       
  1822 __declspec(dllexport)
       
  1823 __declspec(naked)
       
  1824 void call_vector_180 ()
       
  1825 	{
       
  1826 	// ; public: static class RInteger  __cdecl RInteger::NewRandomL(unsigned int,int)
       
  1827 	_asm mov eax, 180
       
  1828 	_asm jmp common_dispatch
       
  1829 	}
       
  1830 
       
  1831 	
       
  1832 __declspec(dllexport)
       
  1833 __declspec(naked)
       
  1834 void call_vector_181 ()
       
  1835 	{
       
  1836 	// ; public: class TInteger const & __thiscall CDSAParameters::P(void)const 
       
  1837 	_asm mov eax, 181
       
  1838 	_asm jmp common_dispatch
       
  1839 	}
       
  1840 
       
  1841 	
       
  1842 __declspec(dllexport)
       
  1843 __declspec(naked)
       
  1844 void call_vector_182 ()
       
  1845 	{
       
  1846 	// ; public: class TInteger const & __thiscall CRSAPrivateKeyCRT::P(void)const 
       
  1847 	_asm mov eax, 182
       
  1848 	_asm jmp common_dispatch
       
  1849 	}
       
  1850 
       
  1851 	
       
  1852 __declspec(dllexport)
       
  1853 __declspec(naked)
       
  1854 void call_vector_183 ()
       
  1855 	{
       
  1856 	// ; public: void __thiscall CPadding::PadL(class TDesC8 const &,class TDes8 &)
       
  1857 	_asm mov eax, 183
       
  1858 	_asm jmp common_dispatch
       
  1859 	}
       
  1860 
       
  1861 	
       
  1862 __declspec(dllexport)
       
  1863 __declspec(naked)
       
  1864 void call_vector_184 ()
       
  1865 	{
       
  1866 	// ; public: class CDSAPrimeCertificate const & __thiscall CDSAKeyPair::PrimeCertificate(void)const 
       
  1867 	_asm mov eax, 184
       
  1868 	_asm jmp common_dispatch
       
  1869 	}
       
  1870 
       
  1871 	
       
  1872 __declspec(dllexport)
       
  1873 __declspec(naked)
       
  1874 void call_vector_185 ()
       
  1875 	{
       
  1876 	// ; public: class CDHPrivateKey const & __thiscall CDHKeyPair::PrivateKey(void)const 
       
  1877 	_asm mov eax, 185
       
  1878 	_asm jmp common_dispatch
       
  1879 	}
       
  1880 
       
  1881 	
       
  1882 __declspec(dllexport)
       
  1883 __declspec(naked)
       
  1884 void call_vector_186 ()
       
  1885 	{
       
  1886 	// ; public: class CDSAPrivateKey const & __thiscall CDSAKeyPair::PrivateKey(void)const 
       
  1887 	_asm mov eax, 186
       
  1888 	_asm jmp common_dispatch
       
  1889 	}
       
  1890 
       
  1891 	
       
  1892 __declspec(dllexport)
       
  1893 __declspec(naked)
       
  1894 void call_vector_187 ()
       
  1895 	{
       
  1896 	// ; public: class CRSAPrivateKey const & __thiscall CRSAKeyPair::PrivateKey(void)const 
       
  1897 	_asm mov eax, 187
       
  1898 	_asm jmp common_dispatch
       
  1899 	}
       
  1900 
       
  1901 	
       
  1902 __declspec(dllexport)
       
  1903 __declspec(naked)
       
  1904 void call_vector_188 ()
       
  1905 	{
       
  1906 	// ; public: virtual void __thiscall CStreamCipher::Process(class TDesC8 const &,class TDes8 &)
       
  1907 	_asm mov eax, 188
       
  1908 	_asm jmp common_dispatch
       
  1909 	}
       
  1910 
       
  1911 	
       
  1912 __declspec(dllexport)
       
  1913 __declspec(naked)
       
  1914 void call_vector_189 ()
       
  1915 	{
       
  1916 	// ; public: virtual void __thiscall CStreamCipher::ProcessFinalL(class TDesC8 const &,class TDes8 &)
       
  1917 	_asm mov eax, 189
       
  1918 	_asm jmp common_dispatch
       
  1919 	}
       
  1920 
       
  1921 	
       
  1922 __declspec(dllexport)
       
  1923 __declspec(naked)
       
  1924 void call_vector_190 ()
       
  1925 	{
       
  1926 	// ; public: class CDHPublicKey const & __thiscall CDHKeyPair::PublicKey(void)const 
       
  1927 	_asm mov eax, 190
       
  1928 	_asm jmp common_dispatch
       
  1929 	}
       
  1930 
       
  1931 	
       
  1932 __declspec(dllexport)
       
  1933 __declspec(naked)
       
  1934 void call_vector_191 ()
       
  1935 	{
       
  1936 	// ; public: class CDSAPublicKey const & __thiscall CDSAKeyPair::PublicKey(void)const 
       
  1937 	_asm mov eax, 191
       
  1938 	_asm jmp common_dispatch
       
  1939 	}
       
  1940 
       
  1941 	
       
  1942 __declspec(dllexport)
       
  1943 __declspec(naked)
       
  1944 void call_vector_192 ()
       
  1945 	{
       
  1946 	// ; public: class CRSAPublicKey const & __thiscall CRSAKeyPair::PublicKey(void)const 
       
  1947 	_asm mov eax, 192
       
  1948 	_asm jmp common_dispatch
       
  1949 	}
       
  1950 
       
  1951 	
       
  1952 __declspec(dllexport)
       
  1953 __declspec(naked)
       
  1954 void call_vector_193 ()
       
  1955 	{
       
  1956 	// ; public: class TInteger const & __thiscall CDSAParameters::Q(void)const 
       
  1957 	_asm mov eax, 193
       
  1958 	_asm jmp common_dispatch
       
  1959 	}
       
  1960 
       
  1961 	
       
  1962 __declspec(dllexport)
       
  1963 __declspec(naked)
       
  1964 void call_vector_194 ()
       
  1965 	{
       
  1966 	// ; public: class TInteger const & __thiscall CRSAPrivateKeyCRT::Q(void)const 
       
  1967 	_asm mov eax, 194
       
  1968 	_asm jmp common_dispatch
       
  1969 	}
       
  1970 
       
  1971 	
       
  1972 __declspec(dllexport)
       
  1973 __declspec(naked)
       
  1974 void call_vector_195 ()
       
  1975 	{
       
  1976 	// ; public: class TInteger const & __thiscall CRSAPrivateKeyCRT::QInv(void)const 
       
  1977 	_asm mov eax, 195
       
  1978 	_asm jmp common_dispatch
       
  1979 	}
       
  1980 
       
  1981 	
       
  1982 __declspec(dllexport)
       
  1983 __declspec(naked)
       
  1984 void call_vector_196 ()
       
  1985 	{
       
  1986 	// ; public: class TInteger const & __thiscall CDSASignature::R(void)const 
       
  1987 	_asm mov eax, 196
       
  1988 	_asm jmp common_dispatch
       
  1989 	}
       
  1990 
       
  1991 	
       
  1992 __declspec(dllexport)
       
  1993 __declspec(naked)
       
  1994 void call_vector_197 ()
       
  1995 	{
       
  1996 	// ; public: class TInteger const & __thiscall CDSASignature::S(void)const 
       
  1997 	_asm mov eax, 197
       
  1998 	_asm jmp common_dispatch
       
  1999 	}
       
  2000 
       
  2001 	
       
  2002 __declspec(dllexport)
       
  2003 __declspec(naked)
       
  2004 void call_vector_198 ()
       
  2005 	{
       
  2006 	// ; public: class TInteger const & __thiscall CRSASignature::S(void)const 
       
  2007 	_asm mov eax, 198
       
  2008 	_asm jmp common_dispatch
       
  2009 	}
       
  2010 
       
  2011 	
       
  2012 __declspec(dllexport)
       
  2013 __declspec(naked)
       
  2014 void call_vector_199 ()
       
  2015 	{
       
  2016 	// ; public: class TDesC8 const & __thiscall CDSAPrimeCertificate::Seed(void)const 
       
  2017 	_asm mov eax, 199
       
  2018 	_asm jmp common_dispatch
       
  2019 	}
       
  2020 
       
  2021 	
       
  2022 __declspec(dllexport)
       
  2023 __declspec(naked)
       
  2024 void call_vector_200 ()
       
  2025 	{
       
  2026 	// ; public: void __thiscall CPadding::SetBlockSize(int)
       
  2027 	_asm mov eax, 200
       
  2028 	_asm jmp common_dispatch
       
  2029 	}
       
  2030 
       
  2031 	
       
  2032 __declspec(dllexport)
       
  2033 __declspec(naked)
       
  2034 void call_vector_201 ()
       
  2035 	{
       
  2036 	// ; public: static enum TCrypto::TStrength  __cdecl TCrypto::Strength(void)
       
  2037 	_asm mov eax, 201
       
  2038 	_asm jmp common_dispatch
       
  2039 	}
       
  2040 
       
  2041 	
       
  2042 __declspec(dllexport)
       
  2043 __declspec(naked)
       
  2044 void call_vector_202 ()
       
  2045 	{
       
  2046 	// ; public: static int __cdecl CDSAParameters::ValidPrimeLength(unsigned int)
       
  2047 	_asm mov eax, 202
       
  2048 	_asm jmp common_dispatch
       
  2049 	}
       
  2050 
       
  2051 	
       
  2052 __declspec(dllexport)
       
  2053 __declspec(naked)
       
  2054 void call_vector_203 ()
       
  2055 	{
       
  2056 	// ; public: int __thiscall CDSAParameters::ValidatePrimesL(class CDSAPrimeCertificate const &)const 
       
  2057 	_asm mov eax, 203
       
  2058 	_asm jmp common_dispatch
       
  2059 	}
       
  2060 
       
  2061 	
       
  2062 __declspec(dllexport)
       
  2063 __declspec(naked)
       
  2064 void call_vector_204 ()
       
  2065 	{
       
  2066 	// ; public: unsigned int __thiscall TInteger::WordCount(void)const 
       
  2067 	_asm mov eax, 204
       
  2068 	_asm jmp common_dispatch
       
  2069 	}
       
  2070 
       
  2071 	
       
  2072 __declspec(dllexport)
       
  2073 __declspec(naked)
       
  2074 void call_vector_205 ()
       
  2075 	{
       
  2076 	// ; public: class TInteger const & __thiscall CDHPublicKey::X(void)const 
       
  2077 	_asm mov eax, 205
       
  2078 	_asm jmp common_dispatch
       
  2079 	}
       
  2080 
       
  2081 	
       
  2082 __declspec(dllexport)
       
  2083 __declspec(naked)
       
  2084 void call_vector_206 ()
       
  2085 	{
       
  2086 	// ; public: class TInteger const & __thiscall CDSAPrivateKey::X(void)const 
       
  2087 	_asm mov eax, 206
       
  2088 	_asm jmp common_dispatch
       
  2089 	}
       
  2090 
       
  2091 	
       
  2092 __declspec(dllexport)
       
  2093 __declspec(naked)
       
  2094 void call_vector_207 ()
       
  2095 	{
       
  2096 	// ; public: class TInteger const & __thiscall CDSAPublicKey::Y(void)const 
       
  2097 	_asm mov eax, 207
       
  2098 	_asm jmp common_dispatch
       
  2099 	}
       
  2100 
       
  2101 	
       
  2102 __declspec(dllexport)
       
  2103 __declspec(naked)
       
  2104 void call_vector_208 ()
       
  2105 	{
       
  2106 	// ; public: class TInteger const & __thiscall CDHPrivateKey::x(void)const 
       
  2107 	_asm mov eax, 208
       
  2108 	_asm jmp common_dispatch
       
  2109 	}
       
  2110 
       
  2111 	
       
  2112 __declspec(dllexport)
       
  2113 __declspec(naked)
       
  2114 void call_vector_209 ()
       
  2115 	{
       
  2116 	// ; public: static int __cdecl TCrypto::IsAsymmetricWeakEnoughL(int)
       
  2117 	_asm mov eax, 209
       
  2118 	_asm jmp common_dispatch
       
  2119 	}
       
  2120 
       
  2121 	
       
  2122 __declspec(dllexport)
       
  2123 __declspec(naked)
       
  2124 void call_vector_210 ()
       
  2125 	{
       
  2126 	// ; public: static int __cdecl TCrypto::IsSymmetricWeakEnoughL(int)
       
  2127 	_asm mov eax, 210
       
  2128 	_asm jmp common_dispatch
       
  2129 	}
       
  2130 
       
  2131 	
       
  2132 __declspec(dllexport)
       
  2133 __declspec(naked)
       
  2134 void call_vector_211 ()
       
  2135 	{
       
  2136 	// ; CPaddingPKCS7::CPaddingPKCS7(int)
       
  2137 	_asm mov eax, 211
       
  2138 	_asm jmp common_dispatch
       
  2139 	}
       
  2140 
       
  2141 	
       
  2142 __declspec(dllexport)
       
  2143 __declspec(naked)
       
  2144 void call_vector_212 ()
       
  2145 	{
       
  2146 	// ; class CPaddingPKCS7 * CPaddingPKCS7::NewL(int)
       
  2147 	_asm mov eax, 212
       
  2148 	_asm jmp common_dispatch
       
  2149 	}
       
  2150 
       
  2151 	
       
  2152 __declspec(dllexport)
       
  2153 __declspec(naked)
       
  2154 void call_vector_213 ()
       
  2155 	{
       
  2156 	// ; class CPaddingPKCS7 * CPaddingPKCS7::NewLC(int)
       
  2157 	_asm mov eax, 213
       
  2158 	_asm jmp common_dispatch
       
  2159 	}
       
  2160 
       
  2161 	
       
  2162 __declspec(dllexport)
       
  2163 __declspec(naked)
       
  2164 void call_vector_214 ()
       
  2165 	{
       
  2166 	// ; void KeyIdentifierUtil::DHKeyIdentifierL(class RInteger const &, class TBuf8<20> &)
       
  2167 	_asm mov eax, 214
       
  2168 	_asm jmp common_dispatch
       
  2169 	}
       
  2170 
       
  2171 	
       
  2172 __declspec(dllexport)
       
  2173 __declspec(naked)
       
  2174 void call_vector_215 ()
       
  2175 	{
       
  2176 	// ; void KeyIdentifierUtil::DSAKeyIdentifierL(class CDSAPublicKey const &, class TBuf8<20> &)
       
  2177 	_asm mov eax, 215
       
  2178 	_asm jmp common_dispatch
       
  2179 	}
       
  2180 
       
  2181 	
       
  2182 __declspec(dllexport)
       
  2183 __declspec(naked)
       
  2184 void call_vector_216 ()
       
  2185 	{
       
  2186 	// ; void KeyIdentifierUtil::RSAKeyIdentifierL(class CRSAPublicKey const &, class TBuf8<20> &)
       
  2187 	_asm mov eax, 216
       
  2188 	_asm jmp common_dispatch
       
  2189 	}
       
  2190 
       
  2191 	
       
  2192 __declspec(dllexport)
       
  2193 __declspec(naked)
       
  2194 void call_vector_217 ()
       
  2195 	{
       
  2196 	// ; class TInteger & TInteger::operator++(void)
       
  2197 	_asm mov eax, 217
       
  2198 	_asm jmp common_dispatch
       
  2199 	}
       
  2200 
       
  2201 	
       
  2202 __declspec(dllexport)
       
  2203 __declspec(naked)
       
  2204 void call_vector_218 ()
       
  2205 	{
       
  2206 	// ; class TInteger & TInteger::operator--(void)
       
  2207 	_asm mov eax, 218
       
  2208 	_asm jmp common_dispatch
       
  2209 	}
       
  2210 
       
  2211 	
       
  2212 __declspec(dllexport)
       
  2213 __declspec(naked)
       
  2214 void call_vector_219 ()
       
  2215 	{
       
  2216 	// ; class RInteger TInteger::InverseModL(class TInteger const &) const
       
  2217 	_asm mov eax, 219
       
  2218 	_asm jmp common_dispatch
       
  2219 	}
       
  2220 
       
  2221 	
       
  2222 __declspec(dllexport)
       
  2223 __declspec(naked)
       
  2224 void call_vector_220 ()
       
  2225 	{
       
  2226 	// ; class RInteger TInteger::TimesL(class TInteger const &) const
       
  2227 	_asm mov eax, 220
       
  2228 	_asm jmp common_dispatch
       
  2229 	}
       
  2230 
       
  2231 	
       
  2232 __declspec(dllexport)
       
  2233 __declspec(naked)
       
  2234 void call_vector_221 ()
       
  2235 	{
       
  2236 	// ; public: __thiscall RInteger::RInteger(class RInteger const &)
       
  2237 	_asm mov eax, 221
       
  2238 	_asm jmp common_dispatch
       
  2239 	}
       
  2240 
       
  2241 	
       
  2242 __declspec(dllexport)
       
  2243 __declspec(naked)
       
  2244 void call_vector_222 ()
       
  2245 	{
       
  2246 	// ; public: class RInteger & __thiscall RInteger::operator=(class RInteger const &)
       
  2247 	_asm mov eax, 222
       
  2248 	_asm jmp common_dispatch
       
  2249 	}
       
  2250 
       
  2251 __declspec(dllexport)
       
  2252 __declspec(naked)
       
  2253 void call_vector_223 ()
       
  2254 	{
       
  2255 	// ; public: class TInteger & __thiscall TInteger::operator*=(class TInteger const &)
       
  2256 	_asm mov eax, 223
       
  2257 	_asm jmp common_dispatch
       
  2258 	}
       
  2259 
       
  2260 __declspec(dllexport)
       
  2261 __declspec(naked)
       
  2262 void call_vector_224 ()
       
  2263 	{
       
  2264 	// ; public: class TInteger & __thiscall TInteger::operator*=(int)
       
  2265 	_asm mov eax, 224
       
  2266 	_asm jmp common_dispatch
       
  2267 	}
       
  2268 
       
  2269 __declspec(dllexport)
       
  2270 __declspec(naked)
       
  2271 void call_vector_225 ()
       
  2272 	{
       
  2273 	// ; public: class TInteger & __thiscall TInteger::operator+=(class TInteger const &)
       
  2274 	_asm mov eax, 225
       
  2275 	_asm jmp common_dispatch
       
  2276 	}
       
  2277 
       
  2278 __declspec(dllexport)
       
  2279 __declspec(naked)
       
  2280 void call_vector_226 ()
       
  2281 	{
       
  2282 	// ; public: class TInteger & __thiscall TInteger::operator+=(int)
       
  2283 	_asm mov eax, 226
       
  2284 	_asm jmp common_dispatch
       
  2285 	}
       
  2286 
       
  2287 __declspec(dllexport)
       
  2288 __declspec(naked)
       
  2289 void call_vector_227 ()
       
  2290 	{
       
  2291 	// ; public: class TInteger & __thiscall TInteger::operator-=(class TInteger const &)
       
  2292 	_asm mov eax, 227
       
  2293 	_asm jmp common_dispatch
       
  2294 	}
       
  2295 
       
  2296 __declspec(dllexport)
       
  2297 __declspec(naked)
       
  2298 void call_vector_228 ()
       
  2299 	{
       
  2300 	// ; public: class TInteger & __thiscall TInteger::operator-=(int)
       
  2301 	_asm mov eax, 228
       
  2302 	_asm jmp common_dispatch
       
  2303 	}
       
  2304 
       
  2305 __declspec(dllexport)
       
  2306 __declspec(naked)
       
  2307 void call_vector_229 ()
       
  2308 	{
       
  2309 	// ; public: class TInteger & __thiscall TInteger::operator/=(class TInteger const &)
       
  2310 	_asm mov eax, 229
       
  2311 	_asm jmp common_dispatch
       
  2312 	}
       
  2313 
       
  2314 __declspec(dllexport)
       
  2315 __declspec(naked)
       
  2316 void call_vector_230 ()
       
  2317 	{
       
  2318 	// ; public: class TInteger & __thiscall TInteger::operator/=(int)
       
  2319 	_asm mov eax, 230
       
  2320 	_asm jmp common_dispatch
       
  2321 	}
       
  2322 
       
  2323 __declspec(dllexport)
       
  2324 __declspec(naked)
       
  2325 void call_vector_231 ()
       
  2326 	{
       
  2327 	// ; public: class TInteger & __thiscall TInteger::operator%=(class TInteger const &)
       
  2328 	_asm mov eax, 231
       
  2329 	_asm jmp common_dispatch
       
  2330 	}
       
  2331 
       
  2332 __declspec(dllexport)
       
  2333 __declspec(naked)
       
  2334 void call_vector_232 ()
       
  2335 	{
       
  2336 	// ; public: class TInteger & __thiscall TInteger::operator%=(int)
       
  2337 	_asm mov eax, 232
       
  2338 	_asm jmp common_dispatch
       
  2339 	}
       
  2340 
       
  2341 __declspec(dllexport)
       
  2342 __declspec(naked)
       
  2343 void call_vector_233 ()
       
  2344 	{
       
  2345 	// ; public: class TInteger & __thiscall TInteger::operator>>=(unsigned int)
       
  2346 	_asm mov eax, 233
       
  2347 	_asm jmp common_dispatch
       
  2348 	}
       
  2349 
       
  2350 __declspec(dllexport)
       
  2351 __declspec(naked)
       
  2352 void call_vector_234 ()
       
  2353 	{
       
  2354 	// ; public: class TInteger & __thiscall TInteger::operator<<=(unsigned int)
       
  2355 	_asm mov eax, 234
       
  2356 	_asm jmp common_dispatch
       
  2357 	}
       
  2358 
       
  2359 __declspec(dllexport)
       
  2360 __declspec(naked)
       
  2361 void call_vector_235 ()
       
  2362 	{
       
  2363 	// ; public: int __thiscall TInteger::Bit(unsigned int)const 
       
  2364 	_asm mov eax, 235
       
  2365 	_asm jmp common_dispatch
       
  2366 	}
       
  2367 
       
  2368 __declspec(dllexport)
       
  2369 __declspec(naked)
       
  2370 void call_vector_236 ()
       
  2371 	{
       
  2372 	// ; public: int __thiscall TInteger::ConvertToLongL(void)const 
       
  2373 	_asm mov eax, 236
       
  2374 	_asm jmp common_dispatch
       
  2375 	}
       
  2376 
       
  2377 __declspec(dllexport)
       
  2378 __declspec(naked)
       
  2379 void call_vector_237 ()
       
  2380 	{
       
  2381 	// ; public: class RInteger  __thiscall TInteger::DividedByL(class TInteger const &)const 
       
  2382 	_asm mov eax, 237
       
  2383 	_asm jmp common_dispatch
       
  2384 	}
       
  2385 
       
  2386 __declspec(dllexport)
       
  2387 __declspec(naked)
       
  2388 void call_vector_238 ()
       
  2389 	{
       
  2390 	// ; public: class RInteger  __thiscall TInteger::DividedByL(unsigned int)const 
       
  2391 	_asm mov eax, 238
       
  2392 	_asm jmp common_dispatch
       
  2393 	}
       
  2394 
       
  2395 __declspec(dllexport)
       
  2396 __declspec(naked)
       
  2397 void call_vector_239 ()
       
  2398 	{
       
  2399 	// ; public: class RInteger  __thiscall TInteger::ExponentiateL(class TInteger const &)const 
       
  2400 	_asm mov eax, 239
       
  2401 	_asm jmp common_dispatch
       
  2402 	}
       
  2403 
       
  2404 __declspec(dllexport)
       
  2405 __declspec(naked)
       
  2406 void call_vector_240 ()
       
  2407 	{
       
  2408 	// ; public: class RInteger  __thiscall TInteger::GCDL(class TInteger const &)const 
       
  2409 	_asm mov eax, 240
       
  2410 	_asm jmp common_dispatch
       
  2411 	}
       
  2412 
       
  2413 __declspec(dllexport)
       
  2414 __declspec(naked)
       
  2415 void call_vector_241 ()
       
  2416 	{
       
  2417 	// ; public: int __thiscall TInteger::IsPrimeL(void)const 
       
  2418 	_asm mov eax, 241
       
  2419 	_asm jmp common_dispatch
       
  2420 	}
       
  2421 
       
  2422 __declspec(dllexport)
       
  2423 __declspec(naked)
       
  2424 void call_vector_242 ()
       
  2425 	{
       
  2426 	// ; public: class RInteger  __thiscall TInteger::MinusL(class TInteger const &)const 
       
  2427 	_asm mov eax, 242
       
  2428 	_asm jmp common_dispatch
       
  2429 	}
       
  2430 
       
  2431 __declspec(dllexport)
       
  2432 __declspec(naked)
       
  2433 void call_vector_243 ()
       
  2434 	{
       
  2435 	// ; public: static class RInteger  __cdecl TInteger::ModularMultiplyL(class TInteger const &,class TInteger const &,class TInteger const &)
       
  2436 	_asm mov eax, 243
       
  2437 	_asm jmp common_dispatch
       
  2438 	}
       
  2439 
       
  2440 __declspec(dllexport)
       
  2441 __declspec(naked)
       
  2442 void call_vector_244 ()
       
  2443 	{
       
  2444 	// ; public: class RInteger  __thiscall TInteger::ModuloL(class TInteger const &)const 
       
  2445 	_asm mov eax, 244
       
  2446 	_asm jmp common_dispatch
       
  2447 	}
       
  2448 
       
  2449 __declspec(dllexport)
       
  2450 __declspec(naked)
       
  2451 void call_vector_245 ()
       
  2452 	{
       
  2453 	// ; public: unsigned int __thiscall TInteger::ModuloL(unsigned int)const 
       
  2454 	_asm mov eax, 245
       
  2455 	_asm jmp common_dispatch
       
  2456 	}
       
  2457 
       
  2458 __declspec(dllexport)
       
  2459 __declspec(naked)
       
  2460 void call_vector_246 ()
       
  2461 	{
       
  2462 	// ; public: void __thiscall TInteger::Negate(void)
       
  2463 	_asm mov eax, 246
       
  2464 	_asm jmp common_dispatch
       
  2465 	}
       
  2466 
       
  2467 __declspec(dllexport)
       
  2468 __declspec(naked)
       
  2469 void call_vector_247 ()
       
  2470 	{
       
  2471 	// ; public: static class TInteger const & __cdecl TInteger::One(void)
       
  2472 	_asm mov eax, 247
       
  2473 	_asm jmp common_dispatch
       
  2474 	}
       
  2475 
       
  2476 __declspec(dllexport)
       
  2477 __declspec(naked)
       
  2478 void call_vector_248 ()
       
  2479 	{
       
  2480 	// ; public: class RInteger  __thiscall TInteger::PlusL(class TInteger const &)const 
       
  2481 	_asm mov eax, 248
       
  2482 	_asm jmp common_dispatch
       
  2483 	}
       
  2484 
       
  2485 __declspec(dllexport)
       
  2486 __declspec(naked)
       
  2487 void call_vector_249 ()
       
  2488 	{
       
  2489 	// ; public: void __thiscall TInteger::SetBit(unsigned int)
       
  2490 	_asm mov eax, 249
       
  2491 	_asm jmp common_dispatch
       
  2492 	}
       
  2493 
       
  2494 __declspec(dllexport)
       
  2495 __declspec(naked)
       
  2496 void call_vector_250 ()
       
  2497 	{
       
  2498 	// ; public: int __thiscall TInteger::SignedCompare(class TInteger const &)const 
       
  2499 	_asm mov eax, 250
       
  2500 	_asm jmp common_dispatch
       
  2501 	}
       
  2502 
       
  2503 __declspec(dllexport)
       
  2504 __declspec(naked)
       
  2505 void call_vector_251 ()
       
  2506 	{
       
  2507 	// ; public: int __thiscall TInteger::SignedCompare(int)const 
       
  2508 	_asm mov eax, 251
       
  2509 	_asm jmp common_dispatch
       
  2510 	}
       
  2511 
       
  2512 __declspec(dllexport)
       
  2513 __declspec(naked)
       
  2514 void call_vector_252 ()
       
  2515 	{
       
  2516 	// ; public: class RInteger  __thiscall TInteger::SquaredL(void)const 
       
  2517 	_asm mov eax, 252
       
  2518 	_asm jmp common_dispatch
       
  2519 	}
       
  2520 
       
  2521 __declspec(dllexport)
       
  2522 __declspec(naked)
       
  2523 void call_vector_253 ()
       
  2524 	{
       
  2525 	// ; public: static class TInteger const & __cdecl TInteger::Two(void)
       
  2526 	_asm mov eax, 253
       
  2527 	_asm jmp common_dispatch
       
  2528 	}
       
  2529 
       
  2530 __declspec(dllexport)
       
  2531 __declspec(naked)
       
  2532 void call_vector_254 ()
       
  2533 	{
       
  2534 	// ; public: int __thiscall TInteger::UnsignedCompare(class TInteger const &)const 
       
  2535 	_asm mov eax, 254
       
  2536 	_asm jmp common_dispatch
       
  2537 	}
       
  2538 
       
  2539 __declspec(dllexport)
       
  2540 __declspec(naked)
       
  2541 void call_vector_255 ()
       
  2542 	{
       
  2543 	// ; public: static class TInteger const & __cdecl TInteger::Zero(void)
       
  2544 	_asm mov eax, 255
       
  2545 	_asm jmp common_dispatch
       
  2546 	}
       
  2547 
       
  2548 __declspec(dllexport)
       
  2549 __declspec(naked)
       
  2550 void call_vector_256 ()
       
  2551 	{
       
  2552 	// ; public: void __thiscall TInteger::CopyL(class TInteger const &,int)
       
  2553 	_asm mov eax, 256
       
  2554 	_asm jmp common_dispatch
       
  2555 	}
       
  2556 
       
  2557 __declspec(dllexport)
       
  2558 __declspec(naked)
       
  2559 void call_vector_257 ()
       
  2560 	{
       
  2561 	// ; public: void __thiscall TInteger::CopyL(int,int)
       
  2562 	_asm mov eax, 257
       
  2563 	_asm jmp common_dispatch
       
  2564 	}
       
  2565 
       
  2566 __declspec(dllexport)
       
  2567 __declspec(naked)
       
  2568 void call_vector_258 ()
       
  2569 	{
       
  2570 	// ; public: void __thiscall TInteger::Set(class RInteger const &)
       
  2571 	_asm mov eax, 258
       
  2572 	_asm jmp common_dispatch
       
  2573 	}
       
  2574 	
       
  2575 __declspec(dllexport)
       
  2576 __declspec(naked)
       
  2577 void call_vector_259 ()
       
  2578 	{
       
  2579 	// ; public: void __thiscall TInteger::Set(class RInteger const &)
       
  2580 	_asm mov eax, 259
       
  2581 	_asm jmp common_dispatch
       
  2582 	}	
       
  2583 	
       
  2584 __declspec(dllexport)
       
  2585 __declspec(naked)
       
  2586 void call_vector_260 ()
       
  2587 	{
       
  2588 	// ; public: class HBufC8 * __thiscall TInteger::BufferWithNoTruncationLC(void)const 
       
  2589 	_asm mov eax, 260
       
  2590 	_asm jmp common_dispatch
       
  2591 	}
       
  2592 			
       
  2593 }
       
  2594 #define MAX_ORDINAL 260