From dbc43ce027a69fbc604f8b8c1d9cfafca14a9e4c Mon Sep 17 00:00:00 2001 From: Jim McKeeth Date: Wed, 12 Dec 2018 22:44:50 -0700 Subject: [PATCH] 10.3 Rio / VER330 / PKG 260 Support added for 10.3 Rio (Compiler 33.0 / VER330 / Product version 26 / Package version 260) --- LockBox-3.5.2.png | Bin 0 -> 46820 bytes design/FMX.uTPLb_ComponentEditors.pas | 483 +++ design/FMX.uTPLb_ComponentRegistration.pas | 58 + design/Vcl.uTPLb_ComponentEditors.pas | 483 +++ design/Vcl.uTPLb_ComponentRegistration.pas | 50 + design/uTPLb_ComponentAbout.dfm | 3191 +++++++++++++++++ design/uTPLb_ComponentAbout.pas | 534 +++ design/uTPLb_ComponentEditors.pas | 493 +++ design/uTPLb_ComponentRegistration.pas | 50 + design/uTPLb_InfoUtils.pas | 127 + hpp/Win32/Release/DCPtwofish_LB3Modified.hpp | 4 +- .../Release/FMX.uTPLb_ComponentAbout.hpp | 4 +- hpp/Win32/Release/FMX.uTPLb_InfoUtils.hpp | 2 +- hpp/Win32/Release/LockBox3DR.hpp | 6 +- hpp/Win32/Release/LockBox3FMXDD.hpp | 11 +- hpp/Win32/Release/LockBox3VCLDD.hpp | 9 +- .../Release/Vcl.uTPLb_ComponentAbout.hpp | 4 +- hpp/Win32/Release/Vcl.uTPLb_InfoUtils.hpp | 2 +- hpp/Win32/Release/uTPLb_3DES.hpp | 46 +- hpp/Win32/Release/uTPLb_AES.hpp | 28 +- hpp/Win32/Release/uTPLb_Asymetric.hpp | 72 +- hpp/Win32/Release/uTPLb_Base64.hpp | 18 +- .../Release/uTPLb_BaseNonVisualComponent.hpp | 10 +- hpp/Win32/Release/uTPLb_BinaryUtils.hpp | 4 +- hpp/Win32/Release/uTPLb_BlockCipher.hpp | 44 +- hpp/Win32/Release/uTPLb_BlowFish.hpp | 34 +- hpp/Win32/Release/uTPLb_CBC.hpp | 26 +- hpp/Win32/Release/uTPLb_CFB_8Bit.hpp | 24 +- hpp/Win32/Release/uTPLb_CFB_Block.hpp | 22 +- hpp/Win32/Release/uTPLb_CTR.hpp | 22 +- hpp/Win32/Release/uTPLb_CipherUtils.hpp | 8 +- hpp/Win32/Release/uTPLb_Codec.hpp | 100 +- hpp/Win32/Release/uTPLb_CodecIntf.hpp | 36 +- hpp/Win32/Release/uTPLb_Constants.hpp | 2 +- .../Release/uTPLb_CryptographicLibrary.hpp | 42 +- hpp/Win32/Release/uTPLb_DES.hpp | 28 +- hpp/Win32/Release/uTPLb_Decorators.hpp | 16 +- hpp/Win32/Release/uTPLb_ECB.hpp | 22 +- hpp/Win32/Release/uTPLb_Hash.hpp | 72 +- hpp/Win32/Release/uTPLb_HashDsc.hpp | 16 +- hpp/Win32/Release/uTPLb_HugeCardinal.hpp | 38 +- hpp/Win32/Release/uTPLb_HugeCardinalUtils.hpp | 2 +- hpp/Win32/Release/uTPLb_I18n.hpp | 2 +- hpp/Win32/Release/uTPLb_IntegerUtils.hpp | 2 +- hpp/Win32/Release/uTPLb_MD5.hpp | 20 +- hpp/Win32/Release/uTPLb_MemoryStreamPool.hpp | 10 +- hpp/Win32/Release/uTPLb_OFB.hpp | 22 +- hpp/Win32/Release/uTPLb_PCBC.hpp | 24 +- hpp/Win32/Release/uTPLb_PointerArithmetic.hpp | 2 +- hpp/Win32/Release/uTPLb_RSA_Engine.hpp | 74 +- hpp/Win32/Release/uTPLb_RSA_Primitives.hpp | 2 +- hpp/Win32/Release/uTPLb_Random.hpp | 12 +- hpp/Win32/Release/uTPLb_SHA1.hpp | 20 +- hpp/Win32/Release/uTPLb_SHA2.hpp | 20 +- hpp/Win32/Release/uTPLb_SVN_Keywords.hpp | 4 +- hpp/Win32/Release/uTPLb_Signatory.hpp | 10 +- hpp/Win32/Release/uTPLb_SimpleBlockCipher.hpp | 40 +- hpp/Win32/Release/uTPLb_StrUtils.hpp | 2 +- hpp/Win32/Release/uTPLb_StreamCipher.hpp | 40 +- hpp/Win32/Release/uTPLb_StreamToBlock.hpp | 22 +- hpp/Win32/Release/uTPLb_StreamUtils.hpp | 8 +- hpp/Win32/Release/uTPLb_TwoFish.hpp | 30 +- hpp/Win32/Release/uTPLb_XXTEA.hpp | 24 +- ...r.groupproj => LockBox3CBuilder.groupproj} | 120 +- packages/CBuilder/LockBox3CD.cbproj | 591 +++ packages/CBuilder/LockBox3CD.cpp | 19 + packages/CBuilder/LockBox3CD.res | Bin 0 -> 448 bytes packages/CBuilder/LockBox3CR.cbproj | 95 +- packages/CBuilder/LockBox3FMXCD.cbproj | 89 +- packages/CBuilder/LockBox3VCLCD.cbproj | 79 +- packages/Delphi/LockBox3DD.dpk | 45 + packages/Delphi/LockBox3DD.dproj | 520 +++ packages/Delphi/LockBox3DD.res | Bin 0 -> 448 bytes packages/Delphi/LockBox3DR.dproj | 46 +- ...phi.groupproj => LockBox3Delphi.groupproj} | 120 +- packages/Delphi/LockBox3FMXDD.dproj | 61 +- packages/Delphi/LockBox3VCLDD.dproj | 39 +- 77 files changed, 7733 insertions(+), 724 deletions(-) create mode 100644 LockBox-3.5.2.png create mode 100644 design/FMX.uTPLb_ComponentEditors.pas create mode 100644 design/FMX.uTPLb_ComponentRegistration.pas create mode 100644 design/Vcl.uTPLb_ComponentEditors.pas create mode 100644 design/Vcl.uTPLb_ComponentRegistration.pas create mode 100644 design/uTPLb_ComponentAbout.dfm create mode 100644 design/uTPLb_ComponentAbout.pas create mode 100644 design/uTPLb_ComponentEditors.pas create mode 100644 design/uTPLb_ComponentRegistration.pas create mode 100644 design/uTPLb_InfoUtils.pas rename packages/CBuilder/{CBuilder.groupproj => LockBox3CBuilder.groupproj} (97%) create mode 100644 packages/CBuilder/LockBox3CD.cbproj create mode 100644 packages/CBuilder/LockBox3CD.cpp create mode 100644 packages/CBuilder/LockBox3CD.res create mode 100644 packages/Delphi/LockBox3DD.dpk create mode 100644 packages/Delphi/LockBox3DD.dproj create mode 100644 packages/Delphi/LockBox3DD.res rename packages/Delphi/{Delphi.groupproj => LockBox3Delphi.groupproj} (97%) diff --git a/LockBox-3.5.2.png b/LockBox-3.5.2.png new file mode 100644 index 0000000000000000000000000000000000000000..ba331d25b83438a14746aa72fd9d45e22c7e002f GIT binary patch literal 46820 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 FV1h7hPc8re literal 0 HcmV?d00001 diff --git a/design/FMX.uTPLb_ComponentEditors.pas b/design/FMX.uTPLb_ComponentEditors.pas new file mode 100644 index 0000000..60ef91c --- /dev/null +++ b/design/FMX.uTPLb_ComponentEditors.pas @@ -0,0 +1,483 @@ +{* ***** BEGIN LICENSE BLOCK ***** +Copyright 2009, 2010 Sean B. Durkin +This file is part of TurboPower LockBox 3. TurboPower LockBox 3 is free +software being offered under a dual licensing scheme: LGPL3 or MPL1.1. + +The contents of this file are subject to the Mozilla Public License (MPL) +Version 1.1 (the "License"); you may not use this file except in compliance +with the License. You may obtain a copy of the License at +http://www.mozilla.org/MPL/ + +Alternatively, you may redistribute it and/or modify it under the terms of +the GNU Lesser General Public License (LGPL) as published by the Free Software +Foundation, either version 3 of the License, or (at your option) any later +version. + +You should have received a copy of the Lesser GNU General Public License +along with TurboPower LockBox 3. If not, see . + +TurboPower LockBox is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. In relation to LGPL, +see the GNU Lesser General Public License for more details. In relation to MPL, +see the MPL License for the specific language governing rights and limitations +under the License. + +The Initial Developer of the Original Code for TurboPower LockBox version 2 +and earlier was TurboPower Software. + + * ***** END LICENSE BLOCK ***** *} + +unit FMX.uTPLb_ComponentEditors; + +interface + +procedure Register; + +implementation + +uses Classes, TypInfo, DesignIntf, DesignEditors, SysUtils, + uTPLb_Hash, uTPLb_CryptographicLibrary, FMX.uTPLb_ComponentAbout, + uTPLb_BaseNonVisualComponent, uTPLb_HashDsc, uTPLb_Codec, + uTPLb_BlockCipher, uTPLb_Signatory, uTPLb_I18n; + +type +TLockBoxEditor = class( TStringProperty) + public + function GetAttributes: TPropertyAttributes; override; + procedure Edit; override; + end; + + +THashEditor2 = class( TStringProperty, IProperty) + protected + function GetEditValue2( out Value: string): Boolean; virtual; + function IProperty.GetEditValue = GetEditValue2; + function SharedNonEmptyLibrary: Boolean; + + public + function GetAttributes: TPropertyAttributes; override; + procedure GetValues(Proc: TGetStrProc); override; + procedure SetValue( const Value: string); override; + end; + +TCipherEditor = class( TStringProperty, IProperty) + protected + function GetEditValue2( out Value: string): Boolean; virtual; + function IProperty.GetEditValue = GetEditValue2; + function SharedNonEmptyLibrary: Boolean; + + public + function GetAttributes: TPropertyAttributes; override; + procedure GetValues(Proc: TGetStrProc); override; + procedure SetValue( const Value: string); override; + end; + +TChainEditor = class( TCipherEditor) + public + procedure GetValues(Proc: TGetStrProc); override; + procedure SetValue( const Value: string); override; + end; + + +procedure Register; +begin +RegisterPropertyEditor( TypeInfo( string), TTPLb_BaseNonVisualComponent, 'About', TLockBoxEditor); +RegisterPropertyEditor( TypeInfo( string), THash, 'Hash', THashEditor2); +RegisterPropertyEditor( TypeInfo( string), TCodec, 'Cipher', TCipherEditor); +RegisterPropertyEditor( TypeInfo( string), TCodec, 'ChainMode', TChainEditor) +end; + + + + +{ THashEditor2 } + +function THashEditor2.GetAttributes: TPropertyAttributes; +begin +result := [ paValueList, paSortList, paMultiSelect, + paRevertable + +{$IF compilerversion >= 16} + // Delphi 2005 or above + , paReadOnly, paValueEditable +{$ELSE} + // Delphi 7 or below: Nothing more. +// paSubProperties, paMultiSelect, +// paAutoUpdate, paSortList, paFullWidthName, +// paVolatileSubProperties, paVCL, paNotNestable + +{$IFEND} + + ] +end; + + +function THashEditor2.SharedNonEmptyLibrary: Boolean; +var + HashComp: THash; + Lib, Lib2: TCryptographicLibrary; + j: integer; +begin +result := False; +Lib2 := nil; +if PropCount >= 1 then + begin + if GetComponent( 0) is THash then + HashComp := THash( GetComponent( 0)) + else + HashComp := nil; + if assigned( HashComp) then + Lib := HashComp.CryptoLibrary + else + Lib := nil; + result := assigned( Lib); + if not result then exit; + for j := 1 to PropCount - 1 do + begin + if GetComponent( j) is THash then + HashComp := THash( GetComponent( 0)) + else + HashComp := nil; + if assigned( HashComp) then + Lib2 := HashComp.CryptoLibrary + else + Lib := nil; + result := Lib = Lib2; + if not result then break + end + end +end; + + + + +function THashEditor2.GetEditValue2( out Value: string): Boolean; +begin +result := GetEditValue( Value); +if not result then exit; +result := SharedNonEmptyLibrary; +if not result then + Value := DS_MixedLibraries +end; + + + +procedure THashEditor2.GetValues( Proc: TGetStrProc); +var + HashComp: THash; + Lib: TCryptographicLibrary; + j: integer; + HashChoices: IInterfaceList; + Hash: IHashDsc; +begin +if (PropCount >= 1) and (GetComponent( 0) is THash) then + HashComp := THash( GetComponent( 0)) + else + HashComp := nil; +if assigned( HashComp) then + Lib := HashComp.CryptoLibrary + else + Lib := nil; +if not assigned( Lib) then exit; +HashChoices := Lib.GetHashChoices; +for j := 0 to HashChoices.Count - 1 do + if Supports( HashChoices[j], IHashDsc, Hash) then + Proc( Lib.ComputeHashDisplayName( Hash)) +end; + + + +procedure THashEditor2.SetValue( const Value: string); +var + HashComp: THash; + Lib: TCryptographicLibrary; + j: integer; + ProgId: string; + HashChoices: IInterfaceList; + Hash: IHashDsc; +begin +if not SharedNonEmptyLibrary then exit; +if (PropCount >= 1) and (GetComponent( 0) is THash) then + HashComp := THash( GetComponent( 0)) + else + HashComp := nil; +if assigned( HashComp) then + Lib := HashComp.CryptoLibrary + else + Lib := nil; +ProgId := ''; +HashChoices := Lib.GetHashChoices; +if assigned( Lib) then + for j := 0 to HashChoices.Count - 1 do + if Supports( HashChoices[j], IHashDsc, Hash) then + begin + if Value <> Lib.ComputeHashDisplayName( Hash) then continue; + ProgId := Hash.ProgId; + break + end; +if ProgId = '' then exit; +for j := 0 to PropCount - 1 do + begin + if GetComponent( j) is THash then + HashComp := THash( GetComponent( j)) + else + HashComp := nil; + HashComp.HashId := ProgId + end; +Modified +end; + +{ TLockBoxEditor } + +procedure TLockBoxEditor.Edit; +var + doCreate: boolean; + SelectedComponent: TComponent; +begin +doCreate := not assigned( TPLb_fmComponentAbout); +if doCreate then + TPLb_fmComponentAbout := TTPLb_fmComponentAbout.Create( nil); +try + if (PropCount >= 1) and (GetComponent( 0) is TComponent) then + SelectedComponent := TComponent( GetComponent( 0)) + else + SelectedComponent := nil; + TPLb_fmComponentAbout.UpdateAbout( SelectedComponent); + if not doCreate then + begin + TPLb_fmComponentAbout.Show; + TPLb_fmComponentAbout.BringToFront + end; + TPLb_fmComponentAbout.ShowModal +finally +if doCreate then + begin + TPLb_fmComponentAbout.Release; + TPLb_fmComponentAbout := nil + end +end end; + + + + +function TLockBoxEditor.GetAttributes: TPropertyAttributes; +begin +result := [paDialog, paReadOnly, paMultiSelect] +end; + +{ TCipherEditor } + +function TCipherEditor.GetAttributes: TPropertyAttributes; +begin +result := [ paValueList, paSortList, paMultiSelect, + paRevertable + +{$IF compilerversion >= 16} + // Delphi 2005 or above + , paReadOnly, paValueEditable +{$ELSE} + // Delphi 7 or below: Nothing more. +{$IFEND} + + ] +end; + +function TCipherEditor.GetEditValue2( out Value: string): Boolean; +begin +result := GetEditValue( Value); +if not result then exit; +result := SharedNonEmptyLibrary; +if not result then + Value := DS_MixedLibraries +end; + + +procedure TCipherEditor.GetValues( Proc: TGetStrProc); +var + CodecComp: TCodec; + Lib: TCryptographicLibrary; + j: integer; + CipherChoices: IInterfaceList; + CipherChoice: ICipherChoice; + CipherDisplayName: string; + isBlockCipher: boolean; + StreamCipherId: string; + BlockCipherId: string; +begin +if (PropCount >= 1) and (GetComponent( 0) is TCodec) then + CodecComp := TCodec( GetComponent( 0)) + else + CodecComp := nil; +if assigned( CodecComp) then + Lib := CodecComp.CryptoLibrary + else + Lib := nil; +if not assigned( Lib) then exit; +CipherChoices := Lib.GetCipherChoices; +for j := 0 to CipherChoices.Count - 1 do + if Supports( CipherChoices[j], ICipherChoice, CipherChoice) then + begin + CipherChoice.GetChoiceParams( + CipherDisplayName, isBlockCipher, StreamCipherId, BlockCipherId); + Proc( CipherDisplayName) + end +end; + + +procedure TCipherEditor.SetValue( const Value: string); +var + CodecComp: TCodec; + Lib: TCryptographicLibrary; + j: integer; + ProgId: string; + CipherChoices: IInterfaceList; + CipherChoice: ICipherChoice; + CipherDisplayName: string; + isBlockCipher: boolean; + StreamCipherId: string; + BlockCipherId: string; + Found: boolean; +begin +if not SharedNonEmptyLibrary then exit; +if (PropCount >= 1) and (GetComponent( 0) is TCodec) then + CodecComp := TCodec( GetComponent( 0)) + else + CodecComp := nil; +if assigned( CodecComp) then + Lib := CodecComp.CryptoLibrary + else + Lib := nil; +ProgId := ''; +CipherChoices := Lib.GetCipherChoices; +Found := False; +if assigned( Lib) then + for j := 0 to CipherChoices.Count - 1 do + if Supports( CipherChoices[j], ICipherChoice, CipherChoice) then + begin + CipherChoice.GetChoiceParams( + CipherDisplayName, isBlockCipher, StreamCipherId, BlockCipherId); + if Value <> CipherDisplayName then continue; + Found := True; + break + end; +if not Found then exit; +for j := 0 to PropCount - 1 do + begin + if GetComponent( j) is TCodec then + CodecComp := TCodec( GetComponent( j)) + else + CodecComp := nil; + CodecComp.StreamCipherId := StreamCipherId; + CodecComp.BlockCipherId := BlockCipherId + end; +Modified +end; + + + +function TCipherEditor.SharedNonEmptyLibrary: Boolean; +var + CodecComp: TCodec; + Lib, Lib2: TCryptographicLibrary; + j: integer; +begin +result := False; +Lib2 := nil; +if PropCount >= 1 then + begin + if GetComponent( 0) is TCodec then + CodecComp := TCodec( GetComponent( 0)) + else + CodecComp := nil; + if assigned( CodecComp) then + Lib := CodecComp.CryptoLibrary + else + Lib := nil; + result := assigned( Lib); + if not result then exit; + for j := 1 to PropCount - 1 do + begin + if GetComponent( j) is TCodec then + CodecComp := TCodec( GetComponent( 0)) + else + CodecComp := nil; + if assigned( CodecComp) then + Lib2 := CodecComp.CryptoLibrary + else + Lib := nil; + result := Lib = Lib2; + if not result then break + end + end +end; + +{ TChainEditor } + +procedure TChainEditor.GetValues( Proc: TGetStrProc); +var + CodecComp: TCodec; + Lib: TCryptographicLibrary; + j: integer; + ChainChoices: IInterfaceList; + ChainChoice: IBlockChainingModel; +begin +if (PropCount >= 1) and (GetComponent( 0) is TCodec) then + CodecComp := TCodec( GetComponent( 0)) + else + CodecComp := nil; +if assigned( CodecComp) then + Lib := CodecComp.CryptoLibrary + else + Lib := nil; +if not assigned( Lib) then exit; +ChainChoices := Lib.GetChainChoices; +for j := 0 to ChainChoices.Count - 1 do + if Supports( ChainChoices[j], IBlockChainingModel, ChainChoice) then + Proc( Lib.ComputeChainDisplayName( ChainChoice)) +end; + + + + +procedure TChainEditor.SetValue( const Value: string); +var + CodecComp: TCodec; + Lib: TCryptographicLibrary; + j: integer; + ChainChoices: IInterfaceList; + ChainChoice: IBlockChainingModel; + Found: boolean; +begin +if not SharedNonEmptyLibrary then exit; +if (PropCount >= 1) and (GetComponent( 0) is TCodec) then + CodecComp := TCodec( GetComponent( 0)) + else + CodecComp := nil; +if assigned( CodecComp) then + Lib := CodecComp.CryptoLibrary + else + Lib := nil; +ChainChoices := Lib.GetChainChoices; +Found := False; +if assigned( Lib) then + for j := 0 to ChainChoices.Count - 1 do + if Supports( ChainChoices[j], IBlockChainingModel, ChainChoice) then + begin + if Value <> Lib.ComputeChainDisplayName( ChainChoice) then continue; + Found := True; + break + end; +if not Found then exit; +for j := 0 to PropCount - 1 do + begin + if GetComponent( j) is TCodec then + CodecComp := TCodec( GetComponent( j)) + else + CodecComp := nil; + CodecComp.ChainModeId := ChainChoice.ProgId + end; +Modified +end; + +end. diff --git a/design/FMX.uTPLb_ComponentRegistration.pas b/design/FMX.uTPLb_ComponentRegistration.pas new file mode 100644 index 0000000..04f9841 --- /dev/null +++ b/design/FMX.uTPLb_ComponentRegistration.pas @@ -0,0 +1,58 @@ +{* ***** BEGIN LICENSE BLOCK ***** +Copyright 2009, 2010 Sean B. Durkin +This file is part of TurboPower LockBox 3. TurboPower LockBox 3 is free +software being offered under a dual licensing scheme: LGPL3 or MPL1.1. + +The contents of this file are subject to the Mozilla Public License (MPL) +Version 1.1 (the "License"); you may not use this file except in compliance +with the License. You may obtain a copy of the License at +http://www.mozilla.org/MPL/ + +Alternatively, you may redistribute it and/or modify it under the terms of +the GNU Lesser General Public License (LGPL) as published by the Free Software +Foundation, either version 3 of the License, or (at your option) any later +version. + +You should have received a copy of the Lesser GNU General Public License +along with TurboPower LockBox 3. If not, see . + +TurboPower LockBox is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. In relation to LGPL, +see the GNU Lesser General Public License for more details. In relation to MPL, +see the MPL License for the specific language governing rights and limitations +under the License. + +The Initial Developer of the Original Code for TurboPower LockBox version 2 +and earlier was TurboPower Software. + + * ***** END LICENSE BLOCK ***** *} + +unit FMX.uTPLb_ComponentRegistration; + +interface + +procedure Register; + +implementation + +{$R 'LockBox3.dcr'} + +uses + System.Classes, FMX.Types, FMX.Controls, uTPLb_Hash, uTPLb_CryptographicLibrary, + uTPLb_Codec, uTPLb_Signatory; + +procedure Register; +begin + GroupDescendentsWith(THash, FMX.Controls.TControl); + GroupDescendentsWith(TCodec, FMX.Controls.TControl); + GroupDescendentsWith(TCryptographicLibrary, FMX.Controls.TControl); + GroupDescendentsWith(TSignatory, FMX.Controls.TControl); + + RegisterFmxClasses([THash, TCodec, TCryptographicLibrary, TSignatory]); + + RegisterComponents( 'LockBox', [THash, TCodec, TCryptographicLibrary, TSignatory]) +end; + + +end. diff --git a/design/Vcl.uTPLb_ComponentEditors.pas b/design/Vcl.uTPLb_ComponentEditors.pas new file mode 100644 index 0000000..341a390 --- /dev/null +++ b/design/Vcl.uTPLb_ComponentEditors.pas @@ -0,0 +1,483 @@ +{* ***** BEGIN LICENSE BLOCK ***** +Copyright 2009, 2010 Sean B. Durkin +This file is part of TurboPower LockBox 3. TurboPower LockBox 3 is free +software being offered under a dual licensing scheme: LGPL3 or MPL1.1. + +The contents of this file are subject to the Mozilla Public License (MPL) +Version 1.1 (the "License"); you may not use this file except in compliance +with the License. You may obtain a copy of the License at +http://www.mozilla.org/MPL/ + +Alternatively, you may redistribute it and/or modify it under the terms of +the GNU Lesser General Public License (LGPL) as published by the Free Software +Foundation, either version 3 of the License, or (at your option) any later +version. + +You should have received a copy of the Lesser GNU General Public License +along with TurboPower LockBox 3. If not, see . + +TurboPower LockBox is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. In relation to LGPL, +see the GNU Lesser General Public License for more details. In relation to MPL, +see the MPL License for the specific language governing rights and limitations +under the License. + +The Initial Developer of the Original Code for TurboPower LockBox version 2 +and earlier was TurboPower Software. + + * ***** END LICENSE BLOCK ***** *} + +unit Vcl.uTPLb_ComponentEditors; + +interface + +procedure Register; + +implementation + +uses Classes, TypInfo, DesignIntf, DesignEditors, VCLEditors, SysUtils, + uTPLb_Hash, uTPLb_CryptographicLibrary, Vcl.uTPLb_ComponentAbout, + uTPLb_BaseNonVisualComponent, uTPLb_HashDsc, uTPLb_Codec, + uTPLb_BlockCipher, uTPLb_Signatory, uTPLb_I18n; + +type +TLockBoxEditor = class( TStringProperty) + public + function GetAttributes: TPropertyAttributes; override; + procedure Edit; override; + end; + + +THashEditor2 = class( TStringProperty, IProperty) + protected + function GetEditValue2( out Value: string): Boolean; virtual; + function IProperty.GetEditValue = GetEditValue2; + function SharedNonEmptyLibrary: Boolean; + + public + function GetAttributes: TPropertyAttributes; override; + procedure GetValues(Proc: TGetStrProc); override; + procedure SetValue( const Value: string); override; + end; + +TCipherEditor = class( TStringProperty, IProperty) + protected + function GetEditValue2( out Value: string): Boolean; virtual; + function IProperty.GetEditValue = GetEditValue2; + function SharedNonEmptyLibrary: Boolean; + + public + function GetAttributes: TPropertyAttributes; override; + procedure GetValues(Proc: TGetStrProc); override; + procedure SetValue( const Value: string); override; + end; + +TChainEditor = class( TCipherEditor) + public + procedure GetValues(Proc: TGetStrProc); override; + procedure SetValue( const Value: string); override; + end; + + +procedure Register; +begin +RegisterPropertyEditor( TypeInfo( string), TTPLb_BaseNonVisualComponent, 'About', TLockBoxEditor); +RegisterPropertyEditor( TypeInfo( string), THash, 'Hash', THashEditor2); +RegisterPropertyEditor( TypeInfo( string), TCodec, 'Cipher', TCipherEditor); +RegisterPropertyEditor( TypeInfo( string), TCodec, 'ChainMode', TChainEditor) +end; + + + + +{ THashEditor2 } + +function THashEditor2.GetAttributes: TPropertyAttributes; +begin +result := [ paValueList, paSortList, paMultiSelect, + paRevertable + +{$IF compilerversion >= 16} + // Delphi 2005 or above + , paReadOnly, paValueEditable +{$ELSE} + // Delphi 7 or below: Nothing more. +// paSubProperties, paMultiSelect, +// paAutoUpdate, paSortList, paFullWidthName, +// paVolatileSubProperties, paVCL, paNotNestable + +{$IFEND} + + ] +end; + + +function THashEditor2.SharedNonEmptyLibrary: Boolean; +var + HashComp: THash; + Lib, Lib2: TCryptographicLibrary; + j: integer; +begin +result := False; +Lib2 := nil; +if PropCount >= 1 then + begin + if GetComponent( 0) is THash then + HashComp := THash( GetComponent( 0)) + else + HashComp := nil; + if assigned( HashComp) then + Lib := HashComp.CryptoLibrary + else + Lib := nil; + result := assigned( Lib); + if not result then exit; + for j := 1 to PropCount - 1 do + begin + if GetComponent( j) is THash then + HashComp := THash( GetComponent( 0)) + else + HashComp := nil; + if assigned( HashComp) then + Lib2 := HashComp.CryptoLibrary + else + Lib := nil; + result := Lib = Lib2; + if not result then break + end + end +end; + + + + +function THashEditor2.GetEditValue2( out Value: string): Boolean; +begin +result := GetEditValue( Value); +if not result then exit; +result := SharedNonEmptyLibrary; +if not result then + Value := DS_MixedLibraries +end; + + + +procedure THashEditor2.GetValues( Proc: TGetStrProc); +var + HashComp: THash; + Lib: TCryptographicLibrary; + j: integer; + HashChoices: IInterfaceList; + Hash: IHashDsc; +begin +if (PropCount >= 1) and (GetComponent( 0) is THash) then + HashComp := THash( GetComponent( 0)) + else + HashComp := nil; +if assigned( HashComp) then + Lib := HashComp.CryptoLibrary + else + Lib := nil; +if not assigned( Lib) then exit; +HashChoices := Lib.GetHashChoices; +for j := 0 to HashChoices.Count - 1 do + if Supports( HashChoices[j], IHashDsc, Hash) then + Proc( Lib.ComputeHashDisplayName( Hash)) +end; + + + +procedure THashEditor2.SetValue( const Value: string); +var + HashComp: THash; + Lib: TCryptographicLibrary; + j: integer; + ProgId: string; + HashChoices: IInterfaceList; + Hash: IHashDsc; +begin +if not SharedNonEmptyLibrary then exit; +if (PropCount >= 1) and (GetComponent( 0) is THash) then + HashComp := THash( GetComponent( 0)) + else + HashComp := nil; +if assigned( HashComp) then + Lib := HashComp.CryptoLibrary + else + Lib := nil; +ProgId := ''; +HashChoices := Lib.GetHashChoices; +if assigned( Lib) then + for j := 0 to HashChoices.Count - 1 do + if Supports( HashChoices[j], IHashDsc, Hash) then + begin + if Value <> Lib.ComputeHashDisplayName( Hash) then continue; + ProgId := Hash.ProgId; + break + end; +if ProgId = '' then exit; +for j := 0 to PropCount - 1 do + begin + if GetComponent( j) is THash then + HashComp := THash( GetComponent( j)) + else + HashComp := nil; + HashComp.HashId := ProgId + end; +Modified +end; + +{ TLockBoxEditor } + +procedure TLockBoxEditor.Edit; +var + doCreate: boolean; + SelectedComponent: TComponent; +begin +doCreate := not assigned( TPLb_fmComponentAbout); +if doCreate then + TPLb_fmComponentAbout := TTPLb_fmComponentAbout.Create( nil); +try + if (PropCount >= 1) and (GetComponent( 0) is TComponent) then + SelectedComponent := TComponent( GetComponent( 0)) + else + SelectedComponent := nil; + TPLb_fmComponentAbout.UpdateAbout( SelectedComponent); + if not doCreate then + begin + TPLb_fmComponentAbout.Show; + TPLb_fmComponentAbout.BringToFront + end; + TPLb_fmComponentAbout.ShowModal +finally +if doCreate then + begin + TPLb_fmComponentAbout.Release; + TPLb_fmComponentAbout := nil + end +end end; + + + + +function TLockBoxEditor.GetAttributes: TPropertyAttributes; +begin +result := [paDialog, paReadOnly, paMultiSelect] +end; + +{ TCipherEditor } + +function TCipherEditor.GetAttributes: TPropertyAttributes; +begin +result := [ paValueList, paSortList, paMultiSelect, + paRevertable + +{$IF compilerversion >= 16} + // Delphi 2005 or above + , paReadOnly, paValueEditable +{$ELSE} + // Delphi 7 or below: Nothing more. +{$IFEND} + + ] +end; + +function TCipherEditor.GetEditValue2( out Value: string): Boolean; +begin +result := GetEditValue( Value); +if not result then exit; +result := SharedNonEmptyLibrary; +if not result then + Value := DS_MixedLibraries +end; + + +procedure TCipherEditor.GetValues( Proc: TGetStrProc); +var + CodecComp: TCodec; + Lib: TCryptographicLibrary; + j: integer; + CipherChoices: IInterfaceList; + CipherChoice: ICipherChoice; + CipherDisplayName: string; + isBlockCipher: boolean; + StreamCipherId: string; + BlockCipherId: string; +begin +if (PropCount >= 1) and (GetComponent( 0) is TCodec) then + CodecComp := TCodec( GetComponent( 0)) + else + CodecComp := nil; +if assigned( CodecComp) then + Lib := CodecComp.CryptoLibrary + else + Lib := nil; +if not assigned( Lib) then exit; +CipherChoices := Lib.GetCipherChoices; +for j := 0 to CipherChoices.Count - 1 do + if Supports( CipherChoices[j], ICipherChoice, CipherChoice) then + begin + CipherChoice.GetChoiceParams( + CipherDisplayName, isBlockCipher, StreamCipherId, BlockCipherId); + Proc( CipherDisplayName) + end +end; + + +procedure TCipherEditor.SetValue( const Value: string); +var + CodecComp: TCodec; + Lib: TCryptographicLibrary; + j: integer; + ProgId: string; + CipherChoices: IInterfaceList; + CipherChoice: ICipherChoice; + CipherDisplayName: string; + isBlockCipher: boolean; + StreamCipherId: string; + BlockCipherId: string; + Found: boolean; +begin +if not SharedNonEmptyLibrary then exit; +if (PropCount >= 1) and (GetComponent( 0) is TCodec) then + CodecComp := TCodec( GetComponent( 0)) + else + CodecComp := nil; +if assigned( CodecComp) then + Lib := CodecComp.CryptoLibrary + else + Lib := nil; +ProgId := ''; +CipherChoices := Lib.GetCipherChoices; +Found := False; +if assigned( Lib) then + for j := 0 to CipherChoices.Count - 1 do + if Supports( CipherChoices[j], ICipherChoice, CipherChoice) then + begin + CipherChoice.GetChoiceParams( + CipherDisplayName, isBlockCipher, StreamCipherId, BlockCipherId); + if Value <> CipherDisplayName then continue; + Found := True; + break + end; +if not Found then exit; +for j := 0 to PropCount - 1 do + begin + if GetComponent( j) is TCodec then + CodecComp := TCodec( GetComponent( j)) + else + CodecComp := nil; + CodecComp.StreamCipherId := StreamCipherId; + CodecComp.BlockCipherId := BlockCipherId + end; +Modified +end; + + + +function TCipherEditor.SharedNonEmptyLibrary: Boolean; +var + CodecComp: TCodec; + Lib, Lib2: TCryptographicLibrary; + j: integer; +begin +result := False; +Lib2 := nil; +if PropCount >= 1 then + begin + if GetComponent( 0) is TCodec then + CodecComp := TCodec( GetComponent( 0)) + else + CodecComp := nil; + if assigned( CodecComp) then + Lib := CodecComp.CryptoLibrary + else + Lib := nil; + result := assigned( Lib); + if not result then exit; + for j := 1 to PropCount - 1 do + begin + if GetComponent( j) is TCodec then + CodecComp := TCodec( GetComponent( 0)) + else + CodecComp := nil; + if assigned( CodecComp) then + Lib2 := CodecComp.CryptoLibrary + else + Lib := nil; + result := Lib = Lib2; + if not result then break + end + end +end; + +{ TChainEditor } + +procedure TChainEditor.GetValues( Proc: TGetStrProc); +var + CodecComp: TCodec; + Lib: TCryptographicLibrary; + j: integer; + ChainChoices: IInterfaceList; + ChainChoice: IBlockChainingModel; +begin +if (PropCount >= 1) and (GetComponent( 0) is TCodec) then + CodecComp := TCodec( GetComponent( 0)) + else + CodecComp := nil; +if assigned( CodecComp) then + Lib := CodecComp.CryptoLibrary + else + Lib := nil; +if not assigned( Lib) then exit; +ChainChoices := Lib.GetChainChoices; +for j := 0 to ChainChoices.Count - 1 do + if Supports( ChainChoices[j], IBlockChainingModel, ChainChoice) then + Proc( Lib.ComputeChainDisplayName( ChainChoice)) +end; + + + + +procedure TChainEditor.SetValue( const Value: string); +var + CodecComp: TCodec; + Lib: TCryptographicLibrary; + j: integer; + ChainChoices: IInterfaceList; + ChainChoice: IBlockChainingModel; + Found: boolean; +begin +if not SharedNonEmptyLibrary then exit; +if (PropCount >= 1) and (GetComponent( 0) is TCodec) then + CodecComp := TCodec( GetComponent( 0)) + else + CodecComp := nil; +if assigned( CodecComp) then + Lib := CodecComp.CryptoLibrary + else + Lib := nil; +ChainChoices := Lib.GetChainChoices; +Found := False; +if assigned( Lib) then + for j := 0 to ChainChoices.Count - 1 do + if Supports( ChainChoices[j], IBlockChainingModel, ChainChoice) then + begin + if Value <> Lib.ComputeChainDisplayName( ChainChoice) then continue; + Found := True; + break + end; +if not Found then exit; +for j := 0 to PropCount - 1 do + begin + if GetComponent( j) is TCodec then + CodecComp := TCodec( GetComponent( j)) + else + CodecComp := nil; + CodecComp.ChainModeId := ChainChoice.ProgId + end; +Modified +end; + +end. diff --git a/design/Vcl.uTPLb_ComponentRegistration.pas b/design/Vcl.uTPLb_ComponentRegistration.pas new file mode 100644 index 0000000..8fac747 --- /dev/null +++ b/design/Vcl.uTPLb_ComponentRegistration.pas @@ -0,0 +1,50 @@ +{* ***** BEGIN LICENSE BLOCK ***** +Copyright 2009, 2010 Sean B. Durkin +This file is part of TurboPower LockBox 3. TurboPower LockBox 3 is free +software being offered under a dual licensing scheme: LGPL3 or MPL1.1. + +The contents of this file are subject to the Mozilla Public License (MPL) +Version 1.1 (the "License"); you may not use this file except in compliance +with the License. You may obtain a copy of the License at +http://www.mozilla.org/MPL/ + +Alternatively, you may redistribute it and/or modify it under the terms of +the GNU Lesser General Public License (LGPL) as published by the Free Software +Foundation, either version 3 of the License, or (at your option) any later +version. + +You should have received a copy of the Lesser GNU General Public License +along with TurboPower LockBox 3. If not, see . + +TurboPower LockBox is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. In relation to LGPL, +see the GNU Lesser General Public License for more details. In relation to MPL, +see the MPL License for the specific language governing rights and limitations +under the License. + +The Initial Developer of the Original Code for TurboPower LockBox version 2 +and earlier was TurboPower Software. + + * ***** END LICENSE BLOCK ***** *} + +unit Vcl.uTPLb_ComponentRegistration; + +interface + +procedure Register; + +implementation + +{$R 'LockBox3.dcr'} + +uses + Classes, uTPLb_Hash, uTPLb_CryptographicLibrary, uTPLb_Codec, uTPLb_Signatory; + +procedure Register; +begin + RegisterComponents( 'LockBox', [THash, TCodec, TCryptographicLibrary, TSignatory]) +end; + + +end. diff --git a/design/uTPLb_ComponentAbout.dfm b/design/uTPLb_ComponentAbout.dfm new file mode 100644 index 0000000..a46d0ed --- /dev/null +++ b/design/uTPLb_ComponentAbout.dfm @@ -0,0 +1,3191 @@ +object TPLb_fmComponentAbout: TTPLb_fmComponentAbout + Left = 0 + Top = 0 + Caption = 'Component About' + ClientHeight = 442 + ClientWidth = 640 + Color = clBtnFace + Font.Charset = DEFAULT_CHARSET + Font.Color = clWindowText + Font.Height = -11 + Font.Name = 'Tahoma' + Font.Style = [] + OldCreateOrder = False + OnCreate = FormCreate + DesignSize = ( + 640 + 442) + PixelsPerInch = 96 + TextHeight = 13 + object pnlAbout: TPanel + Left = 0 + Top = 0 + Width = 641 + Height = 410 + Anchors = [akLeft, akTop, akRight, akBottom] + Caption = 'About Box to be developed!' + TabOrder = 0 + object pgAboutContent: TPageControl + Left = 1 + Top = 1 + Width = 639 + Height = 408 + ActivePage = tsMain + Align = alClient + TabOrder = 0 + object tsMain: TTabSheet + Caption = 'Main' + DesignSize = ( + 631 + 380) + object Image1: TImage + Left = 0 + Top = 0 + Width = 225 + Height = 329 + Picture.Data = { + 0A544A504547496D6167659E020100FFD8FFE000104A46494600010101004800 + 480000FFE1004045786966000049492A0008000000010069870400010000001A + 000000000000000100869202000B0000002C000000000000004170706C654D61 + 726B0A0000FFE20C444943435F50524F46494C4500010100000C346170706C02 + 1000006D6E74725247422058595A2007CF000C00030011001E00006163737041 + 50504C0000000049454320735247420000000000000000000000000000F6D600 + 0100000000D32D48502020000000000000000000000000000000000000000000 + 0000000000000000000000000000000000000000000000000000116370727400 + 0001500000003364657363000001840000007377747074000001F80000001462 + 6B70740000020C000000147258595A00000220000000146758595A0000023400 + 0000146258595A0000024800000014646D6E640000025C0000005F646D646400 + 0002BC0000007976756564000003380000008676696577000003C0000000246C + 756D69000003E4000000146D656173000003F800000024746563680000041C00 + 00000C72545243000004280000080C67545243000004280000080C6254524300 + 0004280000080C7465787400000000436F707972696768742028632920313939 + 39204865776C6574742D5061636B61726420436F6D70616E7900006465736300 + 00000000000019735247422049454336313936362D322E312039393132303300 + 0000000000000000000019735247422049454336313936362D322E3120393931 + 3230330000000000000000000000000000000000000000000000000000000000 + 00000000000000000000000000000058595A20000000000000F3510001000000 + 0116CC58595A200000000000000000000000000000000058595A200000000000 + 006FA2000038F50000039058595A2000000000000062990000B785000018DA58 + 595A2000000000000024A000000F840000B6CF64657363000000000000000549 + 4543200000000000000000000000054945432000000000000000000000000000 + 0000000000000000000000000000000000000000000000000000000000000000 + 0000000000000000000000000000000000000064657363000000000000001F73 + 524742204945432036313936362D322E31207352474220393931323033000000 + 00000000000000001F73524742204945432036313936362D322E312073524742 + 2039393132303300000000000000000000000000000000000000000000000000 + 00000000000000000000000000000064657363000000000000002C5265666572 + 656E63652056696577696E6720436F6E646974696F6E20696E20494543363139 + 36362D322E3100000000000000000000002C5265666572656E63652056696577 + 696E6720436F6E646974696F6E20696E2049454336313936362D322E31000000 + 0000000000000000000000000000000000000000000000766965770000000000 + 13A4FE00145F2E0010CF140003EDCC0004130B00035C9E0000000158595A2000 + 000000004C09560050000000571FE76D65617300000000000000010000000000 + 00000000000000000000000000028F0000000273696720000000004352542063 + 757276000000000000040000000005000A000F00140019001E00230028002D00 + 320037003B00400045004A004F00540059005E00630068006D00720077007C00 + 810086008B00900095009A009F00A400A900AE00B200B700BC00C100C600CB00 + D000D500DB00E000E500EB00F000F600FB01010107010D01130119011F012501 + 2B01320138013E0145014C0152015901600167016E0175017C0183018B019201 + 9A01A101A901B101B901C101C901D101D901E101E901F201FA0203020C021402 + 1D0226022F02380241024B0254025D02670271027A0284028E029802A202AC02 + B602C102CB02D502E002EB02F50300030B03160321032D03380343034F035A03 + 660372037E038A039603A203AE03BA03C703D303E003EC03F904060413042004 + 2D043B0448045504630471047E048C049A04A804B604C404D304E104F004FE05 + 0D051C052B053A05490558056705770586059605A605B505C505D505E505F606 + 0606160627063706480659066A067B068C069D06AF06C006D106E306F5070707 + 19072B073D074F076107740786079907AC07BF07D207E507F8080B081F083208 + 46085A086E0882089608AA08BE08D208E708FB09100925093A094F0964097909 + 8F09A409BA09CF09E509FB0A110A270A3D0A540A6A0A810A980AAE0AC50ADC0A + F30B0B0B220B390B510B690B800B980BB00BC80BE10BF90C120C2A0C430C5C0C + 750C8E0CA70CC00CD90CF30D0D0D260D400D5A0D740D8E0DA90DC30DDE0DF80E + 130E2E0E490E640E7F0E9B0EB60ED20EEE0F090F250F410F5E0F7A0F960FB30F + CF0FEC1009102610431061107E109B10B910D710F511131131114F116D118C11 + AA11C911E81207122612451264128412A312C312E31303132313431363138313 + A413C513E5140614271449146A148B14AD14CE14F01512153415561578159B15 + BD15E0160316261649166C168F16B216D616FA171D17411765178917AE17D217 + F7181B18401865188A18AF18D518FA19201945196B199119B719DD1A041A2A1A + 511A771A9E1AC51AEC1B141B3B1B631B8A1BB21BDA1C021C2A1C521C7B1CA31C + CC1CF51D1E1D471D701D991DC31DEC1E161E401E6A1E941EBE1EE91F131F3E1F + 691F941FBF1FEA20152041206C209820C420F0211C2148217521A121CE21FB22 + 272255228222AF22DD230A23382366239423C223F0241F244D247C24AB24DA25 + 0925382568259725C725F726272657268726B726E827182749277A27AB27DC28 + 0D283F287128A228D429062938296B299D29D02A022A352A682A9B2ACF2B022B + 362B692B9D2BD12C052C392C6E2CA22CD72D0C2D412D762DAB2DE12E162E4C2E + 822EB72EEE2F242F5A2F912FC72FFE3035306C30A430DB3112314A318231BA31 + F2322A3263329B32D4330D3346337F33B833F1342B3465349E34D83513354D35 + 8735C235FD3637367236AE36E937243760379C37D738143850388C38C8390539 + 42397F39BC39F93A363A743AB23AEF3B2D3B6B3BAA3BE83C273C653CA43CE33D + 223D613DA13DE03E203E603EA03EE03F213F613FA23FE24023406440A640E741 + 29416A41AC41EE4230427242B542F7433A437D43C044034447448A44CE451245 + 55459A45DE4622466746AB46F04735477B47C04805484B489148D7491D496349 + A949F04A374A7D4AC44B0C4B534B9A4BE24C2A4C724CBA4D024D4A4D934DDC4E + 254E6E4EB74F004F494F934FDD5027507150BB51065150519B51E65231527C52 + C75313535F53AA53F65442548F54DB5528557555C2560F565C56A956F7574457 + 9257E0582F587D58CB591A596959B85A075A565AA65AF55B455B955BE55C355C + 865CD65D275D785DC95E1A5E6C5EBD5F0F5F615FB36005605760AA60FC614F61 + A261F56249629C62F06343639763EB6440649464E9653D659265E7663D669266 + E8673D679367E9683F689668EC6943699A69F16A486A9F6AF76B4F6BA76BFF6C + 576CAF6D086D606DB96E126E6B6EC46F1E6F786FD1702B708670E0713A719571 + F0724B72A67301735D73B87414747074CC7528758575E1763E769B76F8775677 + B37811786E78CC792A798979E77A467AA57B047B637BC27C217C817CE17D417D + A17E017E627EC27F237F847FE5804780A8810A816B81CD8230829282F4835783 + BA841D848084E3854785AB860E867286D7873B879F8804886988CE8933899989 + FE8A648ACA8B308B968BFC8C638CCA8D318D988DFF8E668ECE8F368F9E900690 + 6E90D6913F91A89211927A92E3934D93B69420948A94F4955F95C99634969F97 + 0A977597E0984C98B89924999099FC9A689AD59B429BAF9C1C9C899CF79D649D + D29E409EAE9F1D9F8B9FFAA069A0D8A147A1B6A226A296A306A376A3E6A456A4 + C7A538A5A9A61AA68BA6FDA76EA7E0A852A8C4A937A9A9AA1CAA8FAB02AB75AB + E9AC5CACD0AD44ADB8AE2DAEA1AF16AF8BB000B075B0EAB160B1D6B24BB2C2B3 + 38B3AEB425B49CB513B58AB601B679B6F0B768B7E0B859B8D1B94AB9C2BA3BBA + B5BB2EBBA7BC21BC9BBD15BD8FBE0ABE84BEFFBF7ABFF5C070C0ECC167C1E3C2 + 5FC2DBC358C3D4C451C4CEC54BC5C8C646C6C3C741C7BFC83DC8BCC93AC9B9CA + 38CAB7CB36CBB6CC35CCB5CD35CDB5CE36CEB6CF37CFB8D039D0BAD13CD1BED2 + 3FD2C1D344D3C6D449D4CBD54ED5D1D655D6D8D75CD7E0D864D8E8D96CD9F1DA + 76DAFBDB80DC05DC8ADD10DD96DE1CDEA2DF29DFAFE036E0BDE144E1CCE253E2 + DBE363E3EBE473E4FCE584E60DE696E71FE7A9E832E8BCE946E9D0EA5BEAE5EB + 70EBFBEC86ED11ED9CEE28EEB4EF40EFCCF058F0E5F172F1FFF28CF319F3A7F4 + 34F4C2F550F5DEF66DF6FBF78AF819F8A8F938F9C7FA57FAE7FB77FC07FC98FD + 29FDBAFE4BFEDCFF6DFFFFFFDB00430001010101010101010101010101020203 + 0202020202040303020305040505050404040506070605050706040406090607 + 08080808080506090A09080A07080808FFDB0043010101010202020402020408 + 0504050808080808080808080808080808080808080808080808080808080808 + 080808080808080808080808080808080808080808FFC0001108014A00EA0301 + 2200021101031101FFC4001F0000010501010101010100000000000000000102 + 030405060708090A0BFFC400B5100002010303020403050504040000017D0102 + 0300041105122131410613516107227114328191A1082342B1C11552D1F02433 + 627282090A161718191A25262728292A3435363738393A434445464748494A53 + 5455565758595A636465666768696A737475767778797A838485868788898A92 + 939495969798999AA2A3A4A5A6A7A8A9AAB2B3B4B5B6B7B8B9BAC2C3C4C5C6C7 + C8C9CAD2D3D4D5D6D7D8D9DAE1E2E3E4E5E6E7E8E9EAF1F2F3F4F5F6F7F8F9FA + FFC4001F0100030101010101010101010000000000000102030405060708090A + 0BFFC400B5110002010204040304070504040001027700010203110405213106 + 1241510761711322328108144291A1B1C109233352F0156272D10A162434E125 + F11718191A262728292A35363738393A434445464748494A535455565758595A + 636465666768696A737475767778797A82838485868788898A92939495969798 + 999AA2A3A4A5A6A7A8A9AAB2B3B4B5B6B7B8B9BAC2C3C4C5C6C7C8C9CAD2D3D4 + D5D6D7D8D9DAE2E3E4E5E6E7E8E9EAF2F3F4F5F6F7F8F9FAFFDA000C03010002 + 110311003F00FD133660E028047B714A2D39239078C574E6CF27818CFA8C628F + B105278C1FE75FE8F7D651FE5AA81CCFD8F0A4E3807AE3AD34DAA8001C67FDD1 + 5D3B5A9239CFD283687278381D29FB71A82E872C6D338EC777A521B5C76CD74C + D69C838C9C9CFB534DA6793C66855EE572239736B9254A8183E941B53800AE08 + C822BA6369C0E0FBD27D8CF1919F4E7AD57B741ECCE605AE540239F6A61B5247 + DD07815D3B5A1248C61BB6074A67D8C83F754E79142C4205491CD1B53C80BF85 + 21B618E14E7D39E7F5AE8CDA1C1E00A6FD90E3040271F9D57B71FB147346D41C + 158C60F539A69B4E47CBB41EFF00E7EB5D19B5EBC0FAFAD0D6995070BD3F3A3D + B07B2D0E6FEC5E8B8E39E2A36B4040F90106BA736D82785F4E4534DAE090471D + FDAABDB03A6CE60D967A02DF5ED519B2191C1C63B7AD74E6DCB6708540EF4DFB + 3119F9481D334FDB87B3672A6CB18CF0DDBDE93EC679F9720F39CD750F6EAB82 + 7683D866A33047DC0C919A6AB82A6CE5CD9B9EABCFD3A531EC9B0C48C8F5AEA7 + ECCA581001F4C521B605978073C7B557D606A2CE4DAD3D0027E94D36AD8E9BAB + AB36E324E00CF5A6FD9540C00368C8E6A957172B39236BC8CFFF00AA98D6C47F + 0E7FCE6BAE36831D0FE151359A923238EB54AB859F53936B5382142FB9EDFF00 + EBA8DADB03EE90D5D69B44C9CAAE0FB535ACD7048196EB4E35C76E87206DC641 + DA48C52FD9F1FF002CF35D59B1503E51CE3AD34D92E4FCAC7F0A7ED856B1ED3F + 6200151CD2359927E51C57566CF83919F7C7F5A4FB2F5EA057C9FB73B5506724 + 6D89C7CAC0F6A4368483F2FA5759F63185383F974A43659EAA3FAD0AB87B07B9 + C89B46F4C034D36808FB81867F2AEB1AD0820EDDDE9CF4A635A86FE1393CD5FB + 712A0CE54DAB0C909FA534DA9000DB81FCABABFB267EEAE0FBF7A69B55048721 + 3F1EB4FDBBEA52A2EDB1C9B5AE790A48A69B507240271FA5758DA7C8B179EF13 + A423FE5A382147FC08F15CDEB3E22F09787E3FB46BBE27F0EE911E3703717699 + 23D9012C7F0159D4C6C20AF3925EA694B0752A3B538B6FCB52A8B42780B93DAA + 3FB280410A31D735E3BAEFED41F0674A92586CB52D6FC4F329E0D858E21CFF00 + D749D9001EE01AF33D5BF6B38E45957C3DE0BB380A9C17BFBD694824640F2D16 + 304F7C073F8D78D89E2FC0D2D25513F4D7F23DCA1C1D98545754DA5DDE9F99F5 + 5BDB81B892AABDC9A9134F9A552D15ACEEA38CAA123F3AFCF7D7FF0068DF8A97 + 99316AF16876CCA4E6C2C628F68FABEE908E831B81EE2B8ED222F8C1F166532D + 84DE22D6EC242436A17F7728B645C8E048E486C75C2063C738C57CFE2FC48C3D + 357A706FD5A4BF5FC6C7B787F0F6BCBE39A5E9AFF923F43B5AF157837C37E62E + BDE2CF0CE952A8F9E396F10C8BFF006CD496FD2BC8B54FDA4FE12593CB1699A8 + 6BDE2CBD8F930695A5BB927A01B9CA633835E2B6DF04BC1BE19BCB0D3FE20789 + B58F1AEBB7199134AD311A305828C04822066704F192100F989E833D55C78DF4 + 3F0922D878734FF0DFC3EB18B98A282C92F2F586483BB61F261639CFCD23B1CF + 2074AF8DC7F8B388B5E8C62BCFA7DEDEBF71F4597F87387A9251BCAA3F2B5BEF + B5BEE67A7D878F7E24F89A3497C33F06A5D2F4F910B2DDF8835858142F6630C2 + 85B1D3F8BD7269C757F1602BFF00091FC48F873E1E90866169A1E90D7F3A7A03 + 24CF20CF4FE0F5AF9EB5BF884FA8B4B75A86ADAAEA890B6641A8DC6E85980DC5 + 8C0BB625FBA0608618F7C1AF883E29FF00C140FF0066FF0086375A859F883E26 + 586BBADEE779B4CD258DDF92DD3020B5F91303801C8618C57C4E37C4ECCAA69E + DDC5768A4BF13F43C0F85D8687C54A2BD6F27F76C7EA2DE7C4CF07E98458CBE2 + EF8A9AEEB258A08E24B7B4463D70638E38CAE067A66B3DBE2FFDA1E0FECCF0C7 + 8C679DE41BB3AD4A30707F842BA81C375F4AFE7D3C57FF0005A3F86DE1D7BB93 + C05F06F5BF14DF65963BBD5EEEDF4D84019208863F3A5EA3396F9B191C76F987 + 57FF0082C6FC7CD4B519B51D23C3BF0A7C3D33AF9654DADC5D300723E6676507 + 82470075E3A57CED6E34C6B7AD69BFFB7A5FA347BF0F0DE8D9F2D14FE518EBE8 + 95CFEABE1F8AD7691CAD73A0EBD085400A497ED396639F943342543003254FA8 + 3C56B597C60D2EECC7E7D85DA06E0868F2C49C8C6E439072BC1318FBC3D2BF92 + 2B1FF82B17ED2D6F73FDA135AFC2CD491412C25D2E47120CE48244D9FEF0E067 + 1F535EF3E13FF82C278AE2BD8AE3C77F0A2C670652EF3E95A995C679388A7465 + E07401C753CF15D581F11331A2EF0AD2D3BB725F73B9E263BC36A32BF35056EE + AD73FA9ED1FC6DE12D73C91A7EAF099645F96320863F81008FC54575E2DD6451 + 246E92C446438219587B11915F80BE04FF00828B7ECDFF0012A08ED2E3C5B378 + 2B5599C29B7F105B1B45C92082B72AD25BE723192EA4E7AD7DE7F0E7E3C6AEAC + AFE14F14DAEB7A611FBA8AF1BED305C281C6CB8524918040E641C0E2BF49C8FC + 6B9292A78F8A92EF1D1FDDB3FC0F82CDFC28F71CF092717FCB2FF3DCFD063664 + EE214FE029BF63238C007DEBCCFE1FFC72F0778D858596A617C1FAFCEA0456F7 + 732886E89E710CFC293FECB60FB57B9BD93AB344D1B2329DACA460838CE31DBE + 95FB76579FE1F194BDAE1A6A4BF2F55D0FC9F33C971383A9ECF131717F9FA773 + 956B339F53EDD2986CC8EDC57526CD981C119EC31FCBF23F95466CB9C951CD7A + 6B1279FECD9CA9B46393DFA7147D98FF0075BF2AEA0DA138C01F5A67D8F3CE1C + FE14DE2102A699EE62C8EDCE33ED49F63F61FD2BB0FB01EC381D7DAB1B5ED4B4 + 5F0BE9173E20F136B3A478774284EC96F6FA7582156C6426F62373103841963E + 95F212C524AED9ECC70ADE88C66B3E096000EA47A537EC873B02E589E07527D8 + 0AF907E227EDC9E04F0F3CF63F0F3C37AB78E6FC292977785EC6C49ECC91E0DC + 4CBDF25625F7AF853E207ED7BF197C5A678751F1943E0ED15F2BF66D3251A6C4 + 5493C33AB79CE3B7CD2907D2BE731BC6585A0B49733F2DBEF3EAF2DE07C6621A + BA515E7FE5B9FAFF00E2BF15F833C0D1EFF1978A7C39E15623E58AFAE9639DCF + FB10026563F4435F3BF88FF6BAF843A2B4D6DA5278A7C5570BD0C5682CE16FFB + 693957C7079F2ABF19350F8B5E0BD205DDEDE78FB4DB224EC792C630D2DCB907 + 80C48DCD81F7E466E83E539C579B6A7FB447C39D2A16B886DAFB5599937C61A5 + 528E79CEE949C93F29C808AA7B022BE431BE235693E5A292FC5FE9F91F6784F0 + DF0D049D79393ECB45FD7A33F5FAF7F6C9F15EB6B2BF837C11E0FD3A207026D4 + 6F64B86CFBF30A679EBCFA735E75ADFED03F18248BED5AAFC456B3B463B4C3A0 + 5A4765167D04E23F358F2061491CFDE1D6BF38ED7E2F78E356FECF5F0AFC39F1 + 4EBE6E2DE3B8B79B4DD0AEAE91D5B24796E10A0C0C1EDD7278AE47546FDA775A + BB4BDD4BC3DFF08DDA2C21925D6758B6D37243370D112D221C705403B79F515F + 378AE2EC6D4769547F97E563E829F0A65F876AD4E2BD75FCEFF858FBAB59F89B + E249124D55759F15B79AA217BDD6EFE376DE482442AC659028DA304B678C9C1C + 0AF3ED47E24695AAC622D6BC53606CA2CBC8226F31B76324CD712105BA6705B0 + 3070062BE2E97C0FE257769BC57F1CBE1868D06E756FB2CB77A9CADC8215308A + 09196047D306B52CF4DF823A6BDB5FEA1F123E29F897568A2DBE6E9FA5C56D10 + 6DD9054CCC727B6486CF27031C78F2CC2A546DCB7F33D2AF2A54D28C23F723DD + 35BF8E3E05D16716BA3BAF88EE530545A4AA5509EDB80233F283907030335E63 + A9FED45A669577279D058D8DDACAD19377771A3170E55C00780D95278241EA78 + C67CC2E7C4DF0C34AD52F2F746F861A9F89FE62BFF0013AD7E6C4ACAAA8AE52D + C226000063BF3CD5C8FE33EABE7DECDE1BF077C35F0ACD9F3A59ADF434967DFC + B026498B166C9EA7FF00D58BC4CFA9849A50BDAEADADDFA7F5B1FA03FB27EADE + 02F88FA278BBE257C47D534ABCD234CB8B5B3B3B595FCD80CAC8EEEF2F03CD51 + B515506E52CCDBB3802BEAFF00167C54D5351B8FEC5D2CDF781F4C48D6489E58 + 00D467F970A6380FFC7AA60939914BEDE563F4FCDCFD927E2CF8BA6F8E377AC7 + 8D35B8FC65241E0EF12CDA5C1A8283069DA82E9EDE44D0C78D91BC4EC19582E5 + 5901ED83F51EB90C7A4E99A878DBC4FAADA409E44F7F757D75398A1B48E3F9E5 + B9B895F81C0919893D0375EDE16698A7195E4EEFF05D3F4D4FA2CA329A589846 + 759DA3D12D2EFCFF00AE86C4BE2C5D1F4ED4ED63B8FECDD35E40F7F3493B66E2 + 34562F25C5C31CC9B4724BFC831B8000357E39FED29FF0555F879E1D79BC29F0 + 374B1F15BC5112F927570C62D1AD1F18DD14A3E7BBDA57204788FD1CD7CE9F1A + BE287ED0DFF051FF001CEAFF000A7F666F0F7896F3E0469970B15F5EBB9B1B3D + 45B77CB71AADD38DB1427AC5667748CA37B46CC42A7DBBFB38FF00C11DBE12F8 + 561B1F13FED07E20D47E305D80A4E9764D3E97A2C72E036C56045D5D00410794 + 4619242E335E155AB2AAFF0078FE5FE7DBF03EED52C2E021CF3B453D96CDFA2D + FF000F567E1EF8A3E2EFED5BFB556B72F87AE75FF1F78E2495C94F0E7862DA51 + 6B01CE4E6DADF8FAB4CC4F727B8FA1FE1BFF00C1257F6B7F18C115E7883C29A0 + 7C2CD20056DFE22BE26408C386FB35BAC8A0631CB3A751EB5FD365A5F7C29F83 + BE16BBF0CFC32F07689E03453F65B7D3340D320B08A2DA4952446BF320DC4967 + 666627BB1CD7CB7F177E3DF843C18A2F7E257C4CF0B783CEE0D1C1A8EA2B1CE5 + B700365A8DD2B636B7017EBD6B96A62A30F817F5FD7A9ECE5D87C4D74E728AA5 + 1BDAF3DDFC935FFA51F9FBE13FF822CF86AD96D64F1D7C7D8EF27618961D12C6 + D6CD636DBC8124ED72CC030519D80F5E3BD7D0767FF0441F842D6DB9FC47F13E + F83421D26FF8492C63F31F200531FD8942803711C9E077C8AF3FD4FF00E0A47F + B3968371F61B5F1678EFC590A9509F60F0F3E3001F984970D0E4658F4EBCF22B + 9587FE0B13E10F0DBCD6F65E09F897A8698E76F9771AA58C3BD49E54282FB4E0 + E41073EB530C449ABBBFDDFF00008CCA8578FB987AA9CBCE374FD2DDBE66878A + BFE08A1E0976913C2FF15FC65E1CB860447F6BB9D2EF90BED276F2B6CEC73818 + DC3A8F9B24E3E3FF00893FF0491FDAB7C07F68BBF06DE786BE26E9C832B0C464 + D32E9F8E311DC66062323A5C1E73D7AD7E83697FF059EF80DAB69690788BE0AF + C695BF2789AD351D36E50276C832464E071818EBD4F7F55F0E7FC149FF0062CF + 1DEBD6467F1AFC43F840F2AB099F5FD02E2183CDEA0B4D64D7118E73C9E30403 + D2BA633A525752D7CD7FC047CC4B38CC294B96BD0E68F749FF009BB7CD1FCD27 + 8DFC17F127E116B6344F8A3E03F167C3BD6CB1444D46CE4B713118C98DCFEEE5 + 1DFE46615D2FC39F8D9F117E14EA2D7FE02F18EB5E1E858813240C3C89F9E92D + B36518F4EAA0F5E6BFACCB1BEF097C71F0BEBD73A0EADF08FF00696F86570922 + 3DA417969ABC68096DA2E2300CB13601003AAF27A64815F98FF1ABFE0969F0AB + E239935FFD9AB5D5F857E3174671E1DBE7927D2EF2404FC91F596D8E48036071 + C01E40E4D2961DB5EEABFA6A7661B37C1D67CB37C8FB3DBEFE9F348CBF801FF0 + 541F0F6BC74DF0A7ED01A25BF8791D4432EBBA6C6D2D93E06DDF736B8692DCE7 + ABA19539C954E83F787E19FED153784B4BF0E5F49A81F89BF07EF62492DAEEC2 + E12EEE2C207FBB259CBBB1716FF29FDCB3120708E98D87F88CF897F0A3E25FC1 + 0F13A7843E29784359F02F890C6D3C02601ADEFE15629E75ACC098EE22CAB297 + 463B48218290547B2FECE7FB59FC50FD9CF541168777FDB7E06B89BCED47C357 + D3B0B2BC6C826584E09B6B8FFA688086FE359074EFC9F3EC665D5556C34ACFF0 + 6BCFB9C19CF0A6131949D0AF14D7F5B3EE7FA07683AA687E2BD134DF12786355 + B2D7F40BC52D6D796CE5A39304065190195D4F0C8C032370C14F15AAD6430321 + 769EE3A75AFC3DFD93BF6C1D17C4BE1F9FE2AFC17D524D474913C50789BC2B7E + C22314BB4623BA44DDE44EAAA7CABB8C32B0C0FDE2068C7ED87C39F1E784FE2A + F85EDFC59E0DBE7BAB277F26E6DE650B75A75C6D0C60B945276C807208256452 + 1D1994F1FD3FC1FC7D4335A765EED55BC7F55DFF0035F89FCBBC5BC075F2C9F3 + 2F7A93DA5E7D9F67F83FC0BA6C73C8DB8E94BF616EC2BAC6B3E4E0639F4F5A8C + D90C9F9457DABC49F16A85CF15FDBD7F6C8F0EFEC45F093C3BE34BDF0EDC78B7 + C61E23D624D0BC33A6F96FE4C93C50F9D71713B27CC62851A23B148691E68937 + 202EC3F9B5F885FB6D7ED33F1CB5B7F114BE0CF135EDD61962BDD4E210C16509 + 24ECB7595A282DE3C804AC6AB9C7258FCC7CA3F6A7FDA93E37FC5FF8C9F107C5 + 7E35F17DE5CDEC5ABEA5A5D847B4245A5D8C5792A436768AC310C28B1A654637 + B02EFBD98B57C8577E23D675C8AEE4BFBAD4754648C3BF9AED2173E60E72C4E3 + EF7E9EF5FCF19FE775B133714DA876FD59FB9F0C6454A9414E5653EEF5F9256F + D7567D4BAA78BBE2F6A76724DE2FF8DBE01F08EEFBF0A5EC97F3A819E0A5BA90 + 0838EAC476E2B87BDFF8419CF9BE23F8A1F13BC61310405B2B24B44938392249 + 8938EBEE38E457834724CC81AEA3FB0D8ED7621CEC523A64E78EE4FE15CEDE78 + F7C29A48D97FE2BD0A1605979BB466C64750B93FC2381EF5F238876B5D9F7B43 + 0E9B6B99B5E4ADFF0004FA817C49F08344B7B68EDBE1E6A1E251184CC9AC6BB2 + 49B8EE3CBC30844CE58019CF1FA76DA67ED15ADF842FB4CB9F00784FC09E00BD + B7064B6B9D2B478967899860B09A4566390C791EBCE40AF80B5CF8DFF0C2C256 + 31F895754C1C62DEDA57CF4EECA074E719EBD7079AE3EFFF006B0F87F6A592D3 + 46D7EF768C0F326823E84633F3123EB8CFB573D4AF4D5F999D1432EAD295E349 + CAFF0087E27EB5EB9FB517C6FF0088A97EDE2DF8B5F10F5F92540A5EEB58B991 + 98601D9CBE02E3036F419C74CD790FF685EDD5C5E35D5DDC4F22AB13E6392460 + F62793EBCFA7BD7E65DCFEDB7796624FEC6F085A472E1943DCDD4B276C670AA8 + 3D3A9AE1AEFF006CBF8AF3C939B0B6D0AC8C8AE85934F466E4F24190B8DDC75F + 4CD671C7D18E8BF04630E16CC24F994546FDD9FAF8B3BC01A367DE331C7CB700 + 375CAFD01E9ED5D5695A6DE5DE9D0CE96D39B675CE021385C9FBE4743820FB8A + FC3C9FF6B2F8F97210C3E35D4B4E2BF207B63141B063A031C6AC30300735E71A + EFC67F8B7E24F3BFB67C6FE23D403E4913DFDC4DDB9FBF263F4AD239C412D22D + 83E05C6D495E7522BEF67EF06A3AC681A44CFF00F090789342D22EA476256E2F + 228CA641C75EFF005E9CF43CD719AB7C5AF853A55AC827F1D785AE6DB0A9B62B + E49E43C60E15093818AFC1BFED6F124EC0B6AB761CF2CD1AAA93F8A8C9351CE7 + 539462F2FF005599319F9A5936FE478AE69E6D525AC61F79E852F0F6092556BD + FD17FC39FD06FC10FDAFBE05F827E29E957FE24F1CA69DE1E9ACEFF4E6B892DA + E16380CD6AC88F2379780A4E01C6700E6BEB8BA3E26FF828FC379E10D1F52F10 + F84FF621D16EBC8D5353B10D0DF7C54D6201BC69D64F200D1E9D6EFB5A6B82B9 + 7930002DB3CBFE797F62BFD9B2DFF690FDA37E17FC34D46EB53D3BC2D77AAC23 + 59BDB3C0B882D012CD1C3231C2CD2042884E76E59F9F2EBFB54F0F49E08F0AC1 + 6DE16F0BE8DA0F82FC15A32DBE916FA669B03476BA459C644691C6A4B1C28627 + 71F989DCCCCEC59ABC7C66224DA94F77B1DF570F0C1C151C35EA4A167AAD9B76 + FBDF4EDBF63E11F8D3A0685F0F7E0F7C37D23E1F69E7C07A1E857171FD91A7E8 + 570D6B6D046D6E646C6D903B30DA9976F30B3396760C54D7D07FB4C7ED4961FB + 3C7C36D43E26EBDA1EA7E2FD134ED374A636762CBF6BB9BDBB114504685CED55 + F3248CB139F94B1009183E57FB5F69D7AFF073C2F716D6F636E971E23B874104 + CBB5E178E5114922B02E06371C83856001CAB1C757E31B91AC6A5E158DD264B6 + 8F51D0ADE6684B2C836AC28016C9208DA0E3BF2320F4F2E93928F2DCFABA3976 + 1F115E78AA914D2E65DF5D17F9BF2BEC7E38FC41F8CBFB7D7ED112F872E27B48 + BF650F86BAF6A70E8DA7436D6F3BEAB7824477019B1F6B10C70C334B24816D23 + DA8C72EC541E23E237FC1393C65E06F1978C344B1F02DE7C61BCD0B4E37FAFF8 + ABC47E2A4D1F4E9665622586D34F81CEA178CA48F98DC7CC4F0A8A09AFD58F89 + 9A35C69FF0CEEAE22D322BEB996F2091C4FBFF0073BA3B8C4A19158ABAB60890 + 8619CF5CF1B5F1B7E3FF00C38F82DFB43691E04F1F7C55B3F87DA1CDE1696FAF + 3FB4EF6386CB549677BB48CCEA41766568F0AF9642400C32A73B546A2BDCD3FA + EFB93571F53EB12834B656EFABEBE495B4FF00863E078BF605D6756F017C26F1 + 37C05D1BE05787A783C3726A1E24935BF061D6F53D52F05DBAE6CAD750FB4C21 + 8C1B08B72EB921CB16C023EE1F88FF00B10EAFF1B3F6633E05F007C3DFD9EFC0 + 9F1B12E2DB4D9BC59A9F8334BB49EEA0DF707CB692C6D604B19AF18D8C66ED61 + FDD42980ABE63495E5FF00B44FED27F0FF00E05FC44FD96FE2278834BF1F78DB + 40D56CB57BEB297C39A609E6BFB5911631E579AD17CC7CF89B63051B54938C57 + D9BF0CFE21695E32D63E04EA96B61AFE916DADFDABC4AF69AACD00B8B46413DB + 88AE56332464C66D5B251C805F048C1CEF46A494AD2D579DEDF99F3F9DB6E3ED + 62F927A59A5ABD536FD3A35B5BCD9F93FF0005FE05F843E307ECF1A56B3E3DF8 + 27F057C3FF0015BC35E2C5F0FF0088AFAF3C216E3FB6F4F896672B22DA9800BD + 2D0CB6B25D44CAA444B32EE6725BD13E387FC1347E035CFED0727C31F859A078 + B7C05A25E7860F896C2FF49F12CB73347235DDC29B4FB05DC73A3C71C5082651 + 346FBC8050EEC8FD33F8B3E3EF831E34F849ACF893E0C7C4AF853F15E28B53B4 + 3AE4FE1DD6A1D45ACEEAE229DA2966689CF94EC2208BBB1BB2E71924D6C5C58C + 117ED79F0EEF8C4B3C537806ED5180CB10E6F30FC9E31B8F18EFDF3C6D5F0968 + A4BAFF00C03CACB38DAAF3CAA4DBE58C57BAD756DAF55D0FE7035DFD8A7E2DFC + 3FF883F12EFBF65EF8C5A7FC63F1AF80354974FD7D3C313DD683E2BF0FDCA338 + 1985D9567C989F0D697126ED8404DDC1F69F823FF053FF001A693AAB7857F6AC + D035AF886B138B3B8F12D840B67E26D39B18FF004EB4711C17F85007EF160B92 + 3FE5A49C67F5B3E1AE81A2687FB727ED0BA059E956B69A2EB50AF8825B58D50C + 776F3496978EE7D6493CD9F716FBC483C8209FC92F899E0EF88737C57D3FF677 + FDB3347D13E2EF867C437F716DF0F3E2B693751C9AB6851F9ECB15AC7AB2A86B + CB389A44B79B4ABE491AD4B249088D0625E0A729C1F345DADFD7F5F91F518978 + 6CC23155A16975B6EBCFD3BEBF267ECB78EE5FD9EFF6E7F80925A5B268DF1F3E + 1E99E222EAC37C57DA4DF01B410180B8B3BC559790C11C8DDB8491E41FE6EFF6 + B9FD8CFC75FB2E6B2D74935EF8DBE175CCFF0067B1D6A7B7F2EEB4BB82C57EC5 + AA44A3F75701810928FDD4C47CBB181897B7BBF02FED27FB0878B752F8D9F067 + C7F16ADE0ED37554F0EEABE21D29A39ADA0BB56575D27C4BA6EF63033E4144B8 + FDDCBCB412EF5217F65FF65DFDA7FE107EDCD6FE2FF0BF8DFC23A25978A351B3 + 9CF89FC2574EF2431C45079B35A798737364FB46EDFF00BC8C90AF8216423AF2 + 9CB9A5AB97DDFD7F5B9582C2C307465496B4E09B4D3D6FA5D6F6EEF4B76B5CFE + 6EBE107C64F1CFC0DF1B58F8D7C09AB7D8356894413C4E4B5B6A96848636B751 + 0204911C6719051B6BA1040AFEAEBF609FDA734AF8AB6567F147E116AB069DE2 + 3820367E26F0C6A173B50C71C4656B6BBC72C30ACF05D28C8DDBB1912A9FE7B7 + F6F4FD88358FD943C6771A878664D47C45F04751D41ADB46D4646F36E3499D81 + 912C2F1FF89DA3C98A638F3951D4FEF23707C3BF64BFDA4FC57FB2EFC62F0DFC + 52F0FF00DA352D35185AEBBA5C32141AC69A58F991293C09864BC4D8E1D707E5 + 7707BB075EA61EB46BD16D4A3B58E2CCF0D4F1985953569292F54FB7F99FE8DD + E0CF11E85E3FF0ED9789FC3734F269F3168A48A6C09ECAE171E65BCEA09D9321 + 6191D082AEB957527A7FB0A7FB3F80AFCCFF00D8FBE37E8FE38F8C3A46A5E01B + E8F54F855E39D39A7B0B858F645A804B23736B70A3395950C5716EFBB0C04ACA + DCC6A07EAEFD8C1E7657F50F0C712FD7B091AED7BDB3F55D7E7B9FCA79F643F5 + 3C47B2E8F55E8FA3F347E5E7C56FF8212FC11F897F10FC7DE36D3FF683F8D9F0 + DF4AD7758BAD7068FA4787F45986953CF33CD24705D4C9BDA1DF34842BA13820 + 166DA09E1ACFFE0DE5FD8D343B5BED57C7BF1F7F6BBF15D845179D3B5C78AF48 + D02DA200FDE92482C46C5CF73201D06457F44BF613D30703B93C9AFC78FF0082 + FA6856D7DFF0491FDADE6BB89A5B7B3FF845EFDC0553B8278934D43C3707897B + F5FA57CCD7952A74DD4F6706D778C7F3B5CFBCCBAAE25D58518CDC53695D2D57 + E4FF0013F815FF008291FC3FF86DF073F6D8FDA6BE137C0DF174FE23F833E1CF + 14CBA6787EEA7D63FB5CFD94450B05FB712C67C3BCA9BC121B61C1239AF86A5B + 2D43EC0DA89BDBA7B665DC5D64C06C9C0DA339EB8FC8D6F49049ADC3A8DB69D6 + 9F64113DAC4AB310A76AA49CB1E84E48FD076AAF6F0C11695A75C4CDA533C301 + 566693334877B8D8AB9FBB820E715F8CD7A71949CBA3BBFC4FE85C3CDD2A7183 + 776AC9F77A7E6CCAB0B1B4D477BB3CCCC3AF9809279EBC7F3AD9B8D12D610238 + 702F648DDE28E45255C28E4139E33838FA541E19111F323DDBD09C0217B6718F + C6BAEBAFB2DBDA9BA0D2F9F6F03DBA448B9326E270D9F6DCD9FC28A3878B8393 + B1389C5CE353962DFF005FF04E2C69D1ADCDBC2CFCBE9FF6CCEDEADE5160B8E7 + 233C67BD5B9D7468748FB6DBCDA9BF9A5A38C98D400CB80770CE40C91CE6AFC5 + 3DA9D2E09E3B2D44EB6B69F607023C461028512062724EDE318E306A82DBDD3E + 8B6F6A6C73325CCD300E721959471EB9E3A9A5EEAF83AEBB3F2B0F9DBB3936AC + FBFF005E4696BFA37D8F4EBE96C52D5E2441B67576F3147196C676F3CF4E064F + A5417CAF637FAD79690C7247676CCA4A021092B938208E87AD4928B89AC6E60B + 1D16C74A33A98E41017385F419E833DFDB152FDA6FA5D4FCF79B4DB4BD923585 + E36DA490003908DCF6FC2B5A8D49FBA9FF0057EF6F239A8CA518FBFAAD77F96F + 6BF66247104B9B6D4247682E66D364691E2401BEFAFCC01EFE9C7715BBE18F0C + F88FC7FAE69DE0CF0A585F6BDE2BD46E16D34CB16644B8BA72719E7851D4976C + 2AAA9662006C65C13B0BF7BE975DB34B829B066488075C8240C923A8CE315FAE + 1FB157893F6B1B1F077882F20F1E789EC7E09C56F3DB7F653F86ECEE22BC8EE9 + 45BCCD14EF6ED259DBBED8D1A48990DC3AAA82CCA5AB3AC9B8691DFD0E4C663D + D14A72B5977BAF92D1DCF7EFD82FE1E69DF083E25FECEFE1C48E07D66E7C5FA5 + 4DA85E0183A84B3FC9BD49E444824548F3FC209EAE73FB39AA5A4BA45D7C46B5 + 5B3B792D6DAE1678CAF24066DDB41ED818E3D477AFCBAF03783FC65E0DF8B7F0 + 0751D7FC25E24D16D4F8B3419619F50D3E7B74982DDC2C0ABCAAB9CA65863AAA + E4022BF52F47D2A0BCD1FC58B72D788973732CA842E247653956390704F4E738 + F515E46650B28DF7D4C783AA3AD5ABE21ECF974FFB7B4F4B6A7897ED0E9AC4BF + 03BE1C5CBD9C735A45AD5DDBCB29B88D9244913763CAC07F9485F98671CE7AF3 + E85AD413CDE1CF0AF88962536D16B3E1869E58A1D85C1B880976C70CDB59864F + 278CD5DFDA7F48B7F0F7C0CF00AE8DAB7DAED46A90DD4D3471FCB1196D8A61F1 + 908C773050704AF38E984F88979E22B1F811A66A3E00F863AA7C46F1858CFE18 + BAB2D034FB98EDEE359646B7F351669331C7F2EF725C00151B3835C985A7EE7B + C7A588CD28BA927845A4B5FF00C9B55676B7CFAEE958E5BE2B6936DA1F82A3B6 + B779AEAF65D4112EBCD672AEA6DEE102A6080F8201DA415F95CF3804687C60F8 + 41F047E3578FE6F04F8CBC0BA5EA7F176D346137873C4577A5C573168098136F + 81C10E92E216600AED0C4B8F989AE6342F11FC40F8C7F077C7DAC7C45F86BA4F + C25F1B693E23FEC8B9D0ECF5693535B4F2AD670C97178C9E5B4A24B7954BC0A2 + 218DA19FAB7BD2785F5ED37F68BF0DF88DAC6F22B17D02522F5212B1238B7981 + 05C82BB8178C1F60AB8E063D6A78552846FE7FA1F956373EA94ABD671A9795A2 + 9F9DB9B9B5EDB6DDD1CEDB412F847C4FF09BE045D5A3EB5E1CD7B47B8D3F52D4 + 61964B79A58D5278DE22A87011B6B16CE7EF3004672397F1769FE18F87DFB45F + ECABE1BD2E4B9D334DD4ECB52D2D34D5C33CF1899489433317639BD914E0E57C + C56FE1E3ADFDAAFF00625F89DFB44784742F89BF083F688F883F037E27783A1B + F1043A16C3FDB06481EE2045533C124771F6885610E85C1598029F229AF11F0B + 7EC6D6FF00B57FC3AFD95F59F8B9F127E2D783FC53E02D56E7C5305EF8A45CCF + AF6B7A74B35BDCCBA45DCF314B8B6BB22258C498DD1B5B4A8108298DA3868ABA + 8AB1C1FDA15A7C95AA55D1F449E965A74B6AD74BF99C7CDF0BFC09F02FC05FB4 + 6FC3FF0087BA0787BC2BE00D3356D0C697A7C24A25A4325D48E88F2392F24812 + EC23348CD2315C924915F5825B5B47FB4BFC2DD58176B27F025E360306531217 + 6C11D464381B811F85723F133F6619FE34FC3AF8D1F0BECBC4C7E1EF893C6F78 + 26B4D4A7DD341A6DD2DD9B8884C8B86303C83C860A7708DB2A4E1775CF0E7C3D + 6F859AB5FC1A9EA9E25F13F873C29F0CE1F0735E7F6819EF6F6E12D0413BC33C + C48498BBDC15C92B19D884911835E84E3EF6C7CC42B3F66DB9DE527ADF7DEF77 + EB7F53C57E1F22C5F16FF64BF1A4EF2DC43E25F0E78874EBCB896DBECF2F9897 + 524B179E022FCC82755E4646C0318C57CD16377F11BE20FC2CF137C35F157C07 + BAF86F2587C6D796C1AF2492DAEEF1A0B8133DFC5A7CB02615E2BB880B947712 + 99DC6DE598FD0FE02FD9F87C048BFE09F3159F88AF7C53A068D7B0786B55B8BF + 69A3BB9B52D42717125C3C0D24F1C6AF1C7223049303CB8B862C58F4F37C52F8 + 83A85C7C0CF1578A756B3D42E2EBE27EBBE0AD41A7B68D84165E546B648872A5 + 5A1313E19724E0649C023C3A98594A2A56B3FEBF33F41C267F4E8C9D04F99749 + 6AADB5F4F96A7E74FED1DF0D35EF817FB4C7C45FDAABE116A9278EBC09A978A4 + 687F173C2773A72CD6D0C17457F717B0C8BE55CE99751AB6CDE185BDDC499389 + 10D7AEFC06FD97FE087C14FDB47E127887C19E1C9E2B1B8D774ABEB2F3EF64B8 + 6D320BC8151E3B10E498E206562A1B3279676176000AFA8FC43E184BBB0FDB9E + CAEE58EFF4FB8D42E216827462119202A89202AB952551C302577F2081C550B2 + D3427C7DF8086E6288490E93E1169F0402852CA0CAB73FDD5538CF7382722B82 + 9C1A92EE8FA6C7E73CF0F671FF00979FF057E563D83E33FC3CB5F8D1A07C50F8 + 4CFE16B5F18E93E23F0FDD69565A718C1379A925A18ED92357C6D956E96D4C4F + B81578E3605704D7E12785BFE0843FF055BD48C36DA8FECBF178726F294C92EB + 1E39F0FD9A1902F39C5F31EB918DBD3B57EB078A7F6E1D27E127EDD16BF04A3F + 85BE26D7FC136377A36AD73A9E9362ACD66F7324735ACD2CB2DC46890A1F2636 + 8957CC658DCA976385FEB27C1173E22F10F87EDB5AF14F866D7C25AC5C4B2B8B + 286E1265F20906397723B85DEA77EDDC5954A86DAC4AAFDC706E4B85C54AA3C4 + 36DA775DB53E7B3ECFB1397AA74A8534A2E2ADCD7BE965DD59DAC9FA23F9DBFF + 008249FF00C13D3F6F0FD95BC4FA6E9BFB47D87C2BD13E11E957D75AE6910E9B + E328358BEB6BC9ADE58A4B4482DD7CB48659265B86732610ACA00633607F436B + 651855040CE3DEBB43644B1C28FAF1C547FD9F2760D8FA57EC194D0A183A7ECA + 82B2BDFAFEB73F2ECDAB54C656F6F5524DF647BA1B2CB702B95F1C7C3AF047C4 + DF09EBBE00F893E0AF097C44F036A908B7D4B44D7F4D8750D3F518C3AC8127B5 + 995A39143246E3729C322B0C30C8F5836B9180A377D29A6D0A8CED4CE719C77A + F96FACC76B9F71FD9ED3BA3FCC2FFE0B33FB367C36F877FF000562FDA1BE08FC + 09F87FE09F869E11BAB9F0A2691E1FD1ACD6C34DD3AE6F742D3A59122810158D + 5A799DF08B80D2F039AF906CBF622BBFF8422F3E20DEFC5CF8430E876F77A859 + DE476767AA6A1776BF6248DEEA5291DA81E5C5E6C6AE43EF46C7CB80587EA0FF + 00C17A6E2D3C3BFF00059AF8E7E24BDBEB67B4826F05DC4D0C4EDE7431C3E1ED + 3373B05185DDF36DE777CB9C74CFE797887F691BAD13F692F88BAA6BDF1DBC6B + F167C033693A83F863C43E1A85AD6EAC2E6EA48A68AE258668A31F6C4F2D63B9 + DC1D642AE8246570C3E2F31708C93B6ADBE97ECFCB7FE99F5987C4E367EED095 + D463ADEF7BAD2CB47ADEDFE4CF50F86FFF0004EDF02F89BC5DFB3BDDC9FB405B + F8ABE0878E96F6C65F13F873458D65D275F8521DBA398EE6664333B5DC3F3315 + 65DB37EEF2A09DCD0BF600F0468FACFC42F0178E7C55E2EF88FF0012B46F16B6 + 95651782350B4974FD474C55C8B97658AE6582E373430BC0487867768A48C14E + 788FDA2BF6DFB2F1BDE68FE2CF85BE2CF8A57DE26F37C3B3EA965AC5A9486F2E + 638657D4AE95405B74B896E52C0F9B1A231685595801B4747E07FF008283F83B + E1E7C71F17FC60D03E1AFC45B1B2D7FC5BAA6BBAC69B657905BCB7167A9E9F6F + 1EA3024C928316FBA8AE658F1CC7E72383BE200F971C459FA5FD2FA5BE5FA115 + 69E69283927676D2F6BE9DF6D5DEDA2B69D19BBE16FD8EBE064FF13348F065D7 + C37F8EBE368F58D55F4E4D26C7C6167A6EB1A08010463CABBB587ED5E6379F89 + 3E6652A55E100067F917F6B8FD9BF5DFD977E39F89FE1A5EE81E2ED27C306DAD + 755F0ECDAE3DBCB737B612C40922E2D95609CC7309E0668D54068F954638ABFE + 1CFDA7B47F08EAFA3F8EF45F869F1267F1DE9776D75FDA7ABF8E6EAF535B7126 + F4B9D4E297786B91889CBC2B12975E001823AAFDAA3F6CCF8C1FB52C3E0AD03E + 21F87B44F09C1A1C73CAF6915A817325DCE54C8CD232AC8B0158A02B0740EAEC + 4B1DA5485597346C9FF5EA91D1428E329D46A7AC2D6776AF7DEE9272B68BCAF7 + D753D3FE1FAFC17F02F877E1B7ED13E2EFD89AD3E2CFC15D4B52BAD1353863BE + BB68348BC5F2D6DC5FDC3C8C89E61B889924257CC11CA98F94D7B9C0D77F007C + 57FB597C27D53E18FC0DD77E1BD87C37D1FC51A3E97AB78662BBB046BD8EDA78 + D99E4267696333CE8928904819064BED15F9E7AEFED1DAFDF7EC9AFF00B2443E + 1CD1A1B2FF0084BECBC56BAD25FC82ED4C105CC62D9ADB66C29BAE4389370605 + 00C364ED97E24FED81F137E25787F48D0B5A87C2324F069DA568BAB6A1E61371 + A958D8DC2CD6F6B238C18A20508D84B90095560A020DEBB9394AF7B69FD7DECC + E9E5F55B8E975777BC9BD39A2D3D5BB6978E9AFE27EB3FC35D535BB0F8CFFB4E + 7827E0CDFF00803C47F10749F04EB773A7F86FC53E05B5B7D42D354874B7B844 + B95BAB69ECAF5D6741240DE58499510395F3F69D2FD8F7F68FF8BBFB457EC737 + 5F0D34BBE5B48ED6FA7BBF11DE4EF2B096D925B4C59411070B8967786509C478 + 91A20630B93F987E27FF008282FC62F1678B35BF1E785BC39F0B3C31F102F74B + B6D2350D6AC2DD66D427B1B7B616B0472BA845631C388C48537B000331C0AEFB + FE09C1F183F698F849E22D47C23F036DBC06FE1CB89E3BBD72F35ED124BE4B38 + C797F2465268D8C8FE446562072C54B12AA18D70D573726D2BA4BF1BBEFE4FFA + D8E7A99425837EDA294935BD9BB5BDE578AEAF6EAFD4FD29F8791F8B2CBE3A7C + 30F066B1E2EF1478D469DE3AD3E19E6D4E6B92F25D8BA8410893BB7941154AED + C02A4ECCB2A21AFD18D4F57D66C343BA3676D3F9E97A6342A9B8E1002720E7B9 + 63EC4F3EFF001DF82342D72E7E33FC2CF1B5E785BC496AB378E2C2EAFAFE7B59 + 96DDE696F37A91295D803B676E0F70BD6BF47BC4115E5CC462D17468EF52E24B + 9985946525740C770223C97DA704860B8F7C75F1F1787718C575FF00863E8B84 + 738A739544D249B8DAED2D93D3D59C77ED2A62BDFD9974248AC923D4CA2C53B4 + 44C864904F83F282157E558F91FC2AB9CF4AE9FE11F88B4F1E0FF87BAFC92EA7 + 0698347B1B9BBFB36C133325BED3B0E54649CF2C474E08AF87BF6D6FDA2BC31F + 0BFE0AF837469ECBC5BE33F8937D7F750E9BA0697A534D762D625469AED90067 + 4822964894CDFC4EFB541C311F9DDA37FC163F50F00E856BE0FD6FF67DD374DD + 361B74B38D6EF57BEB69B629391FBEB32A1B0704001783C726A693F7558F3B2A + CBAB43118A8D4837194E5CAFC9BD77DFADBA763FAB81E25F871A98BBD1EC6EFC + 6DE1FD5F70B7B9592CADE669E607A493472A6F1C8383938C9352358781A5DD68 + 9E38BFB5685834914FA44CB1C8C09E4F96D28E0F19C1231C1AFE66F40FF82DDF + C19177A74D75F083C4DA55BDB4BE6462DFC516D3B95C1F959A5B68B71CEDF98E + 0F18E324D7B75E7FC16E7F652F13C73457FE15F8B5A0CD31DD218FFB2A71B893 + F38D978847247A1E48039AF52963E3CBEF33E4730E0D9FB75EC60D45EEDA4EDF + D2E9FD3FDE797C2DE15B88CFF6778EFC2F76EC490D34F716A555B3B862480AB6 + 4E31865FC7AD456DE06D32E65BBB697C55E1B374F262D826A30499553FC4CD20 + C36D24F4C641009EFF008D3A37FC15EFF634B847B58BC43F1474FB80008659BC + 3390A71D4F9173215C9CF407FAD7AAE9BFF0540FD8E6F54DE37C579EC94A2A79 + 379E19D4F6A8C8246440C30483F81AEFA35A935CDCD63E6F19936222F91D2BAF + 46BF2B1FAC107C2D58609D2C351D375CB87432173346AD1B2EEE0A97C8200182 + 7E51EA49029FAD7C3ED67EC8A6F3C2DA9EAB02DB98A466B69256886D054321CE + DF9BD47B0FEF57E5FE97FB7DFECCBAC5CCD28F8F5F0836395753343736048CE4 + AE66854071F29C9F4C0ED5ECDE19FDB47F67592C4DE695F1FBE1141383BA3F23 + C556B0CA4E70301A54F988EB82001FAF5A9D36ECA6BF03C2C56595A369383F95 + FF005BDCF72D6742D33EDF1D9EB9E1F5D474FB1BEB4BAB2B76B76B68EDA58CAF + 95B132A76AEE6E0F03E6E9D478DF88FF00670D3757D3B48F0C6977BA9E8D6F0F + 8AD7C691DE5D2899A3BB0B36F462B8016469829C29C63AF35F43784BF683D0B5 + A7B33A0FC6EF0E6B770F112A9178AAD66C2903381E7B6327030307935EA43C7F + E33BD56115CC7ADC6C485FF4282EB7720FDE08C472071FE35C71C05F58CD1D34 + 336A7423ECE549DFBB7AEBAF5F3FC2CB63F302EBF65DF8E3A178F3F6B0F15EB3 + F12A0F197837C7DE358B53F0BF87ED7329F0ED8319259C5E34B10785F2B14691 + C52180A8790E18A85ABE258EE21FDA97C2D6E93BCBA6DA9D02CB4E91712196CE + 3B68970BC0DABBD652118020893A86047EA549E20F1179AED7BE0CB2BC9E3032 + 67D114FCA30319118C8C90768F53CF5CF86DDFC39F01CBE2FB7F1D6A7A0259F8 + 996F6DEFD4DB5CEDDA63445D862230AA5628BB90DDCF249E5FECA716E4B53D37 + C4EAA4E2EA2E56AC97CBFCFA9F9A9F1ABC0DE30F895FB5C7ECFDF0EBC0FE178E + 2F0CEBB74B687C4374935D45A36A492C52C0B730A6331CCCC144DBF19F300427 + 62B7F60BA4E84DA568FA469375710DF5C5ADA416D2CC9198D2678E3546754EAA + AC5090BD81AFE7CFC05A6476FF00B53FC0E2B0C31C2FE2CD0D444A0058D7EDF6 + E800EED9DF9CFB8AFE930D92E4E3E5CF61C8FCEBEA782FF76AABEB7FEBF33ED3 + 887D9E269D09C355CBBBDF7B7E871A34F5000C6463A8A6FF0067C638CB0AEBCD + 975002E6945970385AFB958B67CBFF00672EC7AE1B661CE306BE7BFDABFE3BE9 + FF00B2BFECE7F16FF681D53C377DE333E1CD32392C745B594C326B5A95C5CC36 + 765662501BCA12DCDD5B2349B4EC46660090057D3E634C13B457837ED3FF00B3 + E699FB537ECFDF14FE00EA7AE6A7E143E25D3E282C757B2B61713E8BA8DBDCC5 + 7965791C24A894C375696D37965977AAB2E46E0C3E22AD67CBA33F42AB829723 + E4DEDA7AF43FCC7FF6A6FDA57C09FF000518FDADFC51FB4178AFE1EFC46D17E3 + 078BEC239B56F0CF87EE12DF4F8E6D36C63B38EDEC1EE1279DA4FB369D1BB2BB + 1DD2CCC108DBB6B0BC1BF0D7F652D534D9FE36F877E117C77F8BDF04B49B3BED + 5B5AB17F1DD958EB16D6366A91BDC3C012D9CC325C4B8530991D228E4DE0B27C + DDB7EDDBA0FC46FF008276FF00C14AE6F87DF12BC25F0535AD7FC03E2687C592 + DD784B4F7D0E3F17C1AA5AD95F6E569A3DE91E09558CA38867FB4287954927E4 + 0F877FB4A6B1E1CD0D3C3EFF0003BE1C7C40D0A29B5FFB349A9599BBB858755D + FE747E7881FE55FDCE02E32636C6D12480FCECB1359AB2DACFEFFEB6EC7A0B2F + 7C9194534F4BABF6BE9BAF2BBBFE563EF4F81DFB2DFECE1F107E2C78CBE077C4 + 6F869E20F058BEF06E9DE31F0CF8AB46F145E99AD60BDB5F36191E09D9A090C4 + 77C5246EA43BC3F2BA026BE70BBFD97BC69F01F45FDA17C51E3CF865A17C4FD5 + FC01E28D3F40961BDB677D3EEF4F9EE96287568216CF9D1DC192008486550594 + E5B7633ECBF683FDB4F50D37C35F11346F855776D69E1BF0EE9FA21F102783AF + E58A7D2A37FB3DAC535CBA80E866B8936E18B334CC01206293E1F7ED29FB70FC + 33F1B78DB5C117C60F1278F3C4D66346D563D5341D4565B88846112158A38576 + A0478D4448148CA152A70C75A329DDFCFF003D34EF6D0F1ABE171914F9755EEF + BAE4EFD2EB9BA296AF7EBA58FA57F670F893FB387C41B1FDA5E7F02FEC69F073 + C3DF122DE5FED6F09C0E925C8F095A08A6967BA5BABB924D81218647D8EC6381 + D0B47B42AA9835FF008CB73F0CDFE00FC50F8A5FB36FC13FDA6BE176BBA5EBB3 + 05B8D074E8A19C433279F1ADC25A6D8E22B75148B2ED694075704B160FF25786 + 7E2EFED6BAF7C41FDA3FE275C7C35D5BE2678B758F095F7853C5F2AF852F4368 + 564BA449A73CB32C0A192682D650CCF3EE6C22B4B9C96373E137ED5BFB637C2F + F831A77C2FF87963E29FF845AC51F5FB5BB1E1FBDBB821B516B2235CB4263304 + B08B67901958185E319756DA5AB3739FC5AAB2FEBEF496A3AD954B9DBB29B6E3 + BCA57578EB67BE926DDBAAF447E83FC6AF087C01F1C7FC12BF4FF88375E1EF81 + FF00B355EEBBAE43AAF869AD743B868E0BE569A73A4DB5E4505C5F3C6D6D15E4 + 486777059633238C965EA7E2378717E2CFC3DF0B695F0ABE1C699AB7ED01F0FF + 00E135CF8874E8A7D121BB138B975916CED2D946649961B19CAEE52416D91EED + CD5F8FDE12FDB03E3BF857E105C7C17D0F56F0E5DF809BC39AA78616DE54B993 + 65A5EDA3DA4F220170B1ACE5256C3ECC642E430E0EC5A7ED9FF1E747F881E1BF + 895E13B9F0D781F5CD3BC3767E1A65D356E122BB86DA4B8786E5DBCE12A4E05D + 48BBD195768C60866A5565294AFAAFD346BBEBBAFE90E8E4F5A9C270D25EF49A + BC9EA9B8E8F4BEA934F7F3DD9FB97E11F85DF117F6D0FD897C5BE06FDA43E1D7 + 877E17F8C7C35226ABE1CD72C745DBAADA2DADA99DE698C8543A4882EAD24424 + 204219CCB2C05ABF3FBE1C78B3E0C3F84353D1FC33E39F11FC15F85F61E34D33 + 428BC616D1DADDD981285FB4CF7A97511120914878E62D1926D1F1F24AAABF27 + F8ABE337EDCFF157C1965F08B5AF17FC45F107C37F12C475987C23A75A31825B + 55BB32091A1505D617B83E6FEF58F9870E4FCC09F6BFD9C74CFDB23E0A5978E7 + E19587ECB5E19D73C2DE2F2916A96BF167C1939D1E55492171206B99208DB63C + 08CAE9BD94E769CB55525522E53B5BB1CFF5051A7FBC946C9DECBE14BAFC49DF + B6AACADDDE9FAD5F0B7E34F8DF46D5BE0C7C16F0BFED67FB377ED4BF0A6DFC53 + A36916D73E19D366B6D5B4CB68AF239E333C71DF4B69142D2203F2A6E7324841 + 53B80F77F109B593F6CED1EEE5B6D374FB38F4082CDEE16301A7823D3B5320B8 + 04938F3238D8E4642F4E0E7C43E1BFC02D43C11E32F84FF12F43F839A1FC3AF0 + 65E78C346D4E2B7F0EC70C7A359B4D7714788D63918ED7258A03D7729180463A + 3F88DF0DBE3E2FED7FE20F1C687E2582C3E0F2F826F34F49D4D935C68DAF181A + CD5A38A44679A1DA567E72A72C80FCAA0F955A5EC6D396ADF31380A50CC39E9D + 2B4141C5DDD96D7BB76D2FAAF2F22D8FDA0F42FF00851171F117F674F899FB4F + 683AEEB11EBA961A8F8875B61ABC0F636A6E2E2DFCD582068ADCC68768903B36 + FE319C9FABB4CFDA1FE358F805F09B594F89DF0D75AF123F86358D6F56F0F78C + 3FB4EF758F13DA584B234D75A64B6F72B89218546E0F0CDF3BC6CC51701BF227 + E177C32FDA7B44F871E13F823AAE95E0FD4FE2CEA3A178D7C616BA4DD358DCD8 + EB93411C71A476D75118FECB15E5A19E22A5C1F38A487664A8FA27F647FDA2FF + 00E0A6372355F83B7DFB2CDA7837C1FA6681A9DD6957BAA785B53B9B79355237 + DAD86A1770DF22C71CCF2C8864019D00276300DB669E23DDD7F0FB99D78EC8E6 + DD4F6366A36D5B5B36DA6DBF95B6DACBA1F64FC01FDA0F44FDACFE0CFC438BC1 + FA5FECDFAD7C7ED26FE386DF45F89BA02343158BC28F148D6D1C3F6CF2EE03CC + 89748AEAAF180770CA9F33F867E11F01EABFB447ED39E0CFDA5BE07FECC90F81 + B44D034ED76CA1F12F83FC39716BA0F9970D0F9ABA9C969133DA4C4AC8AD3396 + 08C88C77AB67E27F847F177F6E7F1CFC4BF0CFC09FDA1BFE0981E0BFDA0B5982 + FA17B4BBF15FC3E9927F07D9DC4804B2C7A8491CF01B40824917E7C120856624 + 57B86A7FB447ED3DE08F8D3FB44EA5E32FF82767C50F1968125EDA781AE351B2 + 81DECED2CAD6ED858CD0DA4966EF7566CB2433B6164552E01742542DFD65DD5D + BF99C6F29A94E1C918AD52D5495D69D1DD5EFDECB53DE7E3E7ECCBFB2B784FE1 + 978B7C4167FB347EC90DA9699A3C33DBEA0BE03D3A1B6BA9DA280F9C05B88B7C + 7202E546E180F95C139AF9E7C0BFB2BFECA7F153E1AFC01F146A3FF04FDF82BA + B9F16C57706AFE21D12EAFB4CB5F0F5E9D42E6D2CFCDD2E3D452E6486430A079 + 2098EC24F18E57EACFDA8F49F8AB69F097E28F84F45F87D3F8DEF34DF0D269BA + 758DB24E23D7E4B416E5A3842032A49247672F969C333955DC770CFCF7FB15FE + D0DFB65EA3F06B5EF869E1FF00D88BC55E0DD27C1DE17D57C41A75FEB29A8447 + C4FAA2FDA2E6DF4DB486EAD52679A6FB44F831CCC06D05B970A5E230D57F95B6 + DDF4B68BEFEFD0AC066D4DD29D4759452493729CB57757B5B5BB5A2E97DDDAEC + F3783F630FD8162F86763F1075FF00D897C6DA6431DC6ABA76B971E0AF18EBD7 + 1A7F87EE2D6E26B757B8FB66A827F2649221CC71C9B4EE071F296E42F7F627FD + 801FE0DF87BE277883E0F7ED5BE12BFBBD29A49E4F0E78F2F6EF44D3B522F2C5 + 0DBCD7735B4D2DB2CB24710491E375FDE727819D8F85FF00187C53AD7C0FF8DD + 75E3DFD87BE37DBC9E10F09EA5AD35F78A2DEF6CEE35CB7BAD5A192E21D3D4DA + C711BC8E468AF48752FB2D640854332360F823F6C6F873ABFECA1F10B54F12FE + CFBF12AD34AF0369DA3689AE6B37F720369CFA8DF4AD6F776D6EB244B2C09796 + 89BE5741247E7C6B8292383D1CB4DB6EC97CBFE01C30C4639D9734A56693F7FB + DBCDF7EDFA9BBE0CFF0082497EC6FF00107C2BE11F16A788FF006DFF0008E9FA + BE9116ADB9B53D2B59B0D3A530472BDA3DEFF65468261E680825F2CCA01D9B88 + 655A37FF00F0487FD9F7476F065BE8DFB59FED0DE0CD7FC4203E8FA6CFE1CD1A + E2591848898244B6DC06923CB0000CF62057E9A7C37F84FE26F09A6876DAFF00 + 89AC61D2A0D2B47D0D7438228EE22B5B9B77BA6BB9DAE1796F3D66B38B6FDD09 + 6C5815329AF8EBFE0A33F12FE047C25F1BFECC765F1CB4DF8F7A6CB0D8DDDD69 + 3E2DF086A914325A5C2DF46F2E16493CB9EE6DDE3B4996DE58E4531CBC82A4E3 + 7AB86A31A4A76D4F2A8E6F8EAD5E38784EFCCBF962FA5FAAD6DD7D34B9E1FA3F + FC136BC5AFE21D63C1DF0EFF00E0A9BF14EEBC43A76AB1E8F3E93FF08ADEC135 + 9DCC9179912C813578D4AB29C891034646E21B82074BE1EFD91BF6D0D3B57D0D + FC21FF00054DD57C65A328B9BEBAB2B0BBF10D9DC5DE9F637A96DA9416D7533D + C5A457711DC9E5C8D95778C9010EE1E97E3BFDBF7E0FF8160FD8E7E235D7C45F + 1CFC5FF05F88FC5B71AA7FC25B7DE1483428747F0F4104FA7EA063B7896332ED + 9EEADE7F2C460116CEE808D9BBE83F881FB58FC00D0BF6D4F007C0B93C6BA742 + BE28F02EA525C6BD6AC4D8C7A96B72D84FA5DB2B95C39BAB6B20C920F9374D68 + AC54C8C16250C3D9FF009FFC12255F33E6BBA6B66F5847ECE8FECA6B5EF67D16 + E8F7EFD9635CD03C4BFB447C12F09699AEF8E353F1068FA9787BC4D7326BF2BD + D4D7BA55E5E5BC96972BA8316175E604539621B07690A576D7F534F6D8672012 + 7711CFAD7F155FB367ED03F05EEBFE0A08DE12F04789DBC65E20F0E689E1FF00 + 0D697A669F05C4973AD5FE93756EA6D49488A5BB1BD3141E639D8BBB248EA7FB + 63FB4C4F7925A4E6CEDF5848967B9B25BA8DE6B50C031DCA0EEDA09C07C05618 + 23822BD4C8AB462A718F7FD0FAAA384AAE2BDB2B3B276B68AEDB693EBAEB6E88 + CDFB29E708A68FB22FA28AD47181F32003D07AFD297E5EE8335EFF00D68D3FB3 + 5BD8D01E3DF0D04C0D52029F5E735F33FEDB7E27D0F54FD8A3F6C6B3B6D5224B + 897E13F8BFCB293B4326E1A35D38DB2290C9F77EF0231CF3DEBF1225FDBEFE2E + 050CBA47878A839C89CF3FA5666A9FB787C47F11693AC787B5FF0005785B5BD1 + 751B3B8D3EF6D2EBF7B6F796B2C6D1CB0CA8461A3923764653905588C735FA03 + F0871F6D12FBD1F1757C55C04E9CA17B5D35F0B3F981F84FFB5C687F0F7E245C + F85B56D06F341BFF00037886DB57BBD67C55A65BFF00696997E2F5235D32D268 + E20D1C8C9BD12ECAAE523F9BFD66E5678E6EBF68BF87BA7FEDC1E36F097C49D2 + 7C0DE3FF00853E26B7F1368F2787B488E1D32EB45BE30B44F05A6D2B6ECE353B + 5BC4600EC732A9C8DBB70FF6FEF0043F197F6A6F8A3A7E8FE3CF849FB3EF8327 + D33C2D687C3FA8DE5DDB69B67E5D8A189966225F28191AE27540467749807915 + C049FB19FED1DE33F0FF008893C2FF00B5658FC42F126ABE048F5DD67C3779AD + EAFA7CBACE850285B6B4B89AE3F70E316EAD0C570638C47086DC8CA16BF19CEF + 2EAF87AD530F5B49A6D369BD75EBBFF2BFC6E7D7E432C0CA11AD424B91A4D292 + F47A5D24BE27B68AF1B6CCFAAF53BDD77C6B6DE10B3F13DFFC57D43C1D63E14F + 065DDD4DE1CD76D6CF58D1E1BAB9D43EDB7B6FF6D6105C1636CA268E6DE02307 + 1B30587A2FECCDF1ABF68ED73C5FE11F853F1AFC4FE3BB8F14EBFE3C4B8D6A16 + 9A389AF6EF45D4DEC25B5963B651116852EAC09F2C05DF15BBFCC1483F983E28 + FD9A7C51A30F0647F16BF6B9F0D6853BA68BA4DADCDDDCEB32D86956B736A6F2 + DED66BD93C948648E3BBF3843B4A0496465932192B63E207EC67F12FC29E08D0 + 3E3DF85FF693F0EFC54D06F3C6C9A45AEB5617DAB4134D73797AB00D56DA662E + D24724D1A348EA5246DA87321C639954E4764B7BF5EEEEBA771E2729C356A6D5 + 49AD5AE57CBD546DA3BD9E9D9FE3A9F6AEA4DF193E3AF867E077ED85FB33FC69 + F0DFC2BF8BF36ADAA5D6A7A44DADC368B6D7974D6F2594B02CE8D13B2FFA542F + 7120217CAF989F9C0ED7F660B3F881E3CBFF00869E36B4D73E2EE8BE22B9F086 + 93ABBC42E34AB8F0B78DB4EB99E58F57B29ED241E6DB5D35A0BA12436E13CA8E + 1F31515258D8FE68E97FB1B7C40D6FE19FC5E8BE1E7C78F859E34B6F0F5F5BC7 + A8F8274ED6EF22BDD42596E96DF73DB488B1C5B18869166C1CA0501A42A2BD13 + E097ECAFF1E02A78ABE1EFEDB5F057E181D1D9ECAE3C8F1EEA906A1A732AB472 + 5B456496AAD3B050D1794BF2FCCB1B6DDDB6AACD68976DBAF97A1862301869D1 + 925515A2DD9B8EB14F5B3EFBE8EDFF0003C57F69FF00D9335BFD9E7E35FC57F0 + 2F85B40F1AEA9F0DF4CD6561D0B52B9B6F325B8D3E4B78A7B793F760EE50B2F9 + 665036968C8243E56BAAF819FB3C8FB6D8F8B7E24E8EF0DBABA4B63A3DD4592E + 739135CC44723206C80E37119718015BF58BE18FC3CF18FC72F0F9F178F8F1E0 + 3F89DE288522D2A7BED5BC5B17F69DC4B1249F2167448CC80C5E5AA2B00B8DAD + B79AF937E2768569E22F0BEAFE12D37E2FF84FE1978C2F8C91DADAEA96176C75 + A48954CD143756FBBC9F958348E239582B0E143313DF8282F67CB2DD58F3B15C + 4156A54FABA767B396BD377FE6FF002391D5FE27DA78DB47F1A86F87BF123C71 + E17D3E54D3F54D67C39693DC24170B234A8639ECE55B98CC60203380D0E4B21E + 1C06EAE58359D57EDBE1DB3B7F8CDF183C3167E1BF0ADD69FA27F6EB4BAEF84F + ED57B736929D3AE4981F6192CA194F9C0848AEBF7A1847E69F98B54FD937F68E + F84FF16D7E0F78D3C7DE11F80B7376F6634CD7E6D7A73A36B2B711B1867B29AD + 2179268F6C526E75894C611958718AB971FB07FEDFBE1CF17FC5BB1BED33538B + C4BE1E9221E23B87F1F59A35C5A089CDBDE46D2CE1AE2D1A2594C72282701976 + A91B6957AB79A94755DFF07F8B3B696070D4E9BA6EA456CECDAB6E9DD3BE9B35 + A3EA7F45FF000C3C27AA7863E0E7C3DD2D7C57E36F15F86ED7C6DA4A785F51F1 + 0CB6135F49A11BDB636F1DD3D981148D1B89D03A6F2447F7B6915E91A96953F8 + 8BC413E857ACF616092B5F6AB2614186D9611248E64C90A52324E4E3F7B30524 + 1C67F3EBF64CF82DFB6A7C32D07E036A9F1B7E325C78FF00E144BE23F0FCF63A + 2AF8B2DB54D3F4FB796657B664C6656DCD223E14F9681B8072C47A3F81BE057E + D213FC5BF8F6BF16BE32DD7C44F805AFD8CFA6695E0CD42F4D89BBD36E26334D + 06A42048DE3545C42AEB21332112B6D2112BE7B129425CF66DEAD2DCE6C0D1FA + C3A947DB4230E6576DDAFADF952F37BDBA6DB9E91E10F1D7C37FDA33E30FC3BF + 8FBF073E22786BE24F847478F5EF08DDC7A6C12C49A42CF6292D9DBCA92AA33E + DF2A58C4A142BA3447AAB13DEFED29E2FF008E5A178F3E0D5B7C34F853E2BF8A + 9F0E12DD758D5B4ED11ADD6E2F23378E6E228E079A39E7BA7B64052340CD2005 + 01CE2BF3BBF67EF85F07EC0DFB40789BC3FE34F893A07837E057896E358B8D3A + 79E7B8682DE0B781E3D3ECF514680EDB8864BAD8ACA583F98A5DC87403E9BFDB + 0BF672FDA63E395F7C1FF8F5FB2A7ED3165A1492D869FA25868F1EBDA8E8B6DA + 8DEC4F28B69AD25584449739F311D6708184716583643674F152B2B2BA6BFCCF + 5330C9297D6145CD25071B3927AA7B2E8AF77A5DA47D23FB4CE8FA7FC54F865F + 186FBC27E3AF8E169A2E99A35BEA3ACF823C61E0EBFD2F446B6B6D924D269725 + FE9F6F2D8DFAA9575786791098F0536C8EE2C6A1F1B7E17F82B42F07F82FE2DF + C62F115FDFC1F0BAD27BBF0541A4C77BFDBB60F6FF0065FB6F98966D750C925C + 15457179122BA290A3E676F82FE26F877FE0A05E0FFD93FC4307C7EFDB1FE154 + 5E3E6F12E9D05858788B52B58F45B8D305BDC096CEEEF56CE3F3A7795A3B91B8 + 2C6A2C36EF6694AD7DD3FB457C03D6FC7DF01F5497F664F1F7C28BAF8CE740F0 + DEA9E1FD6F525591359D06DEE1F6DB36A0C8CA6CCB5CDCCF0B903F7A885812FB + D1D2936EF15F91CB8AC34694553AB52327B697B6B67EF34BA2BB77E97DEC4DF0 + ABE2F68B6E9F023E19EBFE3CF8847E2127C21D1FC4377E1B92CECE5D0EEED584 + 703DF35F4B6A6E16F565918158EE1323CB7298CE767E3C68DA7FC4EF87DE34F0 + BD8FC49B1F86FE27F1E32F86FC3F7F77E293A1EA0DA92A194DCE9CA260F3BC73 + 2D8C5F648CFCF6EF3E4067515F1DFC68F83DF1F7E1178CFF0068CF8BFE14F1FF + 00C38BDBFF0008781F4AD3BE1E41AE69D2CE90E8B6E19F57D335130C41CBC464 + 49E2BD76655316D7E0964DEF197EC8F69FB5A6AFFF0004F9F8DB79FB427833E3 + 7FC39D02E16CF57D43C397971A2C08934EA4DEE8A4DB02B7316AD6E612989253 + 1C3187388DD86D2C4351E58C77F4F530A183A5EDFDB4EA2B534D6977EF3B6D74 + 975B59DB5BA343F612F8C1F173C75F08B445F8DBA778C2CBE31F8443F84EF667 + D511E7BE821113FDADC8663F6C5B62F6EECD872E92499CC9C7E9BF8AF5C9757D + 44691AC5FCFE25D35E1584C77E7ED50C8A54FC8639B72B038C10DC71DF15F1EF + ECD1F0CB5BF0EF86BC53E2BF157C65F831F1EFC63AE78ABC42355D43C2C26B1B + 18D965582206D1AD605826023713050C15B18670031FA4B5A93C3DA3DC41A3D8 + EAFA45C5FDAABDA2C50CCD2465957122C5270B2F965883B58E013CFCD93B536D + C9C56DD2FF00D799E6E73469354EA452736DB7CA9DACEDD1ABAB35D6DBB69BD0 + 9B468EDF50BFBA8F53B633486F6E64F906E8D7182371FBC1F81C01D87B56D78F + B44F09F8C3C1D7DA2F8D342D3BC4362A56E9ED6F2C61BBB6695508899E39D5E3 + 6E588C80586E6C73C571FA7F8DB44F00E83E26F881E33796C3C31626D2E0DD2D + A3DDC61A47688910460BB12FE48C039C64FF000D6178A3E327C21D77C210EAF6 + 9E32F0FEBFE1EBCD286BD1C7650CB16A1359DB875B89ADF4F72B72645313AB70 + 5542B82432E2B4C5B7ECDC23ABFEBFE01E5E5EAF8C8D49FBB18B5AE9E4FF0027 + D0E1FE31FC1BF843E37F879E0FD3FE3FFC2DF05F89B42B6BB8B51D2B4FB982D9 + 2D7449E3CC62243BE20898088C858A39DE8C8CA145794FC4CD13F671D7EFA2F8 + A7E2CF0A7C27F187C68F0E69174FE1BBF96FAC1B50B5963679E0891D67788CA1 + D8F92644631973B369359FFB697C45D6BC69FB3D6BDF0FBE14FC4BF86367F152 + D74FD2FC55A5D9DFEA1033C5A6CD2DAEF9AE6CA58DDD6CE58672FB8A0F2C94C9 + DA0D7F37FF001A3E317ED7BF02BE306ABF0B7E2C3FC1AF1378934FF2BED90E9B + 0D9DD5BCFBA15979BBB628E0852411952AC08C0201AF3DD1A14A768DDAFEAE7D + 8E5197E371749C938C5EBA5DED7E9E5B6AB768FDE6F0778C7F6B1F077C4FB0F8 + FF00F0E3FE098FE13D37C7FA8EB369E28975A8BC097AF79AC4A97A9723ED579F + 68123A34B022CA8AE81F0D9EC6BEDFFD973E2C7ED0DF0D353D5BE32FC5FD13E3 + 0F837E244DAFDE78AF54B3D77416921BBBA92EE595E133885A5F20F9CC9E509B + 3E48540DC035FCE6FC1CFF0082D3FED49E07F893F0F746F8AF27C3BBAF819A5E + AD65278834BD13C2DA6C3AA5D686265927B6B2BD93A5C342CC892B36776D62D9 + C93FB2BF04BE2DFEDAFE26F1E6A5AD7C7DF16EABA37C287BE4D53C37A369BE13 + F0ADBCCFA3C9FBD86DF55B98D24BC8AFC432A5BC91C51AEC612E27DDB5C7D1E4 + 79657C6B70C2539CDAB5F955FBDAFDBE619A519E052FADCE9C20F6BC9DF65AAB + C7A792D343FA23F08FED91FB4CF8D2F2F63D1FF677D06DF4D8D17CA9AEF51960 + 12B0EACC197E5561CE32C5738249AE9E7FDA7BF68859E655F07FC0A89439015F + C41296519E84E3935F9A571FB50DE6B17020F115C6B71787B6847B2B088C21A3 + 030A81C1CE3A64FB53A0FDA23C0F0C10C31F8775B48D102A80AA7000E993C9FA + 9E6BEAEAF0967E9E986B2F257FC5B3EAF0FC45C30A294B149F9B9DBF2470373F + B2FF008EE15FDEF8BF45624F4FB200187B562DD7ECD5E3E12BB1D7F4B9A3887C + AF1C18F4E9EB5FA5C742D02F2EA4BA4F096A1294C6118B305FD7151DEE8FE1F5 + 8C492F8225283211813927B8C66BF7E8F136393B26BEE5FE67F2CACA7036D53F + BD9FC4FF00FC1440E81F0CBF696FDAC7E1B7C4B316ADA8F883E15E85069456C5 + A74FED3FB24735B1E06222AD0A8F309014E7B66BC6B53FDAFF00E12E99A758DD + 699AD789B54D66E7E1DE83E17D42D2CF4B7656923B5D6A3BDB6B8326C5037CFA + 5386048232549D856BDBBFE0B95A5DADA7FC140F53934ED366D3AD2EBC05E14B + 8113E772E219A2663E8372019E9D077AE3BE005F785749F077C0AD53C5DF0CBE + 1FFC52F04697E15F11EABAB68BACFC3FB3D4659EDAC2E2696E6E2DEE82179D15 + 36BCE8D89636D8C1F638DBFCD7C51467531988AF2766E4DBF9737F9FE47EE796 + D5C3D2C0D08B8B92E5495BFC31F2FEE2EDEBB187E1AFDAFBE0E278C61D52EBC7 + FF00193C036D75168BA66A5A858E8693C7269CDE1CB6D2B524B8B49E19D64646 + 1349148A37615D46DF355D6BE8FF00B527C1BB8FD8DBC03FB3C4BF10758F0CEA + 9E19BA3ACB3A4375E578A648351B76B3D32EA0FB332AC5E5896E9A459372C912 + 01820D6F786ADFE15E8FE29F03E8561F0A3F652D4F51F15EAFE16F0FCB6D6DA2 + 472F88FC3324F6B1EA4F7369A5CE8F14A265CDBC1722401F3189158C991E8FF0 + 7740F851E20D2FC1FAC5D7C0EFD95BE213DB6A3E3CF3755D3BC2725B477C34FD + 1E3B9B7D36EEC2E8A49186266958B219519191275DB86F9FB34A4EEB4FD2CFBF + 46CEBAEF0FFBBBC6697BAFECF4524AFA3DD26F7BF63CDBC7FF001E7E1578FB4D + F0DCFA47ED7767E1EB2D23C6FA9FD89357F0089754D4747D456EE61FDA9750CA + AF7896B247046CF23C40B5E99546F8941B337ED05E1CBAF0BCBE09F117C7DF80 + 361F126FFC51657F27896C6CE7BCB6D574C8ACEF6368B51BDD915FB234ADA648 + 914B33345242CE81B3835F45D07E0769F65AC6BFE35F82BF05BE22784ACFE184 + 7AD6ABA7D9786AE74FD4745BC6D164646925B328562FB4476C62BE4605C3B997 + 2C2463E59168BFB2DA7C23F08FC75D63F65EF15CFF000E359BBBBF0D472E8FAE + EA8B1E9DAE792C2D23D4247D41FCB495C34BBD436F58275550632A5D693A4DA7 + 6EFD7BDBEFBAFC4CF0B85A155414633693B2D29F55CC96CAEADD1A6B456B1F56 + 7847F6BAF853F03FE1CFED09AE7C47D2FF00668F1CFED15A8E972CDE1EBBB4B3 + 4D69F5ABD1B93377751C30DCB4530951FF00D21D650F193BB9603E7BF835F105 + BC73E13F8337DF133C6DE1B8B42D5FE286A1A76BD1DDA5A8974712E9FBA1D46C + C4840B5D91412DBE0611D042A4E579FB67E15FEC77FB28FC5FF1378EFE1EF823 + E037C3FB059BE1ECD059EA4DA96ADE7DA78AFCA8E237481EE592DA28EE5A1640 + 84875694C8A000A3F002F3C37A9E90D77A3F89AC614D52D2EAE34ABC2630C86E + 6090C72C4AE32AD8753D0E31B4E30466E309C2AB77D5A5E9A3FD7AFA9397D2C1 + 6268CA14EE9C5EADA575CCA49595DD92E8AEF65F2FD60F1F245F174FC7DF87BA + 97C41D33C59F137C0BF1D6CE5D3B5359A365D47C2D696F75A7446D5E16789234 + 856CA555562AD89886241CFB769FF166FF00C6FF0005BF6EEB6F82DF1020D37C + 77AC7C54B162D6770219352D10DEDC45A98866C705E29E39B0086783CE284ED6 + 07F0B934AB585644B688DBC6D1189D63F9519491F2B01805723EE9C8C8CFD3D3 + BE107C32F18F8CF5EB9F0E781751BFD1CDCC6ABA95DA5D4B6F6D0C19E0DC18C8 + DEB9C858FE62C4E00FBC46F0C2D44941AF5FC12FC8DF1597D0507273B28B4D5E + 3A2B34DA7AECDEDB5B63FAF6D1BE27783FFE152FECDDE184D4F4F8B578B5FF00 + 0523DBACEABB123BA87CC4923EBB020E78272474C578DFC3EFDA67C25E30FDB3 + 7E347ECE1E3ED45F47B88F5429736D21666BFB28AF629A48A2746DD2916ED6F7 + 062465778E22403B30BF0B7ECC1F0E7C31F0C3C59F0C7C29A64B3EA50B788B47 + 7BCBFBE0EF777F2FF684019DC6E601407C2C4BF2A024A9C972FF004CFED75FF0 + 4F2F0D7ED05F15EC7E29E9DF11BC4FF09FE25C4B6B05DDD6976A2F7FB45616D9 + 6D22169A278AEE3501164562A512305495DD5E3665395271F68B46799C2B91D1 + C654AAA351A95DB8BDB7F2F24EDF33CFFF006D0F875F0BFC0FE18D17C1FA2F85 + 740F86DE3258358B1F0E786BC3BA9C375A0DE594F23CB75279DD62937F932409 + 9CED6685A352A02FDE9F007C77E35F067C1AFD867C270781B46F11786FC433A6 + 9373AB5CDEC90DD68B3C97372D1CD6B6E2D6459C32A4DB9FCD876F1B4BEE38F9 + 2FE36FECA317883E2BFC0EFD97B59F13F8DEE4CDF0EFC556D6DE239F5092F355 + 5BD8044F6BA9493B15692E05C2EF652CA183BA02A0A95F58FD9B3F649F80FE16 + F18B789FC2DF1DBF691F8C96BE0FF0FDDE8FAEE817DADB6A567AB6A771E6C6B7 + 56B6ACD9B3B90D1CA62B542FF746655DC777152949AB45597FC17FA9EEE3A387 + 842319CF9DB5A5B6972ADEF7B25D75EBB5968BCFBF6BBB9D57E247C11FDA2F40 + B709A847A745078974B2EC3CCB69ECAE9659234738037C4678F0C48064E075C7 + 71FB147C56BEB6FD9B7F657F049FEC8BBD62D7C43AFF0081AE0DCDD446E534FB + 08750BDB388C45C968F7CB670703206074AF573F14FE186B3F15BC1FFB376AFF + 000BF5CB9F08F8D34ABEB2D72DB5BD3AF3C39AAE8266B5BAFF0044D434EB885F + CC8E7B6B691D2E21700027032BCFCA5E31FD857F657F0278474C6F0D7C14F8B3 + F0FEC7C416BA27C2ED52EF5BD41B4CF103C925F47347E20B29227B887EDECF66 + 893168E147463BA101DABADD47CAA305B1E3A8D37192ABA293D3676E97DFA2FC + 5F6B9F47FED19FB557C38FD9574AF065FF00C505F88DE24BFF00883E203247A6 + 787A38CDD1D02C9E192737504CD8FB14D2CBE4CA83F792AA6102F9995F997F65 + 8F10C5FB36681FB677ECD7A86AD6EF63F0C3C432F8D7C153C727EE753D2AF6D1 + DE09559982A21B84B59D97394799F8418C7B7F873E1178035FD32D7E0D786FE1 + 9457F0FC0BF897633783EF74BF11A683ABB9B442ED77797B74CD15D4AFE7B3DC + 2011F9E33B3CA2833C6F8B75AF86DF007E1F7FC1489BC3FF000A3C31E2CF0BEB + 8BA1EBBE25D32CADA59AEF5F975D99ACEEEC02F9C044105FC9246B079382FE61 + C1C80AB4EAC9F3CBFAD97FC00A4B0F0A0B0B453727DECBDE4EE9EEEDD5FE7DD7 + 33F0CBC0DA17C47FD9D6EBC29A97C41F851E1AD760B8D75B4FD735661757FA16 + A4CD0A417969B1D44444909121925889DD104F33915DF7C04D66C7C6BA3785D7 + 48F8CFFB34FED39A468B7135CE8DA931946BFA55BAC9334317F679B6B855BA80 + 5CCD10B98E6816489959882CC6BE79B4F007EC63F06FE166A7E2AF861FB2A6B9 + 69A7FC4BF0DDD7846EF48F1B6B975A834F651DF5BDCCA9A8C11DE6D5955EDA36 + 8A6B573246EB19528464FD69F093F66FFD9D7F653F881AFF0088FE09FC37B7D0 + BC4DA8F8526B79B50D4F5ABED46EAC236BD43B607B976411BA797BB6AEE6687A + EDC83B5384F99396C7978FC4D0A30942126E5A28E8ACF4EEAEFA5D7C8F4BFDA0 + D34887F662F8C1A96BB7DA7E89A7C13D8857B89E38916592FA088167918023E4 + 08325492C3AE029F02F86DE3FF0085363FB284BF6BFDA43C33690DC68FAAF866 + EBC27A7A585D36A771A8B5DC76046A51C8D730DCCB20314768BB55FECF23956C + 363D23F68DD63C61AD7C018FC3BABE9B1EADE0EF1280BAF41736966F6B796B70 + 1A48ED44722E77C6B6F0CC40313FEF5447264FC9EBDF00FF00636FD9BB47F824 + 93787FE05FC3FD0340F10DFE9BE25D52DA2373209750B109259CC5A499D94C12 + 79AF1A8608BE748A5712C8A5CE325272A6B46703C4D15454716DA927A256D9B4 + F4BF5DFEE3E02F8FBFB55787742F801E26F00F887E2A695A0781A3D0FC1BE15D + 0AEA5B294A5E6BD657500F12E962748B22E2DEDAE6C1A68E4F9A20A51705981C + 6F1B78D3F603F8BDFB72FC2AF1B6A9E38B0F88DE2FD5F413A3E9D63E23F021B9 + 84D9DD5B4B3E8F35AD8CD6EB15F339BF4489EE72DE44312B18B9AFA4FF006B7F + 0D681A1F8AFE13785340D1FC2ACFAD789A6F13EB76D73A6D84B16BD7D79776D1 + DCDDCB6F728DE65C4A8A51E451BD9300FB779A8E8FF05CFED4DF0A60F0A7C2CF + 8611E956736BD6CECFE0285EE34D161A46EB3B4B55FB24573F67B59A04B9823B + 5386F35D219183A9AE3AB46575CD64F43E9B2ACDA9C294952E6945464EF7E8AC + B4D15EF6DBBB7D0FCD7F85FF00B377FC135BC4FF00F0503F8ABF08EE5BC5FE28 + F8BB75E2BBABED2B44FEC1BBD2ACB4AD5A290DFCBA659DAC4B1410A5BFD9AE22 + 293868E48C158BB0AFDC7D53E0BFC45BDD4F54BBB4F859A83C73DC4B74AEF7CB + 1B3EE72D9DA7A1CB1AF3FF0013F8974CD03E275FF89BC5BAEFC3FF000369DE1C + D3878AFC69E2436EDA2D84B35B22C4935D3BBBCE892DCCF6D0A096496511B140 + CCCE73FA0DA7EA31CB2D85DB4FAACF0DCC51C824FB434884380DC1E46D39E08E + 0822BF5CF093309E16A623D82BC9DB7EC9BE9E57FC4F91E309C71D0A3F599495 + 975D75B24EDA5B5D3A5F667C4EBF03FE25306127C30BC8D79CAFDAD4EDF6C77A + AABF04FC7918119F863E2052A318170D81FA57E844CB70ADBE27D4EC231CA2A4 + AC41FAD02E7536018493904672666E6BF6F871562FF917E27C1CB87B09B3A8FF + 0003D0AD7C612B9923B76BCB1D3B70E05B0C2E7FDA079A6DCEB3E1C8E069AF35 + 2B8BCFE25855031603B63B74FAD79227867C4221B95B7F127881E3660A9E65B0 + 0A99FE2C918AEAA0F85DA67FA2DC4BE28D623B98D4B4C55902961CF200F6E95E + 3CA8508EBCD6F4FF008626157112FB3F7FFC39FC91FF00C169757BDF8ADFB666 + BBE1CF03E897BE0AD334CD1EC747D72FB5A51650CA9616AB706F3CF1BD8E9EC2 + F95D1FAB3464EC016BE1ED17E19FED71E10B2F0FE89E06F1C7ECFF00AF68DA3E + 8DAC2594D69E23D3AE636B0D7AD912F62952E5118B491431BA8745640C1D4956 + 527EEFFF0082B778BFC59F0EFF00E0A1FA9E95A878974AF01DBDBF85F4BBCF0B + 78866126A56FA8E9ED6FE5C06FE281965B6DD3457E8FE5E5A311404210CC5BE5 + 0F86FF00103F653F1E7ED47E1586FD7C17E1BF09EB5F0BAFBC3FE3B991FF00B0 + 346D47598DE4F2A4B595C44B0CA618EDD167555DD2428FCB972DFCF7C4F5B971 + 3512D62DCBCB6BFCFA5BE68FDA385E1386160A70D6CE5B396EFBAB2D62ECB7ED + 6465DAF86FFE0A53A4DBEADF0ADFE1ED978A358F09C3A1DE59695E658DE6A76D + 0E96D05E5A9D2A18AEFCCB92123851C448EEC8CF1AA83B80B17D79FF000511B4 + F1DE99F162F3E037873555BEB5D4FC673D9E9F6B6896DAD4DAC0369757ACB6F7 + 81DEECBF9AAF1478789FCDDD1805ABA3F847E3AF03EB3F053E06FC7C6F1169DA + 778C3C3DE08F889E10F1F7DB2698DC4DE65A09F4E2F2481DE5DC67B98143333E + 5507DD606BD8FC4FA28F14FC0EF839E21B1D5B541E23F0EF8C7C0167E20B7B86 + F32CA7F0B5E582476AF2C6ABBC4715E4D6EB32924482652036DE7C2BCE516A4F + B7E2ED7FC13FF827A152BD2A7594634A3F1493D1AB74FBDE967E6BB9E03F0CFC + 43FF00050BF03EBD65ACF84BF647D6B58974BF01BFC19D547FC23F773DAEA56B + 2C77EB99DA39C29B8316A9227C8CD0B2246769CB03F25EAFF103E28FC30FD932 + 5FD94FC79F06BC59E14B7D5FC4BA5F8A345D775CB3BDD2DA41626E9A4852D6E2 + 055B8CFDBD732238D800CAB6EC8FD4FF000E7C3279BC67FB387C3DF11DAF8B3C + 0DF0A7C49E3EF11F873C6715C7C418B57F0F8D425D3CB585FD84819A5B68A2B5 + 5B992269642505B2B32C4C416EA7E145B697F11BF61CF12FECB7FB565D687ABF + 8FE1BFD4D3C3573AC4ED733687ABAC135BC1A8DBC91364624F25C042CB2AC8E0 + AC9BEB9ABB4A2EA4BCBF34FF003D763D3C1E2E9CA6A318C7752D347EEDD736EE + F6B3B6BB35D59F247ECDBFB79F86BE1EFED37E21F8ABA07C00F1C6AB77E27F0A + 68FA15C693A56AF6AD3DD6B16D68B6F35E9F36354F2E63123B0FBCBB5E463962 + 2BD33E3D7863C25FB46F89F5BD6353F0A7FC2B9865D564D6934FD2A5B626CA59 + 547DA13CC862589CCAE1DDA4541B9CEE0C4F2DE5BF0ABE0CE97F0BF4B9841241 + AE788E6686DF50D5446CBF2328631DB86E561C8C63EF39505C8E157D4344B7B5 + B1D5E33F6B79DA76DB9653D092C41C8C6396CFB01C706BDA8E19C1C677BA7F85 + CF90CC31946A55954C3AB4E2959EB77656EFD17CFB9F2DF8D7F667D3FC43E27D + 2EFBC19791F857C36EB0595D5B3D93C8D6D3460237958F91C9DB9F9D81246F62 + 771AFA77C23F0EF4CF02E9D61A2786ACD6D7488AE0B4AED26E9A57C006591C00 + 5DF81CE3031850060551F1AF8D7C5BF0EFE1DEA5F14BC2BE1FD23C6BA4E8DE26 + D1F4CD5B4E91567456BAF3D63CC251D5C8F2D6321F19F3901EB5ED7F177F6CFF + 000978EFC25F05BE35FC38FD9D7C0BE17F0BDA789EDFC1BAC58ADADB94B9BE9A + 3B999509B522396DB6D83AA153E629964C4ADB06EE97895ED3923AED7F9DADF7 + DCC6A53C6D6A5093F835B5DEFF00AFCCF4AF0369B71178FBC03770C37A8D1EAD + A65C02C48793FE2616BC67031F7B3C7A038CE057EE1450C73DB5D46D1A0BFB79 + 06C468C654EE38C1EAA460824631C63822BC5BE34FC18F86F65E1AF83BF103E1 + E58E8D0ACBE25F0CA79D6F12C0B7163797D67228608155D90CB18DE54370464E + 4E7CE7C5DF11FE25F85FE3DF83FC1369AD413783B5CB15BC360F670B00A23999 + A5F39A3F3049B8A390ADB711F6C15AF271D3F6A9795CF1B0B39D39C696D2BDB7 + F4FC3728FC6ABABD1FB727ECBF791C104F7773E17F144121DE1635431AA2C8AC + CF8E2478E4273FC2DD785AFCCFF807FB4DFEC07E08F8ADF157C572FC62FDA9BF + 659F15DFDEDC5BEBBE768E9AAE9DA9B1BA9259A0BDB5BAB5D46181EDE6575478 + D6309BE41965C2D7D03FB75F8F3C71F0DFE3AFECF7E35F09788358F0C6BF1DAE + AD6715E5A2A6618A58ED22954AB8652AE19918119031CF435EF3E18F871A7FC4 + EF859F00BF685F18FEC6FF00B2EFC7EF17DFC4755F1BF8B356D021B4D78CCFA9 + 7916D3446280C1777062DECFE62B3130A1DA14BBAF930A72943992EBFA9F7117 + 4F0F4E1F586DC1423F0BB6EBB5ACEDD2EFE4CE7EEBE34781BE2D7ED99FB257C3 + 0F07DAFC41F1EEAFE1BD0EE3C7E359D534A8AC750D5FC3D7D66D2C6638E38AD6 + 16891250C418A2915DA5508AC25DFC0F8FAFBC43E0BF8F3FB2E7ECF7F14B52F8 + 99F117E23EBD1CFE25D26F85A5BC363AA5DC37979792C11C65C4626B4B582DED + 447B43BAF9183FBEC5769FB5A59D97877C23E2EF1C6A36FA7CBE2FD0FC610695 + A6F8B525163AA41A64EF36EB6FED3004B6F03C922B3AF98230559DC6066BE81F + 04F8EF5DBBD2FE02699E2FF127C43BAF1749E17B78D74F9FC13F6BB2BAD50D95 + C16F37C486271697322DBC8851640488B258F9A0129C65CAF95EB739310E1CC9 + 3568593DF572F5B6D7B5D5B5BF4D2DF9FE9AB2FC75D67E1241E1C87C63E0FD2F + E2C7C68975ED0B5FD7ED1EC6D74D5D1A39E6963D4E1044D69E7F96FE44589524 + F999990C654FA8E8C7E28F8BBE077EDBBF13EC7E01FC45D37C493EBF268A9E0F + D5B6DAEADAD5AD9B2195ADB11B452878AE1963F2DE5131819518965AFAE7C22F + AFFC69F857F0C3C77A8EB37B71E10D634CB74F12E8F398EEAC75D86E227697ED + 2D20766F2D7CA48F690AAC89B79C83CEFC01F016BDAC7C09F819E31B1F89FE2F + B0F0DE83ABCF67A9693713C7268FE2AD15F53BA3776FA85A4EB234A9E4AC9144 + 40050851B86FE76A74E696ACF2F138DA552D186895969EF6FA35A5B469DAFA34 + 7C65FB567EC9FF001BBC49FB16FC1B5F863E18F1737C5ED1AE6C75A93C2D61B6 + DB54B7B2BCB475B8B38A266DD35CDACB35A8645193E44DF210028F59F833F107 + F6A7F891A1FECE9A3FC52FD9C34AF03F87FC493DF41E2ED6F50D4DA19FC3B636 + 8CBE5DEDDE9A211730ADE334CB6F08947EF0EE6C204ACDFD8693E21784BC1BF1 + 17E1678AAD74ED4BC2BA06A97A3E1FDD9D424B9BCD3741BD174D05B48CF8DCF1 + 47108A3DCCE5167DA40F2A3CCFF1C7C66B61F1EFC24DA27ED4FF0006FE1B789B + 4CD374F95BC1BE21964846AD285926547992556B682E207541388662AFE5E164 + C1517256F79E9E40DA69518F2CEEF4959DECD593B27D1EDBED677B9E65F11BF6 + 7CFDA474AF8A9FB47FC40F06F89FE056B5E37F1AF8BC681E1AD1FC5DE3386C2C + 3C4BE1DFB30BB867B34173E55ADFE96F6EB6C206F2BCD85A475494AB39FD0AF8 + 15F10E2F861E0AF02784BF682F19F86BC3FF001A6F6D6FF4FD4F4DD1EF1AEBC3 + 96D756B1B5F49159DC2AB22B8B15B5B96691F69DD26D663915F9ABF1B3C5DF0C + BE0B7C4CFD9D7C73E329BE1F783FC6BAC78ACAEA4FE18D65AEEDAE74E5B392D5 + B51BE22DADA290C333DB44D72B19624B6F918ABEDF69F8AFF15BE19E8DE39F05 + F8934AF1E6897EDA03EB3E28D66E277115A688FA8688B67A4C174F9DA3ED1241 + 8883ECF3F0163660E8EC51928272EA679A60E58CF674A4BDD927AABA7EEE895D + F4BF4B76B696BF5BFB54DA9F8E7F13BE166A7F097F690F00FC21F0B69FA06A9A + F2EA7ADF8506BFA6EAD25BDCDB9B6B8B5BB56681364D2C69389248D961292C49 + 390C173AC7E08FED2FE1EF89DF017E3A3FED13E0CBBF0D43A8684BE23D1B46F0 + F224BADEA97ED63A6EA925A6A2F146F1595C48A2487680F121915045B8356AFC + 24F177C40F893FB43F86EF3C5B71ABE95E2EF0CF842C741F14FD8EC842FE1AF1 + 5DC3C336A3652A863F67B80D688EB112C8B1449B1C8CD7D63F126F63D2F43F0D + DADBDCCD2CE7C5FE1616A858B3394F1169F92CC79248E7F1A894233E69DF6FF8 + 052C5D5C2D3A785824D497557BA7CCDEB6BE8B5FC366D1F2168DF0FD3E287C69 + F8D3FB397C54F157C6BF8E16F178D6CBE23DBDE2EA565BBC45A5E992DACB69E1 + 8B8B2758629E022578DAE7ED10C8DB15F081156BF5BF4BBCB2F0CDA693E11F0B + 6897FE1EF0E5ADAC76F6765144D7096902A0096EB233B96D8008F1B982840A0E + D0B5F979E26F82FF001ABC5BF187E3CD869BE01F1BE8FA4788AD64F00689E21B + 3B37B88ED85FE98D35BEB022B66F33EC08DA5496B34A8CB245732C0853E72D5F + 62DE7C5CD476878AEB48B1B360AC8F6D70D3CCACBF7D0E547CC183020E1B39C8 + 06BF5BF083035AA55AB24AF1B6B7B5EEDFDFDF65667CEF1AE2E29C20E5A2D92D + 969BF6BBEDD0F7EBDF14DE59169A6BDD4E1527207D8DB117A8383C7E359726B3 + BDDDDED6FE462492C11FE63EB5F3EDD7C451E209EF6DAFB59D3EF0B27988A2E0 + 45207CE00C1EA0FA9AE4C7C58F10403C91E16D5DC27CB91A9A8071C71C57EFD0 + CAE6D6DA9F9DBC6416ECBCFF00B6FDBF9DA7C707867C65728AA7CAB6BB591C7E + 0B81FAD606ADFB6D78948D434AB6F877268CB776D25BACA22945C4123A141347 + B7A3AEF565CF702BDD9B57F0F4F0DD4D1FC37F105CDD42FB5DD34F5D87D80EA2 + B8D7F185A9D4ED34ED3FE18EA96F70F3AA461ACDD9E472DC7CC0617FC9AEF851 + C2CAEBD97E3FF04F31D4AF7BA9FE1FF00FC0FD73C67F0B3E35F8AFC45E38FDA5 + 7E1D699F133C5DE1FD2AD6D26BFD5ADE5BFD42E6D22B686DA2B58CC922AF98F7 + 46EC80E49F3268D94A05DB5E51F167E087ECCBA778A3F662B4D0BF6729B4DBCF + 1843A9784EF8D9EB5730F87A3D62D6EE4C492B4571E70BA685ADE512F98607B7 + 9A1758C98DC8ECBF6DAB3F889AB7C7D8BE26FEC77F0BBED5F0E753D0F41D6B5B + 0D343241AD6AEDA85E5CC134515CCE93C71B98E2212158C33DB3928BB327E26F + 0D6B5FB5FF00C14F037C3FF869E21FD9C7C6B7FA0699E2D3E3AD126BED035179 + 9A4860B8B79E28A6B63247F66C5F90E71B811100C36F3FC619C538D2C5CA3CCA + 4A32B732774D75D7ADD36EFE5A1FD1DC3D83AB530A9C2AEAE3A479ACD36B4D13 + D2D25B6D67ADACD1D4E97FB3E7C00F8843C5D65E1CF835FB52D9788F4BD5A2D0 + B5FD186AF6F3EABA0EA10452CB7CF169725BCB35CDBC48B873BE496329955DB2 + 56A7C39FD91BF66FF899A9FC2FD3F46F13FED2FE15F87FE36BE9E0D2BC52E34C + BAB7F205F18A24BFB248E3105C2A9B597CA328DEA4C91919289E67A57ED83A6E + 9DF13BE2778F7E2A7C19D1F53BFF0012F8E65F1ECB671EA97DA64BA4CD342F14 + D0DBB79B6F3BC6F14F2821E40AF94241D8A46EFC2DFDA33F672F095DFC29B3D6 + BC17F120F852C348F19E89AA5B4422BBB892DEE5CB6872C722DC44B3DCDA09A5 + DD3058D81031BD48038229B8A9545AB5F8FF005B7CCFA0C4C715172F60E574D5 + B66ACA2F6BB6EF7DEF6BF6FB47736FFF0004F0F1B6BBF0BFC23F103E1B7ED3FE + 17F147856F7C6ABE1FB787524D4F4731EF63143A9410B4D2C933182682478923 + 134715C1CE5158D7D69E02FF008259DBF837E22F802CEFFE2D787FE217C42D72 + D751BC5D52F34DBFB5B6D221B3081A38A376925B99A446631B31500238C4614B + 1F8F3E0B7ED7FE09F04E99F017C11E21BDF1758F85F43BCD1352D5A46D384D06 + 9F776F67F65BB922F2CB4CE196CB4C20A29DC1E5180579FA57C5DFF052CD02DB + F694F85FF123C3FE25B3F1AF822DFC777575A6C6CAD68DE13D12DA48EDE04B88 + 0C684FDBA23732CC252702553F2F92A042A71E6517B7A7A5BE5FD7438B33AB9A + CDB85257B7556D56BA6DBE9B69D346DA4FEDCF197ECA775E19D47E28E892F8F3 + C1169A7F86A3D2D3537D4EE24B1B9B99EFC466CC436CD1BB4818B38023672769 + 276804D7C21FB75E85E30FD93E2F07E86D7FE1BBAF14F8816FA482EF4E99AE22 + D323B478A2930B24633397B8528DCAA8DCDC9DB556DBE2C7C1CF869E31B6F00D + 87C62F05F8B74193E23F892C96E9B5D8AF0A58DBEAF6DA8E937AF70CFC24B6D3 + CD0ACA58A8789A3CF2C2BDE3FE0AC7E0ED1BE2E5A7C1BF187C37F889F0DFC64F + 6371AF417AB0F892D26115A4AD6D20BB965491846A0C1B5B7919DD9E718AEB9E + 3DA8D35BDDFDDA2FD59E065592A8625CABBB46CDABAB736F6FCAEFFC99F977FB + 32FED2BF1BFE140F889E05F859E1CD7FE21C5E2ED2EF34DD4F4CB1B67BB9EF21 + B98BC99D644F227DEB2823E6203ABFCC8E19981A7E16FDA8B54B287E2C7C34F8 + BBF0D547F69F8C2D3C5C9A7E91A6C96571A16BF68AD1C68B66F828A44D73BD48 + 24999C9427614ECBE05EA163E1EF859E3FB09FC2BF10756F09CBACA453F8CFC3 + 965791ADA5C8484A959A00668C46C30B24F0B43224EC190336DAFADFC17F107F + 6976FDAA34BF84FA17C79F106B5178ABC23A7788BC25AD5D6A525AEA56424852 + D6CF4ED426B3689196196192D5A4540766255DA1BCB1BE2AA5AA464BF2BF4BD9 + FE87D0CA8C5BAB6A6BA3BB934DD9AD568D2B5FC9F7BDF4FD1EF863FB46FC46F8 + 95A4FC06F0F5CFC33F187C32F87A7C59E148ADADBC470186F6E2DE3D42D63498 + 443FD5A168381260B05CA80006357F6C2F8F1AF7C1AFDA9FE1D78974FF00D9EB + E3BFC6BF075AE850DE5BDEF852CBED68025BDC5A5C44C16261034770D1310ED8 + 6431B8E5805B3E15FDA73F6C3F095DFECFBF017F693F85FF000E7489F5AD4FC3 + F6E35EB6F19B6B97BA9C51EB56A8F24CB126C173BA45DD2C92B336C0555B2587 + D71E1EF8C12789FE31F8BFE1B4171756FA6E87777A134A8E5F2ED67BE8428592 + 7D843B96326E2C4907EEFCB915E4CB99ABC1DB73E5A8D1A747136A9053BBF76D + 2D3D6E8FCEEFDA7F57F883FB4FF87BF673F10E91F096EBE1D7C569FC33E23F17 + 69BA078AE78EC6FA68ECD018F489C958479974B69E6C2CC431678A30A0C95F46 + FEC3DE3FFDBEADBC39E10F83DF127F64ED0FE06FC17D36D26967F136BBAACF2E + A77C0F9CD0AD959890E599E50BE610238A3DEC4972AADC27ED8FF0FF00C697DE + 07F08EADF17EEB47D53C61A178CAE34E835D8F498AD23BED26EEC7ED5025C5BC + 19851A3BA8618F78552C18338DC58B7D8BF05F59F87DE14F84DFF04FEF02F8F7 + 48F891FF0009878E344D622F0ECFA0EBB77A758696F69737055F5316F730ACAB + 222430C41E2B852772ED8D739E75271873F5FBB7FEBF33E8F1105384A8538AE5 + B596F2B35D9DD2B6CD69F2678C7ED63F0EFC4BE23FD9BBC697FF0000AFFC01F1 + 63C6127882DEF24B0D4B54B4F22FF6CC527B323ED11209D526F382CA46E10CBB + B048A6FECCF07EDA5E30F807E2CF84DFB425CFC2AFD9A742B8F07C9E1CF001F0 + 9DEAEA3A9B5F4D0342355B811DCDD462D5005C44A43BC8495D8114D62FC25F89 + 23C75E25F8D7ACDEE8D7FE1FF0AF8D3E2CE91E1291DC63FB2EF2EB4BBC8ACA59 + 39085E4BBB5862393FEB2E8819049AF4AD7753F8B5AF7C4EF84FE3AF82573F0E + 7FE1178747D5F4EB9F09EADAE8D2B51BDB44B97B3824D3AE1D1E1596D9608834 + 72EC0E0B856423822D4DDE3A5FFC91E5E25D68D08D19349E9EF5AEF7F9AD9DB6 + FF0033E7CFD957F647FDABBE127ECF3F123F67AF8F3F14F43F879E16D434BBED + 2BC190F85A69350BBF0FC93B3892F16EDB606B70CCD2C3687730F3E526480909 + 5D87C0BF01F83FF6009BC39E21F88FF1CBF693FDA2F5ABEB492C748B4BDBB857 + 4BF0B5A24F134925BE9525D36EB9725479BB98C71F98130F264FD2D1785ACFC0 + F349A743E0AF06782353BBBC4D6351B5F0F98648A7BD9621BDAE0C1147189815 + 52DE5AB6719DCC18357CF9FB5AEABA1DE5F7ECFF00E0C716D36BBAD5DDFAE936 + 65D8DC6A456EEDBCE5B6894179A48D0090AA8E1465801863D51A3C96937B799E + 366398D5AEFD8415E351A4D24AED75D747EAEFF99D8783344F807FB1F69DE31F + 07787BC4DF11BE22EBFAD78B5B55B4FF00848E346BFD23449248EDE4B3B19E41 + FE9D65661832B2C8030691701A4515C27C5DF81BFB26FED4BAC78C3C57F18FE1 + 2F88BC59E35F075C2F86607D23C41269975ACE9F6EE256DAD01D84A7DA6E1C45 + 2A17F95D5240190533F69736173F1AFF00661F015CDB78DB52F19F8A2D750BDF + 0D45E534EB752464BDE59DBC83F771B476D1C7388B78671E584CB1453E1163E3 + 5F8A9E2FF1BF8075BF85DF08BE30DD68BE23D7B5AF1A68DAB4B630D9699E26D1 + EDAC2E6DA6D34CA2532E9DA84D20FF00465BD8E1CCBF66760A8F91CDCD14B53D + 4C361FDACFDADF965DEED6D75D1AD3DD7E4ED2ECCF70F1CFC25FD90FF68CF85D + F093C17A0FECF365E30F86FE06BED4BC2DA359D9789DB4BFF845ECE0BA686FA2 + 92732C5F6987CD884D3C45A49DF72CA14C8CF9D9FDA1F54D27E1F78F3C2FA778 + 5BE12FC1DD5A0F13E89A1E8BE20875CF0B5BEAD6FAED869B7D143A7D932CDFEA + 85AE23F21A2DA408D436E11C6A3C5FF66ED47E2EFC44F1BF8DADFE237EC26BFB + 38A69C67D43FE137BCB2FECDBBBC990B456BE7C2A2117D7ED1491ABCC5A68B10 + 9772C1806F5DFDADBE147C79F18F8F7E05C9FB3EF8A3F66C88C36462BDD2FE22 + F8816C4C52C570B71692411A9F3A612219D248E3539F255B80015DD4232839B5 + F81C75EAD4A3898E169CED1D5EB2BAD7A5EED6AEEDF9EBD99ECFA57C75F11689 + F1C9FC39A6F857E1569DE1CD5E2BED6FC4573E1FB08EEE6F15456D0B416AF3CF + F648A66BAB65B19ADCAA3CCAB931AB9F2801816573F1CB5FF1A7C5CF016832F8 + 33C59AA787741F0D78A6C2D753B006CC5C45A85CB34B0B5BEC912E2665D36453 + B9A28DE20FE5056615C6F8A3E0AFC64F8A3E36D3347F88BFB6BFC31D13C7B2D8 + DA68B67A2E8DA5DCDE43750C76D00F13589BF31B4F6E59DA03653C12C12C114E + CCE8189993CDFE11FC3DF11787FE37788BC65FF0DF7E28F1CF87627F0EDDCFE1 + 27F05BDB491F8596774B58750BE313493CD0D9C7770315114934EB99E401C124 + AABBA5CA4D0C02709C9CEEF97B3EFDED6D36BEC7D19F01B445D0BF6FBF899AF2 + 4F14BA2CFA35FCE6E7CAF31DE26BCB7D88EC99F3369F9707760EE000CE2BC37C + 4BA87C33D37C4FACD95C6ABAE6937F16A1725A1B40CE7779AF9756DDB7E6EBEB + CF4AEFBF669F861F0575EFDA87F697F8B0BE12F8EFE1AF8A562FA958EA7A337C + 4182F3C3F6EB7D14B6F733DB583DADBAC6DFBA79551E4956396E328A36214E43 + 58F14689A7788B59D0AE7C3DE0FF000EF8774ED467B24BB79D2283516476443B + 9D382FB73B7AE4E3AD7EDFE0BE32961FEB356BCD476DFB2BEB7D8F90E2CCBE58 + AAF0A7874E72B25F3B76FD4B49E25F87F16E91EEB58959584DE79B32E6541D8B + 9CEEC1AB27E2C7C10725DEE6F2473C9636370371F5E95D7DDFC44B1B1F0DE9FA + 859E81E12D734C8A16DB1C77B0C62D877277004E6B824F8C7E159D1268BC1FE1 + C11380CB9BB8B383C8AFDA6A7166060D3A95A31BED79257FBEC7CF438471EF48 + 5193B764CFD00B4F8D9278827F3B4786386D78DB36F9019FF02302ACC7F133C4 + 526A11CEBE1BD41ED5668C896391891F30F98E48000FE95F2C687FF092F88E59 + 26D57E145DE8C15F6ABFF6AAB9E0F5DA0E057A0597867569C5CBC9A6CB69B949 + 21F5176053DD46067B7D2BA2A6128C5688F16352A4B43F9E0B11E27B0F8A167E + 03F183685188FC49A0C5670F88D255B6B9B4BFD1358D3D62BB865DB2F970B4C6 + D1FCA384081970C40AE9BC2BF16FC59A1FC33B9D5BC1DE26BCF0EE8CBF05F41F + 116896D6F7935C3E9DF6FF001447657B14AF233799308D1E332F2EC8E859838E + 3E94FF0082827ECE3E19F8EFF17BE0BE9DE21B3F169B98FC3D716735DE91736D + 25C69B149A995174F6B3EE6B8B58DD944AD16E30ACAAE53692C3F383C21FB0C4 + 7E23D4DBC13FB3D7ED13E21B7F1178C6C6F7FB2ACF5BF0FCFA669FE2DD261BD6 + 8CDBFDBED24712B2DCD8FCC8D0ED578E362137293FC8DC4996CF078EAB86BF34 + 62DBBDBA28DBD74BDFE47EF39257C16230909CBDC9592B59B5F137E6B5B3DF6B + EFB5FF006335187C37E30FF82887C18F0A4BE08D46F3565F87B7BA7DB78D66D4 + 22BDD3F548CF957126971AB42EBE7DA3CB148EFE71644B8286240EACDF0F597F + C335DC69DFB5EEA5A7FECF7A7F88341F15FC51B0F0BC5A6F897C3367A35E6812 + 5CC124D2A40D6E64961B68DB4E7688C325BC845D6FC26D21FE55D37E117EDC53 + 78313C4BA5FC66F03F88757F0FEAE74DD4FC357BE30B196EBC3F2DF9B68C4D34 + B7718B59566105A6EF2A77915111F1B58B5757E4FF00C144EDB769177F04ECBE + 2FDCDCF8B3C33ABC5A8E8EB67AB21BBD22016B636826D3AEDE316F242150798A + 2490212ADF2B01E0DA10FF0086EED4BBF9D8EFC3E0A76BC6AC764B49BFB2F57F + 759DD3EF6DCFA2FE29FEC9FF00B12F8A7C27F1123F853F0E7C47E07F14EAFAAE + 85A2F8045A78A350D41E769ADADAF67923B79E592262D12DD44C6524447202BB + 84CFCA9A7FEC69E0BF8FDFB32EA1F1A3F659F86BFB46C5E38D1666B5BAD33514 + B6BEB0F12B09504B159F99E4DC25C45134EE5605B98D9A35887CEE31E7BA87C7 + 0FDA17E02F867E0EEA5E3DF807E2AF00DBE8DE33FEDCD175DD5ECAF6CE2D47EC + D1DCC0DA703347E533C29346BB8BEEC5AA6F5218B57D1FA0FF00C1403C4FA2F8 + 6BC73F133C1DE16F88BA768D75AAB6A7A9F88F5ED6A06F3EEA6BB9278ECECE27 + 8DE49B64B2CA88EB2AAC519412312AACDC9566D5DC5F6FC97FC1FF00863DFA50 + AF469D38397326EDCCDDD7C4D6CDDDDD5ACAFA5DA567767E7EFC35F81579E2AF + 0EEA9E3CF172EBBE18F84BA45AC9A8EA5A85BD91B8BAB9B7465128B581800C17 + 761E671B1791891B295FA7FF001F3F62CF817A27C33F825A7FC03FDA17C21E10 + D1B57D19B56D5B4FF11DBBAB5D412362CEEAE5AC2196440F7105DC0166574678 + 59D1DFCB54AF99FE0A7ED7F6DE2BF187C7C5F8F77F20F0D78FFC11AE78595E16 + 021D265BD8A60B3EE6DA1984B24131772BE6184A864CA01EC1E00F88FA57C52D + 77C4BF0FFE146B5F0EBC6B73A37C20D3FC35069FE259AD62D3BC592C579A9EA1 + 35807BD1E4EEC4E8124C61278E3DAE386AF4EA25151A92D3FE026DF7ECBA1E3E + 32B63A55A508DD72BD97C2D3E55BBDDA6DF55B2DBAF803FEC95FB69FC2AB9F0E + DC7852E343B5D03C416175AB693AD691E3CD320D3B5382393C99190DECD6ECB2 + 640528F1AC8718C65582C7F043E0B7EDE5E01FDA23C39E34F077C02F8A5E3AF8 + B505AE9DAAC336A9A7BEA563258348AF6B34F791CE2D92D9CDAED4633AA94560 + B8C835E89FB31F8EB53FDA6ADFC4F2F887C29E12FEC7D1AEBC35A5DAE8E9E291 + E1D9ADF458AE66965FB0EA9717106CB85FB55CB15DEB98DE50AADB315F567C05 + F1DFC6CF85DE34F8E1A5EB3E37F88DE1DBB1A9DC782BC3335E6B505EDDE95A26 + A3A0BDEE92B6F73166095FC986CEE56441FBC74C9F99F229CDCDC66F5DED7FB9 + 76D5FEA15F175A92AB4E4A3CE92BAF5B6FAB6D2BEBA5B4D2E7D6F1697FB4D78B + 3E207ECDDE2BFDA1FC05A2E8BE21D0FC67A2A25CF87749B8B7D2EC92E755B162 + 8669A69FED04B46A04AA51492A0295009E3FF6AEF853FB47F80FF6B1B6FDACBF + 658F01F88BE25DC2ECB6F16F85ECE5DC2F2668BECA2E9A1DEAC2DAE6DFC889E7 + 89B7C3716A921E1C1AFBB8493DBFC02FD94FC98A4BCB17D77E1E442D62F31847 + BB59B22001C90BF3818EBC839F5F44F8B6B1F87BC4B0E8DACE94A756B19BCBD4 + 6CD27DB1DE44FB2658A76438272C8C476DC08C96047859B5670519474B5FE674 + F03603DAE26A439799DDA5656B5B5BF6D6D65AE8DA67827C7ED2BE30FC7CF87B + A3F807595B6F833F1675CD21F5F11FF6C26AD1689A9DB2192186EAE62B689265 + 59E5843B471019590E64E0B51F84BE07F8A9F1AFC61FB28F8EEDBE3DE9DF11EC + BE0E7872EFC3BA9785FC29B6DEC24D5654933728144125AA47299E440519730A + F9650EF6AF6BB5F11AF8DFE2768D145A79B7BAB7F01F882EE494A34CA67596D1 + 5220C1805C995082E324E7835CCFEC35A9780B46F841FF00052DBAF1DFC16F18 + 7ED2D79AD6B9E1B6F0BF847498ED61D475CB8935ABE96187ED176A61B684BBDB + CD2CD20D890C6E76BE029D55353A51BCB46BE57E692B7E3632A988AD4B12E8B8 + A84B56D2B6968C766EE92EAFB2D7A5CF8C749FF827B7C00D465F889F05BE317C + 42FDA46EFC5D61A6DD788AFAE3C55E2DBFD36D9ECE6B858E0D46DE5124965388 + 180845C32E58B48D24659936E678D7F617FD873F686F8E1A7DA5AF8A3E26CDE2 + CB9F0DDADFFF00C25DE07F1469B7DA3EB9F6186DEC3CB951AD58DBDE6D8E0696 + 685DD4921DB6C8ED5F6A5A7C73F8147F689FDA474AF13F8ABE0CFEC5361F0CBE + 1D5A786B4CD3EE7C6165A8CD0DDAEB304B7ED1C77DF628EE66C4AE62B686345F + 22289D439949AF9FFC61F1FBF644F81DFB7778A6EF5FF89DA1F8675C3A6FD9EF + 349BAB079273A95CA5B9114DF6585A3669408245D8AD1B79BD40C1393A108B49 + F62D63730AB152A776AFD12DB5ED15A6DFAA5A1F42FC2AF88DF0FBC17A86A1FB + 3FE85F0E63F0AF867C0F6BA85B69B3DD6B7717D766482489965BB13C63CD171F + 6892533AB1CBACAA57E5207B8DFEB3E1AD5E5F85FE25F10FC37D3FC490692973 + AE699ADAC503A786276B6C79904934CB289A789844CF0C4EA864895CAEE057E0 + CF88DE37F00F887E357EDAFA07C20F0FFC41D77C65E07F04DFAEB5A549A0BC77 + ADADDCC2EEB0DA405CB5C197ECED22B421A375C3A160C0364FECD9FB5A7C69F1 + 3FEC637DACF867F64CF8A1F10FE23F87574ED01E39D1349B0F12BEDFB2F9D64F + 71BA599218BCB7B84F25BCA76043B0C888AB888D928BD16F6D8F1B0BC3F567CF + 52B452A92D139F54DDAEB5577FCBE57D4FB3FC7DADF89D3E189D7ACE4BC7F13B + 432A6957B6FA75B3B68F3265E79F12AEF50F98ACBE5C93BD81042AD793F837E3 + E78BBC5DE0FD02DFC5FE2CB27F1CB8B8D74CA238A27BFD36DEEBECF343346A9E + 5CA365D431A3A8592395606C8DEE0F80FC4EF863F11FE3E7C74F84DF157E157C + 4BF86EDA6F81FC19A8E9DA7D847E2159AC6C7C4B04D2BDB7DBED206F36E6CB50 + 925960B872BE6C6159D4A6D0AF8F2FC10F13A789AFEEB5DFDAAFE1BF817C45E1 + 9F0CFD8B4D96CBC3416E7C23E22D5E5B7B9BB8C5B4CA2DF57D2E782DA48A0DEF + E7A929280B2C019AA55F9B5B1185C9F0D4E504E49E9AE97D6EBAA4FADEEDDB4B + 26B4D7EADF879E22F88BE24D03C2FF00F0B2FC13F1DBE1478AF4E880D77419EC + 67B4B1598864713DCC9693DA5E4331D93C72DBDD28612226F62FB0FCD9FB657C + 4EB3F82DFB52FECDDFF099477BA4F86F545B2BA83510CA2DAD4DBDF341389B38 + 3B145CDBCA4FCC116466F94336E97F654D7EEFF671F0A78993E347C41F8C3FB4 + C78AEC7C59A5786045AA0B14B7F0EBCF197827B3769A66BC674C48D2CD286445 + 0B1C60EE27E9AF8E03F670FDA33C59F0FF00E15FC7AFD9E3C45E38D2B4CBEB9D + 4EC2E359BB974FFB25B1B5044F6E2108D756D7223D8C8252A7CA4DEB94C27742 + 6FD9DBA9F3F89C27263355784535A76B766FA3EF6BFAEAFC2BF685F1EF87BC13 + F10FC2F2FC3DF1C9BAF1859F87755B6B2B95D32E6FECEC759D5AD2C6C740B6D4 + AEA0492288DE4D6452379DE30D11775CA206A4F82BF1227F13FC4CD43E2FFC2F + 3E21F05685E22D5FC13F0FB50802C9692D85C26A1F67D6B4CF31195835BBDC34 + 4F26DDB2160E86456E3EA6D2FE26F8C23F19F893C11E18F841F0D4B58782E0D7 + 346B736F1D8BA25ADECF6696C2E2284A9862B6B7125BAB43F265506D0491CF68 + DF100C9E32F1FF00C35F11DC0F8711D8DFE8BE2BD123D47C345ACF519EE618AF + 1AE6CD71143717B05E1B88A599645996548CB677B13855A726F9AFD7F43D8C36 + 3234E93A518FD8BDEFE7E8EFADBAE9AFA9E1BFB3AFC3FF008A1777FE34F17F8B + FC19E32F03A5CF8B5FC4D7BAB6B50B2DBDBCFE1FD4E759AC6F6546062FB77DB1 + 5AD670258A58E294953B156BE8BF0278E75BF84E9A5784344D3BE057C4AF0BDD + 5FA5DDE69FA9786A2D547EEC966916691C796C08C67E6E7B0AF67F8E5ACDADA7 + C02FDA2B5AB191534F8F44749A39D079B13620DC48270A8DB87CA0F073D3EE8F + C68FD996FF00FE1727C47B7F18EB47C4F0FC12D3AFCDAAB5938FF89E31CEF789 + 87CC1636F948C73CD79D9967CB014254E34A33949349CB9AE93BAD1276E97D7A + FA1FA4787794AC6CE788729412946F156B3B453D6EAFD5EDD0FDAFD66D3E0FDC + 7856CE27F86FE1882E2FE498CA2CB4E1244892EE90A80338C3310B81C57CBA3E + 03FC1840120F873A524206115A4BB042F6046CE0D7D27F0BDECFC3F25CAE8F15 + BC5E12E63B1690B99D941E3CD560416F706BE854D52D5D11BFD07900FF000FF5 + E6BF24A946A567CD55A67F40C55382E58A3F0FEDBF68AD775B8E0BCD256E2F74 + C48394B991ADDC37F78263A7A1AD493E2378E350B5D3EF23BB9347D3F072CD76 + E558E3B8CF27EA07D2B94B696E3538634D6ACE2D3EDF710DBEECA161D7692179 + FA55981FE1E595E5CDCE97E1ED535EBA5091986099D6284E797DDD2BFD589578 + 356B7E163FCC88D16B67FA9F9CDFB64FC6A1E14F1BF856CB54D27FE16078A346 + 4B5F155C4D612CA2EFC2D25B5CC5736978D204D90C532CF2C4F924346F82518A + 1AF96F47FDAC7C05ADF843C4B61E21BFF1CE83E36D47C0DE2D8C1D3E499EDE2F + 13DD5E5CCF613DB88E4CAAB4178D6F2CDB540091EE0719AFBF3E38FC58F85BA3 + 7C71D52CB5FF0009DDB43AA7C3ED67C277BA7A4E42F8B62366D7FF00D9D7172B + 8681F12C06376DDB49CA85216BCC35AF875AC7C3DF037C25F074DFB2E7C2DF88 + 1FB2D78FC7826F3C39E2DFEC6596E341B9967845D2C92C40CB7137DA03DB62E1 + D2398CBE5B2CA58AD7F23F1E5575735C4723566F9747D5AB34F7D524BB6DA687 + EE9C2EF0F4F054A1560EF6E6D5A5B3E97B27BBB25BD9DDDD3382F8B7F16BE026 + ABF097E2FF00C45D2BC4BA7697A9F8E3E17F8734B5D0EDA4F26F6DBC51A40D88 + E1633B94A18AC9F7617889C746E7D3ACE0F1A781BE3CFEC51E21F865E327D6FC + 49E2AF04DC78863D11B5282F6CBFE120B4596DADA6F2CEF5492482542C24DCBB + E594900330AD393F629F057ED0BF033C65A2FC1BF017ECD7A17C4E4BC8BC53A4 + 78CBC3BAE5C35BDEE9715D4B6F73A65DC0D11934FB9080CA6D9848B908A082B9 + 3F04FECCBF01B4DF1569E9F157C41F137C69F093414D405ADAEB1E13F0DB6AB7 + FA54A5846B7D76B15C5BC91DA8958AB4B19665C73B3CC40FF2717ED272717CB6 + B3F2D2FDEDD5FCAC8F7692C3AC3B8C9B77BAB349BF7A2A297BB7D92E9ABB3BD8 + FB65FE3478BFC47F0FFE17EADA2789BC7DA1F86F50F04EB9E2B9FEC76ADA9DDD + ADF36B50C4D7977128335E2A43701658C372AEEC3691B85DD3FF00685F8B12AF + 8E7C333FC6678EEF41F19C1E0DD0A49BC3D7B1E9BE24D3E38097F3ADAE5DA7B7 + BC9A3F32E216B859436258980508478A0FD90BE34E8FF1AD7E04FC37FDAF3C2C + D79A5C13DB7C3D6D66D353D260F105849F66BC90456D34329B05792480949432 + BB2021B6B213E29F1027FDB73C17E08B4F147C48F09697AD693ABF88343B44BA + B28ED6FEE2DEFB476FB2D9C0EB61262247DCD165D7F7DC6D60D8AE6535192937 + BFEB2BFE57D3F3D0F6D65D4AABE585AF656EFA592DE377A2B6EF5D3467E8DF88 + 340FD8BBC6DAB7ED0B717FFB2F7C354F889670E85E1DD1E2B1B1BCD1AD6D35C8 + 6D6DA5D5A6BAB68678E25914DDCA8638E24598C49CA32977F23F883FB1E7EC27 + A57ED5DE13F0A5DFFC2E73F047C5BAA5DF8634D8F4DD4A310E8BAC592C71EA09 + 0DEDDC53CD72B1C922B0126158891431511B37CFBF1AFE347C76B7BFF1FF008E + FF00698FD95BC75F0FFC57E2FF00891A1FC4DB3D5DB49BDD3AC6DDACA1682EE2 + B67BB493CC1731E09944F80F92548C6DF49D33F6D0FD9F7C7DA40B6F17596B5E + 1C87C3FF0018F59F88BE1890A19AEA5D2EFF00CF47B4905B89636942CB0336D6 + 1B1EDC1CC88F95F4284A33B26969BFA69FA37BF647CC4F078DA11E784A7256B6 + 8EFF0066CADABFB496A9269735DD8E6B48FF00827FE85E0FFDA3EFBF67BF1E7E + D47A7F87F56BED7751D03C19E25F0BE96D796DA9CF6CF1207BD2B347E53ABDC2 + 433DB44EF2C12799CB2A565F86BF617FDB6357F1FDE7807C3BF18BE16F89FC52 + 9E21B7456B7F8AAAD0DDDE580F2ED2F227994ACE2350C90EDDD222C6E9B176ED + AF49F867F1EBE1CFC62F057ECFBE31F88DE3AB4F037C4EF017C4FF001178A354 + BCD46EA08E7BBB0D51A3949DD94DD2249696F2E554AC85A651B0AED6DDF036AD + 73ACF823F61EF8E1F0D75EF0EE99E3EF0FEAFE279FC4B6B14C96D3DAD8DC5D41 + 7FA7B3C7F7248C5D8BB511EE262382C154ABD690A7CCA377D3F3B6AFEF7DB62E + 798E269CA4AA35BF2BBC74BFBED356E5F89463D5EB25B6C7E8CF86BE1D7ED8BF + B3BA7C1DF09FED19F163C43E3FF3B5FF000FCBA75BE9D3C0BA2D9C56BA85A848 + E1315BDBCD3CB1A90E5E60A4318F6A104C8DF60F8CFC636173E38F88FE2DD56C + CDDE9B6734B72E11465618A474DD27037FEEE3542464E3900EDC5725FB507ED6 + 7E15F8F9A2FC37B9D0B54D1EF5ECBE205ACD0AE9C5DA1B00B728B3C0B233B3ED + 569D71B9890138E981B20C7178FF005FB0BCD32EA192E2EAFED5D229764A923B + B08F12672A55D632197919E0E7047CEE7B38A54DADAFFE47AFC04EAD5A78B849 + A551A76695BB5F4DD2D1799E35E03FDB0FF644F14F8F7C2BE38D33E2F6A5A378 + 934559ECADA3D275AD1EEE0BEB39840F2413D9CB709E644C02282A415646E32A + B8FD08FD967F67FF0085D7763F15BE317ECFDAAF88BC41A2EADE2BB7B9BCD2B5 + FD66E20D3F43D476C970B6BA642276105A38BC925D8AF2C237E17614C27F28BF + F0501FD91F4BF0EFC4397E27FC28D2F5AF1B378AAE5EEEF3C391696649ED2FDA + 09669AE9042A7F7329B69A565D8A2390C8012BB547F425FF0006E2DF41A87EC4 + FF0013EEF5D8ACF50D3F47F143F9764CC562F2922BD905B9CA92A09523382407 + 3C718315314952535D34DDE9AEBF89F4D9270FE17136972B69AEB7D576D7FE1B + B17AF3F64CF841F147C57E27F8E5E2CFD9E3E0678A7C53AC6A1A80D4EF75A86D + 2FB528AEECAEDED66DF6AF1B24677DB6C8CE4078BCA2A48615D4E9DF09BC05E2 + 6D6AC7C61E2DF877E0AD56F9045B354B8F0FD94D7EB14454C510B89636955429 + 554C15DA7A633CFD55FB31CFE17D4FE107ED31AD6A8C6FA083C6FE30BFD3A48E + 62119CDD5CCCB2C69F28DC93B05553C9450C08008AF23D17C536BACC178ADA82 + BCC21042B02923960332FCF92082C093CF25474CE71861E32B4DDBDEFEB53838 + 9F39AF87E6A3878B8AA764DF45A2B5BB5AED16B57B2B3D160B0D4F49D3ED22BB + 86F973710B6E960662CBBD9C7CD2FCA02ED7C8F980E06457AAF8A27D67C4F369 + C9A8EAB7E6F5E5B76696494CC66880388C96C9009C0EB90578E739F25F10F887 + C2FE18D120D6BC61AB5B7877C1D0470C5777CF04D707CC2E234DF1C4AD9DC582 + EF38507AE3005769AC78FF00C0779F0FBC3BE35D13C4967E24B04D1A5BE86EA2 + BEB659B50B54264F35036C42CA5186D2000DEE715EA2953845ADBFAFEBA1F975 + 58E2F1334E379B4EEDEB2695EFAEF6D7BBD6F7EA7E5C7C15D2ED5BE307C5B1A9 + F87F45F11E8F2C7726EA1D5AC4DC5BDEC11DDDD4C77A91F332AAB0507F8D55F1 + C135CFFC0EF1FF008C3C2D25FB7C06F16DAF88B5EF14F8B2C747D2FF00B3B505 + BCB9D6B4987CF975286D0F98AED2430C481A419F2CC64E394DDF4A7C34D2FC11 + F0834AF1F7C54F831E1AF1FEBADE27D767F1BC377ACDACB1DB68EF7AA93AE916 + F7E903A5AA07899D2DD9A528F2B92A1581AE1B50F891E13F869F003E1DFC41F8 + 41F04749F0DE97A65BEA1E22F0E1BDB4B7BEB4F0F5FEA4E64BC82390335C42D7 + 064903BC0D1AB2B228C228884D29CA5A9BD5C33A4B962AEE29EF64B54EFBB6DB + 575A5BF43E6FBFF1968C7E1ADDF8D741D0BE317C65D1BC5DF176D6EB46BBF027 + 852EF549AF20D15E6B7BD78A22144691E62551318DA4C931EF0AE57E8DF89B63 + F163C6DA41F157C3EFD90755D1B5DB0F87CBE7586B1E2C3A45FF008913598DD6 + 48C4976B384D474E9AEAEDE78A796108A638EDC945816BEE4F851E31F10F8963 + 96443E1AB2F0E410C4F359E8ED31B8B6B8963599C5CA79691459F30BAA29766D + EAEDB4B8CE2FED4FE24D33C37F05F5E9B50F1F781BE116AF77A8693616FADEB7 + 2882D7CE170F726DCB178C6E921B7955541C9603838AEC749A8C657DFCBB1E25 + 4CDE5ED9D154EF2BF76F7D35B72B7A6FEB74EFB7CDBE1BD17F685F851F16DFC6 + 7F143C71FB35F873E00E83A15BF846F3C6726A37977AD78BED959CADDADA43BA + D34C96E0C8826170EE90012ECF377462B81F879F0FFF006C3F847F1074FF001E + F8F3F6F997E257823C5DE2EB38A5D26DFC23359E9B7125FC8B0C38BA8C4E964A + E8914314318589D8A0F341E4B2DAD2FEEFF671F111F881E3EF87B7D611F86758 + B3B2F1BF833C74627D5C5CDBCE904434FDAB2335D1B94B79EC6469F7C87E424A + A95D2D5BC7F6DE14F18FEC59F026FE1F0D787BC4DAE7FC20FAC4971269456FB5 + 4B0D36EEDAE2E616BB58FE55826B25664DD95555FBBBB9E6AF1F7756F6BFE9FA + 9EDE0EBBA73B4629EAD35656692BB7B36BCECFCBA1F4B7C19F10F803F699F87F + F1EBE0F78A3E1CF8F2F74F9631A078963B5F1043BAEADAE16506E2DEE2310B40 + AA6CD64DA72DB8A282C19ABE20FD92BE08C9F02FE16C1F07B4FBCB0D575CD1B5 + 5D4ACAEB50C4889A9BC575227DAA38CE4C6B22A870849DB9C678AEEFE1AF83BE + 372787BE2B7C50F871F0E7C6CC747F1A3FC41834F7BF87481AF5A786EF750F37 + 479EE24953C917F05E49796ECD1CB0C90DA12C37BC21BF27DBF6D7F115E59F86 + 75DF0269FACE84F730078AE6F751DF6F72CF1E51416EBC1E7241CF500D7C6F16 + C252A34E9D04B56F5BA4BF1B1FB0F85CE50C4626AE21D97BBEEEED3B7CFA5974 + FC0FDF4D3EE7C6BA1DBC9616BA8C76913E646C2E07B9E3919F6AA326A3AC33BB + 35D4FB8924E1C819AFC31F097EDC9FB46C57C97575E1F975A08D25B6E5898217 + 0373329CE1B03DEBAC3FB5E7ED2D704DC1D065264F9F88D40E79E9DBE95F9FD6 + CBF130769CA2BE69FE4CFDA69E61879AF753FB99EE3E37F14DBE92123F11F8A2 + 1BF9D944BE6CB71F2479F454FC6B82D2FC61E1486DAE52D3E256BD2DD82AD1DB + D8212AC49C1CB75DBD6BF4AFE23FC37F81D6165A3DCFC46F80D3CB7AC7FE269A + 80D3BC88C63D36FDE3D0F3EF5E1E9A0FC28BDB98F46F84BE1ABDB3DD214330D3 + 408EDD4F00963E95FEA0E16B54ABABB25E577FE47F9D55E853A2ED1F7BD6CBF0 + 3F217FE0A0BF0EEEB46F873F01FE215B6A17977A46A7AFEAF6D6D712DCB492AC + C9696EED9C8DCBC7F5FA57C29E1BF8C3F1B74BD23C2DE05F0A7C44F1847E1EB0 + D4ACAEF4CD222995ADDAE62B98E6B646438F32359E28245899BCB0E88F8CA823 + F6BBF6D4F85DA345A07C37F0BF88F555F1FEB91EB72EB10698CE0CD6713DBBC2 + 24FB244C18C123C2C9BDD423344E0162840FC71F154BE10D03C7924BA14BAC36 + BB0EB16F757770674105948265731A2F960871C12D90B1E08C3630BF80719D25 + 2CD6AC5BB5DAFF00D2627EA1C399A53787A78750BF2A6F5575BBD55FD7FC8FD7 + 1D13E2FF00FC1537E1BFC23F1BF89B53F83BF093C6BA595B9BAB9BF92E2DF51D + 5AD6392D98CF38B4B2D48930C48B24ECCC870ECEC55B2D8FCD8F847FB44F823C + 23A548DAB7893E28E85F12D35A3ADC5ADE8B7B6F756D7E7119F225D3640A6DE4 + 0B1B62E2D9E19177F25C2A22FE8E5D78A752F871278A6F7C3571A3F87FC217DF + B4058783FC42349D4EE1AC94C8B717AB25AC6DBD21B5B858D3CC815D52379582 + 02AC71E85FB4D7C47F07DBEBDFB5BD97C76F857F0CA1D12FBE2B597C201AE5FE + 9104D73A7E976F6375731EA8B733E2469E716E11648E78224F32360536E4FC15 + 2AFCB294B4D6DDD7F2FF00F24BA6A7551B4D2A72A564FF0096C9E8DAB5BDE4ED + 6BDAFD7D0F8DBC0BFB45FC17F17AFC31F8C7E27D6E2F87BE35F057C44F187886 + F2C2FA58CB6A5A5EAA16E91410773CE66858155560C6661B86D6AF44B7F12F8B + B50FF827DFC0AD0FE12DFF00862FA28A5D2B50F897A7CD062EB49D162BED39EC + E5B476DA8F99FCB3208F7BAA0070A16423C73E29FC23F813A25AFC25D0BC6BFB + 38E91E19BEF165E5CD85978EBE1FF89EF6DEC6E6EA3291A5AC96138962B191E3 + 952E5D6488865F2CA975DF21E2BE197EC83F05FE30FC60F0AFC09F855FB52F8D + BE1D7C56D46E752B6D4744D7FC3F24834BB8B4B84586DE79A06B4CCAF24723FC + D190B88DB8CEE1E6351BA8DBAFE2B7BADFAFE27DB294793DB464D41252BB5CCB + 975D34BFF9E8B4B23F467C79A37C5683F6E5D37E13FC37F8A9A8F82A6F127C0D + D0359D2926BE96D34DD3F5382C9EDA259CC0E1BEC92359B1914600FB448D8DCB + 93E21E0FF1B7C1FF008E3FB0AFC77FDA0FE2C7ECF1F09AEFC69E24D5347F0369 + F73A2786EC2DEF746D52E0DC5BDA5E0BEF284C8E04092CB3066791979077135F + 307C5C5FDA37F672F149FDA46EFF006D7F047C50F1A68B2BF827C2D7A86EB53D + 435AD122B8920B77892E2CA4B18ED1E337170A8F339DAAD8666209F05F81DFB4 + F789FE0E7C2AF197C16B7F0D699E2CF875AD5F59EA8FA6DECE57ECD796B289AD + E68D8C7261E39159D5C05652F28CBAC8C95E8D26A726BAEBBEB6D6EBA5F6EC7C + 8FF6449D0854A2D49A70B38FBB7E5BF32BFBBFDD6AFD9EB73EEFF8EDFB3B7EC5 + 1E15D63E27EB765F057E2AF837E1BE8BE2DD07C01A8DDE97E389A69744D52E74 + A8AEC5DC31DC4532ADBDC319A32B309F63A291B564C47CE4FF00B05FEC9BF0CB + E2B6A707C46FDA2FC7BE3CF8436516997F7F169DE11874EBCB07BF8A39ECACB5 + 2BFB9B85B64678A68B335B8652CC1018E4385F1AD1FF006D0F0FEB7E05FDA5FC + 09F16BE19DE6A5A67C48F1669FE2A99F47BCE74692C4C3F658A03238660BE408 + DCB03BD18F284E47B37C13FDAC3E1DEBBE32F1AF8A7C53E3BBBF83DA84BAB787 + 534E8752D321D561D4F4AB0D3E1B696DAFA06BAB6864595E0DE019B08C141570 + 72344B5565FD799B4238C8516A5396965BDDBF86ED3B4A5D65B764FB9FAADE24 + FD9E3E1FF807E19F80FE257C36D72CEC7E1B49A8E890E9FA53F87469850CF731 + 3A8FDD49E5065DA031C36E0AD96F9558FD19AB634CF8937D15F4B1D996D4A2BD + 0BD310CB216123EE232A1195F71C0C1C81D09F27F88DAB7C19B6FD935347F859 + E29F869AAD85D789F49F1547A3F879F4F823D32D6E2EC4D2449656F23F931C41 + 8A631B7727DEF9B23CEFF6A0F15C3E1BF86FFB4578BA20B6DABDB784B589ADA5 + 8DC8CC82D658902E33860E50039CE463A600F07886F2A50F26767860E4B15554 + AFAF36FBECBEFDDEA5FF00F8266FED27F0DBE217C74FDACBF6C3F1978617C47F + 0B7E18F863C47A87842D5E18916EDB49B68EE6CA49830225B8BCD4351D3E550C + 0AA9B7B4046C85B381FF000478FDBCBF667FD9A7F63FF8CBF0CBE3EFC70F0BF8 + 13C4FAAEB852D92E0BCBAA4E8F78DE618A248DA57764BFBB90485464A052E992 + C3E32FF827B780BC44BFF04EDF8E71F86EFB488B59BBBBD52FB50B6B99BCB992 + C63BDD06CD03A637C713BC401765C7CE782702BE4AFDBA7F625F16FC05D2FC47 + E3D87C59F0F7C49A5EADAF496165A4F87AEA7BEBCB7F36CA79E67970802C31CD + 0C9106249657858E0B15AF633DC150861B0B421A5E0DC92EADC9DDFDD6FB91F6 + D9263654ABD64E3A295A3BE8928DBCF7BB3FA17F047ED61E12F061F8A7F06BC2 + 3E02F1CE8FE23B3F19F8B2D2E23D6604B3B7D38C7732AC30398E490C97216290 + F96A361C13E66D393F43FC2CD33C3BE09F81F69E24F1A6B1A25B7887C67E219F + 45F075BEA7ACA5BDCDF7D82169AF26B0B59326E4CB71731DBB6CFB8968E79F97 + 6FE78F88BC3FE3B8BC0FE16F8A9E06D23C01E27D6755F8B1E24B44FED5F13DBE + 93A6DE6CB59A76BA6BE6C8923856FDDCECDE5CAA4406596BA2F8EFA4F817E287 + C6CFD92FF684F89FE2CD0BE1E7C3FF00863A49F07E9365A7E957577A65E32F9D + 776F7B6F74B339B4B83753CF7734C59D6E4BA4654A4781E4623054F0738D38BE + 6728C5FA36AF6F55B1E267339E3DBC4629A8C2116BCF7B5EDAB69E9F7EF7D57D + 13FB4158DDDF7C167BBB079E492EAE2D234821793370AB70CAD0BC519065570C + D956DDCA676E791F34F88CF877C35FB057C36D53C5DA9786B4AD10DC689611CF + AA5AAA4905C5CC935D4616F305D31E53A042CA8CC4FDE72057BDFED4F75E04F1 + 7FC1CF1CFC32D4343D2FE2C78616D6DAFB58D26CBC411E9D7D636703A5C2EA11 + 246CD74863648F32ECCED90B02EACC0F79ABFC4BD17C5BF04ADAFE2F06FC33F0 + C7832FB4CD3751845CDB5BDFDAB5CC30A5DC4D2E9B73B92748258A2CC9E5C38F + 295D3E6C9A9AB4EF34E3D1DCF83C0566F0B5215A2E2E5CABA6C9F4DFDEB5D68A + CB477D4F84EEF54F8A56DA27C54B1D2B45F883E38F0A7807C19A0699A97843C3 + 96325E6A961E24BC8D088E2B35432CCF25B3C458A864891159F05B757A9F873C + 0DF1CBE217EC9FAE7843C29FB26EB5E06F1F05D37C3F643E2E47FF0008D5CCEA + B14E1EF54348EFF64B6F325468D5629673391B996202BD7F54F8B5F193C61F03 + 34DF8AB61AC788BFB567D3B4CD57577B186E00B1BB9B76D90DEF9DBA30D34520 + 5420617703F28DB5BDE0BF8AF75E238B4BD0B5BF17F881FE21E83E17B2BED4E1 + 9A6741AA5B5FDB01134A14E242B2D95C32B6DCA159941032A7A6952BFC6FFAFE + BC8C730C6CB5F6514DA4B7BBB2ED6F77AADF6D7ABD4F43F867F1335AF027C2CF + 07DC7C72F1278416E2C679748834AF05C97F7FA469C8E649618B7DC451DC4B29 + 8E392491D8052C0EC18C30E67E3A7C65FD9D7E27E85E16F815F14BC0B79F167E + 1AF8DAD2C750BD5B3BCFB04586BB0A8E0B6CB8578A758A50D11574253AABB0AF + 98BE307C76F85B61E31F107ECE1ABEB77FE1FD7F46D013C4FAB6AB7D0DB5BE87 + A5EA12AFDAD2CE7D4A470D1DF1B6817645F2C651665F9DC10999A1B7C2BF8996 + DFB35B781359D5FC79E23782E6FB4B6D0E1FB769FAC69BA537DAB535B4B845F2 + FED7070822F315E69248E28D5D9F23BA4D3B417A1E07F66D4A753EB3513BB7CC + 9EAADA5ECADDAD75E4BD4F62F831F00FF64BF0B783754F007C0EFD9D2C34AD32 + DBE295835D3EBB7D71A95EA6B763248B65AC9BB3289658EDA598AAC43CADAB34 + D946DCC1FD4ADBC5117C5FF0E7ECCFF163C59E15F0949E37BAD7742BF4BE3749 + 7373A1C9A81B9F3E2B72F08923B59E3B4CB12CA640880AB08C13E3BE16D27F69 + 6F0EF89A2F13F823E0F3D9DE6757F13C1A5F887C4F69A4DBF89ADF5A96D045A7 + 5C6164B8D3B51B08E27BB9D2486451B26B75667991EBD4BE08C3E385F837F0CF + C25E36B9F82B61ACF86F54D2E0BC93C3FA84EBA64B6505BCD1C252F2FE28A59A + FDA6718450102FCA99F999B89F2A8B8ADECFBFF5D7EF3AF1129BAD1A8E49C799 + 3BDD49F9BBBD6DFA5974697D59A9DC585B7C1EF8A7A5E97A64C2EEF3C21AAA18 + 34FB5926796E6E74B9ED5122890339769658155467000FBA0123F8A4D43F662F + DA47E0EF84BC3FAE5F787F5B5F0569FA84533B5CA14686455119516B371200DB + B2146715FDD4F83BC35E29D76DA6D0BE19F884F85FC65773C5F65D5AD6DFCD30 + 6EC3485533CFEE91D339C64E4018AF9D3F681FF825FF00C4AF1FEBFE067F07F8 + 875AF15AF9132EB13F88656963D36ECC99F36188E5791D76D4D6CA6A6270D184 + 9A4974B775DFA6FDB5EE7EA9C0D8CA349D6AF0BB7295AF7ECBEF7BF5E963F948 + B0F177C5D36DA2E97E25F0DDB785FE1D79EB34DA9D9DABE5493832C91A9F9460 + 0E3D09E2BD6A7F8D5F09639E68FF00E16159CDB5C8DF1C6423F3D5464707B702 + BF7D3C63FF0004F5F823FB30784AE353FDA4349B4F1468D2C6CF26A635ABB468 + 9C722316906402C781B8F35F29278ABFE096C1101F81BE25C803FE60572DFAF7 + FAD78B82F062BE2A1CF4EE97F76FFF00C8BFCEC7E8957C43A74256AB64FF00BC + D2FD51FB8DA4D9EB3E32D2AEB47D7FE144916897E4C3BE3B85236118DC0119ED + 5E55E20FD8A23D26DCDE786AEFC3F6B6C57CC9639EEDEDC0E738DCBDBDFB7E35 + FA85E0FF00869E2FBED4B5583C4B041E1ED3A290A5AC4660ECF18E3792BC0C9C + 903B66B0FE297C0DF126BD3A36997914DA14481650F7470D8E7846F5C1E6BFA5 + B0BC51ECEAF251A9C89EFD7F33F9C71BC352AD4554AB4DCDADBA7F48FE247F69 + AF117C64F85DFB567C74F085A7C50F02F8D3C5FA5A5F6B6960FB752D2EFECF4E + 335D9D1E2BB31AFF0067DD436C66B592D97CE8D6711160865321F30F889ACFC2 + 5F8DBE21F85B65F16FF65FD2353F19F883C2ADF10F4DF1378535083C3373AE69 + 2D6EAB25ACB2C1B56EAF05C2B4423B854DA6DD444F8B9AFB3FFE0B57E04D23C5 + FF0018A1F823E0BF879E1FF82FF1063862D4EE7C5BAEDAC9A73FC46824B3712C + 635286410BE9B02065F3258A493ED36D323BC68156BF253C4D71FB4F7C28F8A9 + F03FC23F13FE0A784BE2FA691F0D6E745D0F4CF0F59CDA9D96B9E19BA926533C + EF661DFCD57320C9485E3223255182B57E419D545F5C9A9CAEDBDDDD7F337ABF + 92DFA3D2C7B993E5E9D053A4B96714D68ECEF6565A72DF6EBB27ABEDD96B7FB2 + 4FC06336B7A7F87BE21FED51F04F50D035CB2D0B5A5F13F85D6EEDBC3BE239A2 + 33DB417C91FD8AE2CC85478D2E3CB3B9D1B613C093D1FE32FECFBFF0519F85BF + 157C39E03F0FF8DB4AF8EF6D068F16BD6B7DA01D3EDEC2F95E09ECE5B6B8B6BB + 30BCF298659E3F28961343302A0AB62BC474CFDAC7E0D6AFE32F18F89F54D07C + 4FF0FF0056D53C41E149F57D36DEF26B88AFE18E39AD35CF3981DF1A4B1FD8E4 + 581D58892DF2B86F947BBD8FC45D1FC6BE25F8A7AD687E37F0BFED05F0E478FE + FAF2D74DBAD46EB47F1369DA30B82DA75DDBBDC08A461142E60FF479229235DC + AD05C4646DE58464D249BBBF9A7B75D7E5E5F79D98A789A3255271528C52F8A2 + 9B574B9ACD25E9BEBF81F1CFC60F1C7ED01F0BB5DF87BF067E32FC394F851A6F + 84F53B4F16C7E198AC56D5A412C72B47346C2492311949E7545888446F314E0A + 6D5A7F1DFF00694F0DFC4EFDAD3C07FB4678134DF17F81A3B5D2B44B2D55EF1A + 23752CF6B07D9E6962F21981468562C64EFF00DD93C715FB03FB577837F62ED6 + F5DB1FDA1BC03AC59F8A7C77A4AB69DADB5F6B926A1A75AC76D0931DD4AF2B4B + 9BE124FB65632B9672A7CB5972EFF9D3FB3BEB3F0C7C1DE10F89DE3687C0DF03 + 3C7BA62F8EACEDEC62F883E1B865FB6DBC96AF3A5B5ADD4F6F325B5C294768ED + E4312DCAACD86578C29E5C3E1F9E51A8D5A4B5EDE5DBC8F46971047D84E31A6D + AD23DB7DEDADBADF567D69FB5FFC1DFD9CBE3DFC32F86977FB37FC44F036B3AD + E85A9345ACCBA735D5E5A490BE9F12B013C71F96F2C72AA95457603CD704A6E2 + 2BE13F1C7EC77AEDA5EF87E1F8713DAEA164BA747F6FB8D56F45BC97176657DD + 22008C8A814C43664118FE23F31FDF6F883F137F672D67C1FF001864D73E0FE9 + BF09B4FF00875AD7FC23AB109E1D1A4D47532A50D8325B43828F3232DBC68B23 + B21F3000AC54713E37F857F052D7C57E0AF01D87C61B6D07C61AEDD59FD9AD75 + 15FB4AC1BED848B023C613330061C472AA337DE2CA0296F43030A7093BEEF5FB + F53E11E7B8E84630826E9C159736BA2B6ED257B5D7A1FCEBFC5FF81FAEFC229F + 4482FF00FB4355B79F4E8AE6E35286C644B28AE5A49018124239DAAA872DB492 + DF740C575DF06FF664F14FC49B8B2D435C6BBF08784E4DA4CD243BAEEF90923F + D1E06C0DA40C79927CBDC2BF41FD0FF897F64CF176A17ABA37C33D42C7E2059A + F9915C4B1DDC56D359DC82ABF64BA843B209C6E0400DCAEECED208AF9B17E18F + 8FBC3BA55EF883C43E0FF11D868F1DE0B4FB75CD8C91C3E72C8531E638C11BE3 + 003676B328C13C67B633A52D5308F14D7E4E4947967DFF00AEA78CF877C09E09 + F85BE09BDD3BC17E1FB3F0E69F142D2CC63C7DA2FA55C9F326988DF2C9843DF0 + A33B401F28F2DFF829F7C73F17F845BE1C7C3BF0ADE5C68B078A25D4A3F13334 + 2866BDB68AF228A3B64739DB092652C542B330DB90AB83ECFAFEA897B6BAED97 + EEA330DA5F4CC11F27F776D2B920F427000C0FEB5F0E7FC15775B17BF1F7F67C + D1121920FB278552E195F86633EAD7721638EB9D8719EAA01AF0B3BE59382F3F + F23ED3802757DBCDB6EEEF7D5EA9A7BFE07CDDFB37CE34DF8F7F0975BB67B8B0 + D5E0D76C6682FA09DE19EDDFCD4C3ACD1ED752BC36E0410403C57F5B5FB2CFEC + 3FFB1D786BF625FD9CBF6A1F8BFE1DFD98F50F0CF8AFF6A7F3FE2D7C46F1B6A7 + 6897DE05F0D687AA5D7D93C3D6CB71B588D41AC616B98D5F74B05EB334730F27 + CAFE43BE0879917C55F87D731E370D42D98003EF7CC3000EE6BB9F8A5269CBF1 + 1FE20FF6C35ECB6BFDAB7372B142F12F9970CD22990AC9C020614B805B0BB380 + C31DD5669475EFFE5FD5FB9FA3E1BA7A1FDB94DFB317FC1BF9A97C68F8B3E2AF + 8C3F11FF00643F0569365F1F2F3E25EB96DE28BFD2ADD3C65E1DB8F0725FD9E9 + 5A2C514DE7DBE8F14DE26B0BC96D7CA8C5C5DDBCA855FC98D53F08AF3C69F033 + C53F060FECCDF097E22D978BB57F853A35CAC32ADB3A5AEA161677D7504D769A + 863CBB9135BDCDA5D38899A28F6C3B1C86735F831B3C1F6D6AC9656D7E9A9188 + 8539B18A11279848F91236665C76054EF63C81C9FE81FE02FC26F829A3FEC69F + 0F7E2CEB1F08FE1AF8C3C4FE22F0DF8662D661F14DA49A8E99A95D58B4C96B24 + B66B222AB90BB0B29CC85C970C37579157F7B28A82B35DDDF6F95D79EFE565A1 + E0719E2E950C1FEFAF66EDA5BAF7DB45DBBD8FACFC69F11BE144DF07F56F889E + 06D1A3F8B7E2ED1B481E1AD52E7C23651EB171697D7DF67B7293CB6E0F9DB237 + B52E9B9BCA5910B05CA2B65F8AFF0065BF8FDE1C7F1EF86754D0FC23E15D634D + F00E8BE0CF0FD8F8BB59B6B1D27C59A9C81DE445D523B968FF00D0BECB1A18D6 + 2DF2BC9204930A1C7A5681F1CFC65A0FC0CD3FC53F0AB48F05FC2BD36DFC388F + 05AF842E62D26DF48967DA91358E9D0C1142F009248E5656DA660082247009F1 + 9F8BDF153F683F8A9FB22F8BFC552699A8EB128D06CE1F1186F0C06D3996558D + 679FED3BF6B4B167CE68635731AA87601594D1460F4E676FEBB9F96E26BBF7A3 + 495AFABBEB757F96E95B7765B6BABF73D23E0B7C70D3FE0BE99F033E30FC58F0 + 678225BDBEB7834697C056F7D770699690329D42395F5129E6CF76AD14493A47 + 13C2AA190B606752FF00F670F80F1FC49F11F8E2EFC53F1CE4D674ED586AB63A + 75B789667B6D2748B65510786D8A8F3AFF0048499E37F227669649C202CC5DCC + BBBF082D5B56F841F0611AEF4DBFF116991DB5C0B47B919F2058C44958B93B30 + 22249E3087071C57C2B17C4FF889F09BFE0A1FAFFC11F1AE83E3AD5FC15E2DBA + 92F7C1779A2E9B72D74D1DEB2CF1BACD0E42F9323DD4124E31F67781257C2035 + D0D420A37BFCFBFE472CE75AB559538BB2E5BD93B3B75F3E8AFF00F059F63F82 + FE267C29F1F7C4CF8D7E174F811FB3D78BA76D37416BAD42F6D678BFB56DED65 + DD636BAC457A1A25B9B37762AC91AED708B8047C9E897DE3F87C35ABEA7E21D6 + B54F057C3AF03785BC3A973A8C779AB47A2E8D1B44DE5A0B89D42C4A26B89D14 + B88FE70C4ED24E0F89F8BBE1E78A7E2B5F7C50D3FE22CD3FC39F87733E89F0C2 + 4F13F882F6C20BF9B4D5B88AF2E7C4514B121B7BA8E591648608B747BDD9B223 + 40E95EBDE22FD9A74EF8B7F0335AD0FE3F78B344B8D52F35FD2FC4FAA1F0CA79 + 9A714B0B96B8B7B578EEB78BBB5289209FCD052469E5D91A848CD275A495ADAB + D7F37BEDF8F99E756A7854D4EA3B46365A59BD6CB6D7FCADA1C37C247F8CD0F8 + BFE29E9BE2E97C01E2CD19AE91F4BD66DF5D486F0A3C92B44B736EFE4BABCD0C + D693A181E452C1813C2E78DFD903E32FC21B0F88FF001FFE10F873F6B8F0CFC7 + 291FC6D7F349A77882C9F50D612488849DADEFEDDD2DEEED9D623B6678F21D1D + F7C8B210347E16FC29FD9B60F1F6A1FB4B7817E16F88F54F1069D6B6F669AA3F + 88357D76FB4BB15096B1D9E9FA74B73E4C56D6B6B298E3558CB5BDAAB046620E + 7B0F0369579E35B3F8A9AD69FA34BA4F83B43985EC2BA3D8C16D64937D9EE448 + F73E4A465A396D9E689490EC64B8897850CD5E74AB4D7BCBAF4F976D8FA1A94A + 84E9FB0716AC926DD935EF7CDEFB6A9EBB743F573E0278B3C2DE1FD47C3BE27D + 220D37C61A4DC5CA5B9B2D3EF219A568DA174CA9462A3974E382DB48E339AFBC + 6E7E37E9FE158A69747F867E38B68995E50F15879AACC0E00DA4038C0FCEBF99 + FF00F82772E85E08D0FC6E9ADF8DED7C05E1FBEF196816D6DAB33246D6F218A1 + 469A257D8AF2EE2800EACD80031E2BEE9FDAB7E3A587ECAD67AC78E35EFDADBC + 4BF1420D2A45BAB0D0E07586EF5C70C77C642E508078383E87D2BEB7298C713E + EB5AAD3CBFE01F49C2387AD87A13E56DC79AE9BB5F54AFF89CCFFC145BC75F17 + 3F68CF805E29F08F85FF00649BFD3BC7F16B115F45E2FF0012F88A2D0E29ECD0 + 92D041624FCFB802A1A42173F357F3AF75F0F7C4F6D75736D7D1784EDEF63919 + 268FFE12AB63E5B83865C83838391915F3FF00EDF3FF000516F89BFB60CB71E1 + CD5B4AF885A5E953DF24BA6C1A8DF4C6458B765516040109248033B8F4F5AFCE + 8B9F849F146D6E27B5B9F873AFC3711BB47224B60E1D181C10C08C8208E73CD7 + D0E57E20D5C9F9A95092A9196B66F48BFEEE97D7CDB3DACDF83A8E64E352A45C + 64B4BAD1BF5DCFF47597F6D0B1D375368755F8AF61796AC7CD10D9D9076CF65D + C6B1FC6BF173C39F14174A03C59F116EB4691867EC7208228A4CF4915704D7CF + BA77ECD1F05752F16BD87C37F0EF8CBC7139904B00B7BCDDB17A0525BEE8FAF3 + 5F76E8FF00B23F8ABC2569669A678734F8B541147722CA5D415D616C1E1F8E58 + 01F9D7DC55AD97D171947DD974D8FCAE84333C4A9426B9A2BB733FD753F9A5FF + 0082FC7C28D374EF863A6FC4B8B4BBCB8D1078634EF0CDB5EDE9599EDFC42BAF + 1BEB711A93E6C5E6591D5435C61A3F90464A99143FCC973E24F1C7C5D87E2EEA + 7F0B7E3A782BC1BF14BE1949E13D73C2B657D7D02D8F88F449B448247B20A195 + 2695EF6E4CA5D98E3CB70C084DABFB8DFF0005C1F853A7EBFF00B1C786AFBE20 + 69424B98FE2D7802C6E2313B2472DBCD777304CBBE2C3A8292E37A90C0671CE0 + D7F3227F629F83FE35F176A5E13F087883E2D7EC9FF106E7C27AA78D235BFBF8 + 351F085CE851EE11DC457D24D14C2C67960B95F34CD28896166902B0287F26CF + 69C3EB32AF16FDE77D3BD97A745E7A1F534A9C69D1587ACF96D76BDDBA49B8EE + BF0DBADFD7D59FC5BAAF8D3E1F7C13D17E30E9FF0004BC55AFCFA5F8FBC51ABE + ADE2BF0ED8DE59CDE228754B7B3B8134F144DE45AC8D24AAD2C4B84791260084 + C0D7F007EC6BFF0004F1F8D7E35F86A90C9E3FF05EBEBA54DA878CFC39E14D6E + 2BBD0E09122B89FEC62E0ADC5C4174D1595E4CD6F6D96681118046750DE21F08 + FE0B7EDD7F0BEDBC011F85B47FD983E32F84741F01EA9AB691E1BBFD42CF508A + F74ED6D164BCD2DAC57C9BABB9E55B78CAC4E7C96475F2E42275CFCD3E08FDA2 + FC75FB2A6B5F0F2EFF00E159F8AFE03F8BADBC7575E34D7ED6F7453A5E9DA85B + 5D2412D9C56B61346AF10802C8D180E17C965404867CF8DCB052B2D3F07D56DA + 5D5F5DDAD0EF546A54E68E16A2E6BEC9E9AB6F5EDA592D347AA692B9FA39E3AF + 845FB27FED71E0EB7F097ECC7F1965F857025E7DAFC1DA46A9A2B3786D2D22B1 + 2D22DE5C465A7B640564B9F3181680B112C4CDD3E1BF0EF80BF6A1F803E156F8 + 31E26FD98ADBE30782FE32B5BEA5A28D0B528B573ADAE997188AE34FB8B1323D + ABC336D63E6792E1642AE0C7232D617C4EF899FB2AF8ABE17FEDF9A57C39B693 + C39A36AFAF59F8CFE12D9DE69D259DE69F3DCDDDBFF6858DA081995238ADAE75 + 4B721DBCB96DE38DB0088C2FE81F8C27F883F107E14CDF0B347F19F8874AD76C + 3F67783E24FC3BD36D1FCB6BDD56D3C417E6F5634C037134B069CF1AC7F312A4 + 2A805BE6D6955A8BCAD6F3E8DBDED7DBBEE2C660E187A7185AE9BBDA4DA69FBA + D3BC755693BCAF7F85DAC7C77A3FED6FE1AF1068FF00B4BFC04FDA9743D5FE13 + F8C756F1A68FE22B237704D04BA16A1A5CB108ECAE63921326444B2C2E19119B + 7AB820A79727AF6A1F12FE1BFED1DFF0B46FFE1BEBAF178B3C2DF1A349F1D681 + 79776B2DADCEA5E1FF00ECA7B3BB68D1C6F56F3E3B7915640B94520ED3843F5B + C1F1574BF187C48F15F883E227C22F821F15BC4BFF000AE347F0E3C9E28F0AD8 + DE25FEACDA0CB776FF006BBA3199E50CD6F281BA4076B88C1D91A63E36FF0082 + 847EC49F027E0F7C20F849F1EFE0EE97AD780A5D565D2B47D5BC3EAD3C9A5C8F + 3E9F777725E446EA49258DC9821528B21847240520835AC2D392BEAB55BEFA5F + EE5F23CEA15E854AAF0C93A7269595D38A6E29B7D1EAB4DDADF5D0F72F805F13 + 358D6BE257EDA1FB3B780FC62DA2F82E0F1E5FEB097FA748B24634D55D4AEAEE + D93602F243917C83610CCA91206C0C360FC1CFDAAF59F8A5A15BF8EBE15F8E0E + BFAF69CF6E27F0E78DEF12E196CA12446926E678AD362792F0CBB16261E623CF + 0BA823F233E1C7C47F8C1FB3E6B8FAFF00C39F106BDF0D75DBDD3B633AD8C27E + D567345246A7CAB989D4A34734C15B6F47CA9E86BD03E147C6DF11D8685E06F8 + 4D7FF0AFC39F17F4DD1A632784E18E07B5D5B429CCBE6B359DE403CD08CF9691 + 5BF76E3FD6EE00635545AE56F64BF5D3A3D92B1D188CAE2D4E4B5BF2DBE49F35 + EF6F89EBBAF5BE8FFA5FFDADF44D6BFE19AED3C63E29F869E12D0BC6A6DAE52E + 7EC17F15D4F62B71A54E8611342A23785992DD53E694811C6778CF3FCFD7FC14 + DE75D43F6B1F0DD85EDB5B3DDE95E0BF0F4324687FD5B335CDC6D079EA275CE3 + B9F6AFD08D47E3CFC79F18FC1DB7F007C42B8F0DE8FA4DB786CDB47636133DDC + C90DAE9D2AC4B2DF39C4937C9164C6A10797B559C104FE75FF00C150342D5F4C + FDADBC4BE29D5AC5B49D0355D07444D1EE64CA45A9C50E9F143234521C296599 + 678DD064A9519C6E04F9D8DA8D72736C9BFC8CB82B0AA188A90834DF4B6DBAD3 + EEFF008767CEBF04E2B27F8A5E1D36ED2C9A62DF6E4F3982B18379D9B8F1F305 + DB96F51EF5A7F18ADA4FF8583E2F924373206BB778DA43B5994B1209DD823A1C + 671D070739AE22D3E00FED0D7779F0F753F0D7C23F8C0906B777791E893C5A45 + D5B7F69B416AD3C82DDDF66FD91A990E3180335DEEB3FB247ED4DE1ED22F7C4F + ADFECFFF0015E1D3E3DF24B38D345D4C1C8CEF9238DE49B92DCB95FE2393DEBC + FAB9946A46D176F567EBEDC693BC99C6C5E0BF11594DA483E17F114AD7BA9369 + 16ED0E9D3CF1DD6A0320DB42F0ABACD328C82885981078E2BFA37F879F0FFE28 + 78A3FE09CBF0A7C37F0F7E1CEAFE3AF1B5878774AB993C371C6B05EDEDA99E7B + 798C6B700209552E8C9B240A088580646606B4A6D77C61FB1F7ECB9F05ED7E1B + DBE97E0ED7B4EB4D2ECAFEC64B45296F76DA5BCD75C263CA9DEE967DF2A7CDB9 + 9B249639BDFB425D7C6EF1C7C17D7FC5DF0DEE343BBF1B3E911EA915DEA3E2FB + EB6BCD1DDA1134B32456D166575884F184670640E42AFF000D6586C4CECA57B3 + F25E763E0389F19F5CA8F0DC8B922D3BB6D6AE37D525B24F5D77DB5B1D17853C + 1FF1B3C3BFB3B788BE1D78EFC1BF067F676F1659F866DBC3FA2DCF8A75DB5D7E + E247C84964D5A3D2519ECA08A3FDE463CC9764843158D77B1E9D7E148F017ECE + 3E3EF0EFC68F8B9E27F8BDA4B6990BDA9F86DB3C26DA65827CD7B269F35E4D77 + F6B9278D511E531C5218D76C6636393E33E0BF8B3E32F883FB32DDF8E35ED434 + AF0E78B350D664F0CA41A1C7FE872C71C30078962B97722599259D895CB06500 + 205F9ABAFF001FF84FC051FECA52EA5E23F16D8683E33D206809A758A7859E4B + AD3A64785A159750DC25537323C50DADAA87590BCA5D64F942F7534D6B2EFF00 + D6C7C56226DD574E166F47A2B76B24DDDEAD77D6FF0023EBDF876DE13F83FF00 + 07553E0B687AFE99A2B696DAFDBEA9E2EBEBCD652EC9B68D847757571786E88D + 90C2B8802C31F95F20FBDBBBDD1FE23F8BFC6FE0CD07C47A6D8DAE852CDA1DC4 + BABE9E9334874EBD96DA1683CA70E0B6E769D361460CA23276B21CFC6DA8FC2A + F8F3A641E3EF0B5DDAD8E97616FE12F0A781B47F0D78B75E1E1FB09F5F5682E2 + F6FAC6E67FDCCB1C3166399831795A11145E610457D112FECFDE37D1FC73E319 + B41F8DFE1CD03C397F61E1FF0008DB5C697A15DDD7F6AE91606F2576996FBCB8 + E0D5E67BAB848A780CC90DAACA192691D0C2BDAC9A516AFD8E1783A13A8E74E6 + 9396AE5BF6BDDEAF67AF7E9E5E63E3FD67E1F7883C2FACFC0B7F1968B27C7EBE + B46F1B59F871A49A3D46FB4BB488991D5A21E5AC4D6C75090ABB6486470AC911 + 35F4A7C288F48BFF00D9F3E1F5A4FAA58DCDCEA1A2A2EA9F66960930B229C93B + 1BE490A4A386C75439504E780D37E01FC27F19789FE2BF8A3E2A7822DB5FF127 + 8A3C336FE10D4E59E3716E90DBDCBCB1B43145865651B10DCAB2B347FB83BA32 + FBBBD7F0F783BE107836D3C01E05F0AF863C21E1BB78E28DAC3C3D63058D8A33 + 0532B086108AA5F79566C64ECE493963C153309FB2BA5BFE1FD7A9EA66591E1A + 388FAB425792E5D16AA5A5DC93BAB5B5DFAEA7C07FB1A59FED6DF0B34DFDA5BE + 1F7C44FD9AB56F16D9E9376D2F86F551E27B1D36CFC4F2C6CC8B609772F9B982 + 78648256BC0802287465F32402BACF8C5E0CF1E780BC75FB327C4337D7DE0AD6 + BC2979AB5E9F0FC48C6C751D62FED672F70DE68093430C36AF671C5346CB2453 + 13852ECB5F427EDBDFB4C685FB1F7ECF771F133C17E31F17E9BE32D6BC5DA569 + D751F872CED4422DDADA6F3A5BA865643B2416411110E55B61520920FE767C17 + FF0082B3FC0ED6FC45A38F10EADF0CEDB5296E51A5D43C429A8E8F78B823E779 + 64964B4623AE5B20941C81D358E1A4DF2C9EABD3F0DCF4F2394711CD8D4BDDD9 + 5A2E5D354FDEB59B6F4B18DE2BFD9820F873FB22789357F819FB3E6B97B6371A + BE9FA8DDE9DA158DDCB3DCBDA499FB54E84BCD70908B9250461B68326D036B15 + EDBF68BF87DAD9FD98FC05F10BC0BF14CFC528BC39657571ABF836F74E489FC3 + B60C8CD71A9A48A118EC6FBF14CD239570EA5B6B29FB77E25FFC1523F657F03D + DADCDF7C71F06FC53F114B68F7D1DB7867555D6EFF002A85DCAF95225B47B02E + E3E75C4442EEC236003F2E7C6EFDB33C2BF1F7F669F8A42FFE2DE93A136B7A5C + 9A66836B2FDAAF64D45EE207586392E05B8B7476001289C0412B09490C4F4BA7 + 4E1CCAEF556B7E3B7AF7D0FAFCA71F8EAF560E3171826DDDAB5F6EEAFA2DAD6F + CADFCF26B3657F63AA58EA7A8789668FC43138BAB0B9FB68516A9110CA42750C + 08181F8FBD58D43E35FED1FACDFDF6AF3F8935ED426BA99EE5EE0EA527EFD9D8 + B17FB9DF39FC6BBAF895F0ABC4DE19D453C29A968361E2F9524335D5CDA63CAB + 7461F218643CB6E1C902AF41F07BC786084DBE911ADBEC1B01BA230B8E3F4AF3 + F0D99615D28CEDCCDEEECDAFCB43EFAAE1712AA38A7CBFD75B1FD9068767E21F + 0DF8DAE13E1FDE78FF0055B79D4CAB36972888F07852E30303D0FA57DB9E1696 + CBC4361733F89FC57E3A93C4AB6C0326B1A9F9450019D83CA23D6BCCF50F85FF + 0011357F10CAFA5F8816C6CA3319BEB782168D6303AE197B7E35EE37FF00B337 + 86350D3FC357110D725BDBAB8659965946E9877DC09DC17D0D7F40E33154B957 + 33D7D3FE1CFE6BCBA9623DE8C2378AE97B2F91F98BFF0005A0D0FC5FE0CFD80F + C4FE3BD13C4BA05FD9E87E2EF05EBF650896591BED11EB96EB186DC7E600CB93 + CF40DED5FCA2787FF6C5F87B7BE22D3C78F7E12F833E1E695A97813C65F0F3C4 + 7A9787238ED56F6D3578CFD9E68ED22882AC96B3CB75283B5CB7DA0A9C85CD7F + 611FF055AF82BE0C4FD85FF68AD59B49FEC4F007876E3C377DA925F6A52949C2 + 6BDA70900563B4E03139CF60002702BF989FD86BE1CF8C1343F893F143F65C83 + 40F883F11FC23E3DD34DD47AC411DB4FA9F859D260658C4AB24B115985B7CB1A + 3C8E66FB848551F0F9B538559B9B69DBE5BE9ADBD7F53D878C8E1E2E128B4F7D + F4D74D1B56D1AEA9D8E73C3BF153C37F13FC33F1D7E227C35D2A0F14E9FE03D0 + BC1DA99B893528B48D71A0D274782C6E754D3849347E6A06852392D5F7F9F132 + E23DF1A6DFAABF675FDAFBC43F12748F81FE22F163F88B4DD375EF1EF8D3C75F + 6795CEA12DF436E9379BA5A3CEA511ADADE6B4088BE58712AFCA55005F36F865 + F02BF641F8D3F1C74DB8F127ECDBAAF83F45F8D7378A6C34D49F55B969BC19E2 + 0B39628AF858D9E116D2513DD79D0C72091A30A632170631E53F07BF65CFDA6F + 49F0FF00C04D63F66FFDA37E05FC6ED12D97C4FE30F0DF86F5EB3BBD3A532085 + 60B974B278DA5905D5AAD9B2F98F0812388CA861B9BE765527F6D5B4BF7D5BD7 + 6F4F322AC305522E126E2EEBE2F28CA36BEA95A4AEDD96CEDAEDA5E27D03F65C + F8850FC72D13E29FECF3A27C2ABBF157852DFE37786BC59E1095DB58B749E77F + 36D4B5CBFD9BECEDE5DD0920F2D230C1DD1108454C5D1BF625D02F3C5DF11352 + F833FB5278ABE0F78E3C01E1ABA9B54D1BE2CE990CDB123B75610DBEA119481A + D676B8B4312B5BEC02E2278CCCCA71F346ADE3BFDA52D7F661F863E2CF1A7ECF + DF146DFC19A6F8724F877A178E2EB449D213A5DC4ED72B09955332B8125D7945 + C85064721980D83D2BC5DFB44FC06F899E11F8E27C2BF10FC4961A9BF887C212 + 783748BE69A23716124DA7CBAB59A443CD8E3812EA2BD99559D308AA064384AE + 5A6ED7B3D5767FA7FC0B9F57530B555A14DBE5BD9ED24B58C7ADFA6EB4B6AF75 + AF13E3CF097EDB5FB38F8CBC25E08F15DB2F8EBC4DF1163D17E20D81D1E25F11 + CDABB59E6DE0844F0461E331A136F2C318086290283B1811FADDE2AF887F1C3C + 59F073C39F0F3F6A2F80FF000EBC06614D2AE749B5586EB54BBB67B285E186E3 + 7CEED0464099C3451072BBDB2EA4E061F8875CF8F5F185BC73E1EF82BE331A5F + C4EF86961E14D4B40F0E5CDE47630DF68B3693A5DCDFCA5E4DA5A4916E3ED5E6 + 02588899506D455AFD20F19DCEBDF167F655D03C73F16BC27A17807C4F06AB67 + 25F69D6904E874DC3F92F2EE9B6EC33A146D84203B86768D8A3D3C25FE1DD5FE + 7EBF23F3CE25C7CDAA778C54F4BDB7E8D5976B5975D5349D8FE7A3E30FECC9E1 + 3F883E2BBAF1A691E26D6B42D6F5297ED1A82797F6D8EF66206E74DEEAD1B9DB + D3254E000A057AA7C3FF0085FE06F85FA5369BE17D2E78679900BCBEB83BAEEF + 48FF009EAFC617BF96AAA8BD813CD7ABDFE95A95BC71CFA826FB9CED98EE01B7 + 360F20F73BBA7418CF6E64BDB2916EE70DE52C986627713B4039E3D720F6E2BA + 1D16B7D8E559955A9495394B4FEAC71DAAC44699E20B50B13BFF0064EAC89FC2 + 01FB05C15049C8E0F4F52C057E9AEA5A3C5AFE85E0C43A45ADED81FF0089A5BC + 72C0933477124492ABC68C180701B2245F9813818C62BF3AAC6DEDEF3C4963A2 + 30B80D709750295C16C496F22700F18249EA7AFB62BF483C1773A847F0BFE146 + B93D932DBDE78774DBCB2232BBBF711869109C7F10DA3B0208238C57CA71446F + 4125B2DCFD1BC33AAA9E379A4BDED2DEAF4FCAEFD16DB1CA7C5AF0C8B6F127EC + D57D722E567D23C57ABCB74F2401F79BAF0FDD825C900A2A4A1402C4E4EDCE37 + 0C7A9F8665B78B4F4D5ECFE7684B462556CCB0FA10173CE5B233EAD8E841C8F1 + ADDE9977A4695AB6B90335D5CEBEF6D6DB66F298CB2432170CA7FD60F296E32B + D00058E0AAE3E72F157C52F12FC2DF1AFC24F066909A7BE8BE22B6692EDD2DD3 + ED71E65916368A76041E8A02B03C87FE2C0AF1A8508FB185BAA7F8376FC2C7B9 + 9DD7A8F11513BF3A9A5E4EEAED5D79DFA3B75474BFB61F823C73E27F83FE1E9B + E1C7852D3E22EA91788EDA5BCD39355B7B126DCDB5CC7E789E7221023774DD1B + 1076B02B9DB5D7F86F4BD5759F843AB5A78F74BF067C333A869EDA15A7FC21BE + 268B57D424FF0043F2FCD9EEE3863896EA27D8E91299157CBC331FB95E75F19B + E3247E19F0DF856D3C43A8DADFC72EAF63A65F5CD96B3F6C30B4C5E3D9390885 + 368DACBB8EEF99C2F45ACFFDAA069DF087E16DF7C59D4357D66CB49934840349 + B521EDEDE6371B638ECA1E0C6ECAD243B4B1DDF21605F2C7A70F68FBABA1F259 + 861F152F76A68E5F0FDABE9B745A5AD7E5D9ADCE4FC57A1FC3FF000AFECD83E1 + 87C4EF0BDDFED15A5A42BADF8A25BDD4A1D2B52BCB64B9F3E1D4E2B5B4930912 + CA224554287CA196760ED9FACE39FC3DF03BC3BE21B3F809E12F087ECF9E1B10 + 469A73F842C22B3BB6D40DB31896F6E5D1DAF98049C9371BF280A2E3AD61FC41 + D6B43F8A9FB2FF0087B45F02C379E3AD635BD1A6B0D1574DB46943CDABBC70C7 + 31917E482D960FF499A591D16211B8936B4615BC635BF829F1DC68DF12F579FC + 45F0EBC25E1B51178A3404D675AB9BCB5B1BA9841657B6F7B159445844235B9B + 98E5824946F99213B479CC9E9528B6AE95DD8F0B1752109B857972A52BDBA3BD + 95EDA6FA74D2DA687AFF00C44F1C78FBC5DFB1B7867C7B79A4F87FC451F88342 + B33E2C1FF08FBCAC90CA24325E090388A1549608C1211B69941F977283E97E0C + F8BDA6DEEB49E04BAF08EA9A6DEE8FE09F0A6A316B4F1E535537B65E7C9045F2 + 864F2B1680E5D8B8977E17866F08B75D3B44FD9CF44F877E2BF8CB0FC4CF0BE9 + 771A6D9431681A4AE89672AC12F9B2594CACF712DCDB4CF1B34E8F229751E5A8 + 894B299FE2778FBE28FC3EF84FA8F8A3E0F45E09F0378B2EED6E3C63B27D2524 + D27564F2628E6B5BA91A5692094DBFD95D1E258D235B64895B6A322CCE525AA7 + 6D2F7DCC30DECA737071E64DDACFDDF3D2EB7B797A2D8FB4FC0BE2136FA9DCC1 + AA35DD8D888DA4699C93E601CCA3CD2546EDAF85E460F7EB59BE22F1DF86FC53 + AE6B43484D3EC26B792292348033C6081B4B160B8591C8DE53B12C4673B8FC9B + A3F8EEDB5DF86FA2FC5DD73534D32CAF7C2965E347D2F5093745A435A4623D46 + 1B8693FE597DB2E208D896C155C71939D0F815E18F1B27C2AF84BA878E25F016 + A1E30D3ECE568F50D33567922D56395A46FB7C08F0A2C45E231A324AFE62153B + 5B001AE5C5559CE9BA7257F3D8EAA59261A73788A3354AEAC9272766B4DF57AE + B7767BEEAFA7C7FF00F0508F19E9BE083E11F067C6CF859AA78D7F660F163C56 + BA9EAFA46A125B6A9A35E5ACC92B081CC6C8674882CD146CCA1C457117426BCE + BE1B7FC1337F65CF087C57F837A413E25F8E765AFF008B3FB4ECEEF54D49134A + B8F0E2C5E6C10BDBDBAC42779165123CACE14AAC6362798CB5FA3DFB45F803C7 + 7E3DF037853C17E1ED6FC29A46B29E23D3352BDB7BDBD2D21D243BC771E57969 + 2A2CE51D9A3DCE54BA648EA0416761F07B46F15689E37F0ADCFC4BF13EB5E19B + 1B1F87F73A6EA3125B0F0FDD9918C372F64F0C4E9773C6D25BB481E589A12857 + 00A6D8861A305CAEF65F22B28CDABC308A9D06936DEA9DEF67BB49E97D9F7B1F + 951FB41FEC7DF07FE217C2FF000678BBE1358F86BE1878A7C2DE1369DADF4ED3 + 9A4D3FC48F797976F69A4B488C3C8D4D63B79AF55E505A4B3977B12A9193F2CF + 873C2F63E26F07F8245EEB3E2837161F6996D74893589D61D2E65CAB3476EE4C + 4BB941E5472AC47426BFA9EF177844FC5DD13C45E09F18695A65AF857581AC69 + FACDB597EEDA09ECDB658CD6975B449034A6DED76EE19312B443E50E0FF245E3 + 7D63E20E89A66997DE35D3345892D6EAD1EE2EAD2755FB33C8AA59593A853923 + 1DAA71B829B5CAA5CB0DFB36EFB25F35A5FF0023F50E01CE96268C9D44E528D9 + 77493EB7B277D1DEFDD1F70699FB3F7C48D63448EE7C7BE28D23E1C4B79A53DE + 68882092E9AFAE06163B7F97023620E771E057E5C6AF0FC6BD2B55D4F4B6BEF1 + 8BB5B5C496E4A48ECA76B15C839E471D6BF52BE36FED0DF147E2AF802C354F0B + 7806E346F865A5593DBFF695BB89679D2355DB20E788B20E71C935F14E9FFB5E + F81A0B0B286FAD354BBBD48516697ECE3F7AE14066E5B3C9C9AF95CBF30C4626 + 972E217338B7BBBFE17563F56C660E8D29DE94AC9A5E5FF0E7FA4ADE7C168AE2 + 2975BD3FC557BA1E86ABB8416B19DF367A2976E0E7A66B5357F0C6A1AF45F0F2 + 1F0C47E2BD2EF256FB3EA91DEC085E285324CAB303DF18E0F7AD6F10FC41F115 + 8C1A7786B428F5DF1A6B8D12C8D6F6F6DE4C318E08F34E30457D17E0587C5B69 + A72F897C65E1BD1ED6FA4B668EDB46B390C924871C07C74CFA7415FBC56C7558 + 25293D8FC270D96E1EA49D382B2D2FBE9F3D52ED63F2B3FE0B69F0BF47B9FF00 + 82507ED61A6E817EFA4C93695A024CD7771E645284F12696ED2941CB10013C72 + 7E9CD7F0BFF0BFF64EF8FD64FE23D7FF00674FDA0BE1D9D76559349BAD0752BF + 4D0357D4268A55135ABC178F243198B78915E675DC54F964965CFF00A39FEDD3 + FB3578AFF698FF00827E7C7CF86B61E06FECCF89FAAF866F23D13481A8002F6E + E265BBB7B369D5945B8966B6863136E5F2CB8258004D7F9EAD9EAFE22F869F10 + 34BF81FF00B46F85BC5DF0ABC476C9E24B6D3CFC50D366D0D6DE1B88EDB3A69B + D85017CDC59C4C977681BCB7412A825DB3F3D0AF294ED195A5F9F975BFA25FF0 + 79389635E9CE3ECE09D3E5BD9ABA7D754D69B778DB4F979FF83BE3B7ED17FB23 + 2F8624FDA03E01FC49975CD0BC6BAC78ABC35ABF8B56E2C124D6AEE257BCDD7C + 5196E95CAC570C61932C46770FBD5EADFB37FED51E0FD07C01E2EB2D0BE3327C + 25F885A6FC1BBEB1D175ED618D998BC546CA34916CE74F3199A67B0B30AE02B6 + F9CB0036161F70F893E2BF82749F8EFF00B3E7C3FF0017F867C3DE23F85BE13B + 8D3BC43A0EB3E26D722D6268135B86E2C6DEDE3F32DA08AE1ED22B592EC4D345 + E7E510AA829B9FE46FF8296FEC0FA77C0EF88FA17C56F8531597873E1078FB5E + 16D796CF73BA1F0C7882794B4A90A6448F652ACA658D23DC63F2E54E8D193A53 + 9CA2D41AD1DD26B4D76DBA6BD6FBA47C64730C2E22718D787254A967BDD3B3BA + 5ADED78BBF9DE49DF4BFA3695E28F8ADE10D07E2AF8D7E15F8A759F847E3FD2B + C1771E2AB1D67C2FE22179E13F1C5858A1B8BEB46B8C1649E6B486E201304B5B + 80C2249E17337DA2B07E20695F0BBE32FECC367FB437ED23FB35DDF883E1E5EF + 86FEDF6DE36F879A768FA76AFE1AD5EE6686DE3B69945D580BB93CC9E27113DB + DC2CCAC0A846DFB7C07F68BFF826E7C41F830FF007E1EFC37F1CF887E2DEB3F1 + 0A2D665FECA9E38345B184D943653865125C98823A5FE0ACCDBF2AB8197D829E + 8FE3FF00DAD7E1CF812DBF668F881FB365CFC4CF863F05FC510F8E3C5AFE1C59 + E57B69A2B047821BCD562335A3C5047722E3CB8E22E1D448C596039E4C4D38B4 + D3959BEFA75FC34EDD8F77015A8D5842B61A51959DEFAA7CAAF1693BDFE2D136 + ED77D9EBD8F83FFE09DFF16344F829F0F3F681F847FB50F80BC1D2C36D3F84BE + 255978CB5B86092C3C456F73B63D334D85A3737F0B5BDC5AAA46D878992E18B2 + C2CA47EB368BFB32FC74D1AC744D03C5FF001BBC43F16BE27E9696305EC7AF5F + 5C25BDB38817ECF05AA0C5AC11246A9B488901C12EE597757E167807F684D07E + 23780B44F0DFC5BF14DBDB6B3A7FC57D17C57E1EBCBA479923D2261258DFDBBD + D15C058ED26B66F3242BBD74F8813C003F49FE1EFED1DE22F09780359F11F847 + C47A5BBF8A3C77A5782F5AF11C1FE94B0DCC3A76B1672DDDA5C2B6DF3671A1DB + 32CBF365189400CA197A684270B3575FD2FD5F73CBE26C3E22BC5C653BABBD92 + 5D6E937BED7E9D2DBEA6AC9E13F1778B9359D5AC749BFBCB64924F3EF9A02602 + EA5B3F3838003705BEEE41E41AA2FE199A6BDB0F3AE164BA312C32A49807CCDA + BB909EDF3023903239278A87E28FEDC1FB527EC39AB5E7C1AF8CDF0AB4FD4B4A + B6F17CB05A7C42BFB669ADAF3C2D34D750DA4B1B4523AEE9D63B79CC534A5E38 + 5270A9975F27EC1F1B7C40F80BE3DD5BE19780BC39F0B3C6AFA6A69F69E23D57 + 57D06DA0862B45B8D37CF1688C38921474DB2C8ED118CA7CA5C9727B1E609DDB + 49FA69E7D4F93FEC8C4D05195EF177B3BAD6CD27F9EC7C356164B078E3C272AA + CAB7D06AD66A8FFF003D479B82A4753B867EB9AFBCBE1F78A2D2F3F66DFD956D + 2E229EF27D1FC3C9A7BB79A0A4E893798ACA060E0A8DA413C30CFF0019AF8C7C + 57ABF8425F895A1DFF0082ACF5CD27C34353B09AC935498CF391E64786943A86 + 55700B88C8DCA08525B193F53F81BC67E09F85BF057E08EA1F15B46D6EEFC2B2 + 592D9451E9C8B72CF70A641F68901605A20B1606D1BB9076B00D8F0F3CC37B5A + 5682D5DAC7D6F0B678F0788855ABF0ADECF5D9E89FAB5F7BBE869FED131453F8 + 83F65ABDBA61183F14A7B8325B801D627F0DEB04ED3F77711C704819FA0AF99B + F6807F1143FB46FECEF7767F0B7E3278FBC18961F6C66F0CE8571A9882386FA7 + 79A39843B9A0702688EF906DC4A873F2B57B4FC6C9E1D634ED1B56F05EA9A869 + 571E19D426F16E9D2884DD2214D2AF60C3BCC3CA8E3D97DBF73EE385C143BB8A + 3F043E24FC50F8BBFB3A7C55D73569358BDD5EDEC27B5B89F49509F67F26EE18 + A3B85840C42FB6618CFCAECA76ED5C81E153A11BA6DA4FF5773DE9E655210738 + C6F18EB6BF45A6DAEAAFDFA3EF73CA3E2C7ECFB3FED41F0D356F0A9F15F823E0 + B7C4399F4B9859A5ADB99EC64B6DCC96DA9C766DF248E252EBB2467462396F99 + 47A2DCE9FE09D53E17695F0B7E34788349FDA4F52BEB66D33547B8B1FECEB7D4 + AE926DACEB042F982449A35C3A32CBE64464255B22BC7EDAEF54B3F8AFE32F14 + C365697DE21B6D0AE2E6381596D96F185942C617908C471975501DF0AB82C7D6 + B93F8CDE32F1468775FB297ED29E1AF86BF103C45FB396A7A8DE5EF8975BB1D0 + 6EEF16C64BE582689E68E146D92E679DCC6DC3342EAA738CF3B8C20925D75F2F + 23D1C33C4E26325CEA314F9525A496AAF67BFC3CDB6B73F443C1D63E11F82DF0 + B9FC3DE04F03F86BE1B693636F15AC3A6E8EB722DA32FF007A45371FBC9DA466 + 2CD73BE50F2672E4A803E74B1F1CDBE85E0CF14F8193C4FA545E20D7AC65BC83 + 482FE65EBDBC254ADE4311E0408C82363BB04CC0B290B91ECDE2AD2F59F883E0 + DD0BC67E1AF11F85FC0FE1EBFD5EC1B5DB8F19DE5F59456F6137C925CDB42D0F + 9D1CB9484A5B4E89B8370D113B8F6DAAF843F652F83DE2DF0CFC76B6F87FE09F + 881F10A1F075F7855B51D5744DD6DAD4285AE431B7BF6954DE2C6ED1ADC451C1 + E5DAA6C459941947B11C649B8F26896CF53E07FB2231F6D3AE9CA52BA6A2D377 + BAEADFA3BDD796BA1F146A1F067E26FC67FD9ABC53A37C30D2EFC7C427F10DE6 + BBA4C10DAB06BB9E34286CB6B1411F9FE6491AC8EC8A9234658E335EE9E0FF00 + 0A78D7E2CFECCDA5687F1BB45F17FECEBE34BFF09DEF86A6B3D5F4E8ADF54B1B + D16CB08BB8ECA6625AD59E38A4092EC77459620ABFEBAB5FC47693FC20FD9F6E + F47F833F09FC37F062D574986FADAEBC0BA579524500F3240B773492CB737691 + 46A5A4FB4064C900021D99788FDA0ECFC5D2FC12F82BADF853C4DE0BF869E21F + 146A7A12DFDEEA9A6B3D95E5F4908B88A0FB4BCCB22096489977299362798369 + C00155A729A737B2FEBA7F91182CC29D39C30F1B272764DA4DED67BDD6CB6D6D + F33E82F027C11F82765E061F0E35AF0F5878FF00C2926871E989A7EBA04AC6C2 + 69C5DDCC2A76C6CD0DCDE795718707608E058CAAA12DE6708F853F0AFC7BA0FC + 0AF83BE17F87DF082D6F561BEBDD3340D3E2B291A53BC079991773B7949F2C8E + CF9DD9078DA3D3F4AF114F770EB5AF3D978474FB2BC8FC9BBBBD36E63BDB7D8A + 5BE4FB7F97124DF36E54901C637657B57E76FED296FF000F35DFDA17E01FC51F + 87FF00197C65A17C5DF0F3FD9AE74DF0F680BA92EA56C93F9B1C2F7370F15A47 + 282D3C67CC132949B3B731AE62AE2631A57A8924B777FD5EAC79765B5EB62DC2 + 873B94AF64949A4ECED751568DF4DD3B6EDEA7DA3E14F8ADE17B7FDBE749F85D + E2CB70D61736173A95A9826B8B6FF8496CE288109089376C9E1586EA395A1738 + 281B11B5771AD5BEADA4EB5E25D79ECFC3DE1BF0FEA1730E9979AFF88B51B5B1 + D2627B1D22F1EDAE23B8B9943CB1437E6DACF74625950A8708E91E4FE2DFC70F + 8EDF1BBC53F17745F8A9A3FECF9E09F096B5E1149F48D175693569758D4EDA29 + A46679ADE2976D8C6E3CC7C4AB6A6419387C80C381B3B0F15FC45F1369BE30F8 + B7E2CD67C6F6331526FEFAEDA7B98A31C158CC84F9447202A6D51D80E952F34A + 13A6E14D39DF54A2AFD3CECBF13EBF01E19E365569E2311354AD1B4B9B577BBD + B95DBB5BCFC8FD09FDA97FE0A13F0DFE1FEB3A16ABF02BE31378C6FEED9975F5 + B0D307F674062BBBEB8B596CEE6E144B75791FF6ADD5B9748C5BB471C4E3E7C2 + AF8CF857C3DF0CFC6BA0782FE20F8EBC03E1ED034396547106A3279B73A84C83 + 11F98A7E520281F2F5AF17F8BBE04F056B9F0FF53D13E157C1D8FC53F16756BB + 87CBD4AEED95FEC165110E443216C2C8C1307D49AF1DD56EFF0068DBD97C292F + 8FBE0AEA967A745E65A6976458A9B5C8C79A46EDBBCF5040FA57C7626B3CC15E + 71F6738B7F13D95BA27D765B5FA9FB664591E1F27A5EC68BE68B4AEECAEDF4E6 + 692D95EDD9687D1DFB4BEB9E3EF0F7C40D0FC25E0BD2DFC25F07EEED56F2CAD1 + ECFC86958B0CC68A463CBC90DE98E2BC6AE3C2DA7CF713CD71F0C3C3F3CEEECC + EE2CD7E762724F071C9F4AFAC3C29E07F8C1E3FD0B47F0EF8D755B89BC3DA446 + B0E9ABA9912CD6ABDD439CB600E339AED8F843C196E4C0F7DA7CCE9F21756387 + 238C8FAD78F570F0A508C2752F6EC9FF00C0BBF33EA235E559B942175E763FBD + 897E09699E1FBBB3BDF855F0D75DD6E39976CED35FB8861F2C672CD231604FA7 + 5354FE10788BE2BD9F88B5FD4FC536DE1DB5F0A58CB342B03E9734865607EE2C + E3E52C318EFE95F5F47E3CD0E4BC90E83A8DF4104F21925B7911E331B6718390 + 073E86BB7D3F52D6352D1AEA24B4D3B49D2C2796B2B60A807BEDF5AFD7AAE3EA + B8FBEAF7EEF53F35A180A6A6A54656B7456B1F991F173E387C72D675CD33C3D2 + 78797C0F1DCA89145B5D47BE4809206E7E8A76F078C8E95F39EB5FB2FE91F1C3 + C3C3C0FF00176D3C1DE39F0935CC9E7787BC4362B3D8CAEDC02F13ABC64E3F88 + 283CE7DEBF5A3C61FB39FC39F123DA6A5A86A324D7F09493CE58B74AF8E40560 + 72A09AE2B5CF0E7877E19C77FAF594573AAFF6A40F6F336A53E648980C298C1E + 4638ED9AE9A199C3D9FB3A71FC3FCCE0AD93CE5373AF2BAF5FD0FE693F6BBFF8 + 37CBF639BDD1B4E83C1D7BF107F65B5D5753B4BF7D33C05A836A3A52EA10EE48 + AFDF46BD32C44462470162783018E08CD7E5FF00FC1453FE08B1FF00054CF1C7 + 8A7E07F893C0BAE7C23FDB6BC19F0F2C22B6D21FC1B6A7C3DE25783CC85E796F + 749D46E1A3B9BA616E848B5B99338C0400E07F565AF5CFC428B577F10DDE92DA + DE89A65B977BC96ECDB40D0AAE72C2419E3AE457C77F0AFF00E0B19FB2E5D7C4 + 0BEF86FADFFC27FE15492E1A38B5F974D926D2CC99DB96940E63272037423DAB + 758094E2A54B75F77DDE5E5638A583C34AA2735AEB66F7D559EBE6B4F43F974F + 8D7E27B9F13FEDA1FB21F8B3C47AF7C45F0178A344BBB1F02DFF00C25F18D95C + E97A858DCFD9E69E7D52DECA7D926D9E4B4861998C4AD9FB3059641B55353E11 + 7C6CF8C9E02F8CBF0A3E2D6BFAEEA1E35F0E78AFE1F78ADFC556FA9BE2CD3C57 + A3CF72851DA31FB8F97EC0AC81414895C28DA1857F4EDFB7069BFF000BFF00C0 + 72C5A3FC29F0AFC65F044E0CD1EA1AB680357D1F4D61F32CCB68E0CB0B920112 + C4508EA18100D7F169AC7C1DF8DB65F107C7FF0004F40F165DFC1DF08EA171A8 + 87D3746B09EEE0B182E63962B892237CED711A4C26955916507E7623049274AC + 9D34B99EADBD3CDD96B7D95F5577A69D8F8797042D695369A51E55CC97C29CDE + EBB7327FDE71D5EBA7D2DE1EFD977F623FDA3B49F86F6F2FC1DD4FE01F8DFC47 + 2EABAA6B3ADF823C44DA7691A1C69671EA4A834FBE6B9B744923B993E6F9238A + 2B47DA5768AF8BAF3FE09A5F19F53D7BE25697FB3F7C5BF845F1462D1F5B99F4 + 6D2DFC46DA5EB5AD58C4EFF64BEF25A35B48E66446655136461CAB6DEBDAF8EB + C4BF157E0BE8DE2BF067C58F01F87F5FF0BEA3F0EAEBC1B6973E12BEDB70F71F + D957DA7C37D776B74C1A22F1DDDA09123C8C5A214CB3393F4B7ECBBF18FE1B7F + C2C7F847E23F1A78EBE137C4CF0B58DB8B39BC45A939D135CF0C4A7679EB796B + 3C88042D233CE0A4B25ABFEF0B41048FB8D54C13835049C5FCEDBF6B3ED7E9DA + F7D0F2EBD4C76154EAA973416C9FBDE7BDEFBBB3575A6A937B7E70FED4FF0017 + 3F6BCF0CAF8CFF00651F8EFE36B4616F65A669BE20D3A0B9B7D4619A18C5BEA1 + 68AB741A48C6CDD11DD1796CBFBC8F80CEA7F53FF63CF8F1A4F877F64D9FC177 + 9F0AFC7171E32B9D327D362D4B525B3B2B282DE5B1B3805EA991A4B9BA60F6AF + E5ED8D022B3B163E60032FF698D1BF653F8ADF1A26F8FBF0EF47D1BC41AF5E47 + 68D35F477C6E6C1E7B744B759D2D15BC9F30A470307E47CA1B1B8E479EBEB8B6 + F3897CE69DDD995D94EE058F6249E7A6727FFD4B0C9CA2E7F69E87CFE739CC6A + 528617D9D9AF79F4B495B6B3BFDEF64933D3352FB12F897423032411CB7B6CFE + 6C92395880983B364E58004F18CE38C6302BD1FE325D22FEC71F00A2D53508A1 + BD85BC9855EE63196961BC942AE4E4B146C85527804FCC057CFB2EA69752D85C + 6F0248E4F98103690369272471D0E0F5EBE95FA11A37C2CF865F173E02FC3FF0 + 27C51F0568FE33F0B1B7D36E934CB80E239E780B323CA6274236995800082433 + 272AC41F3739ACE95A7BDDFA0F25A0B1115093B3567A2BBBEDA2BEBBFCB77648 + A1F0F7C163E315D2F84746D5B56D5ED20B56875ED3EEB50B75D2B4BD3E780C12 + 0B94B8036C8C18C884BEF6740AA30CD8F11FD8E3E067ED2FFB2C43E32F87DF14 + 3C79E06D2FE10CED3A8F13E83E288B52D4F5AB5DEAE96EB68D118CC8B2C31C82 + 69245F237498F3BEED7DC9A0F847C2BE16D1F4DF0BF847C33A0F86EC21840B2B + 3D36C22B4B68F0B8388E250A08000C904E00273CD7C9C3E2945AEFC7FF00137C + 31BF919756D21BCCB7B22EAF23C42D165B79550E7745991A6CE0AE53383822BE + 370D2F89EBB5CFD7332C4559548C28F2DA4D45A6B6D92DDB5BF656EBBEAFD7FC + 5377FB30FC3CF1DB598F849FDAFF00F0B3618B40822F13CD1F88F4DB199512D8 + C31FDAE26FECF5BA8E588CC638489586E26318AF41BED6B50D3A2D4F49D02DE5 + D3745D0F4C82DFC37E51F2EDE0B548910476B12B130450E0462050A308B8C005 + 47CFFF00B60FC39F05784BE3BFECFBA7F8335CF1325BDF78A2CAE5745D575C5B + F9A5BBB7485CCB67097698016FE7BCC630222CCEDB40209F23F88FFB4EFC32F0 + 34FAFC5E30F18CDA6F876F75A8ECA3B6D4C0B7D52D2D6DADF3792AE9CB19BEF2 + 1EE55228088312677891510B1F46719425ECB9569BF5D8F89549E261EDE8CA6E + 524EC9AB6B6B6BABB6CF66EFE47AC6B771E2BB7F81DAA59788343BAD7B49BC80 + 6AD3DD5EDCFCB6916E7589A2CB093F76BE5DC3361A33BF6B77C7CFD6DABDEEAF + A5DEFC1EF0F68F7BE2474F87777ADE9F3DB7FA445A74E4DE58DBA5D60EDB7DFE + 66227760B262E13FE598AF8FD3E28FC46FDA2FE3C78E7E20FEC4BFB33FC60F8E + 7E2CD73C331F81EFB56D6336BA0E9B6A5238665516F2A450ACA914482DE7BC58 + D3E66F2CBBEE5D2F8AF6BFB4EF80E2F0CE99FB546A7F0EFC5171E39D2AE6EED3 + 40D2A7F3ED3C396F672470B978A28A381670F2F94AD9B8202B7EF31D65557651 + DDEF6D3F177B2B79B3E870BC2D3A959BE651E6493BF7D355157BB766B5E5E9B9 + F4F7C74FDABBC01ABFC2FF0005F83F5E8FC71F08BE3F788B48D32D751D0F41B5 + 8BC41A8CB6F04999EDF7C7729A7A2C85A748E6924F3A38652AF193951C178B7F + 68A1E3309E0EF8ABF08EEBC6BF0D7C2162353D55754B0B4D5AF3454580C76F70 + 209605D36148831503ECF21C16F9989663F22585F58C5AA4FAD68A25D3FC6F67 + 140FA2CD71FE9170EC8429814B6768DBCE00C01C5767F1DBE26EA1A478624F11 + 7C58D0B4CD335BF1669DFF0008C5CDC69BE685BF887FCBD5CC0BB7CC6507EEF4 + EBDB35E76619B5A4A9466B99EE92777DBF4E88FBCC93C3BC0D1B559C39B92EE2 + E4F48DF7EBB6FA372B773E71D17C47F10F5FF8D3A7FC52D4FE2F78EFE2778734 + A659BC2CBAB4A7CAB67E91C70DAA85B7811000008A345EC02D7E877852DF50BF + F007C45D424B0B0F167C4AF135AC96D6B7128653A6C8F82660E31E5E33C05AFC + EAF06DAEA7E1D7D2ADEFAFA0D474D6B84B5B7BD4B468A15B7E8A7046158E0671 + 5FA136DF12AFBC13A2F84F4BF0C59D8EA1AD6A7A8C16B7AAAA4A699A6AE4CB39 + 04F0F8C804F52C2BCDE23C4CA8F25385E495B4BABC9AEB3B6D6D94775BBD4FB9 + C870706A574A2B5D97BA9768AFCDF5F44749E17F81FA9EB9E0BBCD1F57B8669A + D6111DC6A96AECD2DA02003BCF3F31EBCF3DEBB187E05FC0DD2EDB4FD3B52F18 + EADF6558D537DB6E0D21038519FE23ED5F777C00D57E15EA925F685E0AD3EDB4 + 5BDBA66B9BE52854EA27805A4CE771233CD7E4AFEDADF083E2278ABE3B584DFB + 3CF8B74F82D7C1F34FAADD34971E5C304C0EF112AA82256C829B6BE1E8E7B8CA + B55C6151D252BB95AFE6FF00A67D655CAB0F4A9A9CE1ED1AD1753DF3E1B7833C + 39F083E2BF8D6F343F185FF8C7C17A868D6B36931DCAAACDA55C19184D1BB903 + 763018679FAF4AFA422F1BFECF7AA6ADA56817DE2B6F1578E0B2F93A6419BCB9 + 278E760C841C8E4FAD7A41F895E17F8E9F05FC2BA4C5F09A3D23C7D7BA445737 + D1DC2A465A4D803E148050939DA0F7AF857F628F0BC3A7FC42F8A9E2B6B1F15A + FC439F569AD24B1D64C493E99E4FCA230C8301082AE0E0EE0C2B1CD28D46DD48 + D5E6B2DFA860AAC62941D3B5DEC7D73FB52F88AE7E1C697E12F1DEA3A5D9782F + E1758442D2F2DD462F26697A34AC7E52BB411B4722BF3FEFBE28FF00C13A67BD + BC9E3FDA0AFED23795DD6210BE220493B473DBA57B8FEDCDF1BBE15F877C32F1 + FC54D6B4EF17F8D3ECCC2CF4513F9C4CC3A33C20ED5DBEAD5FCDB5D6B7777573 + 71731DC59DAC7248D22C4B02B08C139DA0F7C6719AFA9E14C8EA6230D7AE9DBA + 3DAFF95FF13C6E20CDA950AD68DB5E9FF03A1FEC8FF0B3E34E8FADDACD0F88E7 + D3F5C4DC8AC9E605209E776475AE83E2359EAFE2DD0751F13FC2D9E2B28EC0E6 + 7B4172CAD74ABD42F6CF706BE3FF00859F0E7E027D9F45821F8B3E6DFE1519D5 + C472CF26070C9FC15F6169BE39F875E03D2F5BD32C7C576BAFA242EB2410BF9E + 6DCA827E7099C0FAD7EB55E2954BD34EE7E69858559D2E5AFA2EF7FD4F8AF4CF + DAC2FADB5FBDB33E3286D6EAC914DD5A5E4E11942F3DFA1AF7CD23F6A1F82BE3 + 2B3D27506F15E957FA8AC0F2DE2CA5648ED8776C838C67B9AFCF7F15FED33F0B + B59BFBFD4B56F877E11BAB58249237BBD5ACE359301B0D180D823039CB76ED5F + 949F143C5BE0DF8ADFB40785EC3C2BFB42FC12F0AFC2B7D4063C2B6F68ABFDA5 + B4F31DC18F04A75CAE31D2BD7865F29C79AA41A5DD7F5FE7E87252C4723E552E + 63FA18FDA060F859E2BF86BAD4FF0011BC6F69A57C24B6D3A4D7A746D4A38ADE + EADD016057691BD075D84E18803078AFC63FD9EF51FF008261FC78F88F6363A3 + 7C749E0D6ECE196FA6D16FED5620F691B11BD0B26028E3BE71F957A4FED21F17 + FE0769DE0C1E00F8DBF11FE1669FF0B61B344B1D118C70AE23195F2A343961C7 + CAA4E320715FCECFED37FB5569DA8780F59F849FB1BFC3EF027C32F86376F37F + 69788AFE3D9AE6BE78CA23E3289D5467920FCBB6851A3463C9527693E97D7EED + FE7B7E45D553A92E754EF05D7CFEE3FA49D4FF00E0A21FF04E7B6BCF18FC3DF8 + 3DF1F97C0DAEE8FB74FF00B3DE2DCC316A5701F6930C846C95791D32335F9EBF + B697ECF5FB64FED63E38F01FC01F0A9F86BF093C0BACB36BADF10F55D0A7B7B8 + 8214527CBFB48DBBD5B20EC0413DF0326BF2CBFE09EFF0A7F6519AE2CFE277ED + 2FFB55F85BE11D869A05ADD787ACAD9EE75DBE2C7026858E4295201F951B804E + 715FB05F197FE0A5BE21FD98B438B5BFD9C74EFDA4BF697F0E5CDB369DA3EBDE + 3F58EFEC442187EF618111245509C01B149000C763C184CD255694A52872456B + 7BA764B66FAA6DEDA33AB1395C2328A6ED7B2DACBE573F3FCFFC11CBE16783B5 + D8BC23F15BF6FBF84FAEF8EA59763DE6A16F28B3B6239CBC8F31C9C740481ED5 + F1DFC6BFD90FE0C7C27D5FC45F10BC09FB43F85BE24DBF84AFBCB5BDD2F4C302 + 6A9228198EC6F4EE52792A586E1D476AFA9EDBF697F0878C7C09FB40FC67F8C3 + F0E26F8C9F1B4EB093787E1B6B78A28A25920002B598C068948E723823D857C8 + 9F0D3C0FE2CF8ED67AE6B7E28F08EA5ABCB6BE6EA0345F3069FA3D82AFDFDAA4 + 846603A28E78CE2BC3CD334C1DA15A5CF52ACD6914DDF476D75D169B2E6BF6B6 + A5432A9A72A4D45416EDD9AD7CADAF9DF43E558FE2778A6FEF9B5CF155958DE6 + 82D2A86D52E1DA292C622E00690C485662A3A90A19B071C9AF51D63C6DF0EB4C + D7EE7C15A978DFC36BAAA3C72C5762768AD6F1645664786E24555236F66D8C38 + 0546013E3DF1DBC67ACE8FF11F4AD3BC34FE15B6F07C090DDE9D3D89DF61BF19 + 21837DE656EA0F19C74C647E65FC4EF889E35F13F88EFAE757B9D1B538AEA792 + 48CD840ABE6FCA0EE2467A210401F2E1B8E0D6B9362B15283AD8A6927F656EB6 + B5DFE1E67C8E77C0D96D45ECF0F1709775A2DB5F776ECF4B1FBB296444FA7DCC + 2C8B03EC8D5C6D78E519E002073ED8E318F5AFD46F83B1B47E02F86C77C6D8D3 + 3CB811FE5673B9C0036FDDE4BF2076C6457F193E0DF8CBE3CF00BEDF0778BFC4 + 1E1BB7DE24FB224A4DB3B8208CDBBE63CF1FDDCFBD7D93E13FDB0FF6C9F89961 + A57C1CF87FF11BE21EA37570AD1C3A3F852CBCBD42F01EA035B219F693C9DA51 + 073920576E3EA43130506CF97C27086232FA8EAD39AB777A5BF3FCCFEA13E2BF + C6CF827F05F4B8AFFE2DFC44F0A7C39B810B2C2351D4156E648CAF22DECD775C + C921C63288463249E6BF08FF006B7FDAF3F672F8A9F10BE1BF8BFE0DFC3DFDA1 + B57F8D1A1CAF69A7F88F47BA1A0C5AA40CEF22DBF92D05CDDDC0469250852385 + 824B221DCAE36F8B783FF614F18E8FFB4F7ECB3E09FDACAF5FE1F597C4BBED42 + 49DADF5EB6975A8A1B78DC6C9EE1C491C77334DE5468A5A57F98F01B68AFE8FF + 00E11FEC95E0FF00823E18F8ADA4FC07F84FF0A7E1178BAE747D5B47D03C4DE1 + ED4B52BEF125E34D6B28866D4757BD8D5EDE4DEF6ECD1C1FBA8DD5C87C22D785 + 52853836E0BE7F71D153174B0BECEA549CAAB6EE9A768EADAD6CEEEDAF75A5EC + 7E43FC3FF82DFF00050FFDB5BC2DA5FC57F8A9F133E1CFEC65F006299F4FD3EF + 27B27B3D4AE7CF8D62992D961275298CAAB123B5DDDC31CB80A491903EEEFD90 + 3FE09C1FB24FC3B9FE26E9FF00163E1EDA7C57F8B3E0AD734BB8D4F5DF1C6A0F + 7FE1FD53429879AFAC5A693188608D5624B81241762EDA19234DCF22CAA6BE84 + FF008271FC55F05FC5FF00D94746FD9D7E2169DE2FF0AFED2BA4E89A868DE31F + 0D6B1E1CBDB69511A49164D47F7902DB32C88C0EE328C4A64C819527DEFC6BF0 + 72C744F14FC7BF1C78FF00E35F85BC39F0F35EF0D587872DACF4CD286A17FA75 + A4D32ADCC770CCC9090560F26195BFD59BC91E5E5218E94631D1B7CC9F45B5FA + 6DFA9963335C573D5A104A9A4D59AD2EAFDED76DF7BD9F6BD8F45FEDAD1749F8 + A363E1C9355D3745F09E95E0FD5B5022CA18ACAC74E4F3A392030C0A23821586 + 165CC8150808E377CB91FCC27ED41FB4EF81BE2CFC73F02D97C36BF83C55E17F + 0D682FA45AEB861912DB5469676B8926821923474853202B303BC96753B48CFF + 004F33FC2CF0C5D6AFE3CF10681E035F06EABE23D2C6937BA95ECBE76A97D671 + C296D6A934A14A986358CA32260B160CFBC8C9FE713E247EC767E05FED371786 + 6C3414F17EA336810EB1223CBB2DA3432BC28E46D070CF6F200BB792A7AF5AF2 + F32AF4E9417B55CB1B3F4E9F2FBFEE6CFB2F0FA9C6A579B84F9AA2B697BBEB77 + F2F2E873BF0C3C53E08F0C6B7F69F1269FA45FDBBA331908F2A58F7270E84F20 + E48E3BD7C99F147E3AF8E3E31787759F0BF8E2FF00C38B6367A81974CBB9A10F + 73022362354D98118618CF3935D2F8B3C3FE03D43C7F7D378F248B47D516E07D + A63B8BA92148594FFAB541D1307F1AED7E347FC28BB59E4D37E0E58CDA2F85EF + B4D861D4658E2257CD539628CFC0DC793839AE3C9F04A38852A7CD5A72D5593B + 47ADAF657DBA688FD4F30C45E8352B5382D1DDABCBE5AFF99E63E32F1578EFC2 + 9FB3F58C7269771E20D7A4B95B6B6BAB6B7CA5AC67E612383C8718C0AEB3F64A + D6FC51E133AAEA7E26DBAC6A5AA26EBC5BC97CC967523A303C2607423A77AF80 + 3C6BF1225B7BBBDD3ACF59D6353D3D1898964B9658D581C06099E7A753587A57 + C5DF13C7A65E5B69C6F1AF65264BAB8F309DAA3850BE8315F414F85F0CA33A58 + 995A537CDEEEB6F2EB7FBFBDD9E6D4CEEB3942A52575056D7AF9FF005A9FD2C7 + C11D77C2FA142DE353E228B4A06668228E7BF42225EE83F964D797F89BE31FC0 + 8F835FB4ADB6BBE24F10C77BE12F1214BA9A5B2B81731E917110C324A8BCAAC9 + 9CE7DBDEBF9D093C77AF4F692B49A95D8B662464C8D863DF8AE763F10DE4B70D + 6D6897135C37F101C8FC71FD6BCCAFC2D41E8AABB3D348D9FE6FF23B29E7B514 + 53F66AEB5D5E9F923FA23F8DDFF051BF812FE3AF1178ABC13E24F11DC5C5BCF1 + 59D959D8DA1449E1419DCD21F526BE27F885FF000508F1CDEF8FEEFE277C26B3 + BBF867AB5E58C7677F25D2ACED7CC8789957A23E0E37771F4AFCE8D22DA772B2 + 6A36EB15E0C8408FB89F5DC3B56ACD69116F36EA601C0C2A33E547E55EDE0382 + F014A10E68F372AEADFE3B1E56338AF17394945F2DDF4D7EE6EE686BFE23D43C + 5DABEA3E21F10EA973ABEB3793BCF3CB2CDBA499D8E49249F5271D8555FB141F + C31C9B7B62A182DEDEE194AD9AC888D95311C2E7DCD696FBB1C6CB45F6DE38AF + A94D7D88E9F33E75A6DDDBD7CCFF0048FB3FDAD9BE022378CBE2CF82BE13FC31 + D2B519B1A85C5FEAA4CF79963929095059D4F3807F3AD8FD9DBFE0AA5F037F69 + 9FDA324FD9DBC15F0F750F08DDEB8B35B685E2EB9B658ECB5BB9442595E21878 + C10A7633901CF1C1C06FA07F6BAF077847C6FF00057C4F63E33F0B7873C5D650 + EA76ED0C3AA58C57491379CBCAAC8AC01FA57E6DFEC13E14F0BE95E39F1E9D33 + C37A069C6DF5CBA8EDFC8B38E3F21015C2A6D03681E82BC2CCB399FF006A4703 + 4E292B26DEEDF974B7E7F91D3808C55172A9EF74EDD17979FA1F3D7FC168BC6B + FB54FC23F036BDF0F3C43F03FC3165F0C6E2F009BC4FA159CB7F737D046325A6 + 78536DA42490A5A4391D38CE6BF0EBF665FD8D7F6E9FDB4FC55A36BDF04BC0B7 + BE11F0EAFEF21F105C46BA569D6EBC6592761994E3B206CFE35FE921E1DB2B2D + 47E0DFC40B6D42D2D6FADE5F0E5E2491CD1875917CA938607823D8D7E4E7EC61 + 71716FF0A7C1FA75BCF341A7AC8AAB023158C0326080A38C575E1F2FAB8A9D49 + 4EA594545E895F56D593D96DFCBAF5EE66AB2A2D422B7FEBE67E5D7833E117EC + D3FB2AF833453F1CFC2FA87C68FDABBCF7B5D5B59BEF0F3EBDA65CED3B7F74D2 + 83E42A6074DBF8F5AFCB8F187ECD3F0CBC4FE31F897F11B56F893AC69DE2CBAD + 625BCB1D16CF438EDF4CB28188C4680648E3DEBFA68FDBE618AC3C25F11EEAC6 + 28ECAE63D34BA490A846462064823907DEBF907D475FD78FC56F16C475BD5CC5 + E72FCBF697C7DDF4CD77E6993E168E1B9DC2F293D5DDA6EFDED6BEBA8B2EC7D6 + AB5DAE6B28FF00C3F5FEBC8F60F86BA6FC2DF839E2ED3A7D17E197FC2E8F896B + AAADC595A9B733B799FDDD98385209C93D0126AEF8C7FE0A09F16FC73AAF8D34 + B8D3C23F00340D3351B8B57D37448C4B77732263F77248EBB2303D1467A0278C + 558FF825BDD5D5DFEDC3A7CD77733DD4DB7563BE472C72B66C54E4FA76F4AFCF + CF10410CBAA7882E6486292E65D6F5896491941691CDE36598F52C72793CF26B + C4C8B153A18A9AB26AD2D2D6F85C7AFC5D7F9B5EAD9EA6718753C341A6D6CEFD + 75FC17C9117C3DFDA67E337C24F893E2AF1378775A8FC2B6DE214305ECB269F1 + DCCF3C0C49263F317099EA5801EC3815DDDDFED49E3CD6ED6DBC1DE38D53C4AB + F0CE6B996E6C5D90416D7D2F7F9D707382C76E7F3AF02FDA2A474378EAEEAE90 + 46A841C141B4703D057D4BA6695A65FF00C3AF04C17DA6D85E431EAF13C692C2 + AEA8C6D392011C1AF9BCE33BAD49CB0F1D2F2716D68F5EDD9792FC4F672FCBA9 + B846BCB5E549A5D3FE0FCCF18FDA66FBC2DAFF00C0BF184FE18866B8F1343FD9 + B168423609E4C6F771ACCA4704298DA41D4719AFC7DB481B5ED5E09AC24B29AE + BEC915B791E708F7CDE488C61DB6AAA9C039C8C03ED5FA85F1AA3483E127880C + 089095D4ACD54A8C600BB4C018ED5F2EFC5EF0C786B48FD87FF66CF18693E1ED + 0F4BF16DFEBBAC5BDF6A96F691C7797B124F71B5259D407755DAB80C48181E95 + BE4784585A3F57BB95A4F5F4B5BF33CACF719ED6B466A293924BEF4FFCBC8F6A + F077FC13DB5DD6BE19DC78EBC61E34D2B51F16EA9776DA27833C35A35C8BB3A8 + EA532991DB50BF0B886D6D6DE39EE65312BB3A44555D4B2B8FE983F63AD1BE04 + 7ECD1FB187C4AF0F785134AD57C3FE15D1AF3C41AEEB7A225B4D7DE2C8ADED5E + F67BA92788932CA1D24B6F2246C423CB4C614337F26DFB10F8DFC69A2FC40F13 + AE8FE2EF13E92B6BE01F125F5B0B6D425885BDCAD84922CC9B586D903C513871 + C868D0E72A31FB1BFF000426B2B3BDD23F692D0EF6D2D6EF449F4BB559ECE58C + 3C1309B49D49660F19F958481103647CC14039C0AF6BEAEA3277777BFA1F95F1 + 6D1ACF0B3F6D3E65069DAD64D376B75FD5EFE56FD93F81173F11BC5DF047E12F + ED243E1EF807C59F13354B2B7D62C34E8E48ADFF00B022BAB7378B6967A8BDB4 + E60263582333CA628649F019E30410DD2FE25EB7A97EDF971E13D5FF00B6B45F + 005E7C03D37C53378761403C9D497C4D790BDCCD1212864684A29D8EEAEB1A82 + 4FCB599FF04D2B8B8BDFF8272FECDAF793CD76E7C216D1132B162505EDD42179 + EC238D2303B22AAF400579B7846F2EE4FF00829BFED38D25D5CBB597ECF3E1D8 + ACC9724DA27DB4BED8BFB83712D818E493D6AF12A3CA9A5AF73E330AE70C4622 + 175CB152B2B3D2D24B4D74F92BF43BDFDAFEEBC51AB7C37F839F143E1DF8FF00 + 5EBBD22C3E3AE8D3CF2D84D2C0349B52DF63934C11E55D218E42C8EB281BFED8 + EA54A6D15EC3FB70D95EE8DF097C7B7B74E743D23FB46085965D48C704D0CB23 + 5BC490C4CE22370D74F6FB63552F90C01E421FCEBFF82A87893C45E1CFD9E346 + BEF0F6BDAD6837ADFB56AEE9ACAE9E076FF47B83CB2104F28A7EAA3D057DB3F0 + 06187C4BA2AEB1E238A3D7F57B9D5DEF2E2EAF544F34F3C7A7E6395DDF2CCEA4 + 92AC4E464E0D7262A7EC62E6B5B7FC03AE9E19D6F67CEF7BFE16FCEDFF000E7D + 2BE1FF0016F8FF0058F177C42D5BC47A5DAA782A2874E8BC311BED533BFD801B + 8C01F349009A7DAB21C0CC3305036E5BF1AFFE0A1FF17E5F87DE0DF0E7C4ABAF + 11E9FA078F2C75A7D3AD7C3B2C43CCF11D9E206B88049D14C0EF1C9E84B9E32C + 6BF606CE49249B4A2EEEE4B4D924E73884E3F2AFE697FE0B1B2CB27863F66E9E + 49249277BFF12BB3B312CCDE5699C93DCF279F735962B0B1C4A54EB6A9FF00C3 + 9F43C075A5431DCF4F46AF6FBADFF0FEA7E4FF00ED09F1AFC4FF001E7C791F8F + B50D3F49B09A085222A0857B84539CB81C6481D6BD407C12FDAEFE30F8722F1C + 7817E17F8D75FF000BB5AA35A3044895D00C6618CB0320E3838FA57C3123BB69 + 766ECECCEF1B1724F2DC8EBEBD4D7F721F02E28A1F82DFB3F451471C510D0AD4 + 055000C7943B5619866D532BC3AA582F753DF5FF00863F67C1E0563EBFB4C43B + BF43F8C487F677F8D57771AEC3AFFC38F1C6917F61937315DE973A6D61D3242F + 3D3B579DE8B617F6B63AF40B6575697CB2A426DCA1564209CE7233D8F5AFEFEB + 55B3B46F195DA35ADB327951F05063A57E08FF00C16AFC2FE1AD0B59F843AA68 + 7E1DD0B46D4EE4CCB717369691C32CEBB73877500B0CF3C9AF3325E28957C4C2 + 8CE1EF34EEEFDD7A7EA6F9A650E9537252D2EB4B7FC13F9E5B2F0C6AFA85C493 + EA39B1B0DFBC46E7E66E3B28AF4C4B3B4B6855A5DA5C2805F68048C7A0A48492 + 8C4924E3AD52C933DA127273FD6BEFA85354AF6D6E7C954AD2AB6E6D0B907C91 + 98AD2D9DF8C9278E7F9D57DB24EB2429F622C0E58673B3D89A935066FB1BFCC7 + EF1EF55A2FDD595B88BF740819DBC67206734DCF5B790429E97342CB4399C08A + 5BA2537960A1B6ED1FEEF5C56A369DA1C6CD19B5B772A76EE2EDCE3BFDDAFD9A + 9BC15E0DB7FD95BC15A9DBF84BC3306A4DA249235C25844B2B398C92C5C2E739 + E735F99B63A4E9525959C92699A7BBB448598C2A49381C938AF17FB6E295F93A + B5BF6F91D5F50E66B9A5D0FFD9} + end + object lblTitle: TLabel + Left = 231 + Top = 3 + Width = 402 + Height = 62 + Anchors = [akLeft, akTop, akRight] + AutoSize = False + Caption = 'TurboPower LockBox 3' + Font.Charset = DEFAULT_CHARSET + Font.Color = clNavy + Font.Height = -33 + Font.Name = 'Lucida Sans' + Font.Style = [fsBold, fsUnderline] + ParentFont = False + Transparent = False + WordWrap = True + end + object Label1: TLabel + Left = 231 + Top = 65 + Width = 400 + Height = 137 + AutoSize = False + Caption = + 'TurboPower LockBox 3 (TPLB3) is a Delphi Library, whose purpose ' + + 'is to provide basic cryptographic functionality, implemented nat' + + 'ively as a white box.'#13#10'Block mode ciphers include AES, Blowfish,' + + ' Twofish, DES, 3DES and XXTEA. Hashes include MD5, SHA-1 and the' + + ' SHA-2 family. Chaining modes include ECB, CBC, PCBC, CFB, CFB-8' + + 'Bit, OFB and CTR. The source code is highly readable and underst' + + 'andable. Salting is provided where it is needed, transparently. ' + + 'The design is very extensible. Extending the range of ciphers an' + + 'd hashes can be done cheaply, easily and quickly.' + WordWrap = True + end + object lblRunTimeVersion: TLabel + Left = 231 + Top = 208 + Width = 78 + Height = 13 + Caption = 'run-time version' + end + object lblDesignTimeVersion: TLabel + Left = 231 + Top = 224 + Width = 93 + Height = 13 + Caption = 'design-time version' + end + object lblLogoAttribution: TLabel + Left = 0 + Top = 330 + Width = 614 + Height = 47 + AutoSize = False + Caption = + 'The above photo was sourced from http://www.flickr.com/photos/ml' + + 'iu92/3146549932 and has been copied with the kind permission of ' + + 'the copyright holder, Mike Liu (mliu92).'#13#10'The photo is copyable' + + ' under the Creative Commons license (http://creativecommons.org/' + + 'licenses/by-nc-sa/2.0/deed.en).' + Font.Charset = DEFAULT_CHARSET + Font.Color = clWindowText + Font.Height = -11 + Font.Name = 'Tahoma' + Font.Style = [fsItalic] + ParentFont = False + WordWrap = True + end + object Memo1: TMemo + Left = 231 + Top = 243 + Width = 194 + Height = 86 + Color = clInfoBk + Lines.Strings = ( + 'TPLB3 is free and open source ' + 'software. It is made available for ' + 'use and copying by an LGPL or an' + 'MPL license at your choice. ' + 'Refer to the "Statement of copying' + 'permission" tab for details.') + ReadOnly = True + TabOrder = 0 + end + end + object tsWelcome: TTabSheet + Caption = 'Welcome' + ImageIndex = 1 + object browserIntro: TWebBrowser + Left = 104 + Top = 0 + Width = 527 + Height = 380 + Align = alRight + TabOrder = 0 + ControlData = { + 4C00000078360000462700000000000000000000000000000000000000000000 + 000000004C000000000000000000000001000000E0D057007335CF11AE690800 + 2B2E126208000000000000004C0000000114020000000000C000000000000046 + 8000000000000000000000000000000000000000000000000000000000000000 + 00000000000000000100000000000000000000000000000000000000} + end + object memoWelcomeInstructions: TMemo + Left = 0 + Top = 0 + Width = 104 + Height = 377 + BorderStyle = bsNone + Font.Charset = DEFAULT_CHARSET + Font.Color = clWindowText + Font.Height = -11 + Font.Name = 'Tahoma' + Font.Style = [] + Lines.Strings = ( + 'The video to the ' + 'right requires an ' + 'internet connection ' + 'and Adobe Flash ' + 'Player 10 to be ' + 'installed, in order to ' + 'play.' + '' + 'The video is hosted ' + 'on YouTube. If you ' + 'are on a corporate ' + 'network and having ' + 'trouble accessing ' + 'the video, check ' + 'your firewall ' + 'configuration for ' + 'access to ' + 'www.youtube.com .') + ParentFont = False + ReadOnly = True + TabOrder = 1 + end + end + object tsProject: TTabSheet + Caption = 'Project' + ImageIndex = 2 + object Label4: TLabel + Left = 0 + Top = 3 + Width = 323 + Height = 30 + Caption = 'This product has been brought to you by ...' + Font.Charset = DEFAULT_CHARSET + Font.Color = clBlue + Font.Height = -27 + Font.Name = 'Script' + Font.Style = [fsBold] + ParentFont = False + end + object lblWebsite: TLabel + Left = 3 + Top = 312 + Width = 250 + Height = 13 + Caption = 'http://sourceforge.net/projects/tplockbox/' + Font.Charset = DEFAULT_CHARSET + Font.Color = clWindowText + Font.Height = -11 + Font.Name = 'Tahoma' + Font.Style = [fsBold, fsUnderline] + ParentFont = False + end + object Memo2: TMemo + Left = 3 + Top = 32 + Width = 614 + Height = 217 + Color = clInfoBk + Lines.Strings = ( + + 'The TPLB3 product is produced under the organisational umbrella ' + + 'of the TurboPower LockBox project. This project has no ' + + 'legal incorporation. It is an informal organisation with no defi' + + 'ned membership. The TPLB3 product is owned by the ' + + 'individual contributors to its parts. The Project on SourceForge' + + ' is administered by the TurboPower SourceForge ' + 'Administrator (tpsfadmin).' + '' + + 'LockBox was originally produced and released by TurboPower Softw' + + 'are Company as a commercial product. Versions 1 and' + + '2 of the product were commericial and were released in the perio' + + 'd from 1997 to 2002. The copyright holder was' + + 'TurboPower Software Company. Version 2 source code was donated t' + + 'o the the TurboPower LockBox SourceForge project' + 'under an MPL 1.1 license, which is free and open-source license.' + '' + + 'LockBox3 was developed from scratch in 2009/2010. It is not a de' + + 'rivative work of LockBox 2 and does not share any' + + 'common code, but the mission of the library remains the same. An' + + ' exception is the unit DCPtwofish_LB3Modified' + + 'which is a modified version of a file from David Barton'#39's DCPCry' + + 'pt package. The original unit of this was' + 'developed by David Barton.') + ReadOnly = True + ScrollBars = ssVertical + TabOrder = 0 + end + object lblTpsfaIntro: TStaticText + Left = 3 + Top = 255 + Width = 356 + Height = 17 + Caption = + 'The TurboPower Source Forge Administrator (tpsfa) can be contact' + + 'ed at:' + TabOrder = 1 + end + object lblTpsfaContact: TStaticText + Left = 3 + Top = 272 + Width = 335 + Height = 17 + Cursor = crHandPoint + Caption = 'http://sourceforge.net/sendmessage.php?touser=625421' + Font.Charset = DEFAULT_CHARSET + Font.Color = clBlue + Font.Height = -11 + Font.Name = 'Tahoma' + Font.Style = [fsBold, fsUnderline] + ParentFont = False + TabOrder = 2 + OnClick = lblTpsfaContactClick + end + object lblWebLabel: TStaticText + Left = 3 + Top = 295 + Width = 177 + Height = 17 + Caption = 'TPLB3 on SourceForge is located at:' + TabOrder = 3 + end + end + object tsCopyLeft: TTabSheet + Caption = 'Statement of copying permission' + ImageIndex = 3 + DesignSize = ( + 631 + 380) + object Label7: TLabel + Left = 3 + Top = 3 + Width = 370 + Height = 13 + Caption = + 'Copyright 2009..2011 Sean B. Durkin (except for portions marked ' + + 'otherwise)' + end + object Label8: TLabel + Left = 3 + Top = 18 + Width = 625 + Height = 26 + Caption = + 'The below copyright applies to all the source code and compiled ' + + 'binaries of the TPBL3 project, except the DCPtwofish_LB3Modified' + + ' unit which comes with its own statement of copying permission i' + + 'n its header comment.' + WordWrap = True + end + object Label9: TLabel + Left = 8 + Top = 48 + Width = 190 + Height = 13 + Caption = 'Statement of copying permission:' + Font.Charset = DEFAULT_CHARSET + Font.Color = clWindowText + Font.Height = -11 + Font.Name = 'Tahoma' + Font.Style = [fsBold] + ParentFont = False + end + object Memo3: TMemo + Left = 2 + Top = 67 + Width = 625 + Height = 246 + Anchors = [akLeft, akTop, akRight] + Font.Charset = DEFAULT_CHARSET + Font.Color = clWindowText + Font.Height = -13 + Font.Name = 'Courier New' + Font.Style = [] + Lines.Strings = ( + + 'This component library is part of TurboPower LockBox 3. TurboPow' + + 'er LockBox ' + '3' + + 'is free software being offered under a dual licensing scheme: LG' + + 'PL3 or ' + 'MPL1.1.' + '' + + 'The contents of this library are subject to the Mozilla Public L' + + 'icense ' + '(MPL)' + + 'Version 1.1 (the "License"); you may not use this file except in' + + ' compliance' + 'with the License. You may obtain a copy of the License at' + 'http://www.mozilla.org/MPL/' + '' + + 'Alternatively, you may redistribute it and/or modify it under th' + + 'e terms of' + + 'the GNU Lesser General Public License (LGPL) as published by the' + + ' Free ' + 'Software' + + 'Foundation, either version 3 of the License, or (at your option)' + + ' any later' + 'version.' + '' + + 'You should have received a copy of the Lesser GNU General Public' + + ' License' + 'along with TurboPower LockBox 3. If not, see ' + '.' + '' + + 'TurboPower LockBox is distributed in the hope that it will be us' + + 'eful,' + 'but WITHOUT ANY WARRANTY; without even the implied warranty of' + + 'MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. In relation' + + ' to LGPL,' + + 'see the GNU Lesser General Public License for more details. In r' + + 'elation to ' + 'MPL,' + + 'see the MPL License for the specific language governing rights a' + + 'nd ' + 'limitations' + 'under the License.' + '' + + 'The Initial Developer of the Original Code for TurboPower LockBo' + + 'x version 2' + 'and earlier was TurboPower Software.' + '') + ParentFont = False + ReadOnly = True + ScrollBars = ssVertical + TabOrder = 0 + end + end + object tsAuthors: TTabSheet + Caption = 'Authors' + ImageIndex = 4 + DesignSize = ( + 631 + 380) + object Bevel1: TBevel + Left = 328 + Top = 16 + Width = 281 + Height = 257 + end + object imgAuthorPic: TImage + Left = 336 + Top = 24 + Width = 265 + Height = 233 + Stretch = True + end + object lblAuthorEmail: TLabel + Left = 328 + Top = 293 + Width = 150 + Height = 13 + Caption = 'email: sean@seanbdurkin.id.au' + end + object lblAuthorWeb: TLabel + Left = 328 + Top = 312 + Width = 173 + Height = 13 + Caption = 'web: http:\\www.seanbdurkin.id.au' + end + object Label12: TLabel + Left = 175 + Top = 135 + Width = 135 + Height = 13 + Caption = 'Select author to see details.' + Font.Charset = DEFAULT_CHARSET + Font.Color = clWindowText + Font.Height = -11 + Font.Name = 'Tahoma' + Font.Style = [fsItalic] + ParentFont = False + end + object imgSean: TImage + Left = 175 + Top = 272 + Width = 135 + Height = 105 + Picture.Data = { + 0A544A504547496D616765A1220000FFD8FFE000104A46494600010100000100 + 010000FFFE003B43524541544F523A2067642D6A7065672076312E3020287573 + 696E6720494A47204A50454720763632292C207175616C697479203D2038350A + FFDB0043000503040404030504040405050506070C08070707070F0B0B090C11 + 0F1212110F111113161C1713141A1511111821181A1D1D1F1F1F13172224221E + 241C1E1F1EFFDB0043010505050706070E08080E1E1411141E1E1E1E1E1E1E1E + 1E1E1E1E1E1E1E1E1E1E1E1E1E1E1E1E1E1E1E1E1E1E1E1E1E1E1E1E1E1E1E1E + 1E1E1E1E1E1E1E1E1E1EFFC0001108009600C803012200021101031101FFC400 + 1F0000010501010101010100000000000000000102030405060708090A0BFFC4 + 00B5100002010303020403050504040000017D01020300041105122131410613 + 516107227114328191A1082342B1C11552D1F02433627282090A161718191A25 + 262728292A3435363738393A434445464748494A535455565758595A63646566 + 6768696A737475767778797A838485868788898A92939495969798999AA2A3A4 + A5A6A7A8A9AAB2B3B4B5B6B7B8B9BAC2C3C4C5C6C7C8C9CAD2D3D4D5D6D7D8D9 + DAE1E2E3E4E5E6E7E8E9EAF1F2F3F4F5F6F7F8F9FAFFC4001F01000301010101 + 01010101010000000000000102030405060708090A0BFFC400B5110002010204 + 0403040705040400010277000102031104052131061241510761711322328108 + 144291A1B1C109233352F0156272D10A162434E125F11718191A262728292A35 + 363738393A434445464748494A535455565758595A636465666768696A737475 + 767778797A82838485868788898A92939495969798999AA2A3A4A5A6A7A8A9AA + B2B3B4B5B6B7B8B9BAC2C3C4C5C6C7C8C9CAD2D3D4D5D6D7D8D9DAE2E3E4E5E6 + E7E8E9EAF2F3F4F5F6F7F8F9FAFFDA000C03010002110311003F00BFFD9761D5 + AD23C9F48EB5347D2ECA55BEB74B58F0F6CCC4141C85C3E3F4A6C16AFB0679FF + 008155DD3E596CEE7CE891188565219C720820FE86BAD62277D5A3C154CC53A6 + D86C286D1318C6368AC5F14682354B609E4C823B64DD085DA4B3E785F61D7F13 + 5DA0B06683ED20DB955201CB648CF4E3AD2A40C8C30F0020E7023269C7112525 + CD2452A4731A3787B50D32582E6FB4EFB30B98010B90DBC027938CE3918AD587 + 4FB6370AD25A6F55C360000D6A45AA5DEAB732D85D0862FECE3E5445108DE87E + 6CF3EE48A9042CB70BFBDE1D48C81D306B49626F37690FD92B18F69A6A321636 + CCEDBC92DB01E41EF489A2592C8CCF670925B2094008AD74B460645131387CF4 + C75029DF66508499DB77A0C5672C4A4FE2295245686CEDBFE11FBBD31E3411CA + 155540FE1C9CE38EB922B061F0A6990808F24857797C67B9FC2BA609174DF233 + 7A0C7353269F348372595C30F65FFEB50B129FDA6CA50473BAFE81A2EA178F32 + F9A8CDC92149E71CD67A784B4FDA079B3301C7FABE6BB7FECCB803F77A75D6EF + 528697FB2F50DD81617457D7691FCEAFDADF64CAB7738A4F09E9C06079BC7765 + 02A61A1DB2C0B6EEF3BC4BD00403FA5760744D4DC8DBA7CBF8B81FD69DFF0008 + E6AE4F16417EB28FF1A7CEDFD962B23839FC3F66650E25BF461D36550B9F0AE9 + AE863617AC0F43E58C8E73D715E9ABE1BD6727FD1EDD7FDE9295BC37A9F19FB2 + 2FAE5F354A72FE564D958F39D3F49D26C63655F3A5263319DF1EEC83F863B554 + 5D1742482587EC1248247DE5CA0C83E838E057A69F0F5E98CFEFAD01CF19627F + A5413F872F1B1B6F6D233DCED63FD2B684E4B683FBC4F5EA7975C68DA0B218E4 + B49C02724EEC1FE551C3A2F87E199654B5B82CA00E65AF4A97C3339CEFBDB76F + FB646A183C38D0DCACA67B5751D51A0C835BC5B7BD37F791E57388920D1CED0B + A7AF049EA71F4C7E3552FEDF4968E412DA91197F318190E335EB5259E8EA38B1 + 801F68C5675D5A58B4CACB671796321D360C37A56F75FCA5F2F99F3F5C2A5ADE + 5C4314322A383220917B67B7EB5CFC6CC751793242A8EA0E39AFA2358F0F6877 + D2666D34E3615CA395C66BC87E23E8963A2EA515A69EAEA8F1EE218E4E493DEB + 92B45A5CC7760145D45139792FAE26D57ED93383BFE5E8071D33FA51515C43B8 + 6DE807028AC15568F52A60F99DD1F49430B91879D463DAACAC46307F781B3504 + 2D16702353F874AB01CA81F28C1AF0F9CF9C4D0E45C0DE64C67DA9EF24A1015C + 818EB8EB509600672A09FD69E27D8497642A3F8693931A64BE6C823C19B1BBAE + 1464F5FF001A8A55DCC5BCF909C6305B1FCA88EE049B444A9CF1D3352CC5608B + E74C13D772F34F9A5B8D14FECA5DC6F9A558B3F36189CFEB5A96CFA0C0CBBAD2 + F6E081CA99428FE64FEB548DE5A11F300481D0362A39AEE1908C14181CE5B914 + 955921EFD4E92D7C4DA6DA7FC7BF87CAE3BAB293FAD595F1D6080745947FDB50 + 3FA572B148A176E771CE48032453DB6B723818CF35BC717552D3F21DA47473F8 + E6E379F2745CAF6CDCE0FE82A03E36D488FF00901420FA9B9247F2AC18C37999 + C863EA31FE344C5901210B76E303F5AD6189C44DD930B3EA6BCFE36D5B195D3A + CD73EB231E7F0AA67C67E203F7E2D387B0573FFB356740F713CFB1ADE2500801 + B764F6F6FAD6C1F0F5C981648D958E33B3B1FC6B593C52DD8724994EEBC69E20 + 3811C1A78CF7F298FF00ECD5567F16788DF0A05AC7C60ED83AFE66967B730395 + 75C30E0AEDC1150491A2953E530079C9AE778BABB5C9E413FE127F14845C4B6C + 31C716E39FD6AB5E788BC4CE706F047EF1C03FC2A49B87E58A83DB355A653C7C + DCE78E69FD6EAF70E4B08BAF788D23C35F2C83D4C4B9FE5548EA5AF33973A8DC + B363A0DA00FC31564A2AEE2D26187AF355E4906E01543EDEFC62AD62AA3EAC39 + 511BEA1AF32026FEE32BCF6AD8D33C44362C7A9028DD3CD03AFD4563498C0DAA + 13270727A550BA0E412B8243606071571C4D45ADC1687A3431C57718920B8491 + 4F4C357897C5DB8B77F1A4968926F9608950AE0E738C9FD0D6EBCF776E018D8A + 9519F94E0D54D5B539E7D1B5396E2DE27921B5771332032121481F375C735D74 + EB7B66A2CEAA189F632E74B53CB65BDB767DAB3863E983456C781AC9EF6E9EE6 + 21124B34BB17781C0C1C007B738E68AEC860B9E37B9D52CD6A2765147D0969A3 + 6AF3925747BD44038674D80FE2D571348BE8817B8B8D32D531F766BD40C0FAF0 + 4D79BCB737F70333DFDC4C7BEF90B7F3A62A0382646AF3161208F0D56B1EADA5 + 7832EB5B4325BF89F4AE49F9617DE47B74156AF3E186AB0EC911FED841195597 + 6822BCA6DDBCA394770C3B86C5747A578C3C41A6B0FB3EAD745474477DE3F26C + D37878762E35E3D51DA4BA1DD68503C963A3E66C0C2C80E33F53D6B12EA7D425 + 320BED1D189EE8BDFEB9AD5D2FE2DEA91A84BEB2B7B951C12BF21FEA2B7AD3E2 + 07847524DBA9698D6EC7A9F2C30FCC73533A4EDA1D11AB4A5D4F33BC0D3CA5FC + B58C0FE1552A38FC6AFE8905ACD76B05E5D0B3B7DA59E531973C761CF26BD322 + B6F03EAA3FD0B518A3723014C807E8DCD4571F0EE39017B4B98D95B9195C7EB9 + AE6F6128CB99EA57B1E6F859E6B742DFCD296CF3797D371F94B7E55242B1A8C0 + 270075620D677C43BFBFF08789C69256331AC3E73EF0183A9F43FE7BD68F876F + 34AD7ED11AD6430C8065E02016FC3B91533C3CE5EF2FB871A525A5C963727E54 + DA7071FDDA9A6C1503A05E83FAD43AAC50E99FBD9A57C16C246172CC7D05451C + F7F38FF47D31D87ABBE00FCB3FE71F8766069B8C5C98DC5AD197EC222D28938C + 839AEFBC3AA93C0237623D31C8AE174DB996200CFA75C28F55C1381D4900E7E8 + 064D75FA05E5A2CC14C5716CE7B3A11EF8F4248E700935D4F53582B157E20693 + 15B5AC5A908C86CF9726DEFC120FE95C5492A142A15F775E7201AF5AF1ADB457 + 3E11BAF9D5963C49B81CE3079FEB5E3F70D66EE63595CA76C3F15E6626294EE8 + 271B32332EC28B21E4F4EA71F8D2B61B3823183824E055694B40DB77EF41C105 + 371A8967678A42AD9EA4809815CC88B21E614909FDEEDC9EC739A8A4B0433644 + ED00070C40E3EB559A4530AE09574FF9E631519C18CC8667738C7CCB8EFF005A + B5A13644B756CF131412AB8CF563542585836641BB3C8DAD906A46F30264AAB3 + 8EBD4E7D2AA4826DC91966DEDCA81C63E95684D219710A0E45BA83FEF573F3DD + 4D7771AA6956B1A102CDC367AB3120003E99AB7E26BE9F48B4DEC11DB3B14337 + 39FA573F672A69D68F737F762DEE6EC028EC7AAE4123A1EA715E960A3152E664 + CA3A1178751B48F114AEF13959DCF916E80B2AFCEBF31E7B74A2A1D0F59B27BB + BEB8BEF2EEADACA259148046E618E40E3E5C81C7D28AF55548C7664DA4F73E8E + F0D699E12F1B7815FC4361A3269D7928923F29242C91C8338C027BF1F9D7946F + 607B0AE73C1FABDF43A4BD8C377709124A5F62C842E4F7C7E15A8B3B9393D7A9 + C9AF1A8C2716F99DD7430C45484EDCAACFA9A2AE4F2302A6561C1C9FC2B39266 + EE7F5A9526E99FE75B9CD63411FD0D4D14BC1E09AA11CA4938E2A4F30F1C7E23 + 8A4D8F94D38EE0F518AD8D2FC51ADE9B8165AA5C42A3F84392BF91E2B95598E4 + FB558B52F348114649EC0734B42A29AD84F8A7A9DFF885E1D5AF5D259E08BC87 + 655DBB90927271E84D723A76A9347B678A668E5886DCA8C1C8F43DC5761AE3DB + 5843B2EBCBF98619739AE03508A28EE2496C65F3620BF2AFF4F5A5A23D3C3F33 + 5691E97E0EF8ACED24969AEDA3CBE5FC8B7511F981ED953C362BD1ED3C51A3DD + C092C177685FA11E5F90DF81E467DB8AF08F0C7D965D334D7B98DDDD2FC839E9 + B0F247E6C3F2AEB75CD6B41B2536D0C44A73B846B9C7E14FDA58EA744F608AF6 + CE68A3E6DE653D48963C8FAF2BFD6A6175A5DB484066872792264DBFA363F3AF + 9D59EC6EFF00796970EA0FF0E4A9155A6D3219DBCB9AED883D8C949D5452C3BE + E7D0BAAF8AB40B3B09E27D4EDA069A33137993205652318C06C7A738FE66BCDA + EBC45E11B201A4D724BA7CF31DADBE7FF1E3815E49E35D1AE2CD2278E3CC2FC2 + B67BE2B36C03AA6D90E4AF15949467AB4274EDB9EB63E21784526F2934AD51B3 + CB48D2A211EF800D6FC56C2EA34BBD3AE18C13279885D7F84FAF3D783C5785D9 + DB5CEA3A9C56B650BCB2CAC238D1392C4FA63AD7D0FA7F86757D1343B4B49038 + 30C20365481BBA9C1FC4D44E8AB6888E589873E9F731B65F63FF00BAFB78AA37 + 1697990EB1C58C7DD639FD4D6D4F1DF281E75BB3A06078E45464C51CA51AD98F + 1D43E7159BA5A09D34CE78B4C939DF11453FDD395155354331CCD19E4F01564C + 022BAA996D766DB947453F2827B1FAD67EA76F630D9CF3A08418A2665F9BAF1D + 3EB42A6C8F647946A66EB5CD71E348894B50030DC09CE79FAF35278B34E8B579 + 2DE38D1E092150AC7A8E7DAB7FE1B5B40344BABE96249269A739666E8063B7D4 + 9ABB2C7135D92B1850ED918AEE8C6DE88231BB3CF353F074B6565892F16472BE + 67968A46E5CFFF005A8AF46BD459E5DAE21DAA9B5776413ED9A2A79E5729B69E + 8713E186FF00489906705437F9FCEBA20873900D416B043090D146AB918240E4 + D68E06D04364F7A5A9E3BD752103201191F5F5A9109E3279A02FCDD6A545F607 + 3DC8E954090E52E471FCEA6456C0F9B27D2A38D0E739EB52AAB0FE94AE5F292A + 67A60935BBA1A2A40D394C391C63A81FFD7AC6B404CCAAD9C138AD8B3BA8ECA4 + 9D653B82283B3BE00C01FE7B9A994EC7461E9734AECE6BC57A75CDC169E4F914 + F6EB81FE26B84921B9B6BBC0C804D7A9EA7A8F9F7204AA8222B9E3D7DBD85735 + 7D66D737AAB142AC33D477150E47A94E262DBEA779A55DDB488E4C12CAA5C380 + 70738C8CD43ADC0B339322A891BEF6E1C8AE8FC51E1D962F0D3DD344E9F38232 + A719AC24BFB89ECED99E24951465CEDCB003AD10926CE8E5B9B1F0FBC317DA85 + ADF3C0A66091EE41F37240248183E82B9F9F48D6A3B9F32790AC6CD9DD95618F + A1AF53F03F8C23F0CB444586F55E7318182318EF5C56A37B6DA878A64956DDA0 + 124A59608DB708F9C8145D5EE5722B17F5AB2D4E6F878F2DEC4585990CB28182 + 037CA377A020FAF1F8F1C1595B5D5D4812142ABBB963C0C7D6BDA3C6535E5B78 + 4ACD2DE078B4DBBF96E59C02AEE082AAC7B1E38AE1CA3038D898F4E98A74A375 + 738B175FD9BE548E93E13EABA2782AE9AEAEF4E5BEB971813ABE1A21E8A0F1F8 + F5AF65D3BE2AF846E11733CD0CAC71B264C01F8F4AF9D4C71F523F5A0ECCF218 + 7E35D7176D0F3BDB49BBB3E9B6D4F41D61166486C27EFBD1867F4AC6BDF0DE94 + C0CD6D2CB13375E372FE58AF03B5BB7B4915E09E68987428E4735D5693F10F5E + B3D9E74F1DD45FDC997391F518AB5C8F7435599D86B3A15D24656DCC33467B1C + AFE86B81F11E91791DABACB6AEA1815F9549033DF35EA7F0FBC61A4F8A24B9B4 + 9EDEDEC2F6040E37B7CB203DC13FD6BA2D6AD8DB69EF7305A473BF965D78183E + FD7A552A307B1AFB595AE7CE9F0BF42F104F35CD8269EAF6F10693CC97853D38 + 5F56EF8F6AB5A8595EC2D3016D3895094DBB7057D6BE83D0E0FB4686B2A59C31 + 1DDBE711E386F51597AD6871EA57F25CB49345238002900AF0302B49D25CB65B + 8E9D5777747CF4D67A9EF60095C8FE31C8A2BD7B51F0BDEC19D924336063AE0F + EB4564A93EC6DCE8F1B8CEDC0E0D384E338E49AF57D13E10DA184C97FA85C48C + 1B185411AFE679ABCBA2783BC3727EFB4FB6BA994700932E0F3D49E3D3A578D5 + 332C3C34E6D4CE9E575A7AD8F2FD274AD5B530A74FD2EF2E5738DF1C44AE7EBD + 2BA483E1FF008BDA5549F4AFB386C61A695547F3AEC742F8D3E1AD1DAE6CB56D + 3E4B548199614822055C751C7638A6DC7ED07A65EEA569A6E97A1C862B999226 + 96770BE5866DB90A33D01CD72CB30AD2D634F4FEBA9BAC0528B4A52D4834EF84 + FA910A6FAE9533C958632E40FA9C0AEB744F861E18B7883EA0D7371203F76490 + 28FC97FC6BA48EEA49402F231F6CD39A7545CB3051EA4D7835B3FAD2D22AC7B9 + 4B27A30DC934FD1BC31A601F62D22D558746F2813F99E6BC53E3A4D6969E217B + FB2C46F2C6BE66D3D597207F4FCABB7F1878DB4FB146B582F23331E18A1DC57D + B8EF5E31F10356B7D56D234058481CAA96FE227B57565B53175AAA9CD3B7A0B1 + 30C3528F245AB9D2F8223B2BED0E092E624959941C919E6BA3D3ED34E8AF95A2 + B684B8E85945727E0BD969E0F8A63148DE5A959028E548E39AB1A06A936A5A88 + 4B3B69400E1773640CFE35F40D36B43892499D77C47D3AE354F0B456F671177F + 9A470178C01DFF000FE95F3B680DE4EBF369EF90CB230507F5AFA7B46D1FC53F + F0971B3D4FCA4D382F18E4B7EBDEBE59F8911C9A27C4CD6A3B57DA6DB5097CBF + 65DC481F91155878BBB4CA9BB59A3D1F49B012BC7662DAF82BF04444631F9715 + A33F8505BF8BAD21D36DC470CA32DB9B710C7EF331FD6B81D17E2A4D63224B26 + 9D99178F95F835575EF891AD6A9E7F927EC4B3FCAE50FCFB7FBA0F61F4AD9C24 + DD909D48D8F40F8CDE3FB582CFFE10EF0DCC925AC6A12F2E3821D81C951F88E4 + FE15C1695AB2DD42A3E5F371F2E78DE3D6B8991DA793CB53F2FF001B7F4A23BD + 297D198988553B57E95D54A9A82B1C35D7B67A9DE9BA98920C2722869A4206D8 + CFE754ECAED6ED152462B263A8EF5335B5CF244A715A3858F3270E57A8F124C4 + 7DD53F534D6927191B52A2782E94FF00AD19A6341764FF00AEC134D585645CB1 + BFBCB1BE8EEA0645910FD430EE0FA8AF60F0AFC45D2858137777E46D87CA36D3 + B651493D41F4EBC5787BD94A7EFDC1FC2A27D3378C35D4BCD3D774690925A33D + FBC4DE26BCB0F06DD6A1A65C9837DC2ADA9539DC99C8CFFE3DFA571FA6FC57F1 + 042BB6F62B6BB53D7828DFA570B25EDFC9A74565717B2CF0C472A1CF4AAADB71 + C753D6B48CA5D424D5F43D667F88B04CC9FBC58A5750DB71B80F6268AF23672A + 78F5A2B68CDA4099F4AF897576B68FC9898F9A579627A0AF3BD52ECB31677FC4 + 9AE7F5AF18EABAA4A65668E0046311AF6FA9AC296E1A662D2C8ECC7D4E6BE0B0 + B9055DE6D2FC4FA0AF9CD25F026FF0313C712A1D66631B060C55B8FF007706A7 + BFF1635E685A2696BA75A5B9D29999278A301E4276E4B1EA7EE83CF7ACDF1529 + 370AE07541FA1AC74CD7D1D2C37B3A7ECF73C7A95BDA4B9F63DF6EBE25EB9709 + 8B6305B29FEE2E4FE66B06FF005ED5F5027ED7A8CF303D99CE3F2E95CED8AEEB + 385F39DD1A9FD2AE4319623E524E6B2A597E1E8BF72089A98DAF53E293256936 + 82CCD803935CAF8875390C90C91E06C62507F5FAD5BF136A6D6EC96898C1197C + 7F2AB9F0F343B4D66F9F56D6264834BB020BEF04F9D21E88A072DD3381ED5E94 + 29A8C6EF70A517F133B2F847AADCAE9F2C37B6D208DE313A65490C992B93F523 + BF5C1AE9BFB7ADE1D4336B0A42A83230870CD9E3A03567C3BA8C335F46C9672C + 488BE4F9536DDCD18E870381F4ADABDF0E5BBCA64B4448D5CFCCA47CBF976AC3 + 114395F34754CEDC26239AF0A8AD25D09AEF51D5B54D434BD62D0CB02B010DC9 + 242AB639C819CF4CF2476AF22F13E9FA06ADADCB3EB3A35F896E2E26679A2952 + 321C1E7B12CB907823A743EBEA97FB34BF267BA794D9DAA37EEE08F9919BAED1 + DCE38CFD6B84BDBAD4751D4B6D8E9D059EE7253F75E7DC863C925BA02727E959 + 7B0F671527BBFCBF32D621D6A9251F81697BDB5FEBA1C27C52F8612785EC2D35 + AB19646D36EFE40B3303247201F30E3195F46C0F43EFE6E6272DB7A0F5AFB3AD + 2D6DD74792F3C43E66AB35E21B7586E31BEE40E044074541D59BD727AD786FC7 + 4F86727856D21F12E9D1C71585E5C323DBC6C4A40C725550B7CCCB80464F71EF + 5A539A7A03565BFF005E5DCF24B871140238F827AFD2A9AB95704019CD49312C + DB8E6AB927CC503A9200AE9488B1D55A4C639D4671902BA5B0BB336222C38191 + 9EF5C733E0EFCF03083FAD6A69F7412412FDE09BB8270395EBF81E6B4DD58E6A + B0E6474AC4E7E61DE91CA8E7033ED4CB5952E6149A339461914AEDB4F1C56691 + C16B0D727A0C5577508D923DE89A465CE1370F5CD35D811D73FA55A1A423B824 + F1D2A22C09E7AF7A490E3B64544EF9CF1548A48467C6475A2A3192C013B47A9E + 9455AB976351588C64558B485EE2748A304BB9C00055089B1D4F38E95D278782 + C5652DEC9C393E5C5CF6EE7FA514287B5928A39A72E55734E2D374DB389435BC + 37138E1A4750DF80CF41524F25B2C584B5B5F420C4BCFE9591717ADE708F7723 + 19E7D6A49E554EA4F4AF7E308538D923952727A914CD6C461112123A05185FCB + B559B5D2359BCB46974D52ACBC2C9BF6E3E87D6B5FC05E0FB9F11DF2DD5CA347 + 64ADC03D64FF00EB57B7D8781ED9ACD52394C785C280A36E3E82BC0C754A4A7E + EAD7F03D5C361A4D5D9F206B7A0EAD60EF25DD8CA067264FBC0FBE6BD7BC13A0 + 47A6F866C23D46708FB7CC8E18230F34923E090B8EBC6D0589C2EDAECFC79E19 + 7D09E36908961990E4E38CFA7F2AE2AD2DE7D26D2DEF93534B0452D2C51CB3AA + 2618F641F31C802B8A5539D58F4943975BD859359D48CEA9A7E9963A784F936C + D199A7246796208C1C1E83D057556FAB6B17B67141F6590B940ACC91B286C77E + 7FC6B91D7B58BFD7241A8694534DB372774365F28041CE5A4700E4E3DAACE91A + 75E6A8079BABDC4F1487059B52250B7718079EF4A355D356BA5F8FE7FE663570 + F4E5AB497FE05FA69F81D078935582DA4FECF9ECEE350BA4841710CCAB1A31FE + 1673DFD42E6B91BCBAD5EF27863574B1B5F3189B7B17F2C7033F34A7963815D6 + 5D68D7363AD3B4BA5D9CD62634862BA595A4469446BF285E3A7EB5CD78E2C6E2 + 5749B54BA63A6473652268824484AB00000325BB67DEB1E6BCB5EBD5EBF76AFF + 0047E66D4D422F963D3FADACADF89ADE11BDF13EB97915E79564ECEA89040ECD + 2048872AA154741DFE6193926B9BF8F5E3DD463B6BDD025B292EAE6466B5B9BE + BA8D4247B48DD1C118E179039EBD0FA1AF5BF8272241A1695F28566B6407D41C + 735E03FB55D89B1F8C1A9B0C88EEE38AE547604C6149FC4A1AB86B3B5ADE874C + AC95D2FEBF43C9247DC38E0F715024804C1B1CAF34E9FE5391D6A183E690BB74 + CE2BB1230B1B8E76E9D1E4F232EC6A5D3A4F3A1039C17C0F7C0C9ACBBCB83E48 + 8BA93DAB46C1BC836EBD76A9661F5AA462E3A1BDE10BB0FA384627744E54E3EB + 5AC5F2393C561FC3DD3351D4F57D4ED34CB669CC48D2945EB80C0703BF5AD894 + 4B14CD1CB1B46EA70C8CB820FA1159F346F6BEA7256A4D4AF6D1892ED0383CE2 + A26EE72682C0E40C546DB867241CF3D6ACC6C23AB1C8CD44E4827A9A7070382A + 703BD465CE76838E791E9548AB114AEDBBBD14C9587396068AB2AC5F57C9C1E6 + B6A39D96CA28178D899FC4F35CEDABB34A898CE4815AB0399A66F4EDCD7A197D + 3D5C8E3ACBA132485B5A82227899037D08CFFF005ABABF0AE8975E26D58B790E + 2D607DA40CFEF0FF009EB5A5F0FBE1CDD7882E20BFBB2F05BC41B6E061A40C39 + FA0AF6C68B42F03E81F6B9A3448E11B638D71973D87D6B3C6636DFBB86E74E1B + 0D7F7E44DE1BD1EDF48B28E4BA78A050BFC4DB547B55EB9F1769B677F2D9C72C + 212DEDCDC5C4EC7E448C67278FA1FC6BCF9FC4373ADDF0BBBC551DA38C0CAC43 + D07BFBD3B5CB0B792D2ED587909771086774F41CA93EA01FCEB91E5929C6EDEA + 6EB3084656B68757E26BDD37C57A088A6BD82D6D6EB9B399971237192C173D31 + 5C569DF0EAEAC9A5617115DC6CB9C24011CAFD49249C7BD56B2D2AE24F1469F7 + 77D016B7D36C0436EEB27CBE61E738EE324F06BAD97C4D36830CF797F0BDC44D + FF002D214276FA02BDBF957055C257A4B45A1E852C6516ED17A9E19AED93DB78 + 9645496F63B08E4476F257746AD8E18AF3CF38CE2BB4D1B4196E2EE0BAD35AC2 + E218E36DA8A8119D9863767382707DB35CB5B6B57F73ADEA3ADDB42EF05D4C5A + 4B603E78C678C0EFC7A5757A15CDA4CC973A45CF9126E1E6C247CAC7FDDEAAD5 + 4A2D5BC8AA894A3AECCDCF0E6B86DEFA6D1F5651E4CCC1648DC15789C281903A + A9C0E08FC3AD70DF11BC37FF0008AEA91CF733497B6D2CAAD6B2BDCB192553D4 + 7CD9008079F6E7BD7B0DA4567AB5828D534FB6BBB884F1E6282E07B679AE67E2 + EDA4373E0B5B7B5043C12EF83CC1BF66074E7B52A93E69DD697DC9C3D274A1C9 + 7BDBF222F851A80934EB4DA891EC62A551B2170DD327DB15E5DFB60A4A7E245B + 5C3AFEEA4D36311B7AE19F3FCEBB1F85F7974FA716B92FE679C70EC81370E3A0 + 1C7B7E1585FB60461FFE119BA1F7CC53AE7D71B38FD6B28E9511BF2FBACF9DE7 + 3C1CD410B703EB524E7838FC455553851F9D7A114649172DFF007D7433C81C9F + A56C42E0C8CC7D2B1AD76C7186624166EBE95A5E608A3DDB890470693467247A + CFECBEB1B78F35766751FE8A42E4E0F2EBD3F2AF70F17F82B45F11C44DD4221B + 9030B731001B3EFEA3EB5F2C7C1FD424B7F16CC52428D2C6D820F7041FE95F48 + 7877C5F226D87503B97FBFDEBE5732A93A58BE68BB688F4E8528CE8D9AB9E59E + 31F026AFE1C6695A3FB5D97559E21903FDE1DAB8D949248C0F402BEB486E2D75 + 0818A0578D8639E73F8579EF8DBE18586A3BEEF47DB6774724A63F76E7E9FC3F + 8715D785CD6FEED5FBCE0AF9735AD3FB8F0594E0600A8DDF68E1BFFAF5AFE23D + 0F53D16ECDBEA36B240FD149E55FE87B8AC575C2E4FF00FAABDD849495D1E6BA + 6D3B320773CE68A64806320E28AD07645BD127F3EEBA005509E8076C7F5AEC7E + 1B58C5A97896286700C4B99197FBD8EDF9E28A2BD4A2F970CDA38A493A963E96 + F094E2DA211AA0C1E062BCCBE3C5F5EFFC26BA5584B20366D179C8AA4E490483 + 9FC40FCA8A2BCAA293AE8F466DFB3658F0EA19619501E550904D5AD1F577BDF3 + 2D6752CD10DA49E847F8D1457BD4FA9E0C8D0D32E58235ABB31087683EC7A569 + 584F23808C41218A9E3834514DABA649C8F8FBC2691DA3EBBA14A9633407CC9A + 139F2DD73CE31D0E79C74FA561D86A8D3DC08AF208FED0AB8F363EE3F4A28AF2 + 31308C5E88F6F05525387BCF63A5D335494DDC7102ECC063731EA2B5359BB37B + 6A90CAB91CF5A28AF325B9E8A6CC3F0DC11DA5DCF0C4311EF0C07A67AD627ED5 + 76135E68FA0CE8E8AB6E25CE49CFCDB318FCA8A2A3FE5EA358FC2CF9B2788E48 + 2467A6455508378CF38A28AEE44A2D25BAC8990C47B1A6798C10C192429C8CF6 + A28AA666B5353C0170D078B6D1867E69369FC4115EEF6F21DB4515F299DA5ED9 + 7A1EB60DFBACD8D3355BAD3E4578A46C0ED9E2BBBD0F5B1A820DD1156C738A28 + AF2A06D31FAF695A7EAD66D6B7D6D1CF1B0E8EB9C7B8F435E13F127C069A0C2F + 7F63741AD7760C726772FD0F71F5A28AF5B2DAB38D4514F4670E321171BDB53C + DA66209F4EF451457D427A1E3D8FFFD9} + Visible = False + end + object Memo4: TMemo + Left = 8 + Top = 8 + Width = 161 + Height = 369 + Anchors = [akLeft, akTop, akBottom] + Lines.Strings = ( + 'To the right is a list of authors ' + 'and contributors to ' + 'TurboPower LockBox 3.' + 'Not included are the authors ' + 'of LockBox 1 & 2, as there is ' + 'no common' + 'copyrightable content ' + 'between them and LockBox 3.' + '' + 'The LockBox 3 project ' + 'welcomes any contributions. If ' + 'you wish to contribute,' + 'and your contributions are ' + 'accepted, your details can, if ' + 'you request, be' + 'added to this list of authors.') + TabOrder = 0 + end + object lbxAuthors: TListBox + Left = 175 + Top = 8 + Width = 138 + Height = 121 + ItemHeight = 13 + Items.Strings = ( + 'Sean B. Durkin' + 'David Barton') + TabOrder = 1 + OnClick = lbxAuthorsClick + end + end + object tsSupport: TTabSheet + Caption = 'Support' + ImageIndex = 5 + object memoSupport: TMemo + Left = 3 + Top = 24 + Width = 286 + Height = 161 + Color = clInfoBk + Font.Charset = DEFAULT_CHARSET + Font.Color = clWindowText + Font.Height = -16 + Font.Name = 'Tahoma' + Font.Style = [] + Lines.Strings = ( + 'Support can be obtained through the ' + 'forums at:' + 'http://lockbox.seanbdurkin.id.au/tiki-f' + 'orums.php') + ParentFont = False + ReadOnly = True + TabOrder = 0 + end + object memoHelp: TMemo + Left = 295 + Top = 24 + Width = 333 + Height = 161 + Color = clInfoBk + Font.Charset = DEFAULT_CHARSET + Font.Color = clWindowText + Font.Height = -16 + Font.Name = 'Tahoma' + Font.Style = [] + Lines.Strings = ( + 'User help for this component suite' + 'can be found at' + 'http://lockbox.seanbdurkin.id.au/LB3Help_H' + 'ome .' + 'If the help is still partially' + 'under construction, please either be' + 'patient, or offer your own content.' + '') + ParentFont = False + ReadOnly = True + TabOrder = 1 + end + end + object tsAlgorithms: TTabSheet + Caption = 'Algorithms' + ImageIndex = 6 + object Panel1: TPanel + Left = 3 + Top = 16 + Width = 270 + Height = 209 + Color = clYellow + Font.Charset = DEFAULT_CHARSET + Font.Color = clNone + Font.Height = -11 + Font.Name = 'Tahoma' + Font.Style = [] + ParentBackground = False + ParentFont = False + TabOrder = 0 + object Label13: TLabel + Left = 16 + Top = 0 + Width = 116 + Height = 13 + Caption = 'About selected Hash' + Font.Charset = DEFAULT_CHARSET + Font.Color = clBlue + Font.Height = -11 + Font.Name = 'Tahoma' + Font.Style = [fsBold] + ParentFont = False + end + object lblHashDisplayName: TLabel + Left = 24 + Top = 24 + Width = 61 + Height = 13 + Caption = 'DisplayName' + Font.Charset = DEFAULT_CHARSET + Font.Color = clBlack + Font.Height = -11 + Font.Name = 'Tahoma' + Font.Style = [] + ParentFont = False + end + object Label15: TLabel + Left = 14 + Top = 43 + Width = 47 + Height = 13 + Caption = 'Features:' + end + object lblHashDefinitionURL: TLabel + Left = 16 + Top = 112 + Width = 59 + Height = 13 + Cursor = crHandPoint + Caption = 'definition url' + Font.Charset = DEFAULT_CHARSET + Font.Color = clNone + Font.Height = -11 + Font.Name = 'Tahoma' + Font.Style = [fsUnderline] + ParentFont = False + OnClick = OnURL_Click + end + object lblHashWikipediaURL: TLabel + Left = 16 + Top = 136 + Width = 58 + Height = 13 + Cursor = crHandPoint + Caption = 'wikipedia url' + Font.Charset = DEFAULT_CHARSET + Font.Color = clNone + Font.Height = -11 + Font.Name = 'Tahoma' + Font.Style = [fsUnderline] + ParentFont = False + OnClick = OnURL_Click + end + object lblHashBlockSize: TLabel + Left = 16 + Top = 160 + Width = 97 + Height = 13 + Caption = 'Block size = 128 bits' + end + object lblHashDigestSize: TLabel + Left = 16 + Top = 184 + Width = 97 + Height = 13 + Caption = 'Digest size = 64 bits' + end + object lbxHashFeatures: TListBox + Left = 67 + Top = 40 + Width = 182 + Height = 65 + ItemHeight = 13 + TabOrder = 0 + end + end + object pnlCipherDescription: TPanel + Left = 299 + Top = 16 + Width = 270 + Height = 209 + Color = clYellow + Font.Charset = DEFAULT_CHARSET + Font.Color = clNone + Font.Height = -11 + Font.Name = 'Tahoma' + Font.Style = [] + ParentBackground = False + ParentFont = False + TabOrder = 1 + object Label20: TLabel + Left = 16 + Top = 0 + Width = 124 + Height = 13 + Caption = 'About selected Cipher' + Font.Charset = DEFAULT_CHARSET + Font.Color = clBlue + Font.Height = -11 + Font.Name = 'Tahoma' + Font.Style = [fsBold] + ParentFont = False + end + object lblCipherDisplayName: TLabel + Left = 24 + Top = 24 + Width = 61 + Height = 13 + Caption = 'DisplayName' + Font.Charset = DEFAULT_CHARSET + Font.Color = clBlack + Font.Height = -11 + Font.Name = 'Tahoma' + Font.Style = [] + ParentFont = False + end + object Label22: TLabel + Left = 14 + Top = 43 + Width = 47 + Height = 13 + Caption = 'Features:' + end + object lblCipherDefinitionURL: TLabel + Left = 16 + Top = 112 + Width = 59 + Height = 13 + Cursor = crHandPoint + Caption = 'definition url' + Font.Charset = DEFAULT_CHARSET + Font.Color = clNone + Font.Height = -11 + Font.Name = 'Tahoma' + Font.Style = [fsUnderline] + ParentFont = False + OnClick = OnURL_Click + end + object lblCipherWikipediaURL: TLabel + Left = 16 + Top = 141 + Width = 58 + Height = 13 + Cursor = crHandPoint + Caption = 'wikipedia url' + Font.Charset = DEFAULT_CHARSET + Font.Color = clNone + Font.Height = -11 + Font.Name = 'Tahoma' + Font.Style = [fsUnderline] + ParentFont = False + OnClick = OnURL_Click + end + object lblCipherBlockSize: TLabel + Left = 16 + Top = 160 + Width = 97 + Height = 13 + Caption = 'Block size = 128 bits' + end + object lbxCipherFeatures: TListBox + Left = 67 + Top = 40 + Width = 182 + Height = 65 + ItemHeight = 13 + TabOrder = 0 + end + object memoExtraCipherDescription: TMemo + Left = 16 + Top = 192 + Width = 233 + Height = 89 + Lines.Strings = ( + 'Extra Cipher Description') + ParentColor = True + ReadOnly = True + ScrollBars = ssVertical + TabOrder = 1 + Visible = False + end + end + object Panel3: TPanel + Left = 3 + Top = 231 + Width = 270 + Height = 146 + Color = clYellow + Font.Charset = DEFAULT_CHARSET + Font.Color = clNone + Font.Height = -11 + Font.Name = 'Tahoma' + Font.Style = [] + ParentBackground = False + ParentFont = False + TabOrder = 2 + object Label27: TLabel + Left = 16 + Top = 0 + Width = 170 + Height = 13 + Caption = 'About selected Chaining Mode' + Font.Charset = DEFAULT_CHARSET + Font.Color = clBlue + Font.Height = -11 + Font.Name = 'Tahoma' + Font.Style = [fsBold] + ParentFont = False + end + object lblChainName: TLabel + Left = 24 + Top = 24 + Width = 61 + Height = 13 + Caption = 'DisplayName' + Font.Charset = DEFAULT_CHARSET + Font.Color = clBlack + Font.Height = -11 + Font.Name = 'Tahoma' + Font.Style = [] + ParentFont = False + end + object Label29: TLabel + Left = 14 + Top = 43 + Width = 47 + Height = 13 + Caption = 'Features:' + end + object lblChainWikipedia: TLabel + Left = 16 + Top = 120 + Width = 58 + Height = 13 + Cursor = crHandPoint + Caption = 'wikipedia url' + Font.Charset = DEFAULT_CHARSET + Font.Color = clNone + Font.Height = -11 + Font.Name = 'Tahoma' + Font.Style = [fsUnderline] + ParentFont = False + OnClick = OnURL_Click + end + object lbxChainFeatures: TListBox + Left = 67 + Top = 40 + Width = 182 + Height = 65 + ItemHeight = 13 + TabOrder = 0 + end + end + end + end + end + object btnClose: TButton + Left = 280 + Top = 416 + Width = 75 + Height = 25 + Anchors = [akLeft, akBottom] + Caption = 'Close' + ModalResult = 1 + TabOrder = 1 + end +end diff --git a/design/uTPLb_ComponentAbout.pas b/design/uTPLb_ComponentAbout.pas new file mode 100644 index 0000000..f23dcc5 --- /dev/null +++ b/design/uTPLb_ComponentAbout.pas @@ -0,0 +1,534 @@ +{* ***** BEGIN LICENSE BLOCK ***** +Copyright 2009, 2010 Sean B. Durkin +This file is part of TurboPower LockBox 3. TurboPower LockBox 3 is free +software being offered under a dual licensing scheme: LGPL3 or MPL1.1. + +The contents of this file are subject to the Mozilla Public License (MPL) +Version 1.1 (the "License"); you may not use this file except in compliance +with the License. You may obtain a copy of the License at +http://www.mozilla.org/MPL/ + +Alternatively, you may redistribute it and/or modify it under the terms of +the GNU Lesser General Public License (LGPL) as published by the Free Software +Foundation, either version 3 of the License, or (at your option) any later +version. + +You should have received a copy of the Lesser GNU General Public License +along with TurboPower LockBox 3. If not, see . + +TurboPower LockBox is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. In relation to LGPL, +see the GNU Lesser General Public License for more details. In relation to MPL, +see the MPL License for the specific language governing rights and limitations +under the License. + +The Initial Developer of the Original Code for TurboPower LockBox version 2 +and earlier was TurboPower Software. + + * ***** END LICENSE BLOCK ***** *} + +unit uTPLb_ComponentAbout; + +interface + +uses + Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms, + Dialogs, ExtCtrls, StdCtrls, OleCtrls, SHDocVw, ComCtrls, jpeg; + +const + WelcomeVideo_URL = 'http://lockbox.seanbdurkin.id.au/online_resources/Intro3_Embedded.html'; + +type + TTPLb_fmComponentAbout = class(TForm) + pnlAbout: TPanel; + btnClose: TButton; + pgAboutContent: TPageControl; + tsMain: TTabSheet; + tsWelcome: TTabSheet; + tsProject: TTabSheet; + tsCopyLeft: TTabSheet; + tsAuthors: TTabSheet; + tsSupport: TTabSheet; + tsAlgorithms: TTabSheet; + Image1: TImage; + lblTitle: TLabel; + Label1: TLabel; + lblRunTimeVersion: TLabel; + lblDesignTimeVersion: TLabel; + Memo1: TMemo; + browserIntro: TWebBrowser; + Label4: TLabel; + Memo2: TMemo; + lblWebsite: TLabel; + Label7: TLabel; + Label8: TLabel; + Memo3: TMemo; + Label9: TLabel; + Memo4: TMemo; + lbxAuthors: TListBox; + imgAuthorPic: TImage; + Bevel1: TBevel; + lblAuthorEmail: TLabel; + lblAuthorWeb: TLabel; + Label12: TLabel; + memoSupport: TMemo; + memoHelp: TMemo; + Panel1: TPanel; + Label13: TLabel; + lblHashDisplayName: TLabel; + Label15: TLabel; + lbxHashFeatures: TListBox; + lblHashDefinitionURL: TLabel; + lblHashWikipediaURL: TLabel; + lblHashBlockSize: TLabel; + lblHashDigestSize: TLabel; + pnlCipherDescription: TPanel; + Label20: TLabel; + lblCipherDisplayName: TLabel; + Label22: TLabel; + lblCipherDefinitionURL: TLabel; + lblCipherWikipediaURL: TLabel; + lblCipherBlockSize: TLabel; + lbxCipherFeatures: TListBox; + Panel3: TPanel; + Label27: TLabel; + lblChainName: TLabel; + Label29: TLabel; + lblChainWikipedia: TLabel; + lbxChainFeatures: TListBox; + lblLogoAttribution: TLabel; + lblTpsfaIntro: TStaticText; + lblTpsfaContact: TStaticText; + lblWebLabel: TStaticText; + imgSean: TImage; + memoExtraCipherDescription: TMemo; + memoWelcomeInstructions: TMemo; + procedure lblTpsfaContactClick(Sender: TObject); + procedure OnURL_Click(Sender: TObject); + procedure lbxAuthorsClick(Sender: TObject); + procedure FormCreate(Sender: TObject); + private + { Private declarations } + + public + procedure UpdateAbout( SelectedComponent: TComponent); + end; + +var + TPLb_fmComponentAbout: TTPLb_fmComponentAbout; + +implementation + + + + + + + + + + + + + +uses uTPLb_InfoUtils, uTPLb_Hash, uTPLb_HashDsc, ShellAPI, uTPLb_StreamCipher, + uTPLb_Signatory, uTPLb_Codec, TypInfo, uTPLb_BlockCipher, Registry, + uTPLb_I18n, uTPLb_Decorators +{$IF CompilerVersion >= 21} + , Rtti +{$IFEND} + ; +{$R *.dfm} +{ +Content Plan +============ +Page 1: Main +0. Big Title: TurboPower LockBox 3 +2. Product definition statement. +3. Logo or nice graphic for LockBox 3 +7. run-time PE version number +8. design-time PE version +4. Brief statement about FOSS: LGPL + +Page 2: Welcome message +1. Embedded video by me introducing the component suite. + +Page 3: Brought to you by ... +Statement about project organisation and control (tpfsa) +5. tpfsa email +6. sourceforge url + +Page 4: CopyLeft +12. Copyright (mark and statement of application) +10. Statement of copying permission +9. LGPL 3 logo as clickable link +11. LGPL and GPL full wording + +Page 5: Authors +13. About authors. List - + 13.1 Name + 13.2 Photo + 13.3 Email +14 Statement welcoming contributions and adding to the list of authors. + +Page 6: Support +15 Statement about official support. +16 Statement about wiki documentation. + +Page 7: Algorithms +17 About Selected Hash - + 17.1 DisplayName + 17.2 Feature list + 17.3 Definition URL + 17.4 Wikipedia URL + 17.5 Block size + 17.6 Digest size +18 About Selected Chaining Mode - + DisplayName + Feature list + Definition URL + Wikipedia URL +19 About Selected Block Cipher - + DisplayName + Feature list + Definition URL + Wikipedia URL + Block size + +} +{ TTPLb_fmComponentAbout } + +procedure TTPLb_fmComponentAbout.lbxAuthorsClick(Sender: TObject); +var + Idx: integer; + Author, sAuthorEmail, sAuthorWeb: string; +begin +Idx := lbxAuthors.ItemIndex; +if Idx <> -1 then + Author := lbxAuthors.Items[ Idx] + else + Author := ''; +if SameText( Author, 'Sean B. Durkin') then + Idx := 0 + else if SameText( Author, 'David Barton') then + Idx := 1 + else if SameText( Author, 'Another contributor') then + Idx := -1 + else + Idx := -1; +case Idx of + -1: begin + imgAuthorPic.Picture := nil; + sAuthorEmail := ''; + sAuthorWeb := '' + end; + 0: begin + imgAuthorPic.Picture := imgSean.Picture; + sAuthorEmail := 'sean@seanbdurkin.id.au'; + sAuthorWeb := 'http:\\www.seanbdurkin.id.au' + end; + 1: begin + imgAuthorPic.Picture := nil; + sAuthorEmail := 'crypto@cityinthesky.co.uk'; + sAuthorWeb := '' + end; + end; +if sAuthorEmail <> '' then + lblAuthorEmail.Caption := DS_Email + sAuthorEmail + else + lblAuthorEmail.Caption := ''; +if sAuthorWeb <> '' then + lblAuthorWeb.Caption := DS_Web + sAuthorWeb + else + lblAuthorWeb.Caption := ''; +end; + +procedure TTPLb_fmComponentAbout.OnURL_Click( Sender: TObject); +var + s: string; +begin +if (Sender is TLabel) then + begin + s := TLabel( Sender).Caption; + ShellExecute( Handle, 'open', PChar( s), nil, nil, SW_SHOWNORMAL) + end +end; + + + +procedure TTPLb_fmComponentAbout.FormCreate(Sender: TObject); +begin +lblAuthorEmail.Caption := ''; +lblAuthorWeb.Caption := ''; +browserIntro.Navigate( WelcomeVideo_URL) +end; + +procedure TTPLb_fmComponentAbout.lblTpsfaContactClick(Sender: TObject); +begin +// +end; + +procedure TTPLb_fmComponentAbout.UpdateAbout( SelectedComponent: TComponent); +var + LibName: string; + FileVersion: string; + HashComp: THash; + HashDsc: IHashDsc; + s: string; + CodecComp: TCodec; + Chain: IBlockChainingModel; + StreamCipher: IStreamCipher; + BlockCipher: IBlockCipher; + ErrorPos: integer; + Reg: TRegistry; + isDebug: boolean; + Features1: TAlgorithmicFeatureSet; + ExtraCipherDescription: string; + +{$IF compilerversion >= 21} + ControlObject: IControlObject; + Controller: TObject; + LContext: TRttiContext; + LType: TRttiType; + Attr: TCustomAttribute; + DesignDesc: DesignDescription; +{$IFEND} + + procedure PopulateListBoxWithFeatures( const Features: TAlgorithmicFeatureSet; Lbx: TListBox); + var + Feat: TAlgorithmicFeature; + begin +{$IF compilerversion >= 16} + // Delphi 2005 or above + for Feat in Features do + begin + +{$ELSE} + // Delphi 7 or below + for Feat := Low( TAlgorithmicFeature) to High( TAlgorithmicFeature) do + begin + if not (Feat in Features) then continue; +{$IFEND} + + s := GetEnumName( TypeInfo( TAlgorithmicFeature), Ord( Feat)); + Lbx.Items.Add( s) + end + end; + + function WikipediaRelativeURL( const Relative: string): string; + begin + result := Relative; + if (Pos( 'http:' , lowercase( result)) <> 1) and + (Pos( 'https:', lowercase( result)) <> 1) and + (result <> '') then + result := 'http://en.wikipedia.org/wiki/' + result + end; + + procedure Debug( const Line: string); + begin + if isDebug and (Line <> '') then + lbxHashFeatures.Items.Add( Line) + end; + + procedure DebugFmt( const Fmt: string; const Args: array of const); + begin + Debug( Format( Fmt, Args)) + end; + +begin +lbxHashFeatures.Clear; +Reg := TRegistry.Create; +try + Reg.RootKey := HKEY_CURRENT_USER; + isDebug := Reg.OpenKeyReadOnly( '\SOFTWARE\TurboPower\LockBox\3') and + Reg.ReadBool( 'Debug') +finally +Reg.Free +end; +ErrorPos := 0; +try +Get_TP_LockBox3_Info( LibName, FileVersion); +lblRunTimeVersion.Caption := Format( DS_RunTimeIs, + [LibName, FileVersion]); +Inc( ErrorPos); +Get_dclTP_LockBox3_Info( LibName, FileVersion); +lblDesignTimeVersion.Caption := Format( DS_DesignTimeIs, + [LibName, FileVersion]); +Inc( ErrorPos); + +if SelectedComponent is THash then + HashComp := THash( SelectedComponent) + else + HashComp := nil; + +Inc( ErrorPos); +if assigned( HashComp) and assigned( HashComp.CryptoLibrary) and + (HashComp.HashId <> '') then + HashDsc := HashComp.CryptoLibrary.HashIntfc( HashComp.HashId) + else + HashDsc := nil; + +Inc( ErrorPos); +CodecComp := nil; +if SelectedComponent is TCodec then + CodecComp := TCodec( SelectedComponent); + +Inc( ErrorPos); +if (SelectedComponent is TSignatory) and + assigned( TSignatory( SelectedComponent).Codec) and + TSignatory( SelectedComponent).Codec.isAsymetric then + CodecComp := TSignatory( SelectedComponent).Codec; +Inc( ErrorPos); + +if assigned( HashComp) then + begin + lblHashDisplayName.Caption := HashComp.Hash; + PopulateListBoxWithFeatures( HashComp.Features, lbxHashFeatures) + end + else + lblHashDisplayName.Caption := DS_HashNotSelected; + +Inc( ErrorPos); +if assigned( HashDsc) then + begin + lblHashDefinitionURL.Caption := HashDsc.DefinitionURL; + lblHashWikipediaURL.Caption := WikipediaRelativeURL( HashDsc.WikipediaReference); + lblHashBlockSize.Caption := Format( DS_BlockSizeEqs, [HashDsc.UpdateSize]); + lblHashDigestSize.Caption := Format( DS_DigestSizeEqs, [HashDsc.DigestSize]); + end + else + begin + lblHashDefinitionURL.Caption := ''; + lblHashWikipediaURL.Caption := ''; + lblHashBlockSize.Caption := ''; + lblHashDigestSize.Caption := ''; + end; + + +Inc( ErrorPos); +if assigned( CodecComp) and assigned( CodecComp.CryptoLibrary) and + (CodecComp.ChainModeId <> '') then + Chain := CodecComp.CryptoLibrary + .BlockChainingModelIntfc( CodecComp.ChainModeId) + else + Chain := nil; + + +Inc( ErrorPos); +lbxChainFeatures.Items.Clear; +if assigned( Chain) then + begin + lblChainName.Caption := Chain.DisplayName; + PopulateListBoxWithFeatures( Chain.Features, lbxChainFeatures); + lblChainWikipedia.Caption := WikipediaRelativeURL( Chain.WikipediaReference) + end + else + begin + lblChainName.Caption := DS_ChainModeNotSelected; + lblChainWikipedia.Caption := '' + end; + + +Inc( ErrorPos); +if assigned( CodecComp) then + lblCipherDisplayName.Caption := CodecComp.Cipher + else + lblCipherDisplayName.Caption := DS_CodecNotSelected; + +Inc( ErrorPos); +if assigned( CodecComp) and assigned( CodecComp.CryptoLibrary) and + (CodecComp.StreamCipherId <> '') then + StreamCipher := CodecComp.CryptoLibrary + .StreamCipherIntfc( CodecComp.StreamCipherId) + else + StreamCipher := nil; + +Inc( ErrorPos); +if assigned( StreamCipher) and (afBlockAdapter in StreamCipher.Features) and + (CodecComp.BlockCipherId <> '') then + begin + BlockCipher := CodecComp.CryptoLibrary.BlockCipherIntfc( CodecComp.BlockCipherId); + if assigned( BlockCipher) then + StreamCipher := nil + end + else + BlockCipher := nil; + +ExtraCipherDescription := ''; +memoExtraCipherDescription.Visible := False; +pnlCipherDescription.Height := 209; + +{$IF compilerversion >= 21} +if not Supports( BlockCipher, IControlObject, ControlObject) then + Supports( StreamCipher, IControlObject, ControlObject); +if assigned( ControlObject) then + Controller := ControlObject.ControlObject + else + Controller := nil; +DesignDesc := nil; +if assigned( Controller) then + begin + LContext := TRttiContext.Create; + try + LType := LContext.GetType( Controller.ClassType); + for Attr in LType.GetAttributes do + begin + if not (Attr is DesignDescription) then continue; + DesignDesc := DesignDescription( Attr); + break + end; + if assigned( DesignDesc) then + ExtraCipherDescription := DesignDesc.Description + finally + LContext.Free + end + end; +{$IFEND} + +if ExtraCipherDescription <> '' then + begin + memoExtraCipherDescription.Height := 100; + pnlCipherDescription.Height := pnlCipherDescription.Height + + memoExtraCipherDescription.Height; + memoExtraCipherDescription.Visible := True; + memoExtraCipherDescription.Lines.Text := ExtraCipherDescription + end; + +Inc( ErrorPos); +lbxCipherFeatures.Items.Clear; +if assigned( StreamCipher) then + begin + ErrorPos := 20; + PopulateListBoxWithFeatures( StreamCipher.Features, lbxCipherFeatures); + lblCipherDefinitionURL.Caption := StreamCipher.DefinitionURL; + lblCipherWikipediaURL.Caption := WikipediaRelativeURL( StreamCipher.WikipediaReference); + lblCipherBlockSize.Caption := '' + end + else if assigned( BlockCipher) then + begin + ErrorPos := 30; + Features1 := BlockCipher.Features; + Include( Features1, afBlockAdapter); + PopulateListBoxWithFeatures( Features1, lbxCipherFeatures); + lblCipherDefinitionURL.Caption := BlockCipher.DefinitionURL; + lblCipherWikipediaURL.Caption := WikipediaRelativeURL( BlockCipher.WikipediaReference); + lblCipherBlockSize.Caption := Format( DS_BlockSizeEqs, [BlockCipher.BlockSize]) + end + else + begin + ErrorPos := 40; + lblCipherDefinitionURL.Caption := ''; + lblCipherWikipediaURL.Caption := ''; + lblCipherBlockSize.Caption := '' + end +except on E: Exception do + begin + DebugFmt( 'ERROR! (%d)', [ErrorPos]); + DebugFmt( 'Class = %s', [E.ClassName]); + DebugFmt( 'Error = %s', [E.Message]) + end; +end +end; + +end. diff --git a/design/uTPLb_ComponentEditors.pas b/design/uTPLb_ComponentEditors.pas new file mode 100644 index 0000000..46db9fe --- /dev/null +++ b/design/uTPLb_ComponentEditors.pas @@ -0,0 +1,493 @@ +{* ***** BEGIN LICENSE BLOCK ***** +Copyright 2009, 2010 Sean B. Durkin +This file is part of TurboPower LockBox 3. TurboPower LockBox 3 is free +software being offered under a dual licensing scheme: LGPL3 or MPL1.1. + +The contents of this file are subject to the Mozilla Public License (MPL) +Version 1.1 (the "License"); you may not use this file except in compliance +with the License. You may obtain a copy of the License at +http://www.mozilla.org/MPL/ + +Alternatively, you may redistribute it and/or modify it under the terms of +the GNU Lesser General Public License (LGPL) as published by the Free Software +Foundation, either version 3 of the License, or (at your option) any later +version. + +You should have received a copy of the Lesser GNU General Public License +along with TurboPower LockBox 3. If not, see . + +TurboPower LockBox is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. In relation to LGPL, +see the GNU Lesser General Public License for more details. In relation to MPL, +see the MPL License for the specific language governing rights and limitations +under the License. + +The Initial Developer of the Original Code for TurboPower LockBox version 2 +and earlier was TurboPower Software. + + * ***** END LICENSE BLOCK ***** *} + +unit uTPLb_ComponentEditors; +interface + + +procedure Register; + +implementation + + + + + + + + + + + +uses Classes, TypInfo, DesignIntf, DesignEditors, VCLEditors, SysUtils, + uTPLb_Hash, uTPLb_CryptographicLibrary, uTPLb_ComponentAbout, + uTPLb_BaseNonVisualComponent, uTPLb_HashDsc, uTPLb_Codec, + uTPLb_BlockCipher, uTPLb_Signatory, uTPLb_I18n; + +type +TLockBoxEditor = class( TStringProperty) + public + function GetAttributes: TPropertyAttributes; override; + procedure Edit; override; + end; + + +THashEditor2 = class( TStringProperty, IProperty) + protected + function GetEditValue2( out Value: string): Boolean; virtual; + function IProperty.GetEditValue = GetEditValue2; + function SharedNonEmptyLibrary: Boolean; + + public + function GetAttributes: TPropertyAttributes; override; + procedure GetValues(Proc: TGetStrProc); override; + procedure SetValue( const Value: string); override; + end; + +TCipherEditor = class( TStringProperty, IProperty) + protected + function GetEditValue2( out Value: string): Boolean; virtual; + function IProperty.GetEditValue = GetEditValue2; + function SharedNonEmptyLibrary: Boolean; + + public + function GetAttributes: TPropertyAttributes; override; + procedure GetValues(Proc: TGetStrProc); override; + procedure SetValue( const Value: string); override; + end; + +TChainEditor = class( TCipherEditor) + public + procedure GetValues(Proc: TGetStrProc); override; + procedure SetValue( const Value: string); override; + end; + + +procedure Register; +begin +RegisterPropertyEditor( TypeInfo( string), TTPLb_BaseNonVisualComponent, 'About', TLockBoxEditor); +RegisterPropertyEditor( TypeInfo( string), THash, 'Hash', THashEditor2); +RegisterPropertyEditor( TypeInfo( string), TCodec, 'Cipher', TCipherEditor); +RegisterPropertyEditor( TypeInfo( string), TCodec, 'ChainMode', TChainEditor) +end; + + + + +{ THashEditor2 } + +function THashEditor2.GetAttributes: TPropertyAttributes; +begin +result := [ paValueList, paSortList, paMultiSelect, + paRevertable + +{$IF compilerversion >= 16} + // Delphi 2005 or above + , paReadOnly, paValueEditable +{$ELSE} + // Delphi 7 or below: Nothing more. +// paSubProperties, paMultiSelect, +// paAutoUpdate, paSortList, paFullWidthName, +// paVolatileSubProperties, paVCL, paNotNestable + +{$IFEND} + + ] +end; + + +function THashEditor2.SharedNonEmptyLibrary: Boolean; +var + HashComp: THash; + Lib, Lib2: TCryptographicLibrary; + j: integer; +begin +result := False; +Lib2 := nil; +if PropCount >= 1 then + begin + if GetComponent( 0) is THash then + HashComp := THash( GetComponent( 0)) + else + HashComp := nil; + if assigned( HashComp) then + Lib := HashComp.CryptoLibrary + else + Lib := nil; + result := assigned( Lib); + if not result then exit; + for j := 1 to PropCount - 1 do + begin + if GetComponent( j) is THash then + HashComp := THash( GetComponent( 0)) + else + HashComp := nil; + if assigned( HashComp) then + Lib2 := HashComp.CryptoLibrary + else + Lib := nil; + result := Lib = Lib2; + if not result then break + end + end +end; + + + + +function THashEditor2.GetEditValue2( out Value: string): Boolean; +begin +result := GetEditValue( Value); +if not result then exit; +result := SharedNonEmptyLibrary; +if not result then + Value := DS_MixedLibraries +end; + + + +procedure THashEditor2.GetValues( Proc: TGetStrProc); +var + HashComp: THash; + Lib: TCryptographicLibrary; + j: integer; + HashChoices: IInterfaceList; + Hash: IHashDsc; +begin +if (PropCount >= 1) and (GetComponent( 0) is THash) then + HashComp := THash( GetComponent( 0)) + else + HashComp := nil; +if assigned( HashComp) then + Lib := HashComp.CryptoLibrary + else + Lib := nil; +if not assigned( Lib) then exit; +HashChoices := Lib.GetHashChoices; +for j := 0 to HashChoices.Count - 1 do + if Supports( HashChoices[j], IHashDsc, Hash) then + Proc( Lib.ComputeHashDisplayName( Hash)) +end; + + + +procedure THashEditor2.SetValue( const Value: string); +var + HashComp: THash; + Lib: TCryptographicLibrary; + j: integer; + ProgId: string; + HashChoices: IInterfaceList; + Hash: IHashDsc; +begin +if not SharedNonEmptyLibrary then exit; +if (PropCount >= 1) and (GetComponent( 0) is THash) then + HashComp := THash( GetComponent( 0)) + else + HashComp := nil; +if assigned( HashComp) then + Lib := HashComp.CryptoLibrary + else + Lib := nil; +ProgId := ''; +HashChoices := Lib.GetHashChoices; +if assigned( Lib) then + for j := 0 to HashChoices.Count - 1 do + if Supports( HashChoices[j], IHashDsc, Hash) then + begin + if Value <> Lib.ComputeHashDisplayName( Hash) then continue; + ProgId := Hash.ProgId; + break + end; +if ProgId = '' then exit; +for j := 0 to PropCount - 1 do + begin + if GetComponent( j) is THash then + HashComp := THash( GetComponent( j)) + else + HashComp := nil; + HashComp.HashId := ProgId + end; +Modified +end; + +{ TLockBoxEditor } + +procedure TLockBoxEditor.Edit; +var + doCreate: boolean; + SelectedComponent: TComponent; +begin +doCreate := not assigned( TPLb_fmComponentAbout); +if doCreate then + TPLb_fmComponentAbout := TTPLb_fmComponentAbout.Create( nil); +try + if (PropCount >= 1) and (GetComponent( 0) is TComponent) then + SelectedComponent := TComponent( GetComponent( 0)) + else + SelectedComponent := nil; + TPLb_fmComponentAbout.UpdateAbout( SelectedComponent); + if not doCreate then + begin + TPLb_fmComponentAbout.Show; + TPLb_fmComponentAbout.BringToFront + end; + TPLb_fmComponentAbout.ShowModal +finally +if doCreate then + begin + TPLb_fmComponentAbout.Release; + TPLb_fmComponentAbout := nil + end +end end; + + + + +function TLockBoxEditor.GetAttributes: TPropertyAttributes; +begin +result := [paDialog, paReadOnly, paMultiSelect] +end; + +{ TCipherEditor } + +function TCipherEditor.GetAttributes: TPropertyAttributes; +begin +result := [ paValueList, paSortList, paMultiSelect, + paRevertable + +{$IF compilerversion >= 16} + // Delphi 2005 or above + , paReadOnly, paValueEditable +{$ELSE} + // Delphi 7 or below: Nothing more. +{$IFEND} + + ] +end; + +function TCipherEditor.GetEditValue2( out Value: string): Boolean; +begin +result := GetEditValue( Value); +if not result then exit; +result := SharedNonEmptyLibrary; +if not result then + Value := DS_MixedLibraries +end; + + +procedure TCipherEditor.GetValues( Proc: TGetStrProc); +var + CodecComp: TCodec; + Lib: TCryptographicLibrary; + j: integer; + CipherChoices: IInterfaceList; + CipherChoice: ICipherChoice; + CipherDisplayName: string; + isBlockCipher: boolean; + StreamCipherId: string; + BlockCipherId: string; +begin +if (PropCount >= 1) and (GetComponent( 0) is TCodec) then + CodecComp := TCodec( GetComponent( 0)) + else + CodecComp := nil; +if assigned( CodecComp) then + Lib := CodecComp.CryptoLibrary + else + Lib := nil; +if not assigned( Lib) then exit; +CipherChoices := Lib.GetCipherChoices; +for j := 0 to CipherChoices.Count - 1 do + if Supports( CipherChoices[j], ICipherChoice, CipherChoice) then + begin + CipherChoice.GetChoiceParams( + CipherDisplayName, isBlockCipher, StreamCipherId, BlockCipherId); + Proc( CipherDisplayName) + end +end; + + +procedure TCipherEditor.SetValue( const Value: string); +var + CodecComp: TCodec; + Lib: TCryptographicLibrary; + j: integer; + ProgId: string; + CipherChoices: IInterfaceList; + CipherChoice: ICipherChoice; + CipherDisplayName: string; + isBlockCipher: boolean; + StreamCipherId: string; + BlockCipherId: string; + Found: boolean; +begin +if not SharedNonEmptyLibrary then exit; +if (PropCount >= 1) and (GetComponent( 0) is TCodec) then + CodecComp := TCodec( GetComponent( 0)) + else + CodecComp := nil; +if assigned( CodecComp) then + Lib := CodecComp.CryptoLibrary + else + Lib := nil; +ProgId := ''; +CipherChoices := Lib.GetCipherChoices; +Found := False; +if assigned( Lib) then + for j := 0 to CipherChoices.Count - 1 do + if Supports( CipherChoices[j], ICipherChoice, CipherChoice) then + begin + CipherChoice.GetChoiceParams( + CipherDisplayName, isBlockCipher, StreamCipherId, BlockCipherId); + if Value <> CipherDisplayName then continue; + Found := True; + break + end; +if not Found then exit; +for j := 0 to PropCount - 1 do + begin + if GetComponent( j) is TCodec then + CodecComp := TCodec( GetComponent( j)) + else + CodecComp := nil; + CodecComp.StreamCipherId := StreamCipherId; + CodecComp.BlockCipherId := BlockCipherId + end; +Modified +end; + + + +function TCipherEditor.SharedNonEmptyLibrary: Boolean; +var + CodecComp: TCodec; + Lib, Lib2: TCryptographicLibrary; + j: integer; +begin +result := False; +Lib2 := nil; +if PropCount >= 1 then + begin + if GetComponent( 0) is TCodec then + CodecComp := TCodec( GetComponent( 0)) + else + CodecComp := nil; + if assigned( CodecComp) then + Lib := CodecComp.CryptoLibrary + else + Lib := nil; + result := assigned( Lib); + if not result then exit; + for j := 1 to PropCount - 1 do + begin + if GetComponent( j) is TCodec then + CodecComp := TCodec( GetComponent( 0)) + else + CodecComp := nil; + if assigned( CodecComp) then + Lib2 := CodecComp.CryptoLibrary + else + Lib := nil; + result := Lib = Lib2; + if not result then break + end + end +end; + +{ TChainEditor } + +procedure TChainEditor.GetValues( Proc: TGetStrProc); +var + CodecComp: TCodec; + Lib: TCryptographicLibrary; + j: integer; + ChainChoices: IInterfaceList; + ChainChoice: IBlockChainingModel; +begin +if (PropCount >= 1) and (GetComponent( 0) is TCodec) then + CodecComp := TCodec( GetComponent( 0)) + else + CodecComp := nil; +if assigned( CodecComp) then + Lib := CodecComp.CryptoLibrary + else + Lib := nil; +if not assigned( Lib) then exit; +ChainChoices := Lib.GetChainChoices; +for j := 0 to ChainChoices.Count - 1 do + if Supports( ChainChoices[j], IBlockChainingModel, ChainChoice) then + Proc( Lib.ComputeChainDisplayName( ChainChoice)) +end; + + + + +procedure TChainEditor.SetValue( const Value: string); +var + CodecComp: TCodec; + Lib: TCryptographicLibrary; + j: integer; + ChainChoices: IInterfaceList; + ChainChoice: IBlockChainingModel; + Found: boolean; +begin +if not SharedNonEmptyLibrary then exit; +if (PropCount >= 1) and (GetComponent( 0) is TCodec) then + CodecComp := TCodec( GetComponent( 0)) + else + CodecComp := nil; +if assigned( CodecComp) then + Lib := CodecComp.CryptoLibrary + else + Lib := nil; +ChainChoices := Lib.GetChainChoices; +Found := False; +if assigned( Lib) then + for j := 0 to ChainChoices.Count - 1 do + if Supports( ChainChoices[j], IBlockChainingModel, ChainChoice) then + begin + if Value <> Lib.ComputeChainDisplayName( ChainChoice) then continue; + Found := True; + break + end; +if not Found then exit; +for j := 0 to PropCount - 1 do + begin + if GetComponent( j) is TCodec then + CodecComp := TCodec( GetComponent( j)) + else + CodecComp := nil; + CodecComp.ChainModeId := ChainChoice.ProgId + end; +Modified +end; + +end. diff --git a/design/uTPLb_ComponentRegistration.pas b/design/uTPLb_ComponentRegistration.pas new file mode 100644 index 0000000..500908c --- /dev/null +++ b/design/uTPLb_ComponentRegistration.pas @@ -0,0 +1,50 @@ +{* ***** BEGIN LICENSE BLOCK ***** +Copyright 2009, 2010 Sean B. Durkin +This file is part of TurboPower LockBox 3. TurboPower LockBox 3 is free +software being offered under a dual licensing scheme: LGPL3 or MPL1.1. + +The contents of this file are subject to the Mozilla Public License (MPL) +Version 1.1 (the "License"); you may not use this file except in compliance +with the License. You may obtain a copy of the License at +http://www.mozilla.org/MPL/ + +Alternatively, you may redistribute it and/or modify it under the terms of +the GNU Lesser General Public License (LGPL) as published by the Free Software +Foundation, either version 3 of the License, or (at your option) any later +version. + +You should have received a copy of the Lesser GNU General Public License +along with TurboPower LockBox 3. If not, see . + +TurboPower LockBox is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. In relation to LGPL, +see the GNU Lesser General Public License for more details. In relation to MPL, +see the MPL License for the specific language governing rights and limitations +under the License. + +The Initial Developer of the Original Code for TurboPower LockBox version 2 +and earlier was TurboPower Software. + + * ***** END LICENSE BLOCK ***** *} + +unit uTPLb_ComponentRegistration; + +interface + +procedure Register; + +implementation + +{$R 'LockBox3.dcr'} + +uses + Classes, uTPLb_Hash, uTPLb_CryptographicLibrary, uTPLb_Codec, uTPLb_Signatory; + +procedure Register; +begin + RegisterComponents( 'LockBox', [THash, TCodec, TCryptographicLibrary, TSignatory]) +end; + + +end. diff --git a/design/uTPLb_InfoUtils.pas b/design/uTPLb_InfoUtils.pas new file mode 100644 index 0000000..80ccb3f --- /dev/null +++ b/design/uTPLb_InfoUtils.pas @@ -0,0 +1,127 @@ +{* ***** BEGIN LICENSE BLOCK ***** +Copyright 2009, 2010 Sean B. Durkin +This file is part of TurboPower LockBox 3. TurboPower LockBox 3 is free +software being offered under a dual licensing scheme: LGPL3 or MPL1.1. + +The contents of this file are subject to the Mozilla Public License (MPL) +Version 1.1 (the "License"); you may not use this file except in compliance +with the License. You may obtain a copy of the License at +http://www.mozilla.org/MPL/ + +Alternatively, you may redistribute it and/or modify it under the terms of +the GNU Lesser General Public License (LGPL) as published by the Free Software +Foundation, either version 3 of the License, or (at your option) any later +version. + +You should have received a copy of the Lesser GNU General Public License +along with TurboPower LockBox 3. If not, see . + +TurboPower LockBox is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. In relation to LGPL, +see the GNU Lesser General Public License for more details. In relation to MPL, +see the MPL License for the specific language governing rights and limitations +under the License. + +The Initial Developer of the Original Code for TurboPower LockBox version 2 +and earlier was TurboPower Software. + + * ***** END LICENSE BLOCK ***** *} + +unit uTPLb_InfoUtils; +interface +uses windows; + +function GetLibraryInfo( + ModuleHandle: HMODULE; var LibName: string; var FileVersion: string): boolean; +// Hint: use HINSTANCE as the actual parameter to get the current package. + + +function Get_TP_LockBox3_Info( // The Run-time package. + var LibName: string; var FileVersion: string): boolean; + + + +function Get_dclTP_LockBox3_Info( // This, the Design-time package. + var LibName: string; var FileVersion: string): boolean; +// Assumes that this unit is part of the dclTP_LockBox3 unit. + + + +implementation + + + + + + + + + + + + + + + + +uses SysUtils, uTPLb_BinaryUtils; + +function GetLibraryInfo( + ModuleHandle: HMODULE; var LibName: string; var FileVersion: string): boolean; +var + iLibSize, iValueSize: DWord; + Buf: ansiString; + Ok: boolean; + fvip: pointer; + MajorV, MinorV, ReleaseV, BuildV: integer; +begin +LibName := GetModuleName( ModuleHandle); +result := LibName <> ''; +if result then + iLibSize := GetFileVersionInfoSize( PChar( LibName), iLibSize) + else + iLibSize := 0; +Ok := iLibSize > 0; +if Ok then + begin + SetLength( Buf, iLibSize); + Ok := GetFileVersionInfo( PChar( LibName), 0, iLibSize, PAnsiChar( Buf)) and + VerQueryValue( PAnsiChar( Buf), '\', fvip, iValueSize) and + (iValueSize >= SizeOf( TVSFixedFileInfo)) + end; +if Ok then + begin + MajorV := HiWord( TVSFixedFileInfo( fvip^).dwFileVersionMS); + MinorV := LoWord( TVSFixedFileInfo( fvip^).dwFileVersionMS); + ReleaseV := HiWord( TVSFixedFileInfo( fvip^).dwFileVersionLS); + BuildV := LoWord( TVSFixedFileInfo( fvip^).dwFileVersionLS) + end + else + begin + MajorV := 0; + MinorV := 0; + ReleaseV := 0; + BuildV := 0 + end; +FileVersion := Format( '%d.%d.%d.%d', [MajorV, MinorV, ReleaseV, BuildV]); +if result then + LibName := ExtractFileName( LibName) +end; + + + +function Get_dclTP_LockBox3_Info( + var LibName: string; var FileVersion: string): boolean; +begin +result := GetLibraryInfo( HINSTANCE, LibName, FileVersion) +end; + + +function Get_TP_LockBox3_Info( // The Run-time package. + var LibName: string; var FileVersion: string): boolean; +begin +result := GetLibraryInfo( Get_TP_LockBox3_HINSTANCE, LibName, FileVersion) +end; + +end. diff --git a/hpp/Win32/Release/DCPtwofish_LB3Modified.hpp b/hpp/Win32/Release/DCPtwofish_LB3Modified.hpp index 5234fd2..c7895d3 100644 --- a/hpp/Win32/Release/DCPtwofish_LB3Modified.hpp +++ b/hpp/Win32/Release/DCPtwofish_LB3Modified.hpp @@ -2,7 +2,7 @@ // Copyright (c) 1995, 2017 by Embarcadero Technologies, Inc. // All rights reserved -// (DO NOT EDIT: machine generated header) 'DCPtwofish_LB3Modified.pas' rev: 32.00 (Windows) +// (DO NOT EDIT: machine generated header) 'DCPtwofish_LB3Modified.pas' rev: 33.00 (Windows) #ifndef Dcptwofish_lb3modifiedHPP #define Dcptwofish_lb3modifiedHPP @@ -51,7 +51,7 @@ static const System::Int8 SK_ROTL = System::Int8(0x9); extern DELPHI_PACKAGE void __fastcall DCP_twofish_InitKey(const void *Key, unsigned Size, TSubKeys &SubKeys, TSBox &SBox); extern DELPHI_PACKAGE void __fastcall DCP_twofish_EncryptECB(const TSubKeys &SubKeys, const TSBox &SBox, const T128 &InData, T128 &OutData); extern DELPHI_PACKAGE void __fastcall DCP_twofish_DecryptECB(const TSubKeys &SubKeys, const TSBox &SBox, const T128 &InData, T128 &OutData); -extern DELPHI_PACKAGE void __fastcall DCP_towfish_Precomp(void); +extern DELPHI_PACKAGE void __fastcall DCP_towfish_Precomp(); } /* namespace Dcptwofish_lb3modified */ #if !defined(DELPHIHEADER_NO_IMPLICIT_NAMESPACE_USE) && !defined(NO_USING_NAMESPACE_DCPTWOFISH_LB3MODIFIED) using namespace Dcptwofish_lb3modified; diff --git a/hpp/Win32/Release/FMX.uTPLb_ComponentAbout.hpp b/hpp/Win32/Release/FMX.uTPLb_ComponentAbout.hpp index 8457d18..5c5f538 100644 --- a/hpp/Win32/Release/FMX.uTPLb_ComponentAbout.hpp +++ b/hpp/Win32/Release/FMX.uTPLb_ComponentAbout.hpp @@ -2,7 +2,7 @@ // Copyright (c) 1995, 2017 by Embarcadero Technologies, Inc. // All rights reserved -// (DO NOT EDIT: machine generated header) 'FMX.uTPLb_ComponentAbout.pas' rev: 32.00 (Windows) +// (DO NOT EDIT: machine generated header) 'FMX.uTPLb_ComponentAbout.pas' rev: 33.00 (Windows) #ifndef Fmx_Utplb_componentaboutHPP #define Fmx_Utplb_componentaboutHPP @@ -144,7 +144,7 @@ class PASCALIMPLEMENTATION TTPLb_fmComponentAbout : public Fmx::Forms::TForm public: /* TCustomForm.Create */ inline __fastcall virtual TTPLb_fmComponentAbout(System::Classes::TComponent* AOwner) : Fmx::Forms::TForm(AOwner) { } /* TCustomForm.CreateNew */ inline __fastcall virtual TTPLb_fmComponentAbout(System::Classes::TComponent* AOwner, NativeInt Dummy) : Fmx::Forms::TForm(AOwner, Dummy) { } - /* TCustomForm.Destroy */ inline __fastcall virtual ~TTPLb_fmComponentAbout(void) { } + /* TCustomForm.Destroy */ inline __fastcall virtual ~TTPLb_fmComponentAbout() { } }; diff --git a/hpp/Win32/Release/FMX.uTPLb_InfoUtils.hpp b/hpp/Win32/Release/FMX.uTPLb_InfoUtils.hpp index d8a2092..be4cfc3 100644 --- a/hpp/Win32/Release/FMX.uTPLb_InfoUtils.hpp +++ b/hpp/Win32/Release/FMX.uTPLb_InfoUtils.hpp @@ -2,7 +2,7 @@ // Copyright (c) 1995, 2017 by Embarcadero Technologies, Inc. // All rights reserved -// (DO NOT EDIT: machine generated header) 'FMX.uTPLb_InfoUtils.pas' rev: 32.00 (Windows) +// (DO NOT EDIT: machine generated header) 'FMX.uTPLb_InfoUtils.pas' rev: 33.00 (Windows) #ifndef Fmx_Utplb_infoutilsHPP #define Fmx_Utplb_infoutilsHPP diff --git a/hpp/Win32/Release/LockBox3DR.hpp b/hpp/Win32/Release/LockBox3DR.hpp index 5e346bc..009e222 100644 --- a/hpp/Win32/Release/LockBox3DR.hpp +++ b/hpp/Win32/Release/LockBox3DR.hpp @@ -2,7 +2,7 @@ // Copyright (c) 1995, 2017 by Embarcadero Technologies, Inc. // All rights reserved -// (DO NOT EDIT: machine generated header) 'LockBox3DR.dpk' rev: 32.00 (Windows) +// (DO NOT EDIT: machine generated header) 'LockBox3DR.dpk' rev: 33.00 (Windows) #ifndef Lockbox3drHPP #define Lockbox3drHPP @@ -77,8 +77,8 @@ #include // (rtl) // SO_SFX: 250 // PRG_EXT: .bpl -// BPI_DIR: C:\Users\Public\Documents\Embarcadero\Studio\19.0\Dcp -// OBJ_DIR: C:\Users\Public\Documents\Embarcadero\Studio\19.0\Dcp +// BPI_DIR: C:\Users\Public\Documents\Embarcadero\Studio\20.0\Dcp +// OBJ_DIR: C:\Users\Public\Documents\Embarcadero\Studio\20.0\Dcp // OBJ_EXT: .obj //-- user supplied ----------------------------------------------------------- diff --git a/hpp/Win32/Release/LockBox3FMXDD.hpp b/hpp/Win32/Release/LockBox3FMXDD.hpp index 62a15d3..8f44885 100644 --- a/hpp/Win32/Release/LockBox3FMXDD.hpp +++ b/hpp/Win32/Release/LockBox3FMXDD.hpp @@ -2,7 +2,7 @@ // Copyright (c) 1995, 2017 by Embarcadero Technologies, Inc. // All rights reserved -// (DO NOT EDIT: machine generated header) 'LockBox3FMXDD.dpk' rev: 32.00 (Windows) +// (DO NOT EDIT: machine generated header) 'LockBox3FMXDD.dpk' rev: 33.00 (Windows) #ifndef Lockbox3fmxddHPP #define Lockbox3fmxddHPP @@ -34,9 +34,11 @@ #include // (rtl) #include // (rtl) #include // (rtl) +#include // (rtl) #include // (rtl) #include // (rtl) #include // (vcl) +#include // (rtl) #include // (rtl) #include // (vcl) #include // (rtl) @@ -75,6 +77,7 @@ #include // (vclactnband) #include // (vclactnband) #include // (vclactnband) +#include // (rtl) #include // (designide) #include // (designide) #include // (designide) @@ -94,7 +97,6 @@ #include // (dbrtl) #include // (dbrtl) #include // (dbrtl) -#include // (rtl) #include // (rtl) #include // (fmx) #include // (fmx) @@ -117,7 +119,6 @@ #include // (fmx) #include // (fmx) #include // (fmx) -#include // (rtl) #include // (fmx) #include // (fmx) #include // (fmx) @@ -208,8 +209,8 @@ #include // (Bindcompfmx) // SO_SFX: 250 // PRG_EXT: .bpl -// BPI_DIR: C:\Users\Public\Documents\Embarcadero\Studio\19.0\Dcp -// OBJ_DIR: C:\Users\Public\Documents\Embarcadero\Studio\19.0\Dcp +// BPI_DIR: C:\Users\Public\Documents\Embarcadero\Studio\20.0\Dcp +// OBJ_DIR: C:\Users\Public\Documents\Embarcadero\Studio\20.0\Dcp // OBJ_EXT: .obj //-- user supplied ----------------------------------------------------------- diff --git a/hpp/Win32/Release/LockBox3VCLDD.hpp b/hpp/Win32/Release/LockBox3VCLDD.hpp index de3cb42..4c1398d 100644 --- a/hpp/Win32/Release/LockBox3VCLDD.hpp +++ b/hpp/Win32/Release/LockBox3VCLDD.hpp @@ -2,7 +2,7 @@ // Copyright (c) 1995, 2017 by Embarcadero Technologies, Inc. // All rights reserved -// (DO NOT EDIT: machine generated header) 'LockBox3VCLDD.dpk' rev: 32.00 (Windows) +// (DO NOT EDIT: machine generated header) 'LockBox3VCLDD.dpk' rev: 33.00 (Windows) #ifndef Lockbox3vclddHPP #define Lockbox3vclddHPP @@ -34,9 +34,11 @@ #include // (rtl) #include // (rtl) #include // (rtl) +#include // (rtl) #include // (rtl) #include // (rtl) #include // (vcl) +#include // (rtl) #include // (rtl) #include // (vcl) #include // (rtl) @@ -87,6 +89,7 @@ #include // (vclactnband) #include // (vclactnband) #include // (vclactnband) +#include // (rtl) #include // (designide) #include // (designide) #include // (designide) @@ -106,8 +109,8 @@ #include // (designide) // SO_SFX: 250 // PRG_EXT: .bpl -// BPI_DIR: C:\Users\Public\Documents\Embarcadero\Studio\19.0\Dcp -// OBJ_DIR: C:\Users\Public\Documents\Embarcadero\Studio\19.0\Dcp +// BPI_DIR: C:\Users\Public\Documents\Embarcadero\Studio\20.0\Dcp +// OBJ_DIR: C:\Users\Public\Documents\Embarcadero\Studio\20.0\Dcp // OBJ_EXT: .obj //-- user supplied ----------------------------------------------------------- diff --git a/hpp/Win32/Release/Vcl.uTPLb_ComponentAbout.hpp b/hpp/Win32/Release/Vcl.uTPLb_ComponentAbout.hpp index 511e582..d78401a 100644 --- a/hpp/Win32/Release/Vcl.uTPLb_ComponentAbout.hpp +++ b/hpp/Win32/Release/Vcl.uTPLb_ComponentAbout.hpp @@ -2,7 +2,7 @@ // Copyright (c) 1995, 2017 by Embarcadero Technologies, Inc. // All rights reserved -// (DO NOT EDIT: machine generated header) 'Vcl.uTPLb_ComponentAbout.pas' rev: 32.00 (Windows) +// (DO NOT EDIT: machine generated header) 'Vcl.uTPLb_ComponentAbout.pas' rev: 33.00 (Windows) #ifndef Vcl_Utplb_componentaboutHPP #define Vcl_Utplb_componentaboutHPP @@ -117,7 +117,7 @@ class PASCALIMPLEMENTATION TTPLb_fmComponentAbout : public Vcl::Forms::TForm public: /* TCustomForm.Create */ inline __fastcall virtual TTPLb_fmComponentAbout(System::Classes::TComponent* AOwner) : Vcl::Forms::TForm(AOwner) { } /* TCustomForm.CreateNew */ inline __fastcall virtual TTPLb_fmComponentAbout(System::Classes::TComponent* AOwner, int Dummy) : Vcl::Forms::TForm(AOwner, Dummy) { } - /* TCustomForm.Destroy */ inline __fastcall virtual ~TTPLb_fmComponentAbout(void) { } + /* TCustomForm.Destroy */ inline __fastcall virtual ~TTPLb_fmComponentAbout() { } public: /* TWinControl.CreateParented */ inline __fastcall TTPLb_fmComponentAbout(HWND ParentWindow) : Vcl::Forms::TForm(ParentWindow) { } diff --git a/hpp/Win32/Release/Vcl.uTPLb_InfoUtils.hpp b/hpp/Win32/Release/Vcl.uTPLb_InfoUtils.hpp index 9418a72..f1383c8 100644 --- a/hpp/Win32/Release/Vcl.uTPLb_InfoUtils.hpp +++ b/hpp/Win32/Release/Vcl.uTPLb_InfoUtils.hpp @@ -2,7 +2,7 @@ // Copyright (c) 1995, 2017 by Embarcadero Technologies, Inc. // All rights reserved -// (DO NOT EDIT: machine generated header) 'Vcl.uTPLb_InfoUtils.pas' rev: 32.00 (Windows) +// (DO NOT EDIT: machine generated header) 'Vcl.uTPLb_InfoUtils.pas' rev: 33.00 (Windows) #ifndef Vcl_Utplb_infoutilsHPP #define Vcl_Utplb_infoutilsHPP diff --git a/hpp/Win32/Release/uTPLb_3DES.hpp b/hpp/Win32/Release/uTPLb_3DES.hpp index 4db20f3..550f733 100644 --- a/hpp/Win32/Release/uTPLb_3DES.hpp +++ b/hpp/Win32/Release/uTPLb_3DES.hpp @@ -2,7 +2,7 @@ // Copyright (c) 1995, 2017 by Embarcadero Technologies, Inc. // All rights reserved -// (DO NOT EDIT: machine generated header) 'uTPLb_3DES.pas' rev: 32.00 (Windows) +// (DO NOT EDIT: machine generated header) 'uTPLb_3DES.pas' rev: 33.00 (Windows) #ifndef Utplb_3desHPP #define Utplb_3desHPP @@ -33,25 +33,25 @@ class PASCALIMPLEMENTATION T3DES : public System::TInterfacedObject typedef System::TInterfacedObject inherited; private: - virtual System::UnicodeString __fastcall DisplayName(void); - virtual System::UnicodeString __fastcall ProgId(void); - Utplb_streamcipher::TAlgorithmicFeatureSet __fastcall Features(void); - System::UnicodeString __fastcall DefinitionURL(void); - System::UnicodeString __fastcall WikipediaReference(void); + virtual System::UnicodeString __fastcall DisplayName(); + virtual System::UnicodeString __fastcall ProgId(); + Utplb_streamcipher::TAlgorithmicFeatureSet __fastcall Features(); + System::UnicodeString __fastcall DefinitionURL(); + System::UnicodeString __fastcall WikipediaReference(); virtual Utplb_streamcipher::TSymetricKey* __fastcall GenerateKey(System::Classes::TStream* Seed); virtual Utplb_streamcipher::TSymetricKey* __fastcall LoadKeyFromStream(System::Classes::TStream* Store); - virtual int __fastcall BlockSize(void); - virtual int __fastcall KeySize(void); - virtual int __fastcall SeedByteSize(void); + virtual int __fastcall BlockSize(); + virtual int __fastcall KeySize(); + virtual int __fastcall SeedByteSize(); virtual Utplb_blockcipher::_di_IBlockCodec __fastcall MakeBlockCodec(Utplb_streamcipher::TSymetricKey* Key); - virtual System::DynamicArray __fastcall SelfTest_Key(void); - virtual System::DynamicArray __fastcall SelfTest_Plaintext(void); - virtual System::DynamicArray __fastcall SelfTest_Ciphertext(void); + virtual System::DynamicArray __fastcall SelfTest_Key(); + virtual System::DynamicArray __fastcall SelfTest_Plaintext(); + virtual System::DynamicArray __fastcall SelfTest_Ciphertext(); public: - __fastcall virtual T3DES(void); + __fastcall virtual T3DES(); public: - /* TObject.Destroy */ inline __fastcall virtual ~T3DES(void) { } + /* TObject.Destroy */ inline __fastcall virtual ~T3DES() { } private: void *__IBlockCipher; // Utplb_blockcipher::IBlockCipher @@ -90,21 +90,21 @@ class PASCALIMPLEMENTATION T3DES_KO1 : public T3DES typedef T3DES inherited; private: - virtual System::UnicodeString __fastcall DisplayName(void); - virtual System::UnicodeString __fastcall ProgId(void); + virtual System::UnicodeString __fastcall DisplayName(); + virtual System::UnicodeString __fastcall ProgId(); virtual Utplb_streamcipher::TSymetricKey* __fastcall GenerateKey(System::Classes::TStream* Seed); virtual Utplb_streamcipher::TSymetricKey* __fastcall LoadKeyFromStream(System::Classes::TStream* Store); - virtual int __fastcall KeySize(void); - virtual int __fastcall SeedByteSize(void); + virtual int __fastcall KeySize(); + virtual int __fastcall SeedByteSize(); virtual Utplb_blockcipher::_di_IBlockCodec __fastcall MakeBlockCodec(Utplb_streamcipher::TSymetricKey* Key); - virtual System::DynamicArray __fastcall SelfTest_Key(void); - virtual System::DynamicArray __fastcall SelfTest_Plaintext(void); - virtual System::DynamicArray __fastcall SelfTest_Ciphertext(void); + virtual System::DynamicArray __fastcall SelfTest_Key(); + virtual System::DynamicArray __fastcall SelfTest_Plaintext(); + virtual System::DynamicArray __fastcall SelfTest_Ciphertext(); public: - /* T3DES.Create */ inline __fastcall virtual T3DES_KO1(void) : T3DES() { } + /* T3DES.Create */ inline __fastcall virtual T3DES_KO1() : T3DES() { } public: - /* TObject.Destroy */ inline __fastcall virtual ~T3DES_KO1(void) { } + /* TObject.Destroy */ inline __fastcall virtual ~T3DES_KO1() { } }; diff --git a/hpp/Win32/Release/uTPLb_AES.hpp b/hpp/Win32/Release/uTPLb_AES.hpp index ea776cd..65c23f3 100644 --- a/hpp/Win32/Release/uTPLb_AES.hpp +++ b/hpp/Win32/Release/uTPLb_AES.hpp @@ -2,7 +2,7 @@ // Copyright (c) 1995, 2017 by Embarcadero Technologies, Inc. // All rights reserved -// (DO NOT EDIT: machine generated header) 'uTPLb_AES.pas' rev: 32.00 (Windows) +// (DO NOT EDIT: machine generated header) 'uTPLb_AES.pas' rev: 33.00 (Windows) #ifndef Utplb_aesHPP #define Utplb_aesHPP @@ -34,26 +34,26 @@ class PASCALIMPLEMENTATION TAES : public System::TInterfacedObject private: int FKeySize; - System::UnicodeString __fastcall DisplayName(void); - System::UnicodeString __fastcall ProgId(void); - Utplb_streamcipher::TAlgorithmicFeatureSet __fastcall Features(void); - System::UnicodeString __fastcall DefinitionURL(void); - System::UnicodeString __fastcall WikipediaReference(void); - int __fastcall SeedByteSize(void); + System::UnicodeString __fastcall DisplayName(); + System::UnicodeString __fastcall ProgId(); + Utplb_streamcipher::TAlgorithmicFeatureSet __fastcall Features(); + System::UnicodeString __fastcall DefinitionURL(); + System::UnicodeString __fastcall WikipediaReference(); + int __fastcall SeedByteSize(); Utplb_streamcipher::TSymetricKey* __fastcall GenerateKey(System::Classes::TStream* Seed); Utplb_streamcipher::TSymetricKey* __fastcall LoadKeyFromStream(System::Classes::TStream* Store); - int __fastcall BlockSize(void); - int __fastcall KeySize(void); + int __fastcall BlockSize(); + int __fastcall KeySize(); Utplb_blockcipher::_di_IBlockCodec __fastcall MakeBlockCodec(Utplb_streamcipher::TSymetricKey* Key); - System::DynamicArray __fastcall SelfTest_Key(void); - System::DynamicArray __fastcall SelfTest_Plaintext(void); - System::DynamicArray __fastcall SelfTest_Ciphertext(void); - System::TObject* __fastcall ControlObject(void); + System::DynamicArray __fastcall SelfTest_Key(); + System::DynamicArray __fastcall SelfTest_Plaintext(); + System::DynamicArray __fastcall SelfTest_Ciphertext(); + System::TObject* __fastcall ControlObject(); public: __fastcall TAES(int KeySize1); public: - /* TObject.Destroy */ inline __fastcall virtual ~TAES(void) { } + /* TObject.Destroy */ inline __fastcall virtual ~TAES() { } private: void *__IControlObject; // Utplb_decorators::IControlObject diff --git a/hpp/Win32/Release/uTPLb_Asymetric.hpp b/hpp/Win32/Release/uTPLb_Asymetric.hpp index 9673166..3230754 100644 --- a/hpp/Win32/Release/uTPLb_Asymetric.hpp +++ b/hpp/Win32/Release/uTPLb_Asymetric.hpp @@ -2,7 +2,7 @@ // Copyright (c) 1995, 2017 by Embarcadero Technologies, Inc. // All rights reserved -// (DO NOT EDIT: machine generated header) 'uTPLb_Asymetric.pas' rev: 32.00 (Windows) +// (DO NOT EDIT: machine generated header) 'uTPLb_Asymetric.pas' rev: 33.00 (Windows) #ifndef Utplb_asymetricHPP #define Utplb_asymetricHPP @@ -28,9 +28,9 @@ class DELPHICLASS TAsymetricKeyPair; class DELPHICLASS TAsymetricEncDec; class DELPHICLASS TAsymetricEncryptor; class DELPHICLASS TAsymetricDecryptor; -__interface IAsymetric_Engine; +__interface DELPHIINTERFACE IAsymetric_Engine; typedef System::DelphiInterface _di_IAsymetric_Engine; -__interface ICodec_WithAsymetricSupport; +__interface DELPHIINTERFACE ICodec_WithAsymetricSupport; typedef System::DelphiInterface _di_ICodec_WithAsymetricSupport; class DELPHICLASS TAsymetric_Engine; //-- type declarations ------------------------------------------------------- @@ -44,16 +44,16 @@ class PASCALIMPLEMENTATION TAsymtricKeyPart : public System::TObject typedef System::TObject inherited; protected: - virtual unsigned __fastcall NominalKeyBitLength(void) = 0 ; + virtual unsigned __fastcall NominalKeyBitLength() = 0 ; public: virtual void __fastcall SaveToStream(System::Classes::TStream* Store) = 0 ; virtual void __fastcall LoadFromStream(System::Classes::TStream* Store) = 0 ; - virtual bool __fastcall isEmpty(void) = 0 ; - virtual void __fastcall Burn(void) = 0 ; + virtual bool __fastcall isEmpty() = 0 ; + virtual void __fastcall Burn() = 0 ; public: - /* TObject.Create */ inline __fastcall TAsymtricKeyPart(void) : System::TObject() { } - /* TObject.Destroy */ inline __fastcall virtual ~TAsymtricKeyPart(void) { } + /* TObject.Create */ inline __fastcall TAsymtricKeyPart() : System::TObject() { } + /* TObject.Destroy */ inline __fastcall virtual ~TAsymtricKeyPart() { } }; @@ -67,16 +67,16 @@ class PASCALIMPLEMENTATION TAsymetricKeyPair : public Utplb_streamcipher::TSymet public: TAsymtricKeyPart* FPublicPart; TAsymtricKeyPart* FPrivatePart; - __fastcall virtual TAsymetricKeyPair(void) = 0 ; - __fastcall virtual ~TAsymetricKeyPair(void); - virtual TKeyStoragePartSet __fastcall HasParts(void); + __fastcall virtual TAsymetricKeyPair() = 0 ; + __fastcall virtual ~TAsymetricKeyPair(); + virtual TKeyStoragePartSet __fastcall HasParts(); virtual void __fastcall SaveToStream(System::Classes::TStream* Stream); virtual void __fastcall StoreToStream(System::Classes::TStream* Store, TKeyStoragePartSet Parts); virtual bool __fastcall Can_StoreToStream(TKeyStoragePartSet Parts); virtual void __fastcall LoadFromStream(System::Classes::TStream* Store, TKeyStoragePartSet Parts) = 0 ; - unsigned __fastcall NominalKeyBitLength(void); - virtual void __fastcall Burn(void); - virtual TAsymetricKeyPair* __fastcall Clone(void); + unsigned __fastcall NominalKeyBitLength(); + virtual void __fastcall Burn(); + virtual TAsymetricKeyPair* __fastcall Clone(); }; #pragma pack(pop) @@ -91,11 +91,11 @@ class PASCALIMPLEMENTATION TAsymetricEncDec : public System::TInterfacedObject unsigned __int64 FBytesProcessed; Utplb_codecintf::_di_ICodec FSymetricCodec; System::TObject* FSymetricCodecObj; - __fastcall virtual TAsymetricEncDec(void); - virtual void __fastcall Reset(void); + __fastcall virtual TAsymetricEncDec(); + virtual void __fastcall Reset(); public: - __fastcall virtual ~TAsymetricEncDec(void); + __fastcall virtual ~TAsymetricEncDec(); }; @@ -108,16 +108,16 @@ class PASCALIMPLEMENTATION TAsymetricEncryptor : public TAsymetricEncDec System::Classes::TStream* FCipherText; __fastcall virtual TAsymetricEncryptor(TAsymtricKeyPart* PublicKey1, System::Classes::TStream* CipherText1); virtual void __fastcall Encrypt(System::Classes::TStream* const Plaintext); - virtual void __fastcall End_Encrypt(void); + virtual void __fastcall End_Encrypt(); public: - virtual Utplb_streamcipher::TSymetricKey* __fastcall GenerateSymetricKey(void) = 0 ; + virtual Utplb_streamcipher::TSymetricKey* __fastcall GenerateSymetricKey() = 0 ; virtual bool __fastcall VerifySignature(System::Classes::TStream* Document, System::TObject* ProgressSender, Utplb_codecintf::TOnEncDecProgress ProgressEvent, bool &wasAborted) = 0 ; protected: - /* TAsymetricEncDec.Create */ inline __fastcall virtual TAsymetricEncryptor(void) : TAsymetricEncDec() { } + /* TAsymetricEncDec.Create */ inline __fastcall virtual TAsymetricEncryptor() : TAsymetricEncDec() { } public: - /* TAsymetricEncDec.Destroy */ inline __fastcall virtual ~TAsymetricEncryptor(void) { } + /* TAsymetricEncDec.Destroy */ inline __fastcall virtual ~TAsymetricEncryptor() { } private: void *__IStreamEncryptor; // Utplb_streamcipher::IStreamEncryptor @@ -149,16 +149,16 @@ class PASCALIMPLEMENTATION TAsymetricDecryptor : public TAsymetricEncDec System::Classes::TStream* FPlainText; __fastcall virtual TAsymetricDecryptor(TAsymtricKeyPart* PrivateKey1, System::Classes::TStream* PlainText1); virtual void __fastcall Decrypt(System::Classes::TStream* const Ciphertext); - virtual void __fastcall End_Decrypt(void); + virtual void __fastcall End_Decrypt(); public: virtual Utplb_streamcipher::TSymetricKey* __fastcall LoadSymetricKey(System::Classes::TStream* Ciphertext) = 0 ; virtual void __fastcall Sign(System::Classes::TStream* Signature, System::TObject* ProgressSender, Utplb_codecintf::TOnEncDecProgress ProgressEvent, bool &wasAborted) = 0 ; protected: - /* TAsymetricEncDec.Create */ inline __fastcall virtual TAsymetricDecryptor(void) : TAsymetricEncDec() { } + /* TAsymetricEncDec.Create */ inline __fastcall virtual TAsymetricDecryptor() : TAsymetricEncDec() { } public: - /* TAsymetricEncDec.Destroy */ inline __fastcall virtual ~TAsymetricDecryptor(void) { } + /* TAsymetricEncDec.Destroy */ inline __fastcall virtual ~TAsymetricDecryptor() { } private: void *__IStreamDecryptor; // Utplb_streamcipher::IStreamDecryptor @@ -191,7 +191,7 @@ __interface INTERFACE_UUID("{F6B035A8-2829-4F43-B95C-14C77A22B379}") IAsymetric __interface INTERFACE_UUID("{76B67794-CB5A-41BA-B519-9250FDC592C6}") ICodec_WithAsymetricSupport : public Utplb_codecintf::ICodec { - virtual _di_IAsymetric_Engine __fastcall Asymetric_Engine(void) = 0 ; + virtual _di_IAsymetric_Engine __fastcall Asymetric_Engine() = 0 ; }; #pragma pack(push,4) @@ -200,20 +200,20 @@ class PASCALIMPLEMENTATION TAsymetric_Engine : public System::TInterfacedObject typedef System::TInterfacedObject inherited; protected: - virtual System::UnicodeString __fastcall DisplayName(void) = 0 ; - virtual System::UnicodeString __fastcall ProgId(void) = 0 ; - virtual Utplb_streamcipher::TAlgorithmicFeatureSet __fastcall Features(void); - virtual System::UnicodeString __fastcall DefinitionURL(void) = 0 ; - virtual System::UnicodeString __fastcall WikipediaReference(void) = 0 ; + virtual System::UnicodeString __fastcall DisplayName() = 0 ; + virtual System::UnicodeString __fastcall ProgId() = 0 ; + virtual Utplb_streamcipher::TAlgorithmicFeatureSet __fastcall Features(); + virtual System::UnicodeString __fastcall DefinitionURL() = 0 ; + virtual System::UnicodeString __fastcall WikipediaReference() = 0 ; Utplb_streamcipher::TSymetricKey* __fastcall GenerateKey(System::Classes::TStream* Seed); virtual Utplb_streamcipher::TSymetricKey* __fastcall LoadKeyFromStream(System::Classes::TStream* Store) = 0 ; - int __fastcall SeedByteSize(void); + int __fastcall SeedByteSize(); Utplb_streamcipher::_di_IStreamCipher __fastcall Parameterize(const System::_di_IInterface Params); virtual Utplb_streamcipher::_di_IStreamEncryptor __fastcall Start_Encrypt(Utplb_streamcipher::TSymetricKey* Key, System::Classes::TStream* CipherText); virtual Utplb_streamcipher::_di_IStreamDecryptor __fastcall Start_Decrypt(Utplb_streamcipher::TSymetricKey* Key, System::Classes::TStream* PlainText); - virtual TAsymetricKeyPairClass __fastcall AsymetricKeyPairClass(void) = 0 ; - virtual TAsymetricEncryptorClass __fastcall EncClass(void) = 0 ; - virtual TAsymetricDecryptorClass __fastcall DecClass(void) = 0 ; + virtual TAsymetricKeyPairClass __fastcall AsymetricKeyPairClass() = 0 ; + virtual TAsymetricEncryptorClass __fastcall EncClass() = 0 ; + virtual TAsymetricDecryptorClass __fastcall DecClass() = 0 ; public: virtual void __fastcall GenerateAsymetricKeyPair(unsigned KeySizeInBits, System::TObject* ProgressSender, Utplb_codecintf::TGenerateAsymetricKeyPairProgress ProgressEvent, TAsymetricKeyPair* &KeyPair, bool &wasAborted) = 0 ; @@ -221,8 +221,8 @@ class PASCALIMPLEMENTATION TAsymetric_Engine : public System::TInterfacedObject virtual bool __fastcall VerifySignature(System::Classes::TStream* Document, System::Classes::TStream* Signature, TAsymtricKeyPart* PublicPart, System::TObject* ProgressSender, Utplb_codecintf::TOnEncDecProgress ProgressEvent, bool &wasAborted); virtual TAsymetricKeyPair* __fastcall CreateFromStream(System::Classes::TStream* Store, TKeyStoragePartSet Parts) = 0 ; public: - /* TObject.Create */ inline __fastcall TAsymetric_Engine(void) : System::TInterfacedObject() { } - /* TObject.Destroy */ inline __fastcall virtual ~TAsymetric_Engine(void) { } + /* TObject.Create */ inline __fastcall TAsymetric_Engine() : System::TInterfacedObject() { } + /* TObject.Destroy */ inline __fastcall virtual ~TAsymetric_Engine() { } private: void *__IAsymetric_Engine; // IAsymetric_Engine diff --git a/hpp/Win32/Release/uTPLb_Base64.hpp b/hpp/Win32/Release/uTPLb_Base64.hpp index 6114541..18510be 100644 --- a/hpp/Win32/Release/uTPLb_Base64.hpp +++ b/hpp/Win32/Release/uTPLb_Base64.hpp @@ -2,7 +2,7 @@ // Copyright (c) 1995, 2017 by Embarcadero Technologies, Inc. // All rights reserved -// (DO NOT EDIT: machine generated header) 'uTPLb_Base64.pas' rev: 32.00 (Windows) +// (DO NOT EDIT: machine generated header) 'uTPLb_Base64.pas' rev: 33.00 (Windows) #ifndef Utplb_base64HPP #define Utplb_base64HPP @@ -30,20 +30,20 @@ class PASCALIMPLEMENTATION TBase64Converter : public System::TInterfacedObject typedef System::TInterfacedObject inherited; private: - System::UnicodeString __fastcall DisplayName(void); - System::UnicodeString __fastcall ProgId(void); - Utplb_streamcipher::TAlgorithmicFeatureSet __fastcall Features(void); - System::UnicodeString __fastcall DefinitionURL(void); - System::UnicodeString __fastcall WikipediaReference(void); + System::UnicodeString __fastcall DisplayName(); + System::UnicodeString __fastcall ProgId(); + Utplb_streamcipher::TAlgorithmicFeatureSet __fastcall Features(); + System::UnicodeString __fastcall DefinitionURL(); + System::UnicodeString __fastcall WikipediaReference(); Utplb_streamcipher::TSymetricKey* __fastcall GenerateKey(System::Classes::TStream* Seed); Utplb_streamcipher::TSymetricKey* __fastcall LoadKeyFromStream(System::Classes::TStream* Store); - int __fastcall SeedByteSize(void); + int __fastcall SeedByteSize(); Utplb_streamcipher::_di_IStreamCipher __fastcall Parameterize(const System::_di_IInterface Params); Utplb_streamcipher::_di_IStreamEncryptor __fastcall Start_Encrypt(Utplb_streamcipher::TSymetricKey* Key, System::Classes::TStream* CipherText); Utplb_streamcipher::_di_IStreamDecryptor __fastcall Start_Decrypt(Utplb_streamcipher::TSymetricKey* Key, System::Classes::TStream* PlainText); public: - /* TObject.Create */ inline __fastcall TBase64Converter(void) : System::TInterfacedObject() { } - /* TObject.Destroy */ inline __fastcall virtual ~TBase64Converter(void) { } + /* TObject.Create */ inline __fastcall TBase64Converter() : System::TInterfacedObject() { } + /* TObject.Destroy */ inline __fastcall virtual ~TBase64Converter() { } private: void *__IisBase64Converter; // Utplb_streamcipher::IisBase64Converter diff --git a/hpp/Win32/Release/uTPLb_BaseNonVisualComponent.hpp b/hpp/Win32/Release/uTPLb_BaseNonVisualComponent.hpp index d63f9bb..d90c433 100644 --- a/hpp/Win32/Release/uTPLb_BaseNonVisualComponent.hpp +++ b/hpp/Win32/Release/uTPLb_BaseNonVisualComponent.hpp @@ -2,7 +2,7 @@ // Copyright (c) 1995, 2017 by Embarcadero Technologies, Inc. // All rights reserved -// (DO NOT EDIT: machine generated header) 'uTPLb_BaseNonVisualComponent.pas' rev: 32.00 (Windows) +// (DO NOT EDIT: machine generated header) 'uTPLb_BaseNonVisualComponent.pas' rev: 33.00 (Windows) #ifndef Utplb_basenonvisualcomponentHPP #define Utplb_basenonvisualcomponentHPP @@ -21,10 +21,10 @@ namespace Utplb_basenonvisualcomponent { //-- forward type declarations ----------------------------------------------- -__interface ITPLb_Component; +__interface DELPHIINTERFACE ITPLb_Component; typedef System::DelphiInterface _di_ITPLb_Component; class DELPHICLASS TTPLb_BaseNonVisualComponent; -__interface IEventOrigin; +__interface DELPHIINTERFACE IEventOrigin; typedef System::DelphiInterface _di_IEventOrigin; //-- type declarations ------------------------------------------------------- __interface INTERFACE_UUID("{AC0A9DC4-DF61-48A6-B460-408CE9CEEB85}") ITPLb_Component : public System::IInterface @@ -37,14 +37,14 @@ class PASCALIMPLEMENTATION TTPLb_BaseNonVisualComponent : public System::Classes typedef System::Classes::TComponent inherited; private: - System::UnicodeString __fastcall GetAbout(void); + System::UnicodeString __fastcall GetAbout(); void __fastcall SetAbout(const System::UnicodeString Value); __published: __property System::UnicodeString About = {read=GetAbout, write=SetAbout, stored=false}; public: /* TComponent.Create */ inline __fastcall virtual TTPLb_BaseNonVisualComponent(System::Classes::TComponent* AOwner) : System::Classes::TComponent(AOwner) { } - /* TComponent.Destroy */ inline __fastcall virtual ~TTPLb_BaseNonVisualComponent(void) { } + /* TComponent.Destroy */ inline __fastcall virtual ~TTPLb_BaseNonVisualComponent() { } private: void *__ITPLb_Component; // ITPLb_Component diff --git a/hpp/Win32/Release/uTPLb_BinaryUtils.hpp b/hpp/Win32/Release/uTPLb_BinaryUtils.hpp index c0ea978..c7b65aa 100644 --- a/hpp/Win32/Release/uTPLb_BinaryUtils.hpp +++ b/hpp/Win32/Release/uTPLb_BinaryUtils.hpp @@ -2,7 +2,7 @@ // Copyright (c) 1995, 2017 by Embarcadero Technologies, Inc. // All rights reserved -// (DO NOT EDIT: machine generated header) 'uTPLb_BinaryUtils.pas' rev: 32.00 (Windows) +// (DO NOT EDIT: machine generated header) 'uTPLb_BinaryUtils.pas' rev: 33.00 (Windows) #ifndef Utplb_binaryutilsHPP #define Utplb_binaryutilsHPP @@ -29,7 +29,7 @@ extern DELPHI_PACKAGE __int64 __fastcall SwapEndien_s64(__int64 Value); extern DELPHI_PACKAGE unsigned __int64 __fastcall SwapEndien_u64(unsigned __int64 Value); extern DELPHI_PACKAGE unsigned __fastcall RotateLeft1Bit_u32(unsigned Value); extern DELPHI_PACKAGE void __fastcall Read_BigEndien_u32_Hex(const System::UnicodeString Value, System::Classes::TStream* BinaryOut); -extern DELPHI_PACKAGE NativeUInt __fastcall Get_TP_LockBox3_HINSTANCE(void); +extern DELPHI_PACKAGE NativeUInt __fastcall Get_TP_LockBox3_HINSTANCE(); } /* namespace Utplb_binaryutils */ #if !defined(DELPHIHEADER_NO_IMPLICIT_NAMESPACE_USE) && !defined(NO_USING_NAMESPACE_UTPLB_BINARYUTILS) using namespace Utplb_binaryutils; diff --git a/hpp/Win32/Release/uTPLb_BlockCipher.hpp b/hpp/Win32/Release/uTPLb_BlockCipher.hpp index bc0e5f5..dfb81f9 100644 --- a/hpp/Win32/Release/uTPLb_BlockCipher.hpp +++ b/hpp/Win32/Release/uTPLb_BlockCipher.hpp @@ -2,7 +2,7 @@ // Copyright (c) 1995, 2017 by Embarcadero Technologies, Inc. // All rights reserved -// (DO NOT EDIT: machine generated header) 'uTPLb_BlockCipher.pas' rev: 32.00 (Windows) +// (DO NOT EDIT: machine generated header) 'uTPLb_BlockCipher.pas' rev: 33.00 (Windows) #ifndef Utplb_blockcipherHPP #define Utplb_blockcipherHPP @@ -23,37 +23,37 @@ namespace Utplb_blockcipher { //-- forward type declarations ----------------------------------------------- -__interface IBlockCodec; +__interface DELPHIINTERFACE IBlockCodec; typedef System::DelphiInterface _di_IBlockCodec; -__interface IBlockCipher; +__interface DELPHIINTERFACE IBlockCipher; typedef System::DelphiInterface _di_IBlockCipher; class DELPHICLASS TBlockChainLink; -__interface IBlockChainingModel; +__interface DELPHIINTERFACE IBlockChainingModel; typedef System::DelphiInterface _di_IBlockChainingModel; -__interface IBlockCipherSelector; +__interface DELPHIINTERFACE IBlockCipherSelector; typedef System::DelphiInterface _di_IBlockCipherSelector; -__interface IBlockCipherSelectorEx2; +__interface DELPHIINTERFACE IBlockCipherSelectorEx2; typedef System::DelphiInterface _di_IBlockCipherSelectorEx2; //-- type declarations ------------------------------------------------------- __interface INTERFACE_UUID("{7E783A4E-EF17-4820-AB33-EF8EF9DA6F22}") IBlockCodec : public System::IInterface { virtual void __fastcall Encrypt_Block(System::Classes::TMemoryStream* Plaintext, System::Classes::TMemoryStream* Ciphertext) = 0 ; virtual void __fastcall Decrypt_Block(System::Classes::TMemoryStream* Plaintext, System::Classes::TMemoryStream* Ciphertext) = 0 ; - virtual void __fastcall Reset(void) = 0 ; - virtual void __fastcall Burn(void) = 0 ; + virtual void __fastcall Reset() = 0 ; + virtual void __fastcall Burn() = 0 ; }; __interface INTERFACE_UUID("{CB927B43-8A02-4332-B844-A174D1D6B705}") IBlockCipher : public Utplb_streamcipher::ICryptoGraphicAlgorithm { virtual Utplb_streamcipher::TSymetricKey* __fastcall GenerateKey(System::Classes::TStream* Seed) = 0 ; virtual Utplb_streamcipher::TSymetricKey* __fastcall LoadKeyFromStream(System::Classes::TStream* Store) = 0 ; - virtual int __fastcall BlockSize(void) = 0 ; - virtual int __fastcall KeySize(void) = 0 ; - virtual int __fastcall SeedByteSize(void) = 0 ; + virtual int __fastcall BlockSize() = 0 ; + virtual int __fastcall KeySize() = 0 ; + virtual int __fastcall SeedByteSize() = 0 ; virtual _di_IBlockCodec __fastcall MakeBlockCodec(Utplb_streamcipher::TSymetricKey* Key) = 0 ; - virtual System::DynamicArray __fastcall SelfTest_Key(void) = 0 ; - virtual System::DynamicArray __fastcall SelfTest_Plaintext(void) = 0 ; - virtual System::DynamicArray __fastcall SelfTest_Ciphertext(void) = 0 ; + virtual System::DynamicArray __fastcall SelfTest_Key() = 0 ; + virtual System::DynamicArray __fastcall SelfTest_Plaintext() = 0 ; + virtual System::DynamicArray __fastcall SelfTest_Ciphertext() = 0 ; }; #pragma pack(push,4) @@ -68,16 +68,16 @@ class PASCALIMPLEMENTATION TBlockChainLink : public System::TObject __fastcall TBlockChainLink(Utplb_streamcipher::TSymetricKey* Key1, System::Classes::TMemoryStream* IV1, _di_IBlockCodec Cipher1); public: - virtual void __fastcall Burn(void); + virtual void __fastcall Burn(); virtual void __fastcall Reset(System::Classes::TMemoryStream* IV); - virtual TBlockChainLink* __fastcall Clone(void); + virtual TBlockChainLink* __fastcall Clone(); virtual void __fastcall Encrypt_Block(System::Classes::TMemoryStream* Plaintext, System::Classes::TMemoryStream* Ciphertext) = 0 ; virtual void __fastcall Decrypt_Block(System::Classes::TMemoryStream* Plaintext, System::Classes::TMemoryStream* Ciphertext) = 0 ; virtual void __fastcall Encrypt_8bit(System::Byte Plaintext, System::Byte &Ciphertext); virtual void __fastcall Decrypt_8bit(System::Byte &Plaintext, System::Byte Ciphertext); - __fastcall virtual ~TBlockChainLink(void); + __fastcall virtual ~TBlockChainLink(); public: - /* TObject.Create */ inline __fastcall TBlockChainLink(void) : System::TObject() { } + /* TObject.Create */ inline __fastcall TBlockChainLink() : System::TObject() { } }; @@ -91,13 +91,13 @@ __interface INTERFACE_UUID("{7ED854DF-5270-41F7-820A-65BF9B5E1D35}") IBlockChai { virtual TBlockChainLink* __fastcall Chain_EncryptBlock(Utplb_streamcipher::TSymetricKey* Key, System::Classes::TMemoryStream* InitializationVector, const _di_IBlockCodec Cipher) = 0 ; virtual TBlockChainLink* __fastcall Chain_DecryptBlock(Utplb_streamcipher::TSymetricKey* Key, System::Classes::TMemoryStream* InitializationVector, const _di_IBlockCodec Cipher) = 0 ; - virtual TChainingFeatureSet __fastcall ChainingFeatures(void) = 0 ; + virtual TChainingFeatureSet __fastcall ChainingFeatures() = 0 ; }; __interface INTERFACE_UUID("{B08F766E-1EB0-4BA0-9C84-8AF02E13B24C}") IBlockCipherSelector : public System::IInterface { - virtual _di_IBlockCipher __fastcall GetBlockCipher(void) = 0 ; - virtual _di_IBlockChainingModel __fastcall GetChainMode(void) = 0 ; + virtual _di_IBlockCipher __fastcall GetBlockCipher() = 0 ; + virtual _di_IBlockChainingModel __fastcall GetChainMode() = 0 ; }; enum DECLSPEC_DENUM TSymetricEncryptionOption : unsigned char { optUseGivenIV, optOpenSSL_CompatibilityMode }; @@ -108,7 +108,7 @@ typedef void __fastcall (__closure *TSetMemStreamProc)(System::Classes::TMemoryS __interface INTERFACE_UUID("{907D6E07-C840-4EB4-888A-146B94BDFB53}") IBlockCipherSelectorEx2 : public IBlockCipherSelector { - virtual TSymetricEncryptionOptionSet __fastcall GetAdvancedOptions2(void) = 0 ; + virtual TSymetricEncryptionOptionSet __fastcall GetAdvancedOptions2() = 0 ; virtual bool __fastcall hasOnSetIVHandler(TSetMemStreamProc &Proc) = 0 ; }; diff --git a/hpp/Win32/Release/uTPLb_BlowFish.hpp b/hpp/Win32/Release/uTPLb_BlowFish.hpp index a274f27..bb58683 100644 --- a/hpp/Win32/Release/uTPLb_BlowFish.hpp +++ b/hpp/Win32/Release/uTPLb_BlowFish.hpp @@ -2,7 +2,7 @@ // Copyright (c) 1995, 2017 by Embarcadero Technologies, Inc. // All rights reserved -// (DO NOT EDIT: machine generated header) 'uTPLb_BlowFish.pas' rev: 32.00 (Windows) +// (DO NOT EDIT: machine generated header) 'uTPLb_BlowFish.pas' rev: 33.00 (Windows) #ifndef Utplb_blowfishHPP #define Utplb_blowfishHPP @@ -34,26 +34,26 @@ class PASCALIMPLEMENTATION TBlowFish : public System::TInterfacedObject typedef System::TInterfacedObject inherited; private: - System::UnicodeString __fastcall DisplayName(void); - System::UnicodeString __fastcall ProgId(void); - Utplb_streamcipher::TAlgorithmicFeatureSet __fastcall Features(void); - System::UnicodeString __fastcall DefinitionURL(void); - System::UnicodeString __fastcall WikipediaReference(void); + System::UnicodeString __fastcall DisplayName(); + System::UnicodeString __fastcall ProgId(); + Utplb_streamcipher::TAlgorithmicFeatureSet __fastcall Features(); + System::UnicodeString __fastcall DefinitionURL(); + System::UnicodeString __fastcall WikipediaReference(); Utplb_streamcipher::TSymetricKey* __fastcall GenerateKey(System::Classes::TStream* Seed); Utplb_streamcipher::TSymetricKey* __fastcall LoadKeyFromStream(System::Classes::TStream* Store); - int __fastcall BlockSize(void); - int __fastcall KeySize(void); + int __fastcall BlockSize(); + int __fastcall KeySize(); Utplb_blockcipher::_di_IBlockCodec __fastcall MakeBlockCodec(Utplb_streamcipher::TSymetricKey* Key); - System::DynamicArray __fastcall SelfTest_Key(void); - System::DynamicArray __fastcall SelfTest_Plaintext(void); - System::DynamicArray __fastcall SelfTest_Ciphertext(void); - System::TObject* __fastcall ControlObject(void); - int __fastcall SeedByteSize(void); + System::DynamicArray __fastcall SelfTest_Key(); + System::DynamicArray __fastcall SelfTest_Plaintext(); + System::DynamicArray __fastcall SelfTest_Ciphertext(); + System::TObject* __fastcall ControlObject(); + int __fastcall SeedByteSize(); public: - __fastcall TBlowFish(void); + __fastcall TBlowFish(); public: - /* TObject.Destroy */ inline __fastcall virtual ~TBlowFish(void) { } + /* TObject.Destroy */ inline __fastcall virtual ~TBlowFish() { } private: void *__IControlObject; // Utplb_decorators::IControlObject @@ -106,8 +106,8 @@ class PASCALIMPLEMENTATION TBlowFishFactory : public System::TObject public: __classmethod Utplb_streamcipher::TSymetricKey* __fastcall GenerateFromSeed(System::Classes::TStream* ASeed); public: - /* TObject.Create */ inline __fastcall TBlowFishFactory(void) : System::TObject() { } - /* TObject.Destroy */ inline __fastcall virtual ~TBlowFishFactory(void) { } + /* TObject.Create */ inline __fastcall TBlowFishFactory() : System::TObject() { } + /* TObject.Destroy */ inline __fastcall virtual ~TBlowFishFactory() { } }; diff --git a/hpp/Win32/Release/uTPLb_CBC.hpp b/hpp/Win32/Release/uTPLb_CBC.hpp index 6bc74bb..62872fd 100644 --- a/hpp/Win32/Release/uTPLb_CBC.hpp +++ b/hpp/Win32/Release/uTPLb_CBC.hpp @@ -2,7 +2,7 @@ // Copyright (c) 1995, 2017 by Embarcadero Technologies, Inc. // All rights reserved -// (DO NOT EDIT: machine generated header) 'uTPLb_CBC.pas' rev: 32.00 (Windows) +// (DO NOT EDIT: machine generated header) 'uTPLb_CBC.pas' rev: 33.00 (Windows) #ifndef Utplb_cbcHPP #define Utplb_cbcHPP @@ -34,15 +34,15 @@ class PASCALIMPLEMENTATION TCBC : public System::TInterfacedObject protected: Utplb_blockcipher::TBlockChainLink* __fastcall Chain_EncryptBlock(Utplb_streamcipher::TSymetricKey* Key, System::Classes::TMemoryStream* InitializationVector, const Utplb_blockcipher::_di_IBlockCodec Cipher); Utplb_blockcipher::TBlockChainLink* __fastcall Chain_DecryptBlock(Utplb_streamcipher::TSymetricKey* Key, System::Classes::TMemoryStream* InitializationVector, const Utplb_blockcipher::_di_IBlockCodec Cipher); - System::UnicodeString __fastcall DisplayName(void); - System::UnicodeString __fastcall ProgId(void); - Utplb_streamcipher::TAlgorithmicFeatureSet __fastcall Features(void); - Utplb_blockcipher::TChainingFeatureSet __fastcall ChainingFeatures(void); - System::UnicodeString __fastcall DefinitionURL(void); - System::UnicodeString __fastcall WikipediaReference(void); + System::UnicodeString __fastcall DisplayName(); + System::UnicodeString __fastcall ProgId(); + Utplb_streamcipher::TAlgorithmicFeatureSet __fastcall Features(); + Utplb_blockcipher::TChainingFeatureSet __fastcall ChainingFeatures(); + System::UnicodeString __fastcall DefinitionURL(); + System::UnicodeString __fastcall WikipediaReference(); public: - /* TObject.Create */ inline __fastcall TCBC(void) : System::TInterfacedObject() { } - /* TObject.Destroy */ inline __fastcall virtual ~TCBC(void) { } + /* TObject.Create */ inline __fastcall TCBC() : System::TInterfacedObject() { } + /* TObject.Destroy */ inline __fastcall virtual ~TCBC() { } private: void *__IBlockChainingModel; // Utplb_blockcipher::IBlockChainingModel @@ -73,16 +73,16 @@ class PASCALIMPLEMENTATION TCBCLink : public Utplb_blockcipher::TBlockChainLink System::Classes::TMemoryStream* FNextCV; public: - virtual void __fastcall Burn(void); - virtual Utplb_blockcipher::TBlockChainLink* __fastcall Clone(void); - __fastcall virtual ~TCBCLink(void); + virtual void __fastcall Burn(); + virtual Utplb_blockcipher::TBlockChainLink* __fastcall Clone(); + __fastcall virtual ~TCBCLink(); virtual void __fastcall Encrypt_Block(System::Classes::TMemoryStream* Plaintext, System::Classes::TMemoryStream* Ciphertext); virtual void __fastcall Decrypt_Block(System::Classes::TMemoryStream* Plaintext, System::Classes::TMemoryStream* Ciphertext); protected: /* TBlockChainLink.BaseCreate */ inline __fastcall TCBCLink(Utplb_streamcipher::TSymetricKey* Key1, System::Classes::TMemoryStream* IV1, Utplb_blockcipher::_di_IBlockCodec Cipher1) : Utplb_blockcipher::TBlockChainLink(Key1, IV1, Cipher1) { } public: - /* TObject.Create */ inline __fastcall TCBCLink(void) : Utplb_blockcipher::TBlockChainLink() { } + /* TObject.Create */ inline __fastcall TCBCLink() : Utplb_blockcipher::TBlockChainLink() { } }; diff --git a/hpp/Win32/Release/uTPLb_CFB_8Bit.hpp b/hpp/Win32/Release/uTPLb_CFB_8Bit.hpp index 6b149bf..c1ab8c6 100644 --- a/hpp/Win32/Release/uTPLb_CFB_8Bit.hpp +++ b/hpp/Win32/Release/uTPLb_CFB_8Bit.hpp @@ -2,7 +2,7 @@ // Copyright (c) 1995, 2017 by Embarcadero Technologies, Inc. // All rights reserved -// (DO NOT EDIT: machine generated header) 'uTPLb_CFB_8Bit.pas' rev: 32.00 (Windows) +// (DO NOT EDIT: machine generated header) 'uTPLb_CFB_8Bit.pas' rev: 33.00 (Windows) #ifndef Utplb_cfb_8bitHPP #define Utplb_cfb_8bitHPP @@ -34,15 +34,15 @@ class PASCALIMPLEMENTATION TCFB_8Bit : public System::TInterfacedObject protected: Utplb_blockcipher::TBlockChainLink* __fastcall Chain_EncryptBlock(Utplb_streamcipher::TSymetricKey* Key, System::Classes::TMemoryStream* InitializationVector, const Utplb_blockcipher::_di_IBlockCodec Cipher); Utplb_blockcipher::TBlockChainLink* __fastcall Chain_DecryptBlock(Utplb_streamcipher::TSymetricKey* Key, System::Classes::TMemoryStream* InitializationVector, const Utplb_blockcipher::_di_IBlockCodec Cipher); - System::UnicodeString __fastcall DisplayName(void); - System::UnicodeString __fastcall ProgId(void); - Utplb_streamcipher::TAlgorithmicFeatureSet __fastcall Features(void); - Utplb_blockcipher::TChainingFeatureSet __fastcall ChainingFeatures(void); - System::UnicodeString __fastcall DefinitionURL(void); - System::UnicodeString __fastcall WikipediaReference(void); + System::UnicodeString __fastcall DisplayName(); + System::UnicodeString __fastcall ProgId(); + Utplb_streamcipher::TAlgorithmicFeatureSet __fastcall Features(); + Utplb_blockcipher::TChainingFeatureSet __fastcall ChainingFeatures(); + System::UnicodeString __fastcall DefinitionURL(); + System::UnicodeString __fastcall WikipediaReference(); public: - /* TObject.Create */ inline __fastcall TCFB_8Bit(void) : System::TInterfacedObject() { } - /* TObject.Destroy */ inline __fastcall virtual ~TCFB_8Bit(void) { } + /* TObject.Create */ inline __fastcall TCFB_8Bit() : System::TInterfacedObject() { } + /* TObject.Destroy */ inline __fastcall virtual ~TCFB_8Bit() { } private: void *__IBlockChainingModel; // Utplb_blockcipher::IBlockChainingModel @@ -75,9 +75,9 @@ class PASCALIMPLEMENTATION TCFB_8BitLink : public Utplb_blockcipher::TBlockChain __fastcall TCFB_8BitLink(Utplb_streamcipher::TSymetricKey* Key1, System::Classes::TMemoryStream* IV1, Utplb_blockcipher::_di_IBlockCodec Cipher1); public: - virtual void __fastcall Burn(void); - virtual Utplb_blockcipher::TBlockChainLink* __fastcall Clone(void); - __fastcall virtual ~TCFB_8BitLink(void); + virtual void __fastcall Burn(); + virtual Utplb_blockcipher::TBlockChainLink* __fastcall Clone(); + __fastcall virtual ~TCFB_8BitLink(); virtual void __fastcall Encrypt_Block(System::Classes::TMemoryStream* Plaintext, System::Classes::TMemoryStream* Ciphertext); virtual void __fastcall Decrypt_Block(System::Classes::TMemoryStream* Plaintext, System::Classes::TMemoryStream* Ciphertext); virtual void __fastcall Encrypt_8bit(System::Byte Plaintext, System::Byte &Ciphertext); diff --git a/hpp/Win32/Release/uTPLb_CFB_Block.hpp b/hpp/Win32/Release/uTPLb_CFB_Block.hpp index f96bd55..2e8509c 100644 --- a/hpp/Win32/Release/uTPLb_CFB_Block.hpp +++ b/hpp/Win32/Release/uTPLb_CFB_Block.hpp @@ -2,7 +2,7 @@ // Copyright (c) 1995, 2017 by Embarcadero Technologies, Inc. // All rights reserved -// (DO NOT EDIT: machine generated header) 'uTPLb_CFB_Block.pas' rev: 32.00 (Windows) +// (DO NOT EDIT: machine generated header) 'uTPLb_CFB_Block.pas' rev: 33.00 (Windows) #ifndef Utplb_cfb_blockHPP #define Utplb_cfb_blockHPP @@ -34,15 +34,15 @@ class PASCALIMPLEMENTATION TCFB_Block : public System::TInterfacedObject protected: Utplb_blockcipher::TBlockChainLink* __fastcall Chain_EncryptBlock(Utplb_streamcipher::TSymetricKey* Key, System::Classes::TMemoryStream* InitializationVector, const Utplb_blockcipher::_di_IBlockCodec Cipher); Utplb_blockcipher::TBlockChainLink* __fastcall Chain_DecryptBlock(Utplb_streamcipher::TSymetricKey* Key, System::Classes::TMemoryStream* InitializationVector, const Utplb_blockcipher::_di_IBlockCodec Cipher); - System::UnicodeString __fastcall DisplayName(void); - System::UnicodeString __fastcall ProgId(void); - Utplb_streamcipher::TAlgorithmicFeatureSet __fastcall Features(void); - Utplb_blockcipher::TChainingFeatureSet __fastcall ChainingFeatures(void); - System::UnicodeString __fastcall DefinitionURL(void); - System::UnicodeString __fastcall WikipediaReference(void); + System::UnicodeString __fastcall DisplayName(); + System::UnicodeString __fastcall ProgId(); + Utplb_streamcipher::TAlgorithmicFeatureSet __fastcall Features(); + Utplb_blockcipher::TChainingFeatureSet __fastcall ChainingFeatures(); + System::UnicodeString __fastcall DefinitionURL(); + System::UnicodeString __fastcall WikipediaReference(); public: - /* TObject.Create */ inline __fastcall TCFB_Block(void) : System::TInterfacedObject() { } - /* TObject.Destroy */ inline __fastcall virtual ~TCFB_Block(void) { } + /* TObject.Create */ inline __fastcall TCFB_Block() : System::TInterfacedObject() { } + /* TObject.Destroy */ inline __fastcall virtual ~TCFB_Block() { } private: void *__IBlockChainingModel; // Utplb_blockcipher::IBlockChainingModel @@ -76,10 +76,10 @@ class PASCALIMPLEMENTATION TCFB_BlockLink : public Utplb_blockcipher::TBlockChai /* TBlockChainLink.BaseCreate */ inline __fastcall TCFB_BlockLink(Utplb_streamcipher::TSymetricKey* Key1, System::Classes::TMemoryStream* IV1, Utplb_blockcipher::_di_IBlockCodec Cipher1) : Utplb_blockcipher::TBlockChainLink(Key1, IV1, Cipher1) { } public: - /* TBlockChainLink.Destroy */ inline __fastcall virtual ~TCFB_BlockLink(void) { } + /* TBlockChainLink.Destroy */ inline __fastcall virtual ~TCFB_BlockLink() { } public: - /* TObject.Create */ inline __fastcall TCFB_BlockLink(void) : Utplb_blockcipher::TBlockChainLink() { } + /* TObject.Create */ inline __fastcall TCFB_BlockLink() : Utplb_blockcipher::TBlockChainLink() { } }; diff --git a/hpp/Win32/Release/uTPLb_CTR.hpp b/hpp/Win32/Release/uTPLb_CTR.hpp index 331707b..7d9bd97 100644 --- a/hpp/Win32/Release/uTPLb_CTR.hpp +++ b/hpp/Win32/Release/uTPLb_CTR.hpp @@ -2,7 +2,7 @@ // Copyright (c) 1995, 2017 by Embarcadero Technologies, Inc. // All rights reserved -// (DO NOT EDIT: machine generated header) 'uTPLb_CTR.pas' rev: 32.00 (Windows) +// (DO NOT EDIT: machine generated header) 'uTPLb_CTR.pas' rev: 33.00 (Windows) #ifndef Utplb_ctrHPP #define Utplb_ctrHPP @@ -34,15 +34,15 @@ class PASCALIMPLEMENTATION TCTR : public System::TInterfacedObject protected: Utplb_blockcipher::TBlockChainLink* __fastcall Chain_EncryptBlock(Utplb_streamcipher::TSymetricKey* Key, System::Classes::TMemoryStream* InitializationVector, const Utplb_blockcipher::_di_IBlockCodec Cipher); Utplb_blockcipher::TBlockChainLink* __fastcall Chain_DecryptBlock(Utplb_streamcipher::TSymetricKey* Key, System::Classes::TMemoryStream* InitializationVector, const Utplb_blockcipher::_di_IBlockCodec Cipher); - System::UnicodeString __fastcall DisplayName(void); - System::UnicodeString __fastcall ProgId(void); - Utplb_streamcipher::TAlgorithmicFeatureSet __fastcall Features(void); - Utplb_blockcipher::TChainingFeatureSet __fastcall ChainingFeatures(void); - System::UnicodeString __fastcall DefinitionURL(void); - System::UnicodeString __fastcall WikipediaReference(void); + System::UnicodeString __fastcall DisplayName(); + System::UnicodeString __fastcall ProgId(); + Utplb_streamcipher::TAlgorithmicFeatureSet __fastcall Features(); + Utplb_blockcipher::TChainingFeatureSet __fastcall ChainingFeatures(); + System::UnicodeString __fastcall DefinitionURL(); + System::UnicodeString __fastcall WikipediaReference(); public: - /* TObject.Create */ inline __fastcall TCTR(void) : System::TInterfacedObject() { } - /* TObject.Destroy */ inline __fastcall virtual ~TCTR(void) { } + /* TObject.Create */ inline __fastcall TCTR() : System::TInterfacedObject() { } + /* TObject.Destroy */ inline __fastcall virtual ~TCTR() { } private: void *__IBlockChainingModel; // Utplb_blockcipher::IBlockChainingModel @@ -76,11 +76,11 @@ class PASCALIMPLEMENTATION TCTRLink : public Utplb_blockcipher::TBlockChainLink __fastcall TCTRLink(Utplb_streamcipher::TSymetricKey* Key1, System::Classes::TMemoryStream* IV1, Utplb_blockcipher::_di_IBlockCodec Cipher1); public: - virtual Utplb_blockcipher::TBlockChainLink* __fastcall Clone(void); + virtual Utplb_blockcipher::TBlockChainLink* __fastcall Clone(); virtual void __fastcall Encrypt_Block(System::Classes::TMemoryStream* Plaintext, System::Classes::TMemoryStream* Ciphertext); virtual void __fastcall Decrypt_Block(System::Classes::TMemoryStream* Plaintext, System::Classes::TMemoryStream* Ciphertext); public: - /* TBlockChainLink.Destroy */ inline __fastcall virtual ~TCTRLink(void) { } + /* TBlockChainLink.Destroy */ inline __fastcall virtual ~TCTRLink() { } }; diff --git a/hpp/Win32/Release/uTPLb_CipherUtils.hpp b/hpp/Win32/Release/uTPLb_CipherUtils.hpp index be1f77b..130705b 100644 --- a/hpp/Win32/Release/uTPLb_CipherUtils.hpp +++ b/hpp/Win32/Release/uTPLb_CipherUtils.hpp @@ -2,7 +2,7 @@ // Copyright (c) 1995, 2017 by Embarcadero Technologies, Inc. // All rights reserved -// (DO NOT EDIT: machine generated header) 'uTPLb_CipherUtils.pas' rev: 32.00 (Windows) +// (DO NOT EDIT: machine generated header) 'uTPLb_CipherUtils.pas' rev: 33.00 (Windows) #ifndef Utplb_cipherutilsHPP #define Utplb_cipherutilsHPP @@ -31,10 +31,10 @@ class PASCALIMPLEMENTATION TDummyKey : public Utplb_streamcipher::TSymetricKey public: virtual void __fastcall SaveToStream(System::Classes::TStream* Stream); - virtual void __fastcall Burn(void); + virtual void __fastcall Burn(); public: - /* TObject.Create */ inline __fastcall TDummyKey(void) : Utplb_streamcipher::TSymetricKey() { } - /* TObject.Destroy */ inline __fastcall virtual ~TDummyKey(void) { } + /* TObject.Create */ inline __fastcall TDummyKey() : Utplb_streamcipher::TSymetricKey() { } + /* TObject.Destroy */ inline __fastcall virtual ~TDummyKey() { } }; diff --git a/hpp/Win32/Release/uTPLb_Codec.hpp b/hpp/Win32/Release/uTPLb_Codec.hpp index 3ffb775..fec84f6 100644 --- a/hpp/Win32/Release/uTPLb_Codec.hpp +++ b/hpp/Win32/Release/uTPLb_Codec.hpp @@ -2,7 +2,7 @@ // Copyright (c) 1995, 2017 by Embarcadero Technologies, Inc. // All rights reserved -// (DO NOT EDIT: machine generated header) 'uTPLb_Codec.pas' rev: 32.00 (Windows) +// (DO NOT EDIT: machine generated header) 'uTPLb_Codec.pas' rev: 33.00 (Windows) #ifndef Utplb_codecHPP #define Utplb_codecHPP @@ -32,7 +32,7 @@ namespace Utplb_codec { //-- forward type declarations ----------------------------------------------- class DELPHICLASS TSimpleCodec; -__interface ICodec_TestAccess; +__interface DELPHIINTERFACE ICodec_TestAccess; typedef System::DelphiInterface _di_ICodec_TestAccess; class DELPHICLASS TCodec; //-- type declarations ------------------------------------------------------- @@ -67,49 +67,49 @@ class PASCALIMPLEMENTATION TSimpleCodec : public System::Classes::TInterfacedPer void __fastcall SetStreamCipher(const Utplb_streamcipher::_di_IStreamCipher Value); void __fastcall SetBlockCipher(const Utplb_blockcipher::_di_IBlockCipher Value); void __fastcall SetChainMode(const Utplb_blockcipher::_di_IBlockChainingModel Value); - Utplb_codecintf::TCodecMode __fastcall GetMode(void); - Utplb_streamcipher::_di_IStreamCipher __fastcall GetStreamCipher(void); - Utplb_blockcipher::_di_IBlockCipher __fastcall GetBlockCipher(void); - Utplb_blockcipher::_di_IBlockChainingModel __fastcall GetChainMode(void); - Utplb_codecintf::TOnEncDecProgress __fastcall GetOnProgress(void); + Utplb_codecintf::TCodecMode __fastcall GetMode(); + Utplb_streamcipher::_di_IStreamCipher __fastcall GetStreamCipher(); + Utplb_blockcipher::_di_IBlockCipher __fastcall GetBlockCipher(); + Utplb_blockcipher::_di_IBlockChainingModel __fastcall GetChainMode(); + Utplb_codecintf::TOnEncDecProgress __fastcall GetOnProgress(); void __fastcall SetOnProgress(Utplb_codecintf::TOnEncDecProgress Value); void __fastcall SetEventSender(System::TObject* Sender); - bool __fastcall isNotBase64Converter(void); - unsigned __fastcall GetAsymetricKeySizeInBits(void); + bool __fastcall isNotBase64Converter(); + unsigned __fastcall GetAsymetricKeySizeInBits(); void __fastcall SetAsymetricKeySizeInBits(unsigned value); - Utplb_codecintf::TGenerateAsymetricKeyPairProgress __fastcall GetAsymGenProgressEvent(void); + Utplb_codecintf::TGenerateAsymetricKeyPairProgress __fastcall GetAsymGenProgressEvent(); void __fastcall SetAsymGenProgressEvent(Utplb_codecintf::TGenerateAsymetricKeyPairProgress Value); - Utplb_streamcipher::TSymetricKey* __fastcall GetKey(void); - Utplb_asymetric::_di_IAsymetric_Engine __fastcall Asymetric_Engine(void); - void __fastcall End_EncryptDecrypt(void); - void __fastcall DoProgress(void); - void __fastcall InitCheck(void); - Utplb_blockcipher::TSymetricEncryptionOptionSet __fastcall GetAdvancedOptions2(void); + Utplb_streamcipher::TSymetricKey* __fastcall GetKey(); + Utplb_asymetric::_di_IAsymetric_Engine __fastcall Asymetric_Engine(); + void __fastcall End_EncryptDecrypt(); + void __fastcall DoProgress(); + void __fastcall InitCheck(); + Utplb_blockcipher::TSymetricEncryptionOptionSet __fastcall GetAdvancedOptions2(); void __fastcall SetAdvancedOptions2(Utplb_blockcipher::TSymetricEncryptionOptionSet Value); bool __fastcall hasOnSetIVHandler(Utplb_blockcipher::TSetMemStreamProc &Proc); - Utplb_blockcipher::TSetMemStreamProc __fastcall GetOnSetIV(void); + Utplb_blockcipher::TSetMemStreamProc __fastcall GetOnSetIV(); void __fastcall SetOnSetIV(Utplb_blockcipher::TSetMemStreamProc Value); public: - __fastcall TSimpleCodec(void); - __fastcall virtual ~TSimpleCodec(void); + __fastcall TSimpleCodec(); + __fastcall virtual ~TSimpleCodec(); void __fastcall Init(const System::UnicodeString Key, System::Sysutils::TEncoding* AEncoding); void __fastcall InitA(const System::UnicodeString Key); void __fastcall SaveKeyToStream(System::Classes::TStream* Store); void __fastcall InitFromStream(System::Classes::TStream* Store); void __fastcall InitFromKey(Utplb_streamcipher::TSymetricKey* Key); - void __fastcall Reset(void); + void __fastcall Reset(); void __fastcall Burn(bool doIncludeBurnKey); - bool __fastcall isAsymetric(void); - void __fastcall InitFromGeneratedAsymetricKeyPair(void); + bool __fastcall isAsymetric(); + void __fastcall InitFromGeneratedAsymetricKeyPair(); void __fastcall Sign(System::Classes::TStream* Document, System::Classes::TStream* Signature, System::TObject* ProgressSender, Utplb_codecintf::TOnEncDecProgress ProgressEvent, System::TObject* SigningKeys_PrivatePart, bool &wasAborted); bool __fastcall VerifySignature(System::Classes::TStream* Document, System::Classes::TStream* Signature, System::TObject* ProgressSender, Utplb_codecintf::TOnEncDecProgress ProgressEvent, System::TObject* SigningKeys_PublicPart, bool &wasAborted); void __fastcall Begin_EncryptMemory(System::Classes::TStream* CipherText); void __fastcall EncryptMemory(const System::DynamicArray Plaintext, int PlaintextLen); - void __fastcall End_EncryptMemory(void); + void __fastcall End_EncryptMemory(); void __fastcall Begin_DecryptMemory(System::Classes::TStream* Plaintext); void __fastcall DecryptMemory(const void *CipherText, int CiphertextLen); - void __fastcall End_DecryptMemory(void); + void __fastcall End_DecryptMemory(); void __fastcall EncryptStream(System::Classes::TStream* Plaintext, System::Classes::TStream* CipherText); void __fastcall DecryptStream(System::Classes::TStream* Plaintext, System::Classes::TStream* CipherText); void __fastcall EncryptFile(const System::UnicodeString Plaintext_FileName, const System::UnicodeString CipherText_FileName); @@ -118,7 +118,7 @@ class PASCALIMPLEMENTATION TSimpleCodec : public System::Classes::TInterfacedPer void __fastcall DecryptString(System::UnicodeString &Plaintext, const System::UnicodeString CipherText_Base64, System::Sysutils::TEncoding* AEncoding); void __fastcall EncryptAnsiString(const System::UnicodeString Plaintext, System::UnicodeString &CipherText_Base64); void __fastcall DecryptAnsiString(System::UnicodeString &Plaintext, const System::UnicodeString CipherText_Base64); - bool __fastcall GetAborted(void); + bool __fastcall GetAborted(); void __fastcall SetAborted(bool Value); System::UnicodeString __fastcall GetCipherDisplayName(Utplb_cryptographiclibrary::TCryptographicLibrary* Lib); __property Utplb_codecintf::TCodecMode Mode = {read=GetMode, nodefault}; @@ -194,7 +194,7 @@ class PASCALIMPLEMENTATION TSimpleCodec : public System::Classes::TInterfacedPer __interface INTERFACE_UUID("{1DCED340-E6C0-4B97-BBAA-98305B5D4F5E}") ICodec_TestAccess : public System::IInterface { - virtual Utplb_codecintf::_di_ICodec __fastcall GetCodecIntf(void) = 0 ; + virtual Utplb_codecintf::_di_ICodec __fastcall GetCodecIntf() = 0 ; }; class PASCALIMPLEMENTATION TCodec : public Utplb_basenonvisualcomponent::TTPLb_BaseNonVisualComponent @@ -229,52 +229,52 @@ class PASCALIMPLEMENTATION TCodec : public Utplb_basenonvisualcomponent::TTPLb_B void __fastcall WriteData_Block(System::Classes::TWriter* Writer); void __fastcall ReadData_Chain(System::Classes::TReader* Reader); void __fastcall WriteData_Chain(System::Classes::TWriter* Writer); - Utplb_codecintf::TCodecMode __fastcall GetMode(void); - Utplb_hash::TOnHashProgress __fastcall GetOnProgress(void); + Utplb_codecintf::TCodecMode __fastcall GetMode(); + Utplb_hash::TOnHashProgress __fastcall GetOnProgress(); void __fastcall SetOnProgress(const Utplb_hash::TOnHashProgress Value); - void __fastcall ProgIdsChanged(void); - Utplb_codecintf::_di_ICodec __fastcall GetCodecIntf(void); + void __fastcall ProgIdsChanged(); + Utplb_codecintf::_di_ICodec __fastcall GetCodecIntf(); void __fastcall SetPassword(const System::UnicodeString NewPassword); void __fastcall GenerateAsymetricKeyPairProgress_Event(System::TObject* Sender, int CountPrimalityTests, bool &doAbort); - unsigned __fastcall GetAsymetricKeySizeInBits(void); + unsigned __fastcall GetAsymetricKeySizeInBits(); void __fastcall SetAsymetricKeySizeInBits(unsigned value); - Utplb_streamcipher::TSymetricKey* __fastcall GetKey(void); - void __fastcall BeginEncDec(void); - void __fastcall EndEncDec(void); - void __fastcall ClearPassword(void); - Utplb_blockcipher::TSymetricEncryptionOptionSet __fastcall GetAdvancedOptions2(void); + Utplb_streamcipher::TSymetricKey* __fastcall GetKey(); + void __fastcall BeginEncDec(); + void __fastcall EndEncDec(); + void __fastcall ClearPassword(); + Utplb_blockcipher::TSymetricEncryptionOptionSet __fastcall GetAdvancedOptions2(); void __fastcall SetAdvancedOptions2(Utplb_blockcipher::TSymetricEncryptionOptionSet Value); - Utplb_blockcipher::TSetMemStreamProc __fastcall GetOnSetIV(void); + Utplb_blockcipher::TSetMemStreamProc __fastcall GetOnSetIV(); void __fastcall SetOnSetIV(Utplb_blockcipher::TSetMemStreamProc Value); protected: virtual void __fastcall Notification(System::Classes::TComponent* AComponent, System::Classes::TOperation Operation); virtual void __fastcall DefineProperties(System::Classes::TFiler* Filer); - virtual System::UnicodeString __fastcall GetCipherDisplayName(void); - virtual System::UnicodeString __fastcall GetChainDisplayName(void); - virtual void __fastcall Loaded(void); + virtual System::UnicodeString __fastcall GetCipherDisplayName(); + virtual System::UnicodeString __fastcall GetChainDisplayName(); + virtual void __fastcall Loaded(); __property bool InterfacesAreCached = {read=FIntfCached, write=SetIntfCached, nodefault}; public: int FGenerateAsymetricKeyPairProgress_CountPrimalityTests; __fastcall virtual TCodec(System::Classes::TComponent* AOwner); - __fastcall virtual ~TCodec(void); - void __fastcall Burn(void); - void __fastcall Reset(void); + __fastcall virtual ~TCodec(); + void __fastcall Burn(); + void __fastcall Reset(); void __fastcall SaveKeyToStream(System::Classes::TStream* Store); void __fastcall InitFromStream(System::Classes::TStream* Store); - bool __fastcall GetAborted(void); + bool __fastcall GetAborted(); void __fastcall SetAborted(bool Value); - bool __fastcall isAsymetric(void); - Utplb_asymetric::_di_IAsymetric_Engine __fastcall Asymetric_Engine(void); + bool __fastcall isAsymetric(); + Utplb_asymetric::_di_IAsymetric_Engine __fastcall Asymetric_Engine(); void __fastcall InitFromKey(Utplb_streamcipher::TSymetricKey* Key); - void __fastcall InitFromGeneratedAsymetricKeyPair(void); + void __fastcall InitFromGeneratedAsymetricKeyPair(); void __fastcall Begin_EncryptMemory(System::Classes::TStream* CipherText); void __fastcall EncryptMemory(const System::DynamicArray Plaintext, int PlaintextLen); - void __fastcall End_EncryptMemory(void); + void __fastcall End_EncryptMemory(); void __fastcall Begin_DecryptMemory(System::Classes::TStream* Plaintext); void __fastcall DecryptMemory(const void *CipherText, int CiphertextLen); - void __fastcall End_DecryptMemory(void); + void __fastcall End_DecryptMemory(); void __fastcall EncryptStream(System::Classes::TStream* Plaintext, System::Classes::TStream* CipherText); void __fastcall DecryptStream(System::Classes::TStream* Plaintext, System::Classes::TStream* CipherText); void __fastcall EncryptFile(const System::UnicodeString Plaintext_FileName, const System::UnicodeString CipherText_FileName); @@ -283,7 +283,7 @@ class PASCALIMPLEMENTATION TCodec : public Utplb_basenonvisualcomponent::TTPLb_B void __fastcall DecryptString(System::UnicodeString &Plaintext, const System::UnicodeString CipherText_Base64, System::Sysutils::TEncoding* AEncoding); void __fastcall EncryptAnsiString(const System::UnicodeString Plaintext, System::UnicodeString &CipherText_Base64); void __fastcall DecryptAnsiString(System::UnicodeString &Plaintext, const System::UnicodeString CipherText_Base64); - int __fastcall Speed(void); + int __fastcall Speed(); __property Utplb_streamcipher::TSymetricKey* Key = {read=GetKey}; __property System::UnicodeString StreamCipherId = {read=FStreamCipherId, write=SetStreamCipherId}; __property System::UnicodeString BlockCipherId = {read=FBlockCipherId, write=SetBlockCipherId}; diff --git a/hpp/Win32/Release/uTPLb_CodecIntf.hpp b/hpp/Win32/Release/uTPLb_CodecIntf.hpp index 9823730..719e92f 100644 --- a/hpp/Win32/Release/uTPLb_CodecIntf.hpp +++ b/hpp/Win32/Release/uTPLb_CodecIntf.hpp @@ -2,7 +2,7 @@ // Copyright (c) 1995, 2017 by Embarcadero Technologies, Inc. // All rights reserved -// (DO NOT EDIT: machine generated header) 'uTPLb_CodecIntf.pas' rev: 32.00 (Windows) +// (DO NOT EDIT: machine generated header) 'uTPLb_CodecIntf.pas' rev: 33.00 (Windows) #ifndef Utplb_codecintfHPP #define Utplb_codecintfHPP @@ -25,7 +25,7 @@ namespace Utplb_codecintf { //-- forward type declarations ----------------------------------------------- -__interface ICodec; +__interface DELPHIINTERFACE ICodec; typedef System::DelphiInterface _di_ICodec; //-- type declarations ------------------------------------------------------- enum DECLSPEC_DENUM TCodecMode : unsigned char { cmUnitialized, cmIdle, cmEncrypting, cmDecrypting }; @@ -39,34 +39,34 @@ __interface INTERFACE_UUID("{48B3116A-5681-4E79-9013-8EC89BAC5B35}") ICodec : virtual void __fastcall SetStreamCipher(const Utplb_streamcipher::_di_IStreamCipher Value) = 0 ; virtual void __fastcall SetBlockCipher(const Utplb_blockcipher::_di_IBlockCipher Value) = 0 ; virtual void __fastcall SetChainMode(const Utplb_blockcipher::_di_IBlockChainingModel Value) = 0 ; - virtual TCodecMode __fastcall GetMode(void) = 0 ; - virtual Utplb_streamcipher::_di_IStreamCipher __fastcall GetStreamCipher(void) = 0 ; - virtual Utplb_blockcipher::_di_IBlockCipher __fastcall GetBlockCipher(void) = 0 ; - virtual Utplb_blockcipher::_di_IBlockChainingModel __fastcall GetChainMode(void) = 0 ; - virtual TOnEncDecProgress __fastcall GetOnProgress(void) = 0 ; + virtual TCodecMode __fastcall GetMode() = 0 ; + virtual Utplb_streamcipher::_di_IStreamCipher __fastcall GetStreamCipher() = 0 ; + virtual Utplb_blockcipher::_di_IBlockCipher __fastcall GetBlockCipher() = 0 ; + virtual Utplb_blockcipher::_di_IBlockChainingModel __fastcall GetChainMode() = 0 ; + virtual TOnEncDecProgress __fastcall GetOnProgress() = 0 ; virtual void __fastcall SetOnProgress(TOnEncDecProgress Value) = 0 ; - virtual unsigned __fastcall GetAsymetricKeySizeInBits(void) = 0 ; + virtual unsigned __fastcall GetAsymetricKeySizeInBits() = 0 ; virtual void __fastcall SetAsymetricKeySizeInBits(unsigned value) = 0 ; - virtual TGenerateAsymetricKeyPairProgress __fastcall GetAsymGenProgressEvent(void) = 0 ; + virtual TGenerateAsymetricKeyPairProgress __fastcall GetAsymGenProgressEvent() = 0 ; virtual void __fastcall SetAsymGenProgressEvent(TGenerateAsymetricKeyPairProgress Value) = 0 ; - virtual Utplb_streamcipher::TSymetricKey* __fastcall GetKey(void) = 0 ; + virtual Utplb_streamcipher::TSymetricKey* __fastcall GetKey() = 0 ; virtual System::UnicodeString __fastcall GetCipherDisplayName(Utplb_cryptographiclibrary::TCryptographicLibrary* Lib) = 0 ; virtual void __fastcall Init(const System::UnicodeString Key, System::Sysutils::TEncoding* AEncoding) = 0 ; virtual void __fastcall SaveKeyToStream(System::Classes::TStream* Store) = 0 ; virtual void __fastcall InitFromStream(System::Classes::TStream* Store) = 0 ; virtual void __fastcall InitFromKey(Utplb_streamcipher::TSymetricKey* Key) = 0 ; - virtual void __fastcall Reset(void) = 0 ; + virtual void __fastcall Reset() = 0 ; virtual void __fastcall Burn(bool doIncludeBurnKey) = 0 ; - virtual bool __fastcall isAsymetric(void) = 0 ; - virtual void __fastcall InitFromGeneratedAsymetricKeyPair(void) = 0 ; + virtual bool __fastcall isAsymetric() = 0 ; + virtual void __fastcall InitFromGeneratedAsymetricKeyPair() = 0 ; virtual void __fastcall Sign(System::Classes::TStream* Document, System::Classes::TStream* Signature, System::TObject* ProgressSender, TOnEncDecProgress ProgressEvent, System::TObject* SigningKeys_PrivatePart, bool &wasAborted) = 0 ; virtual bool __fastcall VerifySignature(System::Classes::TStream* Document, System::Classes::TStream* Signature, System::TObject* ProgressSender, TOnEncDecProgress ProgressEvent, System::TObject* SigningKeys_PublicPart, bool &wasAborted) = 0 ; virtual void __fastcall Begin_EncryptMemory(System::Classes::TStream* CipherText) = 0 ; virtual void __fastcall EncryptMemory(const System::DynamicArray Plaintext, int PlaintextLen) = 0 ; - virtual void __fastcall End_EncryptMemory(void) = 0 ; + virtual void __fastcall End_EncryptMemory() = 0 ; virtual void __fastcall Begin_DecryptMemory(System::Classes::TStream* PlainText) = 0 ; virtual void __fastcall DecryptMemory(const void *CipherText, int CiphertextLen) = 0 ; - virtual void __fastcall End_DecryptMemory(void) = 0 ; + virtual void __fastcall End_DecryptMemory() = 0 ; virtual void __fastcall EncryptStream(System::Classes::TStream* Plaintext, System::Classes::TStream* CipherText) = 0 ; virtual void __fastcall DecryptStream(System::Classes::TStream* Plaintext, System::Classes::TStream* CipherText) = 0 ; virtual void __fastcall EncryptFile(const System::UnicodeString Plaintext_FileName, const System::UnicodeString CipherText_FileName) = 0 ; @@ -75,11 +75,11 @@ __interface INTERFACE_UUID("{48B3116A-5681-4E79-9013-8EC89BAC5B35}") ICodec : virtual void __fastcall DecryptString(System::UnicodeString &Plaintext, const System::UnicodeString CipherText_Base64, System::Sysutils::TEncoding* AEncoding) = 0 ; virtual void __fastcall EncryptAnsiString(const System::UnicodeString Plaintext, System::UnicodeString &CipherText_Base64) = 0 ; virtual void __fastcall DecryptAnsiString(System::UnicodeString &Plaintext, const System::UnicodeString CipherText_Base64) = 0 ; - virtual bool __fastcall GetAborted(void) = 0 ; + virtual bool __fastcall GetAborted() = 0 ; virtual void __fastcall SetAborted(bool Value) = 0 ; - virtual Utplb_blockcipher::TSymetricEncryptionOptionSet __fastcall GetAdvancedOptions2(void) = 0 ; + virtual Utplb_blockcipher::TSymetricEncryptionOptionSet __fastcall GetAdvancedOptions2() = 0 ; virtual void __fastcall SetAdvancedOptions2(Utplb_blockcipher::TSymetricEncryptionOptionSet Value) = 0 ; - virtual Utplb_blockcipher::TSetMemStreamProc __fastcall GetOnSetIV(void) = 0 ; + virtual Utplb_blockcipher::TSetMemStreamProc __fastcall GetOnSetIV() = 0 ; virtual void __fastcall SetOnSetIV(Utplb_blockcipher::TSetMemStreamProc Value) = 0 ; __property TCodecMode Mode = {read=GetMode}; __property Utplb_streamcipher::TSymetricKey* Key = {read=GetKey}; diff --git a/hpp/Win32/Release/uTPLb_Constants.hpp b/hpp/Win32/Release/uTPLb_Constants.hpp index 00d52f6..af44fba 100644 --- a/hpp/Win32/Release/uTPLb_Constants.hpp +++ b/hpp/Win32/Release/uTPLb_Constants.hpp @@ -2,7 +2,7 @@ // Copyright (c) 1995, 2017 by Embarcadero Technologies, Inc. // All rights reserved -// (DO NOT EDIT: machine generated header) 'uTPLb_Constants.pas' rev: 32.00 (Windows) +// (DO NOT EDIT: machine generated header) 'uTPLb_Constants.pas' rev: 33.00 (Windows) #ifndef Utplb_constantsHPP #define Utplb_constantsHPP diff --git a/hpp/Win32/Release/uTPLb_CryptographicLibrary.hpp b/hpp/Win32/Release/uTPLb_CryptographicLibrary.hpp index 358805b..dd72015 100644 --- a/hpp/Win32/Release/uTPLb_CryptographicLibrary.hpp +++ b/hpp/Win32/Release/uTPLb_CryptographicLibrary.hpp @@ -2,7 +2,7 @@ // Copyright (c) 1995, 2017 by Embarcadero Technologies, Inc. // All rights reserved -// (DO NOT EDIT: machine generated header) 'uTPLb_CryptographicLibrary.pas' rev: 32.00 (Windows) +// (DO NOT EDIT: machine generated header) 'uTPLb_CryptographicLibrary.pas' rev: 33.00 (Windows) #ifndef Utplb_cryptographiclibraryHPP #define Utplb_cryptographiclibraryHPP @@ -31,10 +31,10 @@ namespace Utplb_cryptographiclibrary { //-- forward type declarations ----------------------------------------------- class DELPHICLASS TCustomStreamCipher; -__interface ICryptographicLibraryWatcher; +__interface DELPHIINTERFACE ICryptographicLibraryWatcher; typedef System::DelphiInterface _di_ICryptographicLibraryWatcher; class DELPHICLASS TCryptographicLibrary; -__interface ICipherChoice; +__interface DELPHIINTERFACE ICipherChoice; typedef System::DelphiInterface _di_ICipherChoice; //-- type declarations ------------------------------------------------------- enum DECLSPEC_DENUM TCryptoLibStringRef : unsigned char { cStreamId, sStreamName, cBlockId, cBlockName, cChainId, cChainName, cHashId, cHashName }; @@ -65,7 +65,7 @@ class PASCALIMPLEMENTATION TCustomStreamCipher : public System::Classes::TPersis __fastcall TCustomStreamCipher(TCryptographicLibrary* Lib1); public: - __fastcall virtual ~TCustomStreamCipher(void); + __fastcall virtual ~TCustomStreamCipher(); __published: __property System::UnicodeString DisplayName = {read=FDisplayName, write=SetDisplayName}; @@ -78,7 +78,7 @@ class PASCALIMPLEMENTATION TCustomStreamCipher : public System::Classes::TPersis __interface INTERFACE_UUID("{A9170972-FDF5-406B-9010-230E661DAF5C}") ICryptographicLibraryWatcher : public System::IInterface { - virtual void __fastcall ProgIdsChanged(void) = 0 ; + virtual void __fastcall ProgIdsChanged() = 0 ; }; class PASCALIMPLEMENTATION TCryptographicLibrary : public Utplb_basenonvisualcomponent::TTPLb_BaseNonVisualComponent @@ -104,17 +104,17 @@ class PASCALIMPLEMENTATION TCryptographicLibrary : public Utplb_basenonvisualcom TOnGenerateKeyFunc FOnGenerateKeyFunc; TOnStart_EncryptFunc FOnStart_EncryptFunc; TOnStart_DecryptFunc FOnStart_DecryptFunc; - System::Classes::TStrings* __fastcall GetStreamCiphers_ByProgId(void); - System::Classes::TStrings* __fastcall GetStreamCiphers_ByDisplayName(void); + System::Classes::TStrings* __fastcall GetStreamCiphers_ByProgId(); + System::Classes::TStrings* __fastcall GetStreamCiphers_ByDisplayName(); System::UnicodeString __fastcall GetStreamCipherDisplayNames(const System::UnicodeString ProgIdx); - System::Classes::TStrings* __fastcall GetBlockCiphers_ByProgId(void); - System::Classes::TStrings* __fastcall GetBlockCiphers_ByDisplayName(void); + System::Classes::TStrings* __fastcall GetBlockCiphers_ByProgId(); + System::Classes::TStrings* __fastcall GetBlockCiphers_ByDisplayName(); System::UnicodeString __fastcall GetBlockCipherDisplayNames(const System::UnicodeString ProgIdx); - System::Classes::TStrings* __fastcall GetChainModes_ByProgId(void); - System::Classes::TStrings* __fastcall GetChainModes_ByDisplayName(void); + System::Classes::TStrings* __fastcall GetChainModes_ByProgId(); + System::Classes::TStrings* __fastcall GetChainModes_ByDisplayName(); System::UnicodeString __fastcall GetChainModesDisplayNames(const System::UnicodeString ProgIdx); - System::Classes::TStrings* __fastcall GetHashs_ByProgId(void); - System::Classes::TStrings* __fastcall GetHashs_ByDisplayName(void); + System::Classes::TStrings* __fastcall GetHashs_ByProgId(); + System::Classes::TStrings* __fastcall GetHashs_ByDisplayName(); System::UnicodeString __fastcall GetHashDisplayNames(const System::UnicodeString ProgIdx); int __fastcall MeasureDepthUp(int MeasureLimit); int __fastcall MeasureDepthDown(int MeasureLimit); @@ -125,14 +125,14 @@ class PASCALIMPLEMENTATION TCryptographicLibrary : public Utplb_basenonvisualcom System::Generics::Collections::TObjectList__1* FChildLibraries; void __fastcall SetParentLibrary(TCryptographicLibrary* Value); virtual void __fastcall Notification(System::Classes::TComponent* AComponent, System::Classes::TOperation Operation); - virtual void __fastcall StockStreamCiphers(void); - virtual void __fastcall StockBlockCiphers(void); - virtual void __fastcall StockHashes(void); - virtual void __fastcall StockChainModes(void); + virtual void __fastcall StockStreamCiphers(); + virtual void __fastcall StockBlockCiphers(); + virtual void __fastcall StockHashes(); + virtual void __fastcall StockChainModes(); public: __fastcall virtual TCryptographicLibrary(System::Classes::TComponent* AOwner); - __fastcall virtual ~TCryptographicLibrary(void); + __fastcall virtual ~TCryptographicLibrary(); Utplb_streamcipher::_di_IStreamCipher __fastcall StreamCipherIntfc(const System::UnicodeString ProgIdx); void __fastcall RegisterStreamCipher(const Utplb_streamcipher::_di_IStreamCipher Registrant); void __fastcall DeregisterStreamCipher(const Utplb_streamcipher::_di_IStreamCipher Registrant); @@ -149,11 +149,11 @@ class PASCALIMPLEMENTATION TCryptographicLibrary : public Utplb_basenonvisualcom void __fastcall DegisterWatcher(const _di_ICryptographicLibraryWatcher Registrant); virtual void __fastcall ProgIdsChanged(int StackLimit); System::UnicodeString __fastcall RegisterSimpleBlockTransform(Utplb_simpleblockcipher::TSimpleBlockCipherClass Cls, const System::UnicodeString ProgId1, const System::UnicodeString DisplayName1, Utplb_streamcipher::TAlgorithmicFeatureSet Features1, int BlockSizeInBytes1); - System::Classes::_di_IInterfaceList __fastcall GetCipherChoices(void); + System::Classes::_di_IInterfaceList __fastcall GetCipherChoices(); __classmethod System::UnicodeString __fastcall ComputeCipherDisplayName(const Utplb_streamcipher::_di_IStreamCipher SCipher, const Utplb_blockcipher::_di_IBlockCipher BCipher); - System::Classes::_di_IInterfaceList __fastcall GetHashChoices(void); + System::Classes::_di_IInterfaceList __fastcall GetHashChoices(); __classmethod System::UnicodeString __fastcall ComputeHashDisplayName(const Utplb_hashdsc::_di_IHashDsc Hash); - System::Classes::_di_IInterfaceList __fastcall GetChainChoices(void); + System::Classes::_di_IInterfaceList __fastcall GetChainChoices(); __classmethod System::UnicodeString __fastcall ComputeChainDisplayName(const Utplb_blockcipher::_di_IBlockChainingModel Chain); __property System::Classes::TStrings* StreamCiphers_ByProgId = {read=GetStreamCiphers_ByProgId}; __property System::Classes::TStrings* StreamCiphers_ByDisplayName = {read=GetStreamCiphers_ByDisplayName}; diff --git a/hpp/Win32/Release/uTPLb_DES.hpp b/hpp/Win32/Release/uTPLb_DES.hpp index 096bc4d..17757ab 100644 --- a/hpp/Win32/Release/uTPLb_DES.hpp +++ b/hpp/Win32/Release/uTPLb_DES.hpp @@ -2,7 +2,7 @@ // Copyright (c) 1995, 2017 by Embarcadero Technologies, Inc. // All rights reserved -// (DO NOT EDIT: machine generated header) 'uTPLb_DES.pas' rev: 32.00 (Windows) +// (DO NOT EDIT: machine generated header) 'uTPLb_DES.pas' rev: 33.00 (Windows) #ifndef Utplb_desHPP #define Utplb_desHPP @@ -32,25 +32,25 @@ class PASCALIMPLEMENTATION TDES : public System::TInterfacedObject typedef System::TInterfacedObject inherited; private: - System::UnicodeString __fastcall DisplayName(void); - System::UnicodeString __fastcall ProgId(void); - Utplb_streamcipher::TAlgorithmicFeatureSet __fastcall Features(void); - System::UnicodeString __fastcall DefinitionURL(void); - System::UnicodeString __fastcall WikipediaReference(void); + System::UnicodeString __fastcall DisplayName(); + System::UnicodeString __fastcall ProgId(); + Utplb_streamcipher::TAlgorithmicFeatureSet __fastcall Features(); + System::UnicodeString __fastcall DefinitionURL(); + System::UnicodeString __fastcall WikipediaReference(); Utplb_streamcipher::TSymetricKey* __fastcall GenerateKey(System::Classes::TStream* Seed); Utplb_streamcipher::TSymetricKey* __fastcall LoadKeyFromStream(System::Classes::TStream* Store); - int __fastcall BlockSize(void); - int __fastcall KeySize(void); - int __fastcall SeedByteSize(void); + int __fastcall BlockSize(); + int __fastcall KeySize(); + int __fastcall SeedByteSize(); Utplb_blockcipher::_di_IBlockCodec __fastcall MakeBlockCodec(Utplb_streamcipher::TSymetricKey* Key); - System::DynamicArray __fastcall SelfTest_Key(void); - System::DynamicArray __fastcall SelfTest_Plaintext(void); - System::DynamicArray __fastcall SelfTest_Ciphertext(void); + System::DynamicArray __fastcall SelfTest_Key(); + System::DynamicArray __fastcall SelfTest_Plaintext(); + System::DynamicArray __fastcall SelfTest_Ciphertext(); public: - __fastcall TDES(void); + __fastcall TDES(); public: - /* TObject.Destroy */ inline __fastcall virtual ~TDES(void) { } + /* TObject.Destroy */ inline __fastcall virtual ~TDES() { } private: void *__IBlockCipher; // Utplb_blockcipher::IBlockCipher diff --git a/hpp/Win32/Release/uTPLb_Decorators.hpp b/hpp/Win32/Release/uTPLb_Decorators.hpp index 009d591..13c6e25 100644 --- a/hpp/Win32/Release/uTPLb_Decorators.hpp +++ b/hpp/Win32/Release/uTPLb_Decorators.hpp @@ -2,7 +2,7 @@ // Copyright (c) 1995, 2017 by Embarcadero Technologies, Inc. // All rights reserved -// (DO NOT EDIT: machine generated header) 'uTPLb_Decorators.pas' rev: 32.00 (Windows) +// (DO NOT EDIT: machine generated header) 'uTPLb_Decorators.pas' rev: 33.00 (Windows) #ifndef Utplb_decoratorsHPP #define Utplb_decoratorsHPP @@ -20,16 +20,16 @@ namespace Utplb_decorators { //-- forward type declarations ----------------------------------------------- -__interface IControlObject; +__interface DELPHIINTERFACE IControlObject; typedef System::DelphiInterface _di_IControlObject; class DELPHICLASS IntegerRange; class DELPHICLASS DesignDescription; -__interface IVariableSeedSize; +__interface DELPHIINTERFACE IVariableSeedSize; typedef System::DelphiInterface _di_IVariableSeedSize; //-- type declarations ------------------------------------------------------- __interface INTERFACE_UUID("{420914AC-6242-417E-8D18-7B163056DA60}") IControlObject : public System::IInterface { - virtual System::TObject* __fastcall ControlObject(void) = 0 ; + virtual System::TObject* __fastcall ControlObject() = 0 ; }; #pragma pack(push,4) @@ -46,7 +46,7 @@ class PASCALIMPLEMENTATION IntegerRange : public System::TCustomAttribute __property int Min = {read=FMin, nodefault}; __property int Max = {read=FMax, nodefault}; public: - /* TObject.Destroy */ inline __fastcall virtual ~IntegerRange(void) { } + /* TObject.Destroy */ inline __fastcall virtual ~IntegerRange() { } }; @@ -64,7 +64,7 @@ class PASCALIMPLEMENTATION DesignDescription : public System::TCustomAttribute __fastcall DesignDescription(const System::UnicodeString Description1); __property System::UnicodeString Description = {read=FDescription}; public: - /* TObject.Destroy */ inline __fastcall virtual ~DesignDescription(void) { } + /* TObject.Destroy */ inline __fastcall virtual ~DesignDescription() { } }; @@ -72,8 +72,8 @@ class PASCALIMPLEMENTATION DesignDescription : public System::TCustomAttribute __interface INTERFACE_UUID("{38096CBB-5ACB-43D7-826A-C21812F6E447}") IVariableSeedSize : public System::IInterface { - virtual int __fastcall MinSeedByteSize(void) = 0 ; - virtual int __fastcall MaxSeedByteSize(void) = 0 ; + virtual int __fastcall MinSeedByteSize() = 0 ; + virtual int __fastcall MaxSeedByteSize() = 0 ; __property int Min = {read=MinSeedByteSize}; __property int Max = {read=MaxSeedByteSize}; }; diff --git a/hpp/Win32/Release/uTPLb_ECB.hpp b/hpp/Win32/Release/uTPLb_ECB.hpp index e212bc8..04bff6a 100644 --- a/hpp/Win32/Release/uTPLb_ECB.hpp +++ b/hpp/Win32/Release/uTPLb_ECB.hpp @@ -2,7 +2,7 @@ // Copyright (c) 1995, 2017 by Embarcadero Technologies, Inc. // All rights reserved -// (DO NOT EDIT: machine generated header) 'uTPLb_ECB.pas' rev: 32.00 (Windows) +// (DO NOT EDIT: machine generated header) 'uTPLb_ECB.pas' rev: 33.00 (Windows) #ifndef Utplb_ecbHPP #define Utplb_ecbHPP @@ -34,15 +34,15 @@ class PASCALIMPLEMENTATION TECB : public System::TInterfacedObject protected: Utplb_blockcipher::TBlockChainLink* __fastcall Chain_EncryptBlock(Utplb_streamcipher::TSymetricKey* Key, System::Classes::TMemoryStream* InitializationVector, const Utplb_blockcipher::_di_IBlockCodec Cipher); Utplb_blockcipher::TBlockChainLink* __fastcall Chain_DecryptBlock(Utplb_streamcipher::TSymetricKey* Key, System::Classes::TMemoryStream* InitializationVector, const Utplb_blockcipher::_di_IBlockCodec Cipher); - System::UnicodeString __fastcall DisplayName(void); - virtual System::UnicodeString __fastcall ProgId(void); - virtual Utplb_blockcipher::TChainingFeatureSet __fastcall ChainingFeatures(void); - Utplb_streamcipher::TAlgorithmicFeatureSet __fastcall Features(void); - System::UnicodeString __fastcall DefinitionURL(void); - System::UnicodeString __fastcall WikipediaReference(void); + System::UnicodeString __fastcall DisplayName(); + virtual System::UnicodeString __fastcall ProgId(); + virtual Utplb_blockcipher::TChainingFeatureSet __fastcall ChainingFeatures(); + Utplb_streamcipher::TAlgorithmicFeatureSet __fastcall Features(); + System::UnicodeString __fastcall DefinitionURL(); + System::UnicodeString __fastcall WikipediaReference(); public: - /* TObject.Create */ inline __fastcall TECB(void) : System::TInterfacedObject() { } - /* TObject.Destroy */ inline __fastcall virtual ~TECB(void) { } + /* TObject.Create */ inline __fastcall TECB() : System::TInterfacedObject() { } + /* TObject.Destroy */ inline __fastcall virtual ~TECB() { } private: void *__IBlockChainingModel; // Utplb_blockcipher::IBlockChainingModel @@ -76,10 +76,10 @@ class PASCALIMPLEMENTATION TECBLink : public Utplb_blockcipher::TBlockChainLink /* TBlockChainLink.BaseCreate */ inline __fastcall TECBLink(Utplb_streamcipher::TSymetricKey* Key1, System::Classes::TMemoryStream* IV1, Utplb_blockcipher::_di_IBlockCodec Cipher1) : Utplb_blockcipher::TBlockChainLink(Key1, IV1, Cipher1) { } public: - /* TBlockChainLink.Destroy */ inline __fastcall virtual ~TECBLink(void) { } + /* TBlockChainLink.Destroy */ inline __fastcall virtual ~TECBLink() { } public: - /* TObject.Create */ inline __fastcall TECBLink(void) : Utplb_blockcipher::TBlockChainLink() { } + /* TObject.Create */ inline __fastcall TECBLink() : Utplb_blockcipher::TBlockChainLink() { } }; diff --git a/hpp/Win32/Release/uTPLb_Hash.hpp b/hpp/Win32/Release/uTPLb_Hash.hpp index 6f71e3b..673aa9d 100644 --- a/hpp/Win32/Release/uTPLb_Hash.hpp +++ b/hpp/Win32/Release/uTPLb_Hash.hpp @@ -2,7 +2,7 @@ // Copyright (c) 1995, 2017 by Embarcadero Technologies, Inc. // All rights reserved -// (DO NOT EDIT: machine generated header) 'uTPLb_Hash.pas' rev: 32.00 (Windows) +// (DO NOT EDIT: machine generated header) 'uTPLb_Hash.pas' rev: 33.00 (Windows) #ifndef Utplb_hashHPP #define Utplb_hashHPP @@ -26,9 +26,9 @@ namespace Utplb_hash { //-- forward type declarations ----------------------------------------------- -__interface IHash; +__interface DELPHIINTERFACE IHash; typedef System::DelphiInterface _di_IHash; -__interface IHash_TestAccess; +__interface DELPHIINTERFACE IHash_TestAccess; typedef System::DelphiInterface _di_IHash_TestAccess; class DELPHICLASS TSimpleHash; class DELPHICLASS THash; @@ -37,21 +37,21 @@ typedef bool __fastcall (__closure *TOnHashProgress)(System::TObject* Sender, __ __interface INTERFACE_UUID("{97CF303A-B823-42F3-98F6-7022015FDCB5}") IHash : public System::IInterface { - virtual bool __fastcall GetIsHashing(void) = 0 ; - virtual Utplb_hashdsc::_di_IHashDsc __fastcall GetHash(void) = 0 ; + virtual bool __fastcall GetIsHashing() = 0 ; + virtual Utplb_hashdsc::_di_IHashDsc __fastcall GetHash() = 0 ; virtual void __fastcall SetHash(const Utplb_hashdsc::_di_IHashDsc Value) = 0 ; - virtual System::Classes::TStream* __fastcall GetHashOutput(void) = 0 ; - virtual TOnHashProgress __fastcall GetonProgress(void) = 0 ; + virtual System::Classes::TStream* __fastcall GetHashOutput() = 0 ; + virtual TOnHashProgress __fastcall GetonProgress() = 0 ; virtual void __fastcall SetOnProgress(TOnHashProgress Value) = 0 ; - virtual void __fastcall Begin_Hash(void) = 0 ; + virtual void __fastcall Begin_Hash() = 0 ; virtual void __fastcall UpdateMemory(const void *Plaintext, int Count) = 0 ; - virtual void __fastcall End_Hash(void) = 0 ; - virtual void __fastcall Burn(void) = 0 ; + virtual void __fastcall End_Hash() = 0 ; + virtual void __fastcall Burn() = 0 ; virtual void __fastcall HashStream(System::Classes::TStream* Plaintext) = 0 ; virtual void __fastcall HashFile(const System::UnicodeString PlaintextFileName) = 0 ; virtual void __fastcall HashString(const System::UnicodeString Plaintext, System::Sysutils::TEncoding* AEncoding) = 0 ; virtual void __fastcall HashAnsiString(const System::UnicodeString Plaintext) = 0 ; - virtual bool __fastcall isUserAborted(void) = 0 ; + virtual bool __fastcall isUserAborted() = 0 ; virtual void __fastcall WriteHashOutputToStream(System::Classes::TStream* Dest) = 0 ; virtual void __fastcall WriteHashOutputToMemory(void *Dest) = 0 ; __property bool isHashing = {read=GetIsHashing}; @@ -62,7 +62,7 @@ __interface INTERFACE_UUID("{97CF303A-B823-42F3-98F6-7022015FDCB5}") IHash : p __interface INTERFACE_UUID("{E6604CED-09A1-4EA6-BE22-B3371379218B}") IHash_TestAccess : public System::IInterface { - virtual Utplb_hashdsc::_di_IHasher __fastcall GetHasher(void) = 0 ; + virtual Utplb_hashdsc::_di_IHasher __fastcall GetHasher() = 0 ; }; class PASCALIMPLEMENTATION TSimpleHash : public System::Classes::TInterfacedPersistent @@ -71,25 +71,25 @@ class PASCALIMPLEMENTATION TSimpleHash : public System::Classes::TInterfacedPers private: System::TObject* FSender; - bool __fastcall GetIsHashing(void); - Utplb_hashdsc::_di_IHashDsc __fastcall GetHash(void); + bool __fastcall GetIsHashing(); + Utplb_hashdsc::_di_IHashDsc __fastcall GetHash(); void __fastcall SetHash(const Utplb_hashdsc::_di_IHashDsc Value); - System::Classes::TStream* __fastcall GetHashOutput(void); - TOnHashProgress __fastcall GetonProgress(void); + System::Classes::TStream* __fastcall GetHashOutput(); + TOnHashProgress __fastcall GetonProgress(); void __fastcall SetOnProgress(TOnHashProgress Value); - void __fastcall Begin_Hash(void); + void __fastcall Begin_Hash(); void __fastcall UpdateMemory(const void *Plaintext, int Count); - void __fastcall End_Hash(void); - void __fastcall Burn(void); + void __fastcall End_Hash(); + void __fastcall Burn(); void __fastcall HashStream(System::Classes::TStream* Plaintext); void __fastcall HashFile(const System::UnicodeString PlaintextFileName); void __fastcall HashString(const System::UnicodeString Plaintext, System::Sysutils::TEncoding* AEncoding); void __fastcall HashAnsiString(const System::UnicodeString Plaintext); - bool __fastcall isUserAborted(void); + bool __fastcall isUserAborted(); void __fastcall SetEventSender(System::TObject* Sender); void __fastcall WriteHashOutputToStream(System::Classes::TStream* Dest); void __fastcall WriteHashOutputToMemory(void *Dest); - Utplb_hashdsc::_di_IHasher __fastcall GetHasher(void); + Utplb_hashdsc::_di_IHasher __fastcall GetHasher(); protected: Utplb_hashdsc::_di_IHashDsc FHashDsc; @@ -102,8 +102,8 @@ class PASCALIMPLEMENTATION TSimpleHash : public System::Classes::TInterfacedPers bool FisUserAborted; public: - __fastcall TSimpleHash(void); - __fastcall virtual ~TSimpleHash(void); + __fastcall TSimpleHash(); + __fastcall virtual ~TSimpleHash(); private: void *__IHash_TestAccess; // IHash_TestAccess void *__IEventOrigin; // Utplb_basenonvisualcomponent::IEventOrigin @@ -157,39 +157,39 @@ class PASCALIMPLEMENTATION THash : public Utplb_basenonvisualcomponent::TTPLb_Ba Utplb_cryptographiclibrary::TCryptographicLibrary* FLib; System::UnicodeString FHashId; bool FIntfCached; - bool __fastcall GetIsHashing(void); - System::Classes::TStream* __fastcall GetHashOutput(void); - TOnHashProgress __fastcall GetonProgress(void); + bool __fastcall GetIsHashing(); + System::Classes::TStream* __fastcall GetHashOutput(); + TOnHashProgress __fastcall GetonProgress(); void __fastcall SetOnProgress(TOnHashProgress Value); - void __fastcall ProgIdsChanged(void); + void __fastcall ProgIdsChanged(); void __fastcall SetLib(Utplb_cryptographiclibrary::TCryptographicLibrary* Value); void __fastcall Dummy(const System::UnicodeString Value); void __fastcall SetHashId(const System::UnicodeString Value); void __fastcall SetIntfCached(bool Value); - Utplb_streamcipher::TAlgorithmicFeatureSet __fastcall GetFeatures(void); + Utplb_streamcipher::TAlgorithmicFeatureSet __fastcall GetFeatures(); void __fastcall ReadData(System::Classes::TReader* Reader); void __fastcall WriteData(System::Classes::TWriter* Writer); - Utplb_hashdsc::_di_IHasher __fastcall GetHasher(void); + Utplb_hashdsc::_di_IHasher __fastcall GetHasher(); protected: virtual void __fastcall Notification(System::Classes::TComponent* AComponent, System::Classes::TOperation Operation); virtual void __fastcall DefineProperties(System::Classes::TFiler* Filer); - virtual System::UnicodeString __fastcall GetHashDisplayName(void); - virtual void __fastcall Loaded(void); + virtual System::UnicodeString __fastcall GetHashDisplayName(); + virtual void __fastcall Loaded(); __property bool InterfacesAreCached = {read=FIntfCached, write=SetIntfCached, nodefault}; public: __fastcall virtual THash(System::Classes::TComponent* AOwner); - __fastcall virtual ~THash(void); - void __fastcall Begin_Hash(void); + __fastcall virtual ~THash(); + void __fastcall Begin_Hash(); void __fastcall UpdateMemory(const void *Plaintext, int PlaintextLen); - void __fastcall End_Hash(void); - void __fastcall Burn(void); + void __fastcall End_Hash(); + void __fastcall Burn(); void __fastcall HashStream(System::Classes::TStream* Plaintext); void __fastcall HashFile(const System::UnicodeString PlaintextFileName); void __fastcall HashString(const System::UnicodeString Plaintext, System::Sysutils::TEncoding* AEncoding); void __fastcall HashAnsiString(const System::UnicodeString Plaintext); - bool __fastcall isUserAborted(void); + bool __fastcall isUserAborted(); __property bool isHashing = {read=GetIsHashing, nodefault}; __property System::UnicodeString HashId = {read=FHashId, write=SetHashId}; __property System::Classes::TStream* HashOutputValue = {read=GetHashOutput}; diff --git a/hpp/Win32/Release/uTPLb_HashDsc.hpp b/hpp/Win32/Release/uTPLb_HashDsc.hpp index 623e438..f66cb7c 100644 --- a/hpp/Win32/Release/uTPLb_HashDsc.hpp +++ b/hpp/Win32/Release/uTPLb_HashDsc.hpp @@ -2,7 +2,7 @@ // Copyright (c) 1995, 2017 by Embarcadero Technologies, Inc. // All rights reserved -// (DO NOT EDIT: machine generated header) 'uTPLb_HashDsc.pas' rev: 32.00 (Windows) +// (DO NOT EDIT: machine generated header) 'uTPLb_HashDsc.pas' rev: 33.00 (Windows) #ifndef Utplb_hashdscHPP #define Utplb_hashdscHPP @@ -23,24 +23,24 @@ namespace Utplb_hashdsc { //-- forward type declarations ----------------------------------------------- -__interface IHasher; +__interface DELPHIINTERFACE IHasher; typedef System::DelphiInterface _di_IHasher; -__interface IHashDsc; +__interface DELPHIINTERFACE IHashDsc; typedef System::DelphiInterface _di_IHashDsc; //-- type declarations ------------------------------------------------------- __interface INTERFACE_UUID("{982870E4-EC9B-48CD-B882-17F58F0A7D1A}") IHasher : public System::IInterface { virtual void __fastcall Update(System::Classes::TMemoryStream* Source) = 0 ; virtual void __fastcall End_Hash(System::Classes::TMemoryStream* PartBlock, System::Classes::TStream* Digest) = 0 ; - virtual void __fastcall Burn(void) = 0 ; - virtual System::DynamicArray __fastcall SelfTest_Source(void) = 0 ; - virtual System::DynamicArray __fastcall SelfTest_ReferenceHashValue(void) = 0 ; + virtual void __fastcall Burn() = 0 ; + virtual System::DynamicArray __fastcall SelfTest_Source() = 0 ; + virtual System::DynamicArray __fastcall SelfTest_ReferenceHashValue() = 0 ; }; __interface INTERFACE_UUID("{A3922AFC-C917-4364-9FD1-FD84A3E37558}") IHashDsc : public Utplb_streamcipher::ICryptoGraphicAlgorithm { - virtual int __fastcall DigestSize(void) = 0 ; - virtual int __fastcall UpdateSize(void) = 0 ; + virtual int __fastcall DigestSize() = 0 ; + virtual int __fastcall UpdateSize() = 0 ; virtual _di_IHasher __fastcall MakeHasher(const System::_di_IInterface Params) = 0 ; }; diff --git a/hpp/Win32/Release/uTPLb_HugeCardinal.hpp b/hpp/Win32/Release/uTPLb_HugeCardinal.hpp index a5bf37d..0d28c0b 100644 --- a/hpp/Win32/Release/uTPLb_HugeCardinal.hpp +++ b/hpp/Win32/Release/uTPLb_HugeCardinal.hpp @@ -2,7 +2,7 @@ // Copyright (c) 1995, 2017 by Embarcadero Technologies, Inc. // All rights reserved -// (DO NOT EDIT: machine generated header) 'uTPLb_HugeCardinal.pas' rev: 32.00 (Windows) +// (DO NOT EDIT: machine generated header) 'uTPLb_HugeCardinal.pas' rev: 33.00 (Windows) #ifndef Utplb_hugecardinalHPP #define Utplb_hugecardinalHPP @@ -40,16 +40,16 @@ class PASCALIMPLEMENTATION THugeCardinal : /*[[sealed]]*/ public System::TObject private: int FMaxBits; int FBits; - void __fastcall CheckBits(void); + void __fastcall CheckBits(); __classmethod int __fastcall ComputedNeededSize(int RequestedBits); void __fastcall ClearMem(int Offset, int Length); void __fastcall DividePrimitive(THugeCardinal* Divisor, THugeCardinal* &Quotient, THugeCardinal* &Remainder, bool RequiresQuotient); - System::UnicodeString __fastcall GetAsHexString(void); + System::UnicodeString __fastcall GetAsHexString(); void __fastcall MulPower2_OldAlgorithm(int ShiftAmnt); void __fastcall MulPower2_NewAlgorithm(int ShiftAmnt); void __fastcall MultiplyMod_Old(THugeCardinal* Factor, THugeCardinal* Modulus); void __fastcall MultiplyMod_New(THugeCardinal* Factor, THugeCardinal* Modulus); - System::UnicodeString __fastcall GetAsBase10(void); + System::UnicodeString __fastcall GetAsBase10(); protected: System::Classes::TMemoryStream* __fastcall NewMemoryStream(int InitBitSize); @@ -65,14 +65,14 @@ class PASCALIMPLEMENTATION THugeCardinal : /*[[sealed]]*/ public System::TObject __fastcall THugeCardinal(THugeCardinal* Master, const Utplb_memorystreampool::_di_IMemoryStreamPool Pool1); __fastcall THugeCardinal(int MaxBits1, THugeCardinal* Master, const Utplb_memorystreampool::_di_IMemoryStreamPool Pool1); __fastcall THugeCardinal(int MaxBits1, TByteOrder ByteOrder, System::Classes::TStream* Stream, const Utplb_memorystreampool::_di_IMemoryStreamPool Pool1); - __fastcall virtual ~THugeCardinal(void); - THugeCardinal* __fastcall Clone(void); + __fastcall virtual ~THugeCardinal(); + THugeCardinal* __fastcall Clone(); THugeCardinal* __fastcall CloneSized(int MaxBits1); void __fastcall Resize(int NewMaxBit1); - void __fastcall Burn(void); - int __fastcall BitLength(void); - int __fastcall MaxBits(void); - int __fastcall CapacityInBits(void); + void __fastcall Burn(); + int __fastcall BitLength(); + int __fastcall MaxBits(); + int __fastcall CapacityInBits(); void __fastcall Assign(THugeCardinal* Source); void __fastcall AssignFromBuf(TByteOrder ByteOrder, const void *Value, const int ByteLength); void __fastcall AssignFromStreamIn(TByteOrder ByteOrder, System::Classes::TStream* Stream); @@ -82,11 +82,11 @@ class PASCALIMPLEMENTATION THugeCardinal : /*[[sealed]]*/ public System::TObject void __fastcall RandomBits(int BitsOfRandom, bool ExactBitLength); TCompareResult __fastcall Compare(THugeCardinal* Reference); TCompareResult __fastcall CompareSmall(unsigned __int64 Reference); - bool __fastcall isZero(void); - bool __fastcall isOdd(void); - void __fastcall Zeroise(void); - bool __fastcall isSmall(void); - unsigned __int64 __fastcall ExtractSmall(void); + bool __fastcall isZero(); + bool __fastcall isOdd(); + void __fastcall Zeroise(); + bool __fastcall isSmall(); + unsigned __int64 __fastcall ExtractSmall(); unsigned __int64 __fastcall ModSmall(unsigned __int64 Modulus); void __fastcall Add(THugeCardinal* Addend); void __fastcall Increment(__int64 Addend); @@ -108,7 +108,7 @@ class PASCALIMPLEMENTATION THugeCardinal : /*[[sealed]]*/ public System::TObject __property System::UnicodeString AsHexString = {read=GetAsHexString}; __property System::UnicodeString AsBase10 = {read=GetAsBase10}; public: - /* TObject.Create */ inline __fastcall THugeCardinal(void) : System::TObject() { } + /* TObject.Create */ inline __fastcall THugeCardinal() : System::TObject() { } }; @@ -135,9 +135,9 @@ extern DELPHI_PACKAGE bool doUseMultiplyMod_NewAlgorithm; extern DELPHI_PACKAGE bool doProfiling; extern DELPHI_PACKAGE System::StaticArray<__int64, 13> ExecutionTimes; extern DELPHI_PACKAGE System::StaticArray ExecutionPercentages; -extern DELPHI_PACKAGE void __fastcall InitExecutionTimes(void); -extern DELPHI_PACKAGE void __fastcall DoneExecutionTimes(void); -extern DELPHI_PACKAGE void __fastcall CalcExecutionPercentages(void); +extern DELPHI_PACKAGE void __fastcall InitExecutionTimes(); +extern DELPHI_PACKAGE void __fastcall DoneExecutionTimes(); +extern DELPHI_PACKAGE void __fastcall CalcExecutionPercentages(); extern DELPHI_PACKAGE void __fastcall SafeAssign(THugeCardinal* Destin, THugeCardinal* Source); extern DELPHI_PACKAGE void __fastcall SafeAdd(THugeCardinal* Sum, THugeCardinal* Addend1, THugeCardinal* Addend2); } /* namespace Utplb_hugecardinal */ diff --git a/hpp/Win32/Release/uTPLb_HugeCardinalUtils.hpp b/hpp/Win32/Release/uTPLb_HugeCardinalUtils.hpp index d92b4fc..468c979 100644 --- a/hpp/Win32/Release/uTPLb_HugeCardinalUtils.hpp +++ b/hpp/Win32/Release/uTPLb_HugeCardinalUtils.hpp @@ -2,7 +2,7 @@ // Copyright (c) 1995, 2017 by Embarcadero Technologies, Inc. // All rights reserved -// (DO NOT EDIT: machine generated header) 'uTPLb_HugeCardinalUtils.pas' rev: 32.00 (Windows) +// (DO NOT EDIT: machine generated header) 'uTPLb_HugeCardinalUtils.pas' rev: 33.00 (Windows) #ifndef Utplb_hugecardinalutilsHPP #define Utplb_hugecardinalutilsHPP diff --git a/hpp/Win32/Release/uTPLb_I18n.hpp b/hpp/Win32/Release/uTPLb_I18n.hpp index 5db5941..9f4abd4 100644 --- a/hpp/Win32/Release/uTPLb_I18n.hpp +++ b/hpp/Win32/Release/uTPLb_I18n.hpp @@ -2,7 +2,7 @@ // Copyright (c) 1995, 2017 by Embarcadero Technologies, Inc. // All rights reserved -// (DO NOT EDIT: machine generated header) 'uTPLb_I18n.pas' rev: 32.00 (Windows) +// (DO NOT EDIT: machine generated header) 'uTPLb_I18n.pas' rev: 33.00 (Windows) #ifndef Utplb_i18nHPP #define Utplb_i18nHPP diff --git a/hpp/Win32/Release/uTPLb_IntegerUtils.hpp b/hpp/Win32/Release/uTPLb_IntegerUtils.hpp index 6274925..961097c 100644 --- a/hpp/Win32/Release/uTPLb_IntegerUtils.hpp +++ b/hpp/Win32/Release/uTPLb_IntegerUtils.hpp @@ -2,7 +2,7 @@ // Copyright (c) 1995, 2017 by Embarcadero Technologies, Inc. // All rights reserved -// (DO NOT EDIT: machine generated header) 'uTPLb_IntegerUtils.pas' rev: 32.00 (Windows) +// (DO NOT EDIT: machine generated header) 'uTPLb_IntegerUtils.pas' rev: 33.00 (Windows) #ifndef Utplb_integerutilsHPP #define Utplb_integerutilsHPP diff --git a/hpp/Win32/Release/uTPLb_MD5.hpp b/hpp/Win32/Release/uTPLb_MD5.hpp index dca8686..1d9c405 100644 --- a/hpp/Win32/Release/uTPLb_MD5.hpp +++ b/hpp/Win32/Release/uTPLb_MD5.hpp @@ -2,7 +2,7 @@ // Copyright (c) 1995, 2017 by Embarcadero Technologies, Inc. // All rights reserved -// (DO NOT EDIT: machine generated header) 'uTPLb_MD5.pas' rev: 32.00 (Windows) +// (DO NOT EDIT: machine generated header) 'uTPLb_MD5.pas' rev: 33.00 (Windows) #ifndef Utplb_md5HPP #define Utplb_md5HPP @@ -31,17 +31,17 @@ class PASCALIMPLEMENTATION TMD5 : public System::TInterfacedObject typedef System::TInterfacedObject inherited; private: - System::UnicodeString __fastcall DisplayName(void); - System::UnicodeString __fastcall ProgId(void); - Utplb_streamcipher::TAlgorithmicFeatureSet __fastcall Features(void); - int __fastcall DigestSize(void); - int __fastcall UpdateSize(void); + System::UnicodeString __fastcall DisplayName(); + System::UnicodeString __fastcall ProgId(); + Utplb_streamcipher::TAlgorithmicFeatureSet __fastcall Features(); + int __fastcall DigestSize(); + int __fastcall UpdateSize(); Utplb_hashdsc::_di_IHasher __fastcall MakeHasher(const System::_di_IInterface Params); - System::UnicodeString __fastcall DefinitionURL(void); - System::UnicodeString __fastcall WikipediaReference(void); + System::UnicodeString __fastcall DefinitionURL(); + System::UnicodeString __fastcall WikipediaReference(); public: - /* TObject.Create */ inline __fastcall TMD5(void) : System::TInterfacedObject() { } - /* TObject.Destroy */ inline __fastcall virtual ~TMD5(void) { } + /* TObject.Create */ inline __fastcall TMD5() : System::TInterfacedObject() { } + /* TObject.Destroy */ inline __fastcall virtual ~TMD5() { } private: void *__IHashDsc; // Utplb_hashdsc::IHashDsc diff --git a/hpp/Win32/Release/uTPLb_MemoryStreamPool.hpp b/hpp/Win32/Release/uTPLb_MemoryStreamPool.hpp index 2d83e13..33dc3dc 100644 --- a/hpp/Win32/Release/uTPLb_MemoryStreamPool.hpp +++ b/hpp/Win32/Release/uTPLb_MemoryStreamPool.hpp @@ -2,7 +2,7 @@ // Copyright (c) 1995, 2017 by Embarcadero Technologies, Inc. // All rights reserved -// (DO NOT EDIT: machine generated header) 'uTPLb_MemoryStreamPool.pas' rev: 32.00 (Windows) +// (DO NOT EDIT: machine generated header) 'uTPLb_MemoryStreamPool.pas' rev: 33.00 (Windows) #ifndef Utplb_memorystreampoolHPP #define Utplb_memorystreampoolHPP @@ -21,13 +21,13 @@ namespace Utplb_memorystreampool { //-- forward type declarations ----------------------------------------------- -__interface IMemoryStreamPool; +__interface DELPHIINTERFACE IMemoryStreamPool; typedef System::DelphiInterface _di_IMemoryStreamPool; class DELPHICLASS TPooledMemoryStream; //-- type declarations ------------------------------------------------------- __interface INTERFACE_UUID("{ADB2D4BA-40F6-4249-923E-201D4719609B}") IMemoryStreamPool : public System::IInterface { - virtual int __fastcall BayCount(void) = 0 ; + virtual int __fastcall BayCount() = 0 ; virtual void __fastcall GetUsage(int Size, int &Current, int &Peak) = 0 ; virtual int __fastcall GetSize(int Idx) = 0 ; virtual System::Classes::TMemoryStream* __fastcall NewMemoryStream(int InitSize) = 0 ; @@ -46,14 +46,14 @@ class PASCALIMPLEMENTATION TPooledMemoryStream : public System::Classes::TMemory public: __fastcall TPooledMemoryStream(const _di_IMemoryStreamPool Pool1); public: - /* TMemoryStream.Destroy */ inline __fastcall virtual ~TPooledMemoryStream(void) { } + /* TMemoryStream.Destroy */ inline __fastcall virtual ~TPooledMemoryStream() { } }; #pragma pack(pop) //-- var, const, procedure --------------------------------------------------- -extern DELPHI_PACKAGE _di_IMemoryStreamPool __fastcall NewPool(void); +extern DELPHI_PACKAGE _di_IMemoryStreamPool __fastcall NewPool(); } /* namespace Utplb_memorystreampool */ #if !defined(DELPHIHEADER_NO_IMPLICIT_NAMESPACE_USE) && !defined(NO_USING_NAMESPACE_UTPLB_MEMORYSTREAMPOOL) using namespace Utplb_memorystreampool; diff --git a/hpp/Win32/Release/uTPLb_OFB.hpp b/hpp/Win32/Release/uTPLb_OFB.hpp index 8c7890a..dc99d80 100644 --- a/hpp/Win32/Release/uTPLb_OFB.hpp +++ b/hpp/Win32/Release/uTPLb_OFB.hpp @@ -2,7 +2,7 @@ // Copyright (c) 1995, 2017 by Embarcadero Technologies, Inc. // All rights reserved -// (DO NOT EDIT: machine generated header) 'uTPLb_OFB.pas' rev: 32.00 (Windows) +// (DO NOT EDIT: machine generated header) 'uTPLb_OFB.pas' rev: 33.00 (Windows) #ifndef Utplb_ofbHPP #define Utplb_ofbHPP @@ -34,15 +34,15 @@ class PASCALIMPLEMENTATION TOFB : public System::TInterfacedObject protected: Utplb_blockcipher::TBlockChainLink* __fastcall Chain_EncryptBlock(Utplb_streamcipher::TSymetricKey* Key, System::Classes::TMemoryStream* InitializationVector, const Utplb_blockcipher::_di_IBlockCodec Cipher); Utplb_blockcipher::TBlockChainLink* __fastcall Chain_DecryptBlock(Utplb_streamcipher::TSymetricKey* Key, System::Classes::TMemoryStream* InitializationVector, const Utplb_blockcipher::_di_IBlockCodec Cipher); - System::UnicodeString __fastcall DisplayName(void); - System::UnicodeString __fastcall ProgId(void); - Utplb_streamcipher::TAlgorithmicFeatureSet __fastcall Features(void); - Utplb_blockcipher::TChainingFeatureSet __fastcall ChainingFeatures(void); - System::UnicodeString __fastcall DefinitionURL(void); - System::UnicodeString __fastcall WikipediaReference(void); + System::UnicodeString __fastcall DisplayName(); + System::UnicodeString __fastcall ProgId(); + Utplb_streamcipher::TAlgorithmicFeatureSet __fastcall Features(); + Utplb_blockcipher::TChainingFeatureSet __fastcall ChainingFeatures(); + System::UnicodeString __fastcall DefinitionURL(); + System::UnicodeString __fastcall WikipediaReference(); public: - /* TObject.Create */ inline __fastcall TOFB(void) : System::TInterfacedObject() { } - /* TObject.Destroy */ inline __fastcall virtual ~TOFB(void) { } + /* TObject.Create */ inline __fastcall TOFB() : System::TInterfacedObject() { } + /* TObject.Destroy */ inline __fastcall virtual ~TOFB() { } private: void *__IBlockChainingModel; // Utplb_blockcipher::IBlockChainingModel @@ -76,10 +76,10 @@ class PASCALIMPLEMENTATION TOFBLink : public Utplb_blockcipher::TBlockChainLink /* TBlockChainLink.BaseCreate */ inline __fastcall TOFBLink(Utplb_streamcipher::TSymetricKey* Key1, System::Classes::TMemoryStream* IV1, Utplb_blockcipher::_di_IBlockCodec Cipher1) : Utplb_blockcipher::TBlockChainLink(Key1, IV1, Cipher1) { } public: - /* TBlockChainLink.Destroy */ inline __fastcall virtual ~TOFBLink(void) { } + /* TBlockChainLink.Destroy */ inline __fastcall virtual ~TOFBLink() { } public: - /* TObject.Create */ inline __fastcall TOFBLink(void) : Utplb_blockcipher::TBlockChainLink() { } + /* TObject.Create */ inline __fastcall TOFBLink() : Utplb_blockcipher::TBlockChainLink() { } }; diff --git a/hpp/Win32/Release/uTPLb_PCBC.hpp b/hpp/Win32/Release/uTPLb_PCBC.hpp index dc3af3f..a1506f2 100644 --- a/hpp/Win32/Release/uTPLb_PCBC.hpp +++ b/hpp/Win32/Release/uTPLb_PCBC.hpp @@ -2,7 +2,7 @@ // Copyright (c) 1995, 2017 by Embarcadero Technologies, Inc. // All rights reserved -// (DO NOT EDIT: machine generated header) 'uTPLb_PCBC.pas' rev: 32.00 (Windows) +// (DO NOT EDIT: machine generated header) 'uTPLb_PCBC.pas' rev: 33.00 (Windows) #ifndef Utplb_pcbcHPP #define Utplb_pcbcHPP @@ -34,15 +34,15 @@ class PASCALIMPLEMENTATION TPCBC : public System::TInterfacedObject protected: Utplb_blockcipher::TBlockChainLink* __fastcall Chain_EncryptBlock(Utplb_streamcipher::TSymetricKey* Key, System::Classes::TMemoryStream* InitializationVector, const Utplb_blockcipher::_di_IBlockCodec Cipher); Utplb_blockcipher::TBlockChainLink* __fastcall Chain_DecryptBlock(Utplb_streamcipher::TSymetricKey* Key, System::Classes::TMemoryStream* InitializationVector, const Utplb_blockcipher::_di_IBlockCodec Cipher); - System::UnicodeString __fastcall DisplayName(void); - System::UnicodeString __fastcall ProgId(void); - Utplb_streamcipher::TAlgorithmicFeatureSet __fastcall Features(void); - Utplb_blockcipher::TChainingFeatureSet __fastcall ChainingFeatures(void); - System::UnicodeString __fastcall DefinitionURL(void); - System::UnicodeString __fastcall WikipediaReference(void); + System::UnicodeString __fastcall DisplayName(); + System::UnicodeString __fastcall ProgId(); + Utplb_streamcipher::TAlgorithmicFeatureSet __fastcall Features(); + Utplb_blockcipher::TChainingFeatureSet __fastcall ChainingFeatures(); + System::UnicodeString __fastcall DefinitionURL(); + System::UnicodeString __fastcall WikipediaReference(); public: - /* TObject.Create */ inline __fastcall TPCBC(void) : System::TInterfacedObject() { } - /* TObject.Destroy */ inline __fastcall virtual ~TPCBC(void) { } + /* TObject.Create */ inline __fastcall TPCBC() : System::TInterfacedObject() { } + /* TObject.Destroy */ inline __fastcall virtual ~TPCBC() { } private: void *__IBlockChainingModel; // Utplb_blockcipher::IBlockChainingModel @@ -76,9 +76,9 @@ class PASCALIMPLEMENTATION TPCBCLink : public Utplb_blockcipher::TBlockChainLink __fastcall TPCBCLink(Utplb_streamcipher::TSymetricKey* Key, System::Classes::TMemoryStream* InitializationVector, const Utplb_blockcipher::_di_IBlockCodec Cipher); public: - virtual Utplb_blockcipher::TBlockChainLink* __fastcall Clone(void); - virtual void __fastcall Burn(void); - __fastcall virtual ~TPCBCLink(void); + virtual Utplb_blockcipher::TBlockChainLink* __fastcall Clone(); + virtual void __fastcall Burn(); + __fastcall virtual ~TPCBCLink(); virtual void __fastcall Encrypt_Block(System::Classes::TMemoryStream* Plaintext, System::Classes::TMemoryStream* Ciphertext); virtual void __fastcall Decrypt_Block(System::Classes::TMemoryStream* Plaintext, System::Classes::TMemoryStream* Ciphertext); protected: diff --git a/hpp/Win32/Release/uTPLb_PointerArithmetic.hpp b/hpp/Win32/Release/uTPLb_PointerArithmetic.hpp index 337e05c..4e2b794 100644 --- a/hpp/Win32/Release/uTPLb_PointerArithmetic.hpp +++ b/hpp/Win32/Release/uTPLb_PointerArithmetic.hpp @@ -2,7 +2,7 @@ // Copyright (c) 1995, 2017 by Embarcadero Technologies, Inc. // All rights reserved -// (DO NOT EDIT: machine generated header) 'uTPLb_PointerArithmetic.pas' rev: 32.00 (Windows) +// (DO NOT EDIT: machine generated header) 'uTPLb_PointerArithmetic.pas' rev: 33.00 (Windows) #ifndef Utplb_pointerarithmeticHPP #define Utplb_pointerarithmeticHPP diff --git a/hpp/Win32/Release/uTPLb_RSA_Engine.hpp b/hpp/Win32/Release/uTPLb_RSA_Engine.hpp index 9fe0a70..772f38a 100644 --- a/hpp/Win32/Release/uTPLb_RSA_Engine.hpp +++ b/hpp/Win32/Release/uTPLb_RSA_Engine.hpp @@ -2,7 +2,7 @@ // Copyright (c) 1995, 2017 by Embarcadero Technologies, Inc. // All rights reserved -// (DO NOT EDIT: machine generated header) 'uTPLb_RSA_Engine.pas' rev: 32.00 (Windows) +// (DO NOT EDIT: machine generated header) 'uTPLb_RSA_Engine.pas' rev: 33.00 (Windows) #ifndef Utplb_rsa_engineHPP #define Utplb_rsa_engineHPP @@ -28,7 +28,7 @@ namespace Utplb_rsa_engine { //-- forward type declarations ----------------------------------------------- class DELPHICLASS TRSA_Engine; -__interface IHugeCardinalWrap; +__interface DELPHIINTERFACE IHugeCardinalWrap; typedef System::DelphiInterface _di_IHugeCardinalWrap; class DELPHICLASS TRSAKeyPart; class DELPHICLASS TRSA_PublicKeyPart; @@ -43,22 +43,22 @@ class PASCALIMPLEMENTATION TRSA_Engine : public Utplb_asymetric::TAsymetric_Engi typedef Utplb_asymetric::TAsymetric_Engine inherited; protected: - virtual System::UnicodeString __fastcall DisplayName(void); - virtual System::UnicodeString __fastcall ProgId(void); - virtual Utplb_streamcipher::TAlgorithmicFeatureSet __fastcall Features(void); - virtual System::UnicodeString __fastcall DefinitionURL(void); - virtual System::UnicodeString __fastcall WikipediaReference(void); + virtual System::UnicodeString __fastcall DisplayName(); + virtual System::UnicodeString __fastcall ProgId(); + virtual Utplb_streamcipher::TAlgorithmicFeatureSet __fastcall Features(); + virtual System::UnicodeString __fastcall DefinitionURL(); + virtual System::UnicodeString __fastcall WikipediaReference(); virtual Utplb_streamcipher::TSymetricKey* __fastcall LoadKeyFromStream(System::Classes::TStream* Store); - virtual Utplb_asymetric::TAsymetricKeyPairClass __fastcall AsymetricKeyPairClass(void); - virtual Utplb_asymetric::TAsymetricEncryptorClass __fastcall EncClass(void); - virtual Utplb_asymetric::TAsymetricDecryptorClass __fastcall DecClass(void); + virtual Utplb_asymetric::TAsymetricKeyPairClass __fastcall AsymetricKeyPairClass(); + virtual Utplb_asymetric::TAsymetricEncryptorClass __fastcall EncClass(); + virtual Utplb_asymetric::TAsymetricDecryptorClass __fastcall DecClass(); public: virtual void __fastcall GenerateAsymetricKeyPair(unsigned KeySizeInBits, System::TObject* ProgressSender, Utplb_codecintf::TGenerateAsymetricKeyPairProgress ProgressEvent, Utplb_asymetric::TAsymetricKeyPair* &KeyPair, bool &wasAborted); virtual Utplb_asymetric::TAsymetricKeyPair* __fastcall CreateFromStream(System::Classes::TStream* Store, Utplb_asymetric::TKeyStoragePartSet Parts); public: - /* TObject.Create */ inline __fastcall TRSA_Engine(void) : Utplb_asymetric::TAsymetric_Engine() { } - /* TObject.Destroy */ inline __fastcall virtual ~TRSA_Engine(void) { } + /* TObject.Create */ inline __fastcall TRSA_Engine() : Utplb_asymetric::TAsymetric_Engine() { } + /* TObject.Destroy */ inline __fastcall virtual ~TRSA_Engine() { } }; @@ -70,9 +70,9 @@ typedef System::Set __fastcall SelfTest_Key(void); - System::DynamicArray __fastcall SelfTest_Plaintext(void); - System::DynamicArray __fastcall SelfTest_Ciphertext(void); + System::DynamicArray __fastcall SelfTest_Key(); + System::DynamicArray __fastcall SelfTest_Plaintext(); + System::DynamicArray __fastcall SelfTest_Ciphertext(); protected: virtual System::DynamicArray __fastcall Encrypt(const System::DynamicArray Buffer, TSimpleBlockCipherKey* Key, bool doEncrypt) = 0 ; @@ -59,7 +59,7 @@ class PASCALIMPLEMENTATION TSimpleBlockCipher : public System::TInterfacedObject int FBlockSizeInBytes; __fastcall TSimpleBlockCipher(const System::UnicodeString ProgId1, const System::UnicodeString DisplayName1, Utplb_streamcipher::TAlgorithmicFeatureSet Features1, int BlockSizeInBytes1); public: - /* TObject.Destroy */ inline __fastcall virtual ~TSimpleBlockCipher(void) { } + /* TObject.Destroy */ inline __fastcall virtual ~TSimpleBlockCipher() { } private: void *__IBlockCipher; // Utplb_blockcipher::IBlockCipher @@ -102,10 +102,10 @@ class PASCALIMPLEMENTATION TSimpleBlockCipherKey : public Utplb_streamcipher::TS public: System::DynamicArray FKeyData; virtual void __fastcall SaveToStream(System::Classes::TStream* Stream); - virtual void __fastcall Burn(void); + virtual void __fastcall Burn(); public: - /* TObject.Create */ inline __fastcall TSimpleBlockCipherKey(void) : Utplb_streamcipher::TSymetricKey() { } - /* TObject.Destroy */ inline __fastcall virtual ~TSimpleBlockCipherKey(void) { } + /* TObject.Create */ inline __fastcall TSimpleBlockCipherKey() : Utplb_streamcipher::TSymetricKey() { } + /* TObject.Destroy */ inline __fastcall virtual ~TSimpleBlockCipherKey() { } }; @@ -122,11 +122,11 @@ class PASCALIMPLEMENTATION TSimpleBlockCipherCodec : public System::TInterfacedO TSimpleBlockCipher* FCipher; void __fastcall Encrypt_Block(System::Classes::TMemoryStream* Plaintext, System::Classes::TMemoryStream* Ciphertext); void __fastcall Decrypt_Block(System::Classes::TMemoryStream* Plaintext, System::Classes::TMemoryStream* Ciphertext); - void __fastcall Reset(void); - void __fastcall Burn(void); + void __fastcall Reset(); + void __fastcall Burn(); public: - /* TObject.Create */ inline __fastcall TSimpleBlockCipherCodec(void) : System::TInterfacedObject() { } - /* TObject.Destroy */ inline __fastcall virtual ~TSimpleBlockCipherCodec(void) { } + /* TObject.Create */ inline __fastcall TSimpleBlockCipherCodec() : System::TInterfacedObject() { } + /* TObject.Destroy */ inline __fastcall virtual ~TSimpleBlockCipherCodec() { } private: void *__IBlockCodec; // Utplb_blockcipher::IBlockCodec diff --git a/hpp/Win32/Release/uTPLb_StrUtils.hpp b/hpp/Win32/Release/uTPLb_StrUtils.hpp index ed38a07..cde05d8 100644 --- a/hpp/Win32/Release/uTPLb_StrUtils.hpp +++ b/hpp/Win32/Release/uTPLb_StrUtils.hpp @@ -2,7 +2,7 @@ // Copyright (c) 1995, 2017 by Embarcadero Technologies, Inc. // All rights reserved -// (DO NOT EDIT: machine generated header) 'uTPLb_StrUtils.pas' rev: 32.00 (Windows) +// (DO NOT EDIT: machine generated header) 'uTPLb_StrUtils.pas' rev: 33.00 (Windows) #ifndef Utplb_strutilsHPP #define Utplb_strutilsHPP diff --git a/hpp/Win32/Release/uTPLb_StreamCipher.hpp b/hpp/Win32/Release/uTPLb_StreamCipher.hpp index 4c7e3d7..3d2605d 100644 --- a/hpp/Win32/Release/uTPLb_StreamCipher.hpp +++ b/hpp/Win32/Release/uTPLb_StreamCipher.hpp @@ -2,7 +2,7 @@ // Copyright (c) 1995, 2017 by Embarcadero Technologies, Inc. // All rights reserved -// (DO NOT EDIT: machine generated header) 'uTPLb_StreamCipher.pas' rev: 32.00 (Windows) +// (DO NOT EDIT: machine generated header) 'uTPLb_StreamCipher.pas' rev: 33.00 (Windows) #ifndef Utplb_streamcipherHPP #define Utplb_streamcipherHPP @@ -21,18 +21,18 @@ namespace Utplb_streamcipher { //-- forward type declarations ----------------------------------------------- -__interface ICryptoGraphicAlgorithm; +__interface DELPHIINTERFACE ICryptoGraphicAlgorithm; typedef System::DelphiInterface _di_ICryptoGraphicAlgorithm; class DELPHICLASS TSymetricKey; -__interface IStreamEncryptor; +__interface DELPHIINTERFACE IStreamEncryptor; typedef System::DelphiInterface _di_IStreamEncryptor; -__interface IStreamDecryptor; +__interface DELPHIINTERFACE IStreamDecryptor; typedef System::DelphiInterface _di_IStreamDecryptor; -__interface IStreamCipher; +__interface DELPHIINTERFACE IStreamCipher; typedef System::DelphiInterface _di_IStreamCipher; -__interface IStreamCipherEx2; +__interface DELPHIINTERFACE IStreamCipherEx2; typedef System::DelphiInterface _di_IStreamCipherEx2; -__interface IisBase64Converter; +__interface DELPHIINTERFACE IisBase64Converter; typedef System::DelphiInterface _di_IisBase64Converter; //-- type declarations ------------------------------------------------------- enum DECLSPEC_DENUM TAlgorithmicFeature : unsigned char { afStar, afCryptographicallyWeak, afNotImplementedYet, afForTestOnly, afForRunTimeOnly, afEncumberedByPatent, afEncumberedByCopyRight, afOpenSourceSoftware, afCommercial, afCompressor, afConverter, afBlockAdapter, afDisplayNameOnKeySize, afDoesNotNeedSalt, afAsymetric }; @@ -41,11 +41,11 @@ typedef System::Set __fastcall SelfTest_Key(void); - System::DynamicArray __fastcall SelfTest_Plaintext(void); - System::DynamicArray __fastcall SelfTest_Ciphertext(void); - System::TObject* __fastcall ControlObject(void); - int __fastcall SeedByteSize(void); + System::DynamicArray __fastcall SelfTest_Key(); + System::DynamicArray __fastcall SelfTest_Plaintext(); + System::DynamicArray __fastcall SelfTest_Ciphertext(); + System::TObject* __fastcall ControlObject(); + int __fastcall SeedByteSize(); public: - __fastcall TTwoFish(void); + __fastcall TTwoFish(); public: - /* TObject.Destroy */ inline __fastcall virtual ~TTwoFish(void) { } + /* TObject.Destroy */ inline __fastcall virtual ~TTwoFish() { } private: void *__IControlObject; // Utplb_decorators::IControlObject diff --git a/hpp/Win32/Release/uTPLb_XXTEA.hpp b/hpp/Win32/Release/uTPLb_XXTEA.hpp index 70a25b4..73278fc 100644 --- a/hpp/Win32/Release/uTPLb_XXTEA.hpp +++ b/hpp/Win32/Release/uTPLb_XXTEA.hpp @@ -2,7 +2,7 @@ // Copyright (c) 1995, 2017 by Embarcadero Technologies, Inc. // All rights reserved -// (DO NOT EDIT: machine generated header) 'uTPLb_XXTEA.pas' rev: 32.00 (Windows) +// (DO NOT EDIT: machine generated header) 'uTPLb_XXTEA.pas' rev: 33.00 (Windows) #ifndef Utplb_xxteaHPP #define Utplb_xxteaHPP @@ -34,23 +34,23 @@ class PASCALIMPLEMENTATION TXXTEA_LargeBlock : public System::TInterfacedObject private: Utplb_blockcipher::_di_IBlockChainingModel FChaining; - System::UnicodeString __fastcall DisplayName(void); - System::UnicodeString __fastcall ProgId(void); - Utplb_streamcipher::TAlgorithmicFeatureSet __fastcall Features(void); - System::UnicodeString __fastcall DefinitionURL(void); - System::UnicodeString __fastcall WikipediaReference(void); + System::UnicodeString __fastcall DisplayName(); + System::UnicodeString __fastcall ProgId(); + Utplb_streamcipher::TAlgorithmicFeatureSet __fastcall Features(); + System::UnicodeString __fastcall DefinitionURL(); + System::UnicodeString __fastcall WikipediaReference(); Utplb_streamcipher::TSymetricKey* __fastcall GenerateKey(System::Classes::TStream* Seed); Utplb_streamcipher::TSymetricKey* __fastcall LoadKeyFromStream(System::Classes::TStream* Store); - int __fastcall SeedByteSize(void); + int __fastcall SeedByteSize(); Utplb_streamcipher::_di_IStreamCipher __fastcall Parameterize(const System::_di_IInterface Params); Utplb_streamcipher::_di_IStreamEncryptor __fastcall Start_Encrypt(Utplb_streamcipher::TSymetricKey* Key, System::Classes::TStream* CipherText); Utplb_streamcipher::_di_IStreamDecryptor __fastcall Start_Decrypt(Utplb_streamcipher::TSymetricKey* Key, System::Classes::TStream* PlainText); - System::TObject* __fastcall ControlObject(void); + System::TObject* __fastcall ControlObject(); public: - __fastcall TXXTEA_LargeBlock(void); + __fastcall TXXTEA_LargeBlock(); public: - /* TObject.Destroy */ inline __fastcall virtual ~TXXTEA_LargeBlock(void) { } + /* TObject.Destroy */ inline __fastcall virtual ~TXXTEA_LargeBlock() { } private: void *__IControlObject; // Utplb_decorators::IControlObject @@ -98,8 +98,8 @@ class PASCALIMPLEMENTATION TXXTEA_LargeBlock : public System::TInterfacedObject typedef System::StaticArray TTEA_Key; //-- var, const, procedure --------------------------------------------------- -extern DELPHI_PACKAGE void __fastcall XXTEA_Encrypt(const TTEA_Key &Key, const System::TLongWordDynArray Plaintext, System::TLongWordDynArray &Ciphertext); -extern DELPHI_PACKAGE void __fastcall XXTEA_Decrypt(const TTEA_Key &Key, const System::TLongWordDynArray Ciphertext, System::TLongWordDynArray &Plaintext); +extern DELPHI_PACKAGE void __fastcall XXTEA_Encrypt(const TTEA_Key &Key, const System::DynamicArray Plaintext, System::DynamicArray &Ciphertext); +extern DELPHI_PACKAGE void __fastcall XXTEA_Decrypt(const TTEA_Key &Key, const System::DynamicArray Ciphertext, System::DynamicArray &Plaintext); } /* namespace Utplb_xxtea */ #if !defined(DELPHIHEADER_NO_IMPLICIT_NAMESPACE_USE) && !defined(NO_USING_NAMESPACE_UTPLB_XXTEA) using namespace Utplb_xxtea; diff --git a/packages/CBuilder/CBuilder.groupproj b/packages/CBuilder/LockBox3CBuilder.groupproj similarity index 97% rename from packages/CBuilder/CBuilder.groupproj rename to packages/CBuilder/LockBox3CBuilder.groupproj index 4d7745f..598ca7e 100644 --- a/packages/CBuilder/CBuilder.groupproj +++ b/packages/CBuilder/LockBox3CBuilder.groupproj @@ -1,60 +1,60 @@ - - - {C5E6A6AB-43A2-4433-A47D-BD30A624B251} - - - - - - - - - - - - - - Default.Personality.12 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + {C5E6A6AB-43A2-4433-A47D-BD30A624B251} + + + + + + + + + + + + + + Default.Personality.12 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/packages/CBuilder/LockBox3CD.cbproj b/packages/CBuilder/LockBox3CD.cbproj new file mode 100644 index 0000000..d586a3b --- /dev/null +++ b/packages/CBuilder/LockBox3CD.cbproj @@ -0,0 +1,591 @@ + + + {FB75B8F2-189C-41BF-BFED-980AAB6024CD} + 16.0 + VCL + LockBox3CD.cpp + True + Release + Win32 + 1 + Package + + + true + + + true + Base + true + + + true + Base + true + + + true + Base + true + + + true + Base + true + + + true + Base + true + + + true + Base + true + + + true + Cfg_1 + true + true + + + true + Base + true + + + true + Cfg_2 + true + true + + + true + <_TCHARMapping>char + 1031 + true + ..\..\hpp + CppPackage + TurboPack LockBox 3 CBuilder runtime package + true + ..\..\design\;$(IncludePath) + true + ..\..\design\;$(ILINK_LibraryPath) + System;Xml;Data;Datasnap;Web;Soap;Vcl;Vcl.Imaging;Vcl.Touch;Vcl.Samples;Vcl.Shell;$(DCC_Namespace) + ..\..\run\ciphers;..\..\run\cryptography;..\..\run\hashes;..\..\run\library surface;..\..\run\RSA;..\..\run\utilities;..\..\design;$(DCC_UnitSearchPath) + LockBox3CD + true + CompanyName=;FileDescription=;FileVersion=1.0.0.0;InternalName=;LegalCopyright=;LegalTrademarks=;OriginalFilename=;ProductName=;ProductVersion=1.0.0.0;Comments= + -LUDesignIDE + All + true + true + .\$(Platform)\$(Config) + false + true + true + $(BDSLIB)\$(PLATFORM)\release\$(LANGDIR);$(ILINK_TranslatedLibraryPath) + + + AbbreviaCR;bindcomp;bindcompdbx;bindcompfmx;bindengine;CloudService;CustomIPTransport;DataSnapClient;DataSnapCommon;DataSnapFireDAC;DataSnapNativeClient;DataSnapProviderClient;dbexpress;dbrtl;dbxcds;DbxClientDriver;DbxCommonDriver;DBXInterBaseDriver;DBXSqliteDriver;dsnap;dsnapxml;emsclient;emsclientfiredac;FireDAC;FireDACCommon;FireDACCommonDriver;FireDACDBXDriver;FireDACDSDriver;FireDACIBDriver;FireDACSqliteDriver;fmx;fmxFireDAC;FMXTee;FmxTeeUI;ibxpress;IndyCore;IndyIPClient;IndyIPCommon;IndyIPServer;IndyProtocols;IndySystem;inet;RESTBackendComponents;RESTComponents;rtl;soapmidas;soaprtl;soapserver;tethering;xmlrtl;$(PackageImports) + + + AbbreviaCR;bindcomp;bindcompdbx;bindcompfmx;bindengine;CloudService;CustomIPTransport;DataSnapClient;DataSnapCommon;DataSnapFireDAC;DataSnapNativeClient;DataSnapProviderClient;dbexpress;dbrtl;dbxcds;DbxClientDriver;DbxCommonDriver;DBXInterBaseDriver;DBXSqliteDriver;dsnap;dsnapxml;emsclient;emsclientfiredac;FireDAC;FireDACCommon;FireDACCommonDriver;FireDACDBXDriver;FireDACDSDriver;FireDACIBDriver;FireDACSqliteDriver;fmx;fmxase;fmxFireDAC;FMXTee;FmxTeeUI;ibxpress;IndyCore;IndyIPClient;IndyIPCommon;IndyIPServer;IndyProtocols;IndySystem;inet;RESTBackendComponents;RESTComponents;rtl;soapmidas;soaprtl;soapserver;tethering;xmlrtl;$(PackageImports) + + + AbbreviaCR;bindcomp;bindcompdbx;bindcompfmx;bindengine;CloudService;CustomIPTransport;DataSnapClient;DataSnapCommon;DataSnapFireDAC;DataSnapIndy10ServerTransport;DataSnapNativeClient;DataSnapProviderClient;DataSnapServer;DataSnapServerMidas;dbexpress;dbrtl;dbxcds;DbxClientDriver;DbxCommonDriver;DBXFirebirdDriver;DBXInformixDriver;DBXInterBaseDriver;DBXMySQLDriver;DBXOracleDriver;DBXSqliteDriver;DBXSybaseASADriver;dsnap;dsnapxml;emsclient;emsclientfiredac;FireDAC;FireDACASADriver;FireDACCommon;FireDACCommonDriver;FireDACDBXDriver;FireDACDSDriver;FireDACIBDriver;FireDACMSSQLDriver;FireDACMySQLDriver;FireDACODBCDriver;FireDACOracleDriver;FireDACPgDriver;FireDACSqliteDriver;fmx;fmxase;fmxdae;fmxFireDAC;fmxobj;FMXTee;FmxTeeUI;ibxpress;IndyCore;IndyIPClient;IndyIPCommon;IndyIPServer;IndyProtocols;IndySystem;inet;inetdb;inetdbxpress;RESTBackendComponents;RESTComponents;rtl;soapmidas;soaprtl;soapserver;tethering;xmlrtl;$(PackageImports) + + + $(BDSINCLUDE)\windows\vcl;$(IncludePath) + 1033 + AbbreviaCR;AbbreviaVCLC;adortl;AsyncProCD;AsyncProCR;bcbie;bcbsmp;bindcomp;bindcompdbx;bindcompfmx;bindcompvcl;bindengine;CloudService;CodeSiteExpressPkg;CustomIPTransport;DataSnapClient;DataSnapCommon;DataSnapConnectors;DatasnapConnectorsFreePascal;DataSnapFireDAC;DataSnapIndy10ServerTransport;DataSnapNativeClient;DataSnapProviderClient;DataSnapServer;DataSnapServerMidas;dbexpress;dbrtl;dbxcds;DbxClientDriver;DbxCommonDriver;DBXDb2Driver;DBXFirebirdDriver;DBXInformixDriver;DBXInterBaseDriver;DBXMSSQLDriver;DBXMySQLDriver;DBXOdbcDriver;DBXOracleDriver;DBXSqliteDriver;DBXSybaseASADriver;DBXSybaseASEDriver;dsnap;dsnapcon;dsnapxml;emsclient;emsclientfiredac;FireDAC;FireDACADSDriver;FireDACASADriver;FireDACCommon;FireDACCommonDriver;FireDACDb2Driver;FireDACDBXDriver;FireDACDSDriver;FireDACIBDriver;FireDACInfxDriver;FireDACMSAccDriver;FireDACMSSQLDriver;FireDACMySQLDriver;FireDACODBCDriver;FireDACOracleDriver;FireDACPgDriver;FireDACSqliteDriver;fmx;fmxase;fmxdae;fmxFireDAC;fmxobj;FMXTee;FmxTeeUI;frx21;frxDB21;frxe21;frxTee21;ibxpress;IndyCore;IndyIPClient;IndyIPCommon;IndyIPServer;IndyProtocols;IndySystem;inet;inetdb;inetdbxpress;Intraweb;MetropolisUILiveTile;OrpheusCD;OrpheusCR;OrpheusDBCR;RESTBackendComponents;RESTComponents;rtl;soapmidas;soaprtl;soapserver;svn;SynEditCR;Tee;TeeDB;TeeUI;tethering;vcl;vclactnband;vcldb;vcldsnap;vclFireDAC;vclib;vclie;vclimg;VCLRESTComponents;vclribbon;VclSmp;vcltouch;vclx;xmlrtl;$(PackageImports) + Winapi;System.Win;Data.Win;Datasnap.Win;Web.Win;Soap.Win;Xml.Win;Bde;$(DCC_Namespace) + true + CompanyName=;FileDescription=;FileVersion=1.0.0.0;InternalName=;LegalCopyright=;LegalTrademarks=;OriginalFilename=;ProductName=;ProductVersion=1.0.0.0;Comments= + + + AbbreviaCR;AbbreviaVCLC;adortl;bindcomp;bindcompdbx;bindcompfmx;bindcompvcl;bindengine;CloudService;CustomIPTransport;DataSnapClient;DataSnapCommon;DataSnapConnectors;DatasnapConnectorsFreePascal;DataSnapFireDAC;DataSnapIndy10ServerTransport;DataSnapNativeClient;DataSnapProviderClient;DataSnapServer;DataSnapServerMidas;dbexpress;dbrtl;dbxcds;DbxClientDriver;DbxCommonDriver;DBXDb2Driver;DBXFirebirdDriver;DBXInformixDriver;DBXInterBaseDriver;DBXMSSQLDriver;DBXMySQLDriver;DBXOdbcDriver;DBXOracleDriver;DBXSqliteDriver;DBXSybaseASADriver;DBXSybaseASEDriver;dsnap;dsnapcon;dsnapxml;emsclient;emsclientfiredac;FireDAC;FireDACADSDriver;FireDACASADriver;FireDACCommon;FireDACCommonDriver;FireDACDb2Driver;FireDACDBXDriver;FireDACDSDriver;FireDACIBDriver;FireDACInfxDriver;FireDACMSAccDriver;FireDACMSSQLDriver;FireDACMySQLDriver;FireDACODBCDriver;FireDACOracleDriver;FireDACPgDriver;FireDACSqliteDriver;fmx;fmxase;fmxdae;fmxFireDAC;fmxobj;FMXTee;FmxTeeUI;ibxpress;IndyCore;IndyIPClient;IndyIPCommon;IndyIPServer;IndyProtocols;IndySystem;inet;inetdb;inetdbxpress;Intraweb;MetropolisUILiveTile;OrpheusCR;OrpheusDBCR;RESTBackendComponents;RESTComponents;rtl;soapmidas;soaprtl;soapserver;SynEditCR;Tee;TeeDB;TeeUI;tethering;vcl;vclactnband;vcldb;vcldsnap;vclFireDAC;vclib;vclie;vclimg;VCLRESTComponents;vclribbon;VclSmp;vcltouch;vclx;xmlrtl;$(PackageImports) + $(BDSINCLUDE)\windows\vcl;$(IncludePath) + + + false + true + false + true + _DEBUG;$(Defines) + false + None + DEBUG + true + true + true + true + Full + true + true + true + true + true + $(BDSLIB)\$(PLATFORM)\debug;$(ILINK_LibraryPath) + $(BDSLIB)\$(PLATFORM)\debug\$(LANGDIR);$(ILINK_TranslatedLibraryPath) + + + 1033 + true + + + NDEBUG;$(Defines) + None + + + 1033 + true + + + + 3 + + +
TPLb_fmComponentAbout
+ dfm + 4 + + + 5 + + + 6 + + + 7 + + + 0 + + + 2 + + + 1 + + + 9 + + + 11 + + + 13 + + + 8 + + + 12 + + + 10 + + + + Cfg_2 + Base + + + Base + + + Cfg_1 + Base + + + + CPlusPlusBuilder.Personality.12 + CppPackage + + + + False + True + True + False + + + LockBox3CD.cpp + + + Embarcadero C++Builder-Package für Office 2000-Server + Embarcadero C++Builder-Package für Office XP-Server + Microsoft Office 2000 Beispiele für gekapselte Komponenten für Automatisierungsserver + Microsoft Office XP Beispiele für gekapselte Komponenten für Automation Server + + + + + + true + + + + + true + + + + + true + + + + + LockBox3CD.bpl + true + + + + + LockBox3CD.bpl + true + + + + + true + + + + + true + + + true + + + + + LockBox3CD.bpl + true + + + + + true + + + + + true + + + + + true + + + + + true + + + + + 1 + .dylib + + + 0 + .bpl + + + 1 + .dylib + + + 1 + .dylib + + + + + 1 + .dylib + + + 0 + .dll;.bpl + + + + + 1 + + + 1 + + + + + + ..\$(PROJECTNAME).app.dSYM\Contents\Resources\DWARF + 1 + + + + + res\drawable-normal + 1 + + + + + library\lib\x86 + 1 + + + + + 1 + + + 1 + + + + + + library\lib\armeabi-v7a + 1 + + + + + 1 + + + 1 + + + + + res\drawable-xlarge + 1 + + + + + res\drawable-xhdpi + 1 + + + + + 1 + + + 1 + + + + + res\drawable-xxhdpi + 1 + + + + + library\lib\mips + 1 + + + + + res\drawable + 1 + + + + + 1 + + + 1 + + + 0 + + + + + 1 + .framework + + + 0 + + + + + res\drawable-small + 1 + + + + + + 1 + + + Contents\MacOS + 0 + + + + + classes + 1 + + + + + + 1 + + + 1 + + + + + res\drawable + 1 + + + + + Contents\Resources + 1 + + + + + + 1 + + + 1 + + + + + 1 + + + library\lib\armeabi-v7a + 1 + + + 0 + + + 1 + + + 1 + + + + + library\lib\armeabi + 1 + + + + + res\drawable-large + 1 + + + + + 0 + + + 0 + + + 0 + + + 0 + + + 0 + + + + + 1 + + + 1 + + + + + res\drawable-ldpi + 1 + + + + + res\values + 1 + + + + + 1 + + + 1 + + + + + res\drawable-mdpi + 1 + + + + + res\drawable-hdpi + 1 + + + + + 1 + + + + + + + + + + + False + False + False + True + False + + + 12 + + + + + diff --git a/packages/CBuilder/LockBox3CD.cpp b/packages/CBuilder/LockBox3CD.cpp new file mode 100644 index 0000000..f66360b --- /dev/null +++ b/packages/CBuilder/LockBox3CD.cpp @@ -0,0 +1,19 @@ +//--------------------------------------------------------------------------- + +#include +#pragma hdrstop +USEFORMNS("..\..\design\uTPLb_ComponentAbout.pas", Utplb_componentabout, TPLb_fmComponentAbout); +//--------------------------------------------------------------------------- +#pragma package(smart_init) +//--------------------------------------------------------------------------- + +// Package-Quelltext. +//--------------------------------------------------------------------------- + + +#pragma argsused +extern "C" int _libmain(unsigned long reason) +{ + return 1; +} +//--------------------------------------------------------------------------- diff --git a/packages/CBuilder/LockBox3CD.res b/packages/CBuilder/LockBox3CD.res new file mode 100644 index 0000000000000000000000000000000000000000..a64cea33b7bbf9c30d10d7750693ab849f870abc GIT binary patch literal 448 zcmZ9IO-chn5QV>ySr}Iy!G&uXVK#zb0{#&2k7USJhD0SG8Ax>JVZ4a9aqkTrzwWV# zNkPq2cfI%ObpafhZQG^gM)b4P-xuS-DCp%0)Xz%G31c4oUNEv6a>uRbq2EjE5TE(? z4+MUvk^X0~3qde-{;v3lcVk{zGH1cFYI9zARC&P@js5qCDJXSyVwQRcjtX|wOZbVL zB`evD%n-*MiAjl^fWH^jFyoD>Q@2^$oO5+DQMIfzY3&RS {E753F449-E27A-4AB1-AA47-98524AD1FAA4} - 18.4 + 18.5 None LockBox3CR.cpp True @@ -143,7 +143,7 @@ AbbreviaCR;bindcomp;bindcompdbx;bindcompfmx;bindengine;CloudService;CustomIPTransport;DataSnapClient;DataSnapCommon;DataSnapFireDAC;DataSnapNativeClient;DataSnapProviderClient;dbexpress;dbrtl;dbxcds;DbxClientDriver;DbxCommonDriver;DBXInterBaseDriver;DBXSqliteDriver;dsnap;dsnapxml;emsclient;emsclientfiredac;FireDAC;FireDACCommon;FireDACCommonDriver;FireDACDBXDriver;FireDACDSDriver;FireDACIBDriver;FireDACSqliteDriver;fmx;fmxase;fmxFireDAC;FMXTee;FmxTeeUI;ibxpress;IndyCore;IndyIPClient;IndyIPCommon;IndyIPServer;IndyProtocols;IndySystem;inet;RESTBackendComponents;RESTComponents;rtl;soapmidas;soaprtl;soapserver;tethering;xmlrtl;$(PackageImports);$(PackageImports) true Debug - CFBundleName=$(MSBuildProjectName);CFBundleDevelopmentRegion=en;CFBundleDisplayName=$(MSBuildProjectName);CFBundleIdentifier=$(MSBuildProjectName);CFBundleInfoDictionaryVersion=7.1;CFBundleVersion=1.0.0.0;CFBundlePackageType=APPL;CFBundleSignature=????;LSRequiresIPhoneOS=true;CFBundleAllowMixedLocalizations=YES;CFBundleExecutable=$(MSBuildProjectName);UIDeviceFamily=iPhone & iPad;CFBundleResourceSpecification=ResourceRules.plist;NSLocationAlwaysUsageDescription=The reason for accessing the location information of the user;NSLocationWhenInUseUsageDescription=The reason for accessing the location information of the user;FMLocalNotificationPermission=false;UIBackgroundModes=;NSContactsUsageDescription=The reason for accessing the contacts;NSPhotoLibraryUsageDescription=The reason for accessing the photo library;NSCameraUsageDescription=The reason for accessing the camera;CFBundleShortVersionString=1.0.0 + CFBundleName=$(MSBuildProjectName);CFBundleDevelopmentRegion=en;CFBundleDisplayName=$(MSBuildProjectName);CFBundleIdentifier=$(MSBuildProjectName);CFBundleInfoDictionaryVersion=7.1;CFBundleVersion=1.0.0.0;CFBundlePackageType=APPL;CFBundleSignature=????;LSRequiresIPhoneOS=true;CFBundleAllowMixedLocalizations=YES;CFBundleExecutable=$(MSBuildProjectName);UIDeviceFamily=iPhone & iPad;CFBundleResourceSpecification=ResourceRules.plist;NSLocationAlwaysUsageDescription=The reason for accessing the location information of the user;NSLocationWhenInUseUsageDescription=The reason for accessing the location information of the user;FMLocalNotificationPermission=false;UIBackgroundModes=;NSContactsUsageDescription=The reason for accessing the contacts;NSPhotoLibraryUsageDescription=The reason for accessing the photo library;NSCameraUsageDescription=The reason for accessing the camera;CFBundleShortVersionString=1.0.0;NSPhotoLibraryAddUsageDescription=The reason for adding to the photo library;NSFaceIDUsageDescription=The reason for accessing the face id;NSLocationAlwaysAndWhenInUseUsageDescription=The reason for accessing the location information of the user;NSMicrophoneUsageDescription=The reason for accessing the microphone;NSSiriUsageDescription=The reason for accessing Siri true @@ -154,11 +154,11 @@ AbbreviaCR;bindcomp;bindcompdbx;bindcompfmx;bindengine;CloudService;CustomIPTransport;DataSnapClient;DataSnapCommon;DataSnapFireDAC;DataSnapNativeClient;DataSnapProviderClient;dbexpress;dbrtl;dbxcds;DbxClientDriver;DbxCommonDriver;DBXInterBaseDriver;DBXSqliteDriver;dsnap;dsnapxml;emsclient;emsclientfiredac;FireDAC;FireDACCommon;FireDACCommonDriver;FireDACDBXDriver;FireDACDSDriver;FireDACIBDriver;FireDACSqliteDriver;fmx;fmxase;fmxFireDAC;FMXTee;FmxTeeUI;ibxpress;IndyCore;IndyIPClient;IndyIPCommon;IndyIPServer;IndyProtocols;IndySystem;inet;RESTBackendComponents;RESTComponents;rtl;soapmidas;soaprtl;soapserver;tethering;xmlrtl;$(PackageImports);$(PackageImports) true Debug - CFBundleName=$(MSBuildProjectName);CFBundleDevelopmentRegion=en;CFBundleDisplayName=$(MSBuildProjectName);CFBundleIdentifier=$(MSBuildProjectName);CFBundleInfoDictionaryVersion=7.1;CFBundleVersion=1.0.0.0;CFBundlePackageType=APPL;CFBundleSignature=????;LSRequiresIPhoneOS=true;CFBundleAllowMixedLocalizations=YES;CFBundleExecutable=$(MSBuildProjectName);UIDeviceFamily=iPhone & iPad;CFBundleResourceSpecification=ResourceRules.plist;NSLocationAlwaysUsageDescription=The reason for accessing the location information of the user;NSLocationWhenInUseUsageDescription=The reason for accessing the location information of the user;FMLocalNotificationPermission=false;UIBackgroundModes=;NSContactsUsageDescription=The reason for accessing the contacts;NSPhotoLibraryUsageDescription=The reason for accessing the photo library;NSCameraUsageDescription=The reason for accessing the camera;CFBundleShortVersionString=1.0.0 + CFBundleName=$(MSBuildProjectName);CFBundleDevelopmentRegion=en;CFBundleDisplayName=$(MSBuildProjectName);CFBundleIdentifier=$(MSBuildProjectName);CFBundleInfoDictionaryVersion=7.1;CFBundleVersion=1.0.0.0;CFBundlePackageType=APPL;CFBundleSignature=????;LSRequiresIPhoneOS=true;CFBundleAllowMixedLocalizations=YES;CFBundleExecutable=$(MSBuildProjectName);UIDeviceFamily=iPhone & iPad;CFBundleResourceSpecification=ResourceRules.plist;NSLocationAlwaysUsageDescription=The reason for accessing the location information of the user;NSLocationWhenInUseUsageDescription=The reason for accessing the location information of the user;FMLocalNotificationPermission=false;UIBackgroundModes=;NSContactsUsageDescription=The reason for accessing the contacts;NSPhotoLibraryUsageDescription=The reason for accessing the photo library;NSCameraUsageDescription=The reason for accessing the camera;CFBundleShortVersionString=1.0.0;NSPhotoLibraryAddUsageDescription=The reason for adding to the photo library;NSFaceIDUsageDescription=The reason for accessing the face id;NSLocationAlwaysAndWhenInUseUsageDescription=The reason for accessing the location information of the user;NSMicrophoneUsageDescription=The reason for accessing the microphone;NSSiriUsageDescription=The reason for accessing Siri AbbreviaCR;bindcomp;bindcompdbx;bindcompfmx;bindengine;CloudService;CustomIPTransport;DataSnapClient;DataSnapCommon;DataSnapFireDAC;DataSnapIndy10ServerTransport;DataSnapNativeClient;DataSnapProviderClient;DataSnapServer;DataSnapServerMidas;dbexpress;dbrtl;dbxcds;DbxClientDriver;DbxCommonDriver;DBXFirebirdDriver;DBXInformixDriver;DBXInterBaseDriver;DBXMySQLDriver;DBXOracleDriver;DBXSqliteDriver;DBXSybaseASADriver;dsnap;dsnapxml;emsclient;emsclientfiredac;FireDAC;FireDACASADriver;FireDACCommon;FireDACCommonDriver;FireDACDBXDriver;FireDACDSDriver;FireDACIBDriver;FireDACMSSQLDriver;FireDACMySQLDriver;FireDACODBCDriver;FireDACOracleDriver;FireDACPgDriver;FireDACSqliteDriver;fmx;fmxase;fmxdae;fmxFireDAC;fmxobj;FMXTee;FmxTeeUI;ibxpress;IndyCore;IndyIPClient;IndyIPCommon;IndyIPServer;IndyProtocols;IndySystem;inet;inetdb;inetdbxpress;RESTBackendComponents;RESTComponents;rtl;soapmidas;soaprtl;soapserver;tethering;xmlrtl;$(PackageImports) - CFBundleName=$(MSBuildProjectName);CFBundleDisplayName=$(MSBuildProjectName);CFBundleIdentifier=$(MSBuildProjectName);CFBundleVersion=1.0.0;CFBundlePackageType=APPL;CFBundleSignature=????;CFBundleAllowMixedLocalizations=YES;CFBundleExecutable=$(MSBuildProjectName);NSHighResolutionCapable=true;LSApplicationCategoryType=public.app-category.utilities;NSLocationWhenInUseUsageDescription=The reason for accessing the location information of the user;NSLocationAlwaysUsageDescription=The reason for accessing the location information of the user;NSContactsUsageDescription=The reason for accessing the contacts;CFBundleShortVersionString=1.0.0 + CFBundleName=$(MSBuildProjectName);CFBundleDisplayName=$(MSBuildProjectName);CFBundleIdentifier=$(MSBuildProjectName);CFBundleVersion=1.0.0;CFBundlePackageType=APPL;CFBundleSignature=????;CFBundleAllowMixedLocalizations=YES;CFBundleExecutable=$(MSBuildProjectName);NSHighResolutionCapable=true;LSApplicationCategoryType=public.app-category.utilities;NSLocationWhenInUseUsageDescription=The reason for accessing the location information of the user;NSLocationAlwaysUsageDescription=The reason for accessing the location information of the user;NSContactsUsageDescription=The reason for accessing the contacts;CFBundleShortVersionString=1.0.0;NSLocationAlwaysAndWhenInUseUsageDescription=The reason for accessing the location information of the user 1033 @@ -418,6 +418,11 @@ + + + true + + true @@ -434,6 +439,16 @@ true + + + true + + + + + true + + true @@ -515,6 +530,11 @@ true + + + true + + true @@ -546,6 +566,11 @@ true + + + true + + true @@ -561,6 +586,11 @@ true + + + true + + LockBox3CR.tds @@ -572,16 +602,31 @@ true + + + true + + true + + + true + + true + + + true + + true @@ -592,12 +637,16 @@ true + + + true + + 1 - Contents\MacOS 0 @@ -607,6 +656,12 @@ 1 + + + res\xml + 1 + + library\lib\armeabi-v7a @@ -644,6 +699,12 @@ 1 + + + res\values-v21 + 1 + + res\drawable @@ -720,6 +781,10 @@ 1 .framework + + 1 + .framework + 0 @@ -729,6 +794,10 @@ 1 .dylib + + 1 + .dylib + 0 .dll;.bpl @@ -751,6 +820,10 @@ 1 .dylib + + 1 + .dylib + 0 .bpl @@ -772,6 +845,9 @@ 0 + + 0 + 0 @@ -882,6 +958,7 @@ 1 + @@ -889,6 +966,10 @@ Contents\Resources 1 + + Contents\Resources + 1 + @@ -910,6 +991,9 @@ 1 + + 1 + 0 @@ -949,6 +1033,7 @@ + diff --git a/packages/CBuilder/LockBox3FMXCD.cbproj b/packages/CBuilder/LockBox3FMXCD.cbproj index 18d7796..ceb9e88 100644 --- a/packages/CBuilder/LockBox3FMXCD.cbproj +++ b/packages/CBuilder/LockBox3FMXCD.cbproj @@ -1,7 +1,7 @@  {5E37C4FC-5A29-47BF-9855-A43F8652D42E} - 18.4 + 18.5 FMX LockBox3FMXCD.cpp True @@ -252,11 +252,26 @@ + + + true + + true + + + true + + + + + true + + true @@ -369,6 +384,16 @@ true + + + true + + + + + true + + true @@ -379,11 +404,31 @@ true + + + true + + + + + true + + + + + true + + true + + + true + + true @@ -399,12 +444,16 @@ true + + + true + + 1 - Contents\MacOS 0 @@ -414,6 +463,12 @@ 1 + + + res\xml + 1 + + library\lib\armeabi-v7a @@ -451,6 +506,12 @@ 1 + + + res\values-v21 + 1 + + res\drawable @@ -527,6 +588,10 @@ 1 .framework + + 1 + .framework + 0 @@ -536,6 +601,10 @@ 1 .dylib + + 1 + .dylib + 0 .dll;.bpl @@ -558,6 +627,10 @@ 1 .dylib + + 1 + .dylib + 0 .bpl @@ -579,6 +652,9 @@ 0 + + 0 + 0 @@ -689,6 +765,7 @@ 1 + @@ -696,6 +773,10 @@ Contents\Resources 1 + + Contents\Resources + 1 + @@ -717,6 +798,9 @@ 1 + + 1 + 0 @@ -756,6 +840,7 @@ + diff --git a/packages/CBuilder/LockBox3VCLCD.cbproj b/packages/CBuilder/LockBox3VCLCD.cbproj index 1f0b5c5..63acb9d 100644 --- a/packages/CBuilder/LockBox3VCLCD.cbproj +++ b/packages/CBuilder/LockBox3VCLCD.cbproj @@ -1,7 +1,7 @@  {FB75B8F2-189C-41BF-BFED-980AAB6024CD} - 18.4 + 18.5 VCL LockBox3VCLCD.cpp True @@ -285,16 +285,36 @@ + + + true + + + + + true + + true + + + true + + true + + + true + + true @@ -387,6 +407,16 @@ true + + + true + + + + + true + + true @@ -407,11 +437,21 @@ true + + + true + + true + + + true + + true @@ -438,7 +478,6 @@ 1 - Contents\MacOS 0 @@ -448,6 +487,12 @@ 1 + + + res\xml + 1 + + library\lib\armeabi-v7a @@ -485,6 +530,12 @@ 1 + + + res\values-v21 + 1 + + res\drawable @@ -561,6 +612,10 @@ 1 .framework + + 1 + .framework + 0 @@ -570,6 +625,10 @@ 1 .dylib + + 1 + .dylib + 0 .dll;.bpl @@ -592,6 +651,10 @@ 1 .dylib + + 1 + .dylib + 0 .bpl @@ -613,6 +676,9 @@ 0 + + 0 + 0 @@ -723,6 +789,7 @@ 1 + @@ -730,6 +797,10 @@ Contents\Resources 1 + + Contents\Resources + 1 + @@ -751,6 +822,9 @@ 1 + + 1 + 0 @@ -790,6 +864,7 @@ + diff --git a/packages/Delphi/LockBox3DD.dpk b/packages/Delphi/LockBox3DD.dpk new file mode 100644 index 0000000..c13944e --- /dev/null +++ b/packages/Delphi/LockBox3DD.dpk @@ -0,0 +1,45 @@ +package LockBox3DD; + +{$R *.res} +{$IFDEF IMPLICITBUILDING This IFDEF should not be used by users} +{$ALIGN 8} +{$ASSERTIONS ON} +{$BOOLEVAL OFF} +{$DEBUGINFO OFF} +{$EXTENDEDSYNTAX ON} +{$IMPORTEDDATA ON} +{$IOCHECKS ON} +{$LOCALSYMBOLS OFF} +{$LONGSTRINGS ON} +{$OPENSTRINGS ON} +{$OPTIMIZATION ON} +{$OVERFLOWCHECKS OFF} +{$RANGECHECKS OFF} +{$REFERENCEINFO OFF} +{$SAFEDIVIDE OFF} +{$STACKFRAMES OFF} +{$TYPEDADDRESS OFF} +{$VARSTRINGCHECKS ON} +{$WRITEABLECONST OFF} +{$MINENUMSIZE 1} +{$IMAGEBASE $400000} +{$DEFINE RELEASE} +{$ENDIF IMPLICITBUILDING} +{$DESCRIPTION 'TurboPack LockBox 3 designtime package'} +{$DESIGNONLY} +{$IMPLICITBUILD OFF} + +requires + rtl, + designide, + vclie, + vclimg, + LockBox3DR; + +contains + uTPLb_ComponentRegistration in '..\..\design\uTPLb_ComponentRegistration.pas', + uTPLb_ComponentEditors in '..\..\design\uTPLb_ComponentEditors.pas', + uTPLb_ComponentAbout in '..\..\design\uTPLb_ComponentAbout.pas' {TPLb_fmComponentAbout}, + uTPLb_InfoUtils in '..\..\design\uTPLb_InfoUtils.pas'; + +end. diff --git a/packages/Delphi/LockBox3DD.dproj b/packages/Delphi/LockBox3DD.dproj new file mode 100644 index 0000000..0be368f --- /dev/null +++ b/packages/Delphi/LockBox3DD.dproj @@ -0,0 +1,520 @@ + + + {6CE4E4DD-7FD2-4184-A3C0-4235E72C6DF8} + LockBox3DD.dpk + True + Release + 1 + Package + None + 18.0 + Win32 + + + true + + + true + Base + true + + + true + Base + true + + + true + Base + true + + + true + Base + true + + + true + Base + true + + + true + Cfg_1 + true + true + + + true + Base + true + + + true + Cfg_2 + true + true + + + true + Cfg_2 + true + true + + + All + .\$(Platform)\$(Config);$(DCC_UnitSearchPath) + .\$(Platform)\$(Config) + LockBox3DD + rtl;$(DCC_UsePackage) + true + CompanyName=;FileDescription=;FileVersion=1.0.0.0;InternalName=;LegalCopyright=;LegalTrademarks=;OriginalFilename=;ProductName=;ProductVersion=1.0.0.0;Comments= + 00400000 + TurboPower LockBox 3 designtime package + System;Xml;Data;Datasnap;Web;Soap;Winapi;Vcl;Vcl.Imaging;System.Win;$(DCC_Namespace) + true + true + false + false + true + false + 3081 + false + false + + + package=com.embarcadero.$(MSBuildProjectName);label=$(MSBuildProjectName);versionCode=1;versionName=1.0.0;persistent=False;restoreAnyVersion=False;installLocation=preferExternal;largeHeap=False;theme=TitleBar;hardwareAccelerated=true + Debug + + + $(BDS)\bin\delphi_PROJECTICNS.icns + + + 3 + 4 + true + vclie;vclimg;TP_LockBox3;$(DCC_UsePackage) + true + Data.Win;Datasnap.Win;Web.Win;Soap.Win;Xml.Win;Bde;$(DCC_Namespace) + 1033 + CompanyName=;FileDescription=;FileVersion=3.4.0.0;InternalName=;LegalCopyright=;LegalTrademarks=;OriginalFilename=;ProductName=;ProductVersion=1.0.0.0;Comments= + + + vclie;vclimg;$(DCC_UsePackage) + + + false + 0 + 0 + RELEASE;$(DCC_Define) + + + true + 4 + 3 + true + 1033 + CompanyName=;FileDescription=;FileVersion=3.4.0.0;InternalName=;LegalCopyright=;LegalTrademarks=;OriginalFilename=;ProductName=;ProductVersion=1.0.0.0;Comments= + + + DEBUG;$(DCC_Define) + false + true + + + $(BDS)\bin\delphi_PROJECTICNS.icns + + + true + 4 + true + 3 + CompanyName=;FileDescription=;FileVersion=3.4.0.0;InternalName=;LegalCopyright=;LegalTrademarks=;OriginalFilename=;ProductName=;ProductVersion=1.0.0.0;Comments= + 1033 + + + + MainSource + + + + + + + + + +
TPLb_fmComponentAbout
+ + + + Cfg_2 + Base + + + Base + + + Cfg_1 + Base + + + + Delphi.Personality.12 + Package + + + + LockBox3DD.dpk + + + True + False + 1 + 0 + 0 + 0 + False + False + False + False + False + 3081 + 1252 + + + + + 1.0.0.0 + + + + + + 1.0.0.0 + + + + Embarcadero C++Builder-Package für Office 2000-Server + Embarcadero C++Builder-Package für Office XP-Server + Microsoft Office 2000 Beispiele für gekapselte Komponenten für Automatisierungsserver + Microsoft Office XP Beispiele für gekapselte Komponenten für Automation Server + + + + False + False + False + False + True + False + + + + + LockBox3DD.bpl + true + + + + + true + + + true + + + + + 1 + .dylib + + + 0 + .bpl + + + 1 + .dylib + + + 1 + .dylib + + + + + 1 + .dylib + + + 0 + .dll;.bpl + + + + + 1 + + + 1 + + + + + + ..\$(PROJECTNAME).app.dSYM\Contents\Resources\DWARF + 1 + + + + + res\drawable-normal + 1 + + + + + library\lib\x86 + 1 + + + + + 1 + + + 1 + + + + + + library\lib\armeabi-v7a + 1 + + + + + 1 + + + 1 + + + + + res\drawable-xlarge + 1 + + + + + res\drawable-xhdpi + 1 + + + + + 1 + + + 1 + + + + + res\drawable-xxhdpi + 1 + + + + + library\lib\mips + 1 + + + + + res\drawable + 1 + + + + + 1 + + + 1 + + + 0 + + + + + 1 + .framework + + + 0 + + + + + res\drawable-small + 1 + + + + + + 1 + + + Contents\MacOS + 0 + + + + + classes + 1 + + + + + + 1 + + + 1 + + + + + res\drawable + 1 + + + + + Contents\Resources + 1 + + + + + + 1 + + + 1 + + + + + 1 + + + library\lib\armeabi-v7a + 1 + + + 0 + + + 1 + + + 1 + + + + + library\lib\armeabi + 1 + + + + + res\drawable-large + 1 + + + + + 0 + + + 0 + + + 0 + + + 0 + + + 0 + + + + + 1 + + + 1 + + + + + res\drawable-ldpi + 1 + + + + + res\values + 1 + + + + + 1 + + + 1 + + + + + res\drawable-mdpi + 1 + + + + + res\drawable-hdpi + 1 + + + + + 1 + + + + + + + + + + + 12 + + + + + diff --git a/packages/Delphi/LockBox3DD.res b/packages/Delphi/LockBox3DD.res new file mode 100644 index 0000000000000000000000000000000000000000..bcdf8e6b531ee335150777890677e6f79abd43fc GIT binary patch literal 448 zcmZ9I%Sr=55JgXGFN`Zc!G-HE;%o%L1bh(iMI5q~!50C^K%zT8#vk!--1`TPr)Qi* zEx0|mr|zw)E`V)O*Da)fVi3CgmKrZcMlW`vLCB>OuDS6%W-J?V$%Xfk=ZQSUd;I)@ zKxDnSC!XR^tcg^x{UiB_H^0Gp&&-)J1247 Package VCL - 18.4 + 18.5 Win32 @@ -135,6 +135,7 @@ 3081 false false + false 1 @@ -144,7 +145,7 @@ true - CFBundleName=$(MSBuildProjectName);CFBundleDevelopmentRegion=en;CFBundleDisplayName=$(MSBuildProjectName);CFBundleIdentifier=$(MSBuildProjectName);CFBundleInfoDictionaryVersion=6.0;CFBundleVersion=1.0.0.0;CFBundlePackageType=APPL;CFBundleSignature=????;LSRequiresIPhoneOS=true;CFBundleAllowMixedLocalizations=YES;CFBundleExecutable=$(MSBuildProjectName);UIDeviceFamily=iPhone & iPad;CFBundleResourceSpecification=ResourceRules.plist;NSLocationWhenInUseUsageDescription=The reason for accessing the location information of the user;NSLocationAlwaysUsageDescription=The reason for accessing the location information of the user;FMLocalNotificationPermission=false;UIBackgroundModes=;NSContactsUsageDescription=The reason for accessing the contacts;NSPhotoLibraryUsageDescription=The reason for accessing the photo library;NSCameraUsageDescription=The reason for accessing the camera;CFBundleShortVersionString=1.0.0 + CFBundleName=$(MSBuildProjectName);CFBundleDevelopmentRegion=en;CFBundleDisplayName=$(MSBuildProjectName);CFBundleIdentifier=$(MSBuildProjectName);CFBundleInfoDictionaryVersion=6.0;CFBundleVersion=1.0.0.0;CFBundlePackageType=APPL;CFBundleSignature=????;LSRequiresIPhoneOS=true;CFBundleAllowMixedLocalizations=YES;CFBundleExecutable=$(MSBuildProjectName);UIDeviceFamily=iPhone & iPad;CFBundleResourceSpecification=ResourceRules.plist;NSLocationWhenInUseUsageDescription=The reason for accessing the location information of the user;NSLocationAlwaysUsageDescription=The reason for accessing the location information of the user;FMLocalNotificationPermission=false;UIBackgroundModes=;NSContactsUsageDescription=The reason for accessing the contacts;NSPhotoLibraryUsageDescription=The reason for accessing the photo library;NSCameraUsageDescription=The reason for accessing the camera;CFBundleShortVersionString=1.0.0;NSPhotoLibraryAddUsageDescription=The reason for adding to the photo library;NSFaceIDUsageDescription=The reason for accessing the face id;NSLocationAlwaysAndWhenInUseUsageDescription=The reason for accessing the location information of the user;NSMicrophoneUsageDescription=The reason for accessing the microphone;NSSiriUsageDescription=The reason for accessing Siri iPhoneAndiPad @@ -187,7 +188,7 @@ true iPhoneAndiPad - CFBundleName=$(MSBuildProjectName);CFBundleDevelopmentRegion=en;CFBundleDisplayName=$(MSBuildProjectName);CFBundleIdentifier=$(MSBuildProjectName);CFBundleInfoDictionaryVersion=6.0;CFBundleVersion=1.0.0.0;CFBundlePackageType=APPL;CFBundleSignature=????;LSRequiresIPhoneOS=true;CFBundleAllowMixedLocalizations=YES;CFBundleExecutable=$(MSBuildProjectName);UIDeviceFamily=iPhone & iPad;CFBundleResourceSpecification=ResourceRules.plist;NSLocationWhenInUseUsageDescription=The reason for accessing the location information of the user;NSLocationAlwaysUsageDescription=The reason for accessing the location information of the user;FMLocalNotificationPermission=false;UIBackgroundModes=;NSContactsUsageDescription=The reason for accessing the contacts;NSPhotoLibraryUsageDescription=The reason for accessing the photo library;NSCameraUsageDescription=The reason for accessing the camera;CFBundleShortVersionString=1.0.0 + CFBundleName=$(MSBuildProjectName);CFBundleDevelopmentRegion=en;CFBundleDisplayName=$(MSBuildProjectName);CFBundleIdentifier=$(MSBuildProjectName);CFBundleInfoDictionaryVersion=6.0;CFBundleVersion=1.0.0.0;CFBundlePackageType=APPL;CFBundleSignature=????;LSRequiresIPhoneOS=true;CFBundleAllowMixedLocalizations=YES;CFBundleExecutable=$(MSBuildProjectName);UIDeviceFamily=iPhone & iPad;CFBundleResourceSpecification=ResourceRules.plist;NSLocationWhenInUseUsageDescription=The reason for accessing the location information of the user;NSLocationAlwaysUsageDescription=The reason for accessing the location information of the user;FMLocalNotificationPermission=false;UIBackgroundModes=;NSContactsUsageDescription=The reason for accessing the contacts;NSPhotoLibraryUsageDescription=The reason for accessing the photo library;NSCameraUsageDescription=The reason for accessing the camera;CFBundleShortVersionString=1.0.0;NSPhotoLibraryAddUsageDescription=The reason for adding to the photo library;NSFaceIDUsageDescription=The reason for accessing the face id;NSLocationAlwaysAndWhenInUseUsageDescription=The reason for accessing the location information of the user;NSMicrophoneUsageDescription=The reason for accessing the microphone;NSSiriUsageDescription=The reason for accessing Siri Debug @@ -220,7 +221,7 @@ iPhoneAndiPad true - CFBundleName=$(MSBuildProjectName);CFBundleDevelopmentRegion=en;CFBundleDisplayName=$(MSBuildProjectName);CFBundleIdentifier=$(MSBuildProjectName);CFBundleInfoDictionaryVersion=6.0;CFBundleVersion=1.0.0.0;CFBundlePackageType=APPL;CFBundleSignature=????;LSRequiresIPhoneOS=true;CFBundleAllowMixedLocalizations=YES;CFBundleExecutable=$(MSBuildProjectName);UIDeviceFamily=iPhone & iPad;CFBundleResourceSpecification=ResourceRules.plist;NSLocationWhenInUseUsageDescription=The reason for accessing the location information of the user;NSLocationAlwaysUsageDescription=The reason for accessing the location information of the user;FMLocalNotificationPermission=false;UIBackgroundModes=;NSContactsUsageDescription=The reason for accessing the contacts;NSPhotoLibraryUsageDescription=The reason for accessing the photo library;NSCameraUsageDescription=The reason for accessing the camera;CFBundleShortVersionString=1.0.0 + CFBundleName=$(MSBuildProjectName);CFBundleDevelopmentRegion=en;CFBundleDisplayName=$(MSBuildProjectName);CFBundleIdentifier=$(MSBuildProjectName);CFBundleInfoDictionaryVersion=6.0;CFBundleVersion=1.0.0.0;CFBundlePackageType=APPL;CFBundleSignature=????;LSRequiresIPhoneOS=true;CFBundleAllowMixedLocalizations=YES;CFBundleExecutable=$(MSBuildProjectName);UIDeviceFamily=iPhone & iPad;CFBundleResourceSpecification=ResourceRules.plist;NSLocationWhenInUseUsageDescription=The reason for accessing the location information of the user;NSLocationAlwaysUsageDescription=The reason for accessing the location information of the user;FMLocalNotificationPermission=false;UIBackgroundModes=;NSContactsUsageDescription=The reason for accessing the contacts;NSPhotoLibraryUsageDescription=The reason for accessing the photo library;NSCameraUsageDescription=The reason for accessing the camera;CFBundleShortVersionString=1.0.0;NSPhotoLibraryAddUsageDescription=The reason for adding to the photo library;NSFaceIDUsageDescription=The reason for accessing the face id;NSLocationAlwaysAndWhenInUseUsageDescription=The reason for accessing the location information of the user;NSMicrophoneUsageDescription=The reason for accessing the microphone;NSSiriUsageDescription=The reason for accessing Siri true @@ -358,7 +359,6 @@ 1 - Contents\MacOS 0 @@ -368,6 +368,12 @@ 1 + + + res\xml + 1 + + library\lib\armeabi-v7a @@ -405,6 +411,12 @@ 1 + + + res\values-v21 + 1 + + res\drawable @@ -481,6 +493,10 @@ 1 .framework + + 1 + .framework + 0 @@ -490,6 +506,10 @@ 1 .dylib + + 1 + .dylib + 0 .dll;.bpl @@ -512,6 +532,10 @@ 1 .dylib + + 1 + .dylib + 0 .bpl @@ -533,6 +557,9 @@ 0 + + 0 + 0 @@ -643,6 +670,7 @@ 1 + @@ -650,6 +678,10 @@ Contents\Resources 1 + + Contents\Resources + 1 + @@ -671,6 +703,9 @@ 1 + + 1 + 0 @@ -710,6 +745,7 @@ + diff --git a/packages/Delphi/Delphi.groupproj b/packages/Delphi/LockBox3Delphi.groupproj similarity index 97% rename from packages/Delphi/Delphi.groupproj rename to packages/Delphi/LockBox3Delphi.groupproj index 0033be7..7750bf1 100644 --- a/packages/Delphi/Delphi.groupproj +++ b/packages/Delphi/LockBox3Delphi.groupproj @@ -1,60 +1,60 @@ - - - {CD35A969-3EE9-444D-8433-F317BE3BC706} - - - - - - - - - - - - - - Default.Personality.12 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + {CD35A969-3EE9-444D-8433-F317BE3BC706} + + + + + + + + + + + + + + Default.Personality.12 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/packages/Delphi/LockBox3FMXDD.dproj b/packages/Delphi/LockBox3FMXDD.dproj index 9fd2c36..36acbba 100644 --- a/packages/Delphi/LockBox3FMXDD.dproj +++ b/packages/Delphi/LockBox3FMXDD.dproj @@ -2,7 +2,7 @@ {11A75D7E-1ADD-4D9E-9D88-EEEFB3E87BA6} LockBox3FMXDD.dpk - 18.4 + 18.5 FMX True Release @@ -197,8 +197,14 @@ true - - + + + LockBox3FMXDD.bpl + true + + + + true @@ -207,14 +213,13 @@ true - + true - - - LockBox3FMXDD.bpl + + true @@ -223,12 +228,16 @@ true + + + true + + 1 - Contents\MacOS 0 @@ -238,6 +247,12 @@ 1 + + + res\xml + 1 + + library\lib\armeabi-v7a @@ -275,6 +290,12 @@ 1 + + + res\values-v21 + 1 + + res\drawable @@ -351,6 +372,10 @@ 1 .framework + + 1 + .framework + 0 @@ -360,6 +385,10 @@ 1 .dylib + + 1 + .dylib + 0 .dll;.bpl @@ -382,6 +411,10 @@ 1 .dylib + + 1 + .dylib + 0 .bpl @@ -403,6 +436,9 @@ 0 + + 0 + 0 @@ -513,6 +549,7 @@ 1 + @@ -520,6 +557,10 @@ Contents\Resources 1 + + Contents\Resources + 1 + @@ -541,6 +582,9 @@ 1 + + 1 + 0 @@ -580,6 +624,7 @@ + diff --git a/packages/Delphi/LockBox3VCLDD.dproj b/packages/Delphi/LockBox3VCLDD.dproj index 69340ba..51236e4 100644 --- a/packages/Delphi/LockBox3VCLDD.dproj +++ b/packages/Delphi/LockBox3VCLDD.dproj @@ -7,7 +7,7 @@ 1 Package VCL - 18.4 + 18.5 Win32 @@ -250,7 +250,6 @@ 1 - Contents\MacOS 0 @@ -260,6 +259,12 @@ 1 + + + res\xml + 1 + + library\lib\armeabi-v7a @@ -297,6 +302,12 @@ 1 + + + res\values-v21 + 1 + + res\drawable @@ -373,6 +384,10 @@ 1 .framework + + 1 + .framework + 0 @@ -382,6 +397,10 @@ 1 .dylib + + 1 + .dylib + 0 .dll;.bpl @@ -404,6 +423,10 @@ 1 .dylib + + 1 + .dylib + 0 .bpl @@ -425,6 +448,9 @@ 0 + + 0 + 0 @@ -535,6 +561,7 @@ 1 + @@ -542,6 +569,10 @@ Contents\Resources 1 + + Contents\Resources + 1 + @@ -563,6 +594,9 @@ 1 + + 1 + 0 @@ -602,6 +636,7 @@ +