├── .clang-format ├── .gitignore ├── CMakeLists.txt ├── README.md ├── azure-pipelines.yml ├── cmake └── ExternalAnalyzerSDK.cmake └── src ├── SWDAnalyzer.cpp ├── SWDAnalyzer.h ├── SWDAnalyzerResults.cpp ├── SWDAnalyzerResults.h ├── SWDAnalyzerSettings.cpp ├── SWDAnalyzerSettings.h ├── SWDSimulationDataGenerator.cpp ├── SWDSimulationDataGenerator.h ├── SWDTypes.cpp ├── SWDTypes.h ├── SWDUtils.cpp └── SWDUtils.h /.clang-format: -------------------------------------------------------------------------------- 1 | # Logic style 2 | Language: Cpp 3 | # manually added flags 4 | FixNamespaceComments: 'false' 5 | SortIncludes: 'false' 6 | 7 | 8 | # flags copied from web editor, https://zed0.co.uk/clang-format-configurator/ 9 | AllowShortBlocksOnASingleLine: 'false' 10 | AllowShortCaseLabelsOnASingleLine: 'false' 11 | AllowShortFunctionsOnASingleLine: None 12 | AllowShortIfStatementsOnASingleLine: 'false' 13 | AllowShortLoopsOnASingleLine: 'false' 14 | AlwaysBreakAfterReturnType: None 15 | AlwaysBreakTemplateDeclarations: 'true' 16 | BreakBeforeBraces: Allman 17 | ColumnLimit: '140' 18 | ConstructorInitializerAllOnOneLineOrOnePerLine: 'true' 19 | ContinuationIndentWidth: '4' 20 | Cpp11BracedListStyle: 'false' 21 | IndentWidth: '4' 22 | KeepEmptyLinesAtTheStartOfBlocks: 'false' 23 | MaxEmptyLinesToKeep: '2' 24 | NamespaceIndentation: All 25 | PointerAlignment: Left 26 | SpaceBeforeParens: Never 27 | SpaceInEmptyParentheses: 'false' 28 | SpacesInCStyleCastParentheses: 'true' 29 | SpacesInParentheses: 'true' 30 | SpacesInSquareBrackets: 'true' 31 | TabWidth: '4' 32 | UseTab: Never 33 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | /build -------------------------------------------------------------------------------- /CMakeLists.txt: -------------------------------------------------------------------------------- 1 | cmake_minimum_required (VERSION 3.11) 2 | project(swd_analyzer) 3 | 4 | 5 | 6 | # enable generation of compile_commands.json, helpful for IDEs to locate include files. 7 | set(CMAKE_EXPORT_COMPILE_COMMANDS ON) 8 | 9 | # custom CMake Modules are located in the cmake directory. 10 | set(CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/cmake) 11 | 12 | include(ExternalAnalyzerSDK) 13 | 14 | set(SOURCES 15 | src/SWDAnalyzer.cpp 16 | src/SWDAnalyzer.h 17 | src/SWDAnalyzerResults.cpp 18 | src/SWDAnalyzerResults.h 19 | src/SWDAnalyzerSettings.cpp 20 | src/SWDAnalyzerSettings.h 21 | src/SWDSimulationDataGenerator.cpp 22 | src/SWDSimulationDataGenerator.h 23 | src/SWDTypes.cpp 24 | src/SWDTypes.h 25 | src/SWDUtils.cpp 26 | src/SWDUtils.h 27 | ) 28 | 29 | add_analyzer_plugin(swd_analyzer SOURCES ${SOURCES}) 30 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Saleae ARM Serial Wire Debug (SWD) Analyzer 2 | 3 | Saleae ARM Serial Wire Debug (SWD) Analyzer 4 | 5 | ## Getting Started 6 | 7 | ### MacOS 8 | 9 | Dependencies: 10 | - XCode with command line tools 11 | - CMake 3.11+ 12 | 13 | Installing command line tools after XCode is installed: 14 | ``` 15 | xcode-select --install 16 | ``` 17 | 18 | Then open XCode, open Preferences from the main menu, go to locations, and select the only option under 'Command line tools'. 19 | 20 | Installing CMake on MacOS: 21 | 22 | 1. Download the binary distribution for MacOS, `cmake-*-Darwin-x86_64.dmg` 23 | 2. Install the usual way by dragging into applications. 24 | 3. Open a terminal and run the following: 25 | ``` 26 | /Applications/CMake.app/Contents/bin/cmake-gui --install 27 | ``` 28 | *Note: Errors may occur if older versions of CMake are installed.* 29 | 30 | Building the analyzer: 31 | ``` 32 | mkdir build 33 | cd build 34 | cmake .. 35 | cmake --build . 36 | ``` 37 | 38 | ### Ubuntu 16.04 39 | 40 | Dependencies: 41 | - CMake 3.11+ 42 | - gcc 4.8+ 43 | 44 | Misc dependencies: 45 | 46 | ``` 47 | sudo apt-get install build-essential 48 | ``` 49 | 50 | Building the analyzer: 51 | ``` 52 | mkdir build 53 | cd build 54 | cmake .. 55 | cmake --build . 56 | ``` 57 | 58 | ### Windows 59 | 60 | Dependencies: 61 | - Visual Studio 2015 Update 3 62 | - CMake 3.11+ 63 | 64 | **Visual Studio 2015** 65 | 66 | *Note - newer versions of Visual Studio should be fine.* 67 | 68 | Setup options: 69 | - Programming Languages > Visual C++ > select all sub-components. 70 | 71 | Note - if CMake has any problems with the MSVC compiler, it's likely a component is missing. 72 | 73 | **CMake** 74 | 75 | Download and install the latest CMake release here. 76 | https://cmake.org/download/ 77 | 78 | Building the analyzer: 79 | ``` 80 | mkdir build 81 | cd build 82 | cmake .. 83 | ``` 84 | 85 | Then, open the newly created solution file located here: `build\swd_analyzer.sln` 86 | -------------------------------------------------------------------------------- /azure-pipelines.yml: -------------------------------------------------------------------------------- 1 | # Configuration for automated CI building using Microsoft Azure Pipelines. 2 | # https://azure.microsoft.com/en-us/services/devops/pipelines/ 3 | # This will build this analyzer for all 3 target platforms. 4 | # It will create github releases for tagged commits. 5 | 6 | # In order to publish releases to github, you must add a new GitHub service connection in your project settings, under Pipelines -> Service Connections. 7 | # https://docs.microsoft.com/en-us/azure/devops/pipelines/library/service-endpoints?view=azure-devops&tabs=yaml#sep-github 8 | # if you don't setup a github connection, but intend to use azure CI, then you will need to delete the GithubRelease@0 task at the bottom of this file. 9 | # store the name of your service connection in GITHUB_CONNECTION. 10 | variables: 11 | GITHUB_CONNECTION: 'github.com_Marcus10110' 12 | 13 | # trigger: always build commits to master, all commits to open pull requests, and all tags. 14 | trigger: 15 | branches: 16 | include: 17 | - 'master' 18 | tags: 19 | include: 20 | - '*' 21 | pr: 22 | - '*' 23 | 24 | # build for MacOS, Linux, and Windows. 25 | jobs: 26 | - job: build 27 | pool: 28 | vmImage: $(imageName) 29 | strategy: 30 | matrix: 31 | windows: 32 | imageName: 'vs2017-win2016' 33 | CMAKE_ARGS: '-G "Visual Studio 15 Win64"' 34 | BUILD_ARGS: '--config RelWithDebInfo' 35 | linux: 36 | imageName: 'ubuntu-16.04' 37 | CMAKE_ARGS: '-DCMAKE_BUILD_TYPE=RelWithDebInfo' 38 | BUILD_ARGS: '' 39 | mac: 40 | imageName: 'macOS-10.15' 41 | CMAKE_ARGS: '-DCMAKE_BUILD_TYPE=RelWithDebInfo' 42 | BUILD_ARGS: '' 43 | displayName: 'Build and deploy graph-io' 44 | 45 | steps: 46 | - script: | 47 | mkdir build 48 | cd build 49 | cmake $(CMAKE_ARGS) .. 50 | cmake --build . $(BUILD_ARGS) 51 | displayName: 'Build' 52 | 53 | - script: | 54 | cd build 55 | install_name_tool -change @executable_path/libAnalyzer.dylib @rpath/libAnalyzer.dylib Analyzers/*.so 56 | displayName: 'MacOS: fix install name' 57 | condition: eq( variables['Agent.OS'], 'Darwin' ) 58 | 59 | # this publishes to azure pipelines, so that other CI agents can load these files, later in the pipeline 60 | - publish: $(System.DefaultWorkingDirectory)/build/Analyzers/RelWithDebInfo 61 | artifact: AnalyzerLibWin 62 | condition: eq( variables['Agent.OS'], 'Windows_NT' ) 63 | displayName: 'Windows: Publish' 64 | - publish: $(System.DefaultWorkingDirectory)/build/Analyzers 65 | artifact: AnalyzerLibMac 66 | condition: eq( variables['Agent.OS'], 'Darwin' ) 67 | displayName: 'MacOS: Publish' 68 | - publish: $(System.DefaultWorkingDirectory)/build/Analyzers 69 | artifact: AnalyzerLibLinux 70 | condition: eq( variables['Agent.OS'], 'Linux' ) 71 | displayName: 'Linux: Publish' 72 | 73 | # This job downloads the analyzer library compiled from the three different platforms, and preps it for publishing. 74 | - job: deploy 75 | dependsOn: 76 | - build 77 | displayName: 'deploy' 78 | pool: 79 | vmImage: 'ubuntu-16.04' 80 | steps: 81 | - download: current 82 | artifact: AnalyzerLibLinux 83 | - download: current 84 | artifact: AnalyzerLibWin 85 | patterns: | 86 | *.dll 87 | *.pdb 88 | - download: current 89 | artifact: AnalyzerLibMac 90 | - script: | 91 | export REPO_NAME=$(echo $(Build.Repository.Name) | sed 's|.*/||') 92 | echo $REPO_NAME 93 | pushd $(Build.ArtifactStagingDirectory) 94 | mkdir win osx linux 95 | popd 96 | cp $(Pipeline.Workspace)/AnalyzerLibWin/* $(Build.ArtifactStagingDirectory)/win 97 | cp $(Pipeline.Workspace)/AnalyzerLibMac/* $(Build.ArtifactStagingDirectory)/osx 98 | cp $(Pipeline.Workspace)/AnalyzerLibLinux/* $(Build.ArtifactStagingDirectory)/linux 99 | cd $(Build.ArtifactStagingDirectory) 100 | zip -r ${REPO_NAME}-bin.zip . 101 | unzip -l ${REPO_NAME}-bin.zip 102 | # This creates (or replaces) a github release for tagged commits only. The release name will be the tag name. 103 | # Note, if you do not want to setup a github service connection, but want to use CI, you will need to delete this task. 104 | - task: GithubRelease@0 105 | displayName: 'Create GitHub Release' 106 | inputs: 107 | gitHubConnection: $(GITHUB_CONNECTION) 108 | repositoryName: $(Build.Repository.Name) 109 | assets: $(Build.ArtifactStagingDirectory)/*.zip -------------------------------------------------------------------------------- /cmake/ExternalAnalyzerSDK.cmake: -------------------------------------------------------------------------------- 1 | include(FetchContent) 2 | 3 | # Use the C++11 standard 4 | set(CMAKE_CXX_STANDARD 11) 5 | 6 | set(CMAKE_CXX_STANDARD_REQUIRED YES) 7 | 8 | if (NOT CMAKE_RUNTIME_OUTPUT_DIRECTORY OR NOT CMAKE_LIBRARY_OUTPUT_DIRECTORY) 9 | set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/bin/) 10 | set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/bin/) 11 | endif() 12 | 13 | # Fetch the Analyzer SDK if the target does not already exist. 14 | if(NOT TARGET Saleae::AnalyzerSDK) 15 | FetchContent_Declare( 16 | analyzersdk 17 | GIT_REPOSITORY https://github.com/saleae/AnalyzerSDK.git 18 | GIT_TAG master 19 | GIT_SHALLOW True 20 | GIT_PROGRESS True 21 | ) 22 | 23 | FetchContent_GetProperties(analyzersdk) 24 | 25 | if(NOT analyzersdk_POPULATED) 26 | FetchContent_Populate(analyzersdk) 27 | include(${analyzersdk_SOURCE_DIR}/AnalyzerSDKConfig.cmake) 28 | 29 | if(APPLE OR WIN32) 30 | get_target_property(analyzersdk_lib_location Saleae::AnalyzerSDK IMPORTED_LOCATION) 31 | if(CMAKE_LIBRARY_OUTPUT_DIRECTORY) 32 | file(COPY ${analyzersdk_lib_location} DESTINATION ${CMAKE_LIBRARY_OUTPUT_DIRECTORY}) 33 | else() 34 | message(WARNING "Please define CMAKE_RUNTIME_OUTPUT_DIRECTORY and CMAKE_LIBRARY_OUTPUT_DIRECTORY if you want unit tests to locate ${analyzersdk_lib_location}") 35 | endif() 36 | endif() 37 | 38 | endif() 39 | endif() 40 | 41 | function(add_analyzer_plugin TARGET) 42 | set(options ) 43 | set(single_value_args ) 44 | set(multi_value_args SOURCES) 45 | cmake_parse_arguments( _p "${options}" "${single_value_args}" "${multi_value_args}" ${ARGN} ) 46 | 47 | 48 | add_library(${TARGET} MODULE ${_p_SOURCES}) 49 | target_link_libraries(${TARGET} PRIVATE Saleae::AnalyzerSDK) 50 | 51 | set(ANALYZER_DESTINATION "Analyzers") 52 | install(TARGETS ${TARGET} RUNTIME DESTINATION ${ANALYZER_DESTINATION} 53 | LIBRARY DESTINATION ${ANALYZER_DESTINATION}) 54 | 55 | set_target_properties(${TARGET} PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/${ANALYZER_DESTINATION} 56 | LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/${ANALYZER_DESTINATION}) 57 | endfunction() -------------------------------------------------------------------------------- /src/SWDAnalyzer.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | #include 5 | 6 | #include "SWDAnalyzer.h" 7 | #include "SWDAnalyzerSettings.h" 8 | #include "SWDUtils.h" 9 | 10 | SWDAnalyzer::SWDAnalyzer() : mSimulationInitilized( false ) 11 | { 12 | SetAnalyzerSettings( &mSettings ); 13 | } 14 | 15 | SWDAnalyzer::~SWDAnalyzer() 16 | { 17 | KillThread(); 18 | } 19 | 20 | void SWDAnalyzer::SetupResults() 21 | { 22 | // reset the results 23 | mResults.reset( new SWDAnalyzerResults( this, &mSettings ) ); 24 | SetAnalyzerResults( mResults.get() ); 25 | 26 | // set which channels will carry bubbles 27 | mResults->AddChannelBubblesWillAppearOn( mSettings.mSWDIO ); 28 | mResults->AddChannelBubblesWillAppearOn( mSettings.mSWCLK ); 29 | } 30 | 31 | void SWDAnalyzer::WorkerThread() 32 | { 33 | // SetupResults(); 34 | // get the channel pointers 35 | mSWDIO = GetAnalyzerChannelData( mSettings.mSWDIO ); 36 | mSWCLK = GetAnalyzerChannelData( mSettings.mSWCLK ); 37 | 38 | mSWDParser.Setup( mSWDIO, mSWCLK, this ); 39 | 40 | // these are our three objects that SWDParser will fill with data 41 | // on calls to IsOperation or IsLineReset 42 | SWDOperation tran; 43 | SWDLineReset reset; 44 | SWDJtagToSwd jtagToSwd; 45 | SWDBit error_bit; 46 | 47 | mSWDParser.Clear(); 48 | 49 | // For every new bit the parser extracts from the stream, 50 | // ask if this can be a valid operation or line reset. 51 | // A valid operation will have the constant part of the request correctly set, 52 | // and also the parity bits will be correct. 53 | // A valid line reset has at least 50 high bits in succession. 54 | for( ;; ) 55 | { 56 | if( mSWDParser.IsOperation( tran ) ) 57 | { 58 | tran.AddFrames( mResults.get() ); 59 | tran.AddMarkers( mResults.get() ); 60 | 61 | mResults->CommitResults(); 62 | } 63 | else if( mSWDParser.IsLineReset( reset ) ) 64 | { 65 | reset.AddFrames( mResults.get() ); 66 | 67 | mResults->CommitResults(); 68 | } 69 | else if( mSWDParser.IsJtagToSwd( jtagToSwd ) ) 70 | { 71 | jtagToSwd.AddFrames( mResults.get() ); 72 | mResults->CommitResults(); 73 | } 74 | else 75 | { 76 | // This is neither a valid transaction nor a valid reset, 77 | // so remove the first bit and try again. 78 | // We're dropping the error bit into oblivion. 79 | error_bit = mSWDParser.PopFrontBit(); 80 | } 81 | 82 | ReportProgress( mSWDIO->GetSampleNumber() ); 83 | } 84 | } 85 | 86 | bool SWDAnalyzer::NeedsRerun() 87 | { 88 | return false; 89 | } 90 | 91 | U32 SWDAnalyzer::GenerateSimulationData( U64 minimum_sample_index, U32 device_sample_rate, 92 | SimulationChannelDescriptor** simulation_channels ) 93 | { 94 | if( !mSimulationInitilized ) 95 | { 96 | mSimulationDataGenerator.Initialize( GetSimulationSampleRate(), &mSettings ); 97 | mSimulationInitilized = true; 98 | } 99 | 100 | return mSimulationDataGenerator.GenerateSimulationData( minimum_sample_index, device_sample_rate, simulation_channels ); 101 | } 102 | 103 | U32 SWDAnalyzer::GetMinimumSampleRateHz() 104 | { 105 | // this 1MHz limit is a little arbitrary, since the specs don't say much about the 106 | // valid frequency range a SWD stream should be in. 107 | return 1000000; 108 | } 109 | 110 | const char* SWDAnalyzer::GetAnalyzerName() const 111 | { 112 | return ::GetAnalyzerName(); 113 | } 114 | 115 | const char* GetAnalyzerName() 116 | { 117 | return "SWD"; 118 | } 119 | 120 | Analyzer* CreateAnalyzer() 121 | { 122 | return new SWDAnalyzer(); 123 | } 124 | 125 | void DestroyAnalyzer( Analyzer* analyzer ) 126 | { 127 | delete analyzer; 128 | } 129 | -------------------------------------------------------------------------------- /src/SWDAnalyzer.h: -------------------------------------------------------------------------------- 1 | #ifndef SWD_ANALYZER_H 2 | #define SWD_ANALYZER_H 3 | 4 | #include 5 | 6 | #include "SWDAnalyzerSettings.h" 7 | #include "SWDAnalyzerResults.h" 8 | #include "SWDSimulationDataGenerator.h" 9 | 10 | #include "SWDTypes.h" 11 | 12 | class SWDAnalyzer : public Analyzer2 13 | { 14 | public: 15 | SWDAnalyzer(); 16 | virtual ~SWDAnalyzer(); 17 | virtual void SetupResults(); 18 | virtual void WorkerThread(); 19 | 20 | virtual U32 GenerateSimulationData( U64 newest_sample_requested, U32 sample_rate, SimulationChannelDescriptor** simulation_channels ); 21 | virtual U32 GetMinimumSampleRateHz(); 22 | 23 | virtual const char* GetAnalyzerName() const; 24 | virtual bool NeedsRerun(); 25 | 26 | protected: // vars 27 | SWDAnalyzerSettings mSettings; 28 | std::auto_ptr mResults; 29 | 30 | AnalyzerChannelData* mSWDIO; 31 | AnalyzerChannelData* mSWCLK; 32 | 33 | SWDSimulationDataGenerator mSimulationDataGenerator; 34 | 35 | SWDParser mSWDParser; 36 | 37 | bool mSimulationInitilized; 38 | }; 39 | 40 | extern "C" ANALYZER_EXPORT const char* __cdecl GetAnalyzerName(); 41 | extern "C" ANALYZER_EXPORT Analyzer* __cdecl CreateAnalyzer(); 42 | extern "C" ANALYZER_EXPORT void __cdecl DestroyAnalyzer( Analyzer* analyzer ); 43 | 44 | #endif // SWD_ANALYZER_H -------------------------------------------------------------------------------- /src/SWDAnalyzerResults.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | #include 6 | 7 | #include "SWDAnalyzerResults.h" 8 | #include "SWDAnalyzer.h" 9 | #include "SWDAnalyzerSettings.h" 10 | #include "SWDUtils.h" 11 | 12 | SWDAnalyzerResults::SWDAnalyzerResults( SWDAnalyzer* analyzer, SWDAnalyzerSettings* settings ) 13 | : mSettings( settings ), mAnalyzer( analyzer ) 14 | { 15 | } 16 | 17 | SWDAnalyzerResults::~SWDAnalyzerResults() 18 | { 19 | } 20 | 21 | double SWDAnalyzerResults::GetSampleTime( S64 sample ) const 22 | { 23 | return ( sample - mAnalyzer->GetTriggerSample() ) / double( mAnalyzer->GetSampleRate() ); 24 | } 25 | 26 | std::string SWDAnalyzerResults::GetSampleTimeStr( S64 sample ) const 27 | { 28 | char time_str[ 128 ]; 29 | AnalyzerHelpers::GetTimeString( sample, mAnalyzer->GetTriggerSample(), mAnalyzer->GetSampleRate(), time_str, sizeof( time_str ) ); 30 | 31 | // remove trailing zeros 32 | int l = strlen( time_str ); 33 | if( l > 7 ) 34 | time_str[ l - 7 ] = '\0'; 35 | 36 | return time_str; 37 | } 38 | 39 | void SWDAnalyzerResults::GetBubbleText( const Frame& f, DisplayBase display_base, std::vector& results ) 40 | { 41 | results.clear(); 42 | 43 | std::string result; 44 | 45 | if( f.mType == SWDFT_Request ) 46 | { 47 | SWDRequestFrame& req( ( SWDRequestFrame& )f ); 48 | 49 | std::string addr_str( int2str_sal( req.GetAddr(), display_base, 4 ) ); 50 | std::string reg_hex( int2str_sal( req.mData1, display_base, 4 ) ); 51 | std::string reg_name( req.GetRegisterName() ); 52 | 53 | results.push_back( std::string( "Request " ) + ( req.IsAccessPort() ? " AccessPort" : " DebugPort" ) + 54 | ( req.IsRead() ? " Read" : " Write" ) + " " + reg_name + " (" + reg_hex + ")" ); 55 | 56 | results.push_back( int2str_sal( req.mData2, display_base ) ); 57 | results.push_back( "rq" ); 58 | results.push_back( "req" ); 59 | results.push_back( "request" ); 60 | results.push_back( std::string( "request " ) + ( req.IsAccessPort() ? "AP" : "DP" ) + ( req.IsRead() ? " R" : " W" ) + " " + 61 | reg_name ); 62 | 63 | results.push_back( std::string( "Request " ) + ( req.IsAccessPort() ? "AccessPort" : "DebugPort" ) + 64 | ( req.IsRead() ? " Read" : " Write" ) + " " + reg_name ); 65 | } 66 | else if( f.mType == SWDFT_LineReset ) 67 | { 68 | results.push_back( "Line Reset " + int2str( f.mData1 ) + " bits" ); 69 | results.push_back( "rst" ); 70 | results.push_back( "reset" ); 71 | results.push_back( "Line Reset" ); 72 | } 73 | else if ( f.mType == SWDFT_JtagToSwd ) 74 | { 75 | results.push_back( "JTAG to SWD sequence" ); 76 | results.push_back( "JtS" ); 77 | results.push_back( "JTAGtoSWD" ); 78 | results.push_back( "JTAG to SWD" ); 79 | } 80 | else if( f.mType == SWDFT_Turnaround ) 81 | { 82 | results.push_back( "Turnaround" ); 83 | results.push_back( "T" ); 84 | results.push_back( "trn" ); 85 | results.push_back( "turn" ); 86 | } 87 | else if( f.mType == SWDFT_ACK ) 88 | { 89 | if( f.mData1 == ACK_OK ) 90 | { 91 | results.push_back( "ACK OK" ); 92 | results.push_back( "OK" ); 93 | } 94 | else if( f.mData1 == ACK_WAIT ) 95 | { 96 | results.push_back( "ACK WAIT" ); 97 | results.push_back( "WAIT" ); 98 | } 99 | else if( f.mData1 == ACK_FAULT ) 100 | { 101 | results.push_back( "ACK FAULT" ); 102 | results.push_back( "FAULT" ); 103 | } 104 | else 105 | { 106 | results.push_back( "ACK probably disconnected" ); 107 | results.push_back( "ACK " ); 108 | results.push_back( "disc" ); 109 | } 110 | 111 | results.push_back( "ACK" ); 112 | } 113 | else if( ( f.mType == SWDFT_WData ) || ( f.mType == SWDFT_RData ) ) 114 | { 115 | std::string data_str( int2str_sal( f.mData1, display_base, 32 ) ); 116 | SWDRegisters reg( SWDRegisters( f.mData2 ) ); 117 | std::string reg_name( GetRegisterName( reg ) ); 118 | std::string reg_value( GetRegisterValueDesc( reg, U32( f.mData1 ), display_base ) ); 119 | std::string prefix = ( f.mType == SWDFT_WData ) ? "WData" : "RData"; 120 | if( !reg_value.empty() ) 121 | results.push_back( prefix + " " + data_str + " reg " + reg_name + " bits " + reg_value ); 122 | results.push_back( prefix + " " + data_str + " reg " + reg_name ); 123 | results.push_back( prefix ); 124 | results.push_back( prefix + " " + data_str ); 125 | } 126 | else if( f.mType == SWDFT_DataParity ) 127 | { 128 | results.push_back( std::string( "Data parity" ) + ( f.mData2 ? "ok" : "NOT OK" ) ); 129 | results.push_back( f.mData1 ? "1" : "0" ); 130 | results.push_back( "prty" ); 131 | results.push_back( "Parity" ); 132 | } 133 | else if( f.mType == SWDFT_TrailingBits ) 134 | { 135 | results.push_back( "Trailing bits" ); 136 | results.push_back( "Trail" ); 137 | } 138 | else 139 | { 140 | std::string msg; 141 | 142 | switch( f.mType ) 143 | { 144 | case SWDFT_Bit: 145 | msg = "bit " + int2str( f.mData2 ); 146 | break; 147 | case SWDFT_WData: 148 | msg = "data"; 149 | break; 150 | case SWDFT_DataParity: 151 | msg = "dprty"; 152 | break; 153 | case SWDFT_Error: 154 | msg = "err"; 155 | break; 156 | case SWDFT_Request: 157 | msg = "request"; 158 | break; 159 | } 160 | 161 | results.push_back( msg ); 162 | } 163 | } 164 | 165 | void SWDAnalyzerResults::GenerateBubbleText( U64 frame_index, Channel& channel, DisplayBase display_base ) 166 | { 167 | ClearResultStrings(); 168 | Frame f = GetFrame( frame_index ); 169 | 170 | std::vector results; 171 | GetBubbleText( f, display_base, results ); 172 | 173 | for( std::vector::iterator ri( results.begin() ); ri != results.end(); ++ri ) 174 | AddResultString( ri->c_str() ); 175 | } 176 | 177 | #define EXP_RECORD_FIELDS 9 178 | 179 | void SaveRecord( std::vector& rec, std::ofstream& of ) 180 | { 181 | if( rec.empty() ) 182 | return; 183 | 184 | while( rec.size() < EXP_RECORD_FIELDS ) 185 | rec.push_back( "" ); 186 | 187 | for( std::vector::iterator ri( rec.begin() ); ri != rec.end(); ++ri ) 188 | { 189 | if( ri != rec.begin() ) 190 | of << "\t"; 191 | 192 | of << *ri; 193 | } 194 | 195 | of << std::endl; 196 | 197 | rec.clear(); 198 | } 199 | 200 | void SWDAnalyzerResults::GenerateExportFile( const char* file, DisplayBase display_base, U32 export_type_user_id ) 201 | { 202 | std::ofstream of( file, std::ios::out ); 203 | 204 | U64 trigger_sample = mAnalyzer->GetTriggerSample(); 205 | U32 sample_rate = mAnalyzer->GetSampleRate(); 206 | 207 | of << "Time\tType\tR/W\tAP/DP\tRegister\tRequest byte\tACK\tWData\tWData details" << std::endl; 208 | 209 | Frame f; 210 | const U64 num_frames = GetNumFrames(); 211 | std::vector record; 212 | for( U64 fcnt = 0; fcnt < num_frames; fcnt++ ) 213 | { 214 | // get the frame 215 | f = GetFrame( fcnt ); 216 | 217 | if( f.mType == SWDFT_LineReset ) 218 | { 219 | SaveRecord( record, of ); 220 | 221 | record.push_back( GetSampleTimeStr( f.mStartingSampleInclusive ) ); 222 | record.push_back( "Line reset" ); 223 | SaveRecord( record, of ); 224 | } 225 | else if( f.mType == SWDFT_JtagToSwd) 226 | { 227 | SaveRecord( record, of ); 228 | record.push_back( GetSampleTimeStr( f.mStartingSampleInclusive ) ); 229 | record.push_back( "JTAG to SWD Sequence" ); 230 | SaveRecord( record, of ); 231 | } 232 | else if( f.mType == SWDFT_Request ) 233 | { 234 | SaveRecord( record, of ); 235 | 236 | SWDRequestFrame& req( ( SWDRequestFrame& )f ); 237 | record.push_back( GetSampleTimeStr( f.mStartingSampleInclusive ) ); 238 | record.push_back( "Operation" ); 239 | record.push_back( req.IsRead() ? "read" : "write" ); 240 | record.push_back( req.IsAccessPort() ? "AccessPort" : "DebugPort" ); 241 | record.push_back( req.GetRegisterName() ); 242 | record.push_back( int2str_sal( req.mData1, display_base, 8 ) ); 243 | } 244 | else if( f.mType == SWDFT_ACK ) 245 | { 246 | if( f.mData1 == ACK_OK ) 247 | record.push_back( "OK" ); 248 | else if( f.mData1 == ACK_WAIT ) 249 | record.push_back( "WAIT" ); 250 | else if( f.mData1 == ACK_FAULT ) 251 | record.push_back( "FAULT" ); 252 | else 253 | record.push_back( "" ); 254 | } 255 | else if( (f.mType == SWDFT_WData) || (f.mType == SWDFT_RData) ) 256 | { 257 | record.push_back( int2str_sal( f.mData1, display_base, 32 ) ); 258 | 259 | SWDRegisters reg( SWDRegisters( f.mData2 ) ); 260 | record.push_back( GetRegisterValueDesc( reg, U32( f.mData1 ), display_base ) ); 261 | 262 | SaveRecord( record, of ); 263 | } 264 | 265 | if( UpdateExportProgressAndCheckForCancel( fcnt, num_frames ) ) 266 | return; 267 | } 268 | 269 | UpdateExportProgressAndCheckForCancel( num_frames, num_frames ); 270 | } 271 | 272 | void SWDAnalyzerResults::GenerateFrameTabularText( U64 frame_index, DisplayBase display_base ) 273 | { 274 | ClearTabularText(); 275 | 276 | std::vector results; 277 | Frame f = GetFrame( frame_index ); 278 | GetBubbleText( f, display_base, results ); 279 | 280 | if( !results.empty() ) 281 | AddTabularText( results.front().c_str() ); 282 | } 283 | 284 | void SWDAnalyzerResults::GeneratePacketTabularText( U64 packet_id, DisplayBase display_base ) 285 | { 286 | ClearResultStrings(); 287 | AddResultString( "not supported" ); 288 | } 289 | 290 | void SWDAnalyzerResults::GenerateTransactionTabularText( U64 transaction_id, DisplayBase display_base ) 291 | { 292 | ClearResultStrings(); 293 | AddResultString( "not supported" ); 294 | } 295 | -------------------------------------------------------------------------------- /src/SWDAnalyzerResults.h: -------------------------------------------------------------------------------- 1 | #ifndef SWD_ANALYZER_RESULTS_H 2 | #define SWD_ANALYZER_RESULTS_H 3 | 4 | #include 5 | 6 | class SWDAnalyzer; 7 | class SWDAnalyzerSettings; 8 | 9 | class SWDAnalyzerResults : public AnalyzerResults 10 | { 11 | public: 12 | SWDAnalyzerResults( SWDAnalyzer* analyzer, SWDAnalyzerSettings* settings ); 13 | virtual ~SWDAnalyzerResults(); 14 | 15 | virtual void GenerateBubbleText( U64 frame_index, Channel& channel, DisplayBase display_base ); 16 | virtual void GenerateExportFile( const char* file, DisplayBase display_base, U32 export_type_user_id ); 17 | 18 | virtual void GenerateFrameTabularText( U64 frame_index, DisplayBase display_base ); 19 | virtual void GeneratePacketTabularText( U64 packet_id, DisplayBase display_base ); 20 | virtual void GenerateTransactionTabularText( U64 transaction_id, DisplayBase display_base ); 21 | 22 | double GetSampleTime( S64 sample ) const; 23 | std::string GetSampleTimeStr( S64 sample ) const; 24 | 25 | SWDAnalyzerSettings* GetSettings() 26 | { 27 | return mSettings; 28 | } 29 | 30 | protected: // functions 31 | void GetBubbleText( const Frame& f, DisplayBase display_base, std::vector& results ); 32 | 33 | protected: // vars 34 | SWDAnalyzerSettings* mSettings; 35 | SWDAnalyzer* mAnalyzer; 36 | }; 37 | 38 | #endif // SWD_ANALYZER_RESULTS_H -------------------------------------------------------------------------------- /src/SWDAnalyzerSettings.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #include "SWDAnalyzerSettings.h" 4 | #include "SWDAnalyzerResults.h" 5 | #include "SWDTypes.h" 6 | 7 | SWDAnalyzerSettings::SWDAnalyzerSettings() : mSWDIO( UNDEFINED_CHANNEL ), mSWCLK( UNDEFINED_CHANNEL ) 8 | { 9 | // init the interface 10 | mSWDIOInterface.SetTitleAndTooltip( "SWDIO", "SWDIO" ); 11 | mSWDIOInterface.SetChannel( mSWDIO ); 12 | 13 | mSWCLKInterface.SetTitleAndTooltip( "SWCLK", "SWCLK" ); 14 | mSWCLKInterface.SetChannel( mSWCLK ); 15 | 16 | // add the interface 17 | AddInterface( &mSWDIOInterface ); 18 | AddInterface( &mSWCLKInterface ); 19 | 20 | // describe export 21 | AddExportOption( 0, "Export as text file" ); 22 | AddExportExtension( 0, "text", "txt" ); 23 | 24 | ClearChannels(); 25 | 26 | AddChannel( mSWDIO, "SWDIO", false ); 27 | AddChannel( mSWCLK, "SWCLK", false ); 28 | } 29 | 30 | SWDAnalyzerSettings::~SWDAnalyzerSettings() 31 | { 32 | } 33 | 34 | bool SWDAnalyzerSettings::SetSettingsFromInterfaces() 35 | { 36 | if( mSWDIOInterface.GetChannel() == UNDEFINED_CHANNEL ) 37 | { 38 | SetErrorText( "Please select an input for the channel 1." ); 39 | return false; 40 | } 41 | 42 | if( mSWCLKInterface.GetChannel() == UNDEFINED_CHANNEL ) 43 | { 44 | SetErrorText( "Please select an input for the channel 2." ); 45 | return false; 46 | } 47 | 48 | mSWDIO = mSWDIOInterface.GetChannel(); 49 | mSWCLK = mSWCLKInterface.GetChannel(); 50 | 51 | if( mSWDIO == mSWCLK ) 52 | { 53 | SetErrorText( "Please select different inputs for the channels." ); 54 | return false; 55 | } 56 | 57 | ClearChannels(); 58 | 59 | AddChannel( mSWDIO, "SWDIO", true ); 60 | AddChannel( mSWCLK, "SWCLK", true ); 61 | 62 | return true; 63 | } 64 | 65 | void SWDAnalyzerSettings::UpdateInterfacesFromSettings() 66 | { 67 | mSWDIOInterface.SetChannel( mSWDIO ); 68 | mSWCLKInterface.SetChannel( mSWCLK ); 69 | } 70 | 71 | void SWDAnalyzerSettings::LoadSettings( const char* settings ) 72 | { 73 | SimpleArchive text_archive; 74 | text_archive.SetString( settings ); 75 | 76 | text_archive >> mSWDIO; 77 | text_archive >> mSWCLK; 78 | 79 | ClearChannels(); 80 | 81 | AddChannel( mSWDIO, "SWDIO", true ); 82 | AddChannel( mSWCLK, "SWCLK", true ); 83 | 84 | UpdateInterfacesFromSettings(); 85 | } 86 | 87 | const char* SWDAnalyzerSettings::SaveSettings() 88 | { 89 | SimpleArchive text_archive; 90 | 91 | text_archive << mSWDIO; 92 | text_archive << mSWCLK; 93 | 94 | return SetReturnString( text_archive.GetString() ); 95 | } 96 | -------------------------------------------------------------------------------- /src/SWDAnalyzerSettings.h: -------------------------------------------------------------------------------- 1 | #ifndef SWD_ANALYZER_SETTINGS_H 2 | #define SWD_ANALYZER_SETTINGS_H 3 | 4 | #include 5 | #include 6 | 7 | #include "SWDTypes.h" 8 | 9 | class SWDAnalyzerSettings : public AnalyzerSettings 10 | { 11 | public: 12 | SWDAnalyzerSettings(); 13 | virtual ~SWDAnalyzerSettings(); 14 | 15 | virtual bool SetSettingsFromInterfaces(); 16 | virtual void LoadSettings( const char* settings ); 17 | virtual const char* SaveSettings(); 18 | 19 | void UpdateInterfacesFromSettings(); 20 | 21 | Channel mSWDIO; 22 | Channel mSWCLK; 23 | 24 | protected: 25 | AnalyzerSettingInterfaceChannel mSWDIOInterface; 26 | AnalyzerSettingInterfaceChannel mSWCLKInterface; 27 | }; 28 | 29 | #endif // SWD_ANALYZER_SETTINGS_H -------------------------------------------------------------------------------- /src/SWDSimulationDataGenerator.cpp: -------------------------------------------------------------------------------- 1 | #include "SWDSimulationDataGenerator.h" 2 | #include "SWDAnalyzerSettings.h" 3 | 4 | #include "SWDTypes.h" 5 | 6 | #define TENTH_US 0.0000001 7 | 8 | // This simulation data. Taken from a real capture. 9 | 10 | struct SimulationData 11 | { 12 | U8 request; 13 | U32 data; 14 | }; 15 | 16 | SimulationData simul_data[] = { 17 | { 0xA5, 0x0BB11477 }, { 0xA5, 0x0BB11477 }, { 0x81, 0x0000001E }, { 0xA9, 0x50000000 }, { 0x8D, 0xF0000000 }, { 0xB1, 0x000000F0 }, 18 | { 0x9F, 0x00000000 }, { 0xB7, 0x04770021 }, { 0xBD, 0xF0000003 }, { 0xB1, 0x00000000 }, { 0xA3, 0x23000012 }, { 0x8B, 0xF0000000 }, 19 | { 0x9F, 0x00000000 }, { 0x9F, 0xF00FF003 }, { 0xA5, 0x0BB11477 }, { 0x81, 0x0000001E }, { 0xA9, 0x50000000 }, { 0x8D, 0xF0000040 }, 20 | { 0xB1, 0x00000000 }, { 0xA3, 0x23000002 }, { 0x8B, 0xE000ED00 }, { 0x9F, 0x00000000 }, { 0xBD, 0x410CC200 }, { 0x8B, 0xE000ED0C }, 21 | { 0x9F, 0x00000000 }, { 0xBD, 0xFA050000 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0xE0002000 }, { 0xA3, 0x23000012 }, 22 | { 0xBB, 0x00000002 }, { 0xBD, 0x00000000 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0xE000EDF0 }, { 0xA3, 0x23000012 }, 23 | { 0x9F, 0x00000000 }, { 0xBD, 0x03000000 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0xE000EDF0 }, { 0xA3, 0x23000012 }, 24 | { 0xBB, 0xA05F0001 }, { 0xBD, 0x00000000 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0xE0002000 }, { 0xA3, 0x23000012 }, 25 | { 0x9F, 0x00000000 }, { 0xBD, 0x00000040 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0xE000EDFC }, { 0xA3, 0x23000012 }, 26 | { 0x9F, 0x00000000 }, { 0xBD, 0x00000000 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0xE000EDFC }, { 0xA3, 0x23000012 }, 27 | { 0xBB, 0x01000000 }, { 0xBD, 0x00000000 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0xE0001000 }, { 0xA3, 0x23000012 }, 28 | { 0x9F, 0x00000000 }, { 0xBD, 0x20000000 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0xE0001000 }, { 0xA3, 0x23000012 }, 29 | { 0xBB, 0x20000001 }, { 0xBD, 0x00000000 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0xE00FF018 }, { 0xA3, 0x23000012 }, 30 | { 0x9F, 0x00000000 }, { 0xBD, 0x00000000 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0xE000EDF0 }, { 0xA3, 0x23000002 }, 31 | { 0xBB, 0xA05F0003 }, { 0x9F, 0x00000000 }, { 0x9F, 0x01030003 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0xE000EDF0 }, 32 | { 0xA3, 0x23000012 }, { 0xB1, 0x00000010 }, { 0x8B, 0x00000000 }, { 0xB7, 0x00000000 }, { 0xBD, 0x4000A148 }, { 0x8B, 0x00000001 }, 33 | { 0xB7, 0x00000000 }, { 0xBD, 0x00020000 }, { 0x8B, 0x00000002 }, { 0xB7, 0x00000000 }, { 0xBD, 0x00000001 }, { 0x8B, 0x00000003 }, 34 | { 0xB7, 0x00000000 }, { 0xBD, 0x4000A000 }, { 0x8B, 0x00000004 }, { 0xB7, 0x00000000 }, { 0xBD, 0x00000000 }, { 0x8B, 0x00000005 }, 35 | { 0xB7, 0x00000000 }, { 0xBD, 0x00000000 }, { 0x8B, 0x00000006 }, { 0xB7, 0x00000000 }, { 0xBD, 0xFFFFFFFF }, { 0x8B, 0x00000007 }, 36 | { 0xB7, 0x00000000 }, { 0xBD, 0x00000000 }, { 0x8B, 0x00000008 }, { 0xB7, 0x00000000 }, { 0xBD, 0xFFFFFFFF }, { 0x8B, 0x00000009 }, 37 | { 0xB7, 0x00000000 }, { 0xBD, 0xFFFFFFFF }, { 0x8B, 0x0000000A }, { 0xB7, 0x00000000 }, { 0xBD, 0x1FFF4000 }, { 0x8B, 0x0000000B }, 38 | { 0xB7, 0x00000000 }, { 0xBD, 0x00000000 }, { 0x8B, 0x0000000C }, { 0xB7, 0x00000000 }, { 0xBD, 0xFFFFFFFF }, { 0x8B, 0x0000000E }, 39 | { 0xB7, 0x00000000 }, { 0xBD, 0x00000173 }, { 0x8B, 0x0000000F }, { 0xB7, 0x00000000 }, { 0xBD, 0x00000336 }, { 0x8B, 0x00000010 }, 40 | { 0xB7, 0x00000000 }, { 0xBD, 0x01000000 }, { 0x8B, 0x00000011 }, { 0xB7, 0x00000000 }, { 0xBD, 0x20004000 }, { 0x8B, 0x00000012 }, 41 | { 0xB7, 0x00000000 }, { 0xBD, 0xFFFFFFFC }, { 0x8B, 0x00000014 }, { 0xB7, 0x00000000 }, { 0xBD, 0x00000000 }, { 0x81, 0x0000001E }, 42 | { 0xB1, 0x00000000 }, { 0x8B, 0x4001E504 }, { 0xA3, 0x23000012 }, { 0xBB, 0x00000000 }, { 0xBD, 0x00000000 }, { 0x81, 0x0000001E }, 43 | { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000001 }, { 0x81, 0x0000001E }, 44 | { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000001 }, { 0x81, 0x0000001E }, 45 | { 0xB1, 0x00000000 }, { 0x8B, 0xF0000FEC }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000000 }, { 0x81, 0x0000001E }, 46 | { 0xB1, 0x00000000 }, { 0x8B, 0x4001E504 }, { 0xA3, 0x23000012 }, { 0xBB, 0x00000000 }, { 0xBD, 0x00000000 }, { 0x81, 0x0000001E }, 47 | { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000001 }, { 0x81, 0x0000001E }, 48 | { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000001 }, { 0x81, 0x0000001E }, 49 | { 0xB1, 0x00000000 }, { 0x8B, 0xF0000FE8 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x0000004C }, { 0x81, 0x0000001E }, 50 | { 0xB1, 0x00000000 }, { 0x8B, 0x4001E504 }, { 0xA3, 0x23000012 }, { 0xBB, 0x00000000 }, { 0xBD, 0x00000000 }, { 0x81, 0x0000001E }, 51 | { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000001 }, { 0x81, 0x0000001E }, 52 | { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000001 }, { 0x81, 0x0000001E }, 53 | { 0xB1, 0x00000000 }, { 0x8B, 0xF0000FE4 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000040 }, { 0x81, 0x0000001E }, 54 | { 0xB1, 0x00000000 }, { 0x8B, 0x4001E504 }, { 0xA3, 0x23000012 }, { 0xBB, 0x00000000 }, { 0xBD, 0x00000000 }, { 0x81, 0x0000001E }, 55 | { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000001 }, { 0x81, 0x0000001E }, 56 | { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000001 }, { 0x81, 0x0000001E }, 57 | { 0xB1, 0x00000000 }, { 0x8B, 0xF0000FE0 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000001 }, { 0x81, 0x0000001E }, 58 | { 0xB1, 0x00000000 }, { 0x8B, 0x4001E504 }, { 0xA3, 0x23000012 }, { 0xBB, 0x00000000 }, { 0xBD, 0x00000000 }, { 0x81, 0x0000001E }, 59 | { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000001 }, { 0x81, 0x0000001E }, 60 | { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000001 }, { 0x81, 0x0000001E }, 61 | { 0xB1, 0x00000000 }, { 0x8B, 0x10001000 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, 62 | { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, 63 | { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, 64 | { 0x9F, 0xFFFFFFFF }, { 0xBD, 0xFFFFFFFF }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E504 }, { 0xA3, 0x23000012 }, 65 | { 0xBB, 0x00000000 }, { 0xBD, 0x00000000 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, 66 | { 0x9F, 0x00000000 }, { 0xBD, 0x00000001 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, 67 | { 0x9F, 0x00000000 }, { 0xBD, 0x00000001 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x40000608 }, { 0xA3, 0x23000012 }, 68 | { 0x9F, 0x00000000 }, { 0xBD, 0x00000001 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E504 }, { 0xA3, 0x23000012 }, 69 | { 0xBB, 0x00000000 }, { 0xBD, 0x00000000 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, 70 | { 0x9F, 0x00000000 }, { 0xBD, 0x00000001 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, 71 | { 0x9F, 0x00000000 }, { 0xBD, 0x00000001 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x1000002C }, { 0xA3, 0x23000012 }, 72 | { 0x9F, 0x00000000 }, { 0xBD, 0xFFFFFFFF }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E504 }, { 0xA3, 0x23000012 }, 73 | { 0xBB, 0x00000000 }, { 0xBD, 0x00000000 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, 74 | { 0x9F, 0x00000000 }, { 0xBD, 0x00000001 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, 75 | { 0x9F, 0x00000000 }, { 0xBD, 0x00000001 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x10000010 }, { 0xA3, 0x23000012 }, 76 | { 0x9F, 0x00000000 }, { 0xBD, 0x00000400 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x10000014 }, { 0xA3, 0x23000012 }, 77 | { 0x9F, 0x00000000 }, { 0xBD, 0x00000100 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E504 }, { 0xA3, 0x23000012 }, 78 | { 0xBB, 0x00000000 }, { 0xBD, 0x00000000 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, 79 | { 0x9F, 0x00000000 }, { 0xBD, 0x00000001 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, 80 | { 0x9F, 0x00000000 }, { 0xBD, 0x00000001 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x10000034 }, { 0xA3, 0x23000012 }, 81 | { 0x9F, 0x00000000 }, { 0xBD, 0x00000002 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x10000038 }, { 0xA3, 0x23000012 }, 82 | { 0x9F, 0x00000000 }, { 0xBD, 0x00002000 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x1000003C }, { 0xA3, 0x23000012 }, 83 | { 0x9F, 0x00000000 }, { 0xBD, 0x00002000 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E504 }, { 0xA3, 0x23000012 }, 84 | { 0xBB, 0x00000000 }, { 0xBD, 0x00000000 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, 85 | { 0x9F, 0x00000000 }, { 0xBD, 0x00000001 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, 86 | { 0x9F, 0x00000000 }, { 0xBD, 0x00000001 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x10000010 }, { 0xA3, 0x23000012 }, 87 | { 0x9F, 0x00000000 }, { 0xBD, 0x00000400 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x10000014 }, { 0xA3, 0x23000012 }, 88 | { 0x9F, 0x00000000 }, { 0xBD, 0x00000100 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E504 }, { 0xA3, 0x23000012 }, 89 | { 0xBB, 0x00000000 }, { 0xBD, 0x00000000 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, 90 | { 0x9F, 0x00000000 }, { 0xBD, 0x00000001 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, 91 | { 0x9F, 0x00000000 }, { 0xBD, 0x00000001 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E504 }, { 0xA3, 0x23000012 }, 92 | { 0xBB, 0x00000000 }, { 0xBD, 0x00000000 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, 93 | { 0x9F, 0x00000000 }, { 0xBD, 0x00000001 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, 94 | { 0x9F, 0x00000000 }, { 0xBD, 0x00000001 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x1000002C }, { 0xA3, 0x23000012 }, 95 | { 0x9F, 0x00000000 }, { 0xBD, 0xFFFFFFFF }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E504 }, { 0xA3, 0x23000012 }, 96 | { 0xBB, 0x00000000 }, { 0xBD, 0x00000000 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, 97 | { 0x9F, 0x00000000 }, { 0xBD, 0x00000001 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, 98 | { 0x9F, 0x00000000 }, { 0xBD, 0x00000001 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x10000010 }, { 0xA3, 0x23000012 }, 99 | { 0x9F, 0x00000000 }, { 0xBD, 0x00000400 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x10001040 }, { 0xA3, 0x23000012 }, 100 | { 0x9F, 0x00000000 }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, 101 | { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, 102 | { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, 103 | { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, 104 | { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, 105 | { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, 106 | { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, 107 | { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, 108 | { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, 109 | { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, 110 | { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, 111 | { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, 112 | { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, 113 | { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, 114 | { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, 115 | { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, 116 | { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, 117 | { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, 118 | { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, 119 | { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, 120 | { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, 121 | { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, 122 | { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, 123 | { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, 124 | { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, 125 | { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, 126 | { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, 127 | { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, 128 | { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, 129 | { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, 130 | { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, 131 | { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, 132 | { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, 133 | { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, 134 | { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, 135 | { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, 136 | { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, 137 | { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, 138 | { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, 139 | { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, 140 | { 0xBD, 0xFFFFFFFF }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E504 }, { 0xA3, 0x23000012 }, { 0xBB, 0x00000000 }, 141 | { 0xBD, 0x00000000 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, 142 | { 0xBD, 0x00000001 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, 143 | { 0xBD, 0x00000001 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x10000010 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, 144 | { 0xBD, 0x00000400 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x10000014 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, 145 | { 0xBD, 0x00000100 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E504 }, { 0xA3, 0x23000012 }, { 0xBB, 0x00000000 }, 146 | { 0xBD, 0x00000000 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, 147 | { 0xBD, 0x00000001 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, 148 | { 0xBD, 0x00000001 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x1000002C }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, 149 | { 0xBD, 0xFFFFFFFF }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E504 }, { 0xA3, 0x23000012 }, { 0xBB, 0x00000000 }, 150 | { 0xBD, 0x00000000 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, 151 | { 0xBD, 0x00000001 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, 152 | { 0xBD, 0x00000001 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E504 }, { 0xA3, 0x23000012 }, { 0xBB, 0x00000000 }, 153 | { 0xBD, 0x00000000 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, 154 | { 0xBD, 0x00000001 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, 155 | { 0xBD, 0x00000001 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x1000002C }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, 156 | { 0xBD, 0xFFFFFFFF }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0xE000EDF0 }, { 0xA3, 0x23000012 }, { 0xBB, 0xA05F0003 }, 157 | { 0xBD, 0x00000000 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0xE000EDFC }, { 0xA3, 0x23000012 }, { 0xBB, 0x01000001 }, 158 | { 0xBD, 0x00000000 }, { 0x81, 0x0000001E }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0xE000ED0C }, { 0xA3, 0x23000012 }, 159 | { 0xBB, 0x05FA0004 }, { 0xBD, 0x00000000 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0xE000EDF0 }, { 0xA3, 0x23000012 }, 160 | { 0x9F, 0x00000000 }, { 0xBD, 0x03030003 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0xE000EDF0 }, { 0xA3, 0x23000012 }, 161 | { 0x9F, 0x00000000 }, { 0xBD, 0x00030003 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0xE000EDF0 }, { 0xA3, 0x23000012 }, 162 | { 0xBB, 0xA05F0003 }, { 0xBD, 0x00000000 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0xE000EDFC }, { 0xA3, 0x23000012 }, 163 | { 0xBB, 0x01000000 }, { 0xBD, 0x00000000 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0xE000EDF0 }, { 0xA3, 0x23000012 }, 164 | { 0x9F, 0x00000000 }, { 0xBD, 0x00030003 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0xE000EDF0 }, { 0xA3, 0x23000012 }, 165 | { 0x9F, 0x00000000 }, { 0xBD, 0x00030003 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0xE000EDF0 }, { 0xA3, 0x23000012 }, 166 | { 0xB1, 0x00000010 }, { 0x8B, 0x00000000 }, { 0xB7, 0x00000000 }, { 0xBD, 0xFFFFFFFF }, { 0x8B, 0x00000001 }, { 0xB7, 0x00000000 }, 167 | { 0xBD, 0xFFFFFFFF }, { 0x8B, 0x00000002 }, { 0xB7, 0x00000000 }, { 0xBD, 0xFFFFFFFF }, { 0x8B, 0x00000003 }, { 0xB7, 0x00000000 }, 168 | { 0xBD, 0xFFFFFFFF }, { 0x8B, 0x00000004 }, { 0xB7, 0x00000000 }, { 0xBD, 0xFFFFFFFF }, { 0x8B, 0x00000005 }, { 0xB7, 0x00000000 }, 169 | { 0xBD, 0xFFFFFFFF }, { 0x8B, 0x00000006 }, { 0xB7, 0x00000000 }, { 0xBD, 0xFFFFFFFF }, { 0x8B, 0x00000007 }, { 0xB7, 0x00000000 }, 170 | { 0xBD, 0xFFFFFFFF }, { 0x8B, 0x00000008 }, { 0xB7, 0x00000000 }, { 0xBD, 0xFFFFFFFF }, { 0x8B, 0x00000009 }, { 0xB7, 0x00000000 }, 171 | { 0xBD, 0xFFFFFFFF }, { 0x8B, 0x0000000A }, { 0xB7, 0x00000000 }, { 0xBD, 0xFFFFFFFF }, { 0x8B, 0x0000000B }, { 0xB7, 0x00000000 }, 172 | { 0xBD, 0xFFFFFFFF }, { 0x8B, 0x0000000C }, { 0xB7, 0x00000000 }, { 0xBD, 0xFFFFFFFF }, { 0x8B, 0x0000000E }, { 0xB7, 0x00000000 }, 173 | { 0xBD, 0xFFFFFFFF }, { 0x8B, 0x0000000F }, { 0xB7, 0x00000000 }, { 0xBD, 0x00000438 }, { 0x8B, 0x00000010 }, { 0xB7, 0x00000000 }, 174 | { 0xBD, 0xC1000000 }, { 0x8B, 0x00000011 }, { 0xB7, 0x00000000 }, { 0xBD, 0x20004000 }, { 0x8B, 0x00000012 }, { 0xB7, 0x00000000 }, 175 | { 0xBD, 0xFFFFFFFC }, { 0x8B, 0x00000014 }, { 0xB7, 0x00000000 }, { 0xBD, 0x00000000 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, 176 | { 0x8B, 0xE0002000 }, { 0xA3, 0x23000012 }, { 0xBB, 0x00000003 }, { 0xBD, 0x00000000 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, 177 | { 0x8B, 0xE000EDFC }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x01000000 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, 178 | { 0x8B, 0xE0001000 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x20000000 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, 179 | { 0x8B, 0xE0001000 }, { 0xA3, 0x23000012 }, { 0xBB, 0x20000001 }, { 0xBD, 0x00000000 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, 180 | { 0x8B, 0x4001E504 }, { 0xA3, 0x23000012 }, { 0xBB, 0x00000000 }, { 0xBD, 0x00000000 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, 181 | { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000001 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, 182 | { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000001 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, 183 | { 0x8B, 0x10000010 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000400 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, 184 | { 0x8B, 0x10000014 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000100 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, 185 | { 0x8B, 0x40000524 }, { 0xA3, 0x23000012 }, { 0xBB, 0x0000000F }, { 0xBD, 0x00000000 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, 186 | { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000001 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, 187 | { 0x8B, 0x4001E504 }, { 0xA3, 0x23000012 }, { 0xBB, 0x00000001 }, { 0xBD, 0x00000000 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, 188 | { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000001 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, 189 | { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000001 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, 190 | { 0x8B, 0x20000000 }, { 0xA3, 0x23000012 }, { 0xBB, 0x200008E8 }, { 0xBB, 0x200002D5 }, { 0xBB, 0x200002E7 }, { 0xBB, 0x200002E9 }, 191 | { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, 192 | { 0xBB, 0x00000000 }, { 0xBB, 0x200002EB }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x200002ED }, { 0xBB, 0x200002EF }, 193 | { 0xBB, 0x200002F1 }, { 0xBB, 0x200002F1 }, { 0xBB, 0x200002F1 }, { 0xBB, 0x200002F1 }, { 0xBB, 0x200002F1 }, { 0xBB, 0x00000000 }, 194 | { 0xBB, 0x200002F1 }, { 0xBB, 0x200002F1 }, { 0xBB, 0x200002F1 }, { 0xBB, 0x200002F1 }, { 0xBB, 0x200002F1 }, { 0xBB, 0x200002F1 }, 195 | { 0xBB, 0x200002F1 }, { 0xBB, 0x200002F1 }, { 0xBB, 0x200002F1 }, { 0xBB, 0x200002F1 }, { 0xBD, 0x00000000 }, { 0xB1, 0x00000000 }, 196 | { 0x8B, 0x20000080 }, { 0xBB, 0x200002F1 }, { 0xBB, 0x200002F1 }, { 0xBB, 0x200002F1 }, { 0xBB, 0x200002F1 }, { 0xBB, 0x200002F1 }, 197 | { 0xBB, 0x200002F1 }, { 0xBB, 0x200002F1 }, { 0xBB, 0x200002F1 }, { 0xBB, 0x200002F1 }, { 0xBB, 0x200002F1 }, { 0xBB, 0x00000000 }, 198 | { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0xF802F000 }, 199 | { 0xBB, 0xF840F000 }, { 0xBB, 0xC830A00C }, { 0xBB, 0x18243808 }, { 0xBB, 0x46A2182D }, { 0xBB, 0x46AB1E67 }, { 0xBB, 0x465D4654 }, 200 | { 0xBB, 0xD10142AC }, { 0xBB, 0xF832F000 }, { 0xBB, 0x3E0F467E }, { 0xBB, 0x46B6CC0F }, { 0xBB, 0x42332601 }, { 0xBB, 0x1AFBD000 }, 201 | { 0xBB, 0x46AB46A2 }, { 0xBB, 0x47184333 }, { 0xBB, 0x000002A0 }, { 0xBB, 0x000002C0 }, { 0xBB, 0xD3023A10 }, { 0xBB, 0xC178C878 }, 202 | { 0xBB, 0x0752D8FA }, { 0xBB, 0xC830D301 }, { 0xBB, 0xD501C130 }, { 0xBB, 0x600C6804 }, { 0xBB, 0x00004770 }, { 0xBB, 0x24002300 }, 203 | { 0xBB, 0x26002500 }, { 0xBB, 0xD3013A10 }, { 0xBB, 0xD8FBC178 }, { 0xBB, 0xD3000752 }, { 0xBB, 0xD500C130 }, { 0xBB, 0x4770600B }, 204 | { 0xBB, 0x46C0B51F }, { 0xBB, 0xBD1F46C0 }, { 0xBB, 0xBD10B510 }, { 0xBB, 0xF8E9F000 }, { 0xBB, 0xF7FF4611 }, { 0xBB, 0xF000FFF5 }, 205 | { 0xBB, 0xF000F809 }, { 0xBB, 0xB403F901 }, { 0xBB, 0xFFF2F7FF }, { 0xBB, 0xF000BC03 }, { 0xBB, 0x0000F905 }, { 0xBB, 0x4A0D2101 }, 206 | { 0xBB, 0x490D6011 }, { 0xBB, 0xE0076808 }, { 0xBB, 0x1C496801 }, { 0xBB, 0x2100D003 }, { 0xBB, 0x60114A08 }, { 0xBB, 0x1D00E007 }, 207 | { 0xBB, 0x68094907 }, { 0xBB, 0x68124A07 }, { 0xBB, 0x42811889 }, { 0xBB, 0xBF00D8F0 }, { 0xBB, 0x4A052101 }, { 0xBB, 0xBF006011 }, 208 | { 0xBB, 0x0000E7FE }, { 0xBB, 0x20000C04 }, { 0xBB, 0x20000C10 }, { 0xBB, 0x20000C14 }, { 0xBB, 0x20000C00 }, { 0xBB, 0x4841B500 }, 209 | { 0xBB, 0xB28069C0 }, { 0xBB, 0x0003381D }, { 0xBB, 0xF8DFF000 }, { 0xBB, 0x290D1718 }, { 0xBB, 0x29292929 }, { 0xBB, 0x2523290F }, 210 | { 0xBB, 0x1B192929 }, { 0xBB, 0x2113111F }, { 0xBB, 0x27291529 }, { 0xBB, 0x2001291D }, { 0xBB, 0x2001BD00 }, { 0xBB, 0x2001E7FC }, 211 | { 0xBB, 0x2001E7FA }, { 0xBB, 0x2000E7F8 }, { 0xBB, 0x2001E7F6 }, { 0xBB, 0x2001E7F4 }, { 0xBB, 0x2001E7F2 }, { 0xBB, 0x2001E7F0 }, 212 | { 0xBB, 0x2001E7EE }, { 0xBB, 0x2000E7EC }, { 0xBB, 0x2001E7EA }, { 0xBB, 0x2001E7E8 }, { 0xBB, 0x2001E7E6 }, { 0xBB, 0x2001E7E4 }, 213 | { 0xBB, 0xB500E7E2 }, { 0xBB, 0x69C04827 }, { 0xBB, 0x381DB280 }, { 0xBB, 0xF0000003 }, { 0xBB, 0x1718F8AC }, { 0xBB, 0x2929290D }, 214 | { 0xBB, 0x290F2929 }, { 0xBB, 0x29292523 }, { 0xBB, 0x111F1B19 }, { 0xBB, 0x15292113 }, { 0xBB, 0x291D2729 }, { 0xBB, 0xBD002001 }, 215 | { 0xBB, 0xE7FC2001 }, { 0xBB, 0xE7FA2000 }, { 0xBB, 0xE7F82000 }, { 0xBB, 0xE7F62001 }, { 0xBB, 0xE7F42001 }, { 0xBB, 0xE7F22000 }, 216 | { 0xBB, 0xE7F02000 }, { 0xBB, 0xE7EE2000 }, { 0xBB, 0xE7EC2000 }, { 0xBB, 0xE7EA2001 }, { 0xBB, 0xE7E82001 }, { 0xBB, 0xE7E62001 }, 217 | { 0xBB, 0xE7E42001 }, { 0xBB, 0xE7E22000 }, { 0xBB, 0xF7FFB510 }, { 0xBB, 0x2800FFCA }, { 0xBB, 0x480DD005 }, { 0xBB, 0x6048490D }, 218 | { 0xBB, 0x490D13C8 }, { 0xBB, 0xF7FF6188 }, { 0xBB, 0x2800FF8D }, { 0xBB, 0x2001D009 }, { 0xBB, 0x07092105 }, { 0xBB, 0x02122207 }, 219 | { 0xBB, 0x67C81889 }, { 0xBB, 0x490707C0 }, { 0xBB, 0xBD1060C8 }, { 0xBB, 0x49074806 }, { 0xBB, 0x47706008 }, { 0xBB, 0x10000040 }, 220 | { 0xBB, 0xC007FFDF }, { 0xBB, 0x40000500 }, { 0xBB, 0x40006C00 }, { 0xBB, 0x50000500 }, { 0xBB, 0x00F42400 }, { 0xBB, 0x20000800 }, 221 | { 0xBB, 0x6802480A }, { 0xBB, 0x430A210F }, { 0xBB, 0x48096002 }, { 0xBB, 0x48094780 }, { 0xBB, 0xE7FE4700 }, { 0xBB, 0xE7FEE7FE }, 222 | { 0xBB, 0xE7FEE7FE }, { 0xBB, 0x0000E7FE }, { 0xBB, 0x49064805 }, { 0xBB, 0x4B064A04 }, { 0xBB, 0x00004770 }, { 0xBB, 0x40000524 }, 223 | { 0xBB, 0x2000027D }, { 0xBB, 0x200000C1 }, { 0xBB, 0x20000868 }, { 0xBB, 0x200008E8 }, { 0xBB, 0x20000868 }, { 0xBB, 0x47704770 }, 224 | { 0xBB, 0x46754770 }, { 0xBB, 0xF822F000 }, { 0xBB, 0x000546AE }, { 0xBB, 0x46534669 }, { 0xBB, 0x00C008C0 }, { 0xBB, 0xB0184685 }, 225 | { 0xBB, 0xF7FFB520 }, { 0xBB, 0xBC60FFDD }, { 0xBB, 0x08492700 }, { 0xBB, 0x260046B6 }, { 0xBB, 0xC5C0C5C0 }, { 0xBB, 0xC5C0C5C0 }, 226 | { 0xBB, 0xC5C0C5C0 }, { 0xBB, 0xC5C0C5C0 }, { 0xBB, 0x00493D40 }, { 0xBB, 0x4770468D }, { 0xBB, 0x46C04604 }, { 0xBB, 0x462046C0 }, 227 | { 0xBB, 0xFEF9F7FF }, { 0xBB, 0x47704800 }, { 0xBB, 0x20000804 }, { 0xBB, 0x20184901 }, { 0xBB, 0xE7FEBEAB }, { 0xBB, 0x00020026 }, 228 | { 0xBB, 0xB4304770 }, { 0xBB, 0x1E644674 }, { 0xBB, 0x1C647825 }, { 0xBB, 0xD30442AB }, { 0xBB, 0x005B5D63 }, { 0xBB, 0xBC3018E3 }, 229 | { 0xBB, 0x461D4718 }, { 0xBB, 0x0000E7F8 }, { 0xBB, 0x200003BC }, { 0xBB, 0x20000800 }, { 0xBB, 0x00000004 }, { 0xBB, 0x20000104 }, 230 | { 0xBB, 0x200003C0 }, { 0xBB, 0x20000804 }, { 0xBB, 0x000000E4 }, { 0xBB, 0x20000120 }, { 0xBB, 0x00F42400 }, { 0xBD, 0x00000000 }, 231 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x20000C10 }, { 0xA3, 0x23000012 }, { 0xBB, 0xFFFFFFFF }, { 0xBD, 0x00000000 }, 232 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E504 }, { 0xA3, 0x23000012 }, { 0xBB, 0x00000000 }, { 0xBD, 0x00000000 }, 233 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000001 }, 234 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000001 }, 235 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E504 }, { 0xA3, 0x23000012 }, { 0xBB, 0x00000000 }, { 0xBD, 0x00000000 }, 236 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000001 }, 237 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000001 }, 238 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x20000000 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0x9F, 0x200008E8 }, 239 | { 0x9F, 0x200002D5 }, { 0x9F, 0x200002E7 }, { 0x9F, 0x200002E9 }, { 0x9F, 0x00000000 }, { 0x9F, 0x00000000 }, { 0x9F, 0x00000000 }, 240 | { 0x9F, 0x00000000 }, { 0x9F, 0x00000000 }, { 0x9F, 0x00000000 }, { 0x9F, 0x00000000 }, { 0x9F, 0x200002EB }, { 0x9F, 0x00000000 }, 241 | { 0x9F, 0x00000000 }, { 0x9F, 0x200002ED }, { 0x9F, 0x200002EF }, { 0x9F, 0x200002F1 }, { 0x9F, 0x200002F1 }, { 0x9F, 0x200002F1 }, 242 | { 0x9F, 0x200002F1 }, { 0x9F, 0x200002F1 }, { 0x9F, 0x00000000 }, { 0x9F, 0x200002F1 }, { 0x9F, 0x200002F1 }, { 0x9F, 0x200002F1 }, 243 | { 0x9F, 0x200002F1 }, { 0x9F, 0x200002F1 }, { 0x9F, 0x200002F1 }, { 0x9F, 0x200002F1 }, { 0x9F, 0x200002F1 }, { 0x9F, 0x200002F1 }, 244 | { 0x9F, 0x200002F1 }, { 0x9F, 0x200002F1 }, { 0x9F, 0x200002F1 }, { 0x9F, 0x200002F1 }, { 0x9F, 0x200002F1 }, { 0x9F, 0x200002F1 }, 245 | { 0x9F, 0x200002F1 }, { 0x9F, 0x200002F1 }, { 0x9F, 0x200002F1 }, { 0x9F, 0x200002F1 }, { 0x9F, 0x200002F1 }, { 0x9F, 0x00000000 }, 246 | { 0x9F, 0x00000000 }, { 0x9F, 0x00000000 }, { 0x9F, 0x00000000 }, { 0x9F, 0x00000000 }, { 0x9F, 0x00000000 }, { 0x9F, 0xF802F000 }, 247 | { 0x9F, 0xF840F000 }, { 0x9F, 0xC830A00C }, { 0x9F, 0x18243808 }, { 0x9F, 0x46A2182D }, { 0x9F, 0x46AB1E67 }, { 0x9F, 0x465D4654 }, 248 | { 0x9F, 0xD10142AC }, { 0x9F, 0xF832F000 }, { 0x9F, 0x3E0F467E }, { 0x9F, 0x46B6CC0F }, { 0x9F, 0x42332601 }, { 0x9F, 0x1AFBD000 }, 249 | { 0x9F, 0x46AB46A2 }, { 0x9F, 0x47184333 }, { 0x9F, 0x000002A0 }, { 0x9F, 0x000002C0 }, { 0x9F, 0xD3023A10 }, { 0x9F, 0xC178C878 }, 250 | { 0x9F, 0x0752D8FA }, { 0x9F, 0xC830D301 }, { 0x9F, 0xD501C130 }, { 0x9F, 0x600C6804 }, { 0x9F, 0x00004770 }, { 0x9F, 0x24002300 }, 251 | { 0x9F, 0x26002500 }, { 0x9F, 0xD3013A10 }, { 0x9F, 0xD8FBC178 }, { 0x9F, 0xD3000752 }, { 0x9F, 0xD500C130 }, { 0x9F, 0x4770600B }, 252 | { 0x9F, 0x46C0B51F }, { 0x9F, 0xBD1F46C0 }, { 0x9F, 0xBD10B510 }, { 0x9F, 0xF8E9F000 }, { 0x9F, 0xF7FF4611 }, { 0x9F, 0xF000FFF5 }, 253 | { 0x9F, 0xF000F809 }, { 0x9F, 0xB403F901 }, { 0x9F, 0xFFF2F7FF }, { 0x9F, 0xF000BC03 }, { 0x9F, 0x0000F905 }, { 0x9F, 0x4A0D2101 }, 254 | { 0x9F, 0x490D6011 }, { 0x9F, 0xE0076808 }, { 0x9F, 0x1C496801 }, { 0x9F, 0x2100D003 }, { 0x9F, 0x60114A08 }, { 0x9F, 0x1D00E007 }, 255 | { 0x9F, 0x68094907 }, { 0x9F, 0x68124A07 }, { 0x9F, 0x42811889 }, { 0x9F, 0xBF00D8F0 }, { 0x9F, 0x4A052101 }, { 0x9F, 0xBF006011 }, 256 | { 0x9F, 0x0000E7FE }, { 0x9F, 0x20000C04 }, { 0x9F, 0x20000C10 }, { 0x9F, 0x20000C14 }, { 0x9F, 0x20000C00 }, { 0x9F, 0x4841B500 }, 257 | { 0x9F, 0xB28069C0 }, { 0x9F, 0x0003381D }, { 0x9F, 0xF8DFF000 }, { 0x9F, 0x290D1718 }, { 0x9F, 0x29292929 }, { 0x9F, 0x2523290F }, 258 | { 0x9F, 0x1B192929 }, { 0x9F, 0x2113111F }, { 0x9F, 0x27291529 }, { 0x9F, 0x2001291D }, { 0x9F, 0x2001BD00 }, { 0x9F, 0x2001E7FC }, 259 | { 0x9F, 0x2001E7FA }, { 0x9F, 0x2000E7F8 }, { 0x9F, 0x2001E7F6 }, { 0x9F, 0x2001E7F4 }, { 0x9F, 0x2001E7F2 }, { 0x9F, 0x2001E7F0 }, 260 | { 0x9F, 0x2001E7EE }, { 0x9F, 0x2000E7EC }, { 0x9F, 0x2001E7EA }, { 0x9F, 0x2001E7E8 }, { 0x9F, 0x2001E7E6 }, { 0x9F, 0x2001E7E4 }, 261 | { 0x9F, 0xB500E7E2 }, { 0x9F, 0x69C04827 }, { 0x9F, 0x381DB280 }, { 0x9F, 0xF0000003 }, { 0x9F, 0x1718F8AC }, { 0x9F, 0x2929290D }, 262 | { 0x9F, 0x290F2929 }, { 0x9F, 0x29292523 }, { 0x9F, 0x111F1B19 }, { 0x9F, 0x15292113 }, { 0x9F, 0x291D2729 }, { 0x9F, 0xBD002001 }, 263 | { 0x9F, 0xE7FC2001 }, { 0x9F, 0xE7FA2000 }, { 0x9F, 0xE7F82000 }, { 0x9F, 0xE7F62001 }, { 0x9F, 0xE7F42001 }, { 0x9F, 0xE7F22000 }, 264 | { 0x9F, 0xE7F02000 }, { 0x9F, 0xE7EE2000 }, { 0x9F, 0xE7EC2000 }, { 0x9F, 0xE7EA2001 }, { 0x9F, 0xE7E82001 }, { 0x9F, 0xE7E62001 }, 265 | { 0x9F, 0xE7E42001 }, { 0x9F, 0xE7E22000 }, { 0x9F, 0xF7FFB510 }, { 0x9F, 0x2800FFCA }, { 0x9F, 0x480DD005 }, { 0x9F, 0x6048490D }, 266 | { 0x9F, 0x490D13C8 }, { 0x9F, 0xF7FF6188 }, { 0x9F, 0x2800FF8D }, { 0x9F, 0x2001D009 }, { 0x9F, 0x07092105 }, { 0x9F, 0x02122207 }, 267 | { 0x9F, 0x67C81889 }, { 0x9F, 0x490707C0 }, { 0x9F, 0xBD1060C8 }, { 0x9F, 0x49074806 }, { 0x9F, 0x47706008 }, { 0x9F, 0x10000040 }, 268 | { 0x9F, 0xC007FFDF }, { 0x9F, 0x40000500 }, { 0x9F, 0x40006C00 }, { 0x9F, 0x50000500 }, { 0x9F, 0x00F42400 }, { 0x9F, 0x20000800 }, 269 | { 0x9F, 0x6802480A }, { 0x9F, 0x430A210F }, { 0x9F, 0x48096002 }, { 0x9F, 0x48094780 }, { 0x9F, 0xE7FE4700 }, { 0x9F, 0xE7FEE7FE }, 270 | { 0x9F, 0xE7FEE7FE }, { 0x9F, 0x0000E7FE }, { 0x9F, 0x49064805 }, { 0x9F, 0x4B064A04 }, { 0x9F, 0x00004770 }, { 0x9F, 0x40000524 }, 271 | { 0x9F, 0x2000027D }, { 0x9F, 0x200000C1 }, { 0x9F, 0x20000868 }, { 0x9F, 0x200008E8 }, { 0x9F, 0x20000868 }, { 0x9F, 0x47704770 }, 272 | { 0x9F, 0x46754770 }, { 0x9F, 0xF822F000 }, { 0x9F, 0x000546AE }, { 0x9F, 0x46534669 }, { 0x9F, 0x00C008C0 }, { 0x9F, 0xB0184685 }, 273 | { 0x9F, 0xF7FFB520 }, { 0x9F, 0xBC60FFDD }, { 0x9F, 0x08492700 }, { 0x9F, 0x260046B6 }, { 0x9F, 0xC5C0C5C0 }, { 0x9F, 0xC5C0C5C0 }, 274 | { 0x9F, 0xC5C0C5C0 }, { 0x9F, 0xC5C0C5C0 }, { 0x9F, 0x00493D40 }, { 0x9F, 0x4770468D }, { 0x9F, 0x46C04604 }, { 0x9F, 0x462046C0 }, 275 | { 0x9F, 0xFEF9F7FF }, { 0x9F, 0x47704800 }, { 0x9F, 0x20000804 }, { 0x9F, 0x20184901 }, { 0x9F, 0xE7FEBEAB }, { 0x9F, 0x00020026 }, 276 | { 0x9F, 0xB4304770 }, { 0x9F, 0x1E644674 }, { 0x9F, 0x1C647825 }, { 0x9F, 0xD30442AB }, { 0x9F, 0x005B5D63 }, { 0x9F, 0xBC3018E3 }, 277 | { 0x9F, 0x461D4718 }, { 0x9F, 0x0000E7F8 }, { 0x9F, 0x200003BC }, { 0x9F, 0x20000800 }, { 0x9F, 0x00000004 }, { 0x9F, 0x20000104 }, 278 | { 0x9F, 0x200003C0 }, { 0x9F, 0x20000804 }, { 0x9F, 0x000000E4 }, { 0x9F, 0x20000120 }, { 0xBD, 0x00F42400 }, { 0x81, 0x0000001E }, 279 | { 0xB1, 0x00000000 }, { 0x8B, 0x20000C00 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0x9F, 0xFBDF4041 }, { 0x9F, 0xD7CE8201 }, 280 | { 0x9F, 0xFFFD0490 }, { 0x9F, 0xBF8F2840 }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0x000073FF }, { 0x9F, 0x2200F7DF }, { 0x9F, 0x5000FEBF }, 281 | { 0x9F, 0xFFFB0000 }, { 0x9F, 0xFFFB0200 }, { 0x9F, 0xFF7B4C20 }, { 0x9F, 0xFFFA0A00 }, { 0x9F, 0x0102FFD7 }, { 0x9F, 0x0202F7DF }, 282 | { 0x9F, 0x0002FFDE }, { 0xBD, 0x1048D6D7 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x20000C00 }, { 0xA3, 0x23000012 }, 283 | { 0xBB, 0x00000000 }, { 0xBD, 0x00000000 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, 284 | { 0x9F, 0x00000000 }, { 0xBD, 0x00000001 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x20000C04 }, { 0xA3, 0x23000012 }, 285 | { 0xBB, 0x00000000 }, { 0xBD, 0x00000000 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, 286 | { 0x9F, 0x00000000 }, { 0xBD, 0x00000001 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x20000C10 }, { 0xA3, 0x23000012 }, 287 | { 0xBB, 0x00000000 }, { 0xBD, 0x00000000 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, 288 | { 0x9F, 0x00000000 }, { 0xBD, 0x00000001 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x20000C14 }, { 0xA3, 0x23000012 }, 289 | { 0xBB, 0x00000C30 }, { 0xBD, 0x00000000 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, 290 | { 0x9F, 0x00000000 }, { 0xBD, 0x00000001 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0xE0001004 }, { 0xA3, 0x23000012 }, 291 | { 0xBB, 0x00000000 }, { 0xBD, 0x00000000 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0xE000EDF0 }, { 0xA3, 0x23000012 }, 292 | { 0xB1, 0x00000010 }, { 0x93, 0x200002D4 }, { 0x8B, 0x0001000F }, { 0x93, 0x200008E8 }, { 0x8B, 0x00010011 }, { 0xBD, 0x00000000 }, 293 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0xE000ED30 }, { 0xA3, 0x23000002 }, { 0xBB, 0x0000001F }, { 0x8B, 0xE000EDF0 }, 294 | { 0xBB, 0xA05F0003 }, { 0xBB, 0xA05F0001 }, { 0xBD, 0x00000000 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0xE000EDF0 }, 295 | { 0xA3, 0x23000002 }, { 0xBB, 0xA05F0003 }, { 0x9F, 0x00000000 }, { 0x9F, 0x01030003 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, 296 | { 0x8B, 0xE000EDF0 }, { 0xA3, 0x23000012 }, { 0xB1, 0x00000010 }, { 0x8B, 0x00000000 }, { 0xB7, 0x00000000 }, { 0xBD, 0x00000000 }, 297 | { 0x8B, 0x00000001 }, { 0xB7, 0x00000000 }, { 0xBD, 0x00000001 }, { 0x8B, 0x00000002 }, { 0xB7, 0x00000000 }, { 0xBD, 0x20000C00 }, 298 | { 0x8B, 0x00000003 }, { 0xB7, 0x00000000 }, { 0xBD, 0x20000868 }, { 0x8B, 0x00000004 }, { 0xB7, 0x00000000 }, { 0xBD, 0x200003BC }, 299 | { 0x8B, 0x00000005 }, { 0xB7, 0x00000000 }, { 0xBD, 0x20000804 }, { 0x8B, 0x00000006 }, { 0xB7, 0x00000000 }, { 0xBD, 0x00000000 }, 300 | { 0x8B, 0x00000007 }, { 0xB7, 0x00000000 }, { 0xBD, 0x00000000 }, { 0x8B, 0x00000008 }, { 0xB7, 0x00000000 }, { 0xBD, 0xFFFFFFFF }, 301 | { 0x8B, 0x00000009 }, { 0xB7, 0x00000000 }, { 0xBD, 0xFFFFFFFF }, { 0x8B, 0x0000000A }, { 0xB7, 0x00000000 }, { 0xBD, 0x200003BC }, 302 | { 0x8B, 0x0000000B }, { 0xB7, 0x00000000 }, { 0xBD, 0x200003BC }, { 0x8B, 0x0000000C }, { 0xB7, 0x00000000 }, { 0xBD, 0xFFFFFFFF }, 303 | { 0x8B, 0x0000000E }, { 0xB7, 0x00000000 }, { 0xBD, 0x20000157 }, { 0x8B, 0x0000000F }, { 0xB7, 0x00000000 }, { 0xBD, 0x2000019C }, 304 | { 0x8B, 0x00000010 }, { 0xB7, 0x00000000 }, { 0xBD, 0x01000000 }, { 0x8B, 0x00000011 }, { 0xB7, 0x00000000 }, { 0xBD, 0x200008E8 }, 305 | { 0x8B, 0x00000012 }, { 0xB7, 0x00000000 }, { 0xBD, 0xFFFFFFFC }, { 0x8B, 0x00000014 }, { 0xB7, 0x00000000 }, { 0xBD, 0x00000000 }, 306 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x20000C00 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0x9F, 0x00000001 }, 307 | { 0x9F, 0x00000000 }, { 0x9F, 0xFFFD0490 }, { 0x9F, 0xBF8F2840 }, { 0x9F, 0x00000000 }, { 0x9F, 0x00000C30 }, { 0x9F, 0x2200F7DF }, 308 | { 0x9F, 0x5000FEBF }, { 0x9F, 0xFFFB0000 }, { 0x9F, 0xFFFB0200 }, { 0x9F, 0xFF7B4C20 }, { 0x9F, 0xFFFA0A00 }, { 0x9F, 0x0102FFD7 }, 309 | { 0x9F, 0x0202F7DF }, { 0x9F, 0x0002FFDE }, { 0xBD, 0x1048D6D7 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E504 }, 310 | { 0xA3, 0x23000012 }, { 0xBB, 0x00000000 }, { 0xBD, 0x00000000 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, 311 | { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000001 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, 312 | { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000001 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x10000010 }, 313 | { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000400 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x10000014 }, 314 | { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000100 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E504 }, 315 | { 0xA3, 0x23000012 }, { 0xBB, 0x00000000 }, { 0xBD, 0x00000000 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, 316 | { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000001 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, 317 | { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000001 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x1000002C }, 318 | { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0xFFFFFFFF }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x10001000 }, 319 | { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, 320 | { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, 321 | { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0xFFFFFFFF }, { 0xBD, 0xFFFFFFFF }, 322 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x40000608 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000000 }, 323 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x40000600 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000000 }, 324 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x40000604 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000000 }, 325 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E504 }, { 0xA3, 0x23000012 }, { 0xBB, 0x00000002 }, { 0xBD, 0x00000000 }, 326 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000001 }, 327 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000001 }, 328 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E508 }, { 0xA3, 0x23000012 }, { 0xBB, 0x00000000 }, { 0xBD, 0x00000000 }, 329 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000000 }, 330 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000000 }, 331 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000000 }, 332 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000000 }, 333 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000000 }, 334 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000000 }, 335 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000000 }, 336 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000000 }, 337 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000000 }, 338 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000000 }, 339 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000000 }, 340 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000000 }, 341 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000000 }, 342 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000000 }, 343 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000000 }, 344 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000000 }, 345 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000000 }, 346 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000000 }, 347 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000000 }, 348 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000000 }, 349 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000001 }, 350 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E508 }, { 0xA3, 0x23000012 }, { 0xBB, 0x00000400 }, { 0xBD, 0x00000000 }, 351 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000000 }, 352 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000000 }, 353 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000000 }, 354 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000000 }, 355 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000000 }, 356 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000000 }, 357 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000000 }, 358 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000000 }, 359 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000000 }, 360 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000000 }, 361 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000000 }, 362 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000000 }, 363 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000000 }, 364 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000000 }, 365 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000000 }, 366 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000000 }, 367 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000000 }, 368 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000000 }, 369 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000000 }, 370 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000000 }, 371 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000000 }, 372 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000001 }, 373 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E508 }, { 0xA3, 0x23000012 }, { 0xBB, 0x00000800 }, { 0xBD, 0x00000000 }, 374 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000000 }, 375 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000000 }, 376 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000000 }, 377 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000000 }, 378 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000000 }, 379 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000000 }, 380 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000000 }, 381 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000000 }, 382 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000000 }, 383 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000000 }, 384 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000000 }, 385 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000000 }, 386 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000000 }, 387 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000000 }, 388 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000000 }, 389 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000000 }, 390 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000000 }, 391 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000000 }, 392 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000000 }, 393 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000000 }, 394 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000000 }, 395 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000001 }, 396 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E508 }, { 0xA3, 0x23000012 }, { 0xBB, 0x00000C00 }, { 0xBD, 0x00000000 }, 397 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000000 }, 398 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000000 }, 399 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000000 }, 400 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000000 }, 401 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000000 }, 402 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000000 }, 403 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000000 }, 404 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000000 }, 405 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000000 }, 406 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000000 }, 407 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000000 }, 408 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000000 }, 409 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000000 }, 410 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000000 }, 411 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000000 }, 412 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000000 }, 413 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000000 }, 414 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000000 }, 415 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000000 }, 416 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000000 }, 417 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000001 }, 418 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E504 }, { 0xA3, 0x23000012 }, { 0xBB, 0x00000000 }, { 0xBD, 0x00000000 }, 419 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000001 }, 420 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000001 }, 421 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E504 }, { 0xA3, 0x23000012 }, { 0xBB, 0x00000000 }, { 0xBD, 0x00000000 }, 422 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000001 }, 423 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000001 }, 424 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x20000000 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x200008E8 }, 425 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x20000000 }, { 0xA3, 0x23000012 }, { 0xBB, 0x200008E8 }, { 0xBD, 0x00000000 }, 426 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0xE000EDF0 }, { 0xA3, 0x23000012 }, { 0xBB, 0xA05F0003 }, { 0xBD, 0x00000000 }, 427 | { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0xE000EDFC }, { 0xA3, 0x23000012 }, { 0xBB, 0x01000001 }, { 0xBD, 0x00000000 }, 428 | { 0x81, 0x0000001E }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0xE000ED0C }, { 0xA3, 0x23000012 }, { 0xBB, 0x05FA0004 }, 429 | { 0xBD, 0x00000000 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0xE000EDF0 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, 430 | { 0xBD, 0x03030003 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0xE000EDF0 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, 431 | { 0xBD, 0x00030003 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0xE000EDF0 }, { 0xA3, 0x23000012 }, { 0xBB, 0xA05F0003 }, 432 | { 0xBD, 0x00000000 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0xE000EDFC }, { 0xA3, 0x23000012 }, { 0xBB, 0x01000000 }, 433 | { 0xBD, 0x00000000 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0xE000EDF0 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, 434 | { 0xBD, 0x00030003 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0xE000EDF0 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, 435 | { 0xBD, 0x00030003 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0xE000EDF0 }, { 0xA3, 0x23000012 }, { 0xB1, 0x00000010 }, 436 | { 0x8B, 0x00000000 }, { 0xB7, 0x00000000 }, { 0xBD, 0xFFFFFFFF }, { 0x8B, 0x00000001 }, { 0xB7, 0x00000000 }, { 0xBD, 0xFFFFFFFF }, 437 | { 0x8B, 0x00000002 }, { 0xB7, 0x00000000 }, { 0xBD, 0xFFFFFFFF }, { 0x8B, 0x00000003 }, { 0xB7, 0x00000000 }, { 0xBD, 0xFFFFFFFF }, 438 | { 0x8B, 0x00000004 }, { 0xB7, 0x00000000 }, { 0xBD, 0xFFFFFFFF }, { 0x8B, 0x00000005 }, { 0xB7, 0x00000000 }, { 0xBD, 0xFFFFFFFF }, 439 | { 0x8B, 0x00000006 }, { 0xB7, 0x00000000 }, { 0xBD, 0xFFFFFFFF }, { 0x8B, 0x00000007 }, { 0xB7, 0x00000000 }, { 0xBD, 0xFFFFFFFF }, 440 | { 0x8B, 0x00000008 }, { 0xB7, 0x00000000 }, { 0xBD, 0xFFFFFFFF }, { 0x8B, 0x00000009 }, { 0xB7, 0x00000000 }, { 0xBD, 0xFFFFFFFF }, 441 | { 0x8B, 0x0000000A }, { 0xB7, 0x00000000 }, { 0xBD, 0xFFFFFFFF }, { 0x8B, 0x0000000B }, { 0xB7, 0x00000000 }, { 0xBD, 0xFFFFFFFF }, 442 | { 0x8B, 0x0000000C }, { 0xB7, 0x00000000 }, { 0xBD, 0xFFFFFFFF }, { 0x8B, 0x0000000E }, { 0xB7, 0x00000000 }, { 0xBD, 0xFFFFFFFF }, 443 | { 0x8B, 0x0000000F }, { 0xB7, 0x00000000 }, { 0xBD, 0xFFFFFFFE }, { 0x8B, 0x00000010 }, { 0xB7, 0x00000000 }, { 0xBD, 0xC1000000 }, 444 | { 0x8B, 0x00000011 }, { 0xB7, 0x00000000 }, { 0xBD, 0xFFFFFFFC }, { 0x8B, 0x00000012 }, { 0xB7, 0x00000000 }, { 0xBD, 0xFFFFFFFC }, 445 | { 0x8B, 0x00000014 }, { 0xB7, 0x00000000 }, { 0xBD, 0x00000000 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0xE0002000 }, 446 | { 0xA3, 0x23000012 }, { 0xBB, 0x00000003 }, { 0xBD, 0x00000000 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0xE000EDFC }, 447 | { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x01000000 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0xE0001000 }, 448 | { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x20000000 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0xE0001000 }, 449 | { 0xA3, 0x23000012 }, { 0xBB, 0x20000001 }, { 0xBD, 0x00000000 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E504 }, 450 | { 0xA3, 0x23000012 }, { 0xBB, 0x00000000 }, { 0xBD, 0x00000000 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, 451 | { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000001 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, 452 | { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000001 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x10000010 }, 453 | { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000400 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x10000014 }, 454 | { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000100 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x40000524 }, 455 | { 0xA3, 0x23000012 }, { 0xBB, 0x0000000F }, { 0xBD, 0x00000000 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, 456 | { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000001 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E504 }, 457 | { 0xA3, 0x23000012 }, { 0xBB, 0x00000001 }, { 0xBD, 0x00000000 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, 458 | { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000001 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x4001E400 }, 459 | { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000001 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x20000000 }, 460 | { 0xA3, 0x23000012 }, { 0xBB, 0x200008E8 }, { 0xBB, 0x20000341 }, { 0xBB, 0x20000353 }, { 0xBB, 0x20000355 }, { 0xBB, 0x00000000 }, 461 | { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, 462 | { 0xBB, 0x20000357 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x20000359 }, { 0xBB, 0x2000035B }, { 0xBB, 0x2000035D }, 463 | { 0xBB, 0x2000035D }, { 0xBB, 0x2000035D }, { 0xBB, 0x2000035D }, { 0xBB, 0x2000035D }, { 0xBB, 0x00000000 }, { 0xBB, 0x2000035D }, 464 | { 0xBB, 0x2000035D }, { 0xBB, 0x2000035D }, { 0xBB, 0x2000035D }, { 0xBB, 0x2000035D }, { 0xBB, 0x2000035D }, { 0xBB, 0x2000035D }, 465 | { 0xBB, 0x2000035D }, { 0xBB, 0x2000035D }, { 0xBB, 0x2000035D }, { 0xBD, 0x00000000 }, { 0xB1, 0x00000000 }, { 0x8B, 0x20000080 }, 466 | { 0xBB, 0x2000035D }, { 0xBB, 0x2000035D }, { 0xBB, 0x2000035D }, { 0xBB, 0x2000035D }, { 0xBB, 0x2000035D }, { 0xBB, 0x2000035D }, 467 | { 0xBB, 0x2000035D }, { 0xBB, 0x2000035D }, { 0xBB, 0x2000035D }, { 0xBB, 0x2000035D }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, 468 | { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0xF802F000 }, { 0xBB, 0xF840F000 }, 469 | { 0xBB, 0xC830A00C }, { 0xBB, 0x18243808 }, { 0xBB, 0x46A2182D }, { 0xBB, 0x46AB1E67 }, { 0xBB, 0x465D4654 }, { 0xBB, 0xD10142AC }, 470 | { 0xBB, 0xF832F000 }, { 0xBB, 0x3E0F467E }, { 0xBB, 0x46B6CC0F }, { 0xBB, 0x42332601 }, { 0xBB, 0x1AFBD000 }, { 0xBB, 0x46AB46A2 }, 471 | { 0xBB, 0x47184333 }, { 0xBB, 0x00000368 }, { 0xBB, 0x00000388 }, { 0xBB, 0xD3023A10 }, { 0xBB, 0xC178C878 }, { 0xBB, 0x0752D8FA }, 472 | { 0xBB, 0xC830D301 }, { 0xBB, 0xD501C130 }, { 0xBB, 0x600C6804 }, { 0xBB, 0x00004770 }, { 0xBB, 0x24002300 }, { 0xBB, 0x26002500 }, 473 | { 0xBB, 0xD3013A10 }, { 0xBB, 0xD8FBC178 }, { 0xBB, 0xD3000752 }, { 0xBB, 0xD500C130 }, { 0xBB, 0x4770600B }, { 0xBB, 0x46C0B51F }, 474 | { 0xBB, 0xBD1F46C0 }, { 0xBB, 0xBD10B510 }, { 0xBB, 0xF94CF000 }, { 0xBB, 0xF7FF4611 }, { 0xBB, 0xF000FFF5 }, { 0xBB, 0xF000F825 }, 475 | { 0xBB, 0xB403F964 }, { 0xBB, 0xFFF2F7FF }, { 0xBB, 0xF000BC03 }, { 0xBB, 0x0000F969 }, { 0xBB, 0x4605B570 }, { 0xBB, 0x4616460C }, 476 | { 0xBB, 0xCC0FE002 }, { 0xBB, 0x3E10C50F }, { 0xBB, 0xD2FA2E10 }, { 0xBB, 0xD3022E08 }, { 0xBB, 0xC503CC03 }, { 0xBB, 0x2E043E08 }, 477 | { 0xBB, 0xCC01D307 }, { 0xBB, 0x1F36C501 }, { 0xBB, 0x7821E003 }, { 0xBB, 0x1C647029 }, { 0xBB, 0x1E761C6D }, { 0xBB, 0xBD70D2F9 }, 478 | { 0xBB, 0x49162001 }, { 0xBB, 0x49166008 }, { 0xBB, 0xBF006048 }, { 0xBB, 0x68004815 }, { 0xBB, 0xD0FB2800 }, { 0xBB, 0x68024814 }, 479 | { 0xBB, 0x48154914 }, { 0xBB, 0xF7FF6800 }, { 0xBB, 0x2000FFD3 }, { 0xBB, 0x6048490E }, { 0xBB, 0x480EBF00 }, { 0xBB, 0x28006800 }, 480 | { 0xBB, 0x4810D0FB }, { 0xBB, 0x28016980 }, { 0xBB, 0x480BD10B }, { 0xBB, 0x490B6802 }, { 0xBB, 0x6800480B }, { 0xBB, 0xF8CEF000 }, 481 | { 0xBB, 0xD0022800 }, { 0xBB, 0x49032000 }, { 0xBB, 0x20016008 }, { 0xBB, 0x60084908 }, { 0xBB, 0xE7FEBF00 }, { 0xBB, 0x20000C04 }, 482 | { 0xBB, 0x4001E500 }, { 0xBB, 0x4001E400 }, { 0xBB, 0x20000C14 }, { 0xBB, 0x20001000 }, { 0xBB, 0x20000C10 }, { 0xBB, 0x20000C00 }, 483 | { 0xBB, 0x20000C00 }, { 0xBB, 0x4841B500 }, { 0xBB, 0xB28069C0 }, { 0xBB, 0x0003381D }, { 0xBB, 0xF90DF000 }, { 0xBB, 0x290D1718 }, 484 | { 0xBB, 0x29292929 }, { 0xBB, 0x2523290F }, { 0xBB, 0x1B192929 }, { 0xBB, 0x2113111F }, { 0xBB, 0x27291529 }, { 0xBB, 0x2001291D }, 485 | { 0xBB, 0x2001BD00 }, { 0xBB, 0x2001E7FC }, { 0xBB, 0x2001E7FA }, { 0xBB, 0x2000E7F8 }, { 0xBB, 0x2001E7F6 }, { 0xBB, 0x2001E7F4 }, 486 | { 0xBB, 0x2001E7F2 }, { 0xBB, 0x2001E7F0 }, { 0xBB, 0x2001E7EE }, { 0xBB, 0x2000E7EC }, { 0xBB, 0x2001E7EA }, { 0xBB, 0x2001E7E8 }, 487 | { 0xBB, 0x2001E7E6 }, { 0xBB, 0x2001E7E4 }, { 0xBB, 0xB500E7E2 }, { 0xBB, 0x69C04827 }, { 0xBB, 0x381DB280 }, { 0xBB, 0xF0000003 }, 488 | { 0xBB, 0x1718F8DA }, { 0xBB, 0x2929290D }, { 0xBB, 0x290F2929 }, { 0xBB, 0x29292523 }, { 0xBB, 0x111F1B19 }, { 0xBB, 0x15292113 }, 489 | { 0xBB, 0x291D2729 }, { 0xBB, 0xBD002001 }, { 0xBB, 0xE7FC2001 }, { 0xBB, 0xE7FA2000 }, { 0xBB, 0xE7F82000 }, { 0xBB, 0xE7F62001 }, 490 | { 0xBB, 0xE7F42001 }, { 0xBB, 0xE7F22000 }, { 0xBB, 0xE7F02000 }, { 0xBB, 0xE7EE2000 }, { 0xBB, 0xE7EC2000 }, { 0xBB, 0xE7EA2001 }, 491 | { 0xBB, 0xE7E82001 }, { 0xBB, 0xE7E62001 }, { 0xBB, 0xE7E42001 }, { 0xBB, 0xE7E22000 }, { 0xBB, 0xF7FFB510 }, { 0xBB, 0x2800FFCA }, 492 | { 0xBB, 0x480DD005 }, { 0xBB, 0x6048490D }, { 0xBB, 0x490D13C8 }, { 0xBB, 0xF7FF6188 }, { 0xBB, 0x2800FF8D }, { 0xBB, 0x2001D009 }, 493 | { 0xBB, 0x07092105 }, { 0xBB, 0x02122207 }, { 0xBB, 0x67C81889 }, { 0xBB, 0x490707C0 }, { 0xBB, 0xBD1060C8 }, { 0xBB, 0x49074806 }, 494 | { 0xBB, 0x47706008 }, { 0xBB, 0x10000040 }, { 0xBB, 0xC007FFDF }, { 0xBB, 0x40000500 }, { 0xBB, 0x40006C00 }, { 0xBB, 0x50000500 }, 495 | { 0xBB, 0x00F42400 }, { 0xBB, 0x20000800 }, { 0xBB, 0x6802480A }, { 0xBB, 0x430A210F }, { 0xBB, 0x48096002 }, { 0xBB, 0x48094780 }, 496 | { 0xBB, 0xE7FE4700 }, { 0xBB, 0xE7FEE7FE }, { 0xBB, 0xE7FEE7FE }, { 0xBB, 0x0000E7FE }, { 0xBB, 0x49064805 }, { 0xBB, 0x4B064A04 }, 497 | { 0xBB, 0x00004770 }, { 0xBB, 0x40000524 }, { 0xBB, 0x200002E9 }, { 0xBB, 0x200000C1 }, { 0xBB, 0x20000868 }, { 0xBB, 0x200008E8 }, 498 | { 0xBB, 0x20000868 }, { 0xBB, 0xB5104603 }, { 0xBB, 0x079B430B }, { 0xBB, 0x2A04D10F }, { 0xBB, 0xC808D30D }, { 0xBB, 0x1F12C910 }, 499 | { 0xBB, 0xD0F842A3 }, { 0xBB, 0xBA21BA18 }, { 0xBB, 0xD9014288 }, { 0xBB, 0xBD102001 }, { 0xBB, 0x43C02000 }, { 0xBB, 0x2A00BD10 }, 500 | { 0xBB, 0x07D3D003 }, { 0xBB, 0x1C52D003 }, { 0xBB, 0x2000E007 }, { 0xBB, 0x7803BD10 }, { 0xBB, 0x1C40780C }, { 0xBB, 0x1B1B1C49 }, 501 | { 0xBB, 0x7803D107 }, { 0xBB, 0x1C40780C }, { 0xBB, 0x1B1B1C49 }, { 0xBB, 0x1E92D101 }, { 0xBB, 0x4618D1F1 }, { 0xBB, 0x4770BD10 }, 502 | { 0xBB, 0x47704770 }, { 0xBB, 0xF0004675 }, { 0xBB, 0x46AEF823 }, { 0xBB, 0x46690005 }, { 0xBB, 0x08C04653 }, { 0xBB, 0x468500C0 }, 503 | { 0xBB, 0xB520B018 }, { 0xBB, 0xFFB0F7FF }, { 0xBD, 0x00000000 }, { 0xB1, 0x00000000 }, { 0x8B, 0x20000400 }, { 0xBB, 0x2700BC60 }, 504 | { 0xBB, 0x46B60849 }, { 0xBB, 0xC5C02600 }, { 0xBB, 0xC5C0C5C0 }, { 0xBB, 0xC5C0C5C0 }, { 0xBB, 0xC5C0C5C0 }, { 0xBB, 0x3D40C5C0 }, 505 | { 0xBB, 0x468D0049 }, { 0xBB, 0x46044770 }, { 0xBB, 0x46C046C0 }, { 0xBB, 0xF7FF4620 }, { 0xBB, 0x0000FE96 }, { 0xBB, 0x47704800 }, 506 | { 0xBB, 0x20000804 }, { 0xBB, 0x20184901 }, { 0xBB, 0xE7FEBEAB }, { 0xBB, 0x00020026 }, { 0xBB, 0xB4304770 }, { 0xBB, 0x1E644674 }, 507 | { 0xBB, 0x1C647825 }, { 0xBB, 0xD30442AB }, { 0xBB, 0x005B5D63 }, { 0xBB, 0xBC3018E3 }, { 0xBB, 0x461D4718 }, { 0xBB, 0x0000E7F8 }, 508 | { 0xBB, 0x20000484 }, { 0xBB, 0x20000800 }, { 0xBB, 0x00000004 }, { 0xBB, 0x20000104 }, { 0xBB, 0x20000488 }, { 0xBB, 0x20000804 }, 509 | { 0xBB, 0x000000E4 }, { 0xBB, 0x20000120 }, { 0xBB, 0x00F42400 }, { 0xBD, 0x00000000 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, 510 | { 0x8B, 0x20000C10 }, { 0xA3, 0x23000012 }, { 0xBB, 0xFFFFFFFF }, { 0xBD, 0x00000000 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, 511 | { 0x8B, 0x4001E504 }, { 0xA3, 0x23000012 }, { 0xBB, 0x00000000 }, { 0xBD, 0x00000000 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, 512 | { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000001 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, 513 | { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000001 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, 514 | { 0x8B, 0x4001E504 }, { 0xA3, 0x23000012 }, { 0xBB, 0x00000000 }, { 0xBD, 0x00000000 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, 515 | { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000001 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, 516 | { 0x8B, 0x4001E400 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00000001 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, 517 | { 0x8B, 0x20000000 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0x9F, 0x200008E8 }, { 0x9F, 0x20000341 }, { 0x9F, 0x20000353 }, 518 | { 0x9F, 0x20000355 }, { 0x9F, 0x00000000 }, { 0x9F, 0x00000000 }, { 0x9F, 0x00000000 }, { 0x9F, 0x00000000 }, { 0x9F, 0x00000000 }, 519 | { 0x9F, 0x00000000 }, { 0x9F, 0x00000000 }, { 0x9F, 0x20000357 }, { 0x9F, 0x00000000 }, { 0x9F, 0x00000000 }, { 0x9F, 0x20000359 }, 520 | { 0x9F, 0x2000035B }, { 0x9F, 0x2000035D }, { 0x9F, 0x2000035D }, { 0x9F, 0x2000035D }, { 0x9F, 0x2000035D }, { 0x9F, 0x2000035D }, 521 | { 0x9F, 0x00000000 }, { 0x9F, 0x2000035D }, { 0x9F, 0x2000035D }, { 0x9F, 0x2000035D }, { 0x9F, 0x2000035D }, { 0x9F, 0x2000035D }, 522 | { 0x9F, 0x2000035D }, { 0x9F, 0x2000035D }, { 0x9F, 0x2000035D }, { 0x9F, 0x2000035D }, { 0x9F, 0x2000035D }, { 0x9F, 0x2000035D }, 523 | { 0x9F, 0x2000035D }, { 0x9F, 0x2000035D }, { 0x9F, 0x2000035D }, { 0x9F, 0x2000035D }, { 0x9F, 0x2000035D }, { 0x9F, 0x2000035D }, 524 | { 0x9F, 0x2000035D }, { 0x9F, 0x2000035D }, { 0x9F, 0x2000035D }, { 0x9F, 0x00000000 }, { 0x9F, 0x00000000 }, { 0x9F, 0x00000000 }, 525 | { 0x9F, 0x00000000 }, { 0x9F, 0x00000000 }, { 0x9F, 0x00000000 }, { 0x9F, 0xF802F000 }, { 0x9F, 0xF840F000 }, { 0x9F, 0xC830A00C }, 526 | { 0x9F, 0x18243808 }, { 0x9F, 0x46A2182D }, { 0x9F, 0x46AB1E67 }, { 0x9F, 0x465D4654 }, { 0x9F, 0xD10142AC }, { 0x9F, 0xF832F000 }, 527 | { 0x9F, 0x3E0F467E }, { 0x9F, 0x46B6CC0F }, { 0x9F, 0x42332601 }, { 0x9F, 0x1AFBD000 }, { 0x9F, 0x46AB46A2 }, { 0x9F, 0x47184333 }, 528 | { 0x9F, 0x00000368 }, { 0x9F, 0x00000388 }, { 0x9F, 0xD3023A10 }, { 0x9F, 0xC178C878 }, { 0x9F, 0x0752D8FA }, { 0x9F, 0xC830D301 }, 529 | { 0x9F, 0xD501C130 }, { 0x9F, 0x600C6804 }, { 0x9F, 0x00004770 }, { 0x9F, 0x24002300 }, { 0x9F, 0x26002500 }, { 0x9F, 0xD3013A10 }, 530 | { 0x9F, 0xD8FBC178 }, { 0x9F, 0xD3000752 }, { 0x9F, 0xD500C130 }, { 0x9F, 0x4770600B }, { 0x9F, 0x46C0B51F }, { 0x9F, 0xBD1F46C0 }, 531 | { 0x9F, 0xBD10B510 }, { 0x9F, 0xF94CF000 }, { 0x9F, 0xF7FF4611 }, { 0x9F, 0xF000FFF5 }, { 0x9F, 0xF000F825 }, { 0x9F, 0xB403F964 }, 532 | { 0x9F, 0xFFF2F7FF }, { 0x9F, 0xF000BC03 }, { 0x9F, 0x0000F969 }, { 0x9F, 0x4605B570 }, { 0x9F, 0x4616460C }, { 0x9F, 0xCC0FE002 }, 533 | { 0x9F, 0x3E10C50F }, { 0x9F, 0xD2FA2E10 }, { 0x9F, 0xD3022E08 }, { 0x9F, 0xC503CC03 }, { 0x9F, 0x2E043E08 }, { 0x9F, 0xCC01D307 }, 534 | { 0x9F, 0x1F36C501 }, { 0x9F, 0x7821E003 }, { 0x9F, 0x1C647029 }, { 0x9F, 0x1E761C6D }, { 0x9F, 0xBD70D2F9 }, { 0x9F, 0x49162001 }, 535 | { 0x9F, 0x49166008 }, { 0x9F, 0xBF006048 }, { 0x9F, 0x68004815 }, { 0x9F, 0xD0FB2800 }, { 0x9F, 0x68024814 }, { 0x9F, 0x48154914 }, 536 | { 0x9F, 0xF7FF6800 }, { 0x9F, 0x2000FFD3 }, { 0x9F, 0x6048490E }, { 0x9F, 0x480EBF00 }, { 0x9F, 0x28006800 }, { 0x9F, 0x4810D0FB }, 537 | { 0x9F, 0x28016980 }, { 0x9F, 0x480BD10B }, { 0x9F, 0x490B6802 }, { 0x9F, 0x6800480B }, { 0x9F, 0xF8CEF000 }, { 0x9F, 0xD0022800 }, 538 | { 0x9F, 0x49032000 }, { 0x9F, 0x20016008 }, { 0x9F, 0x60084908 }, { 0x9F, 0xE7FEBF00 }, { 0x9F, 0x20000C04 }, { 0x9F, 0x4001E500 }, 539 | { 0x9F, 0x4001E400 }, { 0x9F, 0x20000C14 }, { 0x9F, 0x20001000 }, { 0x9F, 0x20000C10 }, { 0x9F, 0x20000C00 }, { 0x9F, 0x20000C00 }, 540 | { 0x9F, 0x4841B500 }, { 0x9F, 0xB28069C0 }, { 0x9F, 0x0003381D }, { 0x9F, 0xF90DF000 }, { 0x9F, 0x290D1718 }, { 0x9F, 0x29292929 }, 541 | { 0x9F, 0x2523290F }, { 0x9F, 0x1B192929 }, { 0x9F, 0x2113111F }, { 0x9F, 0x27291529 }, { 0x9F, 0x2001291D }, { 0x9F, 0x2001BD00 }, 542 | { 0x9F, 0x2001E7FC }, { 0x9F, 0x2001E7FA }, { 0x9F, 0x2000E7F8 }, { 0x9F, 0x2001E7F6 }, { 0x9F, 0x2001E7F4 }, { 0x9F, 0x2001E7F2 }, 543 | { 0x9F, 0x2001E7F0 }, { 0x9F, 0x2001E7EE }, { 0x9F, 0x2000E7EC }, { 0x9F, 0x2001E7EA }, { 0x9F, 0x2001E7E8 }, { 0x9F, 0x2001E7E6 }, 544 | { 0x9F, 0x2001E7E4 }, { 0x9F, 0xB500E7E2 }, { 0x9F, 0x69C04827 }, { 0x9F, 0x381DB280 }, { 0x9F, 0xF0000003 }, { 0x9F, 0x1718F8DA }, 545 | { 0x9F, 0x2929290D }, { 0x9F, 0x290F2929 }, { 0x9F, 0x29292523 }, { 0x9F, 0x111F1B19 }, { 0x9F, 0x15292113 }, { 0x9F, 0x291D2729 }, 546 | { 0x9F, 0xBD002001 }, { 0x9F, 0xE7FC2001 }, { 0x9F, 0xE7FA2000 }, { 0x9F, 0xE7F82000 }, { 0x9F, 0xE7F62001 }, { 0x9F, 0xE7F42001 }, 547 | { 0x9F, 0xE7F22000 }, { 0x9F, 0xE7F02000 }, { 0x9F, 0xE7EE2000 }, { 0x9F, 0xE7EC2000 }, { 0x9F, 0xE7EA2001 }, { 0x9F, 0xE7E82001 }, 548 | { 0x9F, 0xE7E62001 }, { 0x9F, 0xE7E42001 }, { 0x9F, 0xE7E22000 }, { 0x9F, 0xF7FFB510 }, { 0x9F, 0x2800FFCA }, { 0x9F, 0x480DD005 }, 549 | { 0x9F, 0x6048490D }, { 0x9F, 0x490D13C8 }, { 0x9F, 0xF7FF6188 }, { 0x9F, 0x2800FF8D }, { 0x9F, 0x2001D009 }, { 0x9F, 0x07092105 }, 550 | { 0x9F, 0x02122207 }, { 0x9F, 0x67C81889 }, { 0x9F, 0x490707C0 }, { 0x9F, 0xBD1060C8 }, { 0x9F, 0x49074806 }, { 0x9F, 0x47706008 }, 551 | { 0x9F, 0x10000040 }, { 0x9F, 0xC007FFDF }, { 0x9F, 0x40000500 }, { 0x9F, 0x40006C00 }, { 0x9F, 0x50000500 }, { 0x9F, 0x00F42400 }, 552 | { 0x9F, 0x20000800 }, { 0x9F, 0x6802480A }, { 0x9F, 0x430A210F }, { 0x9F, 0x48096002 }, { 0x9F, 0x48094780 }, { 0x9F, 0xE7FE4700 }, 553 | { 0x9F, 0xE7FEE7FE }, { 0x9F, 0xE7FEE7FE }, { 0x9F, 0x0000E7FE }, { 0x9F, 0x49064805 }, { 0x9F, 0x4B064A04 }, { 0x9F, 0x00004770 }, 554 | { 0x9F, 0x40000524 }, { 0x9F, 0x200002E9 }, { 0x9F, 0x200000C1 }, { 0x9F, 0x20000868 }, { 0x9F, 0x200008E8 }, { 0x9F, 0x20000868 }, 555 | { 0x9F, 0xB5104603 }, { 0x9F, 0x079B430B }, { 0x9F, 0x2A04D10F }, { 0x9F, 0xC808D30D }, { 0x9F, 0x1F12C910 }, { 0x9F, 0xD0F842A3 }, 556 | { 0x9F, 0xBA21BA18 }, { 0x9F, 0xD9014288 }, { 0x9F, 0xBD102001 }, { 0x9F, 0x43C02000 }, { 0x9F, 0x2A00BD10 }, { 0x9F, 0x07D3D003 }, 557 | { 0x9F, 0x1C52D003 }, { 0x9F, 0x2000E007 }, { 0x9F, 0x7803BD10 }, { 0x9F, 0x1C40780C }, { 0x9F, 0x1B1B1C49 }, { 0x9F, 0x7803D107 }, 558 | { 0x9F, 0x1C40780C }, { 0x9F, 0x1B1B1C49 }, { 0x9F, 0x1E92D101 }, { 0x9F, 0x4618D1F1 }, { 0x9F, 0x4770BD10 }, { 0x9F, 0x47704770 }, 559 | { 0x9F, 0xF0004675 }, { 0x9F, 0x46AEF823 }, { 0x9F, 0x46690005 }, { 0x9F, 0x08C04653 }, { 0x9F, 0x468500C0 }, { 0x9F, 0xB520B018 }, 560 | { 0xBD, 0xFFB0F7FF }, { 0xB1, 0x00000000 }, { 0x8B, 0x20000400 }, { 0x9F, 0x00000000 }, { 0x9F, 0x2700BC60 }, { 0x9F, 0x46B60849 }, 561 | { 0x9F, 0xC5C02600 }, { 0x9F, 0xC5C0C5C0 }, { 0x9F, 0xC5C0C5C0 }, { 0x9F, 0xC5C0C5C0 }, { 0x9F, 0x3D40C5C0 }, { 0x9F, 0x468D0049 }, 562 | { 0x9F, 0x46044770 }, { 0x9F, 0x46C046C0 }, { 0x9F, 0xF7FF4620 }, { 0x9F, 0x0000FE96 }, { 0x9F, 0x47704800 }, { 0x9F, 0x20000804 }, 563 | { 0x9F, 0x20184901 }, { 0x9F, 0xE7FEBEAB }, { 0x9F, 0x00020026 }, { 0x9F, 0xB4304770 }, { 0x9F, 0x1E644674 }, { 0x9F, 0x1C647825 }, 564 | { 0x9F, 0xD30442AB }, { 0x9F, 0x005B5D63 }, { 0x9F, 0xBC3018E3 }, { 0x9F, 0x461D4718 }, { 0x9F, 0x0000E7F8 }, { 0x9F, 0x20000484 }, 565 | { 0x9F, 0x20000800 }, { 0x9F, 0x00000004 }, { 0x9F, 0x20000104 }, { 0x9F, 0x20000488 }, { 0x9F, 0x20000804 }, { 0x9F, 0x000000E4 }, 566 | { 0x9F, 0x20000120 }, { 0x9F, 0x00F42400 }, { 0x9F, 0xFFFF8000 }, { 0x9F, 0xFE7F0000 }, { 0x9F, 0x0026FFFF }, { 0x9F, 0x8009EFEF }, 567 | { 0x9F, 0x00007FFF }, { 0x9F, 0x0080FFFF }, { 0x9F, 0xFFDB0008 }, { 0x9F, 0xFDFA3080 }, { 0x9F, 0x7B760400 }, { 0x9F, 0xFFFF0404 }, 568 | { 0x9F, 0x02107EBF }, { 0x9F, 0x0000AF5F }, { 0x9F, 0x0008BC93 }, { 0xBD, 0x1210FFDF }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, 569 | { 0x8B, 0x20000C00 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0x9F, 0x00000001 }, { 0x9F, 0x00000000 }, { 0x9F, 0xFFFD0490 }, 570 | { 0x9F, 0xBF8F2840 }, { 0x9F, 0xFFFFFFFF }, { 0x9F, 0x00000C30 }, { 0x9F, 0x2200F7DF }, { 0x9F, 0x5000FEBF }, { 0x9F, 0xFFFB0000 }, 571 | { 0x9F, 0xFFFB0200 }, { 0x9F, 0xFF7B4C20 }, { 0x9F, 0xFFFA0A00 }, { 0x9F, 0x0102FFD7 }, { 0x9F, 0x0202F7DF }, { 0x9F, 0x0002FFDE }, 572 | { 0xBD, 0x1048D6D7 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x20000C00 }, { 0xA3, 0x23000012 }, { 0xBB, 0x00000000 }, 573 | { 0xBD, 0x00000000 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x20000C04 }, { 0xA3, 0x23000012 }, { 0xBB, 0x00000000 }, 574 | { 0xBD, 0x00000000 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x20000C10 }, { 0xA3, 0x23000012 }, { 0xBB, 0x00000000 }, 575 | { 0xBD, 0x00000000 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x20000C14 }, { 0xA3, 0x23000012 }, { 0xBB, 0x00000C30 }, 576 | { 0xBD, 0x00000000 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x20000C18 }, { 0xA3, 0x23000012 }, { 0xBB, 0x00000000 }, 577 | { 0xBD, 0x00000000 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x20001000 }, { 0xA3, 0x23000012 }, { 0xBB, 0x20004000 }, 578 | { 0xBB, 0x00000439 }, { 0xBB, 0x00000475 }, { 0xBB, 0x00000477 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, 579 | { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000479 }, { 0xBB, 0x00000000 }, 580 | { 0xBB, 0x00000000 }, { 0xBB, 0x0000047B }, { 0xBB, 0x0000047D }, { 0xBB, 0x0000047F }, { 0xBB, 0x0000047F }, { 0xBB, 0x0000047F }, 581 | { 0xBB, 0x0000047F }, { 0xBB, 0x0000047F }, { 0xBB, 0x00000000 }, { 0xBB, 0x0000047F }, { 0xBB, 0x0000047F }, { 0xBB, 0x0000047F }, 582 | { 0xBB, 0x0000047F }, { 0xBB, 0x00000199 }, { 0xBB, 0x0000047F }, { 0xBB, 0x0000047F }, { 0xBB, 0x0000047F }, { 0xBB, 0x0000047F }, 583 | { 0xBB, 0x0000047F }, { 0xBD, 0x00000000 }, { 0xB1, 0x00000000 }, { 0x8B, 0x20001080 }, { 0xBB, 0x0000047F }, { 0xBB, 0x0000047F }, 584 | { 0xBB, 0x0000047F }, { 0xBB, 0x0000047F }, { 0xBB, 0x0000047F }, { 0xBB, 0x0000047F }, { 0xBB, 0x0000047F }, { 0xBB, 0x0000047F }, 585 | { 0xBB, 0x0000047F }, { 0xBB, 0x0000047F }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, 586 | { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x4C06B510 }, { 0xBB, 0x2B007823 }, { 0xBB, 0x4B05D107 }, { 0xBB, 0xD0022B00 }, 587 | { 0xBB, 0xE0004804 }, { 0xBB, 0x2301BF00 }, { 0xBB, 0xBD107023 }, { 0xBB, 0x2000044C }, { 0xBB, 0x00000000 }, { 0xBB, 0x000007D8 }, 588 | { 0xBB, 0x4B08B508 }, { 0xBB, 0xD0032B00 }, { 0xBB, 0x49084807 }, { 0xBB, 0xBF00E000 }, { 0xBB, 0x68034807 }, { 0xBB, 0xD0032B00 }, 589 | { 0xBB, 0x2B004B06 }, { 0xBB, 0x4798D000 }, { 0xBB, 0x46C0BD08 }, { 0xBB, 0x00000000 }, { 0xBB, 0x000007D8 }, { 0xBB, 0x20000450 }, 590 | { 0xBB, 0x20000448 }, { 0xBB, 0x00000000 }, { 0xBB, 0x2B004B16 }, { 0xBB, 0x4B14D100 }, { 0xBB, 0x2240469D }, { 0xBB, 0x1A9A0292 }, 591 | { 0xBB, 0x21004692 }, { 0xBB, 0x460F468B }, { 0xBB, 0x4A144813 }, { 0xBB, 0xF0001A12 }, { 0xBB, 0x4B0FF9D3 }, { 0xBB, 0xD0002B00 }, 592 | { 0xBB, 0x4B0E4798 }, { 0xBB, 0xD0002B00 }, { 0xBB, 0x20004798 }, { 0xBB, 0x00042100 }, { 0xBB, 0x480D000D }, { 0xBB, 0xD0022800 }, 593 | { 0xBB, 0xF000480C }, { 0xBB, 0xF000FAA7 }, { 0xBB, 0x0020F99B }, { 0xBB, 0xF0000029 }, { 0xBB, 0xF000F857 }, { 0xBB, 0x46C0F985 }, 594 | { 0xBB, 0x00080000 }, { 0xBB, 0x20004000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x2000044C }, { 0xBB, 0x2000046C }, 595 | { 0xBB, 0x000006B5 }, { 0xBB, 0x000006C5 }, { 0xBB, 0x22A24B1C }, { 0xBB, 0x58990052 }, { 0xBB, 0x2900B510 }, { 0xBB, 0x21C1D021 }, 596 | { 0xBB, 0x58590089 }, { 0xBB, 0xD51C0388 }, { 0xBB, 0x50992100 }, { 0xBB, 0x58994A16 }, { 0xBB, 0x31FF3101 }, { 0xBB, 0x4B155099 }, 597 | { 0xBB, 0x23FF781A }, { 0xBB, 0xD0114393 }, { 0xBB, 0x1C194A13 }, { 0xBB, 0x480F6013 }, { 0xBB, 0x4C0F4B12 }, { 0xBB, 0x5904781A }, 598 | { 0xBB, 0x2A001909 }, { 0xBB, 0x24A8D012 }, { 0xBB, 0x510100E4 }, { 0xBB, 0x404A2101 }, { 0xBB, 0xBD10701A }, { 0xBB, 0x22084B0A }, 599 | { 0xBB, 0x4806601A }, { 0xBB, 0x4C064B09 }, { 0xBB, 0x5904781A }, { 0xBB, 0x19092108 }, { 0xBB, 0xD1EC2A00 }, { 0xBB, 0x00E424A9 }, 600 | { 0xBB, 0xE7EB5101 }, { 0xBB, 0x4000A000 }, { 0xBB, 0x00000544 }, { 0xBB, 0x50000510 }, { 0xBB, 0x20000004 }, { 0xBB, 0x20000468 }, 601 | { 0xBB, 0x21E023A0 }, { 0xBB, 0x220005DB }, { 0xBB, 0x505A00C9 }, { 0xBB, 0x505A4945 }, { 0xBB, 0x00C921E1 }, { 0xBB, 0x4944505A }, 602 | { 0xBB, 0x21E2505A }, { 0xBB, 0x505A00C9 }, { 0xBB, 0x505A4942 }, { 0xBB, 0x00C921E3 }, { 0xBB, 0x4941505A }, { 0xBB, 0x22E4505A }, 603 | { 0xBB, 0x00D22101 }, { 0xBB, 0x4A3F5099 }, { 0xBB, 0x701121FF }, { 0xBB, 0x21804A3E }, { 0xBB, 0x50990049 }, { 0xBB, 0x4A3E493D }, 604 | { 0xBB, 0x00DB23A2 }, { 0xBB, 0x46C050D1 }, { 0xBB, 0x46C046C0 }, { 0xBB, 0x22014B3A }, { 0xBB, 0x493A601A }, { 0xBB, 0x00D222A2 }, 605 | { 0xBB, 0x46C05099 }, { 0xBB, 0x46C046C0 }, { 0xBB, 0x49384B37 }, { 0xBB, 0x00D222A2 }, { 0xBB, 0x4A335099 }, { 0xBB, 0x48374936 }, 606 | { 0xBB, 0x21A3505A }, { 0xBB, 0x505800C9 }, { 0xBB, 0x48364935 }, { 0xBB, 0x21A4505A }, { 0xBB, 0x505800C9 }, { 0xBB, 0x505A4934 }, 607 | { 0xBB, 0x210722A0 }, { 0xBB, 0x509900D2 }, { 0xBB, 0x22802380 }, { 0xBB, 0x210005DB }, { 0xBB, 0x50990052 }, { 0xBB, 0x60192101 }, 608 | { 0xBB, 0x29005899 }, { 0xBB, 0x4B2DD0FC }, { 0xBB, 0x2200492D }, { 0xBB, 0x21A1505A }, { 0xBB, 0x505A00C9 }, { 0xBB, 0x00D222A2 }, 609 | { 0xBB, 0x50992106 }, { 0xBB, 0x60DA2201 }, { 0xBB, 0x781A4B28 }, { 0xBB, 0x439323FF }, { 0xBB, 0x4B27D122 }, { 0xBB, 0x601A2208 }, 610 | { 0xBB, 0x00522284 }, { 0xBB, 0x21A84B21 }, { 0xBB, 0x505A00C9 }, { 0xBB, 0x21804A23 }, { 0xBB, 0x50990049 }, { 0xBB, 0x210022A9 }, 611 | { 0xBB, 0x509900D2 }, { 0xBB, 0x22C12180 }, { 0xBB, 0x00920289 }, { 0xBB, 0x23805099 }, { 0xBB, 0x05DB2201 }, { 0xBB, 0x4B1C679A }, 612 | { 0xBB, 0x00D22280 }, { 0xBB, 0xB662601A }, { 0xBB, 0x22014B14 }, { 0xBB, 0xE7FE601A }, { 0xBB, 0x60134A15 }, { 0xBB, 0x32FF1C5A }, 613 | { 0xBB, 0x46C0E7DC }, { 0xBB, 0x00000704 }, { 0xBB, 0x0000070C }, { 0xBB, 0x00000714 }, { 0xBB, 0x0000071C }, { 0xBB, 0x5000050C }, 614 | { 0xBB, 0x0000050C }, { 0xBB, 0x00021F03 }, { 0xBB, 0x40006000 }, { 0xBB, 0x00030803 }, { 0xBB, 0x4001F000 }, { 0xBB, 0x4000A140 }, 615 | { 0xBB, 0x00000514 }, { 0xBB, 0x4000A144 }, { 0xBB, 0x0000051C }, { 0xBB, 0x4000A148 }, { 0xBB, 0x00000524 }, { 0xBB, 0x4000A000 }, 616 | { 0xBB, 0x00000504 }, { 0xBB, 0x50000510 }, { 0xBB, 0x20000004 }, { 0xBB, 0x00000544 }, { 0xBB, 0xE000E100 }, { 0xBB, 0x4B024A01 }, 617 | { 0xBB, 0x4770601A }, { 0xBB, 0x00F42400 }, { 0xBB, 0x20000008 }, { 0xBB, 0x781B4B1B }, { 0xBB, 0xD0002B01 }, { 0xBB, 0x4B1A4770 }, 618 | { 0xBB, 0x071A681B }, { 0xBB, 0x4A19D1FA }, { 0xBB, 0x681223F0 }, { 0xBB, 0xD003401A }, { 0xBB, 0xD0012A10 }, { 0xBB, 0xD1032A30 }, 619 | { 0xBB, 0x68124A15 }, { 0xBB, 0xD010421A }, { 0xBB, 0x23F04A12 }, { 0xBB, 0x401A6812 }, { 0xBB, 0xD1E72A40 }, { 0xBB, 0x68124A10 }, 620 | { 0xBB, 0xD1E3421A }, { 0xBB, 0x228023C1 }, { 0xBB, 0x00DB2101 }, { 0xBB, 0x50D105D2 }, { 0xBB, 0x4A0CE7DC }, { 0xBB, 0x601A4B0C }, 621 | { 0xBD, 0x00000000 }, { 0xB1, 0x00000000 }, { 0x8B, 0x20001400 }, { 0xBB, 0x22804B0C }, { 0xBB, 0x601A0212 }, { 0xBB, 0x781B4B04 }, 622 | { 0xBB, 0xD1D12B01 }, { 0xBB, 0x681B4B03 }, { 0xBB, 0xD0DF071A }, { 0xBB, 0x46C0E7CC }, { 0xBB, 0xF0000FE0 }, { 0xBB, 0xF0000FE4 }, 623 | { 0xBB, 0xF0000FE8 }, { 0xBB, 0xF0000FEC }, { 0xBB, 0xC007FFDF }, { 0xBB, 0x40000504 }, { 0xBB, 0x40006C18 }, { 0xBB, 0x68024808 }, 624 | { 0xBB, 0x430A2103 }, { 0xBB, 0x49076002 }, { 0xBB, 0x4B084A07 }, { 0xBB, 0xDD031A9B }, { 0xBB, 0x58C83B04 }, { 0xBB, 0xDCFB50D0 }, 625 | { 0xBB, 0x47804805 }, { 0xBB, 0x47004805 }, { 0xBB, 0x40000524 }, { 0xBB, 0x000007E4 }, { 0xBB, 0x20000000 }, { 0xBB, 0x2000044C }, 626 | { 0xBB, 0x000003AD }, { 0xBB, 0x00000121 }, { 0xBB, 0xE7FEE7FE }, { 0xBB, 0xE7FEE7FE }, { 0xBB, 0xE7FEE7FE }, { 0xBB, 0x2100B510 }, 627 | { 0xBB, 0xF0001C04 }, { 0xBB, 0x4B04F889 }, { 0xBB, 0x6BC36818 }, { 0xBB, 0xD0002B00 }, { 0xBB, 0x1C204798 }, { 0xBB, 0xF98CF000 }, 628 | { 0xBB, 0x000007D4 }, { 0xBB, 0x4E0DB570 }, { 0xBB, 0x24004D0D }, { 0xBB, 0x10AD1BAD }, { 0xBB, 0x00A3D005 }, { 0xBB, 0x340158F3 }, 629 | { 0xBB, 0x42A54798 }, { 0xBB, 0xF000D1F9 }, { 0xBB, 0x4E08F97D }, { 0xBB, 0x24004D08 }, { 0xBB, 0x10AD1BAD }, { 0xBB, 0x00A3D005 }, 630 | { 0xBB, 0x340158F3 }, { 0xBB, 0x42A54798 }, { 0xBB, 0xBD70D1F9 }, { 0xBB, 0x2000043C }, { 0xBB, 0x2000043C }, { 0xBB, 0x2000043C }, 631 | { 0xBB, 0x20000444 }, { 0xBB, 0x0783B5F0 }, { 0xBB, 0x1E54D046 }, { 0xBB, 0xD0422A00 }, { 0xBB, 0x1C03B2CE }, { 0xBB, 0xE0032503 }, 632 | { 0xBB, 0x2C001E62 }, { 0xBB, 0x1C14D03B }, { 0xBB, 0x1E5A3301 }, { 0xBB, 0x422B7016 }, { 0xBB, 0x2C03D1F6 }, { 0xBB, 0x25FFD92B }, 633 | { 0xBB, 0x022A400D }, { 0xBB, 0x042A4315 }, { 0xBB, 0x2C0F4315 }, { 0xBB, 0x1C27D915 }, { 0xBB, 0x093F3F10 }, { 0xBB, 0x013A1C1E }, 634 | { 0xBB, 0x18B63610 }, { 0xBB, 0x60151C1A }, { 0xBB, 0x60956055 }, { 0xBB, 0x321060D5 }, { 0xBB, 0xD1F842B2 }, { 0xBB, 0x013F3701 }, 635 | { 0xBB, 0x19DB220F }, { 0xBB, 0x2C034014 }, { 0xBB, 0x1F27D90D }, { 0xBB, 0x00BA08BF }, { 0xBB, 0x18B61D1E }, { 0xBB, 0xC2201C1A }, 636 | { 0xBB, 0xD1FC42B2 }, { 0xBB, 0x00BF3701 }, { 0xBB, 0x19DB2203 }, { 0xBB, 0x2C004014 }, { 0xBB, 0x191CD005 }, { 0xBB, 0x7019B2C9 }, 637 | { 0xBB, 0x42A33301 }, { 0xBB, 0xBDF0D1FB }, { 0xBB, 0x1C031C14 }, { 0xBB, 0x46C0E7C5 }, { 0xBB, 0x4B03B508 }, { 0xBB, 0xD0022B00 }, 638 | { 0xBB, 0xF0004802 }, { 0xBB, 0xBD08F891 }, { 0xBB, 0x00000000 }, { 0xBB, 0x000006C5 }, { 0xBB, 0x465FB5F0 }, { 0xBB, 0x464D4656 }, 639 | { 0xBB, 0xB4F04644 }, { 0xBB, 0xB0854B40 }, { 0xBB, 0x9002681B }, { 0xBB, 0x33499301 }, { 0xBB, 0x930333FF }, { 0xBB, 0x98011C0F }, 640 | { 0xBB, 0x004921A4 }, { 0xBB, 0x46905842 }, { 0xBB, 0xD04A2A00 }, { 0xBB, 0x46819803 }, { 0xBB, 0x684E4641 }, { 0xBB, 0xD4411E74 }, 641 | { 0xBB, 0x00A34645 }, { 0xBB, 0x18ED3588 }, { 0xBB, 0x23C420C6 }, { 0xBB, 0x005B3601 }, { 0xBB, 0x00B60040 }, { 0xBB, 0x4682469B }, 642 | { 0xBB, 0x44C34446 }, { 0xBB, 0xE00844C2 }, { 0xBB, 0x33801C2B }, { 0xBB, 0x42BB681B }, { 0xBB, 0x3D04D005 }, { 0xBB, 0x3C013E04 }, 643 | { 0xBB, 0x2F00D328 }, { 0xBB, 0x4641D1F4 }, { 0xBB, 0x6833684A }, { 0xBB, 0x42A23A01 }, { 0xBB, 0x2200D02C }, { 0xBB, 0x2B006032 }, 644 | { 0xBB, 0x4640D0EF }, { 0xBB, 0x68404659 }, { 0xBB, 0x68092201 }, { 0xBB, 0x900040A2 }, { 0xBB, 0xD01D4211 }, { 0xBB, 0x68004650 }, 645 | { 0xBB, 0xD11D4210 }, { 0xBB, 0x68299802 }, { 0xBB, 0x46414798 }, { 0xBB, 0x9A006849 }, { 0xBB, 0xD1B84291 }, { 0xBB, 0x6812464A }, 646 | { 0xBB, 0xD1B44542 }, { 0xBB, 0x3E043D04 }, { 0xBB, 0xD2D63C01 }, { 0xBB, 0x2A004A15 }, { 0xBB, 0xB005D10D }, { 0xBB, 0x4690BC3C }, 647 | { 0xBB, 0x46A24699 }, { 0xBB, 0xBDF046AB }, { 0xBB, 0xE7E64798 }, { 0xBB, 0xE7D2604C }, { 0xBB, 0x47986828 }, { 0xBB, 0x4643E7E1 }, 648 | { 0xBB, 0x4640685B }, { 0xBB, 0xD10D2B00 }, { 0xBB, 0x2B006803 }, { 0xBB, 0x4649D00E }, { 0xBB, 0xE000600B }, { 0xBB, 0x464BBF00 }, 649 | { 0xBB, 0x4690681A }, { 0xBB, 0x29004641 }, { 0xBB, 0xE7DED196 }, { 0xBB, 0x46C16803 }, { 0xBB, 0xE7F74698 }, { 0xBB, 0xE7FA2300 }, 650 | { 0xBB, 0x000007D4 }, { 0xBB, 0x00000000 }, { 0xBB, 0x1C01B508 }, { 0xBB, 0x20002200 }, { 0xBB, 0xF0002300 }, { 0xBB, 0xBD08F819 }, 651 | { 0xBB, 0x4B09B538 }, { 0xBB, 0x1AED4D09 }, { 0xBB, 0xD00910AD }, { 0xBB, 0x00AC3D01 }, { 0xBB, 0xE00018E4 }, { 0xBB, 0x68233D01 }, 652 | { 0xBB, 0x3C044798 }, { 0xBB, 0xD1F92D00 }, { 0xBB, 0xF86EF000 }, { 0xBB, 0x46C0BD38 }, { 0xBB, 0x20000444 }, { 0xBB, 0x20000448 }, 653 | { 0xBB, 0x464FB5F0 }, { 0xBB, 0xB4C04646 }, { 0xBB, 0x4B2B4698 }, { 0xBB, 0x681B25A4 }, { 0xBB, 0x595C006D }, { 0xBB, 0x1C06B083 }, 654 | { 0xBB, 0x46911C0F }, { 0xBB, 0x2C009301 }, { 0xBB, 0x6865D044 }, { 0xBB, 0xDD1A2D1F }, { 0xBB, 0x2B004B24 }, { 0xBB, 0x2001D102 }, 655 | { 0xBB, 0xE01C4240 }, { 0xBB, 0x004020C8 }, { 0xBB, 0xBF00E000 }, { 0xBB, 0xD0F61E04 }, { 0xBB, 0x60452500 }, { 0xBB, 0x980123A4 }, 656 | { 0xBB, 0x58C0005B }, { 0xBB, 0x60209901 }, { 0xBB, 0x23C450CC }, { 0xBB, 0x50E5005B }, { 0xBB, 0x005B23C6 }, { 0xBB, 0x2E0050E5 }, 657 | { 0xBB, 0x1C6BD10A }, { 0xBB, 0x00AD3502 }, { 0xBB, 0x20006063 }, { 0xBB, 0xB003512F }, { 0xBB, 0x4690BC0C }, { 0xBB, 0xBDF04699 }, 658 | { 0xBB, 0x18E300AB }, { 0xBB, 0x46482288 }, { 0xBB, 0x20C45098 }, { 0xBB, 0x18220040 }, { 0xBB, 0x21016810 }, { 0xBB, 0x430840A9 }, 659 | { 0xBB, 0x22846010 }, { 0xBB, 0x46400052 }, { 0xBB, 0x2E025098 }, { 0xBB, 0x22C6D1E1 }, { 0xBB, 0x18A30052 }, { 0xBB, 0x43016818 }, 660 | { 0xBB, 0xE7DA6019 }, { 0xBB, 0x344D1C1C }, { 0xBB, 0x515C34FF }, { 0xBB, 0x46C0E7B5 }, { 0xBB, 0x000007D4 }, { 0xBB, 0x00000000 }, 661 | { 0xBB, 0x46C0E7FE }, { 0xBB, 0x46C0B5F8 }, { 0xBB, 0xBC08BCF8 }, { 0xBD, 0x00000000 }, { 0xB1, 0x00000000 }, { 0x8B, 0x200017C0 }, 662 | { 0xBB, 0x4770469E }, { 0xBB, 0x46C0B5F8 }, { 0xBB, 0xBC08BCF8 }, { 0xBB, 0x4770469E }, { 0xBB, 0x00000043 }, { 0xBB, 0x20000010 }, 663 | { 0xBB, 0x00000000 }, { 0xBB, 0x7FFFF944 }, { 0xBB, 0x00000001 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000008 }, { 0xBB, 0x00F42400 }, 664 | { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x200002FC }, { 0xBB, 0x20000364 }, { 0xBD, 0x00000000 }, { 0xB1, 0x00000000 }, 665 | { 0x8B, 0x20001800 }, { 0xBB, 0x200003CC }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, 666 | { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x000007D0 }, 667 | { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, 668 | { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, 669 | { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, 670 | { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, 671 | { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000001 }, { 0xBB, 0x00000000 }, 672 | { 0xBB, 0xABCD330E }, { 0xBB, 0xE66D1234 }, { 0xBB, 0x0005DEEC }, { 0xBB, 0x0000000B }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, 673 | { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, 674 | { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, 675 | { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, 676 | { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, 677 | { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, 678 | { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, 679 | { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, 680 | { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, 681 | { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, 682 | { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, 683 | { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, 684 | { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, 685 | { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, 686 | { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, 687 | { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, 688 | { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, 689 | { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, 690 | { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, 691 | { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, 692 | { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, 693 | { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, 694 | { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, 695 | { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, 696 | { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, 697 | { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, 698 | { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, 699 | { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, 700 | { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, 701 | { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, 702 | { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, 703 | { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, 704 | { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, 705 | { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, 706 | { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, 707 | { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBD, 0x00000000 }, 708 | { 0xB1, 0x00000000 }, { 0x8B, 0x20001C00 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, 709 | { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x00000000 }, { 0xBB, 0x20000010 }, { 0xBB, 0x00000585 }, { 0xBB, 0x000000E9 }, 710 | { 0xBB, 0x000000C1 }, { 0xBB, 0x00000000 }, { 0xBD, 0x00000000 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0xE0001004 }, 711 | { 0xA3, 0x23000012 }, { 0xBB, 0x00000000 }, { 0xBD, 0x00000000 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0xE000EDF0 }, 712 | { 0xA3, 0x23000012 }, { 0xB1, 0x00000010 }, { 0x93, 0x20000340 }, { 0x8B, 0x0001000F }, { 0x93, 0x200008E8 }, { 0x8B, 0x00010011 }, 713 | { 0xBD, 0x00000000 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0xE000ED30 }, { 0xA3, 0x23000002 }, { 0xBB, 0x0000001F }, 714 | { 0x8B, 0xE000EDF0 }, { 0xBB, 0xA05F0003 }, { 0xBB, 0xA05F0001 }, { 0xBD, 0x00000000 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, 715 | { 0x8B, 0xE000EDF0 }, { 0xA3, 0x23000002 }, { 0xBB, 0xA05F0003 }, { 0x9F, 0x00000000 }, { 0x9F, 0x01030003 }, { 0x81, 0x0000001E }, 716 | { 0xB1, 0x00000000 }, { 0x8B, 0xE000EDF0 }, { 0xA3, 0x23000012 }, { 0xB1, 0x00000010 }, { 0x8B, 0x00000000 }, { 0xB7, 0x00000000 }, 717 | { 0xBD, 0x00000001 }, { 0x8B, 0x00000001 }, { 0xB7, 0x00000000 }, { 0xBD, 0x20000C00 }, { 0x8B, 0x00000002 }, { 0xB7, 0x00000000 }, 718 | { 0xBD, 0x000000C1 }, { 0x8B, 0x00000003 }, { 0xB7, 0x00000000 }, { 0xBD, 0x00000000 }, { 0x8B, 0x00000004 }, { 0xB7, 0x00000000 }, 719 | { 0xBD, 0x20000484 }, { 0x8B, 0x00000005 }, { 0xB7, 0x00000000 }, { 0xBD, 0x20000804 }, { 0x8B, 0x00000006 }, { 0xB7, 0x00000000 }, 720 | { 0xBD, 0x00000000 }, { 0x8B, 0x00000007 }, { 0xB7, 0x00000000 }, { 0xBD, 0x00000000 }, { 0x8B, 0x00000008 }, { 0xB7, 0x00000000 }, 721 | { 0xBD, 0xFFFFFFFF }, { 0x8B, 0x00000009 }, { 0xB7, 0x00000000 }, { 0xBD, 0xFFFFFFFF }, { 0x8B, 0x0000000A }, { 0xB7, 0x00000000 }, 722 | { 0xBD, 0x20000484 }, { 0x8B, 0x0000000B }, { 0xB7, 0x00000000 }, { 0xBD, 0x20000484 }, { 0x8B, 0x0000000C }, { 0xB7, 0x00000000 }, 723 | { 0xBD, 0xFFFFFFFF }, { 0x8B, 0x0000000E }, { 0xB7, 0x00000000 }, { 0xBD, 0x200001C3 }, { 0x8B, 0x0000000F }, { 0xB7, 0x00000000 }, 724 | { 0xBD, 0x200001FA }, { 0x8B, 0x00000010 }, { 0xB7, 0x00000000 }, { 0xBD, 0x01000000 }, { 0x8B, 0x00000011 }, { 0xB7, 0x00000000 }, 725 | { 0xBD, 0x200008E8 }, { 0x8B, 0x00000012 }, { 0xB7, 0x00000000 }, { 0xBD, 0xFFFFFFFC }, { 0x8B, 0x00000014 }, { 0xB7, 0x00000000 }, 726 | { 0xBD, 0x00000000 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0x20000C00 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, 727 | { 0x9F, 0x00000001 }, { 0x9F, 0x00000001 }, { 0x9F, 0xFFFD0490 }, { 0x9F, 0xBF8F2840 }, { 0x9F, 0x00000000 }, { 0x9F, 0x00000C30 }, 728 | { 0x9F, 0x00000000 }, { 0x9F, 0x5000FEBF }, { 0x9F, 0xFFFB0000 }, { 0x9F, 0xFFFB0200 }, { 0x9F, 0xFF7B4C20 }, { 0x9F, 0xFFFA0A00 }, 729 | { 0x9F, 0x0102FFD7 }, { 0x9F, 0x0202F7DF }, { 0x9F, 0x0002FFDE }, { 0xBD, 0x1048D6D7 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, 730 | { 0x8B, 0x20001000 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x20004000 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, 731 | { 0x8B, 0x20001000 }, { 0xA3, 0x23000012 }, { 0xBB, 0x20004000 }, { 0xBD, 0x00000000 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, 732 | { 0x8B, 0xE000EDF0 }, { 0xA3, 0x23000012 }, { 0xBB, 0xA05F0003 }, { 0xBD, 0x00000000 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, 733 | { 0x8B, 0xE000EDFC }, { 0xA3, 0x23000012 }, { 0xBB, 0x01000001 }, { 0xBD, 0x00000000 }, { 0x81, 0x0000001E }, { 0x81, 0x0000001E }, 734 | { 0xB1, 0x00000000 }, { 0x8B, 0xE000ED0C }, { 0xA3, 0x23000012 }, { 0xBB, 0x05FA0004 }, { 0xBD, 0x00000000 }, { 0x81, 0x0000001E }, 735 | { 0xB1, 0x00000000 }, { 0x8B, 0xE000EDF0 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x03030003 }, { 0x81, 0x0000001E }, 736 | { 0xB1, 0x00000000 }, { 0x8B, 0xE000EDF0 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00030003 }, { 0x81, 0x0000001E }, 737 | { 0xB1, 0x00000000 }, { 0x8B, 0xE000EDF0 }, { 0xA3, 0x23000012 }, { 0xBB, 0xA05F0003 }, { 0xBD, 0x00000000 }, { 0x81, 0x0000001E }, 738 | { 0xB1, 0x00000000 }, { 0x8B, 0xE000EDFC }, { 0xA3, 0x23000012 }, { 0xBB, 0x01000000 }, { 0xBD, 0x00000000 }, { 0x81, 0x0000001E }, 739 | { 0xB1, 0x00000000 }, { 0x8B, 0xE000EDF0 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00030003 }, { 0x81, 0x0000001E }, 740 | { 0xB1, 0x00000000 }, { 0x8B, 0xE000EDF0 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, { 0xBD, 0x00030003 }, { 0x81, 0x0000001E }, 741 | { 0xB1, 0x00000000 }, { 0x8B, 0xE000EDF0 }, { 0xA3, 0x23000012 }, { 0xB1, 0x00000010 }, { 0x8B, 0x00000000 }, { 0xB7, 0x00000000 }, 742 | { 0xBD, 0xFFFFFFFF }, { 0x8B, 0x00000001 }, { 0xB7, 0x00000000 }, { 0xBD, 0xFFFFFFFF }, { 0x8B, 0x00000002 }, { 0xB7, 0x00000000 }, 743 | { 0xBD, 0xFFFFFFFF }, { 0x8B, 0x00000003 }, { 0xB7, 0x00000000 }, { 0xBD, 0xFFFFFFFF }, { 0x8B, 0x00000004 }, { 0xB7, 0x00000000 }, 744 | { 0xBD, 0xFFFFFFFF }, { 0x8B, 0x00000005 }, { 0xB7, 0x00000000 }, { 0xBD, 0xFFFFFFFF }, { 0x8B, 0x00000006 }, { 0xB7, 0x00000000 }, 745 | { 0xBD, 0xFFFFFFFF }, { 0x8B, 0x00000007 }, { 0xB7, 0x00000000 }, { 0xBD, 0xFFFFFFFF }, { 0x8B, 0x00000008 }, { 0xB7, 0x00000000 }, 746 | { 0xBD, 0xFFFFFFFF }, { 0x8B, 0x00000009 }, { 0xB7, 0x00000000 }, { 0xBD, 0xFFFFFFFF }, { 0x8B, 0x0000000A }, { 0xB7, 0x00000000 }, 747 | { 0xBD, 0xFFFFFFFF }, { 0x8B, 0x0000000B }, { 0xB7, 0x00000000 }, { 0xBD, 0xFFFFFFFF }, { 0x8B, 0x0000000C }, { 0xB7, 0x00000000 }, 748 | { 0xBD, 0xFFFFFFFF }, { 0x8B, 0x0000000E }, { 0xB7, 0x00000000 }, { 0xBD, 0xFFFFFFFF }, { 0x8B, 0x0000000F }, { 0xB7, 0x00000000 }, 749 | { 0xBD, 0x00000438 }, { 0x8B, 0x00000010 }, { 0xB7, 0x00000000 }, { 0xBD, 0xC1000000 }, { 0x8B, 0x00000011 }, { 0xB7, 0x00000000 }, 750 | { 0xBD, 0x20004000 }, { 0x8B, 0x00000012 }, { 0xB7, 0x00000000 }, { 0xBD, 0xFFFFFFFC }, { 0x8B, 0x00000014 }, { 0xB7, 0x00000000 }, 751 | { 0xBD, 0x00000000 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0xE0002000 }, { 0xA3, 0x23000012 }, { 0xBB, 0x00000003 }, 752 | { 0xBD, 0x00000000 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0xE000EDFC }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, 753 | { 0xBD, 0x01000000 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0xE0001000 }, { 0xA3, 0x23000012 }, { 0x9F, 0x00000000 }, 754 | { 0xBD, 0x20000000 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0xE0001000 }, { 0xA3, 0x23000012 }, { 0xBB, 0x20000001 }, 755 | { 0xBD, 0x00000000 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0xE0001004 }, { 0xA3, 0x23000012 }, { 0xBB, 0x00000000 }, 756 | { 0xBD, 0x00000000 }, { 0x81, 0x0000001E }, { 0xB1, 0x00000000 }, { 0x8B, 0xE000ED30 }, { 0xA3, 0x23000002 }, { 0xBB, 0x0000001F }, 757 | { 0x8B, 0xE000EDF0 }, { 0xBB, 0xA05F0003 }, { 0xBB, 0xA05F0001 }, { 0xBD, 0x00000000 }, { 0x81, 0x0000001E }, { 0xA9, 0x00000001 }, 758 | { 0x00, 0x00000000 }, 759 | }; 760 | 761 | SWDSimulationDataGenerator::SWDSimulationDataGenerator() 762 | { 763 | } 764 | 765 | SWDSimulationDataGenerator::~SWDSimulationDataGenerator() 766 | { 767 | } 768 | 769 | void SWDSimulationDataGenerator::Initialize( U32 simulation_sample_rate, SWDAnalyzerSettings* settings ) 770 | { 771 | mSimulationSampleRateHz = simulation_sample_rate; 772 | mSettings = settings; 773 | 774 | mClockGenerator.Init( simulation_sample_rate / 10, simulation_sample_rate ); 775 | 776 | mSWDIO = mSWDSimulationChannels.Add( settings->mSWDIO, mSimulationSampleRateHz, BIT_LOW ); 777 | mSWCLK = mSWDSimulationChannels.Add( settings->mSWCLK, mSimulationSampleRateHz, BIT_LOW ); 778 | 779 | // start from the end to force a line reset in GenerateSimulationData 780 | mSimulCnt = sizeof( simul_data ) / sizeof( SimulationData ) - 1; 781 | } 782 | 783 | U32 SWDSimulationDataGenerator::GenerateSimulationData( U64 largest_sample_requested, U32 sample_rate, 784 | SimulationChannelDescriptor** simulation_channels ) 785 | { 786 | U64 adjusted_largest_sample_requested = 787 | AnalyzerHelpers::AdjustSimulationTargetSample( largest_sample_requested, sample_rate, mSimulationSampleRateHz ); 788 | 789 | // while the caller needs more samples 790 | while( mSWCLK->GetCurrentSampleNumber() < adjusted_largest_sample_requested ) 791 | { 792 | // if we've reached the end of the array of data 793 | if( simul_data[ mSimulCnt ].request == 0 ) 794 | { 795 | // pause, reset and restart the data 796 | AdvanceAllBySec( 0.01 ); 797 | OutputLineReset(); 798 | mSimulCnt = 0; 799 | } 800 | 801 | // shortcut to the simulated data object 802 | const SimulationData& sim( simul_data[ mSimulCnt ] ); 803 | 804 | // the request and ACK with turnarounds 805 | // we need the first data bit to prepare the data line 806 | bool is_write = OutputRequest( sim.request, ACK_OK, ( sim.data & 1 ) ? BIT_HIGH : BIT_LOW ); 807 | OutputData( sim.data, is_write ); // the WData part with parity 808 | 809 | mSimulCnt++; 810 | 811 | // have we reached the end of the data? 812 | if( simul_data[ mSimulCnt ].request == 0 ) 813 | { 814 | // show a fault and wait response 815 | OutputRequest( 0xA5, ACK_FAULT, BIT_HIGH ); 816 | AdvanceAllBySec( TENTH_US * 100 ); 817 | OutputRequest( 0xB1, ACK_WAIT, BIT_LOW ); 818 | AdvanceAllBySec( TENTH_US * 100 ); 819 | } 820 | } 821 | 822 | *simulation_channels = mSWDSimulationChannels.GetArray(); 823 | 824 | return mSWDSimulationChannels.GetCount(); 825 | } 826 | 827 | void SWDSimulationDataGenerator::OutputWriteBit( BitState state ) 828 | { 829 | mSWDIO->TransitionIfNeeded( state ); 830 | 831 | AdvanceAllBySec( TENTH_US * 3 ); 832 | 833 | mSWCLK->Transition(); // CLK goes high 834 | AdvanceAllBySec( TENTH_US * 4 ); 835 | mSWCLK->Transition(); // CLK goes low 836 | 837 | AdvanceAllBySec( TENTH_US * 3 ); 838 | } 839 | 840 | void SWDSimulationDataGenerator::OutputReadBit( BitState first_half, BitState second_half ) 841 | { 842 | mSWDIO->TransitionIfNeeded( first_half ); 843 | 844 | AdvanceAllBySec( TENTH_US * 3 ); 845 | 846 | mSWCLK->Transition(); // CLK goes high 847 | AdvanceAllBySec( TENTH_US * 2 ); 848 | mSWDIO->TransitionIfNeeded( second_half ); 849 | AdvanceAllBySec( TENTH_US * 2 ); 850 | mSWCLK->Transition(); // CLK goes low 851 | 852 | AdvanceAllBySec( TENTH_US * 3 ); 853 | } 854 | 855 | void SWDSimulationDataGenerator::OutputLineReset() 856 | { 857 | int cnt; 858 | 859 | // 55 ones 860 | for( cnt = 0; cnt < 55; ++cnt ) 861 | OutputWriteBit( BIT_HIGH ); 862 | 863 | // 10 zeros 864 | for( cnt = 0; cnt < 10; ++cnt ) 865 | OutputWriteBit( BIT_LOW ); 866 | 867 | // pause 868 | AdvanceAllBySec( TENTH_US * 50 ); 869 | } 870 | 871 | void SWDSimulationDataGenerator::OutputTurnaround( BitState state ) 872 | { 873 | AdvanceAllBySec( TENTH_US * 10 ); 874 | OutputWriteBit( state ); 875 | AdvanceAllBySec( TENTH_US * 10 ); 876 | } 877 | 878 | bool SWDSimulationDataGenerator::OutputRequest( U8 req, U8 ack, BitState first_data_bit ) 879 | { 880 | bool is_write = ( req & 0x04 ) == 0; 881 | 882 | // the request 883 | U8 bmask; 884 | for( bmask = 1; bmask != 0; bmask <<= 1 ) 885 | OutputWriteBit( ( req & bmask ) ? BIT_HIGH : BIT_LOW ); 886 | 887 | // turnaround 888 | OutputTurnaround( ( req & 0x80 ) ? BIT_HIGH : BIT_LOW ); 889 | 890 | // ack 891 | BitState s1( ( ack & 1 ) ? BIT_HIGH : BIT_LOW ); 892 | BitState s2( ( ack & 2 ) ? BIT_HIGH : BIT_LOW ); 893 | BitState s3( ( ack & 4 ) ? BIT_HIGH : BIT_LOW ); 894 | 895 | OutputReadBit( s1, s2 ); 896 | OutputReadBit( s2, s3 ); 897 | OutputReadBit( s3, first_data_bit ); 898 | 899 | // turnaround (if needed) 900 | if( is_write && ack == ACK_OK ) 901 | OutputTurnaround( first_data_bit ); 902 | 903 | return is_write; 904 | } 905 | 906 | void SWDSimulationDataGenerator::OutputData( U32 data, bool is_write ) 907 | { 908 | // the 32 data bits 909 | U32 bmask; 910 | U8 num_bits = 0; 911 | BitState parity_bit, next_bit; 912 | for( bmask = 1; bmask != 0; bmask <<= 1 ) 913 | { 914 | const bool is_last_bit = bmask == 0x80000000; 915 | 916 | if( data & bmask ) 917 | ++num_bits; 918 | 919 | if( is_last_bit ) 920 | parity_bit = ( num_bits & 1 ) ? BIT_HIGH : BIT_LOW; 921 | 922 | if( is_write ) 923 | { 924 | OutputWriteBit( ( data & bmask ) ? BIT_HIGH : BIT_LOW ); 925 | } 926 | else 927 | { 928 | if( is_last_bit ) 929 | next_bit = parity_bit; 930 | else 931 | next_bit = ( data & ( bmask << 1 ) ) ? BIT_HIGH : BIT_LOW; 932 | 933 | OutputReadBit( ( data & bmask ) ? BIT_HIGH : BIT_LOW, next_bit ); 934 | } 935 | } 936 | 937 | // data parity 938 | OutputWriteBit( parity_bit ); 939 | 940 | // trailing zeros 941 | for( num_bits = 0; num_bits < 10; ++num_bits ) 942 | OutputWriteBit( BIT_LOW ); 943 | 944 | // pause 945 | AdvanceAllBySec( TENTH_US * 50 ); 946 | } 947 | -------------------------------------------------------------------------------- /src/SWDSimulationDataGenerator.h: -------------------------------------------------------------------------------- 1 | #ifndef SWD_SIMULATION_DATA_GENERATOR_H 2 | #define SWD_SIMULATION_DATA_GENERATOR_H 3 | 4 | #include 5 | 6 | #include "SWDTypes.h" 7 | 8 | class SWDAnalyzerSettings; 9 | 10 | class SWDSimulationDataGenerator 11 | { 12 | public: 13 | SWDSimulationDataGenerator(); 14 | ~SWDSimulationDataGenerator(); 15 | 16 | void Initialize( U32 simulation_sample_rate, SWDAnalyzerSettings* settings ); 17 | U32 GenerateSimulationData( U64 newest_sample_requested, U32 sample_rate, SimulationChannelDescriptor** simulation_channels ); 18 | 19 | protected: 20 | SWDAnalyzerSettings* mSettings; 21 | U32 mSimulationSampleRateHz; 22 | U32 mSimulCnt; 23 | 24 | void AdvanceAllBySec( double sec ) 25 | { 26 | mSWDSimulationChannels.AdvanceAll( mClockGenerator.AdvanceByTimeS( sec ) ); 27 | } 28 | 29 | // read and write in this context is a bit read or written from the perspective of the host 30 | void OutputWriteBit( BitState state ); 31 | void OutputReadBit( BitState first_half, BitState second_half ); 32 | 33 | void OutputTurnaround( BitState state ); 34 | bool OutputRequest( U8 req, U8 ack, BitState first_data_bit ); 35 | void OutputData( U32 data, bool is_write ); 36 | void OutputLineReset(); 37 | 38 | protected: 39 | ClockGenerator mClockGenerator; 40 | 41 | SimulationChannelDescriptorGroup mSWDSimulationChannels; 42 | SimulationChannelDescriptor* mSWDIO; 43 | SimulationChannelDescriptor* mSWCLK; 44 | }; 45 | 46 | #endif // SWD_SIMULATION_DATA_GENERATOR_H 47 | -------------------------------------------------------------------------------- /src/SWDTypes.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #include 4 | #include 5 | 6 | #include 7 | #include 8 | 9 | #include "SWDAnalyzer.h" 10 | #include "SWDTypes.h" 11 | #include "SWDUtils.h" 12 | 13 | const int TRAN_REQ_AND_ACK = 8 + 1 + 3; // request/turnaround/ACK 14 | const int TRAN_READ_LENGTH = TRAN_REQ_AND_ACK + 33; // previous + 32bit data + parity 15 | const int TRAN_WRITE_LENGTH = TRAN_READ_LENGTH + 1; // previous + one bit for turnaround 16 | const int TRAN_JTAG_TO_SWD = 16; 17 | 18 | S64 SWDBit::GetMinStartEnd() const 19 | { 20 | S64 s = ( rising - low_start ) / 2; 21 | S64 e = ( low_end - falling ) / 2; 22 | return s < e ? s : e; 23 | } 24 | 25 | S64 SWDBit::GetStartSample() const 26 | { 27 | return rising - GetMinStartEnd() + 1; 28 | } 29 | 30 | S64 SWDBit::GetEndSample() const 31 | { 32 | return falling + GetMinStartEnd() - 1; 33 | } 34 | 35 | Frame SWDBit::MakeFrame() 36 | { 37 | Frame f; 38 | 39 | f.mType = SWDFT_Bit; 40 | f.mFlags = 0; 41 | f.mStartingSampleInclusive = GetStartSample(); 42 | f.mEndingSampleInclusive = GetEndSample(); 43 | 44 | f.mData1 = state_rising == BIT_HIGH ? 1 : 0; 45 | f.mData2 = 0; 46 | 47 | return f; 48 | } 49 | 50 | // ******************************************************************************** 51 | 52 | std::string SWDRequestFrame::GetRegisterName() const 53 | { 54 | return ::GetRegisterName( GetRegister() ); 55 | } 56 | 57 | // ******************************************************************************** 58 | 59 | void SWDOperation::Clear() 60 | { 61 | RnW = APnDP = parity_read = data_parity_ok = false; 62 | addr = parity_read = request_byte = ACK = data_parity = data = 0; 63 | reg = SWDR_undefined; 64 | 65 | bits.clear(); 66 | } 67 | 68 | void SWDOperation::AddFrames( SWDAnalyzerResults* pResults ) 69 | { 70 | Frame f; 71 | 72 | assert( bits.size() >= TRAN_REQ_AND_ACK ); 73 | 74 | // request 75 | SWDRequestFrame req; 76 | req.mStartingSampleInclusive = bits[ 0 ].GetStartSample(); 77 | req.mEndingSampleInclusive = bits[ 7 ].GetEndSample(); 78 | req.mFlags = ( IsRead() ? SWDRequestFrame::IS_READ : 0 ) | ( APnDP ? SWDRequestFrame::IS_ACCESS_PORT : 0 ); 79 | req.SetRequestByte( request_byte ); 80 | req.SetRegister( reg ); 81 | req.mType = SWDFT_Request; 82 | pResults->AddFrame( req ); 83 | 84 | // turnaround 85 | f = bits[ 8 ].MakeFrame(); 86 | f.mType = SWDFT_Turnaround; 87 | pResults->AddFrame( f ); 88 | 89 | // ack 90 | f.mStartingSampleInclusive = bits[ 9 ].GetStartSample(); 91 | f.mEndingSampleInclusive = bits[ 11 ].GetEndSample(); 92 | f.mType = SWDFT_ACK; 93 | f.mData1 = ACK; 94 | pResults->AddFrame( f ); 95 | 96 | if( bits.size() < TRAN_READ_LENGTH ) 97 | return; 98 | 99 | // turnaround 100 | std::vector::iterator bi( bits.begin() + 12 ); 101 | if( !IsRead() ) 102 | { 103 | f = bits[ 12 ].MakeFrame(); 104 | f.mType = SWDFT_Turnaround; 105 | pResults->AddFrame( f ); 106 | bi++; 107 | } 108 | 109 | // data 110 | f = bi->MakeFrame(); 111 | f.mEndingSampleInclusive = bi[ 31 ].GetEndSample(); 112 | if( IsRead() ) 113 | { 114 | f.mType = SWDFT_RData; 115 | } else { 116 | f.mType = SWDFT_WData; 117 | } 118 | f.mData1 = data; 119 | f.mData2 = reg; 120 | pResults->AddFrame( f ); 121 | 122 | // data parity 123 | f = bi[ 32 ].MakeFrame(); 124 | f.mType = SWDFT_DataParity; 125 | f.mData1 = data_parity; 126 | f.mData2 = data_parity_ok ? 1 : 0; 127 | pResults->AddFrame( f ); 128 | 129 | bi += 33; 130 | 131 | // do we have trailing bits? 132 | if( bi < bits.end() ) 133 | { 134 | f.mStartingSampleInclusive = bi->GetStartSample(); 135 | f.mEndingSampleInclusive = bits.back().GetEndSample(); 136 | f.mType = SWDFT_TrailingBits; 137 | 138 | f.mFlags = 0; 139 | f.mData1 = 0; 140 | f.mData2 = 0; 141 | 142 | pResults->AddFrame( f ); 143 | } 144 | } 145 | 146 | void SWDOperation::AddMarkers( SWDAnalyzerResults* pResults ) 147 | { 148 | for( std::vector::iterator bi( bits.begin() ); bi != bits.end(); bi++ ) 149 | { 150 | int ndx = bi - bits.begin(); 151 | 152 | // turnaround 153 | if( ndx == 8 || ndx == 12 && !IsRead() ) 154 | pResults->AddMarker( ( bi->falling + bi->rising ) / 2, AnalyzerResults::X, pResults->GetSettings()->mSWCLK ); 155 | 156 | // Data is always sampled by both ends on the rising edge. 157 | pResults->AddMarker( bi->rising, bi->state_rising == BIT_HIGH ? AnalyzerResults::One : AnalyzerResults::Zero, 158 | pResults->GetSettings()->mSWCLK ); 159 | } 160 | } 161 | 162 | void SWDOperation::SetRegister( U32 select_reg ) 163 | { 164 | if( APnDP ) // AccessPort or DebugPort? 165 | { 166 | U8 apbanksel = U8( select_reg & 0xf0 ); 167 | U8 apreg = apbanksel | addr; 168 | 169 | switch( apreg ) 170 | { 171 | case 0x00: 172 | reg = SWDR_AP_CSW; 173 | break; 174 | case 0x04: 175 | reg = SWDR_AP_TAR; 176 | break; 177 | case 0x0C: 178 | reg = SWDR_AP_DRW; 179 | break; 180 | case 0x10: 181 | reg = SWDR_AP_BD0; 182 | break; 183 | case 0x14: 184 | reg = SWDR_AP_BD1; 185 | break; 186 | case 0x18: 187 | reg = SWDR_AP_BD2; 188 | break; 189 | case 0x1C: 190 | reg = SWDR_AP_BD3; 191 | break; 192 | case 0xF4: 193 | reg = SWDR_AP_CFG; 194 | break; 195 | case 0xF8: 196 | reg = SWDR_AP_BASE; 197 | break; 198 | case 0xFC: 199 | reg = SWDR_AP_IDR; 200 | break; 201 | default: 202 | reg = SWDR_AP_RAZ_WI; 203 | break; 204 | } 205 | } 206 | else 207 | { 208 | switch( addr ) 209 | { 210 | case 0x0: 211 | reg = RnW ? SWDR_DP_IDCODE : SWDR_DP_ABORT; 212 | break; 213 | case 0x4: 214 | reg = ( select_reg & 1 ) != 0 ? SWDR_DP_WCR : SWDR_DP_CTRL_STAT; 215 | break; 216 | case 0x8: 217 | reg = RnW ? SWDR_DP_RESEND : SWDR_DP_SELECT; 218 | break; 219 | case 0xC: 220 | reg = RnW ? SWDR_DP_RDBUFF : SWDR_DP_ROUTESEL; 221 | break; 222 | } 223 | } 224 | } 225 | 226 | // ******************************************************************************** 227 | 228 | void SWDLineReset::AddFrames( AnalyzerResults* pResults ) 229 | { 230 | Frame f; 231 | 232 | // line reset 233 | f.mStartingSampleInclusive = bits.front().GetStartSample(); 234 | f.mEndingSampleInclusive = bits.back().GetEndSample(); 235 | f.mType = SWDFT_LineReset; 236 | f.mData1 = bits.size(); 237 | pResults->AddFrame( f ); 238 | } 239 | 240 | // ******************************************************************************** 241 | 242 | void SWDJtagToSwd::AddFrames( AnalyzerResults* pResults ) 243 | { 244 | Frame f; 245 | f.mStartingSampleInclusive = bits.front().GetStartSample(); 246 | f.mEndingSampleInclusive = bits.back().GetEndSample(); 247 | f.mType = SWDFT_JtagToSwd; 248 | f.mData1 = bits.size(); 249 | pResults->AddFrame( f ); 250 | } 251 | 252 | // ******************************************************************************** 253 | 254 | 255 | SWDParser::SWDParser() : mSWDIO( 0 ), mSWCLK( 0 ) 256 | { 257 | } 258 | 259 | void SWDParser::Setup( AnalyzerChannelData* pSWDIO, AnalyzerChannelData* pSWCLK, SWDAnalyzer* pAnalyzer ) 260 | { 261 | mSWDIO = pSWDIO; 262 | mSWCLK = pSWCLK; 263 | 264 | mAnalyzer = pAnalyzer; 265 | 266 | // skip the SWCLK high 267 | if( mSWCLK->GetBitState() == BIT_HIGH ) 268 | { 269 | mSWCLK->AdvanceToNextEdge(); 270 | mSWDIO->AdvanceToAbsPosition( mSWCLK->GetSampleNumber() ); 271 | } 272 | } 273 | 274 | SWDBit SWDParser::ParseBit() 275 | { 276 | SWDBit rbit; 277 | 278 | assert( mSWCLK->GetBitState() == BIT_LOW ); 279 | 280 | rbit.low_start = mSWCLK->GetSampleNumber(); 281 | 282 | // sample the rising edge 1 sample before the the actual 283 | mSWCLK->AdvanceToAbsPosition( mSWCLK->GetSampleOfNextEdge() - 1 ); 284 | mSWDIO->AdvanceToAbsPosition( mSWCLK->GetSampleNumber() ); 285 | rbit.rising = mSWCLK->GetSampleNumber(); 286 | rbit.state_rising = mSWDIO->GetBitState(); 287 | mSWCLK->AdvanceToNextEdge(); 288 | mSWDIO->AdvanceToAbsPosition( mSWCLK->GetSampleNumber() ); 289 | 290 | /* 291 | // go to the rising egde 292 | mSWCLK->AdvanceToNextEdge(); 293 | mSWDIO->AdvanceToAbsPosition(mSWCLK->GetSampleNumber()); 294 | 295 | rbit.rising = mSWCLK->GetSampleNumber(); 296 | rbit.state_rising = mSWDIO->GetBitState(); 297 | */ 298 | 299 | // go to the falling edge 300 | mSWCLK->AdvanceToNextEdge(); 301 | mSWDIO->AdvanceToAbsPosition( mSWCLK->GetSampleNumber() ); 302 | 303 | rbit.falling = mSWCLK->GetSampleNumber(); 304 | rbit.state_falling = mSWDIO->GetBitState(); 305 | 306 | rbit.low_end = mSWCLK->GetSampleOfNextEdge(); 307 | 308 | return rbit; 309 | } 310 | 311 | void SWDParser::BufferBits( size_t num_bits ) 312 | { 313 | while( mBitsBuffer.size() < num_bits ) 314 | mBitsBuffer.push_back( ParseBit() ); 315 | } 316 | 317 | SWDBit SWDParser::PopFrontBit() 318 | { 319 | assert( !mBitsBuffer.empty() ); 320 | 321 | SWDBit ret_val( mBitsBuffer.front() ); 322 | 323 | // shift the elements by 1 324 | std::copy( mBitsBuffer.begin() + 1, mBitsBuffer.end(), mBitsBuffer.begin() ); 325 | mBitsBuffer.pop_back(); 326 | 327 | return ret_val; 328 | } 329 | 330 | bool SWDParser::IsOperation( SWDOperation& tran ) 331 | { 332 | tran.Clear(); 333 | 334 | // read enough bits so that we don't have to worry of subscripts out of range 335 | BufferBits( TRAN_REQ_AND_ACK ); 336 | 337 | // turn the bits into a byte 338 | tran.request_byte = 0; 339 | for( size_t cnt = 0; cnt < 8; ++cnt ) 340 | { 341 | tran.request_byte >>= 1; 342 | tran.request_byte |= ( mBitsBuffer[ cnt ].IsHigh() ? 0x80 : 0 ); 343 | } 344 | 345 | // are the request's constant bits (start, stop & park) wrong? 346 | if( ( tran.request_byte & 0xC1 ) != 0x81 ) 347 | return false; 348 | 349 | // get the indivitual bits 350 | tran.APnDP = ( tran.request_byte & 0x02 ) != 0; //(mBitsBuffer[1].state_falling == BIT_HIGH); 351 | tran.RnW = ( tran.request_byte & 0x04 ) != 0; //(mBitsBuffer[2].state_falling == BIT_HIGH); 352 | tran.addr = ( tran.request_byte & 0x18 ) >> 1; //(mBitsBuffer[3].state_falling == BIT_HIGH ? (1<<2) : 0) 353 | //| (mBitsBuffer[4].state_falling == BIT_HIGH ? (1<<3) : 0); 354 | tran.parity_read = ( ( tran.request_byte & 0x20 ) != 0 ? 1 : 0 ); //(mBitsBuffer[5].state_falling == BIT_HIGH ? 1 : 0); 355 | 356 | // check parity 357 | int check = ( mBitsBuffer[ 1 ].state_rising == BIT_HIGH ? 1 : 0 ) + ( mBitsBuffer[ 2 ].state_rising == BIT_HIGH ? 1 : 0 ) + 358 | ( mBitsBuffer[ 3 ].state_rising == BIT_HIGH ? 1 : 0 ) + ( mBitsBuffer[ 4 ].state_rising == BIT_HIGH ? 1 : 0 ); 359 | 360 | if( tran.parity_read != ( check & 1 ) ) 361 | return false; 362 | 363 | // Set the actual register in this operation based on the data from the request 364 | // and the previous select register state. 365 | tran.SetRegister( mSelectRegister ); 366 | 367 | // get the ACK value 368 | tran.ACK = ( mBitsBuffer[ 9 ].state_rising == BIT_HIGH ? 1 : 0 ) + ( mBitsBuffer[ 10 ].state_rising == BIT_HIGH ? 2 : 0 ) + 369 | ( mBitsBuffer[ 11 ].state_rising == BIT_HIGH ? 4 : 0 ); 370 | 371 | // we're only handling OK, WAIT and FAULT responses 372 | if( tran.ACK == ACK_WAIT || tran.ACK == ACK_FAULT ) 373 | { 374 | // copy this operation's bits 375 | tran.bits.clear(); 376 | std::copy( mBitsBuffer.begin(), mBitsBuffer.begin() + TRAN_REQ_AND_ACK, std::back_inserter( tran.bits ) ); 377 | 378 | // consume this operation's bits 379 | mBitsBuffer.erase( mBitsBuffer.begin(), mBitsBuffer.begin() + TRAN_REQ_AND_ACK ); 380 | 381 | return true; 382 | } 383 | 384 | if( tran.ACK != ACK_OK ) 385 | return false; 386 | 387 | BufferBits( TRAN_READ_LENGTH ); 388 | 389 | // turnaround if write operation 390 | bool read_rising = true; 391 | std::vector::iterator bi( mBitsBuffer.begin() + 12 ); 392 | if( !tran.IsRead() ) 393 | { 394 | BufferBits( TRAN_WRITE_LENGTH ); 395 | ++bi; 396 | // !!! read_rising = false; 397 | } 398 | 399 | // read the data 400 | tran.data = 0; 401 | check = 0; 402 | size_t ndx; 403 | for( ndx = 0; ndx < 32; ndx++ ) 404 | { 405 | tran.data >>= 1; 406 | 407 | if( bi[ ndx ].IsHigh( read_rising ) ) 408 | { 409 | tran.data |= 0x80000000; 410 | ++check; 411 | } 412 | } 413 | 414 | // data parity 415 | tran.data_parity = bi[ ndx ].IsHigh( read_rising ) ? 1 : 0; 416 | 417 | tran.data_parity_ok = ( tran.data_parity == ( check & 1 ) ); 418 | 419 | if( !tran.data_parity_ok ) 420 | return false; 421 | 422 | // if this is a SELECT register write, remember the value 423 | if( tran.reg == SWDR_DP_SELECT && !tran.RnW ) 424 | mSelectRegister = tran.data; 425 | 426 | // buffered trailing zeros 427 | ++ndx; 428 | bool all_zeros = true; 429 | while( bi + ndx < mBitsBuffer.end() ) 430 | { 431 | if( bi[ ndx ].IsHigh( read_rising ) ) 432 | { 433 | all_zeros = false; 434 | break; 435 | } 436 | 437 | ++ndx; 438 | } 439 | 440 | // if we haven't seen a high bit carry on until we do 441 | if( all_zeros ) 442 | { 443 | // read the remaining zero bits 444 | SWDBit bit; 445 | while( 1 ) 446 | { 447 | bit = ParseBit(); 448 | if( bit.IsHigh( read_rising ) ) 449 | break; 450 | 451 | mBitsBuffer.push_back( bit ); 452 | } 453 | 454 | // give the bits to the tran object 455 | tran.bits = mBitsBuffer; 456 | mBitsBuffer.clear(); 457 | 458 | // keep the high bit because that one is probably next operation's start bit 459 | mBitsBuffer.push_back( bit ); 460 | } 461 | else 462 | { 463 | // copy this operation's bits 464 | tran.bits.clear(); 465 | std::copy( mBitsBuffer.begin(), mBitsBuffer.begin() + ndx, std::back_inserter( tran.bits ) ); 466 | 467 | // remove this operation's bits from the buffer 468 | mBitsBuffer.erase( mBitsBuffer.begin(), mBitsBuffer.begin() + ndx ); 469 | } 470 | 471 | return true; 472 | } 473 | 474 | bool SWDParser::IsLineReset( SWDLineReset& reset ) 475 | { 476 | reset.Clear(); 477 | 478 | // we need at least 50 bits with a value of 1 479 | for( size_t cnt = 0; cnt < 50; cnt++ ) 480 | { 481 | if( cnt >= mBitsBuffer.size() ) 482 | mBitsBuffer.push_back( ParseBit() ); 483 | 484 | // we can't have a low bit 485 | if( !mBitsBuffer[ cnt ].IsHigh() ) 486 | return false; 487 | } 488 | 489 | SWDBit bit; 490 | while( true ) 491 | { 492 | bit = ParseBit(); 493 | if( !bit.IsHigh() ) 494 | break; 495 | 496 | mBitsBuffer.push_back( bit ); 497 | } 498 | 499 | // give the bits to the reset object 500 | reset.bits = mBitsBuffer; 501 | mBitsBuffer.clear(); 502 | 503 | // keep the high bit because that one is probably next operation's start bit 504 | mBitsBuffer.push_back( bit ); 505 | 506 | return true; 507 | } 508 | 509 | bool SWDParser::IsJtagToSwd( SWDJtagToSwd& jtagToSwd ) { 510 | jtagToSwd.Clear(); 511 | uint16_t sequence = 0b0111100111100111; 512 | for( size_t cnt = 0; cnt < 16; cnt++ ) 513 | { 514 | if( cnt >= mBitsBuffer.size() ) 515 | mBitsBuffer.push_back( ParseBit() ); 516 | 517 | if( mBitsBuffer[ cnt ].IsHigh() != ( ( sequence >> ( 15 - cnt ) ) & 0b1 ) ) 518 | return false; 519 | } 520 | 521 | jtagToSwd.bits = mBitsBuffer; 522 | mBitsBuffer.clear(); 523 | 524 | return true; 525 | } -------------------------------------------------------------------------------- /src/SWDTypes.h: -------------------------------------------------------------------------------- 1 | #ifndef SWD_TYPES_H 2 | #define SWD_TYPES_H 3 | 4 | #include 5 | 6 | #include "SWDAnalyzerResults.h" 7 | 8 | // the possible frame types 9 | enum SWDFrameTypes 10 | { 11 | SWDFT_Error, 12 | SWDFT_Bit, 13 | 14 | SWDFT_LineReset, 15 | SWDFT_JtagToSwd, 16 | 17 | SWDFT_Request, 18 | SWDFT_Turnaround, 19 | SWDFT_ACK, 20 | SWDFT_WData, 21 | SWDFT_RData, 22 | SWDFT_DataParity, 23 | SWDFT_TrailingBits, 24 | }; 25 | 26 | // the DebugPort and AccessPort registers as defined by SWD 27 | enum SWDRegisters 28 | { 29 | SWDR_undefined, 30 | 31 | // DP 32 | SWDR_DP_IDCODE, 33 | SWDR_DP_ABORT, 34 | SWDR_DP_CTRL_STAT, 35 | SWDR_DP_WCR, 36 | SWDR_DP_RESEND, 37 | SWDR_DP_SELECT, 38 | SWDR_DP_RDBUFF, 39 | SWDR_DP_ROUTESEL, 40 | 41 | // AP 42 | SWDR_AP_CSW, 43 | SWDR_AP_TAR, 44 | SWDR_AP_DRW, 45 | SWDR_AP_BD0, 46 | SWDR_AP_BD1, 47 | SWDR_AP_BD2, 48 | SWDR_AP_BD3, 49 | SWDR_AP_CFG, 50 | SWDR_AP_BASE, 51 | SWDR_AP_RAZ_WI, 52 | SWDR_AP_IDR, 53 | }; 54 | 55 | // some ACK values 56 | enum SWDACK 57 | { 58 | ACK_OK = 1, 59 | ACK_WAIT = 2, 60 | ACK_FAULT = 4, 61 | }; 62 | 63 | // this is the basic token of the analyzer 64 | // objects of this type are buffered in SWDOperation 65 | struct SWDBit 66 | { 67 | BitState state_rising; 68 | BitState state_falling; 69 | 70 | S64 low_start; 71 | S64 rising; 72 | S64 falling; 73 | S64 low_end; 74 | 75 | bool IsHigh( bool is_rising = true ) const 76 | { 77 | return ( is_rising ? state_rising : state_falling ) == BIT_HIGH; 78 | } 79 | 80 | S64 GetMinStartEnd() const; 81 | S64 GetStartSample() const; 82 | S64 GetEndSample() const; 83 | 84 | Frame MakeFrame(); 85 | }; 86 | 87 | // this object contains data about one SWD operation as described in section 5.3 88 | // of the ARM Debug Interface v5 Architecture Specification 89 | struct SWDOperation 90 | { 91 | // request 92 | bool APnDP; 93 | bool RnW; 94 | U8 addr; // A[2..3] 95 | 96 | U8 parity_read; 97 | 98 | U8 request_byte; // the entire request byte 99 | 100 | // acknowledge 101 | U8 ACK; 102 | 103 | // data 104 | U32 data; 105 | U8 data_parity; 106 | bool data_parity_ok; 107 | 108 | std::vector bits; 109 | 110 | // DebugPort or AccessPort register that this operation is reading/writing 111 | SWDRegisters reg; 112 | 113 | void Clear(); 114 | void AddFrames( SWDAnalyzerResults* pResults ); 115 | void AddMarkers( SWDAnalyzerResults* pResults ); 116 | void SetRegister( U32 select_reg ); 117 | 118 | bool IsRead() 119 | { 120 | return RnW; 121 | } 122 | }; 123 | 124 | struct SWDLineReset 125 | { 126 | std::vector bits; 127 | 128 | void Clear() 129 | { 130 | bits.clear(); 131 | } 132 | 133 | void AddFrames( AnalyzerResults* pResults ); 134 | }; 135 | 136 | struct SWDJtagToSwd 137 | { 138 | std::vector bits; 139 | 140 | void Clear() 141 | { 142 | bits.clear(); 143 | } 144 | 145 | void AddFrames( AnalyzerResults* pResults ); 146 | }; 147 | 148 | struct SWDRequestFrame : public Frame 149 | { 150 | // mData1 contains addr, mData2 contains the register enum 151 | 152 | // mFlag 153 | enum 154 | { 155 | IS_READ = ( 1 << 0 ), 156 | IS_ACCESS_PORT = ( 1 << 1 ), 157 | }; 158 | 159 | void SetRequestByte( U8 request_byte ) 160 | { 161 | mData1 = request_byte; 162 | } 163 | 164 | U8 GetAddr() const 165 | { 166 | return ( U8 )( ( mData1 >> 1 ) & 0xc ); 167 | } 168 | bool IsRead() const 169 | { 170 | return ( mFlags & IS_READ ) != 0; 171 | } 172 | bool IsAccessPort() const 173 | { 174 | return ( mFlags & IS_ACCESS_PORT ) != 0; 175 | } 176 | bool IsDebugPort() const 177 | { 178 | return !IsAccessPort(); 179 | } 180 | 181 | void SetRegister( SWDRegisters reg ) 182 | { 183 | mData2 = reg; 184 | } 185 | SWDRegisters GetRegister() const 186 | { 187 | return SWDRegisters( mData2 ); 188 | } 189 | std::string GetRegisterName() const; 190 | }; 191 | 192 | class SWDAnalyzer; 193 | 194 | // This object parses and buffers the bits of the SWD stream. 195 | // IsOperation and IsLineReset return true if the subsequent bits in 196 | // the stream are a valid operation or line reset. 197 | class SWDParser 198 | { 199 | private: 200 | AnalyzerChannelData* mSWDIO; 201 | AnalyzerChannelData* mSWCLK; 202 | 203 | SWDAnalyzer* mAnalyzer; 204 | 205 | std::vector mBitsBuffer; 206 | U32 mSelectRegister; 207 | 208 | SWDBit ParseBit(); 209 | void BufferBits( size_t num_bits ); 210 | 211 | public: 212 | SWDParser(); 213 | 214 | void Setup( AnalyzerChannelData* pSWDIO, AnalyzerChannelData* pSWCLK, SWDAnalyzer* pAnalyzer ); 215 | 216 | void Clear() 217 | { 218 | mBitsBuffer.clear(); 219 | mSelectRegister = 0; 220 | } 221 | 222 | bool IsOperation( SWDOperation& tran ); 223 | bool IsLineReset( SWDLineReset& reset ); 224 | bool IsJtagToSwd( SWDJtagToSwd& jtagToSwd ); 225 | 226 | SWDBit PopFrontBit(); 227 | }; 228 | 229 | #endif // SWD_TYPES_H 230 | -------------------------------------------------------------------------------- /src/SWDUtils.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #include "SWDUtils.h" 4 | #include "SWDTypes.h" 5 | 6 | std::string GetRegisterName( SWDRegisters reg ) 7 | { 8 | switch( reg ) 9 | { 10 | case SWDR_DP_IDCODE: 11 | return "IDCODE"; 12 | case SWDR_DP_ABORT: 13 | return "ABORT"; 14 | case SWDR_DP_CTRL_STAT: 15 | return "CTRL/STAT"; 16 | case SWDR_DP_WCR: 17 | return "WCR"; 18 | case SWDR_DP_RESEND: 19 | return "RESEND"; 20 | case SWDR_DP_SELECT: 21 | return "SELECT"; 22 | case SWDR_DP_RDBUFF: 23 | return "RDBUFF"; 24 | case SWDR_DP_ROUTESEL: 25 | return "ROUTESEL"; 26 | 27 | case SWDR_AP_CSW: 28 | return "CSW"; 29 | case SWDR_AP_TAR: 30 | return "TAR"; 31 | case SWDR_AP_DRW: 32 | return "DRW"; 33 | case SWDR_AP_BD0: 34 | return "BD0"; 35 | case SWDR_AP_BD1: 36 | return "BD1"; 37 | case SWDR_AP_BD2: 38 | return "BD2"; 39 | case SWDR_AP_BD3: 40 | return "BD3"; 41 | case SWDR_AP_CFG: 42 | return "CFG"; 43 | case SWDR_AP_BASE: 44 | return "BASE"; 45 | case SWDR_AP_RAZ_WI: 46 | return "RAZ_WI"; 47 | case SWDR_AP_IDR: 48 | return "IDR"; 49 | } 50 | 51 | return "??"; 52 | } 53 | 54 | std::string GetRegisterValueDesc( SWDRegisters reg, U32 val, DisplayBase display_base ) 55 | { 56 | std::string ret_val; 57 | 58 | switch( reg ) 59 | { 60 | case SWDR_DP_IDCODE: 61 | ret_val = "DESIGNER=" + int2str_sal( val & 0xfff, display_base, 12 ); 62 | ret_val += ", PARTNO=" + int2str_sal( ( val >> 12 ) & 0xffff, display_base, 16 ); 63 | ret_val += ", Version=" + int2str_sal( ( val >> 28 ) & 0xf, display_base, 4 ); 64 | break; 65 | case SWDR_DP_ABORT: 66 | ret_val = std::string( "ORUNERRCLR=" ) + ( ( val & 16 ) ? "1" : "0" ); 67 | ret_val += std::string( ", WDERRCLR=" ) + ( ( val & 8 ) ? "1" : "0" ); 68 | ret_val += std::string( ", STKERRCLR=" ) + ( ( val & 4 ) ? "1" : "0" ); 69 | ret_val += std::string( ", STKCMPCLR=" ) + ( ( val & 2 ) ? "1" : "0" ); 70 | ret_val += std::string( ", DAPABORT=" ) + ( ( val & 1 ) ? "1" : "0" ); 71 | break; 72 | 73 | case SWDR_DP_CTRL_STAT: 74 | ret_val = std::string( "CSYSPWRUPACK=" ) + ( ( val & ( 1 << 31 ) ) ? "1" : "0" ); 75 | ret_val += std::string( ", CSYSPWRUPREQ=" ) + ( ( val & ( 1 << 30 ) ) ? "1" : "0" ); 76 | ret_val += std::string( ", CDBGPWRUPACK=" ) + ( ( val & ( 1 << 29 ) ) ? "1" : "0" ); 77 | ret_val += std::string( ", CDBGPWRUPREQ=" ) + ( ( val & ( 1 << 28 ) ) ? "1" : "0" ); 78 | ret_val += std::string( ", CDBGRSTACK=" ) + ( ( val & ( 1 << 27 ) ) ? "1" : "0" ); 79 | ret_val += std::string( ", CDBGRSTREQ=" ) + ( ( val & ( 1 << 26 ) ) ? "1" : "0" ); 80 | ret_val += ", TRNCNT=" + int2str_sal( ( val >> 12 ) & 0xfff, display_base, 12 ); 81 | ret_val += ", MASKLANE=" + int2str_sal( ( val >> 8 ) & 0xf, display_base, 4 ); 82 | ret_val += std::string( ", WDATAERR=" ) + ( ( val & ( 1 << 7 ) ) ? "1" : "0" ); 83 | ret_val += std::string( ", READOK=" ) + ( ( val & ( 1 << 6 ) ) ? "1" : "0" ); 84 | ret_val += std::string( ", STICKYERR=" ) + ( ( val & ( 1 << 5 ) ) ? "1" : "0" ); 85 | ret_val += std::string( ", STICKYCMP=" ) + ( ( val & ( 1 << 4 ) ) ? "1" : "0" ); 86 | ret_val += ", TRNMODE="; 87 | switch( ( val >> 2 ) & 3 ) 88 | { 89 | case 0: 90 | ret_val += "Normal"; 91 | break; 92 | case 1: 93 | ret_val += "Pushed verify"; 94 | break; 95 | case 2: 96 | ret_val += "Pushed compare"; 97 | break; 98 | case 3: 99 | ret_val += "Reserved"; 100 | break; 101 | } 102 | ret_val += std::string( ", STICKYORUN=" ) + ( ( val & ( 1 << 1 ) ) ? "1" : "0" ); 103 | ret_val += std::string( ", ORUNDETECT=" ) + ( ( val & ( 1 << 0 ) ) ? "1" : "0" ); 104 | break; 105 | case SWDR_DP_WCR: 106 | ret_val = "TURNAROUND=" + int2str_sal( ( val >> 8 ) & 3, display_base, 2 ) + " data period(s)"; 107 | ret_val += ", WIREMODE=" + int2str_sal( ( val >> 4 ) & 0xf, display_base, 4 ); 108 | switch( ( val >> 6 ) & 3 ) 109 | { 110 | case 0: 111 | ret_val += "Asynchronous"; 112 | break; 113 | case 1: 114 | ret_val += "Synchronous"; 115 | break; 116 | default: 117 | ret_val += "Reserved"; 118 | break; 119 | } 120 | break; 121 | // case SWDR_DP_RESEND: break; // just raw data 122 | case SWDR_DP_SELECT: 123 | ret_val = "APSEL=" + int2str_sal( ( val >> 24 ) & 0xff, display_base ); 124 | ret_val += ", APBANKSEL=" + int2str_sal( ( val >> 4 ) & 0xf, display_base, 4 ); 125 | ret_val += ", PRESCALER=" + int2str_sal( val & 0x3, display_base, 2 ); 126 | break; 127 | // case SWDR_DP_RDBUFF: break; // just raw data 128 | // case SWDR_DP_ROUTESEL: break; // just raw data 129 | 130 | // AP 131 | case SWDR_AP_IDR: 132 | ret_val = "Revision=" + int2str_sal( val >> 28, display_base, 4 ); 133 | ret_val += ", JEP-106 continuation=" + int2str_sal( ( val >> 24 ) & 0xf, display_base, 4 ); 134 | ret_val += ", JEP-106 identity=" + int2str_sal( ( val >> 17 ) & 0x7f, display_base, 7 ); 135 | ret_val += 136 | std::string( ", Class=" ) + ( ( val & ( 1 << 16 ) ) ? "This AP is a Memory Acces Port" : "This AP is not a Memory Acces Port" ); 137 | ret_val += ", AP Identfication=" + int2str_sal( val & 0xff, display_base ); 138 | break; 139 | case SWDR_AP_CSW: 140 | ret_val = std::string( "DbgSwEnable=" ) + ( ( val & ( 1 << 31 ) ) ? "1" : "0" ); 141 | ret_val += ", Prot=" + int2str_sal( ( val >> 24 ) & 0x7f, display_base, 7 ); 142 | ret_val += std::string( ", SPIDEN=" ) + ( ( val & ( 1 << 23 ) ) ? "1" : "0" ); 143 | ret_val += ", Mode=" + int2str_sal( ( val >> 8 ) & 0xf, display_base, 4 ); 144 | ret_val += std::string( ", TrInProg=" ) + ( ( val & ( 1 << 7 ) ) ? "1" : "0" ); 145 | ret_val += std::string( ", DeviceEn=" ) + ( ( val & ( 1 << 6 ) ) ? "1" : "0" ); 146 | ret_val += ", AddrInc="; 147 | switch( ( val >> 4 ) & 0x3 ) 148 | { 149 | case 0: 150 | ret_val += "Auto-increment off"; 151 | break; 152 | case 1: 153 | ret_val += "Increment single"; 154 | break; 155 | case 2: 156 | ret_val += "Increment packed"; 157 | break; 158 | case 3: 159 | ret_val += "Reserved"; 160 | break; 161 | } 162 | ret_val += ", Size="; 163 | switch( val & 0x7 ) 164 | { 165 | case 0: 166 | ret_val += "Byte (8 bits)"; 167 | break; 168 | case 1: 169 | ret_val += "Halfword (16 bits)"; 170 | break; 171 | case 2: 172 | ret_val += "Word (32 bits)"; 173 | break; 174 | default: 175 | ret_val += "Reserved"; 176 | break; 177 | } 178 | 179 | break; 180 | // case SWDR_AP_TAR: break; // these are just raw data 181 | // case SWDR_AP_DRW: break; 182 | // case SWDR_AP_BD0: break; 183 | // case SWDR_AP_BD1: break; 184 | // case SWDR_AP_BD2: break; 185 | // case SWDR_AP_BD3: break; 186 | case SWDR_AP_CFG: 187 | if( val & 1 ) 188 | ret_val = "Big-endian"; 189 | else 190 | ret_val = "Little-endian"; 191 | 192 | break; 193 | case SWDR_AP_BASE: 194 | ret_val += "BASEADDR=" + int2str_sal( val >> 12, display_base, 20 ); 195 | ret_val += std::string( ", Format=" ) + ( ( val & ( 1 << 1 ) ) ? "1" : "0" ); 196 | ret_val += ", Entry present="; 197 | if( val & 1 ) 198 | ret_val += "Debug entry present"; 199 | else 200 | ret_val += "No debug entry present"; 201 | 202 | break; 203 | } 204 | 205 | return ret_val; 206 | } 207 | 208 | std::string int2str( const U8 i ) 209 | { 210 | char number_str[ 8 ]; 211 | AnalyzerHelpers::GetNumberString( i, Decimal, 8, number_str, sizeof( number_str ) ); 212 | return number_str; 213 | } 214 | 215 | std::string int2str_sal( const U64 i, DisplayBase base, const int max_bits ) 216 | { 217 | char number_str[ 256 ]; 218 | AnalyzerHelpers::GetNumberString( i, base, max_bits, number_str, sizeof( number_str ) ); 219 | return number_str; 220 | } 221 | -------------------------------------------------------------------------------- /src/SWDUtils.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #ifdef _WINDOWS 4 | #include 5 | #endif 6 | 7 | #include 8 | #include 9 | 10 | #include "SWDTypes.h" 11 | 12 | // returns string descriptions of the register name and the bits with values 13 | std::string GetRegisterName( SWDRegisters reg ); 14 | std::string GetRegisterValueDesc( SWDRegisters reg, U32 val, DisplayBase display_base ); 15 | 16 | std::string int2str_sal( const U64 i, DisplayBase base, const int max_bits = 8 ); 17 | inline std::string int2str( const U64 i ) 18 | { 19 | return int2str_sal( i, Decimal, 64 ); 20 | } 21 | 22 | /* 23 | // debugging helper functions -- Windows only!!! 24 | inline void debug(const std::string& str) 25 | { 26 | #if !defined(NDEBUG) && defined(_WINDOWS) 27 | ::OutputDebugStringA(("----- " + str + "\n").c_str()); 28 | #endif 29 | } 30 | 31 | inline void debug(const char* str) 32 | { 33 | #if !defined(NDEBUG) && defined(_WINDOWS) 34 | debug(std::string(str)); 35 | #endif 36 | } 37 | */ --------------------------------------------------------------------------------