<?xml version="1.0" encoding="Windows-1252"?>
<VisualStudioProject
	ProjectType="Visual C++"
	Version="9.00"
	Name="sqlite3"
	ProjectGUID="{A1A295E5-463C-437F-81CA-1F32367685DA}"
	RootNamespace="sqlite3"
	Keyword="Win32Proj"
	TargetFrameworkVersion="196613"
	>
	<Platforms>
		<Platform
			Name="Win32"
		/>
		<Platform
			Name="x64"
		/>
	</Platforms>
	<ToolFiles>
	</ToolFiles>
	<Configurations>
		<Configuration
			Name="Debug|Win32"
			ConfigurationType="2"
			InheritedPropertySheets=".\pyd_d.vsprops"
			CharacterSet="0"
			>
			<Tool
				Name="VCPreBuildEventTool"
			/>
			<Tool
				Name="VCCustomBuildTool"
			/>
			<Tool
				Name="VCXMLDataGeneratorTool"
			/>
			<Tool
				Name="VCWebServiceProxyGeneratorTool"
			/>
			<Tool
				Name="VCMIDLTool"
			/>
			<Tool
				Name="VCCLCompilerTool"
				AdditionalIncludeDirectories="$(sqlite3Dir)"
			/>
			<Tool
				Name="VCManagedResourceCompilerTool"
			/>
			<Tool
				Name="VCResourceCompilerTool"
			/>
			<Tool
				Name="VCPreLinkEventTool"
			/>
			<Tool
				Name="VCLinkerTool"
				OutputFile="$(OutDir)\$(ProjectName)_d.dll"
				ModuleDefinitionFile="$(sqlite3Dir)\sqlite3.def"
			/>
			<Tool
				Name="VCALinkTool"
			/>
			<Tool
				Name="VCManifestTool"
			/>
			<Tool
				Name="VCXDCMakeTool"
			/>
			<Tool
				Name="VCBscMakeTool"
			/>
			<Tool
				Name="VCFxCopTool"
			/>
			<Tool
				Name="VCAppVerifierTool"
			/>
			<Tool
				Name="VCPostBuildEventTool"
			/>
		</Configuration>
		<Configuration
			Name="Debug|x64"
			ConfigurationType="2"
			InheritedPropertySheets=".\pyd_d.vsprops;.\x64.vsprops"
			CharacterSet="0"
			>
			<Tool
				Name="VCPreBuildEventTool"
			/>
			<Tool
				Name="VCCustomBuildTool"
			/>
			<Tool
				Name="VCXMLDataGeneratorTool"
			/>
			<Tool
				Name="VCWebServiceProxyGeneratorTool"
			/>
			<Tool
				Name="VCMIDLTool"
				TargetEnvironment="3"
			/>
			<Tool
				Name="VCCLCompilerTool"
				AdditionalIncludeDirectories="$(sqlite3Dir)"
			/>
			<Tool
				Name="VCManagedResourceCompilerTool"
			/>
			<Tool
				Name="VCResourceCompilerTool"
			/>
			<Tool
				Name="VCPreLinkEventTool"
			/>
			<Tool
				Name="VCLinkerTool"
				OutputFile="$(OutDir)\$(ProjectName)_d.dll"
				ModuleDefinitionFile="$(sqlite3Dir)\sqlite3.def"
			/>
			<Tool
				Name="VCALinkTool"
			/>
			<Tool
				Name="VCManifestTool"
			/>
			<Tool
				Name="VCXDCMakeTool"
			/>
			<Tool
				Name="VCBscMakeTool"
			/>
			<Tool
				Name="VCFxCopTool"
			/>
			<Tool
				Name="VCAppVerifierTool"
			/>
			<Tool
				Name="VCPostBuildEventTool"
			/>
		</Configuration>
		<Configuration
			Name="Release|Win32"
			ConfigurationType="2"
			InheritedPropertySheets=".\pyd.vsprops"
			CharacterSet="0"
			WholeProgramOptimization="1"
			>
			<Tool
				Name="VCPreBuildEventTool"
			/>
			<Tool
				Name="VCCustomBuildTool"
			/>
			<Tool
				Name="VCXMLDataGeneratorTool"
			/>
			<Tool
				Name="VCWebServiceProxyGeneratorTool"
			/>
			<Tool
				Name="VCMIDLTool"
			/>
			<Tool
				Name="VCCLCompilerTool"
				AdditionalIncludeDirectories="$(sqlite3Dir)"
			/>
			<Tool
				Name="VCManagedResourceCompilerTool"
			/>
			<Tool
				Name="VCResourceCompilerTool"
			/>
			<Tool
				Name="VCPreLinkEventTool"
			/>
			<Tool
				Name="VCLinkerTool"
				OutputFile="$(OutDir)\$(ProjectName).dll"
				ModuleDefinitionFile="$(sqlite3Dir)\sqlite3.def"
			/>
			<Tool
				Name="VCALinkTool"
			/>
			<Tool
				Name="VCManifestTool"
			/>
			<Tool
				Name="VCXDCMakeTool"
			/>
			<Tool
				Name="VCBscMakeTool"
			/>
			<Tool
				Name="VCFxCopTool"
			/>
			<Tool
				Name="VCAppVerifierTool"
			/>
			<Tool
				Name="VCPostBuildEventTool"
			/>
		</Configuration>
		<Configuration
			Name="Release|x64"
			ConfigurationType="2"
			InheritedPropertySheets=".\pyd.vsprops;.\x64.vsprops"
			CharacterSet="0"
			WholeProgramOptimization="1"
			>
			<Tool
				Name="VCPreBuildEventTool"
			/>
			<Tool
				Name="VCCustomBuildTool"
			/>
			<Tool
				Name="VCXMLDataGeneratorTool"
			/>
			<Tool
				Name="VCWebServiceProxyGeneratorTool"
			/>
			<Tool
				Name="VCMIDLTool"
				TargetEnvironment="3"
			/>
			<Tool
				Name="VCCLCompilerTool"
				AdditionalIncludeDirectories="$(sqlite3Dir)"
			/>
			<Tool
				Name="VCManagedResourceCompilerTool"
			/>
			<Tool
				Name="VCResourceCompilerTool"
			/>
			<Tool
				Name="VCPreLinkEventTool"
			/>
			<Tool
				Name="VCLinkerTool"
				OutputFile="$(OutDir)\$(ProjectName).dll"
				ModuleDefinitionFile="$(sqlite3Dir)\sqlite3.def"
			/>
			<Tool
				Name="VCALinkTool"
			/>
			<Tool
				Name="VCManifestTool"
			/>
			<Tool
				Name="VCXDCMakeTool"
			/>
			<Tool
				Name="VCBscMakeTool"
			/>
			<Tool
				Name="VCFxCopTool"
			/>
			<Tool
				Name="VCAppVerifierTool"
			/>
			<Tool
				Name="VCPostBuildEventTool"
			/>
		</Configuration>
		<Configuration
			Name="PGInstrument|Win32"
			ConfigurationType="2"
			InheritedPropertySheets=".\pyd.vsprops;.\pginstrument.vsprops"
			CharacterSet="0"
			WholeProgramOptimization="1"
			>
			<Tool
				Name="VCPreBuildEventTool"
			/>
			<Tool
				Name="VCCustomBuildTool"
			/>
			<Tool
				Name="VCXMLDataGeneratorTool"
			/>
			<Tool
				Name="VCWebServiceProxyGeneratorTool"
			/>
			<Tool
				Name="VCMIDLTool"
			/>
			<Tool
				Name="VCCLCompilerTool"
				AdditionalIncludeDirectories="$(sqlite3Dir)"
			/>
			<Tool
				Name="VCManagedResourceCompilerTool"
			/>
			<Tool
				Name="VCResourceCompilerTool"
			/>
			<Tool
				Name="VCPreLinkEventTool"
			/>
			<Tool
				Name="VCLinkerTool"
				ModuleDefinitionFile="$(sqlite3Dir)\sqlite3.def"
			/>
			<Tool
				Name="VCALinkTool"
			/>
			<Tool
				Name="VCManifestTool"
			/>
			<Tool
				Name="VCXDCMakeTool"
			/>
			<Tool
				Name="VCBscMakeTool"
			/>
			<Tool
				Name="VCFxCopTool"
			/>
			<Tool
				Name="VCAppVerifierTool"
			/>
			<Tool
				Name="VCPostBuildEventTool"
			/>
		</Configuration>
		<Configuration
			Name="PGInstrument|x64"
			ConfigurationType="2"
			InheritedPropertySheets=".\pyd.vsprops;.\x64.vsprops;.\pginstrument.vsprops"
			CharacterSet="0"
			WholeProgramOptimization="1"
			>
			<Tool
				Name="VCPreBuildEventTool"
			/>
			<Tool
				Name="VCCustomBuildTool"
			/>
			<Tool
				Name="VCXMLDataGeneratorTool"
			/>
			<Tool
				Name="VCWebServiceProxyGeneratorTool"
			/>
			<Tool
				Name="VCMIDLTool"
				TargetEnvironment="3"
			/>
			<Tool
				Name="VCCLCompilerTool"
				AdditionalIncludeDirectories="$(sqlite3Dir)"
			/>
			<Tool
				Name="VCManagedResourceCompilerTool"
			/>
			<Tool
				Name="VCResourceCompilerTool"
			/>
			<Tool
				Name="VCPreLinkEventTool"
			/>
			<Tool
				Name="VCLinkerTool"
				ModuleDefinitionFile="$(sqlite3Dir)\sqlite3.def"
			/>
			<Tool
				Name="VCALinkTool"
			/>
			<Tool
				Name="VCManifestTool"
			/>
			<Tool
				Name="VCXDCMakeTool"
			/>
			<Tool
				Name="VCBscMakeTool"
			/>
			<Tool
				Name="VCFxCopTool"
			/>
			<Tool
				Name="VCAppVerifierTool"
			/>
			<Tool
				Name="VCPostBuildEventTool"
			/>
		</Configuration>
		<Configuration
			Name="PGUpdate|Win32"
			ConfigurationType="2"
			InheritedPropertySheets=".\pyd.vsprops;.\pgupdate.vsprops"
			CharacterSet="0"
			WholeProgramOptimization="1"
			>
			<Tool
				Name="VCPreBuildEventTool"
			/>
			<Tool
				Name="VCCustomBuildTool"
			/>
			<Tool
				Name="VCXMLDataGeneratorTool"
			/>
			<Tool
				Name="VCWebServiceProxyGeneratorTool"
			/>
			<Tool
				Name="VCMIDLTool"
			/>
			<Tool
				Name="VCCLCompilerTool"
				AdditionalIncludeDirectories="$(sqlite3Dir)"
			/>
			<Tool
				Name="VCManagedResourceCompilerTool"
			/>
			<Tool
				Name="VCResourceCompilerTool"
			/>
			<Tool
				Name="VCPreLinkEventTool"
			/>
			<Tool
				Name="VCLinkerTool"
				ModuleDefinitionFile="$(sqlite3Dir)\sqlite3.def"
			/>
			<Tool
				Name="VCALinkTool"
			/>
			<Tool
				Name="VCManifestTool"
			/>
			<Tool
				Name="VCXDCMakeTool"
			/>
			<Tool
				Name="VCBscMakeTool"
			/>
			<Tool
				Name="VCFxCopTool"
			/>
			<Tool
				Name="VCAppVerifierTool"
			/>
			<Tool
				Name="VCPostBuildEventTool"
			/>
		</Configuration>
		<Configuration
			Name="PGUpdate|x64"
			ConfigurationType="2"
			InheritedPropertySheets=".\pyd.vsprops;.\x64.vsprops;.\pgupdate.vsprops"
			CharacterSet="0"
			WholeProgramOptimization="1"
			>
			<Tool
				Name="VCPreBuildEventTool"
			/>
			<Tool
				Name="VCCustomBuildTool"
			/>
			<Tool
				Name="VCXMLDataGeneratorTool"
			/>
			<Tool
				Name="VCWebServiceProxyGeneratorTool"
			/>
			<Tool
				Name="VCMIDLTool"
				TargetEnvironment="3"
			/>
			<Tool
				Name="VCCLCompilerTool"
				AdditionalIncludeDirectories="$(sqlite3Dir)"
			/>
			<Tool
				Name="VCManagedResourceCompilerTool"
			/>
			<Tool
				Name="VCResourceCompilerTool"
			/>
			<Tool
				Name="VCPreLinkEventTool"
			/>
			<Tool
				Name="VCLinkerTool"
				ModuleDefinitionFile="$(sqlite3Dir)\sqlite3.def"
			/>
			<Tool
				Name="VCALinkTool"
			/>
			<Tool
				Name="VCManifestTool"
			/>
			<Tool
				Name="VCXDCMakeTool"
			/>
			<Tool
				Name="VCBscMakeTool"
			/>
			<Tool
				Name="VCFxCopTool"
			/>
			<Tool
				Name="VCAppVerifierTool"
			/>
			<Tool
				Name="VCPostBuildEventTool"
			/>
		</Configuration>
	</Configurations>
	<References>
	</References>
	<Files>
		<Filter
			Name="Header Files"
			>
			<File
				RelativePath="$(sqlite3Dir)\btree.h"
				>
			</File>
			<File
				RelativePath="$(sqlite3Dir)\hash.h"
				>
			</File>
			<File
				RelativePath="$(sqlite3Dir)\keywordhash.h"
				>
			</File>
			<File
				RelativePath="$(sqlite3Dir)\opcodes.h"
				>
			</File>
			<File
				RelativePath="$(sqlite3Dir)\os.h"
				>
			</File>
			<File
				RelativePath="$(sqlite3Dir)\os_common.h"
				>
			</File>
			<File
				RelativePath="$(sqlite3Dir)\pager.h"
				>
			</File>
			<File
				RelativePath="$(sqlite3Dir)\parse.h"
				>
			</File>
			<File
				RelativePath="$(sqlite3Dir)\sqlite3.h"
				>
			</File>
			<File
				RelativePath="$(sqlite3Dir)\sqliteInt.h"
				>
			</File>
			<File
				RelativePath="$(sqlite3Dir)\vdbe.h"
				>
			</File>
			<File
				RelativePath="$(sqlite3Dir)\vdbeInt.h"
				>
			</File>
		</Filter>
		<Filter
			Name="Source Files"
			>
			<File
				RelativePath="$(sqlite3Dir)\alter.c"
				>
			</File>
			<File
				RelativePath="$(sqlite3Dir)\analyze.c"
				>
			</File>
			<File
				RelativePath="$(sqlite3Dir)\attach.c"
				>
			</File>
			<File
				RelativePath="$(sqlite3Dir)\auth.c"
				>
			</File>
			<File
				RelativePath="$(sqlite3Dir)\btree.c"
				>
			</File>
			<File
				RelativePath="$(sqlite3Dir)\build.c"
				>
			</File>
			<File
				RelativePath="$(sqlite3Dir)\callback.c"
				>
			</File>
			<File
				RelativePath="$(sqlite3Dir)\complete.c"
				>
			</File>
			<File
				RelativePath="$(sqlite3Dir)\date.c"
				>
			</File>
			<File
				RelativePath="$(sqlite3Dir)\delete.c"
				>
			</File>
			<File
				RelativePath="$(sqlite3Dir)\expr.c"
				>
			</File>
			<File
				RelativePath="$(sqlite3Dir)\func.c"
				>
			</File>
			<File
				RelativePath="$(sqlite3Dir)\hash.c"
				>
			</File>
			<File
				RelativePath="$(sqlite3Dir)\insert.c"
				>
			</File>
			<File
				RelativePath="$(sqlite3Dir)\legacy.c"
				>
			</File>
			<File
				RelativePath="$(sqlite3Dir)\main.c"
				>
			</File>
			<File
				RelativePath="$(sqlite3Dir)\opcodes.c"
				>
			</File>
			<File
				RelativePath="$(sqlite3Dir)\os.c"
				>
			</File>
			<File
				RelativePath="$(sqlite3Dir)\os_unix.c"
				>
			</File>
			<File
				RelativePath="$(sqlite3Dir)\os_win.c"
				>
			</File>
			<File
				RelativePath="$(sqlite3Dir)\pager.c"
				>
			</File>
			<File
				RelativePath="$(sqlite3Dir)\parse.c"
				>
			</File>
			<File
				RelativePath="$(sqlite3Dir)\pragma.c"
				>
			</File>
			<File
				RelativePath="$(sqlite3Dir)\prepare.c"
				>
			</File>
			<File
				RelativePath="$(sqlite3Dir)\printf.c"
				>
			</File>
			<File
				RelativePath="$(sqlite3Dir)\random.c"
				>
			</File>
			<File
				RelativePath="$(sqlite3Dir)\select.c"
				>
			</File>
			<File
				RelativePath="$(sqlite3Dir)\shell.c"
				>
			</File>
			<File
				RelativePath="$(sqlite3Dir)\table.c"
				>
			</File>
			<File
				RelativePath="$(sqlite3Dir)\tokenize.c"
				>
			</File>
			<File
				RelativePath="$(sqlite3Dir)\trigger.c"
				>
			</File>
			<File
				RelativePath="$(sqlite3Dir)\update.c"
				>
			</File>
			<File
				RelativePath="$(sqlite3Dir)\utf.c"
				>
			</File>
			<File
				RelativePath="$(sqlite3Dir)\util.c"
				>
			</File>
			<File
				RelativePath="$(sqlite3Dir)\vacuum.c"
				>
			</File>
			<File
				RelativePath="$(sqlite3Dir)\vdbe.c"
				>
			</File>
			<File
				RelativePath="$(sqlite3Dir)\vdbeapi.c"
				>
			</File>
			<File
				RelativePath="$(sqlite3Dir)\vdbeaux.c"
				>
			</File>
			<File
				RelativePath="$(sqlite3Dir)\vdbefifo.c"
				>
			</File>
			<File
				RelativePath="$(sqlite3Dir)\vdbemem.c"
				>
			</File>
			<File
				RelativePath="$(sqlite3Dir)\where.c"
				>
			</File>
		</Filter>
	</Files>
	<Globals>
	</Globals>
</VisualStudioProject>
