diff --git a/.gitignore b/.gitignore
index 9b81272..0707742 100644
--- a/.gitignore
+++ b/.gitignore
@@ -8,18 +8,6 @@
 *.so.*
 icd/common/libicd.a
 icd/intel/intel_gpa.c
-loader/dispatch.c
-loader/table_ops.h
-tests/xgl_image_tests
-tests/xgl_render_tests
-tests/xglbase
-tests/xglinfo
-layers/xgl_dispatch_table_helper.h
-layers/xgl_enum_string_helper.h
-layers/xgl_generic_intercept_proc_helper.h
-layers/xgl_struct_string_helper.h
-layers/xgl_struct_wrappers.cpp
-layers/xgl_struct_wrappers.h
 _out64
 out32/*
 out64/*
@@ -36,3 +24,5 @@
 *.vcxproj
 *.sdf
 *.filters
+build
+dbuild
diff --git a/BUILD.md b/BUILD.md
index ac5deb1..926cf87 100644
--- a/BUILD.md
+++ b/BUILD.md
@@ -68,7 +68,7 @@
 
 Example debug build:
 ```
-cd YOUR_DEV_DIRECTORY  # cd to the root of the xgl git repository
+cd YOUR_DEV_DIRECTORY  # cd to the root of the vk git repository
 export KHRONOS_ACCOUNT_NAME= <subversion login name for svn checkout of BIL>
 ./update_external_sources.sh  # fetches and builds glslang, llvm, LunarGLASS, and BIL
 cmake -H. -Bdbuild -DCMAKE_BUILD_TYPE=Debug
@@ -76,30 +76,30 @@
 make
 ```
 
-To run XGL programs you must tell the icd loader where to find the libraries. Set the
-environment variable LIBXGL_DRIVERS_PATH to the driver path. For example:
+To run VK programs you must tell the icd loader where to find the libraries. Set the
+environment variable LIBVK_DRIVERS_PATH to the driver path. For example:
 ```
-export LIBXGL_DRIVERS_PATH=$PWD/icd/intel
+export LIBVK_DRIVERS_PATH=$PWD/icd/intel
 ```
 
-To enable debug and validation layers with your XGL programs you must tell the icd loader
-where to find the layer libraries. Set the environment variable LIBXGL_LAYERS_PATH to
-the layer folder and indicate the layers you want loaded via LIBXGL_LAYER_NAMES.
+To enable debug and validation layers with your VK programs you must tell the icd loader
+where to find the layer libraries. Set the environment variable LIBVK_LAYERS_PATH to
+the layer folder and indicate the layers you want loaded via LIBVK_LAYER_NAMES.
 For example, to enable the APIDump and DrawState layers, do:
 ```
-export LIBXGL_LAYERS_PATH=$PWD/layers
-export LIBXGL_LAYER_NAMES=APIDump:DrawState
+export LIBVK_LAYERS_PATH=$PWD/layers
+export LIBVK_LAYER_NAMES=APIDump:DrawState
 ```
 
 ##Linux Test
 
 The test executibles can be found in the dbuild/tests directory. The tests use the Google
 gtest infrastructure. Tests available so far:
-- xglinfo: Report GPU properties
-- xglbase: Test basic entry points
-- xgl_blit_tests: Test XGL Blits (copy, clear, and resolve)
-- xgl_image_tests: Test XGL image related calls needed by render_test
-- xgl_render_tests: Render a single triangle with XGL. Triangle will be in a .ppm in
+- vkinfo: Report GPU properties
+- vkbase: Test basic entry points
+- vk_blit_tests: Test VK Blits (copy, clear, and resolve)
+- vk_image_tests: Test VK image related calls needed by render_test
+- vk_render_tests: Render a single triangle with VK. Triangle will be in a .ppm in
 the current directory at the end of the test.
 
 ##Linux Demos
@@ -162,23 +162,23 @@
 
 Example debug build:
 ```
-cd GL-Next  # cd to the root of the xgl git repository
+cd GL-Next  # cd to the root of the vk git repository
 mkdir _out64
 cd _out64
 cmake -G "Visual Studio 12 Win64" -DCMAKE_BUILD_TYPE=Debug ..
 ```
 
-At this point, you can use Windows Explorer to launch Visual Studio by double-clicking on the "XGL.sln" file in the _out64 folder.  Once Visual Studio comes up, you can select "Debug" or "Release" from a drop-down list.  You can start a build with either the menu (Build->Build Solution), or a keyboard shortcut (Ctrl+Shift+B).  As part of the build process, Python scripts will create additional Visual Studio files and projects, along with additional source files.  All of these auto-generated files are under the "_out64" folder.
+At this point, you can use Windows Explorer to launch Visual Studio by double-clicking on the "VK.sln" file in the _out64 folder.  Once Visual Studio comes up, you can select "Debug" or "Release" from a drop-down list.  You can start a build with either the menu (Build->Build Solution), or a keyboard shortcut (Ctrl+Shift+B).  As part of the build process, Python scripts will create additional Visual Studio files and projects, along with additional source files.  All of these auto-generated files are under the "_out64" folder.
 
-XGL programs must be able to find and use the XGL.dll libary. Make sure it is either installed in the C:\Windows\System32 folder, or the PATH enviroment variable includes the folder that it is located in.
+VK programs must be able to find and use the VK.dll libary. Make sure it is either installed in the C:\Windows\System32 folder, or the PATH enviroment variable includes the folder that it is located in.
 
-To run XGL programs you must have an appropriate ICD (installable client driver) that is either installed in the C:\Windows\System32 folder, or pointed to by the registry and/or an environment variable:
+To run VK programs you must have an appropriate ICD (installable client driver) that is either installed in the C:\Windows\System32 folder, or pointed to by the registry and/or an environment variable:
 
 - Registry:
   - Root Key: HKEY_LOCAL_MACHINE
-  - Key: "SOFTWARE\XGL"
-  - Value: "XGL_DRIVERS_PATH" (semi-colon-delimited set of folders to look for ICDs)
-- Environment Variable: "XGL_DRIVERS_PATH" (semi-colon-delimited set of folders to look for ICDs)
+  - Key: "SOFTWARE\VK"
+  - Value: "VK_DRIVERS_PATH" (semi-colon-delimited set of folders to look for ICDs)
+- Environment Variable: "VK_DRIVERS_PATH" (semi-colon-delimited set of folders to look for ICDs)
 
 Note: If both the registry value and environment variable are used, they are concatenated into a new semi-colon-delimited list of folders.
 
@@ -188,24 +188,24 @@
 - Within the search box, type "environment variable" and click on "Edit the system environment variables" (or navigate there via "System and Security->System->Advanced system settings").
 - This will launch a window with several tabs, one of which is "Advanced".  Click on the "Environment Variables..." button.
 - For either "User variables" or "System variables" click "New...".
-- Enter "XGL_DRIVERS_PATH" as the variable name, and an appropriate Windows path to where your driver DLL is (e.g. C:\Users\username\GL-Next\_out64\icd\drivername\Debug).
+- Enter "VK_DRIVERS_PATH" as the variable name, and an appropriate Windows path to where your driver DLL is (e.g. C:\Users\username\GL-Next\_out64\icd\drivername\Debug).
 
 It is possible to specify multiple icd folders.  Simply use a semi-colon (i.e. ";") to separate folders in the environment variable.
 
-The icd loader searches in all of the folders for files that are named "XGL_*.dll" (e.g. "XGL_foo.dll").  It attempts to dynamically load these files, and look for appropriate functions.
+The icd loader searches in all of the folders for files that are named "VK_*.dll" (e.g. "VK_foo.dll").  It attempts to dynamically load these files, and look for appropriate functions.
 
-To enable debug and validation layers with your XGL programs you must tell the icd loader
+To enable debug and validation layers with your VK programs you must tell the icd loader
 where to find the layer libraries, and which ones you desire to use.  The default folder for layers is C:\Windows\System32. Again, this can be pointed to by the registry and/or an environment variable:
 
 - Registry:
   - Root Key: HKEY_LOCAL_MACHINE
-  - Key: "System\XGL"
-  - Value: "XGL_LAYERS_PATH" (semi-colon-delimited set of folders to look for layers)
-  - Value: "XGL_LAYER_NAMES" (semi-colon-delimited list of layer names)
+  - Key: "System\VK"
+  - Value: "VK_LAYERS_PATH" (semi-colon-delimited set of folders to look for layers)
+  - Value: "VK_LAYER_NAMES" (semi-colon-delimited list of layer names)
 - Environment Variables:
-  - "XGL_LAYERS_PATH" (semi-colon-delimited set of folders to look for layers)
-  - "XGL_LAYER_NAMES" (semi-colon-delimited list of layer names)
+  - "VK_LAYERS_PATH" (semi-colon-delimited set of folders to look for layers)
+  - "VK_LAYER_NAMES" (semi-colon-delimited list of layer names)
 
 Note: If both the registry value and environment variable are used, they are concatenated into a new semi-colon-delimited list.
 
-The icd loader searches in all of the folders for files that are named "XGLLayer*.dll" (e.g. "XGLLayerParamChecker.dll").  It attempts to dynamically load these files, and look for appropriate functions.
+The icd loader searches in all of the folders for files that are named "VKLayer*.dll" (e.g. "VKLayerParamChecker.dll").  It attempts to dynamically load these files, and look for appropriate functions.
diff --git a/README.md b/README.md
index 72ba984..c62fa69 100644
--- a/README.md
+++ b/README.md
@@ -1,13 +1,13 @@
-# Explicit GL (XGL) Ecosystem Components
+# Explicit GL (VK) Ecosystem Components
 *Version 0.8, 04 Feb 2015*
 
-This project provides *open source* tools for XGL Developers.
+This project provides *open source* tools for VK Developers.
 
 ## Introduction
 
-XGL is an Explicit API, enabling direct control over how GPUs actually work. No validation, shader recompilation, memory management or synchronization is done inside an XGL driver. Applications have full control and responsibility. Any errors in how XGL is used are likely to result in a crash. This project provides layered utility libraries to ease development and help guide developers to proven safe patterns.
+VK is an Explicit API, enabling direct control over how GPUs actually work. No validation, shader recompilation, memory management or synchronization is done inside an VK driver. Applications have full control and responsibility. Any errors in how VK is used are likely to result in a crash. This project provides layered utility libraries to ease development and help guide developers to proven safe patterns.
 
-New with XGL in an extensible layered architecture that enables significant innovation in tools:
+New with VK in an extensible layered architecture that enables significant innovation in tools:
 - Cross IHV support enables tools vendors to plug into a common, extensible layer architecture
 - Layered tools during development enable validating, debugging and profiling without production performance impact
 - Modular validation architecture encourages many fine-grained layers--and new layers can be added easily
@@ -19,9 +19,9 @@
 demos for GDC.
 
 The following components are available:
-- XGL Library and header files, which include:
+- VK Library and header files, which include:
     - [*ICD Loader*](loader) and [*Layer Manager*](layers/README.md)
-    - Snapshot of *XGL* and *BIL* header files from [*Khronos*](www.khronos.org)
+    - Snapshot of *VK* and *BIL* header files from [*Khronos*](www.khronos.org)
     
 - [*GLAVE Debugger*](tools/glave)
 
@@ -33,7 +33,7 @@
 
 ## New
 
-- Updated loader, driver, demos, tests and many tools to use "alpha" xgl.h (~ version 47).
+- Updated loader, driver, demos, tests and many tools to use "alpha" vulkan.h (~ version 47).
   Supports new resource binding model, memory allocation, pixel FORMATs and
   other updates.
   APIDump layer is working with these new API elements.
@@ -44,9 +44,9 @@
 
 ## Prior updates
 
-- XGL API trace and capture tools. See tools/glave/README.md for details.
+- VK API trace and capture tools. See tools/glave/README.md for details.
 - Sample driver now supports multiple render targets. Added TriangleMRT to test that functionality.
-- Added XGL_SLOT_SHADER_TEXTURE_RESOURCE to xgl.h as a descriptor slot type to work around confusion in GLSL
+- Added VK_SLOT_SHADER_TEXTURE_RESOURCE to vulkan.h as a descriptor slot type to work around confusion in GLSL
   between textures and buffers as shader resources.
 - Misc. fixes for layers and Intel sample driver
 - Added mutex to APIDump, APIDumpFile and DrawState to prevent apparent threading issues using printf
@@ -70,24 +70,24 @@
 
 ## References
 This version of the components are written based on the following preliminary specs and proposals:
-- [**XGL Programers Reference**, 1 Jul 2014](https://cvs.khronos.org/svn/repos/oglc/trunk/nextgen/proposals/AMD/Explicit%20GL%20Programming%20Guide%20and%20API%20Reference.pdf)
+- [**VK Programers Reference**, 1 Jul 2014](https://cvs.khronos.org/svn/repos/oglc/trunk/nextgen/proposals/AMD/Explicit%20GL%20Programming%20Guide%20and%20API%20Reference.pdf)
 - [**BIL**, revision 29](https://cvs.khronos.org/svn/repos/oglc/trunk/nextgen/proposals/BIL/Specification/BIL.html)
 
 ## License
 This work is intended to be released as open source under a BSD-style
-license once the XGL specification is public. Until that time, this work
-is covered by the Khronos NDA governing the details of the XGL API.
+license once the VK specification is public. Until that time, this work
+is covered by the Khronos NDA governing the details of the VK API.
 
 ## Acknowledgements
 While this project is being developed by LunarG, Inc; there are many other
 companies and individuals making this possible: Valve Software, funding
 project development; Intel Corporation, providing full hardware specifications
-and valuable technical feedback; AMD, providing XGL spec editor contributions;
+and valuable technical feedback; AMD, providing VK spec editor contributions;
 ARM, contributing a Chairman for this working group within Khronos; Nvidia,
 providing an initial co-editor for the spec; Qualcomm for picking up the
 co-editor's chair; and Khronos, for providing hosting within GitHub.
 
 ## Contact
 If you have questions or comments about this driver; or you would like to contribute
-directly to this effort, please contact us at XGL@LunarG.com; or if you prefer, via
+directly to this effort, please contact us at VK@LunarG.com; or if you prefer, via
 the GL Common mailing list: gl_common@khronos.org
diff --git a/include/xgl.h b/include/xgl.h
index b937d42..b78a56c 100644
--- a/include/xgl.h
+++ b/include/xgl.h
@@ -1,5 +1,5 @@
 //
-// File: xgl.h
+// File: vulkan.h
 //
 /*
 ** Copyright (c) 2014 The Khronos Group Inc.
@@ -24,16 +24,16 @@
 ** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
 */
 
-#ifndef __XGL_H__
-#define __XGL_H__
+#ifndef __VULKAN_H__
+#define __VULKAN_H__
 
-#define XGL_MAKE_VERSION(major, minor, patch) \
+#define VK_MAKE_VERSION(major, minor, patch) \
     ((major << 22) | (minor << 12) | patch)
 
-#include "xglPlatform.h"
+#include "vkPlatform.h"
 
-// XGL API version supported by this file
-#define XGL_API_VERSION XGL_MAKE_VERSION(0, 67, 0)
+// VK API version supported by this file
+#define VK_API_VERSION VK_MAKE_VERSION(0, 67, 0)
 
 #ifdef __cplusplus
 extern "C"
@@ -42,1275 +42,1275 @@
 
 /*
 ***************************************************************************************************
-*   Core XGL API
+*   Core VK API
 ***************************************************************************************************
 */
 
 #ifdef __cplusplus
-    #define XGL_DEFINE_HANDLE(_obj) struct _obj##_T {char _dummy;}; typedef _obj##_T* _obj;
-    #define XGL_DEFINE_SUBCLASS_HANDLE(_obj, _base) struct _obj##_T : public _base##_T {}; typedef _obj##_T* _obj;
+    #define VK_DEFINE_HANDLE(_obj) struct _obj##_T {char _dummy;}; typedef _obj##_T* _obj;
+    #define VK_DEFINE_SUBCLASS_HANDLE(_obj, _base) struct _obj##_T : public _base##_T {}; typedef _obj##_T* _obj;
 #else // __cplusplus
-    #define XGL_DEFINE_HANDLE(_obj) typedef void* _obj;
-    #define XGL_DEFINE_SUBCLASS_HANDLE(_obj, _base) typedef void* _obj;
+    #define VK_DEFINE_HANDLE(_obj) typedef void* _obj;
+    #define VK_DEFINE_SUBCLASS_HANDLE(_obj, _base) typedef void* _obj;
 #endif // __cplusplus
 
-XGL_DEFINE_HANDLE(XGL_INSTANCE)
-XGL_DEFINE_HANDLE(XGL_PHYSICAL_GPU)
-XGL_DEFINE_HANDLE(XGL_BASE_OBJECT)
-XGL_DEFINE_SUBCLASS_HANDLE(XGL_DEVICE, XGL_BASE_OBJECT)
-XGL_DEFINE_SUBCLASS_HANDLE(XGL_QUEUE, XGL_BASE_OBJECT)
-XGL_DEFINE_SUBCLASS_HANDLE(XGL_GPU_MEMORY, XGL_BASE_OBJECT)
-XGL_DEFINE_SUBCLASS_HANDLE(XGL_OBJECT, XGL_BASE_OBJECT)
-XGL_DEFINE_SUBCLASS_HANDLE(XGL_BUFFER, XGL_OBJECT)
-XGL_DEFINE_SUBCLASS_HANDLE(XGL_BUFFER_VIEW, XGL_OBJECT)
-XGL_DEFINE_SUBCLASS_HANDLE(XGL_IMAGE, XGL_OBJECT)
-XGL_DEFINE_SUBCLASS_HANDLE(XGL_IMAGE_VIEW, XGL_OBJECT)
-XGL_DEFINE_SUBCLASS_HANDLE(XGL_COLOR_ATTACHMENT_VIEW, XGL_OBJECT)
-XGL_DEFINE_SUBCLASS_HANDLE(XGL_DEPTH_STENCIL_VIEW, XGL_OBJECT)
-XGL_DEFINE_SUBCLASS_HANDLE(XGL_SHADER, XGL_OBJECT)
-XGL_DEFINE_SUBCLASS_HANDLE(XGL_PIPELINE, XGL_OBJECT)
-XGL_DEFINE_SUBCLASS_HANDLE(XGL_SAMPLER, XGL_OBJECT)
-XGL_DEFINE_SUBCLASS_HANDLE(XGL_DESCRIPTOR_SET, XGL_OBJECT)
-XGL_DEFINE_SUBCLASS_HANDLE(XGL_DESCRIPTOR_SET_LAYOUT, XGL_OBJECT)
-XGL_DEFINE_SUBCLASS_HANDLE(XGL_DESCRIPTOR_SET_LAYOUT_CHAIN, XGL_OBJECT)
-XGL_DEFINE_SUBCLASS_HANDLE(XGL_DESCRIPTOR_POOL, XGL_OBJECT)
-XGL_DEFINE_SUBCLASS_HANDLE(XGL_DYNAMIC_STATE_OBJECT, XGL_OBJECT)
-XGL_DEFINE_SUBCLASS_HANDLE(XGL_DYNAMIC_VP_STATE_OBJECT, XGL_DYNAMIC_STATE_OBJECT)
-XGL_DEFINE_SUBCLASS_HANDLE(XGL_DYNAMIC_RS_STATE_OBJECT, XGL_DYNAMIC_STATE_OBJECT)
-XGL_DEFINE_SUBCLASS_HANDLE(XGL_DYNAMIC_CB_STATE_OBJECT, XGL_DYNAMIC_STATE_OBJECT)
-XGL_DEFINE_SUBCLASS_HANDLE(XGL_DYNAMIC_DS_STATE_OBJECT, XGL_DYNAMIC_STATE_OBJECT)
-XGL_DEFINE_SUBCLASS_HANDLE(XGL_CMD_BUFFER, XGL_OBJECT)
-XGL_DEFINE_SUBCLASS_HANDLE(XGL_FENCE, XGL_OBJECT)
-XGL_DEFINE_SUBCLASS_HANDLE(XGL_SEMAPHORE, XGL_OBJECT)
-XGL_DEFINE_SUBCLASS_HANDLE(XGL_EVENT, XGL_OBJECT)
-XGL_DEFINE_SUBCLASS_HANDLE(XGL_QUERY_POOL, XGL_OBJECT)
-XGL_DEFINE_SUBCLASS_HANDLE(XGL_FRAMEBUFFER, XGL_OBJECT)
-XGL_DEFINE_SUBCLASS_HANDLE(XGL_RENDER_PASS, XGL_OBJECT)
+VK_DEFINE_HANDLE(VK_INSTANCE)
+VK_DEFINE_HANDLE(VK_PHYSICAL_GPU)
+VK_DEFINE_HANDLE(VK_BASE_OBJECT)
+VK_DEFINE_SUBCLASS_HANDLE(VK_DEVICE, VK_BASE_OBJECT)
+VK_DEFINE_SUBCLASS_HANDLE(VK_QUEUE, VK_BASE_OBJECT)
+VK_DEFINE_SUBCLASS_HANDLE(VK_GPU_MEMORY, VK_BASE_OBJECT)
+VK_DEFINE_SUBCLASS_HANDLE(VK_OBJECT, VK_BASE_OBJECT)
+VK_DEFINE_SUBCLASS_HANDLE(VK_BUFFER, VK_OBJECT)
+VK_DEFINE_SUBCLASS_HANDLE(VK_BUFFER_VIEW, VK_OBJECT)
+VK_DEFINE_SUBCLASS_HANDLE(VK_IMAGE, VK_OBJECT)
+VK_DEFINE_SUBCLASS_HANDLE(VK_IMAGE_VIEW, VK_OBJECT)
+VK_DEFINE_SUBCLASS_HANDLE(VK_COLOR_ATTACHMENT_VIEW, VK_OBJECT)
+VK_DEFINE_SUBCLASS_HANDLE(VK_DEPTH_STENCIL_VIEW, VK_OBJECT)
+VK_DEFINE_SUBCLASS_HANDLE(VK_SHADER, VK_OBJECT)
+VK_DEFINE_SUBCLASS_HANDLE(VK_PIPELINE, VK_OBJECT)
+VK_DEFINE_SUBCLASS_HANDLE(VK_SAMPLER, VK_OBJECT)
+VK_DEFINE_SUBCLASS_HANDLE(VK_DESCRIPTOR_SET, VK_OBJECT)
+VK_DEFINE_SUBCLASS_HANDLE(VK_DESCRIPTOR_SET_LAYOUT, VK_OBJECT)
+VK_DEFINE_SUBCLASS_HANDLE(VK_DESCRIPTOR_SET_LAYOUT_CHAIN, VK_OBJECT)
+VK_DEFINE_SUBCLASS_HANDLE(VK_DESCRIPTOR_POOL, VK_OBJECT)
+VK_DEFINE_SUBCLASS_HANDLE(VK_DYNAMIC_STATE_OBJECT, VK_OBJECT)
+VK_DEFINE_SUBCLASS_HANDLE(VK_DYNAMIC_VP_STATE_OBJECT, VK_DYNAMIC_STATE_OBJECT)
+VK_DEFINE_SUBCLASS_HANDLE(VK_DYNAMIC_RS_STATE_OBJECT, VK_DYNAMIC_STATE_OBJECT)
+VK_DEFINE_SUBCLASS_HANDLE(VK_DYNAMIC_CB_STATE_OBJECT, VK_DYNAMIC_STATE_OBJECT)
+VK_DEFINE_SUBCLASS_HANDLE(VK_DYNAMIC_DS_STATE_OBJECT, VK_DYNAMIC_STATE_OBJECT)
+VK_DEFINE_SUBCLASS_HANDLE(VK_CMD_BUFFER, VK_OBJECT)
+VK_DEFINE_SUBCLASS_HANDLE(VK_FENCE, VK_OBJECT)
+VK_DEFINE_SUBCLASS_HANDLE(VK_SEMAPHORE, VK_OBJECT)
+VK_DEFINE_SUBCLASS_HANDLE(VK_EVENT, VK_OBJECT)
+VK_DEFINE_SUBCLASS_HANDLE(VK_QUERY_POOL, VK_OBJECT)
+VK_DEFINE_SUBCLASS_HANDLE(VK_FRAMEBUFFER, VK_OBJECT)
+VK_DEFINE_SUBCLASS_HANDLE(VK_RENDER_PASS, VK_OBJECT)
 
-#define XGL_MAX_PHYSICAL_GPUS       16
-#define XGL_MAX_PHYSICAL_GPU_NAME   256
+#define VK_MAX_PHYSICAL_GPUS       16
+#define VK_MAX_PHYSICAL_GPU_NAME   256
 
-#define XGL_LOD_CLAMP_NONE       MAX_FLOAT
-#define XGL_LAST_MIP_OR_SLICE    0xffffffff
+#define VK_LOD_CLAMP_NONE       MAX_FLOAT
+#define VK_LAST_MIP_OR_SLICE    0xffffffff
 
-#define XGL_TRUE  1
-#define XGL_FALSE 0
+#define VK_TRUE  1
+#define VK_FALSE 0
 
-#define XGL_NULL_HANDLE 0
+#define VK_NULL_HANDLE 0
 
 // This macro defines INT_MAX in enumerations to force compilers to use 32 bits
 // to represent them. This may or may not be necessary on some compilers. The
 // option to compile it out may allow compilers that warn about missing enumerants
 // in switch statements to be silenced.
-#define XGL_MAX_ENUM(T) T##_MAX_ENUM = 0x7FFFFFFF
+#define VK_MAX_ENUM(T) T##_MAX_ENUM = 0x7FFFFFFF
 
 // ------------------------------------------------------------------------------------------------
 // Enumerations
 
 
-typedef enum _XGL_MEMORY_PRIORITY
+typedef enum _VK_MEMORY_PRIORITY
 {
-    XGL_MEMORY_PRIORITY_UNUSED                              = 0x0,
-    XGL_MEMORY_PRIORITY_VERY_LOW                            = 0x1,
-    XGL_MEMORY_PRIORITY_LOW                                 = 0x2,
-    XGL_MEMORY_PRIORITY_NORMAL                              = 0x3,
-    XGL_MEMORY_PRIORITY_HIGH                                = 0x4,
-    XGL_MEMORY_PRIORITY_VERY_HIGH                           = 0x5,
+    VK_MEMORY_PRIORITY_UNUSED                              = 0x0,
+    VK_MEMORY_PRIORITY_VERY_LOW                            = 0x1,
+    VK_MEMORY_PRIORITY_LOW                                 = 0x2,
+    VK_MEMORY_PRIORITY_NORMAL                              = 0x3,
+    VK_MEMORY_PRIORITY_HIGH                                = 0x4,
+    VK_MEMORY_PRIORITY_VERY_HIGH                           = 0x5,
 
-    XGL_MEMORY_PRIORITY_BEGIN_RANGE                         = XGL_MEMORY_PRIORITY_UNUSED,
-    XGL_MEMORY_PRIORITY_END_RANGE                           = XGL_MEMORY_PRIORITY_VERY_HIGH,
-    XGL_NUM_MEMORY_PRIORITY                                 = (XGL_MEMORY_PRIORITY_END_RANGE - XGL_MEMORY_PRIORITY_BEGIN_RANGE + 1),
-    XGL_MAX_ENUM(_XGL_MEMORY_PRIORITY)
-} XGL_MEMORY_PRIORITY;
+    VK_MEMORY_PRIORITY_BEGIN_RANGE                         = VK_MEMORY_PRIORITY_UNUSED,
+    VK_MEMORY_PRIORITY_END_RANGE                           = VK_MEMORY_PRIORITY_VERY_HIGH,
+    VK_NUM_MEMORY_PRIORITY                                 = (VK_MEMORY_PRIORITY_END_RANGE - VK_MEMORY_PRIORITY_BEGIN_RANGE + 1),
+    VK_MAX_ENUM(_VK_MEMORY_PRIORITY)
+} VK_MEMORY_PRIORITY;
 
-typedef enum _XGL_IMAGE_LAYOUT
+typedef enum _VK_IMAGE_LAYOUT
 {
-    XGL_IMAGE_LAYOUT_UNDEFINED                              = 0x00000000,   // Implicit layout an image is when its contents are undefined due to various reasons (e.g. right after creation)
-    XGL_IMAGE_LAYOUT_GENERAL                                = 0x00000001,   // General layout when image can be used for any kind of access
-    XGL_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL               = 0x00000002,   // Optimal layout when image is only used for color attachment read/write
-    XGL_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL       = 0x00000003,   // Optimal layout when image is only used for depth/stencil attachment read/write
-    XGL_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL        = 0x00000004,   // Optimal layout when image is used for read only depth/stencil attachment and shader access
-    XGL_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL               = 0x00000005,   // Optimal layout when image is used for read only shader access
-    XGL_IMAGE_LAYOUT_CLEAR_OPTIMAL                          = 0x00000006,   // Optimal layout when image is used only for clear operations
-    XGL_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL                = 0x00000007,   // Optimal layout when image is used only as source of transfer operations
-    XGL_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL           = 0x00000008,   // Optimal layout when image is used only as destination of transfer operations
+    VK_IMAGE_LAYOUT_UNDEFINED                              = 0x00000000,   // Implicit layout an image is when its contents are undefined due to various reasons (e.g. right after creation)
+    VK_IMAGE_LAYOUT_GENERAL                                = 0x00000001,   // General layout when image can be used for any kind of access
+    VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL               = 0x00000002,   // Optimal layout when image is only used for color attachment read/write
+    VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL       = 0x00000003,   // Optimal layout when image is only used for depth/stencil attachment read/write
+    VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL        = 0x00000004,   // Optimal layout when image is used for read only depth/stencil attachment and shader access
+    VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL               = 0x00000005,   // Optimal layout when image is used for read only shader access
+    VK_IMAGE_LAYOUT_CLEAR_OPTIMAL                          = 0x00000006,   // Optimal layout when image is used only for clear operations
+    VK_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL                = 0x00000007,   // Optimal layout when image is used only as source of transfer operations
+    VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL           = 0x00000008,   // Optimal layout when image is used only as destination of transfer operations
 
-    XGL_IMAGE_LAYOUT_BEGIN_RANGE                            = XGL_IMAGE_LAYOUT_UNDEFINED,
-    XGL_IMAGE_LAYOUT_END_RANGE                              = XGL_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL,
-    XGL_NUM_IMAGE_LAYOUT                                    = (XGL_IMAGE_LAYOUT_END_RANGE - XGL_IMAGE_LAYOUT_BEGIN_RANGE + 1),
-    XGL_MAX_ENUM(_XGL_IMAGE_LAYOUT)
-} XGL_IMAGE_LAYOUT;
+    VK_IMAGE_LAYOUT_BEGIN_RANGE                            = VK_IMAGE_LAYOUT_UNDEFINED,
+    VK_IMAGE_LAYOUT_END_RANGE                              = VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL,
+    VK_NUM_IMAGE_LAYOUT                                    = (VK_IMAGE_LAYOUT_END_RANGE - VK_IMAGE_LAYOUT_BEGIN_RANGE + 1),
+    VK_MAX_ENUM(_VK_IMAGE_LAYOUT)
+} VK_IMAGE_LAYOUT;
 
-typedef enum _XGL_PIPE_EVENT
+typedef enum _VK_PIPE_EVENT
 {
-    XGL_PIPE_EVENT_TOP_OF_PIPE                              = 0x00000001,   // Set event before the GPU starts processing subsequent command
-    XGL_PIPE_EVENT_VERTEX_PROCESSING_COMPLETE               = 0x00000002,   // Set event when all pending vertex processing is complete
-    XGL_PIPE_EVENT_LOCAL_FRAGMENT_PROCESSING_COMPLETE       = 0x00000003,   // Set event when all pending fragment shader executions are complete, within each fragment location
-    XGL_PIPE_EVENT_FRAGMENT_PROCESSING_COMPLETE             = 0x00000004,   // Set event when all pending fragment shader executions are complete
-    XGL_PIPE_EVENT_GRAPHICS_PIPELINE_COMPLETE               = 0x00000005,   // Set event when all pending graphics operations are complete
-    XGL_PIPE_EVENT_COMPUTE_PIPELINE_COMPLETE                = 0x00000006,   // Set event when all pending compute operations are complete
-    XGL_PIPE_EVENT_TRANSFER_COMPLETE                        = 0x00000007,   // Set event when all pending transfer operations are complete
-    XGL_PIPE_EVENT_GPU_COMMANDS_COMPLETE                    = 0x00000008,   // Set event when all pending GPU work is complete
+    VK_PIPE_EVENT_TOP_OF_PIPE                              = 0x00000001,   // Set event before the GPU starts processing subsequent command
+    VK_PIPE_EVENT_VERTEX_PROCESSING_COMPLETE               = 0x00000002,   // Set event when all pending vertex processing is complete
+    VK_PIPE_EVENT_LOCAL_FRAGMENT_PROCESSING_COMPLETE       = 0x00000003,   // Set event when all pending fragment shader executions are complete, within each fragment location
+    VK_PIPE_EVENT_FRAGMENT_PROCESSING_COMPLETE             = 0x00000004,   // Set event when all pending fragment shader executions are complete
+    VK_PIPE_EVENT_GRAPHICS_PIPELINE_COMPLETE               = 0x00000005,   // Set event when all pending graphics operations are complete
+    VK_PIPE_EVENT_COMPUTE_PIPELINE_COMPLETE                = 0x00000006,   // Set event when all pending compute operations are complete
+    VK_PIPE_EVENT_TRANSFER_COMPLETE                        = 0x00000007,   // Set event when all pending transfer operations are complete
+    VK_PIPE_EVENT_GPU_COMMANDS_COMPLETE                    = 0x00000008,   // Set event when all pending GPU work is complete
 
-    XGL_PIPE_EVENT_BEGIN_RANGE                              = XGL_PIPE_EVENT_TOP_OF_PIPE,
-    XGL_PIPE_EVENT_END_RANGE                                = XGL_PIPE_EVENT_GPU_COMMANDS_COMPLETE,
-    XGL_NUM_PIPE_EVENT                                      = (XGL_PIPE_EVENT_END_RANGE - XGL_PIPE_EVENT_BEGIN_RANGE + 1),
-    XGL_MAX_ENUM(_XGL_PIPE_EVENT)
-} XGL_PIPE_EVENT;
+    VK_PIPE_EVENT_BEGIN_RANGE                              = VK_PIPE_EVENT_TOP_OF_PIPE,
+    VK_PIPE_EVENT_END_RANGE                                = VK_PIPE_EVENT_GPU_COMMANDS_COMPLETE,
+    VK_NUM_PIPE_EVENT                                      = (VK_PIPE_EVENT_END_RANGE - VK_PIPE_EVENT_BEGIN_RANGE + 1),
+    VK_MAX_ENUM(_VK_PIPE_EVENT)
+} VK_PIPE_EVENT;
 
-typedef enum _XGL_WAIT_EVENT
+typedef enum _VK_WAIT_EVENT
 {
-    XGL_WAIT_EVENT_TOP_OF_PIPE                              = 0x00000001,   // Wait event before the GPU starts processing subsequent commands
-    XGL_WAIT_EVENT_BEFORE_RASTERIZATION                     = 0x00000002,   // Wait event before rasterizing subsequent primitives
+    VK_WAIT_EVENT_TOP_OF_PIPE                              = 0x00000001,   // Wait event before the GPU starts processing subsequent commands
+    VK_WAIT_EVENT_BEFORE_RASTERIZATION                     = 0x00000002,   // Wait event before rasterizing subsequent primitives
 
-    XGL_WAIT_EVENT_BEGIN_RANGE                              = XGL_WAIT_EVENT_TOP_OF_PIPE,
-    XGL_WAIT_EVENT_END_RANGE                                = XGL_WAIT_EVENT_BEFORE_RASTERIZATION,
-    XGL_NUM_WAIT_EVENT                                      = (XGL_WAIT_EVENT_END_RANGE - XGL_WAIT_EVENT_BEGIN_RANGE + 1),
-    XGL_MAX_ENUM(_XGL_WAIT_EVENT)
-} XGL_WAIT_EVENT;
+    VK_WAIT_EVENT_BEGIN_RANGE                              = VK_WAIT_EVENT_TOP_OF_PIPE,
+    VK_WAIT_EVENT_END_RANGE                                = VK_WAIT_EVENT_BEFORE_RASTERIZATION,
+    VK_NUM_WAIT_EVENT                                      = (VK_WAIT_EVENT_END_RANGE - VK_WAIT_EVENT_BEGIN_RANGE + 1),
+    VK_MAX_ENUM(_VK_WAIT_EVENT)
+} VK_WAIT_EVENT;
 
-typedef enum _XGL_MEMORY_OUTPUT_FLAGS
+typedef enum _VK_MEMORY_OUTPUT_FLAGS
 {
-    XGL_MEMORY_OUTPUT_CPU_WRITE_BIT                         = 0x00000001,   // Controls output coherency of CPU writes
-    XGL_MEMORY_OUTPUT_SHADER_WRITE_BIT                      = 0x00000002,   // Controls output coherency of generic shader writes
-    XGL_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT                  = 0x00000004,   // Controls output coherency of color attachment writes
-    XGL_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT          = 0x00000008,   // Controls output coherency of depth/stencil attachment writes
-    XGL_MEMORY_OUTPUT_COPY_BIT                              = 0x00000010,   // Controls output coherency of copy operations
-    XGL_MAX_ENUM(_XGL_MEMORY_OUTPUT_FLAGS)
-} XGL_MEMORY_OUTPUT_FLAGS;
+    VK_MEMORY_OUTPUT_CPU_WRITE_BIT                         = 0x00000001,   // Controls output coherency of CPU writes
+    VK_MEMORY_OUTPUT_SHADER_WRITE_BIT                      = 0x00000002,   // Controls output coherency of generic shader writes
+    VK_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT                  = 0x00000004,   // Controls output coherency of color attachment writes
+    VK_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT          = 0x00000008,   // Controls output coherency of depth/stencil attachment writes
+    VK_MEMORY_OUTPUT_COPY_BIT                              = 0x00000010,   // Controls output coherency of copy operations
+    VK_MAX_ENUM(_VK_MEMORY_OUTPUT_FLAGS)
+} VK_MEMORY_OUTPUT_FLAGS;
 
-typedef enum _XGL_MEMORY_INPUT_FLAGS
+typedef enum _VK_MEMORY_INPUT_FLAGS
 {
-    XGL_MEMORY_INPUT_CPU_READ_BIT                           = 0x00000001,   // Controls input coherency of CPU reads
-    XGL_MEMORY_INPUT_INDIRECT_COMMAND_BIT                   = 0x00000002,   // Controls input coherency of indirect command reads
-    XGL_MEMORY_INPUT_INDEX_FETCH_BIT                        = 0x00000004,   // Controls input coherency of index fetches
-    XGL_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT             = 0x00000008,   // Controls input coherency of vertex attribute fetches
-    XGL_MEMORY_INPUT_UNIFORM_READ_BIT                       = 0x00000010,   // Controls input coherency of uniform buffer reads
-    XGL_MEMORY_INPUT_SHADER_READ_BIT                        = 0x00000020,   // Controls input coherency of generic shader reads
-    XGL_MEMORY_INPUT_COLOR_ATTACHMENT_BIT                   = 0x00000040,   // Controls input coherency of color attachment reads
-    XGL_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT           = 0x00000080,   // Controls input coherency of depth/stencil attachment reads
-    XGL_MEMORY_INPUT_COPY_BIT                               = 0x00000100,   // Controls input coherency of copy operations
-    XGL_MAX_ENUM(_XGL_MEMORY_INPUT_FLAGS)
-} XGL_MEMORY_INPUT_FLAGS;
+    VK_MEMORY_INPUT_CPU_READ_BIT                           = 0x00000001,   // Controls input coherency of CPU reads
+    VK_MEMORY_INPUT_INDIRECT_COMMAND_BIT                   = 0x00000002,   // Controls input coherency of indirect command reads
+    VK_MEMORY_INPUT_INDEX_FETCH_BIT                        = 0x00000004,   // Controls input coherency of index fetches
+    VK_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT             = 0x00000008,   // Controls input coherency of vertex attribute fetches
+    VK_MEMORY_INPUT_UNIFORM_READ_BIT                       = 0x00000010,   // Controls input coherency of uniform buffer reads
+    VK_MEMORY_INPUT_SHADER_READ_BIT                        = 0x00000020,   // Controls input coherency of generic shader reads
+    VK_MEMORY_INPUT_COLOR_ATTACHMENT_BIT                   = 0x00000040,   // Controls input coherency of color attachment reads
+    VK_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT           = 0x00000080,   // Controls input coherency of depth/stencil attachment reads
+    VK_MEMORY_INPUT_COPY_BIT                               = 0x00000100,   // Controls input coherency of copy operations
+    VK_MAX_ENUM(_VK_MEMORY_INPUT_FLAGS)
+} VK_MEMORY_INPUT_FLAGS;
 
-typedef enum _XGL_ATTACHMENT_LOAD_OP
+typedef enum _VK_ATTACHMENT_LOAD_OP
 {
-    XGL_ATTACHMENT_LOAD_OP_LOAD                             = 0x00000000,
-    XGL_ATTACHMENT_LOAD_OP_CLEAR                            = 0x00000001,
-    XGL_ATTACHMENT_LOAD_OP_DONT_CARE                        = 0x00000002,
+    VK_ATTACHMENT_LOAD_OP_LOAD                             = 0x00000000,
+    VK_ATTACHMENT_LOAD_OP_CLEAR                            = 0x00000001,
+    VK_ATTACHMENT_LOAD_OP_DONT_CARE                        = 0x00000002,
 
-    XGL_ATTACHMENT_LOAD_OP_BEGIN_RANGE                      = XGL_ATTACHMENT_LOAD_OP_LOAD,
-    XGL_ATTACHMENT_LOAD_OP_END_RANGE                        = XGL_ATTACHMENT_LOAD_OP_DONT_CARE,
-    XGL_NUM_ATTACHMENT_LOAD_OP                              = (XGL_ATTACHMENT_LOAD_OP_END_RANGE - XGL_ATTACHMENT_LOAD_OP_BEGIN_RANGE + 1),
-    XGL_MAX_ENUM(_XGL_ATTACHMENT_LOAD_OP)
-} XGL_ATTACHMENT_LOAD_OP;
+    VK_ATTACHMENT_LOAD_OP_BEGIN_RANGE                      = VK_ATTACHMENT_LOAD_OP_LOAD,
+    VK_ATTACHMENT_LOAD_OP_END_RANGE                        = VK_ATTACHMENT_LOAD_OP_DONT_CARE,
+    VK_NUM_ATTACHMENT_LOAD_OP                              = (VK_ATTACHMENT_LOAD_OP_END_RANGE - VK_ATTACHMENT_LOAD_OP_BEGIN_RANGE + 1),
+    VK_MAX_ENUM(_VK_ATTACHMENT_LOAD_OP)
+} VK_ATTACHMENT_LOAD_OP;
 
-typedef enum _XGL_ATTACHMENT_STORE_OP
+typedef enum _VK_ATTACHMENT_STORE_OP
 {
-    XGL_ATTACHMENT_STORE_OP_STORE                           = 0x00000000,
-    XGL_ATTACHMENT_STORE_OP_RESOLVE_MSAA                    = 0x00000001,
-    XGL_ATTACHMENT_STORE_OP_DONT_CARE                       = 0x00000002,
+    VK_ATTACHMENT_STORE_OP_STORE                           = 0x00000000,
+    VK_ATTACHMENT_STORE_OP_RESOLVE_MSAA                    = 0x00000001,
+    VK_ATTACHMENT_STORE_OP_DONT_CARE                       = 0x00000002,
 
-    XGL_ATTACHMENT_STORE_OP_BEGIN_RANGE                     = XGL_ATTACHMENT_STORE_OP_STORE,
-    XGL_ATTACHMENT_STORE_OP_END_RANGE                       = XGL_ATTACHMENT_STORE_OP_DONT_CARE,
-    XGL_NUM_ATTACHMENT_STORE_OP                             = (XGL_ATTACHMENT_STORE_OP_END_RANGE - XGL_ATTACHMENT_STORE_OP_BEGIN_RANGE + 1),
-    XGL_MAX_ENUM(_XGL_ATTACHMENT_STORE_OP)
-} XGL_ATTACHMENT_STORE_OP;
+    VK_ATTACHMENT_STORE_OP_BEGIN_RANGE                     = VK_ATTACHMENT_STORE_OP_STORE,
+    VK_ATTACHMENT_STORE_OP_END_RANGE                       = VK_ATTACHMENT_STORE_OP_DONT_CARE,
+    VK_NUM_ATTACHMENT_STORE_OP                             = (VK_ATTACHMENT_STORE_OP_END_RANGE - VK_ATTACHMENT_STORE_OP_BEGIN_RANGE + 1),
+    VK_MAX_ENUM(_VK_ATTACHMENT_STORE_OP)
+} VK_ATTACHMENT_STORE_OP;
 
-typedef enum _XGL_IMAGE_TYPE
+typedef enum _VK_IMAGE_TYPE
 {
-    XGL_IMAGE_1D                                            = 0x00000000,
-    XGL_IMAGE_2D                                            = 0x00000001,
-    XGL_IMAGE_3D                                            = 0x00000002,
+    VK_IMAGE_1D                                            = 0x00000000,
+    VK_IMAGE_2D                                            = 0x00000001,
+    VK_IMAGE_3D                                            = 0x00000002,
 
-    XGL_IMAGE_TYPE_BEGIN_RANGE                              = XGL_IMAGE_1D,
-    XGL_IMAGE_TYPE_END_RANGE                                = XGL_IMAGE_3D,
-    XGL_NUM_IMAGE_TYPE                                      = (XGL_IMAGE_TYPE_END_RANGE - XGL_IMAGE_TYPE_BEGIN_RANGE + 1),
-    XGL_MAX_ENUM(_XGL_IMAGE_TYPE)
-} XGL_IMAGE_TYPE;
+    VK_IMAGE_TYPE_BEGIN_RANGE                              = VK_IMAGE_1D,
+    VK_IMAGE_TYPE_END_RANGE                                = VK_IMAGE_3D,
+    VK_NUM_IMAGE_TYPE                                      = (VK_IMAGE_TYPE_END_RANGE - VK_IMAGE_TYPE_BEGIN_RANGE + 1),
+    VK_MAX_ENUM(_VK_IMAGE_TYPE)
+} VK_IMAGE_TYPE;
 
-typedef enum _XGL_IMAGE_TILING
+typedef enum _VK_IMAGE_TILING
 {
-    XGL_LINEAR_TILING                                       = 0x00000000,
-    XGL_OPTIMAL_TILING                                      = 0x00000001,
+    VK_LINEAR_TILING                                       = 0x00000000,
+    VK_OPTIMAL_TILING                                      = 0x00000001,
 
-    XGL_IMAGE_TILING_BEGIN_RANGE                            = XGL_LINEAR_TILING,
-    XGL_IMAGE_TILING_END_RANGE                              = XGL_OPTIMAL_TILING,
-    XGL_NUM_IMAGE_TILING                                    = (XGL_IMAGE_TILING_END_RANGE - XGL_IMAGE_TILING_BEGIN_RANGE + 1),
-    XGL_MAX_ENUM(_XGL_IMAGE_TILING)
-} XGL_IMAGE_TILING;
+    VK_IMAGE_TILING_BEGIN_RANGE                            = VK_LINEAR_TILING,
+    VK_IMAGE_TILING_END_RANGE                              = VK_OPTIMAL_TILING,
+    VK_NUM_IMAGE_TILING                                    = (VK_IMAGE_TILING_END_RANGE - VK_IMAGE_TILING_BEGIN_RANGE + 1),
+    VK_MAX_ENUM(_VK_IMAGE_TILING)
+} VK_IMAGE_TILING;
 
-typedef enum _XGL_IMAGE_VIEW_TYPE
+typedef enum _VK_IMAGE_VIEW_TYPE
 {
-    XGL_IMAGE_VIEW_1D                                       = 0x00000000,
-    XGL_IMAGE_VIEW_2D                                       = 0x00000001,
-    XGL_IMAGE_VIEW_3D                                       = 0x00000002,
-    XGL_IMAGE_VIEW_CUBE                                     = 0x00000003,
+    VK_IMAGE_VIEW_1D                                       = 0x00000000,
+    VK_IMAGE_VIEW_2D                                       = 0x00000001,
+    VK_IMAGE_VIEW_3D                                       = 0x00000002,
+    VK_IMAGE_VIEW_CUBE                                     = 0x00000003,
 
-    XGL_IMAGE_VIEW_TYPE_BEGIN_RANGE                         = XGL_IMAGE_VIEW_1D,
-    XGL_IMAGE_VIEW_TYPE_END_RANGE                           = XGL_IMAGE_VIEW_CUBE,
-    XGL_NUM_IMAGE_VIEW_TYPE                                 = (XGL_IMAGE_VIEW_TYPE_END_RANGE - XGL_IMAGE_VIEW_TYPE_BEGIN_RANGE + 1),
-    XGL_MAX_ENUM(_XGL_IMAGE_VIEW_TYPE)
-} XGL_IMAGE_VIEW_TYPE;
+    VK_IMAGE_VIEW_TYPE_BEGIN_RANGE                         = VK_IMAGE_VIEW_1D,
+    VK_IMAGE_VIEW_TYPE_END_RANGE                           = VK_IMAGE_VIEW_CUBE,
+    VK_NUM_IMAGE_VIEW_TYPE                                 = (VK_IMAGE_VIEW_TYPE_END_RANGE - VK_IMAGE_VIEW_TYPE_BEGIN_RANGE + 1),
+    VK_MAX_ENUM(_VK_IMAGE_VIEW_TYPE)
+} VK_IMAGE_VIEW_TYPE;
 
-typedef enum _XGL_IMAGE_ASPECT
+typedef enum _VK_IMAGE_ASPECT
 {
-    XGL_IMAGE_ASPECT_COLOR                                  = 0x00000000,
-    XGL_IMAGE_ASPECT_DEPTH                                  = 0x00000001,
-    XGL_IMAGE_ASPECT_STENCIL                                = 0x00000002,
+    VK_IMAGE_ASPECT_COLOR                                  = 0x00000000,
+    VK_IMAGE_ASPECT_DEPTH                                  = 0x00000001,
+    VK_IMAGE_ASPECT_STENCIL                                = 0x00000002,
 
-    XGL_IMAGE_ASPECT_BEGIN_RANGE                            = XGL_IMAGE_ASPECT_COLOR,
-    XGL_IMAGE_ASPECT_END_RANGE                              = XGL_IMAGE_ASPECT_STENCIL,
-    XGL_NUM_IMAGE_ASPECT                                    = (XGL_IMAGE_ASPECT_END_RANGE - XGL_IMAGE_ASPECT_BEGIN_RANGE + 1),
-    XGL_MAX_ENUM(_XGL_IMAGE_ASPECT)
-} XGL_IMAGE_ASPECT;
+    VK_IMAGE_ASPECT_BEGIN_RANGE                            = VK_IMAGE_ASPECT_COLOR,
+    VK_IMAGE_ASPECT_END_RANGE                              = VK_IMAGE_ASPECT_STENCIL,
+    VK_NUM_IMAGE_ASPECT                                    = (VK_IMAGE_ASPECT_END_RANGE - VK_IMAGE_ASPECT_BEGIN_RANGE + 1),
+    VK_MAX_ENUM(_VK_IMAGE_ASPECT)
+} VK_IMAGE_ASPECT;
 
-typedef enum _XGL_CHANNEL_SWIZZLE
+typedef enum _VK_CHANNEL_SWIZZLE
 {
-    XGL_CHANNEL_SWIZZLE_ZERO                                = 0x00000000,
-    XGL_CHANNEL_SWIZZLE_ONE                                 = 0x00000001,
-    XGL_CHANNEL_SWIZZLE_R                                   = 0x00000002,
-    XGL_CHANNEL_SWIZZLE_G                                   = 0x00000003,
-    XGL_CHANNEL_SWIZZLE_B                                   = 0x00000004,
-    XGL_CHANNEL_SWIZZLE_A                                   = 0x00000005,
+    VK_CHANNEL_SWIZZLE_ZERO                                = 0x00000000,
+    VK_CHANNEL_SWIZZLE_ONE                                 = 0x00000001,
+    VK_CHANNEL_SWIZZLE_R                                   = 0x00000002,
+    VK_CHANNEL_SWIZZLE_G                                   = 0x00000003,
+    VK_CHANNEL_SWIZZLE_B                                   = 0x00000004,
+    VK_CHANNEL_SWIZZLE_A                                   = 0x00000005,
 
-    XGL_CHANNEL_SWIZZLE_BEGIN_RANGE                         = XGL_CHANNEL_SWIZZLE_ZERO,
-    XGL_CHANNEL_SWIZZLE_END_RANGE                           = XGL_CHANNEL_SWIZZLE_A,
-    XGL_NUM_CHANNEL_SWIZZLE                                 = (XGL_CHANNEL_SWIZZLE_END_RANGE - XGL_CHANNEL_SWIZZLE_BEGIN_RANGE + 1),
-    XGL_MAX_ENUM(_XGL_CHANNEL_SWIZZLE)
-} XGL_CHANNEL_SWIZZLE;
+    VK_CHANNEL_SWIZZLE_BEGIN_RANGE                         = VK_CHANNEL_SWIZZLE_ZERO,
+    VK_CHANNEL_SWIZZLE_END_RANGE                           = VK_CHANNEL_SWIZZLE_A,
+    VK_NUM_CHANNEL_SWIZZLE                                 = (VK_CHANNEL_SWIZZLE_END_RANGE - VK_CHANNEL_SWIZZLE_BEGIN_RANGE + 1),
+    VK_MAX_ENUM(_VK_CHANNEL_SWIZZLE)
+} VK_CHANNEL_SWIZZLE;
 
-typedef enum _XGL_DESCRIPTOR_TYPE
+typedef enum _VK_DESCRIPTOR_TYPE
 {
-    XGL_DESCRIPTOR_TYPE_SAMPLER                             = 0x00000000,
-    XGL_DESCRIPTOR_TYPE_SAMPLER_TEXTURE                     = 0x00000001,
-    XGL_DESCRIPTOR_TYPE_TEXTURE                             = 0x00000002,
-    XGL_DESCRIPTOR_TYPE_TEXTURE_BUFFER                      = 0x00000003,
-    XGL_DESCRIPTOR_TYPE_IMAGE                               = 0x00000004,
-    XGL_DESCRIPTOR_TYPE_IMAGE_BUFFER                        = 0x00000005,
-    XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER                      = 0x00000006,
-    XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER               = 0x00000007,
-    XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC              = 0x00000008,
-    XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER_DYNAMIC       = 0x00000009,
+    VK_DESCRIPTOR_TYPE_SAMPLER                             = 0x00000000,
+    VK_DESCRIPTOR_TYPE_SAMPLER_TEXTURE                     = 0x00000001,
+    VK_DESCRIPTOR_TYPE_TEXTURE                             = 0x00000002,
+    VK_DESCRIPTOR_TYPE_TEXTURE_BUFFER                      = 0x00000003,
+    VK_DESCRIPTOR_TYPE_IMAGE                               = 0x00000004,
+    VK_DESCRIPTOR_TYPE_IMAGE_BUFFER                        = 0x00000005,
+    VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER                      = 0x00000006,
+    VK_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER               = 0x00000007,
+    VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC              = 0x00000008,
+    VK_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER_DYNAMIC       = 0x00000009,
 
-    XGL_DESCRIPTOR_TYPE_BEGIN_RANGE                         = XGL_DESCRIPTOR_TYPE_SAMPLER,
-    XGL_DESCRIPTOR_TYPE_END_RANGE                           = XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER_DYNAMIC,
-    XGL_NUM_DESCRIPTOR_TYPE                                 = (XGL_DESCRIPTOR_TYPE_END_RANGE - XGL_DESCRIPTOR_TYPE_BEGIN_RANGE + 1),
-    XGL_MAX_ENUM(_XGL_DESCRIPTOR_TYPE)
-} XGL_DESCRIPTOR_TYPE;
+    VK_DESCRIPTOR_TYPE_BEGIN_RANGE                         = VK_DESCRIPTOR_TYPE_SAMPLER,
+    VK_DESCRIPTOR_TYPE_END_RANGE                           = VK_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER_DYNAMIC,
+    VK_NUM_DESCRIPTOR_TYPE                                 = (VK_DESCRIPTOR_TYPE_END_RANGE - VK_DESCRIPTOR_TYPE_BEGIN_RANGE + 1),
+    VK_MAX_ENUM(_VK_DESCRIPTOR_TYPE)
+} VK_DESCRIPTOR_TYPE;
 
-typedef enum _XGL_DESCRIPTOR_POOL_USAGE
+typedef enum _VK_DESCRIPTOR_POOL_USAGE
 {
-    XGL_DESCRIPTOR_POOL_USAGE_ONE_SHOT                      = 0x00000000,
-    XGL_DESCRIPTOR_POOL_USAGE_DYNAMIC                       = 0x00000001,
+    VK_DESCRIPTOR_POOL_USAGE_ONE_SHOT                      = 0x00000000,
+    VK_DESCRIPTOR_POOL_USAGE_DYNAMIC                       = 0x00000001,
 
-    XGL_DESCRIPTOR_POOL_USAGE_BEGIN_RANGE                   = XGL_DESCRIPTOR_POOL_USAGE_ONE_SHOT,
-    XGL_DESCRIPTOR_POOL_USAGE_END_RANGE                     = XGL_DESCRIPTOR_POOL_USAGE_DYNAMIC,
-    XGL_NUM_DESCRIPTOR_POOL_USAGE                           = (XGL_DESCRIPTOR_POOL_USAGE_END_RANGE - XGL_DESCRIPTOR_POOL_USAGE_BEGIN_RANGE + 1),
-    XGL_MAX_ENUM(_XGL_DESCRIPTOR_POOL_USAGE)
-} XGL_DESCRIPTOR_POOL_USAGE;
+    VK_DESCRIPTOR_POOL_USAGE_BEGIN_RANGE                   = VK_DESCRIPTOR_POOL_USAGE_ONE_SHOT,
+    VK_DESCRIPTOR_POOL_USAGE_END_RANGE                     = VK_DESCRIPTOR_POOL_USAGE_DYNAMIC,
+    VK_NUM_DESCRIPTOR_POOL_USAGE                           = (VK_DESCRIPTOR_POOL_USAGE_END_RANGE - VK_DESCRIPTOR_POOL_USAGE_BEGIN_RANGE + 1),
+    VK_MAX_ENUM(_VK_DESCRIPTOR_POOL_USAGE)
+} VK_DESCRIPTOR_POOL_USAGE;
 
-typedef enum _XGL_DESCRIPTOR_UPDATE_MODE
+typedef enum _VK_DESCRIPTOR_UPDATE_MODE
 {
-    XGL_DESCRIPTOR_UDPATE_MODE_COPY                         = 0x00000000,
-    XGL_DESCRIPTOR_UPDATE_MODE_FASTEST                      = 0x00000001,
+    VK_DESCRIPTOR_UDPATE_MODE_COPY                         = 0x00000000,
+    VK_DESCRIPTOR_UPDATE_MODE_FASTEST                      = 0x00000001,
 
-    XGL_DESCRIPTOR_UPDATE_MODE_BEGIN_RANGE                  = XGL_DESCRIPTOR_UDPATE_MODE_COPY,
-    XGL_DESCRIPTOR_UPDATE_MODE_END_RANGE                    = XGL_DESCRIPTOR_UPDATE_MODE_FASTEST,
-    XGL_NUM_DESCRIPTOR_UPDATE_MODE                          = (XGL_DESCRIPTOR_UPDATE_MODE_END_RANGE - XGL_DESCRIPTOR_UPDATE_MODE_BEGIN_RANGE + 1),
-    XGL_MAX_ENUM(_XGL_DESCRIPTOR_UPDATE_MODE)
-} XGL_DESCRIPTOR_UPDATE_MODE;
+    VK_DESCRIPTOR_UPDATE_MODE_BEGIN_RANGE                  = VK_DESCRIPTOR_UDPATE_MODE_COPY,
+    VK_DESCRIPTOR_UPDATE_MODE_END_RANGE                    = VK_DESCRIPTOR_UPDATE_MODE_FASTEST,
+    VK_NUM_DESCRIPTOR_UPDATE_MODE                          = (VK_DESCRIPTOR_UPDATE_MODE_END_RANGE - VK_DESCRIPTOR_UPDATE_MODE_BEGIN_RANGE + 1),
+    VK_MAX_ENUM(_VK_DESCRIPTOR_UPDATE_MODE)
+} VK_DESCRIPTOR_UPDATE_MODE;
 
-typedef enum _XGL_DESCRIPTOR_SET_USAGE
+typedef enum _VK_DESCRIPTOR_SET_USAGE
 {
-    XGL_DESCRIPTOR_SET_USAGE_ONE_SHOT                       = 0x00000000,
-    XGL_DESCRIPTOR_SET_USAGE_STATIC                         = 0x00000001,
+    VK_DESCRIPTOR_SET_USAGE_ONE_SHOT                       = 0x00000000,
+    VK_DESCRIPTOR_SET_USAGE_STATIC                         = 0x00000001,
 
-    XGL_DESCRIPTOR_SET_USAGE_BEGIN_RANGE                    = XGL_DESCRIPTOR_SET_USAGE_ONE_SHOT,
-    XGL_DESCRIPTOR_SET_USAGE_END_RANGE                      = XGL_DESCRIPTOR_SET_USAGE_STATIC,
-    XGL_NUM_DESCRIPTOR_SET_USAGE                            = (XGL_DESCRIPTOR_SET_USAGE_END_RANGE - XGL_DESCRIPTOR_SET_USAGE_BEGIN_RANGE + 1),
-    XGL_MAX_ENUM(_XGL_DESCRIPTOR_SET_USAGE)
-} XGL_DESCRIPTOR_SET_USAGE;
+    VK_DESCRIPTOR_SET_USAGE_BEGIN_RANGE                    = VK_DESCRIPTOR_SET_USAGE_ONE_SHOT,
+    VK_DESCRIPTOR_SET_USAGE_END_RANGE                      = VK_DESCRIPTOR_SET_USAGE_STATIC,
+    VK_NUM_DESCRIPTOR_SET_USAGE                            = (VK_DESCRIPTOR_SET_USAGE_END_RANGE - VK_DESCRIPTOR_SET_USAGE_BEGIN_RANGE + 1),
+    VK_MAX_ENUM(_VK_DESCRIPTOR_SET_USAGE)
+} VK_DESCRIPTOR_SET_USAGE;
 
-typedef enum _XGL_QUERY_TYPE
+typedef enum _VK_QUERY_TYPE
 {
-    XGL_QUERY_OCCLUSION                                     = 0x00000000,
-    XGL_QUERY_PIPELINE_STATISTICS                           = 0x00000001,
+    VK_QUERY_OCCLUSION                                     = 0x00000000,
+    VK_QUERY_PIPELINE_STATISTICS                           = 0x00000001,
 
-    XGL_QUERY_TYPE_BEGIN_RANGE                              = XGL_QUERY_OCCLUSION,
-    XGL_QUERY_TYPE_END_RANGE                                = XGL_QUERY_PIPELINE_STATISTICS,
-    XGL_NUM_QUERY_TYPE                                      = (XGL_QUERY_TYPE_END_RANGE - XGL_QUERY_TYPE_BEGIN_RANGE + 1),
-    XGL_MAX_ENUM(_XGL_QUERY_TYPE)
-} XGL_QUERY_TYPE;
+    VK_QUERY_TYPE_BEGIN_RANGE                              = VK_QUERY_OCCLUSION,
+    VK_QUERY_TYPE_END_RANGE                                = VK_QUERY_PIPELINE_STATISTICS,
+    VK_NUM_QUERY_TYPE                                      = (VK_QUERY_TYPE_END_RANGE - VK_QUERY_TYPE_BEGIN_RANGE + 1),
+    VK_MAX_ENUM(_VK_QUERY_TYPE)
+} VK_QUERY_TYPE;
 
-typedef enum _XGL_TIMESTAMP_TYPE
+typedef enum _VK_TIMESTAMP_TYPE
 {
-    XGL_TIMESTAMP_TOP                                       = 0x00000000,
-    XGL_TIMESTAMP_BOTTOM                                    = 0x00000001,
+    VK_TIMESTAMP_TOP                                       = 0x00000000,
+    VK_TIMESTAMP_BOTTOM                                    = 0x00000001,
 
-    XGL_TIMESTAMP_TYPE_BEGIN_RANGE                          = XGL_TIMESTAMP_TOP,
-    XGL_TIMESTAMP_TYPE_END_RANGE                            = XGL_TIMESTAMP_BOTTOM,
-    XGL_NUM_TIMESTAMP_TYPE                                  = (XGL_TIMESTAMP_TYPE_END_RANGE - XGL_TIMESTAMP_TYPE_BEGIN_RANGE + 1),
-    XGL_MAX_ENUM(_XGL_TIMESTEAMP_TYPE)
-} XGL_TIMESTAMP_TYPE;
+    VK_TIMESTAMP_TYPE_BEGIN_RANGE                          = VK_TIMESTAMP_TOP,
+    VK_TIMESTAMP_TYPE_END_RANGE                            = VK_TIMESTAMP_BOTTOM,
+    VK_NUM_TIMESTAMP_TYPE                                  = (VK_TIMESTAMP_TYPE_END_RANGE - VK_TIMESTAMP_TYPE_BEGIN_RANGE + 1),
+    VK_MAX_ENUM(_VK_TIMESTEAMP_TYPE)
+} VK_TIMESTAMP_TYPE;
 
-typedef enum _XGL_BORDER_COLOR_TYPE
+typedef enum _VK_BORDER_COLOR_TYPE
 {
-    XGL_BORDER_COLOR_OPAQUE_WHITE                           = 0x00000000,
-    XGL_BORDER_COLOR_TRANSPARENT_BLACK                      = 0x00000001,
-    XGL_BORDER_COLOR_OPAQUE_BLACK                           = 0x00000002,
+    VK_BORDER_COLOR_OPAQUE_WHITE                           = 0x00000000,
+    VK_BORDER_COLOR_TRANSPARENT_BLACK                      = 0x00000001,
+    VK_BORDER_COLOR_OPAQUE_BLACK                           = 0x00000002,
 
-    XGL_BORDER_COLOR_TYPE_BEGIN_RANGE                       = XGL_BORDER_COLOR_OPAQUE_WHITE,
-    XGL_BORDER_COLOR_TYPE_END_RANGE                         = XGL_BORDER_COLOR_OPAQUE_BLACK,
-    XGL_NUM_BORDER_COLOR_TYPE                               = (XGL_BORDER_COLOR_TYPE_END_RANGE - XGL_BORDER_COLOR_TYPE_BEGIN_RANGE + 1),
-    XGL_MAX_ENUM(_XGL_BORDER_COLOR_TYPE)
-} XGL_BORDER_COLOR_TYPE;
+    VK_BORDER_COLOR_TYPE_BEGIN_RANGE                       = VK_BORDER_COLOR_OPAQUE_WHITE,
+    VK_BORDER_COLOR_TYPE_END_RANGE                         = VK_BORDER_COLOR_OPAQUE_BLACK,
+    VK_NUM_BORDER_COLOR_TYPE                               = (VK_BORDER_COLOR_TYPE_END_RANGE - VK_BORDER_COLOR_TYPE_BEGIN_RANGE + 1),
+    VK_MAX_ENUM(_VK_BORDER_COLOR_TYPE)
+} VK_BORDER_COLOR_TYPE;
 
-typedef enum _XGL_PIPELINE_BIND_POINT
+typedef enum _VK_PIPELINE_BIND_POINT
 {
-    XGL_PIPELINE_BIND_POINT_COMPUTE                         = 0x00000000,
-    XGL_PIPELINE_BIND_POINT_GRAPHICS                        = 0x00000001,
+    VK_PIPELINE_BIND_POINT_COMPUTE                         = 0x00000000,
+    VK_PIPELINE_BIND_POINT_GRAPHICS                        = 0x00000001,
 
-    XGL_PIPELINE_BIND_POINT_BEGIN_RANGE                     = XGL_PIPELINE_BIND_POINT_COMPUTE,
-    XGL_PIPELINE_BIND_POINT_END_RANGE                       = XGL_PIPELINE_BIND_POINT_GRAPHICS,
-    XGL_NUM_PIPELINE_BIND_POINT                             = (XGL_PIPELINE_BIND_POINT_END_RANGE - XGL_PIPELINE_BIND_POINT_BEGIN_RANGE + 1),
-    XGL_MAX_ENUM(_XGL_PIPELINE_BIND_POINT)
-} XGL_PIPELINE_BIND_POINT;
+    VK_PIPELINE_BIND_POINT_BEGIN_RANGE                     = VK_PIPELINE_BIND_POINT_COMPUTE,
+    VK_PIPELINE_BIND_POINT_END_RANGE                       = VK_PIPELINE_BIND_POINT_GRAPHICS,
+    VK_NUM_PIPELINE_BIND_POINT                             = (VK_PIPELINE_BIND_POINT_END_RANGE - VK_PIPELINE_BIND_POINT_BEGIN_RANGE + 1),
+    VK_MAX_ENUM(_VK_PIPELINE_BIND_POINT)
+} VK_PIPELINE_BIND_POINT;
 
-typedef enum _XGL_STATE_BIND_POINT
+typedef enum _VK_STATE_BIND_POINT
 {
-    XGL_STATE_BIND_VIEWPORT                                 = 0x00000000,
-    XGL_STATE_BIND_RASTER                                   = 0x00000001,
-    XGL_STATE_BIND_COLOR_BLEND                              = 0x00000002,
-    XGL_STATE_BIND_DEPTH_STENCIL                            = 0x00000003,
+    VK_STATE_BIND_VIEWPORT                                 = 0x00000000,
+    VK_STATE_BIND_RASTER                                   = 0x00000001,
+    VK_STATE_BIND_COLOR_BLEND                              = 0x00000002,
+    VK_STATE_BIND_DEPTH_STENCIL                            = 0x00000003,
 
-    XGL_STATE_BIND_POINT_BEGIN_RANGE                        = XGL_STATE_BIND_VIEWPORT,
-    XGL_STATE_BIND_POINT_END_RANGE                          = XGL_STATE_BIND_DEPTH_STENCIL,
-    XGL_NUM_STATE_BIND_POINT                                = (XGL_STATE_BIND_POINT_END_RANGE - XGL_STATE_BIND_POINT_BEGIN_RANGE + 1),
-    XGL_MAX_ENUM(_XGL_STATE_BIND_POINT)
-} XGL_STATE_BIND_POINT;
+    VK_STATE_BIND_POINT_BEGIN_RANGE                        = VK_STATE_BIND_VIEWPORT,
+    VK_STATE_BIND_POINT_END_RANGE                          = VK_STATE_BIND_DEPTH_STENCIL,
+    VK_NUM_STATE_BIND_POINT                                = (VK_STATE_BIND_POINT_END_RANGE - VK_STATE_BIND_POINT_BEGIN_RANGE + 1),
+    VK_MAX_ENUM(_VK_STATE_BIND_POINT)
+} VK_STATE_BIND_POINT;
 
-typedef enum _XGL_PRIMITIVE_TOPOLOGY
+typedef enum _VK_PRIMITIVE_TOPOLOGY
 {
-    XGL_TOPOLOGY_POINT_LIST                                 = 0x00000000,
-    XGL_TOPOLOGY_LINE_LIST                                  = 0x00000001,
-    XGL_TOPOLOGY_LINE_STRIP                                 = 0x00000002,
-    XGL_TOPOLOGY_TRIANGLE_LIST                              = 0x00000003,
-    XGL_TOPOLOGY_TRIANGLE_STRIP                             = 0x00000004,
-    XGL_TOPOLOGY_TRIANGLE_FAN                               = 0x00000005,
-    XGL_TOPOLOGY_LINE_LIST_ADJ                              = 0x00000006,
-    XGL_TOPOLOGY_LINE_STRIP_ADJ                             = 0x00000007,
-    XGL_TOPOLOGY_TRIANGLE_LIST_ADJ                          = 0x00000008,
-    XGL_TOPOLOGY_TRIANGLE_STRIP_ADJ                         = 0x00000009,
-    XGL_TOPOLOGY_PATCH                                      = 0x0000000a,
+    VK_TOPOLOGY_POINT_LIST                                 = 0x00000000,
+    VK_TOPOLOGY_LINE_LIST                                  = 0x00000001,
+    VK_TOPOLOGY_LINE_STRIP                                 = 0x00000002,
+    VK_TOPOLOGY_TRIANGLE_LIST                              = 0x00000003,
+    VK_TOPOLOGY_TRIANGLE_STRIP                             = 0x00000004,
+    VK_TOPOLOGY_TRIANGLE_FAN                               = 0x00000005,
+    VK_TOPOLOGY_LINE_LIST_ADJ                              = 0x00000006,
+    VK_TOPOLOGY_LINE_STRIP_ADJ                             = 0x00000007,
+    VK_TOPOLOGY_TRIANGLE_LIST_ADJ                          = 0x00000008,
+    VK_TOPOLOGY_TRIANGLE_STRIP_ADJ                         = 0x00000009,
+    VK_TOPOLOGY_PATCH                                      = 0x0000000a,
 
-    XGL_PRIMITIVE_TOPOLOGY_BEGIN_RANGE                      = XGL_TOPOLOGY_POINT_LIST,
-    XGL_PRIMITIVE_TOPOLOGY_END_RANGE                        = XGL_TOPOLOGY_PATCH,
-    XGL_NUM_PRIMITIVE_TOPOLOGY                              = (XGL_PRIMITIVE_TOPOLOGY_END_RANGE - XGL_PRIMITIVE_TOPOLOGY_BEGIN_RANGE + 1),
-    XGL_MAX_ENUM(_XGL_PRIMITIVE_TOPOLOGY)
-} XGL_PRIMITIVE_TOPOLOGY;
+    VK_PRIMITIVE_TOPOLOGY_BEGIN_RANGE                      = VK_TOPOLOGY_POINT_LIST,
+    VK_PRIMITIVE_TOPOLOGY_END_RANGE                        = VK_TOPOLOGY_PATCH,
+    VK_NUM_PRIMITIVE_TOPOLOGY                              = (VK_PRIMITIVE_TOPOLOGY_END_RANGE - VK_PRIMITIVE_TOPOLOGY_BEGIN_RANGE + 1),
+    VK_MAX_ENUM(_VK_PRIMITIVE_TOPOLOGY)
+} VK_PRIMITIVE_TOPOLOGY;
 
-typedef enum _XGL_INDEX_TYPE
+typedef enum _VK_INDEX_TYPE
 {
-    XGL_INDEX_8                                             = 0x00000000,
-    XGL_INDEX_16                                            = 0x00000001,
-    XGL_INDEX_32                                            = 0x00000002,
+    VK_INDEX_8                                             = 0x00000000,
+    VK_INDEX_16                                            = 0x00000001,
+    VK_INDEX_32                                            = 0x00000002,
 
-    XGL_INDEX_TYPE_BEGIN_RANGE                              = XGL_INDEX_8,
-    XGL_INDEX_TYPE_END_RANGE                                = XGL_INDEX_32,
-    XGL_NUM_INDEX_TYPE                                      = (XGL_INDEX_TYPE_END_RANGE - XGL_INDEX_TYPE_BEGIN_RANGE + 1),
-    XGL_MAX_ENUM(_XGL_INDEX_TYPE)
-} XGL_INDEX_TYPE;
+    VK_INDEX_TYPE_BEGIN_RANGE                              = VK_INDEX_8,
+    VK_INDEX_TYPE_END_RANGE                                = VK_INDEX_32,
+    VK_NUM_INDEX_TYPE                                      = (VK_INDEX_TYPE_END_RANGE - VK_INDEX_TYPE_BEGIN_RANGE + 1),
+    VK_MAX_ENUM(_VK_INDEX_TYPE)
+} VK_INDEX_TYPE;
 
-typedef enum _XGL_TEX_FILTER
+typedef enum _VK_TEX_FILTER
 {
-    XGL_TEX_FILTER_NEAREST                                  = 0,
-    XGL_TEX_FILTER_LINEAR                                   = 1,
+    VK_TEX_FILTER_NEAREST                                  = 0,
+    VK_TEX_FILTER_LINEAR                                   = 1,
 
-    XGL_TEX_FILTER_BEGIN_RANGE                              = XGL_TEX_FILTER_NEAREST,
-    XGL_TEX_FILTER_END_RANGE                                = XGL_TEX_FILTER_LINEAR,
-    XGL_NUM_TEX_FILTER                                      = (XGL_TEX_FILTER_END_RANGE - XGL_TEX_FILTER_BEGIN_RANGE + 1),
-    XGL_MAX_ENUM(_XGL_TEX_FILTER)
-} XGL_TEX_FILTER;
+    VK_TEX_FILTER_BEGIN_RANGE                              = VK_TEX_FILTER_NEAREST,
+    VK_TEX_FILTER_END_RANGE                                = VK_TEX_FILTER_LINEAR,
+    VK_NUM_TEX_FILTER                                      = (VK_TEX_FILTER_END_RANGE - VK_TEX_FILTER_BEGIN_RANGE + 1),
+    VK_MAX_ENUM(_VK_TEX_FILTER)
+} VK_TEX_FILTER;
 
-typedef enum _XGL_TEX_MIPMAP_MODE
+typedef enum _VK_TEX_MIPMAP_MODE
 {
-    XGL_TEX_MIPMAP_BASE                                     = 0,        // Always choose base level
-    XGL_TEX_MIPMAP_NEAREST                                  = 1,        // Choose nearest mip level
-    XGL_TEX_MIPMAP_LINEAR                                   = 2,        // Linear filter between mip levels
+    VK_TEX_MIPMAP_BASE                                     = 0,        // Always choose base level
+    VK_TEX_MIPMAP_NEAREST                                  = 1,        // Choose nearest mip level
+    VK_TEX_MIPMAP_LINEAR                                   = 2,        // Linear filter between mip levels
 
-    XGL_TEX_MIPMAP_BEGIN_RANGE                              = XGL_TEX_MIPMAP_BASE,
-    XGL_TEX_MIPMAP_END_RANGE                                = XGL_TEX_MIPMAP_LINEAR,
-    XGL_NUM_TEX_MIPMAP                                      = (XGL_TEX_MIPMAP_END_RANGE - XGL_TEX_MIPMAP_BEGIN_RANGE + 1),
-    XGL_MAX_ENUM(_XGL_TEX_MIPMAP_MODE)
-} XGL_TEX_MIPMAP_MODE;
+    VK_TEX_MIPMAP_BEGIN_RANGE                              = VK_TEX_MIPMAP_BASE,
+    VK_TEX_MIPMAP_END_RANGE                                = VK_TEX_MIPMAP_LINEAR,
+    VK_NUM_TEX_MIPMAP                                      = (VK_TEX_MIPMAP_END_RANGE - VK_TEX_MIPMAP_BEGIN_RANGE + 1),
+    VK_MAX_ENUM(_VK_TEX_MIPMAP_MODE)
+} VK_TEX_MIPMAP_MODE;
 
-typedef enum _XGL_TEX_ADDRESS
+typedef enum _VK_TEX_ADDRESS
 {
-    XGL_TEX_ADDRESS_WRAP                                    = 0x00000000,
-    XGL_TEX_ADDRESS_MIRROR                                  = 0x00000001,
-    XGL_TEX_ADDRESS_CLAMP                                   = 0x00000002,
-    XGL_TEX_ADDRESS_MIRROR_ONCE                             = 0x00000003,
-    XGL_TEX_ADDRESS_CLAMP_BORDER                            = 0x00000004,
+    VK_TEX_ADDRESS_WRAP                                    = 0x00000000,
+    VK_TEX_ADDRESS_MIRROR                                  = 0x00000001,
+    VK_TEX_ADDRESS_CLAMP                                   = 0x00000002,
+    VK_TEX_ADDRESS_MIRROR_ONCE                             = 0x00000003,
+    VK_TEX_ADDRESS_CLAMP_BORDER                            = 0x00000004,
 
-    XGL_TEX_ADDRESS_BEGIN_RANGE                             = XGL_TEX_ADDRESS_WRAP,
-    XGL_TEX_ADDRESS_END_RANGE                               = XGL_TEX_ADDRESS_CLAMP_BORDER,
-    XGL_NUM_TEX_ADDRESS                                     = (XGL_TEX_ADDRESS_END_RANGE - XGL_TEX_ADDRESS_BEGIN_RANGE + 1),
-    XGL_MAX_ENUM(_XGL_TEX_ADDRESS)
-} XGL_TEX_ADDRESS;
+    VK_TEX_ADDRESS_BEGIN_RANGE                             = VK_TEX_ADDRESS_WRAP,
+    VK_TEX_ADDRESS_END_RANGE                               = VK_TEX_ADDRESS_CLAMP_BORDER,
+    VK_NUM_TEX_ADDRESS                                     = (VK_TEX_ADDRESS_END_RANGE - VK_TEX_ADDRESS_BEGIN_RANGE + 1),
+    VK_MAX_ENUM(_VK_TEX_ADDRESS)
+} VK_TEX_ADDRESS;
 
-typedef enum _XGL_COMPARE_FUNC
+typedef enum _VK_COMPARE_FUNC
 {
-    XGL_COMPARE_NEVER                                       = 0x00000000,
-    XGL_COMPARE_LESS                                        = 0x00000001,
-    XGL_COMPARE_EQUAL                                       = 0x00000002,
-    XGL_COMPARE_LESS_EQUAL                                  = 0x00000003,
-    XGL_COMPARE_GREATER                                     = 0x00000004,
-    XGL_COMPARE_NOT_EQUAL                                   = 0x00000005,
-    XGL_COMPARE_GREATER_EQUAL                               = 0x00000006,
-    XGL_COMPARE_ALWAYS                                      = 0x00000007,
+    VK_COMPARE_NEVER                                       = 0x00000000,
+    VK_COMPARE_LESS                                        = 0x00000001,
+    VK_COMPARE_EQUAL                                       = 0x00000002,
+    VK_COMPARE_LESS_EQUAL                                  = 0x00000003,
+    VK_COMPARE_GREATER                                     = 0x00000004,
+    VK_COMPARE_NOT_EQUAL                                   = 0x00000005,
+    VK_COMPARE_GREATER_EQUAL                               = 0x00000006,
+    VK_COMPARE_ALWAYS                                      = 0x00000007,
 
-    XGL_COMPARE_FUNC_BEGIN_RANGE                            = XGL_COMPARE_NEVER,
-    XGL_COMPARE_FUNC_END_RANGE                              = XGL_COMPARE_ALWAYS,
-    XGL_NUM_COMPARE_FUNC                                    = (XGL_COMPARE_FUNC_END_RANGE - XGL_COMPARE_FUNC_BEGIN_RANGE + 1),
-    XGL_MAX_ENUM(_XGL_COMPARE_FUNC)
-} XGL_COMPARE_FUNC;
+    VK_COMPARE_FUNC_BEGIN_RANGE                            = VK_COMPARE_NEVER,
+    VK_COMPARE_FUNC_END_RANGE                              = VK_COMPARE_ALWAYS,
+    VK_NUM_COMPARE_FUNC                                    = (VK_COMPARE_FUNC_END_RANGE - VK_COMPARE_FUNC_BEGIN_RANGE + 1),
+    VK_MAX_ENUM(_VK_COMPARE_FUNC)
+} VK_COMPARE_FUNC;
 
-typedef enum _XGL_FILL_MODE
+typedef enum _VK_FILL_MODE
 {
-    XGL_FILL_POINTS                                         = 0x00000000,
-    XGL_FILL_WIREFRAME                                      = 0x00000001,
-    XGL_FILL_SOLID                                          = 0x00000002,
+    VK_FILL_POINTS                                         = 0x00000000,
+    VK_FILL_WIREFRAME                                      = 0x00000001,
+    VK_FILL_SOLID                                          = 0x00000002,
 
-    XGL_FILL_MODE_BEGIN_RANGE                               = XGL_FILL_POINTS,
-    XGL_FILL_MODE_END_RANGE                                 = XGL_FILL_SOLID,
-    XGL_NUM_FILL_MODE                                       = (XGL_FILL_MODE_END_RANGE - XGL_FILL_MODE_BEGIN_RANGE + 1),
-    XGL_MAX_ENUM(_XGL_FILL_MODE)
-} XGL_FILL_MODE;
+    VK_FILL_MODE_BEGIN_RANGE                               = VK_FILL_POINTS,
+    VK_FILL_MODE_END_RANGE                                 = VK_FILL_SOLID,
+    VK_NUM_FILL_MODE                                       = (VK_FILL_MODE_END_RANGE - VK_FILL_MODE_BEGIN_RANGE + 1),
+    VK_MAX_ENUM(_VK_FILL_MODE)
+} VK_FILL_MODE;
 
-typedef enum _XGL_CULL_MODE
+typedef enum _VK_CULL_MODE
 {
-    XGL_CULL_NONE                                           = 0x00000000,
-    XGL_CULL_FRONT                                          = 0x00000001,
-    XGL_CULL_BACK                                           = 0x00000002,
-    XGL_CULL_FRONT_AND_BACK                                 = 0x00000003,
+    VK_CULL_NONE                                           = 0x00000000,
+    VK_CULL_FRONT                                          = 0x00000001,
+    VK_CULL_BACK                                           = 0x00000002,
+    VK_CULL_FRONT_AND_BACK                                 = 0x00000003,
 
-    XGL_CULL_MODE_BEGIN_RANGE                               = XGL_CULL_NONE,
-    XGL_CULL_MODE_END_RANGE                                 = XGL_CULL_FRONT_AND_BACK,
-    XGL_NUM_CULL_MODE                                       = (XGL_CULL_MODE_END_RANGE - XGL_CULL_MODE_BEGIN_RANGE + 1),
-    XGL_MAX_ENUM(_XGL_CULL_MODE)
-} XGL_CULL_MODE;
+    VK_CULL_MODE_BEGIN_RANGE                               = VK_CULL_NONE,
+    VK_CULL_MODE_END_RANGE                                 = VK_CULL_FRONT_AND_BACK,
+    VK_NUM_CULL_MODE                                       = (VK_CULL_MODE_END_RANGE - VK_CULL_MODE_BEGIN_RANGE + 1),
+    VK_MAX_ENUM(_VK_CULL_MODE)
+} VK_CULL_MODE;
 
-typedef enum _XGL_FACE_ORIENTATION
+typedef enum _VK_FACE_ORIENTATION
 {
-    XGL_FRONT_FACE_CCW                                      = 0x00000000,
-    XGL_FRONT_FACE_CW                                       = 0x00000001,
+    VK_FRONT_FACE_CCW                                      = 0x00000000,
+    VK_FRONT_FACE_CW                                       = 0x00000001,
 
-    XGL_FACE_ORIENTATION_BEGIN_RANGE                        = XGL_FRONT_FACE_CCW,
-    XGL_FACE_ORIENTATION_END_RANGE                          = XGL_FRONT_FACE_CW,
-    XGL_NUM_FACE_ORIENTATION                                = (XGL_FACE_ORIENTATION_END_RANGE - XGL_FACE_ORIENTATION_BEGIN_RANGE + 1),
-    XGL_MAX_ENUM(_XGL_FACE_ORIENTATION)
-} XGL_FACE_ORIENTATION;
+    VK_FACE_ORIENTATION_BEGIN_RANGE                        = VK_FRONT_FACE_CCW,
+    VK_FACE_ORIENTATION_END_RANGE                          = VK_FRONT_FACE_CW,
+    VK_NUM_FACE_ORIENTATION                                = (VK_FACE_ORIENTATION_END_RANGE - VK_FACE_ORIENTATION_BEGIN_RANGE + 1),
+    VK_MAX_ENUM(_VK_FACE_ORIENTATION)
+} VK_FACE_ORIENTATION;
 
-typedef enum _XGL_PROVOKING_VERTEX_CONVENTION
+typedef enum _VK_PROVOKING_VERTEX_CONVENTION
 {
-    XGL_PROVOKING_VERTEX_FIRST                              = 0x00000000,
-    XGL_PROVOKING_VERTEX_LAST                               = 0x00000001,
+    VK_PROVOKING_VERTEX_FIRST                              = 0x00000000,
+    VK_PROVOKING_VERTEX_LAST                               = 0x00000001,
 
-    XGL_PROVOKING_VERTEX_BEGIN_RANGE                        = XGL_PROVOKING_VERTEX_FIRST,
-    XGL_PROVOKING_VERTEX_END_RANGE                          = XGL_PROVOKING_VERTEX_LAST,
-    XGL_NUM_PROVOKING_VERTEX_CONVENTION                     = (XGL_PROVOKING_VERTEX_END_RANGE - XGL_PROVOKING_VERTEX_BEGIN_RANGE + 1),
-    XGL_MAX_ENUM(_XGL_PROVOKING_VERTEX_CONVENTION)
-} XGL_PROVOKING_VERTEX_CONVENTION;
+    VK_PROVOKING_VERTEX_BEGIN_RANGE                        = VK_PROVOKING_VERTEX_FIRST,
+    VK_PROVOKING_VERTEX_END_RANGE                          = VK_PROVOKING_VERTEX_LAST,
+    VK_NUM_PROVOKING_VERTEX_CONVENTION                     = (VK_PROVOKING_VERTEX_END_RANGE - VK_PROVOKING_VERTEX_BEGIN_RANGE + 1),
+    VK_MAX_ENUM(_VK_PROVOKING_VERTEX_CONVENTION)
+} VK_PROVOKING_VERTEX_CONVENTION;
 
-typedef enum _XGL_COORDINATE_ORIGIN
+typedef enum _VK_COORDINATE_ORIGIN
 {
-    XGL_COORDINATE_ORIGIN_UPPER_LEFT                        = 0x00000000,
-    XGL_COORDINATE_ORIGIN_LOWER_LEFT                        = 0x00000001,
+    VK_COORDINATE_ORIGIN_UPPER_LEFT                        = 0x00000000,
+    VK_COORDINATE_ORIGIN_LOWER_LEFT                        = 0x00000001,
 
-    XGL_COORDINATE_ORIGIN_BEGIN_RANGE                       = XGL_COORDINATE_ORIGIN_UPPER_LEFT,
-    XGL_COORDINATE_ORIGIN_END_RANGE                         = XGL_COORDINATE_ORIGIN_LOWER_LEFT,
-    XGL_NUM_COORDINATE_ORIGIN                               = (XGL_COORDINATE_ORIGIN_END_RANGE - XGL_COORDINATE_ORIGIN_END_RANGE + 1),
-    XGL_MAX_ENUM(_XGL_COORDINATE_ORIGIN)
-} XGL_COORDINATE_ORIGIN;
+    VK_COORDINATE_ORIGIN_BEGIN_RANGE                       = VK_COORDINATE_ORIGIN_UPPER_LEFT,
+    VK_COORDINATE_ORIGIN_END_RANGE                         = VK_COORDINATE_ORIGIN_LOWER_LEFT,
+    VK_NUM_COORDINATE_ORIGIN                               = (VK_COORDINATE_ORIGIN_END_RANGE - VK_COORDINATE_ORIGIN_END_RANGE + 1),
+    VK_MAX_ENUM(_VK_COORDINATE_ORIGIN)
+} VK_COORDINATE_ORIGIN;
 
-typedef enum _XGL_DEPTH_MODE
+typedef enum _VK_DEPTH_MODE
 {
-    XGL_DEPTH_MODE_ZERO_TO_ONE                              = 0x00000000,
-    XGL_DEPTH_MODE_NEGATIVE_ONE_TO_ONE                      = 0x00000001,
+    VK_DEPTH_MODE_ZERO_TO_ONE                              = 0x00000000,
+    VK_DEPTH_MODE_NEGATIVE_ONE_TO_ONE                      = 0x00000001,
 
-    XGL_DEPTH_MODE_BEGIN_RANGE                              = XGL_DEPTH_MODE_ZERO_TO_ONE,
-    XGL_DEPTH_MODE_END_RANGE                                = XGL_DEPTH_MODE_NEGATIVE_ONE_TO_ONE,
-    XGL_NUM_DEPTH_MODE                                      = (XGL_DEPTH_MODE_END_RANGE - XGL_DEPTH_MODE_BEGIN_RANGE + 1),
-    XGL_MAX_ENUM(_XGL_DEPTH_MODE)
-} XGL_DEPTH_MODE;
+    VK_DEPTH_MODE_BEGIN_RANGE                              = VK_DEPTH_MODE_ZERO_TO_ONE,
+    VK_DEPTH_MODE_END_RANGE                                = VK_DEPTH_MODE_NEGATIVE_ONE_TO_ONE,
+    VK_NUM_DEPTH_MODE                                      = (VK_DEPTH_MODE_END_RANGE - VK_DEPTH_MODE_BEGIN_RANGE + 1),
+    VK_MAX_ENUM(_VK_DEPTH_MODE)
+} VK_DEPTH_MODE;
 
-typedef enum _XGL_BLEND
+typedef enum _VK_BLEND
 {
-    XGL_BLEND_ZERO                                          = 0x00000000,
-    XGL_BLEND_ONE                                           = 0x00000001,
-    XGL_BLEND_SRC_COLOR                                     = 0x00000002,
-    XGL_BLEND_ONE_MINUS_SRC_COLOR                           = 0x00000003,
-    XGL_BLEND_DEST_COLOR                                    = 0x00000004,
-    XGL_BLEND_ONE_MINUS_DEST_COLOR                          = 0x00000005,
-    XGL_BLEND_SRC_ALPHA                                     = 0x00000006,
-    XGL_BLEND_ONE_MINUS_SRC_ALPHA                           = 0x00000007,
-    XGL_BLEND_DEST_ALPHA                                    = 0x00000008,
-    XGL_BLEND_ONE_MINUS_DEST_ALPHA                          = 0x00000009,
-    XGL_BLEND_CONSTANT_COLOR                                = 0x0000000a,
-    XGL_BLEND_ONE_MINUS_CONSTANT_COLOR                      = 0x0000000b,
-    XGL_BLEND_CONSTANT_ALPHA                                = 0x0000000c,
-    XGL_BLEND_ONE_MINUS_CONSTANT_ALPHA                      = 0x0000000d,
-    XGL_BLEND_SRC_ALPHA_SATURATE                            = 0x0000000e,
-    XGL_BLEND_SRC1_COLOR                                    = 0x0000000f,
-    XGL_BLEND_ONE_MINUS_SRC1_COLOR                          = 0x00000010,
-    XGL_BLEND_SRC1_ALPHA                                    = 0x00000011,
-    XGL_BLEND_ONE_MINUS_SRC1_ALPHA                          = 0x00000012,
+    VK_BLEND_ZERO                                          = 0x00000000,
+    VK_BLEND_ONE                                           = 0x00000001,
+    VK_BLEND_SRC_COLOR                                     = 0x00000002,
+    VK_BLEND_ONE_MINUS_SRC_COLOR                           = 0x00000003,
+    VK_BLEND_DEST_COLOR                                    = 0x00000004,
+    VK_BLEND_ONE_MINUS_DEST_COLOR                          = 0x00000005,
+    VK_BLEND_SRC_ALPHA                                     = 0x00000006,
+    VK_BLEND_ONE_MINUS_SRC_ALPHA                           = 0x00000007,
+    VK_BLEND_DEST_ALPHA                                    = 0x00000008,
+    VK_BLEND_ONE_MINUS_DEST_ALPHA                          = 0x00000009,
+    VK_BLEND_CONSTANT_COLOR                                = 0x0000000a,
+    VK_BLEND_ONE_MINUS_CONSTANT_COLOR                      = 0x0000000b,
+    VK_BLEND_CONSTANT_ALPHA                                = 0x0000000c,
+    VK_BLEND_ONE_MINUS_CONSTANT_ALPHA                      = 0x0000000d,
+    VK_BLEND_SRC_ALPHA_SATURATE                            = 0x0000000e,
+    VK_BLEND_SRC1_COLOR                                    = 0x0000000f,
+    VK_BLEND_ONE_MINUS_SRC1_COLOR                          = 0x00000010,
+    VK_BLEND_SRC1_ALPHA                                    = 0x00000011,
+    VK_BLEND_ONE_MINUS_SRC1_ALPHA                          = 0x00000012,
 
-    XGL_BLEND_BEGIN_RANGE                                   = XGL_BLEND_ZERO,
-    XGL_BLEND_END_RANGE                                     = XGL_BLEND_ONE_MINUS_SRC1_ALPHA,
-    XGL_NUM_BLEND                                           = (XGL_BLEND_END_RANGE - XGL_BLEND_BEGIN_RANGE + 1),
-    XGL_MAX_ENUM(_XGL_BLEND)
-} XGL_BLEND;
+    VK_BLEND_BEGIN_RANGE                                   = VK_BLEND_ZERO,
+    VK_BLEND_END_RANGE                                     = VK_BLEND_ONE_MINUS_SRC1_ALPHA,
+    VK_NUM_BLEND                                           = (VK_BLEND_END_RANGE - VK_BLEND_BEGIN_RANGE + 1),
+    VK_MAX_ENUM(_VK_BLEND)
+} VK_BLEND;
 
-typedef enum _XGL_BLEND_FUNC
+typedef enum _VK_BLEND_FUNC
 {
-    XGL_BLEND_FUNC_ADD                                      = 0x00000000,
-    XGL_BLEND_FUNC_SUBTRACT                                 = 0x00000001,
-    XGL_BLEND_FUNC_REVERSE_SUBTRACT                         = 0x00000002,
-    XGL_BLEND_FUNC_MIN                                      = 0x00000003,
-    XGL_BLEND_FUNC_MAX                                      = 0x00000004,
+    VK_BLEND_FUNC_ADD                                      = 0x00000000,
+    VK_BLEND_FUNC_SUBTRACT                                 = 0x00000001,
+    VK_BLEND_FUNC_REVERSE_SUBTRACT                         = 0x00000002,
+    VK_BLEND_FUNC_MIN                                      = 0x00000003,
+    VK_BLEND_FUNC_MAX                                      = 0x00000004,
 
-    XGL_BLEND_FUNC_BEGIN_RANGE                              = XGL_BLEND_FUNC_ADD,
-    XGL_BLEND_FUNC_END_RANGE                                = XGL_BLEND_FUNC_MAX,
-    XGL_NUM_BLEND_FUNC                                      = (XGL_BLEND_FUNC_END_RANGE - XGL_BLEND_FUNC_BEGIN_RANGE + 1),
-    XGL_MAX_ENUM(_XGL_BLEND_FUNC)
-} XGL_BLEND_FUNC;
+    VK_BLEND_FUNC_BEGIN_RANGE                              = VK_BLEND_FUNC_ADD,
+    VK_BLEND_FUNC_END_RANGE                                = VK_BLEND_FUNC_MAX,
+    VK_NUM_BLEND_FUNC                                      = (VK_BLEND_FUNC_END_RANGE - VK_BLEND_FUNC_BEGIN_RANGE + 1),
+    VK_MAX_ENUM(_VK_BLEND_FUNC)
+} VK_BLEND_FUNC;
 
-typedef enum _XGL_STENCIL_OP
+typedef enum _VK_STENCIL_OP
 {
-    XGL_STENCIL_OP_KEEP                                     = 0x00000000,
-    XGL_STENCIL_OP_ZERO                                     = 0x00000001,
-    XGL_STENCIL_OP_REPLACE                                  = 0x00000002,
-    XGL_STENCIL_OP_INC_CLAMP                                = 0x00000003,
-    XGL_STENCIL_OP_DEC_CLAMP                                = 0x00000004,
-    XGL_STENCIL_OP_INVERT                                   = 0x00000005,
-    XGL_STENCIL_OP_INC_WRAP                                 = 0x00000006,
-    XGL_STENCIL_OP_DEC_WRAP                                 = 0x00000007,
+    VK_STENCIL_OP_KEEP                                     = 0x00000000,
+    VK_STENCIL_OP_ZERO                                     = 0x00000001,
+    VK_STENCIL_OP_REPLACE                                  = 0x00000002,
+    VK_STENCIL_OP_INC_CLAMP                                = 0x00000003,
+    VK_STENCIL_OP_DEC_CLAMP                                = 0x00000004,
+    VK_STENCIL_OP_INVERT                                   = 0x00000005,
+    VK_STENCIL_OP_INC_WRAP                                 = 0x00000006,
+    VK_STENCIL_OP_DEC_WRAP                                 = 0x00000007,
 
-    XGL_STENCIL_OP_BEGIN_RANGE                              = XGL_STENCIL_OP_KEEP,
-    XGL_STENCIL_OP_END_RANGE                                = XGL_STENCIL_OP_DEC_WRAP,
-    XGL_NUM_STENCIL_OP                                      = (XGL_STENCIL_OP_END_RANGE - XGL_STENCIL_OP_BEGIN_RANGE + 1),
-    XGL_MAX_ENUM(_XGL_STENCIL_OP)
-} XGL_STENCIL_OP;
+    VK_STENCIL_OP_BEGIN_RANGE                              = VK_STENCIL_OP_KEEP,
+    VK_STENCIL_OP_END_RANGE                                = VK_STENCIL_OP_DEC_WRAP,
+    VK_NUM_STENCIL_OP                                      = (VK_STENCIL_OP_END_RANGE - VK_STENCIL_OP_BEGIN_RANGE + 1),
+    VK_MAX_ENUM(_VK_STENCIL_OP)
+} VK_STENCIL_OP;
 
-typedef enum _XGL_LOGIC_OP
+typedef enum _VK_LOGIC_OP
 {
-    XGL_LOGIC_OP_COPY                                       = 0x00000000,
-    XGL_LOGIC_OP_CLEAR                                      = 0x00000001,
-    XGL_LOGIC_OP_AND                                        = 0x00000002,
-    XGL_LOGIC_OP_AND_REVERSE                                = 0x00000003,
-    XGL_LOGIC_OP_AND_INVERTED                               = 0x00000004,
-    XGL_LOGIC_OP_NOOP                                       = 0x00000005,
-    XGL_LOGIC_OP_XOR                                        = 0x00000006,
-    XGL_LOGIC_OP_OR                                         = 0x00000007,
-    XGL_LOGIC_OP_NOR                                        = 0x00000008,
-    XGL_LOGIC_OP_EQUIV                                      = 0x00000009,
-    XGL_LOGIC_OP_INVERT                                     = 0x0000000a,
-    XGL_LOGIC_OP_OR_REVERSE                                 = 0x0000000b,
-    XGL_LOGIC_OP_COPY_INVERTED                              = 0x0000000c,
-    XGL_LOGIC_OP_OR_INVERTED                                = 0x0000000d,
-    XGL_LOGIC_OP_NAND                                       = 0x0000000e,
-    XGL_LOGIC_OP_SET                                        = 0x0000000f,
+    VK_LOGIC_OP_COPY                                       = 0x00000000,
+    VK_LOGIC_OP_CLEAR                                      = 0x00000001,
+    VK_LOGIC_OP_AND                                        = 0x00000002,
+    VK_LOGIC_OP_AND_REVERSE                                = 0x00000003,
+    VK_LOGIC_OP_AND_INVERTED                               = 0x00000004,
+    VK_LOGIC_OP_NOOP                                       = 0x00000005,
+    VK_LOGIC_OP_XOR                                        = 0x00000006,
+    VK_LOGIC_OP_OR                                         = 0x00000007,
+    VK_LOGIC_OP_NOR                                        = 0x00000008,
+    VK_LOGIC_OP_EQUIV                                      = 0x00000009,
+    VK_LOGIC_OP_INVERT                                     = 0x0000000a,
+    VK_LOGIC_OP_OR_REVERSE                                 = 0x0000000b,
+    VK_LOGIC_OP_COPY_INVERTED                              = 0x0000000c,
+    VK_LOGIC_OP_OR_INVERTED                                = 0x0000000d,
+    VK_LOGIC_OP_NAND                                       = 0x0000000e,
+    VK_LOGIC_OP_SET                                        = 0x0000000f,
 
-    XGL_LOGIC_OP_BEGIN_RANGE                                = XGL_LOGIC_OP_COPY,
-    XGL_LOGIC_OP_END_RANGE                                  = XGL_LOGIC_OP_SET,
-    XGL_NUM_LOGIC_OP                                        = (XGL_LOGIC_OP_END_RANGE - XGL_LOGIC_OP_BEGIN_RANGE + 1),
-    XGL_MAX_ENUM(_XGL_LOGIC_OP)
-} XGL_LOGIC_OP;
+    VK_LOGIC_OP_BEGIN_RANGE                                = VK_LOGIC_OP_COPY,
+    VK_LOGIC_OP_END_RANGE                                  = VK_LOGIC_OP_SET,
+    VK_NUM_LOGIC_OP                                        = (VK_LOGIC_OP_END_RANGE - VK_LOGIC_OP_BEGIN_RANGE + 1),
+    VK_MAX_ENUM(_VK_LOGIC_OP)
+} VK_LOGIC_OP;
 
-typedef enum _XGL_SYSTEM_ALLOC_TYPE
+typedef enum _VK_SYSTEM_ALLOC_TYPE
 {
-    XGL_SYSTEM_ALLOC_API_OBJECT                             = 0x00000000,
-    XGL_SYSTEM_ALLOC_INTERNAL                               = 0x00000001,
-    XGL_SYSTEM_ALLOC_INTERNAL_TEMP                          = 0x00000002,
-    XGL_SYSTEM_ALLOC_INTERNAL_SHADER                        = 0x00000003,
-    XGL_SYSTEM_ALLOC_DEBUG                                  = 0x00000004,
+    VK_SYSTEM_ALLOC_API_OBJECT                             = 0x00000000,
+    VK_SYSTEM_ALLOC_INTERNAL                               = 0x00000001,
+    VK_SYSTEM_ALLOC_INTERNAL_TEMP                          = 0x00000002,
+    VK_SYSTEM_ALLOC_INTERNAL_SHADER                        = 0x00000003,
+    VK_SYSTEM_ALLOC_DEBUG                                  = 0x00000004,
 
-    XGL_SYSTEM_ALLOC_BEGIN_RANGE                            = XGL_SYSTEM_ALLOC_API_OBJECT,
-    XGL_SYSTEM_ALLOC_END_RANGE                              = XGL_SYSTEM_ALLOC_DEBUG,
-    XGL_NUM_SYSTEM_ALLOC_TYPE                               = (XGL_SYSTEM_ALLOC_END_RANGE - XGL_SYSTEM_ALLOC_BEGIN_RANGE + 1),
-    XGL_MAX_ENUM(_XGL_SYSTEM_ALLOC_TYPE)
-} XGL_SYSTEM_ALLOC_TYPE;
+    VK_SYSTEM_ALLOC_BEGIN_RANGE                            = VK_SYSTEM_ALLOC_API_OBJECT,
+    VK_SYSTEM_ALLOC_END_RANGE                              = VK_SYSTEM_ALLOC_DEBUG,
+    VK_NUM_SYSTEM_ALLOC_TYPE                               = (VK_SYSTEM_ALLOC_END_RANGE - VK_SYSTEM_ALLOC_BEGIN_RANGE + 1),
+    VK_MAX_ENUM(_VK_SYSTEM_ALLOC_TYPE)
+} VK_SYSTEM_ALLOC_TYPE;
 
-typedef enum _XGL_PHYSICAL_GPU_TYPE
+typedef enum _VK_PHYSICAL_GPU_TYPE
 {
-    XGL_GPU_TYPE_OTHER                                      = 0x00000000,
-    XGL_GPU_TYPE_INTEGRATED                                 = 0x00000001,
-    XGL_GPU_TYPE_DISCRETE                                   = 0x00000002,
-    XGL_GPU_TYPE_VIRTUAL                                    = 0x00000003,
+    VK_GPU_TYPE_OTHER                                      = 0x00000000,
+    VK_GPU_TYPE_INTEGRATED                                 = 0x00000001,
+    VK_GPU_TYPE_DISCRETE                                   = 0x00000002,
+    VK_GPU_TYPE_VIRTUAL                                    = 0x00000003,
 
-    XGL_PHYSICAL_GPU_TYPE_BEGIN_RANGE                       = XGL_GPU_TYPE_OTHER,
-    XGL_PHYSICAL_GPU_TYPE_END_RANGE                         = XGL_GPU_TYPE_VIRTUAL,
-    XGL_NUM_PHYSICAL_GPU_TYPE                               = (XGL_PHYSICAL_GPU_TYPE_END_RANGE - XGL_PHYSICAL_GPU_TYPE_BEGIN_RANGE + 1),
-    XGL_MAX_ENUM(_XGL_PHYSICAL_GPU_TYPE)
-} XGL_PHYSICAL_GPU_TYPE;
+    VK_PHYSICAL_GPU_TYPE_BEGIN_RANGE                       = VK_GPU_TYPE_OTHER,
+    VK_PHYSICAL_GPU_TYPE_END_RANGE                         = VK_GPU_TYPE_VIRTUAL,
+    VK_NUM_PHYSICAL_GPU_TYPE                               = (VK_PHYSICAL_GPU_TYPE_END_RANGE - VK_PHYSICAL_GPU_TYPE_BEGIN_RANGE + 1),
+    VK_MAX_ENUM(_VK_PHYSICAL_GPU_TYPE)
+} VK_PHYSICAL_GPU_TYPE;
 
-typedef enum _XGL_PHYSICAL_GPU_INFO_TYPE
+typedef enum _VK_PHYSICAL_GPU_INFO_TYPE
 {
-    // Info type for xglGetGpuInfo()
-    XGL_INFO_TYPE_PHYSICAL_GPU_PROPERTIES                   = 0x00000000,
-    XGL_INFO_TYPE_PHYSICAL_GPU_PERFORMANCE                  = 0x00000001,
-    XGL_INFO_TYPE_PHYSICAL_GPU_QUEUE_PROPERTIES             = 0x00000002,
-    XGL_INFO_TYPE_PHYSICAL_GPU_MEMORY_PROPERTIES            = 0x00000003,
+    // Info type for vkGetGpuInfo()
+    VK_INFO_TYPE_PHYSICAL_GPU_PROPERTIES                   = 0x00000000,
+    VK_INFO_TYPE_PHYSICAL_GPU_PERFORMANCE                  = 0x00000001,
+    VK_INFO_TYPE_PHYSICAL_GPU_QUEUE_PROPERTIES             = 0x00000002,
+    VK_INFO_TYPE_PHYSICAL_GPU_MEMORY_PROPERTIES            = 0x00000003,
 
-    XGL_INFO_TYPE_PHYSICAL_GPU_BEGIN_RANGE                  = XGL_INFO_TYPE_PHYSICAL_GPU_PROPERTIES,
-    XGL_INFO_TYPE_PHYSICAL_GPU_END_RANGE                    = XGL_INFO_TYPE_PHYSICAL_GPU_MEMORY_PROPERTIES,
-    XGL_NUM_INFO_TYPE_PHYSICAL_GPU                          = (XGL_INFO_TYPE_PHYSICAL_GPU_END_RANGE - XGL_INFO_TYPE_PHYSICAL_GPU_BEGIN_RANGE + 1),
-    XGL_MAX_ENUM(_XGL_PHYSICAL_GPU_INFO_TYPE)
-} XGL_PHYSICAL_GPU_INFO_TYPE;
+    VK_INFO_TYPE_PHYSICAL_GPU_BEGIN_RANGE                  = VK_INFO_TYPE_PHYSICAL_GPU_PROPERTIES,
+    VK_INFO_TYPE_PHYSICAL_GPU_END_RANGE                    = VK_INFO_TYPE_PHYSICAL_GPU_MEMORY_PROPERTIES,
+    VK_NUM_INFO_TYPE_PHYSICAL_GPU                          = (VK_INFO_TYPE_PHYSICAL_GPU_END_RANGE - VK_INFO_TYPE_PHYSICAL_GPU_BEGIN_RANGE + 1),
+    VK_MAX_ENUM(_VK_PHYSICAL_GPU_INFO_TYPE)
+} VK_PHYSICAL_GPU_INFO_TYPE;
 
-typedef enum _XGL_FORMAT_INFO_TYPE
+typedef enum _VK_FORMAT_INFO_TYPE
 {
-    // Info type for xglGetFormatInfo()
-    XGL_INFO_TYPE_FORMAT_PROPERTIES                         = 0x00000000,
+    // Info type for vkGetFormatInfo()
+    VK_INFO_TYPE_FORMAT_PROPERTIES                         = 0x00000000,
 
-    XGL_INFO_TYPE_FORMAT_BEGIN_RANGE                        = XGL_INFO_TYPE_FORMAT_PROPERTIES,
-    XGL_INFO_TYPE_FORMAT_END_RANGE                          = XGL_INFO_TYPE_FORMAT_PROPERTIES,
-    XGL_NUM_INFO_TYPE_FORMAT                                 = (XGL_INFO_TYPE_FORMAT_END_RANGE - XGL_INFO_TYPE_FORMAT_BEGIN_RANGE + 1),
-    XGL_MAX_ENUM(_XGL_FORMAT_INFO_TYPE)
-} XGL_FORMAT_INFO_TYPE;
+    VK_INFO_TYPE_FORMAT_BEGIN_RANGE                        = VK_INFO_TYPE_FORMAT_PROPERTIES,
+    VK_INFO_TYPE_FORMAT_END_RANGE                          = VK_INFO_TYPE_FORMAT_PROPERTIES,
+    VK_NUM_INFO_TYPE_FORMAT                                 = (VK_INFO_TYPE_FORMAT_END_RANGE - VK_INFO_TYPE_FORMAT_BEGIN_RANGE + 1),
+    VK_MAX_ENUM(_VK_FORMAT_INFO_TYPE)
+} VK_FORMAT_INFO_TYPE;
 
-typedef enum _XGL_SUBRESOURCE_INFO_TYPE
+typedef enum _VK_SUBRESOURCE_INFO_TYPE
 {
-    // Info type for xglGetImageSubresourceInfo()
-    XGL_INFO_TYPE_SUBRESOURCE_LAYOUT                        = 0x00000000,
+    // Info type for vkGetImageSubresourceInfo()
+    VK_INFO_TYPE_SUBRESOURCE_LAYOUT                        = 0x00000000,
 
-    XGL_INFO_TYPE_SUBRESOURCE_BEGIN_RANGE                   = XGL_INFO_TYPE_SUBRESOURCE_LAYOUT,
-    XGL_INFO_TYPE_SUBRESOURCE_END_RANGE                     = XGL_INFO_TYPE_SUBRESOURCE_LAYOUT,
-    XGL_NUM_INFO_TYPE_SUBRESOURCE                           = (XGL_INFO_TYPE_SUBRESOURCE_END_RANGE - XGL_INFO_TYPE_SUBRESOURCE_BEGIN_RANGE + 1),
-    XGL_MAX_ENUM(_XGL_SUBRESOURCE_INFO_TYPE)
-} XGL_SUBRESOURCE_INFO_TYPE;
+    VK_INFO_TYPE_SUBRESOURCE_BEGIN_RANGE                   = VK_INFO_TYPE_SUBRESOURCE_LAYOUT,
+    VK_INFO_TYPE_SUBRESOURCE_END_RANGE                     = VK_INFO_TYPE_SUBRESOURCE_LAYOUT,
+    VK_NUM_INFO_TYPE_SUBRESOURCE                           = (VK_INFO_TYPE_SUBRESOURCE_END_RANGE - VK_INFO_TYPE_SUBRESOURCE_BEGIN_RANGE + 1),
+    VK_MAX_ENUM(_VK_SUBRESOURCE_INFO_TYPE)
+} VK_SUBRESOURCE_INFO_TYPE;
 
-typedef enum _XGL_OBJECT_INFO_TYPE
+typedef enum _VK_OBJECT_INFO_TYPE
 {
-    // Info type for xglGetObjectInfo()
-    XGL_INFO_TYPE_MEMORY_ALLOCATION_COUNT                   = 0x00000000,
-    XGL_INFO_TYPE_MEMORY_REQUIREMENTS                       = 0x00000001,
-    XGL_INFO_TYPE_BUFFER_MEMORY_REQUIREMENTS                = 0x00000002,
-    XGL_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS                 = 0x00000003,
+    // Info type for vkGetObjectInfo()
+    VK_INFO_TYPE_MEMORY_ALLOCATION_COUNT                   = 0x00000000,
+    VK_INFO_TYPE_MEMORY_REQUIREMENTS                       = 0x00000001,
+    VK_INFO_TYPE_BUFFER_MEMORY_REQUIREMENTS                = 0x00000002,
+    VK_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS                 = 0x00000003,
 
-    XGL_INFO_TYPE_BEGIN_RANGE                               = XGL_INFO_TYPE_MEMORY_ALLOCATION_COUNT,
-    XGL_INFO_TYPE_END_RANGE                                 = XGL_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS,
-    XGL_NUM_INFO_TYPE                                       = (XGL_INFO_TYPE_END_RANGE - XGL_INFO_TYPE_BEGIN_RANGE + 1),
-    XGL_MAX_ENUM(_XGL_OBJECT_INFO_TYPE)
-} XGL_OBJECT_INFO_TYPE;
+    VK_INFO_TYPE_BEGIN_RANGE                               = VK_INFO_TYPE_MEMORY_ALLOCATION_COUNT,
+    VK_INFO_TYPE_END_RANGE                                 = VK_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS,
+    VK_NUM_INFO_TYPE                                       = (VK_INFO_TYPE_END_RANGE - VK_INFO_TYPE_BEGIN_RANGE + 1),
+    VK_MAX_ENUM(_VK_OBJECT_INFO_TYPE)
+} VK_OBJECT_INFO_TYPE;
 
-typedef enum _XGL_VALIDATION_LEVEL
+typedef enum _VK_VALIDATION_LEVEL
 {
-    XGL_VALIDATION_LEVEL_0                                  = 0x00000000,
-    XGL_VALIDATION_LEVEL_1                                  = 0x00000001,
-    XGL_VALIDATION_LEVEL_2                                  = 0x00000002,
-    XGL_VALIDATION_LEVEL_3                                  = 0x00000003,
-    XGL_VALIDATION_LEVEL_4                                  = 0x00000004,
+    VK_VALIDATION_LEVEL_0                                  = 0x00000000,
+    VK_VALIDATION_LEVEL_1                                  = 0x00000001,
+    VK_VALIDATION_LEVEL_2                                  = 0x00000002,
+    VK_VALIDATION_LEVEL_3                                  = 0x00000003,
+    VK_VALIDATION_LEVEL_4                                  = 0x00000004,
 
-    XGL_VALIDATION_LEVEL_BEGIN_RANGE                        = XGL_VALIDATION_LEVEL_0,
-    XGL_VALIDATION_LEVEL_END_RANGE                          = XGL_VALIDATION_LEVEL_4,
-    XGL_NUM_VALIDATION_LEVEL                                = (XGL_VALIDATION_LEVEL_END_RANGE - XGL_VALIDATION_LEVEL_BEGIN_RANGE + 1),
+    VK_VALIDATION_LEVEL_BEGIN_RANGE                        = VK_VALIDATION_LEVEL_0,
+    VK_VALIDATION_LEVEL_END_RANGE                          = VK_VALIDATION_LEVEL_4,
+    VK_NUM_VALIDATION_LEVEL                                = (VK_VALIDATION_LEVEL_END_RANGE - VK_VALIDATION_LEVEL_BEGIN_RANGE + 1),
 
-    XGL_MAX_ENUM(_XGL_VALIDATION_LEVEL)
-} XGL_VALIDATION_LEVEL;
+    VK_MAX_ENUM(_VK_VALIDATION_LEVEL)
+} VK_VALIDATION_LEVEL;
 
 // ------------------------------------------------------------------------------------------------
 // Error and return codes
 
-typedef enum _XGL_RESULT
+typedef enum _VK_RESULT
 {
     // Return codes for successful operation execution (>= 0)
-    XGL_SUCCESS                                             = 0x0000000,
-    XGL_UNSUPPORTED                                         = 0x0000001,
-    XGL_NOT_READY                                           = 0x0000002,
-    XGL_TIMEOUT                                             = 0x0000003,
-    XGL_EVENT_SET                                           = 0x0000004,
-    XGL_EVENT_RESET                                         = 0x0000005,
+    VK_SUCCESS                                             = 0x0000000,
+    VK_UNSUPPORTED                                         = 0x0000001,
+    VK_NOT_READY                                           = 0x0000002,
+    VK_TIMEOUT                                             = 0x0000003,
+    VK_EVENT_SET                                           = 0x0000004,
+    VK_EVENT_RESET                                         = 0x0000005,
 
     // Error codes (negative values)
-    XGL_ERROR_UNKNOWN                                       = -(0x00000001),
-    XGL_ERROR_UNAVAILABLE                                   = -(0x00000002),
-    XGL_ERROR_INITIALIZATION_FAILED                         = -(0x00000003),
-    XGL_ERROR_OUT_OF_MEMORY                                 = -(0x00000004),
-    XGL_ERROR_OUT_OF_GPU_MEMORY                             = -(0x00000005),
-    XGL_ERROR_DEVICE_ALREADY_CREATED                        = -(0x00000006),
-    XGL_ERROR_DEVICE_LOST                                   = -(0x00000007),
-    XGL_ERROR_INVALID_POINTER                               = -(0x00000008),
-    XGL_ERROR_INVALID_VALUE                                 = -(0x00000009),
-    XGL_ERROR_INVALID_HANDLE                                = -(0x0000000A),
-    XGL_ERROR_INVALID_ORDINAL                               = -(0x0000000B),
-    XGL_ERROR_INVALID_MEMORY_SIZE                           = -(0x0000000C),
-    XGL_ERROR_INVALID_EXTENSION                             = -(0x0000000D),
-    XGL_ERROR_INVALID_FLAGS                                 = -(0x0000000E),
-    XGL_ERROR_INVALID_ALIGNMENT                             = -(0x0000000F),
-    XGL_ERROR_INVALID_FORMAT                                = -(0x00000010),
-    XGL_ERROR_INVALID_IMAGE                                 = -(0x00000011),
-    XGL_ERROR_INVALID_DESCRIPTOR_SET_DATA                   = -(0x00000012),
-    XGL_ERROR_INVALID_QUEUE_TYPE                            = -(0x00000013),
-    XGL_ERROR_INVALID_OBJECT_TYPE                           = -(0x00000014),
-    XGL_ERROR_UNSUPPORTED_SHADER_IL_VERSION                 = -(0x00000015),
-    XGL_ERROR_BAD_SHADER_CODE                               = -(0x00000016),
-    XGL_ERROR_BAD_PIPELINE_DATA                             = -(0x00000017),
-    XGL_ERROR_TOO_MANY_MEMORY_REFERENCES                    = -(0x00000018),
-    XGL_ERROR_NOT_MAPPABLE                                  = -(0x00000019),
-    XGL_ERROR_MEMORY_MAP_FAILED                             = -(0x0000001A),
-    XGL_ERROR_MEMORY_UNMAP_FAILED                           = -(0x0000001B),
-    XGL_ERROR_INCOMPATIBLE_DEVICE                           = -(0x0000001C),
-    XGL_ERROR_INCOMPATIBLE_DRIVER                           = -(0x0000001D),
-    XGL_ERROR_INCOMPLETE_COMMAND_BUFFER                     = -(0x0000001E),
-    XGL_ERROR_BUILDING_COMMAND_BUFFER                       = -(0x0000001F),
-    XGL_ERROR_MEMORY_NOT_BOUND                              = -(0x00000020),
-    XGL_ERROR_INCOMPATIBLE_QUEUE                            = -(0x00000021),
-    XGL_ERROR_NOT_SHAREABLE                                 = -(0x00000022),
-    XGL_MAX_ENUM(_XGL_RESULT_CODE)
-} XGL_RESULT;
+    VK_ERROR_UNKNOWN                                       = -(0x00000001),
+    VK_ERROR_UNAVAILABLE                                   = -(0x00000002),
+    VK_ERROR_INITIALIZATION_FAILED                         = -(0x00000003),
+    VK_ERROR_OUT_OF_MEMORY                                 = -(0x00000004),
+    VK_ERROR_OUT_OF_GPU_MEMORY                             = -(0x00000005),
+    VK_ERROR_DEVICE_ALREADY_CREATED                        = -(0x00000006),
+    VK_ERROR_DEVICE_LOST                                   = -(0x00000007),
+    VK_ERROR_INVALID_POINTER                               = -(0x00000008),
+    VK_ERROR_INVALID_VALUE                                 = -(0x00000009),
+    VK_ERROR_INVALID_HANDLE                                = -(0x0000000A),
+    VK_ERROR_INVALID_ORDINAL                               = -(0x0000000B),
+    VK_ERROR_INVALID_MEMORY_SIZE                           = -(0x0000000C),
+    VK_ERROR_INVALID_EXTENSION                             = -(0x0000000D),
+    VK_ERROR_INVALID_FLAGS                                 = -(0x0000000E),
+    VK_ERROR_INVALID_ALIGNMENT                             = -(0x0000000F),
+    VK_ERROR_INVALID_FORMAT                                = -(0x00000010),
+    VK_ERROR_INVALID_IMAGE                                 = -(0x00000011),
+    VK_ERROR_INVALID_DESCRIPTOR_SET_DATA                   = -(0x00000012),
+    VK_ERROR_INVALID_QUEUE_TYPE                            = -(0x00000013),
+    VK_ERROR_INVALID_OBJECT_TYPE                           = -(0x00000014),
+    VK_ERROR_UNSUPPORTED_SHADER_IL_VERSION                 = -(0x00000015),
+    VK_ERROR_BAD_SHADER_CODE                               = -(0x00000016),
+    VK_ERROR_BAD_PIPELINE_DATA                             = -(0x00000017),
+    VK_ERROR_TOO_MANY_MEMORY_REFERENCES                    = -(0x00000018),
+    VK_ERROR_NOT_MAPPABLE                                  = -(0x00000019),
+    VK_ERROR_MEMORY_MAP_FAILED                             = -(0x0000001A),
+    VK_ERROR_MEMORY_UNMAP_FAILED                           = -(0x0000001B),
+    VK_ERROR_INCOMPATIBLE_DEVICE                           = -(0x0000001C),
+    VK_ERROR_INCOMPATIBLE_DRIVER                           = -(0x0000001D),
+    VK_ERROR_INCOMPLETE_COMMAND_BUFFER                     = -(0x0000001E),
+    VK_ERROR_BUILDING_COMMAND_BUFFER                       = -(0x0000001F),
+    VK_ERROR_MEMORY_NOT_BOUND                              = -(0x00000020),
+    VK_ERROR_INCOMPATIBLE_QUEUE                            = -(0x00000021),
+    VK_ERROR_NOT_SHAREABLE                                 = -(0x00000022),
+    VK_MAX_ENUM(_VK_RESULT_CODE)
+} VK_RESULT;
 
 // ------------------------------------------------------------------------------------------------
-// XGL format definitions
+// VK format definitions
 
-typedef enum _XGL_VERTEX_INPUT_STEP_RATE
+typedef enum _VK_VERTEX_INPUT_STEP_RATE
 {
-    XGL_VERTEX_INPUT_STEP_RATE_VERTEX                       = 0x0,
-    XGL_VERTEX_INPUT_STEP_RATE_INSTANCE                     = 0x1,
-    XGL_VERTEX_INPUT_STEP_RATE_DRAW                         = 0x2,  //Optional
+    VK_VERTEX_INPUT_STEP_RATE_VERTEX                       = 0x0,
+    VK_VERTEX_INPUT_STEP_RATE_INSTANCE                     = 0x1,
+    VK_VERTEX_INPUT_STEP_RATE_DRAW                         = 0x2,  //Optional
 
-    XGL_VERTEX_INPUT_STEP_RATE_BEGIN_RANGE                  = XGL_VERTEX_INPUT_STEP_RATE_VERTEX,
-    XGL_VERTEX_INPUT_STEP_RATE_END_RANGE                    = XGL_VERTEX_INPUT_STEP_RATE_DRAW,
-    XGL_NUM_VERTEX_INPUT_STEP_RATE                          = (XGL_VERTEX_INPUT_STEP_RATE_END_RANGE - XGL_VERTEX_INPUT_STEP_RATE_BEGIN_RANGE + 1),
-    XGL_MAX_ENUM(_XGL_VERTEX_INPUT_STEP_RATE)
-} XGL_VERTEX_INPUT_STEP_RATE;
+    VK_VERTEX_INPUT_STEP_RATE_BEGIN_RANGE                  = VK_VERTEX_INPUT_STEP_RATE_VERTEX,
+    VK_VERTEX_INPUT_STEP_RATE_END_RANGE                    = VK_VERTEX_INPUT_STEP_RATE_DRAW,
+    VK_NUM_VERTEX_INPUT_STEP_RATE                          = (VK_VERTEX_INPUT_STEP_RATE_END_RANGE - VK_VERTEX_INPUT_STEP_RATE_BEGIN_RANGE + 1),
+    VK_MAX_ENUM(_VK_VERTEX_INPUT_STEP_RATE)
+} VK_VERTEX_INPUT_STEP_RATE;
 
-typedef enum _XGL_FORMAT
+typedef enum _VK_FORMAT
 {
-    XGL_FMT_UNDEFINED                                       = 0x00000000,
-    XGL_FMT_R4G4_UNORM                                      = 0x00000001,
-    XGL_FMT_R4G4_USCALED                                    = 0x00000002,
-    XGL_FMT_R4G4B4A4_UNORM                                  = 0x00000003,
-    XGL_FMT_R4G4B4A4_USCALED                                = 0x00000004,
-    XGL_FMT_R5G6B5_UNORM                                    = 0x00000005,
-    XGL_FMT_R5G6B5_USCALED                                  = 0x00000006,
-    XGL_FMT_R5G5B5A1_UNORM                                  = 0x00000007,
-    XGL_FMT_R5G5B5A1_USCALED                                = 0x00000008,
-    XGL_FMT_R8_UNORM                                        = 0x00000009,
-    XGL_FMT_R8_SNORM                                        = 0x0000000A,
-    XGL_FMT_R8_USCALED                                      = 0x0000000B,
-    XGL_FMT_R8_SSCALED                                      = 0x0000000C,
-    XGL_FMT_R8_UINT                                         = 0x0000000D,
-    XGL_FMT_R8_SINT                                         = 0x0000000E,
-    XGL_FMT_R8_SRGB                                         = 0x0000000F,
-    XGL_FMT_R8G8_UNORM                                      = 0x00000010,
-    XGL_FMT_R8G8_SNORM                                      = 0x00000011,
-    XGL_FMT_R8G8_USCALED                                    = 0x00000012,
-    XGL_FMT_R8G8_SSCALED                                    = 0x00000013,
-    XGL_FMT_R8G8_UINT                                       = 0x00000014,
-    XGL_FMT_R8G8_SINT                                       = 0x00000015,
-    XGL_FMT_R8G8_SRGB                                       = 0x00000016,
-    XGL_FMT_R8G8B8_UNORM                                    = 0x00000017,
-    XGL_FMT_R8G8B8_SNORM                                    = 0x00000018,
-    XGL_FMT_R8G8B8_USCALED                                  = 0x00000019,
-    XGL_FMT_R8G8B8_SSCALED                                  = 0x0000001A,
-    XGL_FMT_R8G8B8_UINT                                     = 0x0000001B,
-    XGL_FMT_R8G8B8_SINT                                     = 0x0000001C,
-    XGL_FMT_R8G8B8_SRGB                                     = 0x0000001D,
-    XGL_FMT_R8G8B8A8_UNORM                                  = 0x0000001E,
-    XGL_FMT_R8G8B8A8_SNORM                                  = 0x0000001F,
-    XGL_FMT_R8G8B8A8_USCALED                                = 0x00000020,
-    XGL_FMT_R8G8B8A8_SSCALED                                = 0x00000021,
-    XGL_FMT_R8G8B8A8_UINT                                   = 0x00000022,
-    XGL_FMT_R8G8B8A8_SINT                                   = 0x00000023,
-    XGL_FMT_R8G8B8A8_SRGB                                   = 0x00000024,
-    XGL_FMT_R10G10B10A2_UNORM                               = 0x00000025,
-    XGL_FMT_R10G10B10A2_SNORM                               = 0x00000026,
-    XGL_FMT_R10G10B10A2_USCALED                             = 0x00000027,
-    XGL_FMT_R10G10B10A2_SSCALED                             = 0x00000028,
-    XGL_FMT_R10G10B10A2_UINT                                = 0x00000029,
-    XGL_FMT_R10G10B10A2_SINT                                = 0x0000002A,
-    XGL_FMT_R16_UNORM                                       = 0x0000002B,
-    XGL_FMT_R16_SNORM                                       = 0x0000002C,
-    XGL_FMT_R16_USCALED                                     = 0x0000002D,
-    XGL_FMT_R16_SSCALED                                     = 0x0000002E,
-    XGL_FMT_R16_UINT                                        = 0x0000002F,
-    XGL_FMT_R16_SINT                                        = 0x00000030,
-    XGL_FMT_R16_SFLOAT                                      = 0x00000031,
-    XGL_FMT_R16G16_UNORM                                    = 0x00000032,
-    XGL_FMT_R16G16_SNORM                                    = 0x00000033,
-    XGL_FMT_R16G16_USCALED                                  = 0x00000034,
-    XGL_FMT_R16G16_SSCALED                                  = 0x00000035,
-    XGL_FMT_R16G16_UINT                                     = 0x00000036,
-    XGL_FMT_R16G16_SINT                                     = 0x00000037,
-    XGL_FMT_R16G16_SFLOAT                                   = 0x00000038,
-    XGL_FMT_R16G16B16_UNORM                                 = 0x00000039,
-    XGL_FMT_R16G16B16_SNORM                                 = 0x0000003A,
-    XGL_FMT_R16G16B16_USCALED                               = 0x0000003B,
-    XGL_FMT_R16G16B16_SSCALED                               = 0x0000003C,
-    XGL_FMT_R16G16B16_UINT                                  = 0x0000003D,
-    XGL_FMT_R16G16B16_SINT                                  = 0x0000003E,
-    XGL_FMT_R16G16B16_SFLOAT                                = 0x0000003F,
-    XGL_FMT_R16G16B16A16_UNORM                              = 0x00000040,
-    XGL_FMT_R16G16B16A16_SNORM                              = 0x00000041,
-    XGL_FMT_R16G16B16A16_USCALED                            = 0x00000042,
-    XGL_FMT_R16G16B16A16_SSCALED                            = 0x00000043,
-    XGL_FMT_R16G16B16A16_UINT                               = 0x00000044,
-    XGL_FMT_R16G16B16A16_SINT                               = 0x00000045,
-    XGL_FMT_R16G16B16A16_SFLOAT                             = 0x00000046,
-    XGL_FMT_R32_UINT                                        = 0x00000047,
-    XGL_FMT_R32_SINT                                        = 0x00000048,
-    XGL_FMT_R32_SFLOAT                                      = 0x00000049,
-    XGL_FMT_R32G32_UINT                                     = 0x0000004A,
-    XGL_FMT_R32G32_SINT                                     = 0x0000004B,
-    XGL_FMT_R32G32_SFLOAT                                   = 0x0000004C,
-    XGL_FMT_R32G32B32_UINT                                  = 0x0000004D,
-    XGL_FMT_R32G32B32_SINT                                  = 0x0000004E,
-    XGL_FMT_R32G32B32_SFLOAT                                = 0x0000004F,
-    XGL_FMT_R32G32B32A32_UINT                               = 0x00000050,
-    XGL_FMT_R32G32B32A32_SINT                               = 0x00000051,
-    XGL_FMT_R32G32B32A32_SFLOAT                             = 0x00000052,
-    XGL_FMT_R64_SFLOAT                                      = 0x00000053,
-    XGL_FMT_R64G64_SFLOAT                                   = 0x00000054,
-    XGL_FMT_R64G64B64_SFLOAT                                = 0x00000055,
-    XGL_FMT_R64G64B64A64_SFLOAT                             = 0x00000056,
-    XGL_FMT_R11G11B10_UFLOAT                                = 0x00000057,
-    XGL_FMT_R9G9B9E5_UFLOAT                                 = 0x00000058,
-    XGL_FMT_D16_UNORM                                       = 0x00000059,
-    XGL_FMT_D24_UNORM                                       = 0x0000005A,
-    XGL_FMT_D32_SFLOAT                                      = 0x0000005B,
-    XGL_FMT_S8_UINT                                         = 0x0000005C,
-    XGL_FMT_D16_UNORM_S8_UINT                               = 0x0000005D,
-    XGL_FMT_D24_UNORM_S8_UINT                               = 0x0000005E,
-    XGL_FMT_D32_SFLOAT_S8_UINT                              = 0x0000005F,
-    XGL_FMT_BC1_RGB_UNORM                                   = 0x00000060,
-    XGL_FMT_BC1_RGB_SRGB                                    = 0x00000061,
-    XGL_FMT_BC1_RGBA_UNORM                                  = 0x00000062,
-    XGL_FMT_BC1_RGBA_SRGB                                   = 0x00000063,
-    XGL_FMT_BC2_UNORM                                       = 0x00000064,
-    XGL_FMT_BC2_SRGB                                        = 0x00000065,
-    XGL_FMT_BC3_UNORM                                       = 0x00000066,
-    XGL_FMT_BC3_SRGB                                        = 0x00000067,
-    XGL_FMT_BC4_UNORM                                       = 0x00000068,
-    XGL_FMT_BC4_SNORM                                       = 0x00000069,
-    XGL_FMT_BC5_UNORM                                       = 0x0000006A,
-    XGL_FMT_BC5_SNORM                                       = 0x0000006B,
-    XGL_FMT_BC6H_UFLOAT                                     = 0x0000006C,
-    XGL_FMT_BC6H_SFLOAT                                     = 0x0000006D,
-    XGL_FMT_BC7_UNORM                                       = 0x0000006E,
-    XGL_FMT_BC7_SRGB                                        = 0x0000006F,
-    XGL_FMT_ETC2_R8G8B8_UNORM                               = 0x00000070,
-    XGL_FMT_ETC2_R8G8B8_SRGB                                = 0x00000071,
-    XGL_FMT_ETC2_R8G8B8A1_UNORM                             = 0x00000072,
-    XGL_FMT_ETC2_R8G8B8A1_SRGB                              = 0x00000073,
-    XGL_FMT_ETC2_R8G8B8A8_UNORM                             = 0x00000074,
-    XGL_FMT_ETC2_R8G8B8A8_SRGB                              = 0x00000075,
-    XGL_FMT_EAC_R11_UNORM                                   = 0x00000076,
-    XGL_FMT_EAC_R11_SNORM                                   = 0x00000077,
-    XGL_FMT_EAC_R11G11_UNORM                                = 0x00000078,
-    XGL_FMT_EAC_R11G11_SNORM                                = 0x00000079,
-    XGL_FMT_ASTC_4x4_UNORM                                  = 0x0000007A,
-    XGL_FMT_ASTC_4x4_SRGB                                   = 0x0000007B,
-    XGL_FMT_ASTC_5x4_UNORM                                  = 0x0000007C,
-    XGL_FMT_ASTC_5x4_SRGB                                   = 0x0000007D,
-    XGL_FMT_ASTC_5x5_UNORM                                  = 0x0000007E,
-    XGL_FMT_ASTC_5x5_SRGB                                   = 0x0000007F,
-    XGL_FMT_ASTC_6x5_UNORM                                  = 0x00000080,
-    XGL_FMT_ASTC_6x5_SRGB                                   = 0x00000081,
-    XGL_FMT_ASTC_6x6_UNORM                                  = 0x00000082,
-    XGL_FMT_ASTC_6x6_SRGB                                   = 0x00000083,
-    XGL_FMT_ASTC_8x5_UNORM                                  = 0x00000084,
-    XGL_FMT_ASTC_8x5_SRGB                                   = 0x00000085,
-    XGL_FMT_ASTC_8x6_UNORM                                  = 0x00000086,
-    XGL_FMT_ASTC_8x6_SRGB                                   = 0x00000087,
-    XGL_FMT_ASTC_8x8_UNORM                                  = 0x00000088,
-    XGL_FMT_ASTC_8x8_SRGB                                   = 0x00000089,
-    XGL_FMT_ASTC_10x5_UNORM                                 = 0x0000008A,
-    XGL_FMT_ASTC_10x5_SRGB                                  = 0x0000008B,
-    XGL_FMT_ASTC_10x6_UNORM                                 = 0x0000008C,
-    XGL_FMT_ASTC_10x6_SRGB                                  = 0x0000008D,
-    XGL_FMT_ASTC_10x8_UNORM                                 = 0x0000008E,
-    XGL_FMT_ASTC_10x8_SRGB                                  = 0x0000008F,
-    XGL_FMT_ASTC_10x10_UNORM                                = 0x00000090,
-    XGL_FMT_ASTC_10x10_SRGB                                 = 0x00000091,
-    XGL_FMT_ASTC_12x10_UNORM                                = 0x00000092,
-    XGL_FMT_ASTC_12x10_SRGB                                 = 0x00000093,
-    XGL_FMT_ASTC_12x12_UNORM                                = 0x00000094,
-    XGL_FMT_ASTC_12x12_SRGB                                 = 0x00000095,
-    XGL_FMT_B4G4R4A4_UNORM                                  = 0x00000096,
-    XGL_FMT_B5G5R5A1_UNORM                                  = 0x00000097,
-    XGL_FMT_B5G6R5_UNORM                                    = 0x00000098,
-    XGL_FMT_B5G6R5_USCALED                                  = 0x00000099,
-    XGL_FMT_B8G8R8_UNORM                                    = 0x0000009A,
-    XGL_FMT_B8G8R8_SNORM                                    = 0x0000009B,
-    XGL_FMT_B8G8R8_USCALED                                  = 0x0000009C,
-    XGL_FMT_B8G8R8_SSCALED                                  = 0x0000009D,
-    XGL_FMT_B8G8R8_UINT                                     = 0x0000009E,
-    XGL_FMT_B8G8R8_SINT                                     = 0x0000009F,
-    XGL_FMT_B8G8R8_SRGB                                     = 0x000000A0,
-    XGL_FMT_B8G8R8A8_UNORM                                  = 0x000000A1,
-    XGL_FMT_B8G8R8A8_SNORM                                  = 0x000000A2,
-    XGL_FMT_B8G8R8A8_USCALED                                = 0x000000A3,
-    XGL_FMT_B8G8R8A8_SSCALED                                = 0x000000A4,
-    XGL_FMT_B8G8R8A8_UINT                                   = 0x000000A5,
-    XGL_FMT_B8G8R8A8_SINT                                   = 0x000000A6,
-    XGL_FMT_B8G8R8A8_SRGB                                   = 0x000000A7,
-    XGL_FMT_B10G10R10A2_UNORM                               = 0x000000A8,
-    XGL_FMT_B10G10R10A2_SNORM                               = 0x000000A9,
-    XGL_FMT_B10G10R10A2_USCALED                             = 0x000000AA,
-    XGL_FMT_B10G10R10A2_SSCALED                             = 0x000000AB,
-    XGL_FMT_B10G10R10A2_UINT                                = 0x000000AC,
-    XGL_FMT_B10G10R10A2_SINT                                = 0x000000AD,
+    VK_FMT_UNDEFINED                                       = 0x00000000,
+    VK_FMT_R4G4_UNORM                                      = 0x00000001,
+    VK_FMT_R4G4_USCALED                                    = 0x00000002,
+    VK_FMT_R4G4B4A4_UNORM                                  = 0x00000003,
+    VK_FMT_R4G4B4A4_USCALED                                = 0x00000004,
+    VK_FMT_R5G6B5_UNORM                                    = 0x00000005,
+    VK_FMT_R5G6B5_USCALED                                  = 0x00000006,
+    VK_FMT_R5G5B5A1_UNORM                                  = 0x00000007,
+    VK_FMT_R5G5B5A1_USCALED                                = 0x00000008,
+    VK_FMT_R8_UNORM                                        = 0x00000009,
+    VK_FMT_R8_SNORM                                        = 0x0000000A,
+    VK_FMT_R8_USCALED                                      = 0x0000000B,
+    VK_FMT_R8_SSCALED                                      = 0x0000000C,
+    VK_FMT_R8_UINT                                         = 0x0000000D,
+    VK_FMT_R8_SINT                                         = 0x0000000E,
+    VK_FMT_R8_SRGB                                         = 0x0000000F,
+    VK_FMT_R8G8_UNORM                                      = 0x00000010,
+    VK_FMT_R8G8_SNORM                                      = 0x00000011,
+    VK_FMT_R8G8_USCALED                                    = 0x00000012,
+    VK_FMT_R8G8_SSCALED                                    = 0x00000013,
+    VK_FMT_R8G8_UINT                                       = 0x00000014,
+    VK_FMT_R8G8_SINT                                       = 0x00000015,
+    VK_FMT_R8G8_SRGB                                       = 0x00000016,
+    VK_FMT_R8G8B8_UNORM                                    = 0x00000017,
+    VK_FMT_R8G8B8_SNORM                                    = 0x00000018,
+    VK_FMT_R8G8B8_USCALED                                  = 0x00000019,
+    VK_FMT_R8G8B8_SSCALED                                  = 0x0000001A,
+    VK_FMT_R8G8B8_UINT                                     = 0x0000001B,
+    VK_FMT_R8G8B8_SINT                                     = 0x0000001C,
+    VK_FMT_R8G8B8_SRGB                                     = 0x0000001D,
+    VK_FMT_R8G8B8A8_UNORM                                  = 0x0000001E,
+    VK_FMT_R8G8B8A8_SNORM                                  = 0x0000001F,
+    VK_FMT_R8G8B8A8_USCALED                                = 0x00000020,
+    VK_FMT_R8G8B8A8_SSCALED                                = 0x00000021,
+    VK_FMT_R8G8B8A8_UINT                                   = 0x00000022,
+    VK_FMT_R8G8B8A8_SINT                                   = 0x00000023,
+    VK_FMT_R8G8B8A8_SRGB                                   = 0x00000024,
+    VK_FMT_R10G10B10A2_UNORM                               = 0x00000025,
+    VK_FMT_R10G10B10A2_SNORM                               = 0x00000026,
+    VK_FMT_R10G10B10A2_USCALED                             = 0x00000027,
+    VK_FMT_R10G10B10A2_SSCALED                             = 0x00000028,
+    VK_FMT_R10G10B10A2_UINT                                = 0x00000029,
+    VK_FMT_R10G10B10A2_SINT                                = 0x0000002A,
+    VK_FMT_R16_UNORM                                       = 0x0000002B,
+    VK_FMT_R16_SNORM                                       = 0x0000002C,
+    VK_FMT_R16_USCALED                                     = 0x0000002D,
+    VK_FMT_R16_SSCALED                                     = 0x0000002E,
+    VK_FMT_R16_UINT                                        = 0x0000002F,
+    VK_FMT_R16_SINT                                        = 0x00000030,
+    VK_FMT_R16_SFLOAT                                      = 0x00000031,
+    VK_FMT_R16G16_UNORM                                    = 0x00000032,
+    VK_FMT_R16G16_SNORM                                    = 0x00000033,
+    VK_FMT_R16G16_USCALED                                  = 0x00000034,
+    VK_FMT_R16G16_SSCALED                                  = 0x00000035,
+    VK_FMT_R16G16_UINT                                     = 0x00000036,
+    VK_FMT_R16G16_SINT                                     = 0x00000037,
+    VK_FMT_R16G16_SFLOAT                                   = 0x00000038,
+    VK_FMT_R16G16B16_UNORM                                 = 0x00000039,
+    VK_FMT_R16G16B16_SNORM                                 = 0x0000003A,
+    VK_FMT_R16G16B16_USCALED                               = 0x0000003B,
+    VK_FMT_R16G16B16_SSCALED                               = 0x0000003C,
+    VK_FMT_R16G16B16_UINT                                  = 0x0000003D,
+    VK_FMT_R16G16B16_SINT                                  = 0x0000003E,
+    VK_FMT_R16G16B16_SFLOAT                                = 0x0000003F,
+    VK_FMT_R16G16B16A16_UNORM                              = 0x00000040,
+    VK_FMT_R16G16B16A16_SNORM                              = 0x00000041,
+    VK_FMT_R16G16B16A16_USCALED                            = 0x00000042,
+    VK_FMT_R16G16B16A16_SSCALED                            = 0x00000043,
+    VK_FMT_R16G16B16A16_UINT                               = 0x00000044,
+    VK_FMT_R16G16B16A16_SINT                               = 0x00000045,
+    VK_FMT_R16G16B16A16_SFLOAT                             = 0x00000046,
+    VK_FMT_R32_UINT                                        = 0x00000047,
+    VK_FMT_R32_SINT                                        = 0x00000048,
+    VK_FMT_R32_SFLOAT                                      = 0x00000049,
+    VK_FMT_R32G32_UINT                                     = 0x0000004A,
+    VK_FMT_R32G32_SINT                                     = 0x0000004B,
+    VK_FMT_R32G32_SFLOAT                                   = 0x0000004C,
+    VK_FMT_R32G32B32_UINT                                  = 0x0000004D,
+    VK_FMT_R32G32B32_SINT                                  = 0x0000004E,
+    VK_FMT_R32G32B32_SFLOAT                                = 0x0000004F,
+    VK_FMT_R32G32B32A32_UINT                               = 0x00000050,
+    VK_FMT_R32G32B32A32_SINT                               = 0x00000051,
+    VK_FMT_R32G32B32A32_SFLOAT                             = 0x00000052,
+    VK_FMT_R64_SFLOAT                                      = 0x00000053,
+    VK_FMT_R64G64_SFLOAT                                   = 0x00000054,
+    VK_FMT_R64G64B64_SFLOAT                                = 0x00000055,
+    VK_FMT_R64G64B64A64_SFLOAT                             = 0x00000056,
+    VK_FMT_R11G11B10_UFLOAT                                = 0x00000057,
+    VK_FMT_R9G9B9E5_UFLOAT                                 = 0x00000058,
+    VK_FMT_D16_UNORM                                       = 0x00000059,
+    VK_FMT_D24_UNORM                                       = 0x0000005A,
+    VK_FMT_D32_SFLOAT                                      = 0x0000005B,
+    VK_FMT_S8_UINT                                         = 0x0000005C,
+    VK_FMT_D16_UNORM_S8_UINT                               = 0x0000005D,
+    VK_FMT_D24_UNORM_S8_UINT                               = 0x0000005E,
+    VK_FMT_D32_SFLOAT_S8_UINT                              = 0x0000005F,
+    VK_FMT_BC1_RGB_UNORM                                   = 0x00000060,
+    VK_FMT_BC1_RGB_SRGB                                    = 0x00000061,
+    VK_FMT_BC1_RGBA_UNORM                                  = 0x00000062,
+    VK_FMT_BC1_RGBA_SRGB                                   = 0x00000063,
+    VK_FMT_BC2_UNORM                                       = 0x00000064,
+    VK_FMT_BC2_SRGB                                        = 0x00000065,
+    VK_FMT_BC3_UNORM                                       = 0x00000066,
+    VK_FMT_BC3_SRGB                                        = 0x00000067,
+    VK_FMT_BC4_UNORM                                       = 0x00000068,
+    VK_FMT_BC4_SNORM                                       = 0x00000069,
+    VK_FMT_BC5_UNORM                                       = 0x0000006A,
+    VK_FMT_BC5_SNORM                                       = 0x0000006B,
+    VK_FMT_BC6H_UFLOAT                                     = 0x0000006C,
+    VK_FMT_BC6H_SFLOAT                                     = 0x0000006D,
+    VK_FMT_BC7_UNORM                                       = 0x0000006E,
+    VK_FMT_BC7_SRGB                                        = 0x0000006F,
+    VK_FMT_ETC2_R8G8B8_UNORM                               = 0x00000070,
+    VK_FMT_ETC2_R8G8B8_SRGB                                = 0x00000071,
+    VK_FMT_ETC2_R8G8B8A1_UNORM                             = 0x00000072,
+    VK_FMT_ETC2_R8G8B8A1_SRGB                              = 0x00000073,
+    VK_FMT_ETC2_R8G8B8A8_UNORM                             = 0x00000074,
+    VK_FMT_ETC2_R8G8B8A8_SRGB                              = 0x00000075,
+    VK_FMT_EAC_R11_UNORM                                   = 0x00000076,
+    VK_FMT_EAC_R11_SNORM                                   = 0x00000077,
+    VK_FMT_EAC_R11G11_UNORM                                = 0x00000078,
+    VK_FMT_EAC_R11G11_SNORM                                = 0x00000079,
+    VK_FMT_ASTC_4x4_UNORM                                  = 0x0000007A,
+    VK_FMT_ASTC_4x4_SRGB                                   = 0x0000007B,
+    VK_FMT_ASTC_5x4_UNORM                                  = 0x0000007C,
+    VK_FMT_ASTC_5x4_SRGB                                   = 0x0000007D,
+    VK_FMT_ASTC_5x5_UNORM                                  = 0x0000007E,
+    VK_FMT_ASTC_5x5_SRGB                                   = 0x0000007F,
+    VK_FMT_ASTC_6x5_UNORM                                  = 0x00000080,
+    VK_FMT_ASTC_6x5_SRGB                                   = 0x00000081,
+    VK_FMT_ASTC_6x6_UNORM                                  = 0x00000082,
+    VK_FMT_ASTC_6x6_SRGB                                   = 0x00000083,
+    VK_FMT_ASTC_8x5_UNORM                                  = 0x00000084,
+    VK_FMT_ASTC_8x5_SRGB                                   = 0x00000085,
+    VK_FMT_ASTC_8x6_UNORM                                  = 0x00000086,
+    VK_FMT_ASTC_8x6_SRGB                                   = 0x00000087,
+    VK_FMT_ASTC_8x8_UNORM                                  = 0x00000088,
+    VK_FMT_ASTC_8x8_SRGB                                   = 0x00000089,
+    VK_FMT_ASTC_10x5_UNORM                                 = 0x0000008A,
+    VK_FMT_ASTC_10x5_SRGB                                  = 0x0000008B,
+    VK_FMT_ASTC_10x6_UNORM                                 = 0x0000008C,
+    VK_FMT_ASTC_10x6_SRGB                                  = 0x0000008D,
+    VK_FMT_ASTC_10x8_UNORM                                 = 0x0000008E,
+    VK_FMT_ASTC_10x8_SRGB                                  = 0x0000008F,
+    VK_FMT_ASTC_10x10_UNORM                                = 0x00000090,
+    VK_FMT_ASTC_10x10_SRGB                                 = 0x00000091,
+    VK_FMT_ASTC_12x10_UNORM                                = 0x00000092,
+    VK_FMT_ASTC_12x10_SRGB                                 = 0x00000093,
+    VK_FMT_ASTC_12x12_UNORM                                = 0x00000094,
+    VK_FMT_ASTC_12x12_SRGB                                 = 0x00000095,
+    VK_FMT_B4G4R4A4_UNORM                                  = 0x00000096,
+    VK_FMT_B5G5R5A1_UNORM                                  = 0x00000097,
+    VK_FMT_B5G6R5_UNORM                                    = 0x00000098,
+    VK_FMT_B5G6R5_USCALED                                  = 0x00000099,
+    VK_FMT_B8G8R8_UNORM                                    = 0x0000009A,
+    VK_FMT_B8G8R8_SNORM                                    = 0x0000009B,
+    VK_FMT_B8G8R8_USCALED                                  = 0x0000009C,
+    VK_FMT_B8G8R8_SSCALED                                  = 0x0000009D,
+    VK_FMT_B8G8R8_UINT                                     = 0x0000009E,
+    VK_FMT_B8G8R8_SINT                                     = 0x0000009F,
+    VK_FMT_B8G8R8_SRGB                                     = 0x000000A0,
+    VK_FMT_B8G8R8A8_UNORM                                  = 0x000000A1,
+    VK_FMT_B8G8R8A8_SNORM                                  = 0x000000A2,
+    VK_FMT_B8G8R8A8_USCALED                                = 0x000000A3,
+    VK_FMT_B8G8R8A8_SSCALED                                = 0x000000A4,
+    VK_FMT_B8G8R8A8_UINT                                   = 0x000000A5,
+    VK_FMT_B8G8R8A8_SINT                                   = 0x000000A6,
+    VK_FMT_B8G8R8A8_SRGB                                   = 0x000000A7,
+    VK_FMT_B10G10R10A2_UNORM                               = 0x000000A8,
+    VK_FMT_B10G10R10A2_SNORM                               = 0x000000A9,
+    VK_FMT_B10G10R10A2_USCALED                             = 0x000000AA,
+    VK_FMT_B10G10R10A2_SSCALED                             = 0x000000AB,
+    VK_FMT_B10G10R10A2_UINT                                = 0x000000AC,
+    VK_FMT_B10G10R10A2_SINT                                = 0x000000AD,
 
-    XGL_FMT_BEGIN_RANGE                                     = XGL_FMT_UNDEFINED,
-    XGL_FMT_END_RANGE                                       = XGL_FMT_B10G10R10A2_SINT,
-    XGL_NUM_FMT                                             = (XGL_FMT_END_RANGE - XGL_FMT_BEGIN_RANGE + 1),
-    XGL_MAX_ENUM(_XGL_FORMAT)
-} XGL_FORMAT;
+    VK_FMT_BEGIN_RANGE                                     = VK_FMT_UNDEFINED,
+    VK_FMT_END_RANGE                                       = VK_FMT_B10G10R10A2_SINT,
+    VK_NUM_FMT                                             = (VK_FMT_END_RANGE - VK_FMT_BEGIN_RANGE + 1),
+    VK_MAX_ENUM(_VK_FORMAT)
+} VK_FORMAT;
 
 // Shader stage enumerant
-typedef enum _XGL_PIPELINE_SHADER_STAGE
+typedef enum _VK_PIPELINE_SHADER_STAGE
 {
-    XGL_SHADER_STAGE_VERTEX                                 = 0,
-    XGL_SHADER_STAGE_TESS_CONTROL                           = 1,
-    XGL_SHADER_STAGE_TESS_EVALUATION                        = 2,
-    XGL_SHADER_STAGE_GEOMETRY                               = 3,
-    XGL_SHADER_STAGE_FRAGMENT                               = 4,
-    XGL_SHADER_STAGE_COMPUTE                                = 5,
+    VK_SHADER_STAGE_VERTEX                                 = 0,
+    VK_SHADER_STAGE_TESS_CONTROL                           = 1,
+    VK_SHADER_STAGE_TESS_EVALUATION                        = 2,
+    VK_SHADER_STAGE_GEOMETRY                               = 3,
+    VK_SHADER_STAGE_FRAGMENT                               = 4,
+    VK_SHADER_STAGE_COMPUTE                                = 5,
 
-    XGL_SHADER_STAGE_BEGIN_RANGE                            = XGL_SHADER_STAGE_VERTEX,
-    XGL_SHADER_STAGE_END_RANGE                              = XGL_SHADER_STAGE_COMPUTE,
-    XGL_NUM_SHADER_STAGE                                    = (XGL_SHADER_STAGE_END_RANGE - XGL_SHADER_STAGE_BEGIN_RANGE + 1),
-    XGL_MAX_ENUM(_XGL_PIPELINE_SHADER_STAGE)
-} XGL_PIPELINE_SHADER_STAGE;
+    VK_SHADER_STAGE_BEGIN_RANGE                            = VK_SHADER_STAGE_VERTEX,
+    VK_SHADER_STAGE_END_RANGE                              = VK_SHADER_STAGE_COMPUTE,
+    VK_NUM_SHADER_STAGE                                    = (VK_SHADER_STAGE_END_RANGE - VK_SHADER_STAGE_BEGIN_RANGE + 1),
+    VK_MAX_ENUM(_VK_PIPELINE_SHADER_STAGE)
+} VK_PIPELINE_SHADER_STAGE;
 
-typedef enum _XGL_SHADER_STAGE_FLAGS
+typedef enum _VK_SHADER_STAGE_FLAGS
 {
-    XGL_SHADER_STAGE_FLAGS_VERTEX_BIT                        = 0x00000001,
-    XGL_SHADER_STAGE_FLAGS_TESS_CONTROL_BIT                  = 0x00000002,
-    XGL_SHADER_STAGE_FLAGS_TESS_EVALUATION_BIT               = 0x00000004,
-    XGL_SHADER_STAGE_FLAGS_GEOMETRY_BIT                      = 0x00000008,
-    XGL_SHADER_STAGE_FLAGS_FRAGMENT_BIT                      = 0x00000010,
-    XGL_SHADER_STAGE_FLAGS_COMPUTE_BIT                       = 0x00000020,
+    VK_SHADER_STAGE_FLAGS_VERTEX_BIT                        = 0x00000001,
+    VK_SHADER_STAGE_FLAGS_TESS_CONTROL_BIT                  = 0x00000002,
+    VK_SHADER_STAGE_FLAGS_TESS_EVALUATION_BIT               = 0x00000004,
+    VK_SHADER_STAGE_FLAGS_GEOMETRY_BIT                      = 0x00000008,
+    VK_SHADER_STAGE_FLAGS_FRAGMENT_BIT                      = 0x00000010,
+    VK_SHADER_STAGE_FLAGS_COMPUTE_BIT                       = 0x00000020,
 
-    XGL_SHADER_STAGE_FLAGS_ALL                               = 0x7FFFFFFF,
-    XGL_MAX_ENUM(_XGL_SHADER_STAGE_FLAGS)
-} XGL_SHADER_STAGE_FLAGS;
+    VK_SHADER_STAGE_FLAGS_ALL                               = 0x7FFFFFFF,
+    VK_MAX_ENUM(_VK_SHADER_STAGE_FLAGS)
+} VK_SHADER_STAGE_FLAGS;
 
 // Structure type enumerant
-typedef enum _XGL_STRUCTURE_TYPE
+typedef enum _VK_STRUCTURE_TYPE
 {
-    XGL_STRUCTURE_TYPE_APPLICATION_INFO                     = 0,
-    XGL_STRUCTURE_TYPE_DEVICE_CREATE_INFO                   = 1,
-    XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO                    = 2,
-    XGL_STRUCTURE_TYPE_MEMORY_OPEN_INFO                     = 4,
-    XGL_STRUCTURE_TYPE_PEER_MEMORY_OPEN_INFO                = 5,
-    XGL_STRUCTURE_TYPE_BUFFER_VIEW_ATTACH_INFO              = 6,
-    XGL_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO               = 7,
-    XGL_STRUCTURE_TYPE_EVENT_WAIT_INFO                      = 8,
-    XGL_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO               = 9,
-    XGL_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO    = 10,
-    XGL_STRUCTURE_TYPE_DEPTH_STENCIL_VIEW_CREATE_INFO       = 11,
-    XGL_STRUCTURE_TYPE_SHADER_CREATE_INFO                   = 12,
-    XGL_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO         = 13,
-    XGL_STRUCTURE_TYPE_SAMPLER_CREATE_INFO                  = 14,
-    XGL_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO    = 15,
-    XGL_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO         = 16,
-    XGL_STRUCTURE_TYPE_DYNAMIC_RS_STATE_CREATE_INFO         = 17,
-    XGL_STRUCTURE_TYPE_DYNAMIC_CB_STATE_CREATE_INFO         = 18,
-    XGL_STRUCTURE_TYPE_DYNAMIC_DS_STATE_CREATE_INFO         = 19,
-    XGL_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO               = 20,
-    XGL_STRUCTURE_TYPE_EVENT_CREATE_INFO                    = 21,
-    XGL_STRUCTURE_TYPE_FENCE_CREATE_INFO                    = 22,
-    XGL_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO                = 23,
-    XGL_STRUCTURE_TYPE_SEMAPHORE_OPEN_INFO                  = 24,
-    XGL_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO               = 25,
-    XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO    = 26,
-    XGL_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO        = 27,
-    XGL_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO    = 28,
-    XGL_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO        = 29,
-    XGL_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO      = 30,
-    XGL_STRUCTURE_TYPE_PIPELINE_VP_STATE_CREATE_INFO        = 31,
-    XGL_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO        = 32,
-    XGL_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO        = 33,
-    XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO        = 34,
-    XGL_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO        = 35,
-    XGL_STRUCTURE_TYPE_IMAGE_CREATE_INFO                    = 36,
-    XGL_STRUCTURE_TYPE_BUFFER_CREATE_INFO                   = 37,
-    XGL_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO              = 38,
-    XGL_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO              = 39,
-    XGL_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO                = 40,
-    XGL_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO       = 41,
-    XGL_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO              = 42,
-    XGL_STRUCTURE_TYPE_LAYER_CREATE_INFO                    = 43,
-    XGL_STRUCTURE_TYPE_PIPELINE_BARRIER                     = 44,
-    XGL_STRUCTURE_TYPE_MEMORY_BARRIER                       = 45,
-    XGL_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER                = 46,
-    XGL_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER                 = 47,
-    XGL_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO          = 48,
-    XGL_STRUCTURE_TYPE_UPDATE_SAMPLERS                      = 49,
-    XGL_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES              = 50,
-    XGL_STRUCTURE_TYPE_UPDATE_IMAGES                        = 51,
-    XGL_STRUCTURE_TYPE_UPDATE_BUFFERS                       = 52,
-    XGL_STRUCTURE_TYPE_UPDATE_AS_COPY                       = 53,
-    XGL_STRUCTURE_TYPE_MEMORY_ALLOC_BUFFER_INFO             = 54,
-    XGL_STRUCTURE_TYPE_MEMORY_ALLOC_IMAGE_INFO              = 55,
-    XGL_STRUCTURE_TYPE_INSTANCE_CREATE_INFO                 = 56,
-    XGL_STRUCTURE_TYPE_BEGIN_RANGE                          = XGL_STRUCTURE_TYPE_APPLICATION_INFO,
-    XGL_STRUCTURE_TYPE_END_RANGE                            = XGL_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
-    XGL_NUM_STRUCTURE_TYPE                                  = (XGL_STRUCTURE_TYPE_END_RANGE - XGL_STRUCTURE_TYPE_BEGIN_RANGE + 1),
-    XGL_MAX_ENUM(_XGL_STRUCTURE_TYPE)
-} XGL_STRUCTURE_TYPE;
+    VK_STRUCTURE_TYPE_APPLICATION_INFO                     = 0,
+    VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO                   = 1,
+    VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO                    = 2,
+    VK_STRUCTURE_TYPE_MEMORY_OPEN_INFO                     = 4,
+    VK_STRUCTURE_TYPE_PEER_MEMORY_OPEN_INFO                = 5,
+    VK_STRUCTURE_TYPE_BUFFER_VIEW_ATTACH_INFO              = 6,
+    VK_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO               = 7,
+    VK_STRUCTURE_TYPE_EVENT_WAIT_INFO                      = 8,
+    VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO               = 9,
+    VK_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO    = 10,
+    VK_STRUCTURE_TYPE_DEPTH_STENCIL_VIEW_CREATE_INFO       = 11,
+    VK_STRUCTURE_TYPE_SHADER_CREATE_INFO                   = 12,
+    VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO         = 13,
+    VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO                  = 14,
+    VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO    = 15,
+    VK_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO         = 16,
+    VK_STRUCTURE_TYPE_DYNAMIC_RS_STATE_CREATE_INFO         = 17,
+    VK_STRUCTURE_TYPE_DYNAMIC_CB_STATE_CREATE_INFO         = 18,
+    VK_STRUCTURE_TYPE_DYNAMIC_DS_STATE_CREATE_INFO         = 19,
+    VK_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO               = 20,
+    VK_STRUCTURE_TYPE_EVENT_CREATE_INFO                    = 21,
+    VK_STRUCTURE_TYPE_FENCE_CREATE_INFO                    = 22,
+    VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO                = 23,
+    VK_STRUCTURE_TYPE_SEMAPHORE_OPEN_INFO                  = 24,
+    VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO               = 25,
+    VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO    = 26,
+    VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO        = 27,
+    VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO    = 28,
+    VK_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO        = 29,
+    VK_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO      = 30,
+    VK_STRUCTURE_TYPE_PIPELINE_VP_STATE_CREATE_INFO        = 31,
+    VK_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO        = 32,
+    VK_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO        = 33,
+    VK_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO        = 34,
+    VK_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO        = 35,
+    VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO                    = 36,
+    VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO                   = 37,
+    VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO              = 38,
+    VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO              = 39,
+    VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO                = 40,
+    VK_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO       = 41,
+    VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO              = 42,
+    VK_STRUCTURE_TYPE_LAYER_CREATE_INFO                    = 43,
+    VK_STRUCTURE_TYPE_PIPELINE_BARRIER                     = 44,
+    VK_STRUCTURE_TYPE_MEMORY_BARRIER                       = 45,
+    VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER                = 46,
+    VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER                 = 47,
+    VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO          = 48,
+    VK_STRUCTURE_TYPE_UPDATE_SAMPLERS                      = 49,
+    VK_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES              = 50,
+    VK_STRUCTURE_TYPE_UPDATE_IMAGES                        = 51,
+    VK_STRUCTURE_TYPE_UPDATE_BUFFERS                       = 52,
+    VK_STRUCTURE_TYPE_UPDATE_AS_COPY                       = 53,
+    VK_STRUCTURE_TYPE_MEMORY_ALLOC_BUFFER_INFO             = 54,
+    VK_STRUCTURE_TYPE_MEMORY_ALLOC_IMAGE_INFO              = 55,
+    VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO                 = 56,
+    VK_STRUCTURE_TYPE_BEGIN_RANGE                          = VK_STRUCTURE_TYPE_APPLICATION_INFO,
+    VK_STRUCTURE_TYPE_END_RANGE                            = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
+    VK_NUM_STRUCTURE_TYPE                                  = (VK_STRUCTURE_TYPE_END_RANGE - VK_STRUCTURE_TYPE_BEGIN_RANGE + 1),
+    VK_MAX_ENUM(_VK_STRUCTURE_TYPE)
+} VK_STRUCTURE_TYPE;
 
 // ------------------------------------------------------------------------------------------------
 // Flags
 
 // Device creation flags
-typedef enum _XGL_DEVICE_CREATE_FLAGS
+typedef enum _VK_DEVICE_CREATE_FLAGS
 {
-    XGL_DEVICE_CREATE_VALIDATION_BIT                        = 0x00000001,
-    XGL_DEVICE_CREATE_MGPU_IQ_MATCH_BIT                     = 0x00000002,
-    XGL_MAX_ENUM(_XGL_DEVICE_CREATE_FLAGS)
-} XGL_DEVICE_CREATE_FLAGS;
+    VK_DEVICE_CREATE_VALIDATION_BIT                        = 0x00000001,
+    VK_DEVICE_CREATE_MGPU_IQ_MATCH_BIT                     = 0x00000002,
+    VK_MAX_ENUM(_VK_DEVICE_CREATE_FLAGS)
+} VK_DEVICE_CREATE_FLAGS;
 
 // Queue capabilities
-typedef enum _XGL_QUEUE_FLAGS
+typedef enum _VK_QUEUE_FLAGS
 {
-    XGL_QUEUE_GRAPHICS_BIT                                  = 0x00000001,   // Queue supports graphics operations
-    XGL_QUEUE_COMPUTE_BIT                                   = 0x00000002,   // Queue supports compute operations
-    XGL_QUEUE_DMA_BIT                                       = 0x00000004,   // Queue supports DMA operations
-    XGL_QUEUE_EXTENDED_BIT                                  = 0x40000000,   // Extended queue
-    XGL_MAX_ENUM(_XGL_QUEUE_FLAGS)
-} XGL_QUEUE_FLAGS;
+    VK_QUEUE_GRAPHICS_BIT                                  = 0x00000001,   // Queue supports graphics operations
+    VK_QUEUE_COMPUTE_BIT                                   = 0x00000002,   // Queue supports compute operations
+    VK_QUEUE_DMA_BIT                                       = 0x00000004,   // Queue supports DMA operations
+    VK_QUEUE_EXTENDED_BIT                                  = 0x40000000,   // Extended queue
+    VK_MAX_ENUM(_VK_QUEUE_FLAGS)
+} VK_QUEUE_FLAGS;
 
-// memory properties passed into xglAllocMemory().
-typedef enum _XGL_MEMORY_PROPERTY_FLAGS
+// memory properties passed into vkAllocMemory().
+typedef enum _VK_MEMORY_PROPERTY_FLAGS
 {
-    XGL_MEMORY_PROPERTY_GPU_ONLY                            = 0x00000000,   // If not set, then allocate memory on device (GPU)
-    XGL_MEMORY_PROPERTY_CPU_VISIBLE_BIT                     = 0x00000001,
-    XGL_MEMORY_PROPERTY_CPU_GPU_COHERENT_BIT                = 0x00000002,
-    XGL_MEMORY_PROPERTY_CPU_UNCACHED_BIT                    = 0x00000004,
-    XGL_MEMORY_PROPERTY_CPU_WRITE_COMBINED_BIT              = 0x00000008,
-    XGL_MEMORY_PROPERTY_PREFER_CPU_LOCAL                    = 0x00000010,   // all else being equal, prefer CPU access
-    XGL_MEMORY_PROPERTY_SHAREABLE_BIT                       = 0x00000020,
-    XGL_MAX_ENUM(_XGL_MEMORY_PROPERTY_FLAGS)
-} XGL_MEMORY_PROPERTY_FLAGS;
+    VK_MEMORY_PROPERTY_GPU_ONLY                            = 0x00000000,   // If not set, then allocate memory on device (GPU)
+    VK_MEMORY_PROPERTY_CPU_VISIBLE_BIT                     = 0x00000001,
+    VK_MEMORY_PROPERTY_CPU_GPU_COHERENT_BIT                = 0x00000002,
+    VK_MEMORY_PROPERTY_CPU_UNCACHED_BIT                    = 0x00000004,
+    VK_MEMORY_PROPERTY_CPU_WRITE_COMBINED_BIT              = 0x00000008,
+    VK_MEMORY_PROPERTY_PREFER_CPU_LOCAL                    = 0x00000010,   // all else being equal, prefer CPU access
+    VK_MEMORY_PROPERTY_SHAREABLE_BIT                       = 0x00000020,
+    VK_MAX_ENUM(_VK_MEMORY_PROPERTY_FLAGS)
+} VK_MEMORY_PROPERTY_FLAGS;
 
-typedef enum _XGL_MEMORY_TYPE
+typedef enum _VK_MEMORY_TYPE
 {
-    XGL_MEMORY_TYPE_OTHER                                   = 0x00000000,   // device memory that is not any of the others
-    XGL_MEMORY_TYPE_BUFFER                                  = 0x00000001,   // memory for buffers and associated information
-    XGL_MEMORY_TYPE_IMAGE                                   = 0x00000002,   // memory for images and associated information
+    VK_MEMORY_TYPE_OTHER                                   = 0x00000000,   // device memory that is not any of the others
+    VK_MEMORY_TYPE_BUFFER                                  = 0x00000001,   // memory for buffers and associated information
+    VK_MEMORY_TYPE_IMAGE                                   = 0x00000002,   // memory for images and associated information
 
-    XGL_MEMORY_TYPE_BEGIN_RANGE                             = XGL_MEMORY_TYPE_OTHER,
-    XGL_MEMORY_TYPE_END_RANGE                               = XGL_MEMORY_TYPE_IMAGE,
-    XGL_NUM_MEMORY_TYPE                                     = (XGL_MEMORY_TYPE_END_RANGE - XGL_MEMORY_TYPE_BEGIN_RANGE + 1),
-    XGL_MAX_ENUM(_XGL_MEMORY_TYPE)
-} XGL_MEMORY_TYPE;
+    VK_MEMORY_TYPE_BEGIN_RANGE                             = VK_MEMORY_TYPE_OTHER,
+    VK_MEMORY_TYPE_END_RANGE                               = VK_MEMORY_TYPE_IMAGE,
+    VK_NUM_MEMORY_TYPE                                     = (VK_MEMORY_TYPE_END_RANGE - VK_MEMORY_TYPE_BEGIN_RANGE + 1),
+    VK_MAX_ENUM(_VK_MEMORY_TYPE)
+} VK_MEMORY_TYPE;
 
 // Buffer and buffer allocation usage flags
-typedef enum _XGL_BUFFER_USAGE_FLAGS
+typedef enum _VK_BUFFER_USAGE_FLAGS
 {
-    XGL_BUFFER_USAGE_GENERAL                                = 0x00000000,   // no special usage
-    XGL_BUFFER_USAGE_SHADER_ACCESS_READ_BIT                 = 0x00000001,   // Shader read (e.g. TBO, image buffer, UBO, SSBO)
-    XGL_BUFFER_USAGE_SHADER_ACCESS_WRITE_BIT                = 0x00000002,   // Shader write (e.g. image buffer, SSBO)
-    XGL_BUFFER_USAGE_SHADER_ACCESS_ATOMIC_BIT               = 0x00000004,   // Shader atomic operations (e.g. image buffer, SSBO)
-    XGL_BUFFER_USAGE_TRANSFER_SOURCE_BIT                    = 0x00000008,   // used as a source for copies
-    XGL_BUFFER_USAGE_TRANSFER_DESTINATION_BIT               = 0x00000010,   // used as a destination for copies
-    XGL_BUFFER_USAGE_UNIFORM_READ_BIT                       = 0x00000020,   // Uniform read (UBO)
-    XGL_BUFFER_USAGE_INDEX_FETCH_BIT                        = 0x00000040,   // Fixed function index fetch (index buffer)
-    XGL_BUFFER_USAGE_VERTEX_FETCH_BIT                       = 0x00000080,   // Fixed function vertex fetch (VBO)
-    XGL_BUFFER_USAGE_SHADER_STORAGE_BIT                     = 0x00000100,   // Shader storage buffer (SSBO)
-    XGL_BUFFER_USAGE_INDIRECT_PARAMETER_FETCH_BIT           = 0x00000200,   // Can be the source of indirect parameters (e.g. indirect buffer, parameter buffer)
-    XGL_BUFFER_USAGE_TEXTURE_BUFFER_BIT                     = 0x00000400,   // texture buffer (TBO)
-    XGL_BUFFER_USAGE_IMAGE_BUFFER_BIT                       = 0x00000800,   // image buffer (load/store)
-    XGL_MAX_ENUM(_XGL_BUFFER_USAGE_FLAGS)
-} XGL_BUFFER_USAGE_FLAGS;
+    VK_BUFFER_USAGE_GENERAL                                = 0x00000000,   // no special usage
+    VK_BUFFER_USAGE_SHADER_ACCESS_READ_BIT                 = 0x00000001,   // Shader read (e.g. TBO, image buffer, UBO, SSBO)
+    VK_BUFFER_USAGE_SHADER_ACCESS_WRITE_BIT                = 0x00000002,   // Shader write (e.g. image buffer, SSBO)
+    VK_BUFFER_USAGE_SHADER_ACCESS_ATOMIC_BIT               = 0x00000004,   // Shader atomic operations (e.g. image buffer, SSBO)
+    VK_BUFFER_USAGE_TRANSFER_SOURCE_BIT                    = 0x00000008,   // used as a source for copies
+    VK_BUFFER_USAGE_TRANSFER_DESTINATION_BIT               = 0x00000010,   // used as a destination for copies
+    VK_BUFFER_USAGE_UNIFORM_READ_BIT                       = 0x00000020,   // Uniform read (UBO)
+    VK_BUFFER_USAGE_INDEX_FETCH_BIT                        = 0x00000040,   // Fixed function index fetch (index buffer)
+    VK_BUFFER_USAGE_VERTEX_FETCH_BIT                       = 0x00000080,   // Fixed function vertex fetch (VBO)
+    VK_BUFFER_USAGE_SHADER_STORAGE_BIT                     = 0x00000100,   // Shader storage buffer (SSBO)
+    VK_BUFFER_USAGE_INDIRECT_PARAMETER_FETCH_BIT           = 0x00000200,   // Can be the source of indirect parameters (e.g. indirect buffer, parameter buffer)
+    VK_BUFFER_USAGE_TEXTURE_BUFFER_BIT                     = 0x00000400,   // texture buffer (TBO)
+    VK_BUFFER_USAGE_IMAGE_BUFFER_BIT                       = 0x00000800,   // image buffer (load/store)
+    VK_MAX_ENUM(_VK_BUFFER_USAGE_FLAGS)
+} VK_BUFFER_USAGE_FLAGS;
 
 // Buffer flags
-typedef enum _XGL_BUFFER_CREATE_FLAGS
+typedef enum _VK_BUFFER_CREATE_FLAGS
 {
-    XGL_BUFFER_CREATE_SHAREABLE_BIT                         = 0x00000001,
-    XGL_BUFFER_CREATE_SPARSE_BIT                            = 0x00000002,
-    XGL_MAX_ENUM(_XGL_BUFFER_CREATE_FLAGS)
-} XGL_BUFFER_CREATE_FLAGS;
+    VK_BUFFER_CREATE_SHAREABLE_BIT                         = 0x00000001,
+    VK_BUFFER_CREATE_SPARSE_BIT                            = 0x00000002,
+    VK_MAX_ENUM(_VK_BUFFER_CREATE_FLAGS)
+} VK_BUFFER_CREATE_FLAGS;
 
-typedef enum _XGL_BUFFER_VIEW_TYPE
+typedef enum _VK_BUFFER_VIEW_TYPE
 {
-    XGL_BUFFER_VIEW_RAW                                     = 0x00000000,   // Raw buffer without special structure (e.g. UBO, SSBO, indirect and parameter buffers)
-    XGL_BUFFER_VIEW_TYPED                                   = 0x00000001,   // Typed buffer, format and channels are used (TBO, image buffer)
+    VK_BUFFER_VIEW_RAW                                     = 0x00000000,   // Raw buffer without special structure (e.g. UBO, SSBO, indirect and parameter buffers)
+    VK_BUFFER_VIEW_TYPED                                   = 0x00000001,   // Typed buffer, format and channels are used (TBO, image buffer)
 
-    XGL_BUFFER_VIEW_TYPE_BEGIN_RANGE                        = XGL_BUFFER_VIEW_RAW,
-    XGL_BUFFER_VIEW_TYPE_END_RANGE                          = XGL_BUFFER_VIEW_TYPED,
-    XGL_NUM_BUFFER_VIEW_TYPE                                = (XGL_BUFFER_VIEW_TYPE_END_RANGE - XGL_BUFFER_VIEW_TYPE_BEGIN_RANGE + 1),
-    XGL_MAX_ENUM(_XGL_BUFFER_VIEW_TYPE)
-} XGL_BUFFER_VIEW_TYPE;
+    VK_BUFFER_VIEW_TYPE_BEGIN_RANGE                        = VK_BUFFER_VIEW_RAW,
+    VK_BUFFER_VIEW_TYPE_END_RANGE                          = VK_BUFFER_VIEW_TYPED,
+    VK_NUM_BUFFER_VIEW_TYPE                                = (VK_BUFFER_VIEW_TYPE_END_RANGE - VK_BUFFER_VIEW_TYPE_BEGIN_RANGE + 1),
+    VK_MAX_ENUM(_VK_BUFFER_VIEW_TYPE)
+} VK_BUFFER_VIEW_TYPE;
 
 
 // Images memory allocations can be used for resources of a given format class.
-typedef enum _XGL_IMAGE_FORMAT_CLASS
+typedef enum _VK_IMAGE_FORMAT_CLASS
 {
-    XGL_IMAGE_FORMAT_CLASS_128_BITS                         = 1,  // color formats
-    XGL_IMAGE_FORMAT_CLASS_96_BITS                          = 2,
-    XGL_IMAGE_FORMAT_CLASS_64_BITS                          = 3,
-    XGL_IMAGE_FORMAT_CLASS_48_BITS                          = 4,
-    XGL_IMAGE_FORMAT_CLASS_32_BITS                          = 5,
-    XGL_IMAGE_FORMAT_CLASS_24_BITS                          = 6,
-    XGL_IMAGE_FORMAT_CLASS_16_BITS                          = 7,
-    XGL_IMAGE_FORMAT_CLASS_8_BITS                           = 8,
-    XGL_IMAGE_FORMAT_CLASS_128_BIT_BLOCK                    = 9,  // 128-bit block compressed formats
-    XGL_IMAGE_FORMAT_CLASS_64_BIT_BLOCK                     = 10, // 64-bit block compressed formats
-    XGL_IMAGE_FORMAT_CLASS_D32                              = 11, // D32_SFLOAT
-    XGL_IMAGE_FORMAT_CLASS_D24                              = 12, // D24_UNORM
-    XGL_IMAGE_FORMAT_CLASS_D16                              = 13, // D16_UNORM
-    XGL_IMAGE_FORMAT_CLASS_S8                               = 14, // S8_UINT
-    XGL_IMAGE_FORMAT_CLASS_D32S8                            = 15, // D32_SFLOAT_S8_UINT
-    XGL_IMAGE_FORMAT_CLASS_D24S8                            = 16, // D24_UNORM_S8_UINT
-    XGL_IMAGE_FORMAT_CLASS_D16S8                            = 17, // D16_UNORM_S8_UINT
-    XGL_IMAGE_FORMAT_CLASS_LINEAR                           = 18, // used for pitch-linear (transparent) textures
+    VK_IMAGE_FORMAT_CLASS_128_BITS                         = 1,  // color formats
+    VK_IMAGE_FORMAT_CLASS_96_BITS                          = 2,
+    VK_IMAGE_FORMAT_CLASS_64_BITS                          = 3,
+    VK_IMAGE_FORMAT_CLASS_48_BITS                          = 4,
+    VK_IMAGE_FORMAT_CLASS_32_BITS                          = 5,
+    VK_IMAGE_FORMAT_CLASS_24_BITS                          = 6,
+    VK_IMAGE_FORMAT_CLASS_16_BITS                          = 7,
+    VK_IMAGE_FORMAT_CLASS_8_BITS                           = 8,
+    VK_IMAGE_FORMAT_CLASS_128_BIT_BLOCK                    = 9,  // 128-bit block compressed formats
+    VK_IMAGE_FORMAT_CLASS_64_BIT_BLOCK                     = 10, // 64-bit block compressed formats
+    VK_IMAGE_FORMAT_CLASS_D32                              = 11, // D32_SFLOAT
+    VK_IMAGE_FORMAT_CLASS_D24                              = 12, // D24_UNORM
+    VK_IMAGE_FORMAT_CLASS_D16                              = 13, // D16_UNORM
+    VK_IMAGE_FORMAT_CLASS_S8                               = 14, // S8_UINT
+    VK_IMAGE_FORMAT_CLASS_D32S8                            = 15, // D32_SFLOAT_S8_UINT
+    VK_IMAGE_FORMAT_CLASS_D24S8                            = 16, // D24_UNORM_S8_UINT
+    VK_IMAGE_FORMAT_CLASS_D16S8                            = 17, // D16_UNORM_S8_UINT
+    VK_IMAGE_FORMAT_CLASS_LINEAR                           = 18, // used for pitch-linear (transparent) textures
 
-    XGL_IMAGE_FORMAT_CLASS_BEGIN_RANGE                      = XGL_IMAGE_FORMAT_CLASS_128_BITS,
-    XGL_IMAGE_FORMAT_CLASS_END_RANGE                        = XGL_IMAGE_FORMAT_CLASS_LINEAR,
-    XGL_NUM_IMAGE_FORMAT_CLASS                              = (XGL_IMAGE_FORMAT_CLASS_END_RANGE - XGL_IMAGE_FORMAT_CLASS_BEGIN_RANGE + 1),
-    XGL_MAX_ENUM(_XGL_IMAGE_FORMAT_CLASS)
-} XGL_IMAGE_FORMAT_CLASS;
+    VK_IMAGE_FORMAT_CLASS_BEGIN_RANGE                      = VK_IMAGE_FORMAT_CLASS_128_BITS,
+    VK_IMAGE_FORMAT_CLASS_END_RANGE                        = VK_IMAGE_FORMAT_CLASS_LINEAR,
+    VK_NUM_IMAGE_FORMAT_CLASS                              = (VK_IMAGE_FORMAT_CLASS_END_RANGE - VK_IMAGE_FORMAT_CLASS_BEGIN_RANGE + 1),
+    VK_MAX_ENUM(_VK_IMAGE_FORMAT_CLASS)
+} VK_IMAGE_FORMAT_CLASS;
 
 // Image and image allocation usage flags
-typedef enum _XGL_IMAGE_USAGE_FLAGS
+typedef enum _VK_IMAGE_USAGE_FLAGS
 {
-    XGL_IMAGE_USAGE_GENERAL                                 = 0x00000000,   // no special usage
-    XGL_IMAGE_USAGE_SHADER_ACCESS_READ_BIT                  = 0x00000001,   // shader read (e.g. texture, image)
-    XGL_IMAGE_USAGE_SHADER_ACCESS_WRITE_BIT                 = 0x00000002,   // shader write (e.g. image)
-    XGL_IMAGE_USAGE_SHADER_ACCESS_ATOMIC_BIT                = 0x00000004,   // shader atomic operations (e.g. image)
-    XGL_IMAGE_USAGE_TRANSFER_SOURCE_BIT                     = 0x00000008,   // used as a source for copies
-    XGL_IMAGE_USAGE_TRANSFER_DESTINATION_BIT                = 0x00000010,   // used as a destination for copies
-    XGL_IMAGE_USAGE_TEXTURE_BIT                             = 0x00000020,   // opaque texture (2d, 3d, etc.)
-    XGL_IMAGE_USAGE_IMAGE_BIT                               = 0x00000040,   // opaque image (2d, 3d, etc.)
-    XGL_IMAGE_USAGE_COLOR_ATTACHMENT_BIT                    = 0x00000080,   // framebuffer color attachment
-    XGL_IMAGE_USAGE_DEPTH_STENCIL_BIT                       = 0x00000100,   // framebuffer depth/stencil
-    XGL_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT                = 0x00000200,   // image data not needed outside of rendering.
-    XGL_MAX_ENUM(_XGL_IMAGE_USAGE_FLAGS)
-} XGL_IMAGE_USAGE_FLAGS;
+    VK_IMAGE_USAGE_GENERAL                                 = 0x00000000,   // no special usage
+    VK_IMAGE_USAGE_SHADER_ACCESS_READ_BIT                  = 0x00000001,   // shader read (e.g. texture, image)
+    VK_IMAGE_USAGE_SHADER_ACCESS_WRITE_BIT                 = 0x00000002,   // shader write (e.g. image)
+    VK_IMAGE_USAGE_SHADER_ACCESS_ATOMIC_BIT                = 0x00000004,   // shader atomic operations (e.g. image)
+    VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT                     = 0x00000008,   // used as a source for copies
+    VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT                = 0x00000010,   // used as a destination for copies
+    VK_IMAGE_USAGE_TEXTURE_BIT                             = 0x00000020,   // opaque texture (2d, 3d, etc.)
+    VK_IMAGE_USAGE_IMAGE_BIT                               = 0x00000040,   // opaque image (2d, 3d, etc.)
+    VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT                    = 0x00000080,   // framebuffer color attachment
+    VK_IMAGE_USAGE_DEPTH_STENCIL_BIT                       = 0x00000100,   // framebuffer depth/stencil
+    VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT                = 0x00000200,   // image data not needed outside of rendering.
+    VK_MAX_ENUM(_VK_IMAGE_USAGE_FLAGS)
+} VK_IMAGE_USAGE_FLAGS;
 
 // Image flags
-typedef enum _XGL_IMAGE_CREATE_FLAGS
+typedef enum _VK_IMAGE_CREATE_FLAGS
 {
-    XGL_IMAGE_CREATE_INVARIANT_DATA_BIT                     = 0x00000001,
-    XGL_IMAGE_CREATE_CLONEABLE_BIT                          = 0x00000002,
-    XGL_IMAGE_CREATE_SHAREABLE_BIT                          = 0x00000004,
-    XGL_IMAGE_CREATE_SPARSE_BIT                             = 0x00000008,
-    XGL_IMAGE_CREATE_MUTABLE_FORMAT_BIT                     = 0x00000010,   // Allows image views to have different format than the base image
-    XGL_MAX_ENUM(_XGL_IMAGE_CREATE_FLAGS)
-} XGL_IMAGE_CREATE_FLAGS;
+    VK_IMAGE_CREATE_INVARIANT_DATA_BIT                     = 0x00000001,
+    VK_IMAGE_CREATE_CLONEABLE_BIT                          = 0x00000002,
+    VK_IMAGE_CREATE_SHAREABLE_BIT                          = 0x00000004,
+    VK_IMAGE_CREATE_SPARSE_BIT                             = 0x00000008,
+    VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT                     = 0x00000010,   // Allows image views to have different format than the base image
+    VK_MAX_ENUM(_VK_IMAGE_CREATE_FLAGS)
+} VK_IMAGE_CREATE_FLAGS;
 
 // Depth-stencil view creation flags
-typedef enum _XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS
+typedef enum _VK_DEPTH_STENCIL_VIEW_CREATE_FLAGS
 {
-    XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_DEPTH_BIT       = 0x00000001,
-    XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_STENCIL_BIT     = 0x00000002,
-    XGL_MAX_ENUM(_XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS)
-} XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS;
+    VK_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_DEPTH_BIT       = 0x00000001,
+    VK_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_STENCIL_BIT     = 0x00000002,
+    VK_MAX_ENUM(_VK_DEPTH_STENCIL_VIEW_CREATE_FLAGS)
+} VK_DEPTH_STENCIL_VIEW_CREATE_FLAGS;
 
 // Pipeline creation flags
-typedef enum _XGL_PIPELINE_CREATE_FLAGS
+typedef enum _VK_PIPELINE_CREATE_FLAGS
 {
-    XGL_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT            = 0x00000001,
-    XGL_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT               = 0x00000002,
-    XGL_MAX_ENUM(_XGL_PIPELINE_CREATE_FLAGS)
-} XGL_PIPELINE_CREATE_FLAGS;
+    VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT            = 0x00000001,
+    VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT               = 0x00000002,
+    VK_MAX_ENUM(_VK_PIPELINE_CREATE_FLAGS)
+} VK_PIPELINE_CREATE_FLAGS;
 
 // Fence creation flags
-typedef enum _XGL_FENCE_CREATE_FLAGS
+typedef enum _VK_FENCE_CREATE_FLAGS
 {
-    XGL_FENCE_CREATE_SIGNALED_BIT                           = 0x00000001,
-    XGL_MAX_ENUM(_XGL_FENCE_CREATE_FLAGS)
-} XGL_FENCE_CREATE_FLAGS;
+    VK_FENCE_CREATE_SIGNALED_BIT                           = 0x00000001,
+    VK_MAX_ENUM(_VK_FENCE_CREATE_FLAGS)
+} VK_FENCE_CREATE_FLAGS;
 
 // Semaphore creation flags
-typedef enum _XGL_SEMAPHORE_CREATE_FLAGS
+typedef enum _VK_SEMAPHORE_CREATE_FLAGS
 {
-    XGL_SEMAPHORE_CREATE_SHAREABLE_BIT                      = 0x00000001,
-    XGL_MAX_ENUM(_XGL_SEMAPHORE_CREATE_FLAGS)
-} XGL_SEMAPHORE_CREATE_FLAGS;
+    VK_SEMAPHORE_CREATE_SHAREABLE_BIT                      = 0x00000001,
+    VK_MAX_ENUM(_VK_SEMAPHORE_CREATE_FLAGS)
+} VK_SEMAPHORE_CREATE_FLAGS;
 
 // Format capability flags
-typedef enum _XGL_FORMAT_FEATURE_FLAGS
+typedef enum _VK_FORMAT_FEATURE_FLAGS
 {
-    XGL_FORMAT_IMAGE_SHADER_READ_BIT                        = 0x00000001,
-    XGL_FORMAT_IMAGE_SHADER_WRITE_BIT                       = 0x00000002,
-    XGL_FORMAT_IMAGE_COPY_BIT                               = 0x00000004,
-    XGL_FORMAT_MEMORY_SHADER_ACCESS_BIT                     = 0x00000008,
-    XGL_FORMAT_COLOR_ATTACHMENT_WRITE_BIT                   = 0x00000010,
-    XGL_FORMAT_COLOR_ATTACHMENT_BLEND_BIT                   = 0x00000020,
-    XGL_FORMAT_DEPTH_ATTACHMENT_BIT                         = 0x00000040,
-    XGL_FORMAT_STENCIL_ATTACHMENT_BIT                       = 0x00000080,
-    XGL_FORMAT_MSAA_ATTACHMENT_BIT                          = 0x00000100,
-    XGL_FORMAT_CONVERSION_BIT                               = 0x00000200,
-    XGL_MAX_ENUM(_XGL_FORMAT_FEATURE_FLAGS)
-} XGL_FORMAT_FEATURE_FLAGS;
+    VK_FORMAT_IMAGE_SHADER_READ_BIT                        = 0x00000001,
+    VK_FORMAT_IMAGE_SHADER_WRITE_BIT                       = 0x00000002,
+    VK_FORMAT_IMAGE_COPY_BIT                               = 0x00000004,
+    VK_FORMAT_MEMORY_SHADER_ACCESS_BIT                     = 0x00000008,
+    VK_FORMAT_COLOR_ATTACHMENT_WRITE_BIT                   = 0x00000010,
+    VK_FORMAT_COLOR_ATTACHMENT_BLEND_BIT                   = 0x00000020,
+    VK_FORMAT_DEPTH_ATTACHMENT_BIT                         = 0x00000040,
+    VK_FORMAT_STENCIL_ATTACHMENT_BIT                       = 0x00000080,
+    VK_FORMAT_MSAA_ATTACHMENT_BIT                          = 0x00000100,
+    VK_FORMAT_CONVERSION_BIT                               = 0x00000200,
+    VK_MAX_ENUM(_VK_FORMAT_FEATURE_FLAGS)
+} VK_FORMAT_FEATURE_FLAGS;
 
 // Query flags
-typedef enum _XGL_QUERY_CONTROL_FLAGS
+typedef enum _VK_QUERY_CONTROL_FLAGS
 {
-    XGL_QUERY_IMPRECISE_DATA_BIT                            = 0x00000001,
-    XGL_MAX_ENUM(_XGL_QUERY_CONTROL_FLAGS)
-} XGL_QUERY_CONTROL_FLAGS;
+    VK_QUERY_IMPRECISE_DATA_BIT                            = 0x00000001,
+    VK_MAX_ENUM(_VK_QUERY_CONTROL_FLAGS)
+} VK_QUERY_CONTROL_FLAGS;
 
 // GPU compatibility flags
-typedef enum _XGL_GPU_COMPATIBILITY_FLAGS
+typedef enum _VK_GPU_COMPATIBILITY_FLAGS
 {
-    XGL_GPU_COMPAT_ASIC_FEATURES_BIT                        = 0x00000001,
-    XGL_GPU_COMPAT_IQ_MATCH_BIT                             = 0x00000002,
-    XGL_GPU_COMPAT_PEER_TRANSFER_BIT                        = 0x00000004,
-    XGL_GPU_COMPAT_SHARED_MEMORY_BIT                        = 0x00000008,
-    XGL_GPU_COMPAT_SHARED_SYNC_BIT                          = 0x00000010,
-    XGL_GPU_COMPAT_SHARED_GPU0_DISPLAY_BIT                  = 0x00000020,
-    XGL_GPU_COMPAT_SHARED_GPU1_DISPLAY_BIT                  = 0x00000040,
-    XGL_MAX_ENUM(_XGL_GPU_COMPATIBILITY_FLAGS)
-} XGL_GPU_COMPATIBILITY_FLAGS;
+    VK_GPU_COMPAT_ASIC_FEATURES_BIT                        = 0x00000001,
+    VK_GPU_COMPAT_IQ_MATCH_BIT                             = 0x00000002,
+    VK_GPU_COMPAT_PEER_TRANSFER_BIT                        = 0x00000004,
+    VK_GPU_COMPAT_SHARED_MEMORY_BIT                        = 0x00000008,
+    VK_GPU_COMPAT_SHARED_SYNC_BIT                          = 0x00000010,
+    VK_GPU_COMPAT_SHARED_GPU0_DISPLAY_BIT                  = 0x00000020,
+    VK_GPU_COMPAT_SHARED_GPU1_DISPLAY_BIT                  = 0x00000040,
+    VK_MAX_ENUM(_VK_GPU_COMPATIBILITY_FLAGS)
+} VK_GPU_COMPATIBILITY_FLAGS;
 
 // Command buffer building flags
-typedef enum _XGL_CMD_BUFFER_BUILD_FLAGS
+typedef enum _VK_CMD_BUFFER_BUILD_FLAGS
 {
-    XGL_CMD_BUFFER_OPTIMIZE_GPU_SMALL_BATCH_BIT             = 0x00000001,
-    XGL_CMD_BUFFER_OPTIMIZE_PIPELINE_SWITCH_BIT             = 0x00000002,
-    XGL_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT             = 0x00000004,
-    XGL_CMD_BUFFER_OPTIMIZE_DESCRIPTOR_SET_SWITCH_BIT       = 0x00000008,
-    XGL_MAX_ENUM(_XGL_CMD_BUFFER_BUILD_FLAGS)
-} XGL_CMD_BUFFER_BUILD_FLAGS;
+    VK_CMD_BUFFER_OPTIMIZE_GPU_SMALL_BATCH_BIT             = 0x00000001,
+    VK_CMD_BUFFER_OPTIMIZE_PIPELINE_SWITCH_BIT             = 0x00000002,
+    VK_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT             = 0x00000004,
+    VK_CMD_BUFFER_OPTIMIZE_DESCRIPTOR_SET_SWITCH_BIT       = 0x00000008,
+    VK_MAX_ENUM(_VK_CMD_BUFFER_BUILD_FLAGS)
+} VK_CMD_BUFFER_BUILD_FLAGS;
 
 // ------------------------------------------------------------------------------------------------
-// XGL structures
+// VK structures
 
-typedef struct _XGL_OFFSET2D
+typedef struct _VK_OFFSET2D
 {
     int32_t                                 x;
     int32_t                                 y;
-} XGL_OFFSET2D;
+} VK_OFFSET2D;
 
-typedef struct _XGL_OFFSET3D
+typedef struct _VK_OFFSET3D
 {
     int32_t                                 x;
     int32_t                                 y;
     int32_t                                 z;
-} XGL_OFFSET3D;
+} VK_OFFSET3D;
 
-typedef struct _XGL_EXTENT2D
+typedef struct _VK_EXTENT2D
 {
     int32_t                                 width;
     int32_t                                 height;
-} XGL_EXTENT2D;
+} VK_EXTENT2D;
 
-typedef struct _XGL_EXTENT3D
+typedef struct _VK_EXTENT3D
 {
     int32_t                                 width;
     int32_t                                 height;
     int32_t                                 depth;
-} XGL_EXTENT3D;
+} VK_EXTENT3D;
 
-typedef struct _XGL_VIEWPORT
+typedef struct _VK_VIEWPORT
 {
     float                                   originX;
     float                                   originY;
@@ -1318,31 +1318,31 @@
     float                                   height;
     float                                   minDepth;
     float                                   maxDepth;
-} XGL_VIEWPORT;
+} VK_VIEWPORT;
 
-typedef struct _XGL_RECT
+typedef struct _VK_RECT
 {
-    XGL_OFFSET2D                            offset;
-    XGL_EXTENT2D                            extent;
-} XGL_RECT;
+    VK_OFFSET2D                            offset;
+    VK_EXTENT2D                            extent;
+} VK_RECT;
 
-typedef struct _XGL_CHANNEL_MAPPING
+typedef struct _VK_CHANNEL_MAPPING
 {
-    XGL_CHANNEL_SWIZZLE                     r;
-    XGL_CHANNEL_SWIZZLE                     g;
-    XGL_CHANNEL_SWIZZLE                     b;
-    XGL_CHANNEL_SWIZZLE                     a;
-} XGL_CHANNEL_MAPPING;
+    VK_CHANNEL_SWIZZLE                     r;
+    VK_CHANNEL_SWIZZLE                     g;
+    VK_CHANNEL_SWIZZLE                     b;
+    VK_CHANNEL_SWIZZLE                     a;
+} VK_CHANNEL_MAPPING;
 
-typedef struct _XGL_PHYSICAL_GPU_PROPERTIES
+typedef struct _VK_PHYSICAL_GPU_PROPERTIES
 {
     uint32_t                                apiVersion;
     uint32_t                                driverVersion;
     uint32_t                                vendorId;
     uint32_t                                deviceId;
-    XGL_PHYSICAL_GPU_TYPE                   gpuType;
-    char                                    gpuName[XGL_MAX_PHYSICAL_GPU_NAME];
-    XGL_GPU_SIZE                            maxInlineMemoryUpdateSize;
+    VK_PHYSICAL_GPU_TYPE                   gpuType;
+    char                                    gpuName[VK_MAX_PHYSICAL_GPU_NAME];
+    VK_GPU_SIZE                            maxInlineMemoryUpdateSize;
     uint32_t                                maxBoundDescriptorSets;
     uint32_t                                maxThreadGroupSize;
     uint64_t                                timestampFrequency;
@@ -1350,731 +1350,731 @@
     uint32_t                                maxDescriptorSets;              // at least 2?
     uint32_t                                maxViewports;                   // at least 16?
     uint32_t                                maxColorAttachments;            // at least 8?
-} XGL_PHYSICAL_GPU_PROPERTIES;
+} VK_PHYSICAL_GPU_PROPERTIES;
 
-typedef struct _XGL_PHYSICAL_GPU_PERFORMANCE
+typedef struct _VK_PHYSICAL_GPU_PERFORMANCE
 {
     float                                   maxGpuClock;
     float                                   aluPerClock;
     float                                   texPerClock;
     float                                   primsPerClock;
     float                                   pixelsPerClock;
-} XGL_PHYSICAL_GPU_PERFORMANCE;
+} VK_PHYSICAL_GPU_PERFORMANCE;
 
-typedef struct _XGL_GPU_COMPATIBILITY_INFO
+typedef struct _VK_GPU_COMPATIBILITY_INFO
 {
-    XGL_FLAGS                               compatibilityFlags; // XGL_GPU_COMPATIBILITY_FLAGS
-} XGL_GPU_COMPATIBILITY_INFO;
+    VK_FLAGS                               compatibilityFlags; // VK_GPU_COMPATIBILITY_FLAGS
+} VK_GPU_COMPATIBILITY_INFO;
 
-typedef struct _XGL_APPLICATION_INFO
+typedef struct _VK_APPLICATION_INFO
 {
-    XGL_STRUCTURE_TYPE                      sType;              // Type of structure. Should be XGL_STRUCTURE_TYPE_APPLICATION_INFO
+    VK_STRUCTURE_TYPE                      sType;              // Type of structure. Should be VK_STRUCTURE_TYPE_APPLICATION_INFO
     const void*                             pNext;              // Next structure in chain
     const char*                             pAppName;
     uint32_t                                appVersion;
     const char*                             pEngineName;
     uint32_t                                engineVersion;
     uint32_t                                apiVersion;
-} XGL_APPLICATION_INFO;
+} VK_APPLICATION_INFO;
 
-typedef void* (XGLAPI *XGL_ALLOC_FUNCTION)(
+typedef void* (VKAPI *VK_ALLOC_FUNCTION)(
     void*                                   pUserData,
     size_t                                  size,
     size_t                                  alignment,
-    XGL_SYSTEM_ALLOC_TYPE                   allocType);
+    VK_SYSTEM_ALLOC_TYPE                   allocType);
 
-typedef void (XGLAPI *XGL_FREE_FUNCTION)(
+typedef void (VKAPI *VK_FREE_FUNCTION)(
     void*                                   pUserData,
     void*                                   pMem);
 
-typedef struct _XGL_ALLOC_CALLBACKS
+typedef struct _VK_ALLOC_CALLBACKS
 {
     void*                                   pUserData;
-    XGL_ALLOC_FUNCTION                      pfnAlloc;
-    XGL_FREE_FUNCTION                       pfnFree;
-} XGL_ALLOC_CALLBACKS;
+    VK_ALLOC_FUNCTION                      pfnAlloc;
+    VK_FREE_FUNCTION                       pfnFree;
+} VK_ALLOC_CALLBACKS;
 
-typedef struct _XGL_DEVICE_QUEUE_CREATE_INFO
+typedef struct _VK_DEVICE_QUEUE_CREATE_INFO
 {
     uint32_t                                queueNodeIndex;
     uint32_t                                queueCount;
-} XGL_DEVICE_QUEUE_CREATE_INFO;
+} VK_DEVICE_QUEUE_CREATE_INFO;
 
-typedef struct _XGL_DEVICE_CREATE_INFO
+typedef struct _VK_DEVICE_CREATE_INFO
 {
-    XGL_STRUCTURE_TYPE                      sType;                      // Should be XGL_STRUCTURE_TYPE_DEVICE_CREATE_INFO
+    VK_STRUCTURE_TYPE                      sType;                      // Should be VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO
     const void*                             pNext;                      // Pointer to next structure
     uint32_t                                queueRecordCount;
-    const XGL_DEVICE_QUEUE_CREATE_INFO*     pRequestedQueues;
+    const VK_DEVICE_QUEUE_CREATE_INFO*     pRequestedQueues;
     uint32_t                                extensionCount;
     const char*const*                       ppEnabledExtensionNames;
-    XGL_VALIDATION_LEVEL                    maxValidationLevel;
-    XGL_FLAGS                               flags;                      // XGL_DEVICE_CREATE_FLAGS
-} XGL_DEVICE_CREATE_INFO;
+    VK_VALIDATION_LEVEL                    maxValidationLevel;
+    VK_FLAGS                               flags;                      // VK_DEVICE_CREATE_FLAGS
+} VK_DEVICE_CREATE_INFO;
 
-typedef struct _XGL_INSTANCE_CREATE_INFO
+typedef struct _VK_INSTANCE_CREATE_INFO
 {
-    XGL_STRUCTURE_TYPE                      sType;                      // Should be XGL_STRUCTURE_TYPE_INSTANCE_CREATE_INFO
+    VK_STRUCTURE_TYPE                      sType;                      // Should be VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO
     const void*                             pNext;                      // Pointer to next structure
-    const XGL_APPLICATION_INFO*             pAppInfo;
-    const XGL_ALLOC_CALLBACKS*              pAllocCb;
+    const VK_APPLICATION_INFO*             pAppInfo;
+    const VK_ALLOC_CALLBACKS*              pAllocCb;
     uint32_t                                extensionCount;
     const char*const*                       ppEnabledExtensionNames;    // layer or extension name to be enabled
-} XGL_INSTANCE_CREATE_INFO;
+} VK_INSTANCE_CREATE_INFO;
 
-// can be added to XGL_DEVICE_CREATE_INFO or XGL_INSTANCE_CREATE_INFO via pNext
-typedef struct _XGL_LAYER_CREATE_INFO
+// can be added to VK_DEVICE_CREATE_INFO or VK_INSTANCE_CREATE_INFO via pNext
+typedef struct _VK_LAYER_CREATE_INFO
 {
-    XGL_STRUCTURE_TYPE                      sType;                      // Should be XGL_STRUCTURE_TYPE_LAYER_CREATE_INFO
+    VK_STRUCTURE_TYPE                      sType;                      // Should be VK_STRUCTURE_TYPE_LAYER_CREATE_INFO
     const void*                             pNext;                      // Pointer to next structure
     uint32_t                                layerCount;
-    const char *const*                      ppActiveLayerNames;         // layer name from the layer's xglEnumerateLayers())
-} XGL_LAYER_CREATE_INFO;
+    const char *const*                      ppActiveLayerNames;         // layer name from the layer's vkEnumerateLayers())
+} VK_LAYER_CREATE_INFO;
 
-typedef struct _XGL_PHYSICAL_GPU_QUEUE_PROPERTIES
+typedef struct _VK_PHYSICAL_GPU_QUEUE_PROPERTIES
 {
-    XGL_FLAGS                               queueFlags;                 // XGL_QUEUE_FLAGS
+    VK_FLAGS                               queueFlags;                 // VK_QUEUE_FLAGS
     uint32_t                                queueCount;
     uint32_t                                maxAtomicCounters;
     bool32_t                                supportsTimestamps;
     uint32_t                                maxMemReferences;           // Tells how many memory references can be active for the given queue
-} XGL_PHYSICAL_GPU_QUEUE_PROPERTIES;
+} VK_PHYSICAL_GPU_QUEUE_PROPERTIES;
 
-typedef struct _XGL_PHYSICAL_GPU_MEMORY_PROPERTIES
+typedef struct _VK_PHYSICAL_GPU_MEMORY_PROPERTIES
 {
     bool32_t                                supportsMigration;
     bool32_t                                supportsPinning;
-} XGL_PHYSICAL_GPU_MEMORY_PROPERTIES;
+} VK_PHYSICAL_GPU_MEMORY_PROPERTIES;
 
-typedef struct _XGL_MEMORY_ALLOC_INFO
+typedef struct _VK_MEMORY_ALLOC_INFO
 {
-    XGL_STRUCTURE_TYPE                      sType;                      // Must be XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO
+    VK_STRUCTURE_TYPE                      sType;                      // Must be VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO
     const void*                             pNext;                      // Pointer to next structure
-    XGL_GPU_SIZE                            allocationSize;             // Size of memory allocation
-    XGL_FLAGS                               memProps;                   // XGL_MEMORY_PROPERTY_FLAGS
-    XGL_MEMORY_TYPE                         memType;
-    XGL_MEMORY_PRIORITY                     memPriority;
-} XGL_MEMORY_ALLOC_INFO;
+    VK_GPU_SIZE                            allocationSize;             // Size of memory allocation
+    VK_FLAGS                               memProps;                   // VK_MEMORY_PROPERTY_FLAGS
+    VK_MEMORY_TYPE                         memType;
+    VK_MEMORY_PRIORITY                     memPriority;
+} VK_MEMORY_ALLOC_INFO;
 
-// This structure is included in the XGL_MEMORY_ALLOC_INFO chain
+// This structure is included in the VK_MEMORY_ALLOC_INFO chain
 // for memory regions allocated for buffer usage.
-typedef struct _XGL_MEMORY_ALLOC_BUFFER_INFO
+typedef struct _VK_MEMORY_ALLOC_BUFFER_INFO
 {
-    XGL_STRUCTURE_TYPE                      sType;                      // Must be XGL_STRUCTURE_TYPE_MEMORY_ALLOC_BUFFER_INFO
+    VK_STRUCTURE_TYPE                      sType;                      // Must be VK_STRUCTURE_TYPE_MEMORY_ALLOC_BUFFER_INFO
     const void*                             pNext;                      // Pointer to next structure
-    XGL_FLAGS                               usage;                      // XGL_BUFFER_USAGE_FLAGS
-} XGL_MEMORY_ALLOC_BUFFER_INFO;
+    VK_FLAGS                               usage;                      // VK_BUFFER_USAGE_FLAGS
+} VK_MEMORY_ALLOC_BUFFER_INFO;
 
-// This structure is included in the XGL_MEMORY_ALLOC_INFO chain
+// This structure is included in the VK_MEMORY_ALLOC_INFO chain
 // for memory regions allocated for image usage.
-typedef struct _XGL_MEMORY_ALLOC_IMAGE_INFO
+typedef struct _VK_MEMORY_ALLOC_IMAGE_INFO
 {
-    XGL_STRUCTURE_TYPE                      sType;                      // Must be XGL_STRUCTURE_TYPE_MEMORY_ALLOC_IMAGE_INFO
+    VK_STRUCTURE_TYPE                      sType;                      // Must be VK_STRUCTURE_TYPE_MEMORY_ALLOC_IMAGE_INFO
     const void*                             pNext;                      // Pointer to next structure
-    XGL_FLAGS                               usage;                      // XGL_IMAGE_USAGE_FLAGS
-    XGL_IMAGE_FORMAT_CLASS                  formatClass;
+    VK_FLAGS                               usage;                      // VK_IMAGE_USAGE_FLAGS
+    VK_IMAGE_FORMAT_CLASS                  formatClass;
     uint32_t                                samples;
-} XGL_MEMORY_ALLOC_IMAGE_INFO;
+} VK_MEMORY_ALLOC_IMAGE_INFO;
 
-typedef struct _XGL_MEMORY_OPEN_INFO
+typedef struct _VK_MEMORY_OPEN_INFO
 {
-    XGL_STRUCTURE_TYPE                      sType;                      // Must be XGL_STRUCTURE_TYPE_MEMORY_OPEN_INFO
+    VK_STRUCTURE_TYPE                      sType;                      // Must be VK_STRUCTURE_TYPE_MEMORY_OPEN_INFO
     const void*                             pNext;                      // Pointer to next structure
-    XGL_GPU_MEMORY                          sharedMem;
-} XGL_MEMORY_OPEN_INFO;
+    VK_GPU_MEMORY                          sharedMem;
+} VK_MEMORY_OPEN_INFO;
 
-typedef struct _XGL_PEER_MEMORY_OPEN_INFO
+typedef struct _VK_PEER_MEMORY_OPEN_INFO
 {
-    XGL_STRUCTURE_TYPE                      sType;                      // Must be XGL_STRUCTURE_TYPE_PEER_MEMORY_OPEN_INFO
+    VK_STRUCTURE_TYPE                      sType;                      // Must be VK_STRUCTURE_TYPE_PEER_MEMORY_OPEN_INFO
     const void*                             pNext;                      // Pointer to next structure
-    XGL_GPU_MEMORY                          originalMem;
-} XGL_PEER_MEMORY_OPEN_INFO;
+    VK_GPU_MEMORY                          originalMem;
+} VK_PEER_MEMORY_OPEN_INFO;
 
-typedef struct _XGL_MEMORY_REQUIREMENTS
+typedef struct _VK_MEMORY_REQUIREMENTS
 {
-    XGL_GPU_SIZE                            size;                       // Specified in bytes
-    XGL_GPU_SIZE                            alignment;                  // Specified in bytes
-    XGL_GPU_SIZE                            granularity;                // Granularity on which xglBindObjectMemoryRange can bind sub-ranges of memory specified in bytes (usually the page size)
-    XGL_FLAGS                               memProps;                   // XGL_MEMORY_PROPERTY_FLAGS
-    XGL_MEMORY_TYPE                         memType;
-} XGL_MEMORY_REQUIREMENTS;
+    VK_GPU_SIZE                            size;                       // Specified in bytes
+    VK_GPU_SIZE                            alignment;                  // Specified in bytes
+    VK_GPU_SIZE                            granularity;                // Granularity on which vkBindObjectMemoryRange can bind sub-ranges of memory specified in bytes (usually the page size)
+    VK_FLAGS                               memProps;                   // VK_MEMORY_PROPERTY_FLAGS
+    VK_MEMORY_TYPE                         memType;
+} VK_MEMORY_REQUIREMENTS;
 
-typedef struct _XGL_BUFFER_MEMORY_REQUIREMENTS
+typedef struct _VK_BUFFER_MEMORY_REQUIREMENTS
 {
-    XGL_FLAGS                               usage;                      // XGL_BUFFER_USAGE_FLAGS
-} XGL_BUFFER_MEMORY_REQUIREMENTS;
+    VK_FLAGS                               usage;                      // VK_BUFFER_USAGE_FLAGS
+} VK_BUFFER_MEMORY_REQUIREMENTS;
 
-typedef struct _XGL_IMAGE_MEMORY_REQUIREMENTS
+typedef struct _VK_IMAGE_MEMORY_REQUIREMENTS
 {
-    XGL_FLAGS                               usage;                      // XGL_IMAGE_USAGE_FLAGS
-    XGL_IMAGE_FORMAT_CLASS                  formatClass;
+    VK_FLAGS                               usage;                      // VK_IMAGE_USAGE_FLAGS
+    VK_IMAGE_FORMAT_CLASS                  formatClass;
     uint32_t                                samples;
-} XGL_IMAGE_MEMORY_REQUIREMENTS;
+} VK_IMAGE_MEMORY_REQUIREMENTS;
 
-typedef struct _XGL_FORMAT_PROPERTIES
+typedef struct _VK_FORMAT_PROPERTIES
 {
-    XGL_FLAGS                               linearTilingFeatures;      // XGL_FORMAT_FEATURE_FLAGS
-    XGL_FLAGS                               optimalTilingFeatures;     // XGL_FORMAT_FEATURE_FLAGS
-} XGL_FORMAT_PROPERTIES;
+    VK_FLAGS                               linearTilingFeatures;      // VK_FORMAT_FEATURE_FLAGS
+    VK_FLAGS                               optimalTilingFeatures;     // VK_FORMAT_FEATURE_FLAGS
+} VK_FORMAT_PROPERTIES;
 
-typedef struct _XGL_BUFFER_VIEW_ATTACH_INFO
+typedef struct _VK_BUFFER_VIEW_ATTACH_INFO
 {
-    XGL_STRUCTURE_TYPE                      sType;                      // Must be XGL_STRUCTURE_TYPE_BUFFER_VIEW_ATTACH_INFO
+    VK_STRUCTURE_TYPE                      sType;                      // Must be VK_STRUCTURE_TYPE_BUFFER_VIEW_ATTACH_INFO
     const void*                             pNext;                      // Pointer to next structure
-    XGL_BUFFER_VIEW                         view;
-} XGL_BUFFER_VIEW_ATTACH_INFO;
+    VK_BUFFER_VIEW                         view;
+} VK_BUFFER_VIEW_ATTACH_INFO;
 
-typedef struct _XGL_IMAGE_VIEW_ATTACH_INFO
+typedef struct _VK_IMAGE_VIEW_ATTACH_INFO
 {
-    XGL_STRUCTURE_TYPE                      sType;                      // Must be XGL_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO
+    VK_STRUCTURE_TYPE                      sType;                      // Must be VK_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO
     const void*                             pNext;                      // Pointer to next structure
-    XGL_IMAGE_VIEW                          view;
-    XGL_IMAGE_LAYOUT                        layout;
-} XGL_IMAGE_VIEW_ATTACH_INFO;
+    VK_IMAGE_VIEW                          view;
+    VK_IMAGE_LAYOUT                        layout;
+} VK_IMAGE_VIEW_ATTACH_INFO;
 
-typedef struct _XGL_UPDATE_SAMPLERS
+typedef struct _VK_UPDATE_SAMPLERS
 {
-    XGL_STRUCTURE_TYPE                      sType;                      // Must be XGL_STRUCTURE_TYPE_UPDATE_SAMPLERS
+    VK_STRUCTURE_TYPE                      sType;                      // Must be VK_STRUCTURE_TYPE_UPDATE_SAMPLERS
     const void*                             pNext;                      // Pointer to next structure
     uint32_t                                binding;                    // Binding of the sampler (array)
     uint32_t                                arrayIndex;                 // First element of the array to update or zero otherwise
     uint32_t                                count;                      // Number of elements to update
-    const XGL_SAMPLER*                      pSamplers;
-} XGL_UPDATE_SAMPLERS;
+    const VK_SAMPLER*                      pSamplers;
+} VK_UPDATE_SAMPLERS;
 
-typedef struct _XGL_SAMPLER_IMAGE_VIEW_INFO
+typedef struct _VK_SAMPLER_IMAGE_VIEW_INFO
 {
-    XGL_SAMPLER                             sampler;
-    const XGL_IMAGE_VIEW_ATTACH_INFO*       pImageView;
-} XGL_SAMPLER_IMAGE_VIEW_INFO;
+    VK_SAMPLER                             sampler;
+    const VK_IMAGE_VIEW_ATTACH_INFO*       pImageView;
+} VK_SAMPLER_IMAGE_VIEW_INFO;
 
-typedef struct _XGL_UPDATE_SAMPLER_TEXTURES
+typedef struct _VK_UPDATE_SAMPLER_TEXTURES
 {
-    XGL_STRUCTURE_TYPE                      sType;                      // Must be XGL_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES
+    VK_STRUCTURE_TYPE                      sType;                      // Must be VK_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES
     const void*                             pNext;                      // Pointer to next structure
     uint32_t                                binding;                    // Binding of the combined texture sampler (array)
     uint32_t                                arrayIndex;                 // First element of the array to update or zero otherwise
     uint32_t                                count;                      // Number of elements to update
-    const XGL_SAMPLER_IMAGE_VIEW_INFO*      pSamplerImageViews;
-} XGL_UPDATE_SAMPLER_TEXTURES;
+    const VK_SAMPLER_IMAGE_VIEW_INFO*      pSamplerImageViews;
+} VK_UPDATE_SAMPLER_TEXTURES;
 
-typedef struct _XGL_UPDATE_IMAGES
+typedef struct _VK_UPDATE_IMAGES
 {
-    XGL_STRUCTURE_TYPE                       sType;                     // Must be XGL_STRUCTURE_TYPE_UPDATE_IMAGES
+    VK_STRUCTURE_TYPE                       sType;                     // Must be VK_STRUCTURE_TYPE_UPDATE_IMAGES
     const void*                              pNext;                     // Pointer to next structure
-    XGL_DESCRIPTOR_TYPE                      descriptorType;
+    VK_DESCRIPTOR_TYPE                      descriptorType;
     uint32_t                                 binding;                   // Binding of the image (array)
     uint32_t                                 arrayIndex;                // First element of the array to update or zero otherwise
     uint32_t                                 count;                     // Number of elements to update
-    const XGL_IMAGE_VIEW_ATTACH_INFO*        pImageViews;
-} XGL_UPDATE_IMAGES;
+    const VK_IMAGE_VIEW_ATTACH_INFO*        pImageViews;
+} VK_UPDATE_IMAGES;
 
-typedef struct _XGL_UPDATE_BUFFERS
+typedef struct _VK_UPDATE_BUFFERS
 {
-    XGL_STRUCTURE_TYPE                        sType;                    // Must be XGL_STRUCTURE_TYPE_UPDATE_BUFFERS
+    VK_STRUCTURE_TYPE                        sType;                    // Must be VK_STRUCTURE_TYPE_UPDATE_BUFFERS
     const void*                               pNext;                    // Pointer to next structure
-    XGL_DESCRIPTOR_TYPE                       descriptorType;
+    VK_DESCRIPTOR_TYPE                       descriptorType;
     uint32_t                                  binding;                  // Binding of the buffer (array)
     uint32_t                                  arrayIndex;               // First element of the array to update or zero otherwise
     uint32_t                                  count;                    // Number of elements to update
-    const XGL_BUFFER_VIEW_ATTACH_INFO*        pBufferViews;
-} XGL_UPDATE_BUFFERS;
+    const VK_BUFFER_VIEW_ATTACH_INFO*        pBufferViews;
+} VK_UPDATE_BUFFERS;
 
-typedef struct _XGL_UPDATE_AS_COPY
+typedef struct _VK_UPDATE_AS_COPY
 {
-    XGL_STRUCTURE_TYPE                      sType;                      // Must be XGL_STRUCTURE_TYPE_UPDATE_AS_COPY
+    VK_STRUCTURE_TYPE                      sType;                      // Must be VK_STRUCTURE_TYPE_UPDATE_AS_COPY
     const void*                             pNext;                      // Pointer to next structure
-    XGL_DESCRIPTOR_TYPE                     descriptorType;
-    XGL_DESCRIPTOR_SET                      descriptorSet;
+    VK_DESCRIPTOR_TYPE                     descriptorType;
+    VK_DESCRIPTOR_SET                      descriptorSet;
     uint32_t                                binding;
     uint32_t                                arrayElement;
     uint32_t                                count;
-} XGL_UPDATE_AS_COPY;
+} VK_UPDATE_AS_COPY;
 
-typedef struct _XGL_BUFFER_CREATE_INFO
+typedef struct _VK_BUFFER_CREATE_INFO
 {
-    XGL_STRUCTURE_TYPE                      sType;                      // Must be XGL_STRUCTURE_TYPE_BUFFER_CREATE_INFO
+    VK_STRUCTURE_TYPE                      sType;                      // Must be VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO
     const void*                             pNext;                      // Pointer to next structure.
-    XGL_GPU_SIZE                            size;                       // Specified in bytes
-    XGL_FLAGS                               usage;                      // XGL_BUFFER_USAGE_FLAGS
-    XGL_FLAGS                               flags;                      // XGL_BUFFER_CREATE_FLAGS
-} XGL_BUFFER_CREATE_INFO;
+    VK_GPU_SIZE                            size;                       // Specified in bytes
+    VK_FLAGS                               usage;                      // VK_BUFFER_USAGE_FLAGS
+    VK_FLAGS                               flags;                      // VK_BUFFER_CREATE_FLAGS
+} VK_BUFFER_CREATE_INFO;
 
-typedef struct _XGL_BUFFER_VIEW_CREATE_INFO
+typedef struct _VK_BUFFER_VIEW_CREATE_INFO
 {
-    XGL_STRUCTURE_TYPE                      sType;                      // Must be XGL_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO
+    VK_STRUCTURE_TYPE                      sType;                      // Must be VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO
     const void*                             pNext;                      // Pointer to next structure.
-    XGL_BUFFER                              buffer;
-    XGL_BUFFER_VIEW_TYPE                    viewType;
-    XGL_FORMAT                              format;                     // Optionally specifies format of elements
-    XGL_GPU_SIZE                            offset;                     // Specified in bytes
-    XGL_GPU_SIZE                            range;                      // View size specified in bytes
-} XGL_BUFFER_VIEW_CREATE_INFO;
+    VK_BUFFER                              buffer;
+    VK_BUFFER_VIEW_TYPE                    viewType;
+    VK_FORMAT                              format;                     // Optionally specifies format of elements
+    VK_GPU_SIZE                            offset;                     // Specified in bytes
+    VK_GPU_SIZE                            range;                      // View size specified in bytes
+} VK_BUFFER_VIEW_CREATE_INFO;
 
-typedef struct _XGL_IMAGE_SUBRESOURCE
+typedef struct _VK_IMAGE_SUBRESOURCE
 {
-    XGL_IMAGE_ASPECT                        aspect;
+    VK_IMAGE_ASPECT                        aspect;
     uint32_t                                mipLevel;
     uint32_t                                arraySlice;
-} XGL_IMAGE_SUBRESOURCE;
+} VK_IMAGE_SUBRESOURCE;
 
-typedef struct _XGL_IMAGE_SUBRESOURCE_RANGE
+typedef struct _VK_IMAGE_SUBRESOURCE_RANGE
 {
-    XGL_IMAGE_ASPECT                        aspect;
+    VK_IMAGE_ASPECT                        aspect;
     uint32_t                                baseMipLevel;
     uint32_t                                mipLevels;
     uint32_t                                baseArraySlice;
     uint32_t                                arraySize;
-} XGL_IMAGE_SUBRESOURCE_RANGE;
+} VK_IMAGE_SUBRESOURCE_RANGE;
 
-typedef struct _XGL_EVENT_WAIT_INFO
+typedef struct _VK_EVENT_WAIT_INFO
 {
-    XGL_STRUCTURE_TYPE                      sType;                      // Must be XGL_STRUCTURE_TYPE_EVENT_WAIT_INFO
+    VK_STRUCTURE_TYPE                      sType;                      // Must be VK_STRUCTURE_TYPE_EVENT_WAIT_INFO
     const void*                             pNext;                      // Pointer to next structure.
 
     uint32_t                                eventCount;                 // Number of events to wait on
-    const XGL_EVENT*                        pEvents;                    // Array of event objects to wait on
+    const VK_EVENT*                        pEvents;                    // Array of event objects to wait on
 
-    XGL_WAIT_EVENT                          waitEvent;                  // Pipeline event where the wait should happen
+    VK_WAIT_EVENT                          waitEvent;                  // Pipeline event where the wait should happen
 
     uint32_t                                memBarrierCount;            // Number of memory barriers
-    const void**                            ppMemBarriers;              // Array of pointers to memory barriers (any of them can be either XGL_MEMORY_BARRIER, XGL_BUFFER_MEMORY_BARRIER, or XGL_IMAGE_MEMORY_BARRIER)
-} XGL_EVENT_WAIT_INFO;
+    const void**                            ppMemBarriers;              // Array of pointers to memory barriers (any of them can be either VK_MEMORY_BARRIER, VK_BUFFER_MEMORY_BARRIER, or VK_IMAGE_MEMORY_BARRIER)
+} VK_EVENT_WAIT_INFO;
 
-typedef struct _XGL_PIPELINE_BARRIER
+typedef struct _VK_PIPELINE_BARRIER
 {
-    XGL_STRUCTURE_TYPE                      sType;                      // Must be XGL_STRUCTURE_TYPE_PIPELINE_BARRIER
+    VK_STRUCTURE_TYPE                      sType;                      // Must be VK_STRUCTURE_TYPE_PIPELINE_BARRIER
     const void*                             pNext;                      // Pointer to next structure.
 
     uint32_t                                eventCount;                 // Number of events to wait on
-    const XGL_PIPE_EVENT*                   pEvents;                    // Array of pipeline events to wait on
+    const VK_PIPE_EVENT*                   pEvents;                    // Array of pipeline events to wait on
 
-    XGL_WAIT_EVENT                          waitEvent;                  // Pipeline event where the wait should happen
+    VK_WAIT_EVENT                          waitEvent;                  // Pipeline event where the wait should happen
 
     uint32_t                                memBarrierCount;            // Number of memory barriers
-    const void**                            ppMemBarriers;              // Array of pointers to memory barriers (any of them can be either XGL_MEMORY_BARRIER, XGL_BUFFER_MEMORY_BARRIER, or XGL_IMAGE_MEMORY_BARRIER)
-} XGL_PIPELINE_BARRIER;
+    const void**                            ppMemBarriers;              // Array of pointers to memory barriers (any of them can be either VK_MEMORY_BARRIER, VK_BUFFER_MEMORY_BARRIER, or VK_IMAGE_MEMORY_BARRIER)
+} VK_PIPELINE_BARRIER;
 
-typedef struct _XGL_MEMORY_BARRIER
+typedef struct _VK_MEMORY_BARRIER
 {
-    XGL_STRUCTURE_TYPE                      sType;                      // Must be XGL_STRUCTURE_TYPE_MEMORY_BARRIER
+    VK_STRUCTURE_TYPE                      sType;                      // Must be VK_STRUCTURE_TYPE_MEMORY_BARRIER
     const void*                             pNext;                      // Pointer to next structure.
 
-    XGL_FLAGS                               outputMask;                 // Outputs the barrier should sync (see XGL_MEMORY_OUTPUT_FLAGS)
-    XGL_FLAGS                               inputMask;                  // Inputs the barrier should sync to (see XGL_MEMORY_INPUT_FLAGS)
-} XGL_MEMORY_BARRIER;
+    VK_FLAGS                               outputMask;                 // Outputs the barrier should sync (see VK_MEMORY_OUTPUT_FLAGS)
+    VK_FLAGS                               inputMask;                  // Inputs the barrier should sync to (see VK_MEMORY_INPUT_FLAGS)
+} VK_MEMORY_BARRIER;
 
-typedef struct _XGL_BUFFER_MEMORY_BARRIER
+typedef struct _VK_BUFFER_MEMORY_BARRIER
 {
-    XGL_STRUCTURE_TYPE                      sType;                      // Must be XGL_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER
+    VK_STRUCTURE_TYPE                      sType;                      // Must be VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER
     const void*                             pNext;                      // Pointer to next structure.
 
-    XGL_FLAGS                               outputMask;                 // Outputs the barrier should sync (see XGL_MEMORY_OUTPUT_FLAGS)
-    XGL_FLAGS                               inputMask;                  // Inputs the barrier should sync to (see XGL_MEMORY_INPUT_FLAGS)
+    VK_FLAGS                               outputMask;                 // Outputs the barrier should sync (see VK_MEMORY_OUTPUT_FLAGS)
+    VK_FLAGS                               inputMask;                  // Inputs the barrier should sync to (see VK_MEMORY_INPUT_FLAGS)
 
-    XGL_BUFFER                              buffer;                     // Buffer to sync
+    VK_BUFFER                              buffer;                     // Buffer to sync
 
-    XGL_GPU_SIZE                            offset;                     // Offset within the buffer to sync
-    XGL_GPU_SIZE                            size;                       // Amount of bytes to sync
-} XGL_BUFFER_MEMORY_BARRIER;
+    VK_GPU_SIZE                            offset;                     // Offset within the buffer to sync
+    VK_GPU_SIZE                            size;                       // Amount of bytes to sync
+} VK_BUFFER_MEMORY_BARRIER;
 
-typedef struct _XGL_IMAGE_MEMORY_BARRIER
+typedef struct _VK_IMAGE_MEMORY_BARRIER
 {
-    XGL_STRUCTURE_TYPE                      sType;                      // Must be XGL_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER
+    VK_STRUCTURE_TYPE                      sType;                      // Must be VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER
     const void*                             pNext;                      // Pointer to next structure.
 
-    XGL_FLAGS                               outputMask;                 // Outputs the barrier should sync (see XGL_MEMORY_OUTPUT_FLAGS)
-    XGL_FLAGS                               inputMask;                  // Inputs the barrier should sync to (see XGL_MEMORY_INPUT_FLAGS)
+    VK_FLAGS                               outputMask;                 // Outputs the barrier should sync (see VK_MEMORY_OUTPUT_FLAGS)
+    VK_FLAGS                               inputMask;                  // Inputs the barrier should sync to (see VK_MEMORY_INPUT_FLAGS)
 
-    XGL_IMAGE_LAYOUT                        oldLayout;                  // Current layout of the image
-    XGL_IMAGE_LAYOUT                        newLayout;                  // New layout to transition the image to
+    VK_IMAGE_LAYOUT                        oldLayout;                  // Current layout of the image
+    VK_IMAGE_LAYOUT                        newLayout;                  // New layout to transition the image to
 
-    XGL_IMAGE                               image;                      // Image to sync
+    VK_IMAGE                               image;                      // Image to sync
 
-    XGL_IMAGE_SUBRESOURCE_RANGE             subresourceRange;           // Subresource range to sync
-} XGL_IMAGE_MEMORY_BARRIER;
+    VK_IMAGE_SUBRESOURCE_RANGE             subresourceRange;           // Subresource range to sync
+} VK_IMAGE_MEMORY_BARRIER;
 
-typedef struct _XGL_IMAGE_CREATE_INFO
+typedef struct _VK_IMAGE_CREATE_INFO
 {
-    XGL_STRUCTURE_TYPE                      sType;                      // Must be XGL_STRUCTURE_TYPE_IMAGE_CREATE_INFO
+    VK_STRUCTURE_TYPE                      sType;                      // Must be VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO
     const void*                             pNext;                      // Pointer to next structure.
-    XGL_IMAGE_TYPE                          imageType;
-    XGL_FORMAT                              format;
-    XGL_EXTENT3D                            extent;
+    VK_IMAGE_TYPE                          imageType;
+    VK_FORMAT                              format;
+    VK_EXTENT3D                            extent;
     uint32_t                                mipLevels;
     uint32_t                                arraySize;
     uint32_t                                samples;
-    XGL_IMAGE_TILING                        tiling;
-    XGL_FLAGS                               usage;                      // XGL_IMAGE_USAGE_FLAGS
-    XGL_FLAGS                               flags;                      // XGL_IMAGE_CREATE_FLAGS
-} XGL_IMAGE_CREATE_INFO;
+    VK_IMAGE_TILING                        tiling;
+    VK_FLAGS                               usage;                      // VK_IMAGE_USAGE_FLAGS
+    VK_FLAGS                               flags;                      // VK_IMAGE_CREATE_FLAGS
+} VK_IMAGE_CREATE_INFO;
 
-typedef struct _XGL_PEER_IMAGE_OPEN_INFO
+typedef struct _VK_PEER_IMAGE_OPEN_INFO
 {
-    XGL_IMAGE                               originalImage;
-} XGL_PEER_IMAGE_OPEN_INFO;
+    VK_IMAGE                               originalImage;
+} VK_PEER_IMAGE_OPEN_INFO;
 
-typedef struct _XGL_SUBRESOURCE_LAYOUT
+typedef struct _VK_SUBRESOURCE_LAYOUT
 {
-    XGL_GPU_SIZE                            offset;                 // Specified in bytes
-    XGL_GPU_SIZE                            size;                   // Specified in bytes
-    XGL_GPU_SIZE                            rowPitch;               // Specified in bytes
-    XGL_GPU_SIZE                            depthPitch;             // Specified in bytes
-} XGL_SUBRESOURCE_LAYOUT;
+    VK_GPU_SIZE                            offset;                 // Specified in bytes
+    VK_GPU_SIZE                            size;                   // Specified in bytes
+    VK_GPU_SIZE                            rowPitch;               // Specified in bytes
+    VK_GPU_SIZE                            depthPitch;             // Specified in bytes
+} VK_SUBRESOURCE_LAYOUT;
 
-typedef struct _XGL_IMAGE_VIEW_CREATE_INFO
+typedef struct _VK_IMAGE_VIEW_CREATE_INFO
 {
-    XGL_STRUCTURE_TYPE                      sType;                  // Must be XGL_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO
+    VK_STRUCTURE_TYPE                      sType;                  // Must be VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO
     const void*                             pNext;                  // Pointer to next structure
-    XGL_IMAGE                               image;
-    XGL_IMAGE_VIEW_TYPE                     viewType;
-    XGL_FORMAT                              format;
-    XGL_CHANNEL_MAPPING                     channels;
-    XGL_IMAGE_SUBRESOURCE_RANGE             subresourceRange;
+    VK_IMAGE                               image;
+    VK_IMAGE_VIEW_TYPE                     viewType;
+    VK_FORMAT                              format;
+    VK_CHANNEL_MAPPING                     channels;
+    VK_IMAGE_SUBRESOURCE_RANGE             subresourceRange;
     float                                   minLod;
-} XGL_IMAGE_VIEW_CREATE_INFO;
+} VK_IMAGE_VIEW_CREATE_INFO;
 
-typedef struct _XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO
+typedef struct _VK_COLOR_ATTACHMENT_VIEW_CREATE_INFO
 {
-    XGL_STRUCTURE_TYPE                      sType;                  // Must be XGL_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO
+    VK_STRUCTURE_TYPE                      sType;                  // Must be VK_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO
     const void*                             pNext;                  // Pointer to next structure
-    XGL_IMAGE                               image;
-    XGL_FORMAT                              format;
+    VK_IMAGE                               image;
+    VK_FORMAT                              format;
     uint32_t                                mipLevel;
     uint32_t                                baseArraySlice;
     uint32_t                                arraySize;
-    XGL_IMAGE                               msaaResolveImage;
-    XGL_IMAGE_SUBRESOURCE_RANGE             msaaResolveSubResource;
-} XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO;
+    VK_IMAGE                               msaaResolveImage;
+    VK_IMAGE_SUBRESOURCE_RANGE             msaaResolveSubResource;
+} VK_COLOR_ATTACHMENT_VIEW_CREATE_INFO;
 
-typedef struct _XGL_DEPTH_STENCIL_VIEW_CREATE_INFO
+typedef struct _VK_DEPTH_STENCIL_VIEW_CREATE_INFO
 {
-    XGL_STRUCTURE_TYPE                      sType;                  // Must be XGL_STRUCTURE_TYPE_DEPTH_STENCIL_VIEW_CREATE_INFO
+    VK_STRUCTURE_TYPE                      sType;                  // Must be VK_STRUCTURE_TYPE_DEPTH_STENCIL_VIEW_CREATE_INFO
     const void*                             pNext;                  // Pointer to next structure
-    XGL_IMAGE                               image;
+    VK_IMAGE                               image;
     uint32_t                                mipLevel;
     uint32_t                                baseArraySlice;
     uint32_t                                arraySize;
-    XGL_IMAGE                               msaaResolveImage;
-    XGL_IMAGE_SUBRESOURCE_RANGE             msaaResolveSubResource;
-    XGL_FLAGS                               flags;                  // XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS
-} XGL_DEPTH_STENCIL_VIEW_CREATE_INFO;
+    VK_IMAGE                               msaaResolveImage;
+    VK_IMAGE_SUBRESOURCE_RANGE             msaaResolveSubResource;
+    VK_FLAGS                               flags;                  // VK_DEPTH_STENCIL_VIEW_CREATE_FLAGS
+} VK_DEPTH_STENCIL_VIEW_CREATE_INFO;
 
-typedef struct _XGL_COLOR_ATTACHMENT_BIND_INFO
+typedef struct _VK_COLOR_ATTACHMENT_BIND_INFO
 {
-    XGL_COLOR_ATTACHMENT_VIEW               view;
-    XGL_IMAGE_LAYOUT                        layout;
-} XGL_COLOR_ATTACHMENT_BIND_INFO;
+    VK_COLOR_ATTACHMENT_VIEW               view;
+    VK_IMAGE_LAYOUT                        layout;
+} VK_COLOR_ATTACHMENT_BIND_INFO;
 
-typedef struct _XGL_DEPTH_STENCIL_BIND_INFO
+typedef struct _VK_DEPTH_STENCIL_BIND_INFO
 {
-    XGL_DEPTH_STENCIL_VIEW                  view;
-    XGL_IMAGE_LAYOUT                        layout;
-} XGL_DEPTH_STENCIL_BIND_INFO;
+    VK_DEPTH_STENCIL_VIEW                  view;
+    VK_IMAGE_LAYOUT                        layout;
+} VK_DEPTH_STENCIL_BIND_INFO;
 
-typedef struct _XGL_BUFFER_COPY
+typedef struct _VK_BUFFER_COPY
 {
-    XGL_GPU_SIZE                            srcOffset;              // Specified in bytes
-    XGL_GPU_SIZE                            destOffset;             // Specified in bytes
-    XGL_GPU_SIZE                            copySize;               // Specified in bytes
-} XGL_BUFFER_COPY;
+    VK_GPU_SIZE                            srcOffset;              // Specified in bytes
+    VK_GPU_SIZE                            destOffset;             // Specified in bytes
+    VK_GPU_SIZE                            copySize;               // Specified in bytes
+} VK_BUFFER_COPY;
 
-typedef struct _XGL_IMAGE_MEMORY_BIND_INFO
+typedef struct _VK_IMAGE_MEMORY_BIND_INFO
 {
-    XGL_IMAGE_SUBRESOURCE                   subresource;
-    XGL_OFFSET3D                            offset;
-    XGL_EXTENT3D                            extent;
-} XGL_IMAGE_MEMORY_BIND_INFO;
+    VK_IMAGE_SUBRESOURCE                   subresource;
+    VK_OFFSET3D                            offset;
+    VK_EXTENT3D                            extent;
+} VK_IMAGE_MEMORY_BIND_INFO;
 
-typedef struct _XGL_IMAGE_COPY
+typedef struct _VK_IMAGE_COPY
 {
-    XGL_IMAGE_SUBRESOURCE                   srcSubresource;
-    XGL_OFFSET3D                            srcOffset;
-    XGL_IMAGE_SUBRESOURCE                   destSubresource;
-    XGL_OFFSET3D                            destOffset;
-    XGL_EXTENT3D                            extent;
-} XGL_IMAGE_COPY;
+    VK_IMAGE_SUBRESOURCE                   srcSubresource;
+    VK_OFFSET3D                            srcOffset;
+    VK_IMAGE_SUBRESOURCE                   destSubresource;
+    VK_OFFSET3D                            destOffset;
+    VK_EXTENT3D                            extent;
+} VK_IMAGE_COPY;
 
-typedef struct _XGL_IMAGE_BLIT
+typedef struct _VK_IMAGE_BLIT
 {
-    XGL_IMAGE_SUBRESOURCE                   srcSubresource;
-    XGL_OFFSET3D                            srcOffset;
-    XGL_EXTENT3D                            srcExtent;
-    XGL_IMAGE_SUBRESOURCE                   destSubresource;
-    XGL_OFFSET3D                            destOffset;
-    XGL_EXTENT3D                            destExtent;
-} XGL_IMAGE_BLIT;
+    VK_IMAGE_SUBRESOURCE                   srcSubresource;
+    VK_OFFSET3D                            srcOffset;
+    VK_EXTENT3D                            srcExtent;
+    VK_IMAGE_SUBRESOURCE                   destSubresource;
+    VK_OFFSET3D                            destOffset;
+    VK_EXTENT3D                            destExtent;
+} VK_IMAGE_BLIT;
 
-typedef struct _XGL_BUFFER_IMAGE_COPY
+typedef struct _VK_BUFFER_IMAGE_COPY
 {
-    XGL_GPU_SIZE                            bufferOffset;           // Specified in bytes
-    XGL_IMAGE_SUBRESOURCE                   imageSubresource;
-    XGL_OFFSET3D                            imageOffset;
-    XGL_EXTENT3D                            imageExtent;
-} XGL_BUFFER_IMAGE_COPY;
+    VK_GPU_SIZE                            bufferOffset;           // Specified in bytes
+    VK_IMAGE_SUBRESOURCE                   imageSubresource;
+    VK_OFFSET3D                            imageOffset;
+    VK_EXTENT3D                            imageExtent;
+} VK_BUFFER_IMAGE_COPY;
 
-typedef struct _XGL_IMAGE_RESOLVE
+typedef struct _VK_IMAGE_RESOLVE
 {
-    XGL_IMAGE_SUBRESOURCE                   srcSubresource;
-    XGL_OFFSET2D                            srcOffset;
-    XGL_IMAGE_SUBRESOURCE                   destSubresource;
-    XGL_OFFSET2D                            destOffset;
-    XGL_EXTENT2D                            extent;
-} XGL_IMAGE_RESOLVE;
+    VK_IMAGE_SUBRESOURCE                   srcSubresource;
+    VK_OFFSET2D                            srcOffset;
+    VK_IMAGE_SUBRESOURCE                   destSubresource;
+    VK_OFFSET2D                            destOffset;
+    VK_EXTENT2D                            extent;
+} VK_IMAGE_RESOLVE;
 
-typedef struct _XGL_SHADER_CREATE_INFO
+typedef struct _VK_SHADER_CREATE_INFO
 {
-    XGL_STRUCTURE_TYPE                      sType;              // Must be XGL_STRUCTURE_TYPE_SHADER_CREATE_INFO
+    VK_STRUCTURE_TYPE                      sType;              // Must be VK_STRUCTURE_TYPE_SHADER_CREATE_INFO
     const void*                             pNext;              // Pointer to next structure
     size_t                                  codeSize;           // Specified in bytes
     const void*                             pCode;
-    XGL_FLAGS                               flags;              // Reserved
-} XGL_SHADER_CREATE_INFO;
+    VK_FLAGS                               flags;              // Reserved
+} VK_SHADER_CREATE_INFO;
 
-typedef struct _XGL_DESCRIPTOR_SET_LAYOUT_BINDING
+typedef struct _VK_DESCRIPTOR_SET_LAYOUT_BINDING
 {
-    XGL_DESCRIPTOR_TYPE                     descriptorType;
+    VK_DESCRIPTOR_TYPE                     descriptorType;
     uint32_t                                count;
-    XGL_FLAGS                               stageFlags;         // XGL_SHADER_STAGE_FLAGS
-    const XGL_SAMPLER*                      pImmutableSamplers;
-} XGL_DESCRIPTOR_SET_LAYOUT_BINDING;
+    VK_FLAGS                               stageFlags;         // VK_SHADER_STAGE_FLAGS
+    const VK_SAMPLER*                      pImmutableSamplers;
+} VK_DESCRIPTOR_SET_LAYOUT_BINDING;
 
-typedef struct _XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO
+typedef struct _VK_DESCRIPTOR_SET_LAYOUT_CREATE_INFO
 {
-    XGL_STRUCTURE_TYPE                       sType;             // Must be XGL_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO
+    VK_STRUCTURE_TYPE                       sType;             // Must be VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO
     const void*                              pNext;             // Pointer to next structure
     uint32_t                                 count;             // Number of bindings in the descriptor set layout
-    const XGL_DESCRIPTOR_SET_LAYOUT_BINDING* pBinding;          // Array of descriptor set layout bindings
-} XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
+    const VK_DESCRIPTOR_SET_LAYOUT_BINDING* pBinding;          // Array of descriptor set layout bindings
+} VK_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
 
-typedef struct _XGL_DESCRIPTOR_TYPE_COUNT
+typedef struct _VK_DESCRIPTOR_TYPE_COUNT
 {
-    XGL_DESCRIPTOR_TYPE                     type;
+    VK_DESCRIPTOR_TYPE                     type;
     uint32_t                                count;
-} XGL_DESCRIPTOR_TYPE_COUNT;
+} VK_DESCRIPTOR_TYPE_COUNT;
 
-typedef struct _XGL_DESCRIPTOR_POOL_CREATE_INFO
+typedef struct _VK_DESCRIPTOR_POOL_CREATE_INFO
 {
-    XGL_STRUCTURE_TYPE                      sType;              // Must be XGL_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO
+    VK_STRUCTURE_TYPE                      sType;              // Must be VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO
     const void*                             pNext;              // Pointer to next structure
     uint32_t                                count;
-    const XGL_DESCRIPTOR_TYPE_COUNT*        pTypeCount;
-} XGL_DESCRIPTOR_POOL_CREATE_INFO;
+    const VK_DESCRIPTOR_TYPE_COUNT*        pTypeCount;
+} VK_DESCRIPTOR_POOL_CREATE_INFO;
 
-typedef struct _XGL_LINK_CONST_BUFFER
+typedef struct _VK_LINK_CONST_BUFFER
 {
     uint32_t                                    bufferId;
     size_t                                      bufferSize;
     const void*                                 pBufferData;
-} XGL_LINK_CONST_BUFFER;
+} VK_LINK_CONST_BUFFER;
 
-typedef struct _XGL_SPECIALIZATION_MAP_ENTRY
+typedef struct _VK_SPECIALIZATION_MAP_ENTRY
 {
     uint32_t                                constantId;         // The SpecConstant ID specified in the BIL
     uint32_t                                offset;             // Offset of the value in the data block
-} XGL_SPECIALIZATION_MAP_ENTRY;
+} VK_SPECIALIZATION_MAP_ENTRY;
 
-typedef struct _XGL_SPECIALIZATION_INFO
+typedef struct _VK_SPECIALIZATION_INFO
 {
     uint32_t                                mapEntryCount;
-    const XGL_SPECIALIZATION_MAP_ENTRY*     pMap;               // mapEntryCount entries
+    const VK_SPECIALIZATION_MAP_ENTRY*     pMap;               // mapEntryCount entries
     const void*                             pData;
-} XGL_SPECIALIZATION_INFO;
+} VK_SPECIALIZATION_INFO;
 
-typedef struct _XGL_PIPELINE_SHADER
+typedef struct _VK_PIPELINE_SHADER
 {
-    XGL_PIPELINE_SHADER_STAGE               stage;
-    XGL_SHADER                              shader;
+    VK_PIPELINE_SHADER_STAGE               stage;
+    VK_SHADER                              shader;
     uint32_t                                linkConstBufferCount;
-    const XGL_LINK_CONST_BUFFER*            pLinkConstBufferInfo;
-    const XGL_SPECIALIZATION_INFO*          pSpecializationInfo;
-} XGL_PIPELINE_SHADER;
+    const VK_LINK_CONST_BUFFER*            pLinkConstBufferInfo;
+    const VK_SPECIALIZATION_INFO*          pSpecializationInfo;
+} VK_PIPELINE_SHADER;
 
-typedef struct _XGL_COMPUTE_PIPELINE_CREATE_INFO
+typedef struct _VK_COMPUTE_PIPELINE_CREATE_INFO
 {
-    XGL_STRUCTURE_TYPE                      sType;      // Must be XGL_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO
+    VK_STRUCTURE_TYPE                      sType;      // Must be VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO
     const void*                             pNext;      // Pointer to next structure
-    XGL_PIPELINE_SHADER                     cs;
-    XGL_FLAGS                               flags;      // XGL_PIPELINE_CREATE_FLAGS
-    XGL_DESCRIPTOR_SET_LAYOUT_CHAIN         setLayoutChain; // For local size fields zero is treated an invalid value
+    VK_PIPELINE_SHADER                     cs;
+    VK_FLAGS                               flags;      // VK_PIPELINE_CREATE_FLAGS
+    VK_DESCRIPTOR_SET_LAYOUT_CHAIN         setLayoutChain; // For local size fields zero is treated an invalid value
     uint32_t                                localSizeX;
     uint32_t                                localSizeY;
     uint32_t                                localSizeZ;
 
-} XGL_COMPUTE_PIPELINE_CREATE_INFO;
+} VK_COMPUTE_PIPELINE_CREATE_INFO;
 
-typedef struct _XGL_VERTEX_INPUT_BINDING_DESCRIPTION
+typedef struct _VK_VERTEX_INPUT_BINDING_DESCRIPTION
 {
     uint32_t                                binding;        // Vertex buffer binding id
     uint32_t                                strideInBytes;  // Distance between vertices in bytes (0 = no advancement)
 
-    XGL_VERTEX_INPUT_STEP_RATE              stepRate;       // Rate at which binding is incremented
-} XGL_VERTEX_INPUT_BINDING_DESCRIPTION;
+    VK_VERTEX_INPUT_STEP_RATE              stepRate;       // Rate at which binding is incremented
+} VK_VERTEX_INPUT_BINDING_DESCRIPTION;
 
-typedef struct _XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION
+typedef struct _VK_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION
 {
     uint32_t                                location;       // location of the shader vertex attrib
     uint32_t                                binding;        // Vertex buffer binding id
 
-    XGL_FORMAT                              format;         // format of source data
+    VK_FORMAT                              format;         // format of source data
 
     uint32_t                                offsetInBytes;  // Offset of first element in bytes from base of vertex
-} XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION;
+} VK_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION;
 
-typedef struct _XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO
+typedef struct _VK_PIPELINE_VERTEX_INPUT_CREATE_INFO
 {
-    XGL_STRUCTURE_TYPE                            sType;          // Should be XGL_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO
+    VK_STRUCTURE_TYPE                            sType;          // Should be VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO
     const void*                                   pNext;          // Pointer to next structure
 
     uint32_t                                      bindingCount;   // number of bindings
-    const XGL_VERTEX_INPUT_BINDING_DESCRIPTION*   pVertexBindingDescriptions;
+    const VK_VERTEX_INPUT_BINDING_DESCRIPTION*   pVertexBindingDescriptions;
 
     uint32_t                                      attributeCount; // number of attributes
-    const XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* pVertexAttributeDescriptions;
-} XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO;
+    const VK_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* pVertexAttributeDescriptions;
+} VK_PIPELINE_VERTEX_INPUT_CREATE_INFO;
 
-typedef struct _XGL_PIPELINE_IA_STATE_CREATE_INFO
+typedef struct _VK_PIPELINE_IA_STATE_CREATE_INFO
 {
-    XGL_STRUCTURE_TYPE                      sType;      // Must be XGL_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO
+    VK_STRUCTURE_TYPE                      sType;      // Must be VK_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO
     const void*                             pNext;      // Pointer to next structure
-    XGL_PRIMITIVE_TOPOLOGY                  topology;
+    VK_PRIMITIVE_TOPOLOGY                  topology;
     bool32_t                                disableVertexReuse;         // optional
     bool32_t                                primitiveRestartEnable;
     uint32_t                                primitiveRestartIndex;      // optional (GL45)
-} XGL_PIPELINE_IA_STATE_CREATE_INFO;
+} VK_PIPELINE_IA_STATE_CREATE_INFO;
 
-typedef struct _XGL_PIPELINE_TESS_STATE_CREATE_INFO
+typedef struct _VK_PIPELINE_TESS_STATE_CREATE_INFO
 {
-    XGL_STRUCTURE_TYPE                      sType;      // Must be XGL_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO
+    VK_STRUCTURE_TYPE                      sType;      // Must be VK_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO
     const void*                             pNext;      // Pointer to next structure
     uint32_t                                patchControlPoints;
-} XGL_PIPELINE_TESS_STATE_CREATE_INFO;
+} VK_PIPELINE_TESS_STATE_CREATE_INFO;
 
-typedef struct _XGL_PIPELINE_VP_STATE_CREATE_INFO
+typedef struct _VK_PIPELINE_VP_STATE_CREATE_INFO
 {
-    XGL_STRUCTURE_TYPE                      sType;      // Must be XGL_STRUCTURE_TYPE_PIPELINE_VP_STATE_CREATE_INFO
+    VK_STRUCTURE_TYPE                      sType;      // Must be VK_STRUCTURE_TYPE_PIPELINE_VP_STATE_CREATE_INFO
     const void*                             pNext;      // Pointer to next structure
     uint32_t                                numViewports;
-    XGL_COORDINATE_ORIGIN                   clipOrigin;                 // optional (GL45)
-    XGL_DEPTH_MODE                          depthMode;                  // optional (GL45)
-} XGL_PIPELINE_VP_STATE_CREATE_INFO;
+    VK_COORDINATE_ORIGIN                   clipOrigin;                 // optional (GL45)
+    VK_DEPTH_MODE                          depthMode;                  // optional (GL45)
+} VK_PIPELINE_VP_STATE_CREATE_INFO;
 
-typedef struct _XGL_PIPELINE_RS_STATE_CREATE_INFO
+typedef struct _VK_PIPELINE_RS_STATE_CREATE_INFO
 {
-    XGL_STRUCTURE_TYPE                      sType;      // Must be XGL_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO
+    VK_STRUCTURE_TYPE                      sType;      // Must be VK_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO
     const void*                             pNext;      // Pointer to next structure
     bool32_t                                depthClipEnable;
     bool32_t                                rasterizerDiscardEnable;
     bool32_t                                programPointSize;           // optional (GL45)
-    XGL_COORDINATE_ORIGIN                   pointOrigin;                // optional (GL45)
-    XGL_PROVOKING_VERTEX_CONVENTION         provokingVertex;            // optional (GL45)
-    XGL_FILL_MODE                           fillMode;                   // optional (GL45)
-    XGL_CULL_MODE                           cullMode;
-    XGL_FACE_ORIENTATION                    frontFace;
-} XGL_PIPELINE_RS_STATE_CREATE_INFO;
+    VK_COORDINATE_ORIGIN                   pointOrigin;                // optional (GL45)
+    VK_PROVOKING_VERTEX_CONVENTION         provokingVertex;            // optional (GL45)
+    VK_FILL_MODE                           fillMode;                   // optional (GL45)
+    VK_CULL_MODE                           cullMode;
+    VK_FACE_ORIENTATION                    frontFace;
+} VK_PIPELINE_RS_STATE_CREATE_INFO;
 
-typedef struct _XGL_PIPELINE_MS_STATE_CREATE_INFO
+typedef struct _VK_PIPELINE_MS_STATE_CREATE_INFO
 {
-    XGL_STRUCTURE_TYPE                      sType;      // Must be XGL_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO
+    VK_STRUCTURE_TYPE                      sType;      // Must be VK_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO
     const void*                             pNext;      // Pointer to next structure
     uint32_t                                samples;
     bool32_t                                multisampleEnable;          // optional (GL45)
     bool32_t                                sampleShadingEnable;        // optional (GL45)
     float                                   minSampleShading;           // optional (GL45)
-    XGL_SAMPLE_MASK                         sampleMask;
-} XGL_PIPELINE_MS_STATE_CREATE_INFO;
+    VK_SAMPLE_MASK                         sampleMask;
+} VK_PIPELINE_MS_STATE_CREATE_INFO;
 
-typedef struct _XGL_PIPELINE_CB_ATTACHMENT_STATE
+typedef struct _VK_PIPELINE_CB_ATTACHMENT_STATE
 {
     bool32_t                                blendEnable;
-    XGL_FORMAT                              format;
-    XGL_BLEND                               srcBlendColor;
-    XGL_BLEND                               destBlendColor;
-    XGL_BLEND_FUNC                          blendFuncColor;
-    XGL_BLEND                               srcBlendAlpha;
-    XGL_BLEND                               destBlendAlpha;
-    XGL_BLEND_FUNC                          blendFuncAlpha;
+    VK_FORMAT                              format;
+    VK_BLEND                               srcBlendColor;
+    VK_BLEND                               destBlendColor;
+    VK_BLEND_FUNC                          blendFuncColor;
+    VK_BLEND                               srcBlendAlpha;
+    VK_BLEND                               destBlendAlpha;
+    VK_BLEND_FUNC                          blendFuncAlpha;
     uint8_t                                 channelWriteMask;
-} XGL_PIPELINE_CB_ATTACHMENT_STATE;
+} VK_PIPELINE_CB_ATTACHMENT_STATE;
 
-typedef struct _XGL_PIPELINE_CB_STATE_CREATE_INFO
+typedef struct _VK_PIPELINE_CB_STATE_CREATE_INFO
 {
-    XGL_STRUCTURE_TYPE                      sType;      // Must be XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO
+    VK_STRUCTURE_TYPE                      sType;      // Must be VK_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO
     const void*                             pNext;      // Pointer to next structure
     bool32_t                                alphaToCoverageEnable;
     bool32_t                                logicOpEnable;
-    XGL_LOGIC_OP                            logicOp;
+    VK_LOGIC_OP                            logicOp;
     uint32_t                                attachmentCount;    // # of pAttachments
-    const XGL_PIPELINE_CB_ATTACHMENT_STATE* pAttachments;
-} XGL_PIPELINE_CB_STATE_CREATE_INFO;
+    const VK_PIPELINE_CB_ATTACHMENT_STATE* pAttachments;
+} VK_PIPELINE_CB_STATE_CREATE_INFO;
 
-typedef struct _XGL_STENCIL_OP_STATE
+typedef struct _VK_STENCIL_OP_STATE
 {
-    XGL_STENCIL_OP                          stencilFailOp;
-    XGL_STENCIL_OP                          stencilPassOp;
-    XGL_STENCIL_OP                          stencilDepthFailOp;
-    XGL_COMPARE_FUNC                        stencilFunc;
-} XGL_STENCIL_OP_STATE;
+    VK_STENCIL_OP                          stencilFailOp;
+    VK_STENCIL_OP                          stencilPassOp;
+    VK_STENCIL_OP                          stencilDepthFailOp;
+    VK_COMPARE_FUNC                        stencilFunc;
+} VK_STENCIL_OP_STATE;
 
-typedef struct _XGL_PIPELINE_DS_STATE_CREATE_INFO
+typedef struct _VK_PIPELINE_DS_STATE_CREATE_INFO
 {
-    XGL_STRUCTURE_TYPE                      sType;      // Must be XGL_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO
+    VK_STRUCTURE_TYPE                      sType;      // Must be VK_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO
     const void*                             pNext;      // Pointer to next structure
-    XGL_FORMAT                              format;
+    VK_FORMAT                              format;
     bool32_t                                depthTestEnable;
     bool32_t                                depthWriteEnable;
-    XGL_COMPARE_FUNC                        depthFunc;
+    VK_COMPARE_FUNC                        depthFunc;
     bool32_t                                depthBoundsEnable;          // optional (depth_bounds_test)
     bool32_t                                stencilTestEnable;
-    XGL_STENCIL_OP_STATE                    front;
-    XGL_STENCIL_OP_STATE                    back;
-} XGL_PIPELINE_DS_STATE_CREATE_INFO;
+    VK_STENCIL_OP_STATE                    front;
+    VK_STENCIL_OP_STATE                    back;
+} VK_PIPELINE_DS_STATE_CREATE_INFO;
 
-typedef struct _XGL_PIPELINE_SHADER_STAGE_CREATE_INFO
+typedef struct _VK_PIPELINE_SHADER_STAGE_CREATE_INFO
 {
-    XGL_STRUCTURE_TYPE                      sType;      // Must be XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO
+    VK_STRUCTURE_TYPE                      sType;      // Must be VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO
     const void*                             pNext;      // Pointer to next structure
-    XGL_PIPELINE_SHADER                     shader;
-} XGL_PIPELINE_SHADER_STAGE_CREATE_INFO;
+    VK_PIPELINE_SHADER                     shader;
+} VK_PIPELINE_SHADER_STAGE_CREATE_INFO;
 
-typedef struct _XGL_GRAPHICS_PIPELINE_CREATE_INFO
+typedef struct _VK_GRAPHICS_PIPELINE_CREATE_INFO
 {
-    XGL_STRUCTURE_TYPE                      sType;      // Must be XGL_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO
+    VK_STRUCTURE_TYPE                      sType;      // Must be VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO
     const void*                             pNext;      // Pointer to next structure
-    XGL_FLAGS                               flags;      // XGL_PIPELINE_CREATE_FLAGS
-    XGL_DESCRIPTOR_SET_LAYOUT_CHAIN         pSetLayoutChain;
-} XGL_GRAPHICS_PIPELINE_CREATE_INFO;
+    VK_FLAGS                               flags;      // VK_PIPELINE_CREATE_FLAGS
+    VK_DESCRIPTOR_SET_LAYOUT_CHAIN         pSetLayoutChain;
+} VK_GRAPHICS_PIPELINE_CREATE_INFO;
 
-typedef struct _XGL_SAMPLER_CREATE_INFO
+typedef struct _VK_SAMPLER_CREATE_INFO
 {
-    XGL_STRUCTURE_TYPE                      sType;          // Must be XGL_STRUCTURE_TYPE_SAMPLER_CREATE_INFO
+    VK_STRUCTURE_TYPE                      sType;          // Must be VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO
     const void*                             pNext;          // Pointer to next structure
-    XGL_TEX_FILTER                          magFilter;      // Filter mode for magnification
-    XGL_TEX_FILTER                          minFilter;      // Filter mode for minifiation
-    XGL_TEX_MIPMAP_MODE                     mipMode;        // Mipmap selection mode
-    XGL_TEX_ADDRESS                         addressU;
-    XGL_TEX_ADDRESS                         addressV;
-    XGL_TEX_ADDRESS                         addressW;
+    VK_TEX_FILTER                          magFilter;      // Filter mode for magnification
+    VK_TEX_FILTER                          minFilter;      // Filter mode for minifiation
+    VK_TEX_MIPMAP_MODE                     mipMode;        // Mipmap selection mode
+    VK_TEX_ADDRESS                         addressU;
+    VK_TEX_ADDRESS                         addressV;
+    VK_TEX_ADDRESS                         addressW;
     float                                   mipLodBias;
     uint32_t                                maxAnisotropy;
-    XGL_COMPARE_FUNC                        compareFunc;
+    VK_COMPARE_FUNC                        compareFunc;
     float                                   minLod;
     float                                   maxLod;
-    XGL_BORDER_COLOR_TYPE                   borderColorType;
-} XGL_SAMPLER_CREATE_INFO;
+    VK_BORDER_COLOR_TYPE                   borderColorType;
+} VK_SAMPLER_CREATE_INFO;
 
-typedef struct _XGL_DYNAMIC_VP_STATE_CREATE_INFO
+typedef struct _VK_DYNAMIC_VP_STATE_CREATE_INFO
 {
-    XGL_STRUCTURE_TYPE                      sType;      // Must be XGL_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO
+    VK_STRUCTURE_TYPE                      sType;      // Must be VK_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO
     const void*                             pNext;      // Pointer to next structure
     uint32_t                                viewportAndScissorCount;  // number of entries in pViewports and pScissors
-    const XGL_VIEWPORT*                     pViewports;
-    const XGL_RECT*                         pScissors;
-} XGL_DYNAMIC_VP_STATE_CREATE_INFO;
+    const VK_VIEWPORT*                     pViewports;
+    const VK_RECT*                         pScissors;
+} VK_DYNAMIC_VP_STATE_CREATE_INFO;
 
-typedef struct _XGL_DYNAMIC_RS_STATE_CREATE_INFO
+typedef struct _VK_DYNAMIC_RS_STATE_CREATE_INFO
 {
-    XGL_STRUCTURE_TYPE                      sType;      // Must be XGL_STRUCTURE_TYPE_DYNAMIC_RS_STATE_CREATE_INFO
+    VK_STRUCTURE_TYPE                      sType;      // Must be VK_STRUCTURE_TYPE_DYNAMIC_RS_STATE_CREATE_INFO
     const void*                             pNext;      // Pointer to next structure
     float                                   depthBias;
     float                                   depthBiasClamp;
@@ -2082,18 +2082,18 @@
     float                                   pointSize;          // optional (GL45) - Size of points
     float                                   pointFadeThreshold; // optional (GL45) - Size of point fade threshold
     float                                   lineWidth;          // optional (GL45) - Width of lines
-} XGL_DYNAMIC_RS_STATE_CREATE_INFO;
+} VK_DYNAMIC_RS_STATE_CREATE_INFO;
 
-typedef struct _XGL_DYNAMIC_CB_STATE_CREATE_INFO
+typedef struct _VK_DYNAMIC_CB_STATE_CREATE_INFO
 {
-    XGL_STRUCTURE_TYPE                      sType;      // Must be XGL_STRUCTURE_TYPE_DYNAMIC_CB_STATE_CREATE_INFO
+    VK_STRUCTURE_TYPE                      sType;      // Must be VK_STRUCTURE_TYPE_DYNAMIC_CB_STATE_CREATE_INFO
     const void*                             pNext;      // Pointer to next structure
     float                                   blendConst[4];
-} XGL_DYNAMIC_CB_STATE_CREATE_INFO;
+} VK_DYNAMIC_CB_STATE_CREATE_INFO;
 
-typedef struct _XGL_DYNAMIC_DS_STATE_CREATE_INFO
+typedef struct _VK_DYNAMIC_DS_STATE_CREATE_INFO
 {
-    XGL_STRUCTURE_TYPE                      sType;      // Must be XGL_STRUCTURE_TYPE_DYNAMIC_DS_STATE_CREATE_INFO
+    VK_STRUCTURE_TYPE                      sType;      // Must be VK_STRUCTURE_TYPE_DYNAMIC_DS_STATE_CREATE_INFO
     const void*                             pNext;      // Pointer to next structure
     float                                   minDepth;               // optional (depth_bounds_test)
     float                                   maxDepth;               // optional (depth_bounds_test)
@@ -2101,106 +2101,106 @@
     uint32_t                                stencilWriteMask;
     uint32_t                                stencilFrontRef;
     uint32_t                                stencilBackRef;
-} XGL_DYNAMIC_DS_STATE_CREATE_INFO;
+} VK_DYNAMIC_DS_STATE_CREATE_INFO;
 
-typedef struct _XGL_CMD_BUFFER_CREATE_INFO
+typedef struct _VK_CMD_BUFFER_CREATE_INFO
 {
-    XGL_STRUCTURE_TYPE                      sType;      // Must be XGL_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO
+    VK_STRUCTURE_TYPE                      sType;      // Must be VK_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO
     const void*                             pNext;      // Pointer to next structure
     uint32_t                                queueNodeIndex;
-    XGL_FLAGS                               flags;
-} XGL_CMD_BUFFER_CREATE_INFO;
+    VK_FLAGS                               flags;
+} VK_CMD_BUFFER_CREATE_INFO;
 
-typedef struct _XGL_CMD_BUFFER_BEGIN_INFO
+typedef struct _VK_CMD_BUFFER_BEGIN_INFO
 {
-    XGL_STRUCTURE_TYPE                      sType;      // Must be XGL_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO
+    VK_STRUCTURE_TYPE                      sType;      // Must be VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO
     const void*                             pNext;      // Pointer to next structure
 
-    XGL_FLAGS                               flags;      // XGL_CMD_BUFFER_BUILD_FLAGS
-} XGL_CMD_BUFFER_BEGIN_INFO;
+    VK_FLAGS                               flags;      // VK_CMD_BUFFER_BUILD_FLAGS
+} VK_CMD_BUFFER_BEGIN_INFO;
 
-typedef struct _XGL_RENDER_PASS_BEGIN
+typedef struct _VK_RENDER_PASS_BEGIN
 {
-    XGL_RENDER_PASS                         renderPass;
-    XGL_FRAMEBUFFER                         framebuffer;
-} XGL_RENDER_PASS_BEGIN;
+    VK_RENDER_PASS                         renderPass;
+    VK_FRAMEBUFFER                         framebuffer;
+} VK_RENDER_PASS_BEGIN;
 
-typedef struct _XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO
+typedef struct _VK_CMD_BUFFER_GRAPHICS_BEGIN_INFO
 {
-    XGL_STRUCTURE_TYPE                      sType;      // Must be XGL_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO
+    VK_STRUCTURE_TYPE                      sType;      // Must be VK_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO
     const void*                             pNext;      // Pointer to next structure
 
-    XGL_RENDER_PASS_BEGIN                   renderPassContinue;  // Only needed when a render pass is split across two command buffers
-} XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO;
+    VK_RENDER_PASS_BEGIN                   renderPassContinue;  // Only needed when a render pass is split across two command buffers
+} VK_CMD_BUFFER_GRAPHICS_BEGIN_INFO;
 
 // Union allowing specification of floating point or raw color data. Actual value selected is based on image being cleared.
-typedef union _XGL_CLEAR_COLOR_VALUE
+typedef union _VK_CLEAR_COLOR_VALUE
 {
     float                                   floatColor[4];
     uint32_t                                rawColor[4];
-} XGL_CLEAR_COLOR_VALUE;
+} VK_CLEAR_COLOR_VALUE;
 
-typedef struct _XGL_CLEAR_COLOR
+typedef struct _VK_CLEAR_COLOR
 {
-    XGL_CLEAR_COLOR_VALUE                   color;
+    VK_CLEAR_COLOR_VALUE                   color;
     bool32_t                                useRawValue;
-} XGL_CLEAR_COLOR;
+} VK_CLEAR_COLOR;
 
-typedef struct _XGL_RENDER_PASS_CREATE_INFO
+typedef struct _VK_RENDER_PASS_CREATE_INFO
 {
-    XGL_STRUCTURE_TYPE                      sType;      // Must be XGL_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO
+    VK_STRUCTURE_TYPE                      sType;      // Must be VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO
     const void*                             pNext;      // Pointer to next structure
 
-    XGL_RECT                                renderArea;
+    VK_RECT                                renderArea;
     uint32_t                                colorAttachmentCount;
-    XGL_EXTENT2D                            extent;
+    VK_EXTENT2D                            extent;
     uint32_t                                sampleCount;
     uint32_t                                layers;
-    const XGL_FORMAT*                       pColorFormats;
-    const XGL_IMAGE_LAYOUT*                 pColorLayouts;
-    const XGL_ATTACHMENT_LOAD_OP*           pColorLoadOps;
-    const XGL_ATTACHMENT_STORE_OP*          pColorStoreOps;
-    const XGL_CLEAR_COLOR*                  pColorLoadClearValues;
-    XGL_FORMAT                              depthStencilFormat;
-    XGL_IMAGE_LAYOUT                        depthStencilLayout;
-    XGL_ATTACHMENT_LOAD_OP                  depthLoadOp;
+    const VK_FORMAT*                       pColorFormats;
+    const VK_IMAGE_LAYOUT*                 pColorLayouts;
+    const VK_ATTACHMENT_LOAD_OP*           pColorLoadOps;
+    const VK_ATTACHMENT_STORE_OP*          pColorStoreOps;
+    const VK_CLEAR_COLOR*                  pColorLoadClearValues;
+    VK_FORMAT                              depthStencilFormat;
+    VK_IMAGE_LAYOUT                        depthStencilLayout;
+    VK_ATTACHMENT_LOAD_OP                  depthLoadOp;
     float                                   depthLoadClearValue;
-    XGL_ATTACHMENT_STORE_OP                 depthStoreOp;
-    XGL_ATTACHMENT_LOAD_OP                  stencilLoadOp;
+    VK_ATTACHMENT_STORE_OP                 depthStoreOp;
+    VK_ATTACHMENT_LOAD_OP                  stencilLoadOp;
     uint32_t                                stencilLoadClearValue;
-    XGL_ATTACHMENT_STORE_OP                 stencilStoreOp;
-} XGL_RENDER_PASS_CREATE_INFO;
+    VK_ATTACHMENT_STORE_OP                 stencilStoreOp;
+} VK_RENDER_PASS_CREATE_INFO;
 
-typedef struct _XGL_EVENT_CREATE_INFO
+typedef struct _VK_EVENT_CREATE_INFO
 {
-    XGL_STRUCTURE_TYPE                      sType;      // Must be XGL_STRUCTURE_TYPE_EVENT_CREATE_INFO
+    VK_STRUCTURE_TYPE                      sType;      // Must be VK_STRUCTURE_TYPE_EVENT_CREATE_INFO
     const void*                             pNext;      // Pointer to next structure
-    XGL_FLAGS                               flags;      // Reserved
-} XGL_EVENT_CREATE_INFO;
+    VK_FLAGS                               flags;      // Reserved
+} VK_EVENT_CREATE_INFO;
 
-typedef struct _XGL_FENCE_CREATE_INFO
+typedef struct _VK_FENCE_CREATE_INFO
 {
-    XGL_STRUCTURE_TYPE                      sType;      // Must be XGL_STRUCTURE_TYPE_FENCE_CREATE_INFO
+    VK_STRUCTURE_TYPE                      sType;      // Must be VK_STRUCTURE_TYPE_FENCE_CREATE_INFO
     const void*                             pNext;      // Pointer to next structure
-    XGL_FENCE_CREATE_FLAGS                  flags;      // XGL_FENCE_CREATE_FLAGS
-} XGL_FENCE_CREATE_INFO;
+    VK_FENCE_CREATE_FLAGS                  flags;      // VK_FENCE_CREATE_FLAGS
+} VK_FENCE_CREATE_INFO;
 
-typedef struct _XGL_SEMAPHORE_CREATE_INFO
+typedef struct _VK_SEMAPHORE_CREATE_INFO
 {
-    XGL_STRUCTURE_TYPE                      sType;      // Must be XGL_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO
+    VK_STRUCTURE_TYPE                      sType;      // Must be VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO
     const void*                             pNext;      // Pointer to next structure
     uint32_t                                initialCount;
-    XGL_FLAGS                               flags;      // XGL_SEMAPHORE_CREATE_FLAGS
-} XGL_SEMAPHORE_CREATE_INFO;
+    VK_FLAGS                               flags;      // VK_SEMAPHORE_CREATE_FLAGS
+} VK_SEMAPHORE_CREATE_INFO;
 
-typedef struct _XGL_SEMAPHORE_OPEN_INFO
+typedef struct _VK_SEMAPHORE_OPEN_INFO
 {
-    XGL_STRUCTURE_TYPE                      sType;      // Must be XGL_STRUCTURE_TYPE_SEMAPHORE_OPEN_INFO
+    VK_STRUCTURE_TYPE                      sType;      // Must be VK_STRUCTURE_TYPE_SEMAPHORE_OPEN_INFO
     const void*                             pNext;      // Pointer to next structure
-    XGL_SEMAPHORE                           sharedSemaphore;
-} XGL_SEMAPHORE_OPEN_INFO;
+    VK_SEMAPHORE                           sharedSemaphore;
+} VK_SEMAPHORE_OPEN_INFO;
 
-typedef struct _XGL_PIPELINE_STATISTICS_DATA
+typedef struct _VK_PIPELINE_STATISTICS_DATA
 {
     uint64_t                                fsInvocations;            // Fragment shader invocations
     uint64_t                                cPrimitives;              // Clipper primitives
@@ -2213,219 +2213,219 @@
     uint64_t                                tcsInvocations;           // Tessellation control shader invocations
     uint64_t                                tesInvocations;           // Tessellation evaluation shader invocations
     uint64_t                                csInvocations;            // Compute shader invocations
-} XGL_PIPELINE_STATISTICS_DATA;
+} VK_PIPELINE_STATISTICS_DATA;
 
-typedef struct _XGL_QUERY_POOL_CREATE_INFO
+typedef struct _VK_QUERY_POOL_CREATE_INFO
 {
-    XGL_STRUCTURE_TYPE                      sType;      // Must be XGL_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO
+    VK_STRUCTURE_TYPE                      sType;      // Must be VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO
     const void*                             pNext;      // Pointer to next structure
-    XGL_QUERY_TYPE                          queryType;
+    VK_QUERY_TYPE                          queryType;
     uint32_t                                slots;
-} XGL_QUERY_POOL_CREATE_INFO;
+} VK_QUERY_POOL_CREATE_INFO;
 
-typedef struct _XGL_FRAMEBUFFER_CREATE_INFO
+typedef struct _VK_FRAMEBUFFER_CREATE_INFO
 {
-    XGL_STRUCTURE_TYPE                      sType;  // Must be XGL_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO
+    VK_STRUCTURE_TYPE                      sType;  // Must be VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO
     const void*                             pNext;  // Pointer to next structure
 
     uint32_t                                colorAttachmentCount;
-    const XGL_COLOR_ATTACHMENT_BIND_INFO*   pColorAttachments;
-    const XGL_DEPTH_STENCIL_BIND_INFO*      pDepthStencilAttachment;
+    const VK_COLOR_ATTACHMENT_BIND_INFO*   pColorAttachments;
+    const VK_DEPTH_STENCIL_BIND_INFO*      pDepthStencilAttachment;
 
     uint32_t                                sampleCount;
     uint32_t                                width;
     uint32_t                                height;
     uint32_t                                layers;
-} XGL_FRAMEBUFFER_CREATE_INFO;
+} VK_FRAMEBUFFER_CREATE_INFO;
 
-typedef struct _XGL_DRAW_INDIRECT_CMD
+typedef struct _VK_DRAW_INDIRECT_CMD
 {
     uint32_t                                vertexCount;
     uint32_t                                instanceCount;
     uint32_t                                firstVertex;
     uint32_t                                firstInstance;
-} XGL_DRAW_INDIRECT_CMD;
+} VK_DRAW_INDIRECT_CMD;
 
-typedef struct _XGL_DRAW_INDEXED_INDIRECT_CMD
+typedef struct _VK_DRAW_INDEXED_INDIRECT_CMD
 {
     uint32_t                                indexCount;
     uint32_t                                instanceCount;
     uint32_t                                firstIndex;
     int32_t                                 vertexOffset;
     uint32_t                                firstInstance;
-} XGL_DRAW_INDEXED_INDIRECT_CMD;
+} VK_DRAW_INDEXED_INDIRECT_CMD;
 
-typedef struct _XGL_DISPATCH_INDIRECT_CMD
+typedef struct _VK_DISPATCH_INDIRECT_CMD
 {
     uint32_t   x;
     uint32_t   y;
     uint32_t   z;
-} XGL_DISPATCH_INDIRECT_CMD;
+} VK_DISPATCH_INDIRECT_CMD;
 
 // ------------------------------------------------------------------------------------------------
 // API functions
-typedef XGL_RESULT (XGLAPI *xglCreateInstanceType)(const XGL_INSTANCE_CREATE_INFO* pCreateInfo, XGL_INSTANCE* pInstance);
-typedef XGL_RESULT (XGLAPI *xglDestroyInstanceType)(XGL_INSTANCE instance);
-typedef XGL_RESULT (XGLAPI *xglEnumerateGpusType)(XGL_INSTANCE instance, uint32_t maxGpus, uint32_t* pGpuCount, XGL_PHYSICAL_GPU* pGpus);
-typedef XGL_RESULT (XGLAPI *xglGetGpuInfoType)(XGL_PHYSICAL_GPU gpu, XGL_PHYSICAL_GPU_INFO_TYPE infoType, size_t* pDataSize, void* pData);
-typedef void *     (XGLAPI *xglGetProcAddrType)(XGL_PHYSICAL_GPU gpu, const char * pName);
-typedef XGL_RESULT (XGLAPI *xglCreateDeviceType)(XGL_PHYSICAL_GPU gpu, const XGL_DEVICE_CREATE_INFO* pCreateInfo, XGL_DEVICE* pDevice);
-typedef XGL_RESULT (XGLAPI *xglDestroyDeviceType)(XGL_DEVICE device);
-typedef XGL_RESULT (XGLAPI *xglGetExtensionSupportType)(XGL_PHYSICAL_GPU gpu, const char* pExtName);
-typedef XGL_RESULT (XGLAPI *xglEnumerateLayersType)(XGL_PHYSICAL_GPU gpu, size_t maxLayerCount, size_t maxStringSize, size_t* pOutLayerCount, char* const* pOutLayers, void* pReserved);
-typedef XGL_RESULT (XGLAPI *xglGetDeviceQueueType)(XGL_DEVICE device, uint32_t queueNodeIndex, uint32_t queueIndex, XGL_QUEUE* pQueue);
-typedef XGL_RESULT (XGLAPI *xglQueueSubmitType)(XGL_QUEUE queue, uint32_t cmdBufferCount, const XGL_CMD_BUFFER* pCmdBuffers, XGL_FENCE fence);
-typedef XGL_RESULT (XGLAPI *xglQueueAddMemReferenceType)(XGL_QUEUE queue, XGL_GPU_MEMORY mem);
-typedef XGL_RESULT (XGLAPI *xglQueueRemoveMemReferenceType)(XGL_QUEUE queue, XGL_GPU_MEMORY mem);
-typedef XGL_RESULT (XGLAPI *xglQueueWaitIdleType)(XGL_QUEUE queue);
-typedef XGL_RESULT (XGLAPI *xglDeviceWaitIdleType)(XGL_DEVICE device);
-typedef XGL_RESULT (XGLAPI *xglAllocMemoryType)(XGL_DEVICE device, const XGL_MEMORY_ALLOC_INFO* pAllocInfo, XGL_GPU_MEMORY* pMem);
-typedef XGL_RESULT (XGLAPI *xglFreeMemoryType)(XGL_GPU_MEMORY mem);
-typedef XGL_RESULT (XGLAPI *xglSetMemoryPriorityType)(XGL_GPU_MEMORY mem, XGL_MEMORY_PRIORITY priority);
-typedef XGL_RESULT (XGLAPI *xglMapMemoryType)(XGL_GPU_MEMORY mem, XGL_FLAGS flags, void** ppData);
-typedef XGL_RESULT (XGLAPI *xglUnmapMemoryType)(XGL_GPU_MEMORY mem);
-typedef XGL_RESULT (XGLAPI *xglPinSystemMemoryType)(XGL_DEVICE device, const void* pSysMem, size_t memSize, XGL_GPU_MEMORY* pMem);
-typedef XGL_RESULT (XGLAPI *xglGetMultiGpuCompatibilityType)(XGL_PHYSICAL_GPU gpu0, XGL_PHYSICAL_GPU gpu1, XGL_GPU_COMPATIBILITY_INFO* pInfo);
-typedef XGL_RESULT (XGLAPI *xglOpenSharedMemoryType)(XGL_DEVICE device, const XGL_MEMORY_OPEN_INFO* pOpenInfo, XGL_GPU_MEMORY* pMem);
-typedef XGL_RESULT (XGLAPI *xglOpenSharedSemaphoreType)(XGL_DEVICE device, const XGL_SEMAPHORE_OPEN_INFO* pOpenInfo, XGL_SEMAPHORE* pSemaphore);
-typedef XGL_RESULT (XGLAPI *xglOpenPeerMemoryType)(XGL_DEVICE device, const XGL_PEER_MEMORY_OPEN_INFO* pOpenInfo, XGL_GPU_MEMORY* pMem);
-typedef XGL_RESULT (XGLAPI *xglOpenPeerImageType)(XGL_DEVICE device, const XGL_PEER_IMAGE_OPEN_INFO* pOpenInfo, XGL_IMAGE* pImage, XGL_GPU_MEMORY* pMem);
-typedef XGL_RESULT (XGLAPI *xglDestroyObjectType)(XGL_OBJECT object);
-typedef XGL_RESULT (XGLAPI *xglGetObjectInfoType)(XGL_BASE_OBJECT object, XGL_OBJECT_INFO_TYPE infoType, size_t* pDataSize, void* pData);
-typedef XGL_RESULT (XGLAPI *xglBindObjectMemoryType)(XGL_OBJECT object, uint32_t allocationIdx, XGL_GPU_MEMORY mem, XGL_GPU_SIZE offset);
-typedef XGL_RESULT (XGLAPI *xglBindObjectMemoryRangeType)(XGL_OBJECT object, uint32_t allocationIdx, XGL_GPU_SIZE rangeOffset,XGL_GPU_SIZE rangeSize, XGL_GPU_MEMORY mem, XGL_GPU_SIZE memOffset);
-typedef XGL_RESULT (XGLAPI *xglBindImageMemoryRangeType)(XGL_IMAGE image, uint32_t allocationIdx, const XGL_IMAGE_MEMORY_BIND_INFO* bindInfo, XGL_GPU_MEMORY mem, XGL_GPU_SIZE memOffset);
-typedef XGL_RESULT (XGLAPI *xglCreateFenceType)(XGL_DEVICE device, const XGL_FENCE_CREATE_INFO* pCreateInfo, XGL_FENCE* pFence);
-typedef XGL_RESULT (XGLAPI *xglResetFencesType)(XGL_DEVICE device, uint32_t fenceCount, XGL_FENCE* pFences);
-typedef XGL_RESULT (XGLAPI *xglGetFenceStatusType)(XGL_FENCE fence);
-typedef XGL_RESULT (XGLAPI *xglWaitForFencesType)(XGL_DEVICE device, uint32_t fenceCount, const XGL_FENCE* pFences, bool32_t waitAll, uint64_t timeout);
-typedef XGL_RESULT (XGLAPI *xglCreateSemaphoreType)(XGL_DEVICE device, const XGL_SEMAPHORE_CREATE_INFO* pCreateInfo, XGL_SEMAPHORE* pSemaphore);
-typedef XGL_RESULT (XGLAPI *xglQueueSignalSemaphoreType)(XGL_QUEUE queue, XGL_SEMAPHORE semaphore);
-typedef XGL_RESULT (XGLAPI *xglQueueWaitSemaphoreType)(XGL_QUEUE queue, XGL_SEMAPHORE semaphore);
-typedef XGL_RESULT (XGLAPI *xglCreateEventType)(XGL_DEVICE device, const XGL_EVENT_CREATE_INFO* pCreateInfo, XGL_EVENT* pEvent);
-typedef XGL_RESULT (XGLAPI *xglGetEventStatusType)(XGL_EVENT event);
-typedef XGL_RESULT (XGLAPI *xglSetEventType)(XGL_EVENT event);
-typedef XGL_RESULT (XGLAPI *xglResetEventType)(XGL_EVENT event);
-typedef XGL_RESULT (XGLAPI *xglCreateQueryPoolType)(XGL_DEVICE device, const XGL_QUERY_POOL_CREATE_INFO* pCreateInfo, XGL_QUERY_POOL* pQueryPool);
-typedef XGL_RESULT (XGLAPI *xglGetQueryPoolResultsType)(XGL_QUERY_POOL queryPool, uint32_t startQuery, uint32_t queryCount, size_t* pDataSize, void* pData);
-typedef XGL_RESULT (XGLAPI *xglGetFormatInfoType)(XGL_DEVICE device, XGL_FORMAT format, XGL_FORMAT_INFO_TYPE infoType, size_t* pDataSize, void* pData);
-typedef XGL_RESULT (XGLAPI *xglCreateBufferType)(XGL_DEVICE device, const XGL_BUFFER_CREATE_INFO* pCreateInfo, XGL_BUFFER* pBuffer);
-typedef XGL_RESULT (XGLAPI *xglCreateBufferViewType)(XGL_DEVICE device, const XGL_BUFFER_VIEW_CREATE_INFO* pCreateInfo, XGL_BUFFER_VIEW* pView);
-typedef XGL_RESULT (XGLAPI *xglCreateImageType)(XGL_DEVICE device, const XGL_IMAGE_CREATE_INFO* pCreateInfo, XGL_IMAGE* pImage);
-typedef XGL_RESULT (XGLAPI *xglGetImageSubresourceInfoType)(XGL_IMAGE image, const XGL_IMAGE_SUBRESOURCE* pSubresource, XGL_SUBRESOURCE_INFO_TYPE infoType, size_t* pDataSize, void* pData);
-typedef XGL_RESULT (XGLAPI *xglCreateImageViewType)(XGL_DEVICE device, const XGL_IMAGE_VIEW_CREATE_INFO* pCreateInfo, XGL_IMAGE_VIEW* pView);
-typedef XGL_RESULT (XGLAPI *xglCreateColorAttachmentViewType)(XGL_DEVICE device, const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pCreateInfo, XGL_COLOR_ATTACHMENT_VIEW* pView);
-typedef XGL_RESULT (XGLAPI *xglCreateDepthStencilViewType)(XGL_DEVICE device, const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pCreateInfo, XGL_DEPTH_STENCIL_VIEW* pView);
-typedef XGL_RESULT (XGLAPI *xglCreateShaderType)(XGL_DEVICE device, const XGL_SHADER_CREATE_INFO* pCreateInfo, XGL_SHADER* pShader);
-typedef XGL_RESULT (XGLAPI *xglCreateGraphicsPipelineType)(XGL_DEVICE device, const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo, XGL_PIPELINE* pPipeline);
-typedef XGL_RESULT (XGLAPI *xglCreateGraphicsPipelineDerivativeType)(XGL_DEVICE device, const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo, XGL_PIPELINE basePipeline, XGL_PIPELINE* pPipeline);
-typedef XGL_RESULT (XGLAPI *xglCreateComputePipelineType)(XGL_DEVICE device, const XGL_COMPUTE_PIPELINE_CREATE_INFO* pCreateInfo, XGL_PIPELINE* pPipeline);
-typedef XGL_RESULT (XGLAPI *xglStorePipelineType)(XGL_PIPELINE pipeline, size_t* pDataSize, void* pData);
-typedef XGL_RESULT (XGLAPI *xglLoadPipelineType)(XGL_DEVICE device, size_t dataSize, const void* pData, XGL_PIPELINE* pPipeline);
-typedef XGL_RESULT (XGLAPI *xglLoadPipelineDerivativeType)(XGL_DEVICE device, size_t dataSize, const void* pData, XGL_PIPELINE basePipeline, XGL_PIPELINE* pPipeline);
-typedef XGL_RESULT (XGLAPI *xglCreateSamplerType)(XGL_DEVICE device, const XGL_SAMPLER_CREATE_INFO* pCreateInfo, XGL_SAMPLER* pSampler);
-typedef XGL_RESULT (XGLAPI *xglCreateDescriptorSetLayoutType)(XGL_DEVICE device, const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pCreateInfo, XGL_DESCRIPTOR_SET_LAYOUT* pSetLayout);
-typedef XGL_RESULT (XGLAPI *xglCreateDescriptorSetLayoutChainType)(XGL_DEVICE device, uint32_t setLayoutArrayCount, const XGL_DESCRIPTOR_SET_LAYOUT* pSetLayoutArray, XGL_DESCRIPTOR_SET_LAYOUT_CHAIN* pLayoutChain);
-typedef XGL_RESULT (XGLAPI *xglBeginDescriptorPoolUpdateType)(XGL_DEVICE device, XGL_DESCRIPTOR_UPDATE_MODE updateMode);
-typedef XGL_RESULT (XGLAPI *xglEndDescriptorPoolUpdateType)(XGL_DEVICE device, XGL_CMD_BUFFER cmd);
-typedef XGL_RESULT (XGLAPI *xglCreateDescriptorPoolType)(XGL_DEVICE device, XGL_DESCRIPTOR_POOL_USAGE poolUsage, uint32_t maxSets, const XGL_DESCRIPTOR_POOL_CREATE_INFO* pCreateInfo, XGL_DESCRIPTOR_POOL* pDescriptorPool);
-typedef XGL_RESULT (XGLAPI *xglResetDescriptorPoolType)(XGL_DESCRIPTOR_POOL descriptorPool);
-typedef XGL_RESULT (XGLAPI *xglAllocDescriptorSetsType)(XGL_DESCRIPTOR_POOL descriptorPool, XGL_DESCRIPTOR_SET_USAGE setUsage, uint32_t count, const XGL_DESCRIPTOR_SET_LAYOUT* pSetLayouts, XGL_DESCRIPTOR_SET* pDescriptorSets, uint32_t* pCount);
-typedef void       (XGLAPI *xglClearDescriptorSetsType)(XGL_DESCRIPTOR_POOL descriptorPool, uint32_t count, const XGL_DESCRIPTOR_SET* pDescriptorSets);
-typedef void       (XGLAPI *xglUpdateDescriptorsType)(XGL_DESCRIPTOR_SET descriptorSet, uint32_t updateCount, const void** ppUpdateArray);
-typedef XGL_RESULT (XGLAPI *xglCreateDynamicViewportStateType)(XGL_DEVICE device, const XGL_DYNAMIC_VP_STATE_CREATE_INFO* pCreateInfo, XGL_DYNAMIC_VP_STATE_OBJECT* pState);
-typedef XGL_RESULT (XGLAPI *xglCreateDynamicRasterStateType)(XGL_DEVICE device, const XGL_DYNAMIC_RS_STATE_CREATE_INFO* pCreateInfo, XGL_DYNAMIC_RS_STATE_OBJECT* pState);
-typedef XGL_RESULT (XGLAPI *xglCreateDynamicColorBlendStateType)(XGL_DEVICE device, const XGL_DYNAMIC_CB_STATE_CREATE_INFO* pCreateInfo, XGL_DYNAMIC_CB_STATE_OBJECT* pState);
-typedef XGL_RESULT (XGLAPI *xglCreateDynamicDepthStencilStateType)(XGL_DEVICE device, const XGL_DYNAMIC_DS_STATE_CREATE_INFO* pCreateInfo, XGL_DYNAMIC_DS_STATE_OBJECT* pState);
-typedef XGL_RESULT (XGLAPI *xglCreateCommandBufferType)(XGL_DEVICE device, const XGL_CMD_BUFFER_CREATE_INFO* pCreateInfo, XGL_CMD_BUFFER* pCmdBuffer);
-typedef XGL_RESULT (XGLAPI *xglBeginCommandBufferType)(XGL_CMD_BUFFER cmdBuffer, const XGL_CMD_BUFFER_BEGIN_INFO* pBeginInfo);
-typedef XGL_RESULT (XGLAPI *xglEndCommandBufferType)(XGL_CMD_BUFFER cmdBuffer);
-typedef XGL_RESULT (XGLAPI *xglResetCommandBufferType)(XGL_CMD_BUFFER cmdBuffer);
-typedef void       (XGLAPI *xglCmdBindPipelineType)(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, XGL_PIPELINE pipeline);
-typedef void       (XGLAPI *xglCmdBindDynamicStateObjectType)(XGL_CMD_BUFFER cmdBuffer, XGL_STATE_BIND_POINT stateBindPoint, XGL_DYNAMIC_STATE_OBJECT state);
-typedef void       (XGLAPI *xglCmdBindDescriptorSetsType)(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, XGL_DESCRIPTOR_SET_LAYOUT_CHAIN layoutChain, uint32_t layoutChainSlot, uint32_t count, const XGL_DESCRIPTOR_SET* pDescriptorSets, const uint32_t* pUserData);
-typedef void       (XGLAPI *xglCmdBindIndexBufferType)(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER buffer, XGL_GPU_SIZE offset, XGL_INDEX_TYPE indexType);
-typedef void       (XGLAPI *xglCmdBindVertexBufferType)(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER buffer, XGL_GPU_SIZE offset, uint32_t binding);
-typedef void       (XGLAPI *xglCmdDrawType)(XGL_CMD_BUFFER cmdBuffer, uint32_t firstVertex, uint32_t vertexCount, uint32_t firstInstance, uint32_t instanceCount);
-typedef void       (XGLAPI *xglCmdDrawIndexedType)(XGL_CMD_BUFFER cmdBuffer, uint32_t firstIndex, uint32_t indexCount, int32_t vertexOffset, uint32_t firstInstance, uint32_t instanceCount);
-typedef void       (XGLAPI *xglCmdDrawIndirectType)(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER buffer, XGL_GPU_SIZE offset, uint32_t count, uint32_t stride);
-typedef void       (XGLAPI *xglCmdDrawIndexedIndirectType)(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER buffer, XGL_GPU_SIZE offset, uint32_t count, uint32_t stride);
-typedef void       (XGLAPI *xglCmdDispatchType)(XGL_CMD_BUFFER cmdBuffer, uint32_t x, uint32_t y, uint32_t z);
-typedef void       (XGLAPI *xglCmdDispatchIndirectType)(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER buffer, XGL_GPU_SIZE offset);
-typedef void       (XGLAPI *xglCmdCopyBufferType)(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER srcBuffer, XGL_BUFFER destBuffer, uint32_t regionCount, const XGL_BUFFER_COPY* pRegions);
-typedef void       (XGLAPI *xglCmdCopyImageType)(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE srcImage, XGL_IMAGE_LAYOUT srcImageLayout, XGL_IMAGE destImage, XGL_IMAGE_LAYOUT destImageLayout, uint32_t regionCount, const XGL_IMAGE_COPY* pRegions);
-typedef void       (XGLAPI *xglCmdBlitImageType)(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE srcImage, XGL_IMAGE_LAYOUT srcImageLayout, XGL_IMAGE destImage, XGL_IMAGE_LAYOUT destImageLayout, uint32_t regionCount, const XGL_IMAGE_BLIT* pRegions);
-typedef void       (XGLAPI *xglCmdCopyBufferToImageType)(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER srcBuffer, XGL_IMAGE destImage, XGL_IMAGE_LAYOUT destImageLayout, uint32_t regionCount, const XGL_BUFFER_IMAGE_COPY* pRegions);
-typedef void       (XGLAPI *xglCmdCopyImageToBufferType)(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE srcImage, XGL_IMAGE_LAYOUT srcImageLayout, XGL_BUFFER destBuffer, uint32_t regionCount, const XGL_BUFFER_IMAGE_COPY* pRegions);
-typedef void       (XGLAPI *xglCmdCloneImageDataType)(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE srcImage, XGL_IMAGE_LAYOUT srcImageLayout, XGL_IMAGE destImage, XGL_IMAGE_LAYOUT destImageLayout);
-typedef void       (XGLAPI *xglCmdUpdateBufferType)(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER destBuffer, XGL_GPU_SIZE destOffset, XGL_GPU_SIZE dataSize, const uint32_t* pData);
-typedef void       (XGLAPI *xglCmdFillBufferType)(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER destBuffer, XGL_GPU_SIZE destOffset, XGL_GPU_SIZE fillSize, uint32_t data);
-typedef void       (XGLAPI *xglCmdClearColorImageType)(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE image, XGL_IMAGE_LAYOUT imageLayout, XGL_CLEAR_COLOR color, uint32_t rangeCount, const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges);
-typedef void       (XGLAPI *xglCmdClearDepthStencilType)(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE image, XGL_IMAGE_LAYOUT imageLayout, float depth, uint32_t stencil, uint32_t rangeCount, const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges);
-typedef void       (XGLAPI *xglCmdResolveImageType)(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE srcImage, XGL_IMAGE_LAYOUT srcImageLayout, XGL_IMAGE destImage, XGL_IMAGE_LAYOUT destImageLayout, uint32_t rectCount, const XGL_IMAGE_RESOLVE* pRects);
-typedef void       (XGLAPI *xglCmdSetEventType)(XGL_CMD_BUFFER cmdBuffer, XGL_EVENT event, XGL_PIPE_EVENT pipeEvent);
-typedef void       (XGLAPI *xglCmdResetEventType)(XGL_CMD_BUFFER cmdBuffer, XGL_EVENT event, XGL_PIPE_EVENT pipeEvent);
-typedef void       (XGLAPI *xglCmdWaitEventsType)(XGL_CMD_BUFFER cmdBuffer, const XGL_EVENT_WAIT_INFO* pWaitInfo);
-typedef void       (XGLAPI *xglCmdPipelineBarrierType)(XGL_CMD_BUFFER cmdBuffer, const XGL_PIPELINE_BARRIER* pBarrier);
-typedef void       (XGLAPI *xglCmdBeginQueryType)(XGL_CMD_BUFFER cmdBuffer, XGL_QUERY_POOL queryPool, uint32_t slot, XGL_FLAGS flags);
-typedef void       (XGLAPI *xglCmdEndQueryType)(XGL_CMD_BUFFER cmdBuffer, XGL_QUERY_POOL queryPool, uint32_t slot);
-typedef void       (XGLAPI *xglCmdResetQueryPoolType)(XGL_CMD_BUFFER cmdBuffer, XGL_QUERY_POOL queryPool, uint32_t startQuery, uint32_t queryCount);
-typedef void       (XGLAPI *xglCmdWriteTimestampType)(XGL_CMD_BUFFER cmdBuffer, XGL_TIMESTAMP_TYPE timestampType, XGL_BUFFER destBuffer, XGL_GPU_SIZE destOffset);
-typedef void       (XGLAPI *xglCmdInitAtomicCountersType)(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, const uint32_t* pData);
-typedef void       (XGLAPI *xglCmdLoadAtomicCountersType)(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, XGL_BUFFER srcBuffer, XGL_GPU_SIZE srcOffset);
-typedef void       (XGLAPI *xglCmdSaveAtomicCountersType)(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, XGL_BUFFER destBuffer, XGL_GPU_SIZE destOffset);
-typedef XGL_RESULT (XGLAPI *xglCreateFramebufferType)(XGL_DEVICE device, const XGL_FRAMEBUFFER_CREATE_INFO* pCreateInfo, XGL_FRAMEBUFFER* pFramebuffer);
-typedef XGL_RESULT (XGLAPI *xglCreateRenderPassType)(XGL_DEVICE device, const XGL_RENDER_PASS_CREATE_INFO* pCreateInfo, XGL_RENDER_PASS* pRenderPass);
-typedef void       (XGLAPI *xglCmdBeginRenderPassType)(XGL_CMD_BUFFER cmdBuffer, const XGL_RENDER_PASS_BEGIN* pRenderPassBegin);
-typedef void       (XGLAPI *xglCmdEndRenderPassType)(XGL_CMD_BUFFER cmdBuffer, XGL_RENDER_PASS renderPass);
+typedef VK_RESULT (VKAPI *vkCreateInstanceType)(const VK_INSTANCE_CREATE_INFO* pCreateInfo, VK_INSTANCE* pInstance);
+typedef VK_RESULT (VKAPI *vkDestroyInstanceType)(VK_INSTANCE instance);
+typedef VK_RESULT (VKAPI *vkEnumerateGpusType)(VK_INSTANCE instance, uint32_t maxGpus, uint32_t* pGpuCount, VK_PHYSICAL_GPU* pGpus);
+typedef VK_RESULT (VKAPI *vkGetGpuInfoType)(VK_PHYSICAL_GPU gpu, VK_PHYSICAL_GPU_INFO_TYPE infoType, size_t* pDataSize, void* pData);
+typedef void *     (VKAPI *vkGetProcAddrType)(VK_PHYSICAL_GPU gpu, const char * pName);
+typedef VK_RESULT (VKAPI *vkCreateDeviceType)(VK_PHYSICAL_GPU gpu, const VK_DEVICE_CREATE_INFO* pCreateInfo, VK_DEVICE* pDevice);
+typedef VK_RESULT (VKAPI *vkDestroyDeviceType)(VK_DEVICE device);
+typedef VK_RESULT (VKAPI *vkGetExtensionSupportType)(VK_PHYSICAL_GPU gpu, const char* pExtName);
+typedef VK_RESULT (VKAPI *vkEnumerateLayersType)(VK_PHYSICAL_GPU gpu, size_t maxLayerCount, size_t maxStringSize, size_t* pOutLayerCount, char* const* pOutLayers, void* pReserved);
+typedef VK_RESULT (VKAPI *vkGetDeviceQueueType)(VK_DEVICE device, uint32_t queueNodeIndex, uint32_t queueIndex, VK_QUEUE* pQueue);
+typedef VK_RESULT (VKAPI *vkQueueSubmitType)(VK_QUEUE queue, uint32_t cmdBufferCount, const VK_CMD_BUFFER* pCmdBuffers, VK_FENCE fence);
+typedef VK_RESULT (VKAPI *vkQueueAddMemReferenceType)(VK_QUEUE queue, VK_GPU_MEMORY mem);
+typedef VK_RESULT (VKAPI *vkQueueRemoveMemReferenceType)(VK_QUEUE queue, VK_GPU_MEMORY mem);
+typedef VK_RESULT (VKAPI *vkQueueWaitIdleType)(VK_QUEUE queue);
+typedef VK_RESULT (VKAPI *vkDeviceWaitIdleType)(VK_DEVICE device);
+typedef VK_RESULT (VKAPI *vkAllocMemoryType)(VK_DEVICE device, const VK_MEMORY_ALLOC_INFO* pAllocInfo, VK_GPU_MEMORY* pMem);
+typedef VK_RESULT (VKAPI *vkFreeMemoryType)(VK_GPU_MEMORY mem);
+typedef VK_RESULT (VKAPI *vkSetMemoryPriorityType)(VK_GPU_MEMORY mem, VK_MEMORY_PRIORITY priority);
+typedef VK_RESULT (VKAPI *vkMapMemoryType)(VK_GPU_MEMORY mem, VK_FLAGS flags, void** ppData);
+typedef VK_RESULT (VKAPI *vkUnmapMemoryType)(VK_GPU_MEMORY mem);
+typedef VK_RESULT (VKAPI *vkPinSystemMemoryType)(VK_DEVICE device, const void* pSysMem, size_t memSize, VK_GPU_MEMORY* pMem);
+typedef VK_RESULT (VKAPI *vkGetMultiGpuCompatibilityType)(VK_PHYSICAL_GPU gpu0, VK_PHYSICAL_GPU gpu1, VK_GPU_COMPATIBILITY_INFO* pInfo);
+typedef VK_RESULT (VKAPI *vkOpenSharedMemoryType)(VK_DEVICE device, const VK_MEMORY_OPEN_INFO* pOpenInfo, VK_GPU_MEMORY* pMem);
+typedef VK_RESULT (VKAPI *vkOpenSharedSemaphoreType)(VK_DEVICE device, const VK_SEMAPHORE_OPEN_INFO* pOpenInfo, VK_SEMAPHORE* pSemaphore);
+typedef VK_RESULT (VKAPI *vkOpenPeerMemoryType)(VK_DEVICE device, const VK_PEER_MEMORY_OPEN_INFO* pOpenInfo, VK_GPU_MEMORY* pMem);
+typedef VK_RESULT (VKAPI *vkOpenPeerImageType)(VK_DEVICE device, const VK_PEER_IMAGE_OPEN_INFO* pOpenInfo, VK_IMAGE* pImage, VK_GPU_MEMORY* pMem);
+typedef VK_RESULT (VKAPI *vkDestroyObjectType)(VK_OBJECT object);
+typedef VK_RESULT (VKAPI *vkGetObjectInfoType)(VK_BASE_OBJECT object, VK_OBJECT_INFO_TYPE infoType, size_t* pDataSize, void* pData);
+typedef VK_RESULT (VKAPI *vkBindObjectMemoryType)(VK_OBJECT object, uint32_t allocationIdx, VK_GPU_MEMORY mem, VK_GPU_SIZE offset);
+typedef VK_RESULT (VKAPI *vkBindObjectMemoryRangeType)(VK_OBJECT object, uint32_t allocationIdx, VK_GPU_SIZE rangeOffset,VK_GPU_SIZE rangeSize, VK_GPU_MEMORY mem, VK_GPU_SIZE memOffset);
+typedef VK_RESULT (VKAPI *vkBindImageMemoryRangeType)(VK_IMAGE image, uint32_t allocationIdx, const VK_IMAGE_MEMORY_BIND_INFO* bindInfo, VK_GPU_MEMORY mem, VK_GPU_SIZE memOffset);
+typedef VK_RESULT (VKAPI *vkCreateFenceType)(VK_DEVICE device, const VK_FENCE_CREATE_INFO* pCreateInfo, VK_FENCE* pFence);
+typedef VK_RESULT (VKAPI *vkResetFencesType)(VK_DEVICE device, uint32_t fenceCount, VK_FENCE* pFences);
+typedef VK_RESULT (VKAPI *vkGetFenceStatusType)(VK_FENCE fence);
+typedef VK_RESULT (VKAPI *vkWaitForFencesType)(VK_DEVICE device, uint32_t fenceCount, const VK_FENCE* pFences, bool32_t waitAll, uint64_t timeout);
+typedef VK_RESULT (VKAPI *vkCreateSemaphoreType)(VK_DEVICE device, const VK_SEMAPHORE_CREATE_INFO* pCreateInfo, VK_SEMAPHORE* pSemaphore);
+typedef VK_RESULT (VKAPI *vkQueueSignalSemaphoreType)(VK_QUEUE queue, VK_SEMAPHORE semaphore);
+typedef VK_RESULT (VKAPI *vkQueueWaitSemaphoreType)(VK_QUEUE queue, VK_SEMAPHORE semaphore);
+typedef VK_RESULT (VKAPI *vkCreateEventType)(VK_DEVICE device, const VK_EVENT_CREATE_INFO* pCreateInfo, VK_EVENT* pEvent);
+typedef VK_RESULT (VKAPI *vkGetEventStatusType)(VK_EVENT event);
+typedef VK_RESULT (VKAPI *vkSetEventType)(VK_EVENT event);
+typedef VK_RESULT (VKAPI *vkResetEventType)(VK_EVENT event);
+typedef VK_RESULT (VKAPI *vkCreateQueryPoolType)(VK_DEVICE device, const VK_QUERY_POOL_CREATE_INFO* pCreateInfo, VK_QUERY_POOL* pQueryPool);
+typedef VK_RESULT (VKAPI *vkGetQueryPoolResultsType)(VK_QUERY_POOL queryPool, uint32_t startQuery, uint32_t queryCount, size_t* pDataSize, void* pData);
+typedef VK_RESULT (VKAPI *vkGetFormatInfoType)(VK_DEVICE device, VK_FORMAT format, VK_FORMAT_INFO_TYPE infoType, size_t* pDataSize, void* pData);
+typedef VK_RESULT (VKAPI *vkCreateBufferType)(VK_DEVICE device, const VK_BUFFER_CREATE_INFO* pCreateInfo, VK_BUFFER* pBuffer);
+typedef VK_RESULT (VKAPI *vkCreateBufferViewType)(VK_DEVICE device, const VK_BUFFER_VIEW_CREATE_INFO* pCreateInfo, VK_BUFFER_VIEW* pView);
+typedef VK_RESULT (VKAPI *vkCreateImageType)(VK_DEVICE device, const VK_IMAGE_CREATE_INFO* pCreateInfo, VK_IMAGE* pImage);
+typedef VK_RESULT (VKAPI *vkGetImageSubresourceInfoType)(VK_IMAGE image, const VK_IMAGE_SUBRESOURCE* pSubresource, VK_SUBRESOURCE_INFO_TYPE infoType, size_t* pDataSize, void* pData);
+typedef VK_RESULT (VKAPI *vkCreateImageViewType)(VK_DEVICE device, const VK_IMAGE_VIEW_CREATE_INFO* pCreateInfo, VK_IMAGE_VIEW* pView);
+typedef VK_RESULT (VKAPI *vkCreateColorAttachmentViewType)(VK_DEVICE device, const VK_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pCreateInfo, VK_COLOR_ATTACHMENT_VIEW* pView);
+typedef VK_RESULT (VKAPI *vkCreateDepthStencilViewType)(VK_DEVICE device, const VK_DEPTH_STENCIL_VIEW_CREATE_INFO* pCreateInfo, VK_DEPTH_STENCIL_VIEW* pView);
+typedef VK_RESULT (VKAPI *vkCreateShaderType)(VK_DEVICE device, const VK_SHADER_CREATE_INFO* pCreateInfo, VK_SHADER* pShader);
+typedef VK_RESULT (VKAPI *vkCreateGraphicsPipelineType)(VK_DEVICE device, const VK_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo, VK_PIPELINE* pPipeline);
+typedef VK_RESULT (VKAPI *vkCreateGraphicsPipelineDerivativeType)(VK_DEVICE device, const VK_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo, VK_PIPELINE basePipeline, VK_PIPELINE* pPipeline);
+typedef VK_RESULT (VKAPI *vkCreateComputePipelineType)(VK_DEVICE device, const VK_COMPUTE_PIPELINE_CREATE_INFO* pCreateInfo, VK_PIPELINE* pPipeline);
+typedef VK_RESULT (VKAPI *vkStorePipelineType)(VK_PIPELINE pipeline, size_t* pDataSize, void* pData);
+typedef VK_RESULT (VKAPI *vkLoadPipelineType)(VK_DEVICE device, size_t dataSize, const void* pData, VK_PIPELINE* pPipeline);
+typedef VK_RESULT (VKAPI *vkLoadPipelineDerivativeType)(VK_DEVICE device, size_t dataSize, const void* pData, VK_PIPELINE basePipeline, VK_PIPELINE* pPipeline);
+typedef VK_RESULT (VKAPI *vkCreateSamplerType)(VK_DEVICE device, const VK_SAMPLER_CREATE_INFO* pCreateInfo, VK_SAMPLER* pSampler);
+typedef VK_RESULT (VKAPI *vkCreateDescriptorSetLayoutType)(VK_DEVICE device, const VK_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pCreateInfo, VK_DESCRIPTOR_SET_LAYOUT* pSetLayout);
+typedef VK_RESULT (VKAPI *vkCreateDescriptorSetLayoutChainType)(VK_DEVICE device, uint32_t setLayoutArrayCount, const VK_DESCRIPTOR_SET_LAYOUT* pSetLayoutArray, VK_DESCRIPTOR_SET_LAYOUT_CHAIN* pLayoutChain);
+typedef VK_RESULT (VKAPI *vkBeginDescriptorPoolUpdateType)(VK_DEVICE device, VK_DESCRIPTOR_UPDATE_MODE updateMode);
+typedef VK_RESULT (VKAPI *vkEndDescriptorPoolUpdateType)(VK_DEVICE device, VK_CMD_BUFFER cmd);
+typedef VK_RESULT (VKAPI *vkCreateDescriptorPoolType)(VK_DEVICE device, VK_DESCRIPTOR_POOL_USAGE poolUsage, uint32_t maxSets, const VK_DESCRIPTOR_POOL_CREATE_INFO* pCreateInfo, VK_DESCRIPTOR_POOL* pDescriptorPool);
+typedef VK_RESULT (VKAPI *vkResetDescriptorPoolType)(VK_DESCRIPTOR_POOL descriptorPool);
+typedef VK_RESULT (VKAPI *vkAllocDescriptorSetsType)(VK_DESCRIPTOR_POOL descriptorPool, VK_DESCRIPTOR_SET_USAGE setUsage, uint32_t count, const VK_DESCRIPTOR_SET_LAYOUT* pSetLayouts, VK_DESCRIPTOR_SET* pDescriptorSets, uint32_t* pCount);
+typedef void       (VKAPI *vkClearDescriptorSetsType)(VK_DESCRIPTOR_POOL descriptorPool, uint32_t count, const VK_DESCRIPTOR_SET* pDescriptorSets);
+typedef void       (VKAPI *vkUpdateDescriptorsType)(VK_DESCRIPTOR_SET descriptorSet, uint32_t updateCount, const void** ppUpdateArray);
+typedef VK_RESULT (VKAPI *vkCreateDynamicViewportStateType)(VK_DEVICE device, const VK_DYNAMIC_VP_STATE_CREATE_INFO* pCreateInfo, VK_DYNAMIC_VP_STATE_OBJECT* pState);
+typedef VK_RESULT (VKAPI *vkCreateDynamicRasterStateType)(VK_DEVICE device, const VK_DYNAMIC_RS_STATE_CREATE_INFO* pCreateInfo, VK_DYNAMIC_RS_STATE_OBJECT* pState);
+typedef VK_RESULT (VKAPI *vkCreateDynamicColorBlendStateType)(VK_DEVICE device, const VK_DYNAMIC_CB_STATE_CREATE_INFO* pCreateInfo, VK_DYNAMIC_CB_STATE_OBJECT* pState);
+typedef VK_RESULT (VKAPI *vkCreateDynamicDepthStencilStateType)(VK_DEVICE device, const VK_DYNAMIC_DS_STATE_CREATE_INFO* pCreateInfo, VK_DYNAMIC_DS_STATE_OBJECT* pState);
+typedef VK_RESULT (VKAPI *vkCreateCommandBufferType)(VK_DEVICE device, const VK_CMD_BUFFER_CREATE_INFO* pCreateInfo, VK_CMD_BUFFER* pCmdBuffer);
+typedef VK_RESULT (VKAPI *vkBeginCommandBufferType)(VK_CMD_BUFFER cmdBuffer, const VK_CMD_BUFFER_BEGIN_INFO* pBeginInfo);
+typedef VK_RESULT (VKAPI *vkEndCommandBufferType)(VK_CMD_BUFFER cmdBuffer);
+typedef VK_RESULT (VKAPI *vkResetCommandBufferType)(VK_CMD_BUFFER cmdBuffer);
+typedef void       (VKAPI *vkCmdBindPipelineType)(VK_CMD_BUFFER cmdBuffer, VK_PIPELINE_BIND_POINT pipelineBindPoint, VK_PIPELINE pipeline);
+typedef void       (VKAPI *vkCmdBindDynamicStateObjectType)(VK_CMD_BUFFER cmdBuffer, VK_STATE_BIND_POINT stateBindPoint, VK_DYNAMIC_STATE_OBJECT state);
+typedef void       (VKAPI *vkCmdBindDescriptorSetsType)(VK_CMD_BUFFER cmdBuffer, VK_PIPELINE_BIND_POINT pipelineBindPoint, VK_DESCRIPTOR_SET_LAYOUT_CHAIN layoutChain, uint32_t layoutChainSlot, uint32_t count, const VK_DESCRIPTOR_SET* pDescriptorSets, const uint32_t* pUserData);
+typedef void       (VKAPI *vkCmdBindIndexBufferType)(VK_CMD_BUFFER cmdBuffer, VK_BUFFER buffer, VK_GPU_SIZE offset, VK_INDEX_TYPE indexType);
+typedef void       (VKAPI *vkCmdBindVertexBufferType)(VK_CMD_BUFFER cmdBuffer, VK_BUFFER buffer, VK_GPU_SIZE offset, uint32_t binding);
+typedef void       (VKAPI *vkCmdDrawType)(VK_CMD_BUFFER cmdBuffer, uint32_t firstVertex, uint32_t vertexCount, uint32_t firstInstance, uint32_t instanceCount);
+typedef void       (VKAPI *vkCmdDrawIndexedType)(VK_CMD_BUFFER cmdBuffer, uint32_t firstIndex, uint32_t indexCount, int32_t vertexOffset, uint32_t firstInstance, uint32_t instanceCount);
+typedef void       (VKAPI *vkCmdDrawIndirectType)(VK_CMD_BUFFER cmdBuffer, VK_BUFFER buffer, VK_GPU_SIZE offset, uint32_t count, uint32_t stride);
+typedef void       (VKAPI *vkCmdDrawIndexedIndirectType)(VK_CMD_BUFFER cmdBuffer, VK_BUFFER buffer, VK_GPU_SIZE offset, uint32_t count, uint32_t stride);
+typedef void       (VKAPI *vkCmdDispatchType)(VK_CMD_BUFFER cmdBuffer, uint32_t x, uint32_t y, uint32_t z);
+typedef void       (VKAPI *vkCmdDispatchIndirectType)(VK_CMD_BUFFER cmdBuffer, VK_BUFFER buffer, VK_GPU_SIZE offset);
+typedef void       (VKAPI *vkCmdCopyBufferType)(VK_CMD_BUFFER cmdBuffer, VK_BUFFER srcBuffer, VK_BUFFER destBuffer, uint32_t regionCount, const VK_BUFFER_COPY* pRegions);
+typedef void       (VKAPI *vkCmdCopyImageType)(VK_CMD_BUFFER cmdBuffer, VK_IMAGE srcImage, VK_IMAGE_LAYOUT srcImageLayout, VK_IMAGE destImage, VK_IMAGE_LAYOUT destImageLayout, uint32_t regionCount, const VK_IMAGE_COPY* pRegions);
+typedef void       (VKAPI *vkCmdBlitImageType)(VK_CMD_BUFFER cmdBuffer, VK_IMAGE srcImage, VK_IMAGE_LAYOUT srcImageLayout, VK_IMAGE destImage, VK_IMAGE_LAYOUT destImageLayout, uint32_t regionCount, const VK_IMAGE_BLIT* pRegions);
+typedef void       (VKAPI *vkCmdCopyBufferToImageType)(VK_CMD_BUFFER cmdBuffer, VK_BUFFER srcBuffer, VK_IMAGE destImage, VK_IMAGE_LAYOUT destImageLayout, uint32_t regionCount, const VK_BUFFER_IMAGE_COPY* pRegions);
+typedef void       (VKAPI *vkCmdCopyImageToBufferType)(VK_CMD_BUFFER cmdBuffer, VK_IMAGE srcImage, VK_IMAGE_LAYOUT srcImageLayout, VK_BUFFER destBuffer, uint32_t regionCount, const VK_BUFFER_IMAGE_COPY* pRegions);
+typedef void       (VKAPI *vkCmdCloneImageDataType)(VK_CMD_BUFFER cmdBuffer, VK_IMAGE srcImage, VK_IMAGE_LAYOUT srcImageLayout, VK_IMAGE destImage, VK_IMAGE_LAYOUT destImageLayout);
+typedef void       (VKAPI *vkCmdUpdateBufferType)(VK_CMD_BUFFER cmdBuffer, VK_BUFFER destBuffer, VK_GPU_SIZE destOffset, VK_GPU_SIZE dataSize, const uint32_t* pData);
+typedef void       (VKAPI *vkCmdFillBufferType)(VK_CMD_BUFFER cmdBuffer, VK_BUFFER destBuffer, VK_GPU_SIZE destOffset, VK_GPU_SIZE fillSize, uint32_t data);
+typedef void       (VKAPI *vkCmdClearColorImageType)(VK_CMD_BUFFER cmdBuffer, VK_IMAGE image, VK_IMAGE_LAYOUT imageLayout, VK_CLEAR_COLOR color, uint32_t rangeCount, const VK_IMAGE_SUBRESOURCE_RANGE* pRanges);
+typedef void       (VKAPI *vkCmdClearDepthStencilType)(VK_CMD_BUFFER cmdBuffer, VK_IMAGE image, VK_IMAGE_LAYOUT imageLayout, float depth, uint32_t stencil, uint32_t rangeCount, const VK_IMAGE_SUBRESOURCE_RANGE* pRanges);
+typedef void       (VKAPI *vkCmdResolveImageType)(VK_CMD_BUFFER cmdBuffer, VK_IMAGE srcImage, VK_IMAGE_LAYOUT srcImageLayout, VK_IMAGE destImage, VK_IMAGE_LAYOUT destImageLayout, uint32_t rectCount, const VK_IMAGE_RESOLVE* pRects);
+typedef void       (VKAPI *vkCmdSetEventType)(VK_CMD_BUFFER cmdBuffer, VK_EVENT event, VK_PIPE_EVENT pipeEvent);
+typedef void       (VKAPI *vkCmdResetEventType)(VK_CMD_BUFFER cmdBuffer, VK_EVENT event, VK_PIPE_EVENT pipeEvent);
+typedef void       (VKAPI *vkCmdWaitEventsType)(VK_CMD_BUFFER cmdBuffer, const VK_EVENT_WAIT_INFO* pWaitInfo);
+typedef void       (VKAPI *vkCmdPipelineBarrierType)(VK_CMD_BUFFER cmdBuffer, const VK_PIPELINE_BARRIER* pBarrier);
+typedef void       (VKAPI *vkCmdBeginQueryType)(VK_CMD_BUFFER cmdBuffer, VK_QUERY_POOL queryPool, uint32_t slot, VK_FLAGS flags);
+typedef void       (VKAPI *vkCmdEndQueryType)(VK_CMD_BUFFER cmdBuffer, VK_QUERY_POOL queryPool, uint32_t slot);
+typedef void       (VKAPI *vkCmdResetQueryPoolType)(VK_CMD_BUFFER cmdBuffer, VK_QUERY_POOL queryPool, uint32_t startQuery, uint32_t queryCount);
+typedef void       (VKAPI *vkCmdWriteTimestampType)(VK_CMD_BUFFER cmdBuffer, VK_TIMESTAMP_TYPE timestampType, VK_BUFFER destBuffer, VK_GPU_SIZE destOffset);
+typedef void       (VKAPI *vkCmdInitAtomicCountersType)(VK_CMD_BUFFER cmdBuffer, VK_PIPELINE_BIND_POINT pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, const uint32_t* pData);
+typedef void       (VKAPI *vkCmdLoadAtomicCountersType)(VK_CMD_BUFFER cmdBuffer, VK_PIPELINE_BIND_POINT pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, VK_BUFFER srcBuffer, VK_GPU_SIZE srcOffset);
+typedef void       (VKAPI *vkCmdSaveAtomicCountersType)(VK_CMD_BUFFER cmdBuffer, VK_PIPELINE_BIND_POINT pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, VK_BUFFER destBuffer, VK_GPU_SIZE destOffset);
+typedef VK_RESULT (VKAPI *vkCreateFramebufferType)(VK_DEVICE device, const VK_FRAMEBUFFER_CREATE_INFO* pCreateInfo, VK_FRAMEBUFFER* pFramebuffer);
+typedef VK_RESULT (VKAPI *vkCreateRenderPassType)(VK_DEVICE device, const VK_RENDER_PASS_CREATE_INFO* pCreateInfo, VK_RENDER_PASS* pRenderPass);
+typedef void       (VKAPI *vkCmdBeginRenderPassType)(VK_CMD_BUFFER cmdBuffer, const VK_RENDER_PASS_BEGIN* pRenderPassBegin);
+typedef void       (VKAPI *vkCmdEndRenderPassType)(VK_CMD_BUFFER cmdBuffer, VK_RENDER_PASS renderPass);
 
-#ifdef XGL_PROTOTYPES
+#ifdef VK_PROTOTYPES
 
 // GPU initialization
 
-XGL_RESULT XGLAPI xglCreateInstance(
-    const XGL_INSTANCE_CREATE_INFO*             pCreateInfo,
-    XGL_INSTANCE*                               pInstance);
+VK_RESULT VKAPI vkCreateInstance(
+    const VK_INSTANCE_CREATE_INFO*             pCreateInfo,
+    VK_INSTANCE*                               pInstance);
 
-XGL_RESULT XGLAPI xglDestroyInstance(
-    XGL_INSTANCE                                instance);
+VK_RESULT VKAPI vkDestroyInstance(
+    VK_INSTANCE                                instance);
 
-XGL_RESULT XGLAPI xglEnumerateGpus(
-    XGL_INSTANCE                                instance,
+VK_RESULT VKAPI vkEnumerateGpus(
+    VK_INSTANCE                                instance,
     uint32_t                                    maxGpus,
     uint32_t*                                   pGpuCount,
-    XGL_PHYSICAL_GPU*                           pGpus);
+    VK_PHYSICAL_GPU*                           pGpus);
 
-XGL_RESULT XGLAPI xglGetGpuInfo(
-    XGL_PHYSICAL_GPU                            gpu,
-    XGL_PHYSICAL_GPU_INFO_TYPE                  infoType,
+VK_RESULT VKAPI vkGetGpuInfo(
+    VK_PHYSICAL_GPU                            gpu,
+    VK_PHYSICAL_GPU_INFO_TYPE                  infoType,
     size_t*                                     pDataSize,
     void*                                       pData);
 
-void * XGLAPI xglGetProcAddr(
-    XGL_PHYSICAL_GPU                            gpu,
+void * VKAPI vkGetProcAddr(
+    VK_PHYSICAL_GPU                            gpu,
     const char*                                 pName);
 
 // Device functions
 
-XGL_RESULT XGLAPI xglCreateDevice(
-    XGL_PHYSICAL_GPU                            gpu,
-    const XGL_DEVICE_CREATE_INFO*               pCreateInfo,
-    XGL_DEVICE*                                 pDevice);
+VK_RESULT VKAPI vkCreateDevice(
+    VK_PHYSICAL_GPU                            gpu,
+    const VK_DEVICE_CREATE_INFO*               pCreateInfo,
+    VK_DEVICE*                                 pDevice);
 
-XGL_RESULT XGLAPI xglDestroyDevice(
-    XGL_DEVICE                                  device);
+VK_RESULT VKAPI vkDestroyDevice(
+    VK_DEVICE                                  device);
 
 // Extension discovery functions
 
-XGL_RESULT XGLAPI xglGetExtensionSupport(
-    XGL_PHYSICAL_GPU                            gpu,
+VK_RESULT VKAPI vkGetExtensionSupport(
+    VK_PHYSICAL_GPU                            gpu,
     const char*                                 pExtName);
 
 // Layer discovery functions
 
-XGL_RESULT XGLAPI xglEnumerateLayers(
-    XGL_PHYSICAL_GPU                            gpu,
+VK_RESULT VKAPI vkEnumerateLayers(
+    VK_PHYSICAL_GPU                            gpu,
     size_t                                      maxLayerCount,
     size_t                                      maxStringSize,
     size_t*                                     pOutLayerCount,
@@ -2434,182 +2434,182 @@
 
 // Queue functions
 
-XGL_RESULT XGLAPI xglGetDeviceQueue(
-    XGL_DEVICE                                  device,
+VK_RESULT VKAPI vkGetDeviceQueue(
+    VK_DEVICE                                  device,
     uint32_t                                    queueNodeIndex,
     uint32_t                                    queueIndex,
-    XGL_QUEUE*                                  pQueue);
+    VK_QUEUE*                                  pQueue);
 
-XGL_RESULT XGLAPI xglQueueSubmit(
-    XGL_QUEUE                                   queue,
+VK_RESULT VKAPI vkQueueSubmit(
+    VK_QUEUE                                   queue,
     uint32_t                                    cmdBufferCount,
-    const XGL_CMD_BUFFER*                       pCmdBuffers,
-    XGL_FENCE                                   fence);
+    const VK_CMD_BUFFER*                       pCmdBuffers,
+    VK_FENCE                                   fence);
 
-XGL_RESULT XGLAPI xglQueueAddMemReference(
-    XGL_QUEUE                                   queue,
-    XGL_GPU_MEMORY                              mem);
+VK_RESULT VKAPI vkQueueAddMemReference(
+    VK_QUEUE                                   queue,
+    VK_GPU_MEMORY                              mem);
 
-XGL_RESULT XGLAPI xglQueueRemoveMemReference(
-    XGL_QUEUE                                   queue,
-    XGL_GPU_MEMORY                              mem);
+VK_RESULT VKAPI vkQueueRemoveMemReference(
+    VK_QUEUE                                   queue,
+    VK_GPU_MEMORY                              mem);
 
-XGL_RESULT XGLAPI xglQueueWaitIdle(
-    XGL_QUEUE                                   queue);
+VK_RESULT VKAPI vkQueueWaitIdle(
+    VK_QUEUE                                   queue);
 
-XGL_RESULT XGLAPI xglDeviceWaitIdle(
-    XGL_DEVICE                                  device);
+VK_RESULT VKAPI vkDeviceWaitIdle(
+    VK_DEVICE                                  device);
 
 // Memory functions
 
-XGL_RESULT XGLAPI xglAllocMemory(
-    XGL_DEVICE                                  device,
-    const XGL_MEMORY_ALLOC_INFO*                pAllocInfo,
-    XGL_GPU_MEMORY*                             pMem);
+VK_RESULT VKAPI vkAllocMemory(
+    VK_DEVICE                                  device,
+    const VK_MEMORY_ALLOC_INFO*                pAllocInfo,
+    VK_GPU_MEMORY*                             pMem);
 
-XGL_RESULT XGLAPI xglFreeMemory(
-    XGL_GPU_MEMORY                              mem);
+VK_RESULT VKAPI vkFreeMemory(
+    VK_GPU_MEMORY                              mem);
 
-XGL_RESULT XGLAPI xglSetMemoryPriority(
-    XGL_GPU_MEMORY                              mem,
-    XGL_MEMORY_PRIORITY                         priority);
+VK_RESULT VKAPI vkSetMemoryPriority(
+    VK_GPU_MEMORY                              mem,
+    VK_MEMORY_PRIORITY                         priority);
 
-XGL_RESULT XGLAPI xglMapMemory(
-    XGL_GPU_MEMORY                              mem,
-    XGL_FLAGS                                   flags,                // Reserved
+VK_RESULT VKAPI vkMapMemory(
+    VK_GPU_MEMORY                              mem,
+    VK_FLAGS                                   flags,                // Reserved
     void**                                      ppData);
 
-XGL_RESULT XGLAPI xglUnmapMemory(
-    XGL_GPU_MEMORY                              mem);
+VK_RESULT VKAPI vkUnmapMemory(
+    VK_GPU_MEMORY                              mem);
 
-XGL_RESULT XGLAPI xglPinSystemMemory(
-    XGL_DEVICE                                  device,
+VK_RESULT VKAPI vkPinSystemMemory(
+    VK_DEVICE                                  device,
     const void*                                 pSysMem,
     size_t                                      memSize,
-    XGL_GPU_MEMORY*                             pMem);
+    VK_GPU_MEMORY*                             pMem);
 
 // Multi-device functions
 
-XGL_RESULT XGLAPI xglGetMultiGpuCompatibility(
-    XGL_PHYSICAL_GPU                            gpu0,
-    XGL_PHYSICAL_GPU                            gpu1,
-    XGL_GPU_COMPATIBILITY_INFO*                 pInfo);
+VK_RESULT VKAPI vkGetMultiGpuCompatibility(
+    VK_PHYSICAL_GPU                            gpu0,
+    VK_PHYSICAL_GPU                            gpu1,
+    VK_GPU_COMPATIBILITY_INFO*                 pInfo);
 
-XGL_RESULT XGLAPI xglOpenSharedMemory(
-    XGL_DEVICE                                  device,
-    const XGL_MEMORY_OPEN_INFO*                 pOpenInfo,
-    XGL_GPU_MEMORY*                             pMem);
+VK_RESULT VKAPI vkOpenSharedMemory(
+    VK_DEVICE                                  device,
+    const VK_MEMORY_OPEN_INFO*                 pOpenInfo,
+    VK_GPU_MEMORY*                             pMem);
 
-XGL_RESULT XGLAPI xglOpenSharedSemaphore(
-    XGL_DEVICE                                  device,
-    const XGL_SEMAPHORE_OPEN_INFO*              pOpenInfo,
-    XGL_SEMAPHORE*                              pSemaphore);
+VK_RESULT VKAPI vkOpenSharedSemaphore(
+    VK_DEVICE                                  device,
+    const VK_SEMAPHORE_OPEN_INFO*              pOpenInfo,
+    VK_SEMAPHORE*                              pSemaphore);
 
-XGL_RESULT XGLAPI xglOpenPeerMemory(
-    XGL_DEVICE                                  device,
-    const XGL_PEER_MEMORY_OPEN_INFO*            pOpenInfo,
-    XGL_GPU_MEMORY*                             pMem);
+VK_RESULT VKAPI vkOpenPeerMemory(
+    VK_DEVICE                                  device,
+    const VK_PEER_MEMORY_OPEN_INFO*            pOpenInfo,
+    VK_GPU_MEMORY*                             pMem);
 
-XGL_RESULT XGLAPI xglOpenPeerImage(
-    XGL_DEVICE                                  device,
-    const XGL_PEER_IMAGE_OPEN_INFO*             pOpenInfo,
-    XGL_IMAGE*                                  pImage,
-    XGL_GPU_MEMORY*                             pMem);
+VK_RESULT VKAPI vkOpenPeerImage(
+    VK_DEVICE                                  device,
+    const VK_PEER_IMAGE_OPEN_INFO*             pOpenInfo,
+    VK_IMAGE*                                  pImage,
+    VK_GPU_MEMORY*                             pMem);
 
 // Generic API object functions
 
-XGL_RESULT XGLAPI xglDestroyObject(
-    XGL_OBJECT                                  object);
+VK_RESULT VKAPI vkDestroyObject(
+    VK_OBJECT                                  object);
 
-XGL_RESULT XGLAPI xglGetObjectInfo(
-    XGL_BASE_OBJECT                             object,
-    XGL_OBJECT_INFO_TYPE                        infoType,
+VK_RESULT VKAPI vkGetObjectInfo(
+    VK_BASE_OBJECT                             object,
+    VK_OBJECT_INFO_TYPE                        infoType,
     size_t*                                     pDataSize,
     void*                                       pData);
 
-XGL_RESULT XGLAPI xglBindObjectMemory(
-    XGL_OBJECT                                  object,
+VK_RESULT VKAPI vkBindObjectMemory(
+    VK_OBJECT                                  object,
     uint32_t                                    allocationIdx,
-    XGL_GPU_MEMORY                              mem,
-    XGL_GPU_SIZE                                memOffset);
+    VK_GPU_MEMORY                              mem,
+    VK_GPU_SIZE                                memOffset);
 
-XGL_RESULT XGLAPI xglBindObjectMemoryRange(
-    XGL_OBJECT                                  object,
+VK_RESULT VKAPI vkBindObjectMemoryRange(
+    VK_OBJECT                                  object,
     uint32_t                                    allocationIdx,
-    XGL_GPU_SIZE                                rangeOffset,
-    XGL_GPU_SIZE                                rangeSize,
-    XGL_GPU_MEMORY                              mem,
-    XGL_GPU_SIZE                                memOffset);
+    VK_GPU_SIZE                                rangeOffset,
+    VK_GPU_SIZE                                rangeSize,
+    VK_GPU_MEMORY                              mem,
+    VK_GPU_SIZE                                memOffset);
 
-XGL_RESULT XGLAPI xglBindImageMemoryRange(
-    XGL_IMAGE                                   image,
+VK_RESULT VKAPI vkBindImageMemoryRange(
+    VK_IMAGE                                   image,
     uint32_t                                    allocationIdx,
-    const XGL_IMAGE_MEMORY_BIND_INFO*           bindInfo,
-    XGL_GPU_MEMORY                              mem,
-    XGL_GPU_SIZE                                memOffset);
+    const VK_IMAGE_MEMORY_BIND_INFO*           bindInfo,
+    VK_GPU_MEMORY                              mem,
+    VK_GPU_SIZE                                memOffset);
 
 // Fence functions
 
-XGL_RESULT XGLAPI xglCreateFence(
-    XGL_DEVICE                                  device,
-    const XGL_FENCE_CREATE_INFO*                pCreateInfo,
-    XGL_FENCE*                                  pFence);
+VK_RESULT VKAPI vkCreateFence(
+    VK_DEVICE                                  device,
+    const VK_FENCE_CREATE_INFO*                pCreateInfo,
+    VK_FENCE*                                  pFence);
 
-XGL_RESULT XGLAPI xglResetFences(
-    XGL_DEVICE                                  device,
+VK_RESULT VKAPI vkResetFences(
+    VK_DEVICE                                  device,
     uint32_t                                    fenceCount,
-    XGL_FENCE*                                  pFences);
+    VK_FENCE*                                  pFences);
 
-XGL_RESULT XGLAPI xglGetFenceStatus(
-    XGL_FENCE fence);
+VK_RESULT VKAPI vkGetFenceStatus(
+    VK_FENCE fence);
 
-XGL_RESULT XGLAPI xglWaitForFences(
-    XGL_DEVICE                                  device,
+VK_RESULT VKAPI vkWaitForFences(
+    VK_DEVICE                                  device,
     uint32_t                                    fenceCount,
-    const XGL_FENCE*                            pFences,
+    const VK_FENCE*                            pFences,
     bool32_t                                    waitAll,
     uint64_t                                    timeout); // timeout in nanoseconds
 
 // Queue semaphore functions
 
-XGL_RESULT XGLAPI xglCreateSemaphore(
-    XGL_DEVICE                                  device,
-    const XGL_SEMAPHORE_CREATE_INFO*            pCreateInfo,
-    XGL_SEMAPHORE*                              pSemaphore);
+VK_RESULT VKAPI vkCreateSemaphore(
+    VK_DEVICE                                  device,
+    const VK_SEMAPHORE_CREATE_INFO*            pCreateInfo,
+    VK_SEMAPHORE*                              pSemaphore);
 
-XGL_RESULT XGLAPI xglQueueSignalSemaphore(
-    XGL_QUEUE                                   queue,
-    XGL_SEMAPHORE                               semaphore);
+VK_RESULT VKAPI vkQueueSignalSemaphore(
+    VK_QUEUE                                   queue,
+    VK_SEMAPHORE                               semaphore);
 
-XGL_RESULT XGLAPI xglQueueWaitSemaphore(
-    XGL_QUEUE                                   queue,
-    XGL_SEMAPHORE                               semaphore);
+VK_RESULT VKAPI vkQueueWaitSemaphore(
+    VK_QUEUE                                   queue,
+    VK_SEMAPHORE                               semaphore);
 
 // Event functions
 
-XGL_RESULT XGLAPI xglCreateEvent(
-    XGL_DEVICE                                  device,
-    const XGL_EVENT_CREATE_INFO*                pCreateInfo,
-    XGL_EVENT*                                  pEvent);
+VK_RESULT VKAPI vkCreateEvent(
+    VK_DEVICE                                  device,
+    const VK_EVENT_CREATE_INFO*                pCreateInfo,
+    VK_EVENT*                                  pEvent);
 
-XGL_RESULT XGLAPI xglGetEventStatus(
-    XGL_EVENT                                   event);
+VK_RESULT VKAPI vkGetEventStatus(
+    VK_EVENT                                   event);
 
-XGL_RESULT XGLAPI xglSetEvent(
-    XGL_EVENT                                   event);
+VK_RESULT VKAPI vkSetEvent(
+    VK_EVENT                                   event);
 
-XGL_RESULT XGLAPI xglResetEvent(
-    XGL_EVENT                                   event);
+VK_RESULT VKAPI vkResetEvent(
+    VK_EVENT                                   event);
 
 // Query functions
 
-XGL_RESULT XGLAPI xglCreateQueryPool(
-    XGL_DEVICE                                  device,
-    const XGL_QUERY_POOL_CREATE_INFO*           pCreateInfo,
-    XGL_QUERY_POOL*                             pQueryPool);
+VK_RESULT VKAPI vkCreateQueryPool(
+    VK_DEVICE                                  device,
+    const VK_QUERY_POOL_CREATE_INFO*           pCreateInfo,
+    VK_QUERY_POOL*                             pQueryPool);
 
-XGL_RESULT XGLAPI xglGetQueryPoolResults(
-    XGL_QUERY_POOL                              queryPool,
+VK_RESULT VKAPI vkGetQueryPoolResults(
+    VK_QUERY_POOL                              queryPool,
     uint32_t                                    startQuery,
     uint32_t                                    queryCount,
     size_t*                                     pDataSize,
@@ -2617,446 +2617,446 @@
 
 // Format capabilities
 
-XGL_RESULT XGLAPI xglGetFormatInfo(
-    XGL_DEVICE                                  device,
-    XGL_FORMAT                                  format,
-    XGL_FORMAT_INFO_TYPE                        infoType,
+VK_RESULT VKAPI vkGetFormatInfo(
+    VK_DEVICE                                  device,
+    VK_FORMAT                                  format,
+    VK_FORMAT_INFO_TYPE                        infoType,
     size_t*                                     pDataSize,
     void*                                       pData);
 
 // Buffer functions
 
-XGL_RESULT XGLAPI xglCreateBuffer(
-    XGL_DEVICE                                  device,
-    const XGL_BUFFER_CREATE_INFO*               pCreateInfo,
-    XGL_BUFFER*                                 pBuffer);
+VK_RESULT VKAPI vkCreateBuffer(
+    VK_DEVICE                                  device,
+    const VK_BUFFER_CREATE_INFO*               pCreateInfo,
+    VK_BUFFER*                                 pBuffer);
 
 // Buffer view functions
 
-XGL_RESULT XGLAPI xglCreateBufferView(
-    XGL_DEVICE                                  device,
-    const XGL_BUFFER_VIEW_CREATE_INFO*          pCreateInfo,
-    XGL_BUFFER_VIEW*                            pView);
+VK_RESULT VKAPI vkCreateBufferView(
+    VK_DEVICE                                  device,
+    const VK_BUFFER_VIEW_CREATE_INFO*          pCreateInfo,
+    VK_BUFFER_VIEW*                            pView);
 
 // Image functions
 
-XGL_RESULT XGLAPI xglCreateImage(
-    XGL_DEVICE                                  device,
-    const XGL_IMAGE_CREATE_INFO*                pCreateInfo,
-    XGL_IMAGE*                                  pImage);
+VK_RESULT VKAPI vkCreateImage(
+    VK_DEVICE                                  device,
+    const VK_IMAGE_CREATE_INFO*                pCreateInfo,
+    VK_IMAGE*                                  pImage);
 
-XGL_RESULT XGLAPI xglGetImageSubresourceInfo(
-    XGL_IMAGE                                   image,
-    const XGL_IMAGE_SUBRESOURCE*                pSubresource,
-    XGL_SUBRESOURCE_INFO_TYPE                   infoType,
+VK_RESULT VKAPI vkGetImageSubresourceInfo(
+    VK_IMAGE                                   image,
+    const VK_IMAGE_SUBRESOURCE*                pSubresource,
+    VK_SUBRESOURCE_INFO_TYPE                   infoType,
     size_t*                                     pDataSize,
     void*                                       pData);
 
 // Image view functions
 
-XGL_RESULT XGLAPI xglCreateImageView(
-    XGL_DEVICE                                  device,
-    const XGL_IMAGE_VIEW_CREATE_INFO*           pCreateInfo,
-    XGL_IMAGE_VIEW*                             pView);
+VK_RESULT VKAPI vkCreateImageView(
+    VK_DEVICE                                  device,
+    const VK_IMAGE_VIEW_CREATE_INFO*           pCreateInfo,
+    VK_IMAGE_VIEW*                             pView);
 
-XGL_RESULT XGLAPI xglCreateColorAttachmentView(
-    XGL_DEVICE                                  device,
-    const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pCreateInfo,
-    XGL_COLOR_ATTACHMENT_VIEW*                  pView);
+VK_RESULT VKAPI vkCreateColorAttachmentView(
+    VK_DEVICE                                  device,
+    const VK_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pCreateInfo,
+    VK_COLOR_ATTACHMENT_VIEW*                  pView);
 
-XGL_RESULT XGLAPI xglCreateDepthStencilView(
-    XGL_DEVICE                                  device,
-    const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO*   pCreateInfo,
-    XGL_DEPTH_STENCIL_VIEW*                     pView);
+VK_RESULT VKAPI vkCreateDepthStencilView(
+    VK_DEVICE                                  device,
+    const VK_DEPTH_STENCIL_VIEW_CREATE_INFO*   pCreateInfo,
+    VK_DEPTH_STENCIL_VIEW*                     pView);
 
 // Shader functions
 
-XGL_RESULT XGLAPI xglCreateShader(
-    XGL_DEVICE                                  device,
-    const XGL_SHADER_CREATE_INFO*               pCreateInfo,
-    XGL_SHADER*                                 pShader);
+VK_RESULT VKAPI vkCreateShader(
+    VK_DEVICE                                  device,
+    const VK_SHADER_CREATE_INFO*               pCreateInfo,
+    VK_SHADER*                                 pShader);
 
 // Pipeline functions
 
-XGL_RESULT XGLAPI xglCreateGraphicsPipeline(
-    XGL_DEVICE                                  device,
-    const XGL_GRAPHICS_PIPELINE_CREATE_INFO*    pCreateInfo,
-    XGL_PIPELINE*                               pPipeline);
+VK_RESULT VKAPI vkCreateGraphicsPipeline(
+    VK_DEVICE                                  device,
+    const VK_GRAPHICS_PIPELINE_CREATE_INFO*    pCreateInfo,
+    VK_PIPELINE*                               pPipeline);
 
-XGL_RESULT XGLAPI xglCreateGraphicsPipelineDerivative(
-    XGL_DEVICE                                  device,
-    const XGL_GRAPHICS_PIPELINE_CREATE_INFO*    pCreateInfo,
-    XGL_PIPELINE                                basePipeline,
-    XGL_PIPELINE*                               pPipeline);
+VK_RESULT VKAPI vkCreateGraphicsPipelineDerivative(
+    VK_DEVICE                                  device,
+    const VK_GRAPHICS_PIPELINE_CREATE_INFO*    pCreateInfo,
+    VK_PIPELINE                                basePipeline,
+    VK_PIPELINE*                               pPipeline);
 
-XGL_RESULT XGLAPI xglCreateComputePipeline(
-    XGL_DEVICE                                  device,
-    const XGL_COMPUTE_PIPELINE_CREATE_INFO*     pCreateInfo,
-    XGL_PIPELINE*                               pPipeline);
+VK_RESULT VKAPI vkCreateComputePipeline(
+    VK_DEVICE                                  device,
+    const VK_COMPUTE_PIPELINE_CREATE_INFO*     pCreateInfo,
+    VK_PIPELINE*                               pPipeline);
 
-XGL_RESULT XGLAPI xglStorePipeline(
-    XGL_PIPELINE                                pipeline,
+VK_RESULT VKAPI vkStorePipeline(
+    VK_PIPELINE                                pipeline,
     size_t*                                     pDataSize,
     void*                                       pData);
 
-XGL_RESULT XGLAPI xglLoadPipeline(
-    XGL_DEVICE                                  device,
+VK_RESULT VKAPI vkLoadPipeline(
+    VK_DEVICE                                  device,
     size_t                                      dataSize,
     const void*                                 pData,
-    XGL_PIPELINE*                               pPipeline);
+    VK_PIPELINE*                               pPipeline);
 
-XGL_RESULT XGLAPI xglLoadPipelineDerivative(
-    XGL_DEVICE                                  device,
+VK_RESULT VKAPI vkLoadPipelineDerivative(
+    VK_DEVICE                                  device,
     size_t                                      dataSize,
     const void*                                 pData,
-    XGL_PIPELINE                                basePipeline,
-    XGL_PIPELINE*                               pPipeline);
+    VK_PIPELINE                                basePipeline,
+    VK_PIPELINE*                               pPipeline);
 
 // Sampler functions
 
-XGL_RESULT XGLAPI xglCreateSampler(
-    XGL_DEVICE                                  device,
-    const XGL_SAMPLER_CREATE_INFO*              pCreateInfo,
-    XGL_SAMPLER*                                pSampler);
+VK_RESULT VKAPI vkCreateSampler(
+    VK_DEVICE                                  device,
+    const VK_SAMPLER_CREATE_INFO*              pCreateInfo,
+    VK_SAMPLER*                                pSampler);
 
 // Descriptor set functions
 
-XGL_RESULT XGLAPI xglCreateDescriptorSetLayout(
-    XGL_DEVICE                                   device,
-    const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pCreateInfo,
-    XGL_DESCRIPTOR_SET_LAYOUT*                   pSetLayout);
+VK_RESULT VKAPI vkCreateDescriptorSetLayout(
+    VK_DEVICE                                   device,
+    const VK_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pCreateInfo,
+    VK_DESCRIPTOR_SET_LAYOUT*                   pSetLayout);
 
-XGL_RESULT XGLAPI xglCreateDescriptorSetLayoutChain(
-    XGL_DEVICE                                   device,
+VK_RESULT VKAPI vkCreateDescriptorSetLayoutChain(
+    VK_DEVICE                                   device,
     uint32_t                                     setLayoutArrayCount,
-    const XGL_DESCRIPTOR_SET_LAYOUT*             pSetLayoutArray,
-    XGL_DESCRIPTOR_SET_LAYOUT_CHAIN*             pLayoutChain);
+    const VK_DESCRIPTOR_SET_LAYOUT*             pSetLayoutArray,
+    VK_DESCRIPTOR_SET_LAYOUT_CHAIN*             pLayoutChain);
 
-XGL_RESULT XGLAPI xglBeginDescriptorPoolUpdate(
-    XGL_DEVICE                                   device,
-    XGL_DESCRIPTOR_UPDATE_MODE                   updateMode);
+VK_RESULT VKAPI vkBeginDescriptorPoolUpdate(
+    VK_DEVICE                                   device,
+    VK_DESCRIPTOR_UPDATE_MODE                   updateMode);
 
-XGL_RESULT XGLAPI xglEndDescriptorPoolUpdate(
-    XGL_DEVICE                                   device,
-    XGL_CMD_BUFFER                               cmd);
+VK_RESULT VKAPI vkEndDescriptorPoolUpdate(
+    VK_DEVICE                                   device,
+    VK_CMD_BUFFER                               cmd);
 
-XGL_RESULT XGLAPI xglCreateDescriptorPool(
-    XGL_DEVICE                                   device,
-    XGL_DESCRIPTOR_POOL_USAGE                    poolUsage,
+VK_RESULT VKAPI vkCreateDescriptorPool(
+    VK_DEVICE                                   device,
+    VK_DESCRIPTOR_POOL_USAGE                    poolUsage,
     uint32_t                                     maxSets,
-    const XGL_DESCRIPTOR_POOL_CREATE_INFO*       pCreateInfo,
-    XGL_DESCRIPTOR_POOL*                         pDescriptorPool);
+    const VK_DESCRIPTOR_POOL_CREATE_INFO*       pCreateInfo,
+    VK_DESCRIPTOR_POOL*                         pDescriptorPool);
 
-XGL_RESULT XGLAPI xglResetDescriptorPool(
-    XGL_DESCRIPTOR_POOL                          descriptorPool);
+VK_RESULT VKAPI vkResetDescriptorPool(
+    VK_DESCRIPTOR_POOL                          descriptorPool);
 
-XGL_RESULT XGLAPI xglAllocDescriptorSets(
-    XGL_DESCRIPTOR_POOL                          descriptorPool,
-    XGL_DESCRIPTOR_SET_USAGE                     setUsage,
+VK_RESULT VKAPI vkAllocDescriptorSets(
+    VK_DESCRIPTOR_POOL                          descriptorPool,
+    VK_DESCRIPTOR_SET_USAGE                     setUsage,
     uint32_t                                     count,
-    const XGL_DESCRIPTOR_SET_LAYOUT*             pSetLayouts,
-    XGL_DESCRIPTOR_SET*                          pDescriptorSets,
+    const VK_DESCRIPTOR_SET_LAYOUT*             pSetLayouts,
+    VK_DESCRIPTOR_SET*                          pDescriptorSets,
     uint32_t*                                    pCount);
 
-void XGLAPI xglClearDescriptorSets(
-    XGL_DESCRIPTOR_POOL                          descriptorPool,
+void VKAPI vkClearDescriptorSets(
+    VK_DESCRIPTOR_POOL                          descriptorPool,
     uint32_t                                     count,
-    const XGL_DESCRIPTOR_SET*                    pDescriptorSets);
+    const VK_DESCRIPTOR_SET*                    pDescriptorSets);
 
-void XGLAPI xglUpdateDescriptors(
-    XGL_DESCRIPTOR_SET                           descriptorSet,
+void VKAPI vkUpdateDescriptors(
+    VK_DESCRIPTOR_SET                           descriptorSet,
     uint32_t                                     updateCount,
     const void**                                 ppUpdateArray);
 
 // State object functions
 
-XGL_RESULT XGLAPI xglCreateDynamicViewportState(
-    XGL_DEVICE                                  device,
-    const XGL_DYNAMIC_VP_STATE_CREATE_INFO*     pCreateInfo,
-    XGL_DYNAMIC_VP_STATE_OBJECT*                pState);
+VK_RESULT VKAPI vkCreateDynamicViewportState(
+    VK_DEVICE                                  device,
+    const VK_DYNAMIC_VP_STATE_CREATE_INFO*     pCreateInfo,
+    VK_DYNAMIC_VP_STATE_OBJECT*                pState);
 
-XGL_RESULT XGLAPI xglCreateDynamicRasterState(
-    XGL_DEVICE                                  device,
-    const XGL_DYNAMIC_RS_STATE_CREATE_INFO*     pCreateInfo,
-    XGL_DYNAMIC_RS_STATE_OBJECT*                pState);
+VK_RESULT VKAPI vkCreateDynamicRasterState(
+    VK_DEVICE                                  device,
+    const VK_DYNAMIC_RS_STATE_CREATE_INFO*     pCreateInfo,
+    VK_DYNAMIC_RS_STATE_OBJECT*                pState);
 
-XGL_RESULT XGLAPI xglCreateDynamicColorBlendState(
-    XGL_DEVICE                                  device,
-    const XGL_DYNAMIC_CB_STATE_CREATE_INFO*     pCreateInfo,
-    XGL_DYNAMIC_CB_STATE_OBJECT*                pState);
+VK_RESULT VKAPI vkCreateDynamicColorBlendState(
+    VK_DEVICE                                  device,
+    const VK_DYNAMIC_CB_STATE_CREATE_INFO*     pCreateInfo,
+    VK_DYNAMIC_CB_STATE_OBJECT*                pState);
 
-XGL_RESULT XGLAPI xglCreateDynamicDepthStencilState(
-    XGL_DEVICE                                  device,
-    const XGL_DYNAMIC_DS_STATE_CREATE_INFO*     pCreateInfo,
-    XGL_DYNAMIC_DS_STATE_OBJECT*                pState);
+VK_RESULT VKAPI vkCreateDynamicDepthStencilState(
+    VK_DEVICE                                  device,
+    const VK_DYNAMIC_DS_STATE_CREATE_INFO*     pCreateInfo,
+    VK_DYNAMIC_DS_STATE_OBJECT*                pState);
 
 // Command buffer functions
 
-XGL_RESULT XGLAPI xglCreateCommandBuffer(
-    XGL_DEVICE                                  device,
-    const XGL_CMD_BUFFER_CREATE_INFO*           pCreateInfo,
-    XGL_CMD_BUFFER*                             pCmdBuffer);
+VK_RESULT VKAPI vkCreateCommandBuffer(
+    VK_DEVICE                                  device,
+    const VK_CMD_BUFFER_CREATE_INFO*           pCreateInfo,
+    VK_CMD_BUFFER*                             pCmdBuffer);
 
-XGL_RESULT XGLAPI xglBeginCommandBuffer(
-    XGL_CMD_BUFFER                              cmdBuffer,
-    const XGL_CMD_BUFFER_BEGIN_INFO*            pBeginInfo);
+VK_RESULT VKAPI vkBeginCommandBuffer(
+    VK_CMD_BUFFER                              cmdBuffer,
+    const VK_CMD_BUFFER_BEGIN_INFO*            pBeginInfo);
 
-XGL_RESULT XGLAPI xglEndCommandBuffer(
-    XGL_CMD_BUFFER                              cmdBuffer);
+VK_RESULT VKAPI vkEndCommandBuffer(
+    VK_CMD_BUFFER                              cmdBuffer);
 
-XGL_RESULT XGLAPI xglResetCommandBuffer(
-    XGL_CMD_BUFFER                              cmdBuffer);
+VK_RESULT VKAPI vkResetCommandBuffer(
+    VK_CMD_BUFFER                              cmdBuffer);
 
 // Command buffer building functions
 
-void XGLAPI xglCmdBindPipeline(
-    XGL_CMD_BUFFER                              cmdBuffer,
-    XGL_PIPELINE_BIND_POINT                     pipelineBindPoint,
-    XGL_PIPELINE                                pipeline);
+void VKAPI vkCmdBindPipeline(
+    VK_CMD_BUFFER                              cmdBuffer,
+    VK_PIPELINE_BIND_POINT                     pipelineBindPoint,
+    VK_PIPELINE                                pipeline);
 
-void XGLAPI xglCmdBindDynamicStateObject(
-    XGL_CMD_BUFFER                              cmdBuffer,
-    XGL_STATE_BIND_POINT                        stateBindPoint,
-    XGL_DYNAMIC_STATE_OBJECT                    dynamicState);
+void VKAPI vkCmdBindDynamicStateObject(
+    VK_CMD_BUFFER                              cmdBuffer,
+    VK_STATE_BIND_POINT                        stateBindPoint,
+    VK_DYNAMIC_STATE_OBJECT                    dynamicState);
 
-void XGLAPI xglCmdBindDescriptorSets(
-    XGL_CMD_BUFFER                              cmdBuffer,
-    XGL_PIPELINE_BIND_POINT                     pipelineBindPoint,
-    XGL_DESCRIPTOR_SET_LAYOUT_CHAIN             layoutChain,
+void VKAPI vkCmdBindDescriptorSets(
+    VK_CMD_BUFFER                              cmdBuffer,
+    VK_PIPELINE_BIND_POINT                     pipelineBindPoint,
+    VK_DESCRIPTOR_SET_LAYOUT_CHAIN             layoutChain,
     uint32_t                                    layoutChainSlot,
     uint32_t                                    count,
-    const XGL_DESCRIPTOR_SET*                   pDescriptorSets,
+    const VK_DESCRIPTOR_SET*                   pDescriptorSets,
     const uint32_t*                             pUserData);
 
-void XGLAPI xglCmdBindIndexBuffer(
-    XGL_CMD_BUFFER                              cmdBuffer,
-    XGL_BUFFER                                  buffer,
-    XGL_GPU_SIZE                                offset,
-    XGL_INDEX_TYPE                              indexType);
+void VKAPI vkCmdBindIndexBuffer(
+    VK_CMD_BUFFER                              cmdBuffer,
+    VK_BUFFER                                  buffer,
+    VK_GPU_SIZE                                offset,
+    VK_INDEX_TYPE                              indexType);
 
-void XGLAPI xglCmdBindVertexBuffer(
-    XGL_CMD_BUFFER                              cmdBuffer,
-    XGL_BUFFER                                  buffer,
-    XGL_GPU_SIZE                                offset,
+void VKAPI vkCmdBindVertexBuffer(
+    VK_CMD_BUFFER                              cmdBuffer,
+    VK_BUFFER                                  buffer,
+    VK_GPU_SIZE                                offset,
     uint32_t                                    binding);
 
-void XGLAPI xglCmdDraw(
-    XGL_CMD_BUFFER                              cmdBuffer,
+void VKAPI vkCmdDraw(
+    VK_CMD_BUFFER                              cmdBuffer,
     uint32_t                                    firstVertex,
     uint32_t                                    vertexCount,
     uint32_t                                    firstInstance,
     uint32_t                                    instanceCount);
 
-void XGLAPI xglCmdDrawIndexed(
-    XGL_CMD_BUFFER                              cmdBuffer,
+void VKAPI vkCmdDrawIndexed(
+    VK_CMD_BUFFER                              cmdBuffer,
     uint32_t                                    firstIndex,
     uint32_t                                    indexCount,
     int32_t                                     vertexOffset,
     uint32_t                                    firstInstance,
     uint32_t                                    instanceCount);
 
-void XGLAPI xglCmdDrawIndirect(
-    XGL_CMD_BUFFER                              cmdBuffer,
-    XGL_BUFFER                                  buffer,
-    XGL_GPU_SIZE                                offset,
+void VKAPI vkCmdDrawIndirect(
+    VK_CMD_BUFFER                              cmdBuffer,
+    VK_BUFFER                                  buffer,
+    VK_GPU_SIZE                                offset,
     uint32_t                                    count,
     uint32_t                                    stride);
 
-void XGLAPI xglCmdDrawIndexedIndirect(
-    XGL_CMD_BUFFER                              cmdBuffer,
-    XGL_BUFFER                                  buffer,
-    XGL_GPU_SIZE                                offset,
+void VKAPI vkCmdDrawIndexedIndirect(
+    VK_CMD_BUFFER                              cmdBuffer,
+    VK_BUFFER                                  buffer,
+    VK_GPU_SIZE                                offset,
     uint32_t                                    count,
     uint32_t                                    stride);
 
-void XGLAPI xglCmdDispatch(
-    XGL_CMD_BUFFER                              cmdBuffer,
+void VKAPI vkCmdDispatch(
+    VK_CMD_BUFFER                              cmdBuffer,
     uint32_t                                    x,
     uint32_t                                    y,
     uint32_t                                    z);
 
-void XGLAPI xglCmdDispatchIndirect(
-    XGL_CMD_BUFFER                              cmdBuffer,
-    XGL_BUFFER                                  buffer,
-    XGL_GPU_SIZE                                offset);
+void VKAPI vkCmdDispatchIndirect(
+    VK_CMD_BUFFER                              cmdBuffer,
+    VK_BUFFER                                  buffer,
+    VK_GPU_SIZE                                offset);
 
-void XGLAPI xglCmdCopyBuffer(
-    XGL_CMD_BUFFER                              cmdBuffer,
-    XGL_BUFFER                                  srcBuffer,
-    XGL_BUFFER                                  destBuffer,
+void VKAPI vkCmdCopyBuffer(
+    VK_CMD_BUFFER                              cmdBuffer,
+    VK_BUFFER                                  srcBuffer,
+    VK_BUFFER                                  destBuffer,
     uint32_t                                    regionCount,
-    const XGL_BUFFER_COPY*                      pRegions);
+    const VK_BUFFER_COPY*                      pRegions);
 
-void XGLAPI xglCmdCopyImage(
-    XGL_CMD_BUFFER                              cmdBuffer,
-    XGL_IMAGE                                   srcImage,
-    XGL_IMAGE_LAYOUT                            srcImageLayout,
-    XGL_IMAGE                                   destImage,
-    XGL_IMAGE_LAYOUT                            destImageLayout,
+void VKAPI vkCmdCopyImage(
+    VK_CMD_BUFFER                              cmdBuffer,
+    VK_IMAGE                                   srcImage,
+    VK_IMAGE_LAYOUT                            srcImageLayout,
+    VK_IMAGE                                   destImage,
+    VK_IMAGE_LAYOUT                            destImageLayout,
     uint32_t                                    regionCount,
-    const XGL_IMAGE_COPY*                       pRegions);
+    const VK_IMAGE_COPY*                       pRegions);
 
-void XGLAPI xglCmdBlitImage(
-    XGL_CMD_BUFFER                              cmdBuffer,
-    XGL_IMAGE                                   srcImage,
-    XGL_IMAGE_LAYOUT                            srcImageLayout,
-    XGL_IMAGE                                   destImage,
-    XGL_IMAGE_LAYOUT                            destImageLayout,
+void VKAPI vkCmdBlitImage(
+    VK_CMD_BUFFER                              cmdBuffer,
+    VK_IMAGE                                   srcImage,
+    VK_IMAGE_LAYOUT                            srcImageLayout,
+    VK_IMAGE                                   destImage,
+    VK_IMAGE_LAYOUT                            destImageLayout,
     uint32_t                                    regionCount,
-    const XGL_IMAGE_BLIT*                       pRegions);
+    const VK_IMAGE_BLIT*                       pRegions);
 
-void XGLAPI xglCmdCopyBufferToImage(
-    XGL_CMD_BUFFER                              cmdBuffer,
-    XGL_BUFFER                                  srcBuffer,
-    XGL_IMAGE                                   destImage,
-    XGL_IMAGE_LAYOUT                            destImageLayout,
+void VKAPI vkCmdCopyBufferToImage(
+    VK_CMD_BUFFER                              cmdBuffer,
+    VK_BUFFER                                  srcBuffer,
+    VK_IMAGE                                   destImage,
+    VK_IMAGE_LAYOUT                            destImageLayout,
     uint32_t                                    regionCount,
-    const XGL_BUFFER_IMAGE_COPY*                pRegions);
+    const VK_BUFFER_IMAGE_COPY*                pRegions);
 
-void XGLAPI xglCmdCopyImageToBuffer(
-    XGL_CMD_BUFFER                              cmdBuffer,
-    XGL_IMAGE                                   srcImage,
-    XGL_IMAGE_LAYOUT                            srcImageLayout,
-    XGL_BUFFER                                  destBuffer,
+void VKAPI vkCmdCopyImageToBuffer(
+    VK_CMD_BUFFER                              cmdBuffer,
+    VK_IMAGE                                   srcImage,
+    VK_IMAGE_LAYOUT                            srcImageLayout,
+    VK_BUFFER                                  destBuffer,
     uint32_t                                    regionCount,
-    const XGL_BUFFER_IMAGE_COPY*                pRegions);
+    const VK_BUFFER_IMAGE_COPY*                pRegions);
 
-void XGLAPI xglCmdCloneImageData(
-    XGL_CMD_BUFFER                              cmdBuffer,
-    XGL_IMAGE                                   srcImage,
-    XGL_IMAGE_LAYOUT                            srcImageLayout,
-    XGL_IMAGE                                   destImage,
-    XGL_IMAGE_LAYOUT                            destImageLayout);
+void VKAPI vkCmdCloneImageData(
+    VK_CMD_BUFFER                              cmdBuffer,
+    VK_IMAGE                                   srcImage,
+    VK_IMAGE_LAYOUT                            srcImageLayout,
+    VK_IMAGE                                   destImage,
+    VK_IMAGE_LAYOUT                            destImageLayout);
 
-void XGLAPI xglCmdUpdateBuffer(
-    XGL_CMD_BUFFER                              cmdBuffer,
-    XGL_BUFFER                                  destBuffer,
-    XGL_GPU_SIZE                                destOffset,
-    XGL_GPU_SIZE                                dataSize,
+void VKAPI vkCmdUpdateBuffer(
+    VK_CMD_BUFFER                              cmdBuffer,
+    VK_BUFFER                                  destBuffer,
+    VK_GPU_SIZE                                destOffset,
+    VK_GPU_SIZE                                dataSize,
     const uint32_t*                             pData);
 
-void XGLAPI xglCmdFillBuffer(
-    XGL_CMD_BUFFER                              cmdBuffer,
-    XGL_BUFFER                                  destBuffer,
-    XGL_GPU_SIZE                                destOffset,
-    XGL_GPU_SIZE                                fillSize,
+void VKAPI vkCmdFillBuffer(
+    VK_CMD_BUFFER                              cmdBuffer,
+    VK_BUFFER                                  destBuffer,
+    VK_GPU_SIZE                                destOffset,
+    VK_GPU_SIZE                                fillSize,
     uint32_t                                    data);
 
-void XGLAPI xglCmdClearColorImage(
-    XGL_CMD_BUFFER                              cmdBuffer,
-    XGL_IMAGE                                   image,
-    XGL_IMAGE_LAYOUT                            imageLayout,
-    XGL_CLEAR_COLOR                             color,
+void VKAPI vkCmdClearColorImage(
+    VK_CMD_BUFFER                              cmdBuffer,
+    VK_IMAGE                                   image,
+    VK_IMAGE_LAYOUT                            imageLayout,
+    VK_CLEAR_COLOR                             color,
     uint32_t                                    rangeCount,
-    const XGL_IMAGE_SUBRESOURCE_RANGE*          pRanges);
+    const VK_IMAGE_SUBRESOURCE_RANGE*          pRanges);
 
-void XGLAPI xglCmdClearDepthStencil(
-    XGL_CMD_BUFFER                              cmdBuffer,
-    XGL_IMAGE                                   image,
-    XGL_IMAGE_LAYOUT                            imageLayout,
+void VKAPI vkCmdClearDepthStencil(
+    VK_CMD_BUFFER                              cmdBuffer,
+    VK_IMAGE                                   image,
+    VK_IMAGE_LAYOUT                            imageLayout,
     float                                       depth,
     uint32_t                                    stencil,
     uint32_t                                    rangeCount,
-    const XGL_IMAGE_SUBRESOURCE_RANGE*          pRanges);
+    const VK_IMAGE_SUBRESOURCE_RANGE*          pRanges);
 
-void XGLAPI xglCmdResolveImage(
-    XGL_CMD_BUFFER                              cmdBuffer,
-    XGL_IMAGE                                   srcImage,
-    XGL_IMAGE_LAYOUT                            srcImageLayout,
-    XGL_IMAGE                                   destImage,
-    XGL_IMAGE_LAYOUT                            destImageLayout,
+void VKAPI vkCmdResolveImage(
+    VK_CMD_BUFFER                              cmdBuffer,
+    VK_IMAGE                                   srcImage,
+    VK_IMAGE_LAYOUT                            srcImageLayout,
+    VK_IMAGE                                   destImage,
+    VK_IMAGE_LAYOUT                            destImageLayout,
     uint32_t                                    rectCount,
-    const XGL_IMAGE_RESOLVE*                    pRects);
+    const VK_IMAGE_RESOLVE*                    pRects);
 
-void XGLAPI xglCmdSetEvent(
-    XGL_CMD_BUFFER                              cmdBuffer,
-    XGL_EVENT                                   event,
-    XGL_PIPE_EVENT                              pipeEvent);
+void VKAPI vkCmdSetEvent(
+    VK_CMD_BUFFER                              cmdBuffer,
+    VK_EVENT                                   event,
+    VK_PIPE_EVENT                              pipeEvent);
 
-void XGLAPI xglCmdResetEvent(
-    XGL_CMD_BUFFER                              cmdBuffer,
-    XGL_EVENT                                   event,
-    XGL_PIPE_EVENT                              pipeEvent);
+void VKAPI vkCmdResetEvent(
+    VK_CMD_BUFFER                              cmdBuffer,
+    VK_EVENT                                   event,
+    VK_PIPE_EVENT                              pipeEvent);
 
-void XGLAPI xglCmdWaitEvents(
-    XGL_CMD_BUFFER                              cmdBuffer,
-    const XGL_EVENT_WAIT_INFO*                  pWaitInfo);
+void VKAPI vkCmdWaitEvents(
+    VK_CMD_BUFFER                              cmdBuffer,
+    const VK_EVENT_WAIT_INFO*                  pWaitInfo);
 
-void XGLAPI xglCmdPipelineBarrier(
-    XGL_CMD_BUFFER                              cmdBuffer,
-    const XGL_PIPELINE_BARRIER*                 pBarrier);
+void VKAPI vkCmdPipelineBarrier(
+    VK_CMD_BUFFER                              cmdBuffer,
+    const VK_PIPELINE_BARRIER*                 pBarrier);
 
-void XGLAPI xglCmdBeginQuery(
-    XGL_CMD_BUFFER                              cmdBuffer,
-    XGL_QUERY_POOL                              queryPool,
+void VKAPI vkCmdBeginQuery(
+    VK_CMD_BUFFER                              cmdBuffer,
+    VK_QUERY_POOL                              queryPool,
     uint32_t                                    slot,
-    XGL_FLAGS                                   flags);
+    VK_FLAGS                                   flags);
 
-void XGLAPI xglCmdEndQuery(
-    XGL_CMD_BUFFER                              cmdBuffer,
-    XGL_QUERY_POOL                              queryPool,
+void VKAPI vkCmdEndQuery(
+    VK_CMD_BUFFER                              cmdBuffer,
+    VK_QUERY_POOL                              queryPool,
     uint32_t                                    slot);
 
-void XGLAPI xglCmdResetQueryPool(
-    XGL_CMD_BUFFER                              cmdBuffer,
-    XGL_QUERY_POOL                              queryPool,
+void VKAPI vkCmdResetQueryPool(
+    VK_CMD_BUFFER                              cmdBuffer,
+    VK_QUERY_POOL                              queryPool,
     uint32_t                                    startQuery,
     uint32_t                                    queryCount);
 
-void XGLAPI xglCmdWriteTimestamp(
-    XGL_CMD_BUFFER                              cmdBuffer,
-    XGL_TIMESTAMP_TYPE                          timestampType,
-    XGL_BUFFER                                  destBuffer,
-    XGL_GPU_SIZE                                destOffset);
+void VKAPI vkCmdWriteTimestamp(
+    VK_CMD_BUFFER                              cmdBuffer,
+    VK_TIMESTAMP_TYPE                          timestampType,
+    VK_BUFFER                                  destBuffer,
+    VK_GPU_SIZE                                destOffset);
 
-void XGLAPI xglCmdInitAtomicCounters(
-    XGL_CMD_BUFFER                              cmdBuffer,
-    XGL_PIPELINE_BIND_POINT                     pipelineBindPoint,
+void VKAPI vkCmdInitAtomicCounters(
+    VK_CMD_BUFFER                              cmdBuffer,
+    VK_PIPELINE_BIND_POINT                     pipelineBindPoint,
     uint32_t                                    startCounter,
     uint32_t                                    counterCount,
     const uint32_t*                             pData);
 
-void XGLAPI xglCmdLoadAtomicCounters(
-    XGL_CMD_BUFFER                              cmdBuffer,
-    XGL_PIPELINE_BIND_POINT                     pipelineBindPoint,
+void VKAPI vkCmdLoadAtomicCounters(
+    VK_CMD_BUFFER                              cmdBuffer,
+    VK_PIPELINE_BIND_POINT                     pipelineBindPoint,
     uint32_t                                    startCounter,
     uint32_t                                    counterCount,
-    XGL_BUFFER                                  srcBuffer,
-    XGL_GPU_SIZE                                srcOffset);
+    VK_BUFFER                                  srcBuffer,
+    VK_GPU_SIZE                                srcOffset);
 
-void XGLAPI xglCmdSaveAtomicCounters(
-    XGL_CMD_BUFFER                              cmdBuffer,
-    XGL_PIPELINE_BIND_POINT                     pipelineBindPoint,
+void VKAPI vkCmdSaveAtomicCounters(
+    VK_CMD_BUFFER                              cmdBuffer,
+    VK_PIPELINE_BIND_POINT                     pipelineBindPoint,
     uint32_t                                    startCounter,
     uint32_t                                    counterCount,
-    XGL_BUFFER                                  destBuffer,
-    XGL_GPU_SIZE                                destOffset);
+    VK_BUFFER                                  destBuffer,
+    VK_GPU_SIZE                                destOffset);
 
-XGL_RESULT XGLAPI xglCreateFramebuffer(
-    XGL_DEVICE                                  device,
-    const XGL_FRAMEBUFFER_CREATE_INFO*          pCreateInfo,
-    XGL_FRAMEBUFFER*                            pFramebuffer);
+VK_RESULT VKAPI vkCreateFramebuffer(
+    VK_DEVICE                                  device,
+    const VK_FRAMEBUFFER_CREATE_INFO*          pCreateInfo,
+    VK_FRAMEBUFFER*                            pFramebuffer);
 
-XGL_RESULT XGLAPI xglCreateRenderPass(
-    XGL_DEVICE                                  device,
-    const XGL_RENDER_PASS_CREATE_INFO*          pCreateInfo,
-    XGL_RENDER_PASS*                            pRenderPass);
+VK_RESULT VKAPI vkCreateRenderPass(
+    VK_DEVICE                                  device,
+    const VK_RENDER_PASS_CREATE_INFO*          pCreateInfo,
+    VK_RENDER_PASS*                            pRenderPass);
 
-void XGLAPI xglCmdBeginRenderPass(
-    XGL_CMD_BUFFER                              cmdBuffer,
-    const XGL_RENDER_PASS_BEGIN*                pRenderPassBegin);
+void VKAPI vkCmdBeginRenderPass(
+    VK_CMD_BUFFER                              cmdBuffer,
+    const VK_RENDER_PASS_BEGIN*                pRenderPassBegin);
 
-void XGLAPI xglCmdEndRenderPass(
-    XGL_CMD_BUFFER                              cmdBuffer,
-    XGL_RENDER_PASS                             renderPass);
+void VKAPI vkCmdEndRenderPass(
+    VK_CMD_BUFFER                              cmdBuffer,
+    VK_RENDER_PASS                             renderPass);
 
-#endif // XGL_PROTOTYPES
+#endif // VK_PROTOTYPES
 
 #ifdef __cplusplus
 } // extern "C"
 #endif // __cplusplus
 
-#endif // __XGL_H__
+#endif // __VULKAN_H__
 
 /******************************************************************************************
 
@@ -3076,27 +3076,27 @@
     To incorporate trasnform feedback, we could create a new pipeline stage. This would
     be injected into a PSO by including the following in the chain:
 
-    typedef struct _XGL_XFB_CREATE_INFO
+    typedef struct _VK_XFB_CREATE_INFO
     {
-        XGL_STRUCTURE_TYPE    sType;  // Must be XGL_STRUCTURE_TYPE_PIPELINE_XFB_CREATE_INFO
+        VK_STRUCTURE_TYPE    sType;  // Must be VK_STRUCTURE_TYPE_PIPELINE_XFB_CREATE_INFO
         const void*           pNext;  // Pointer to next structure
         // More XFB state, if any goes here
-    } XGL_DEPTH_STENCIL_VIEW_CREATE_INFO;
+    } VK_DEPTH_STENCIL_VIEW_CREATE_INFO;
 
     We expect that only the shader-side configuration (via layout qualifiers or their IR
     equivalent) is used to configure the data written to each stream. When transform
     feedback is part of the pipeline, transform feedback binding would be available
     through a new API bind point:
 
-        xglCmdBindTransformFeedbackMemoryView(
-                XGL_CMD_BUFFER                              cmdBuffer,
-                XGL_PIPELINE_BIND_POINT                     pipelineBindPoint, // = GRAPHICS
+        vkCmdBindTransformFeedbackMemoryView(
+                VK_CMD_BUFFER                              cmdBuffer,
+                VK_PIPELINE_BIND_POINT                     pipelineBindPoint, // = GRAPHICS
                 uint32_t                                    index,
-                const XGL_MEMORY_VIEW_ATTACH_INFO*          pMemView);
+                const VK_MEMORY_VIEW_ATTACH_INFO*          pMemView);
 
     2) "Bindless" + support for non-bindless hardware.
 
-    XGL doesn't have bindless textures the way that GL does. It has resource descriptor
+    VK doesn't have bindless textures the way that GL does. It has resource descriptor
     sets, or resource tables. Resource tables can be nested and hold references to more
     resource tables. They are explicitly sized by the application and have no artificial
     upper size limit. An application can still attach as many textures as they want to
diff --git a/include/xglDbg.h b/include/xglDbg.h
index 5a6c8fa..fb22482 100644
--- a/include/xglDbg.h
+++ b/include/xglDbg.h
@@ -1,171 +1,171 @@
-#ifndef __XGLDBG_H__
-#define __XGLDBG_H__
+#ifndef __VKDBG_H__
+#define __VKDBG_H__
 
-#include <xgl.h>
+#include <vulkan.h>
 
 #ifdef __cplusplus
 extern "C"
 {
 #endif // __cplusplus
 
-typedef enum _XGL_DBG_MSG_TYPE
+typedef enum _VK_DBG_MSG_TYPE
 {
-    XGL_DBG_MSG_UNKNOWN      = 0x0,
-    XGL_DBG_MSG_ERROR        = 0x1,
-    XGL_DBG_MSG_WARNING      = 0x2,
-    XGL_DBG_MSG_PERF_WARNING = 0x3,
+    VK_DBG_MSG_UNKNOWN      = 0x0,
+    VK_DBG_MSG_ERROR        = 0x1,
+    VK_DBG_MSG_WARNING      = 0x2,
+    VK_DBG_MSG_PERF_WARNING = 0x3,
 
-    XGL_DBG_MSG_TYPE_BEGIN_RANGE = XGL_DBG_MSG_UNKNOWN,
-    XGL_DBG_MSG_TYPE_END_RANGE   = XGL_DBG_MSG_PERF_WARNING,
-    XGL_NUM_DBG_MSG_TYPE         = (XGL_DBG_MSG_TYPE_END_RANGE - XGL_DBG_MSG_TYPE_BEGIN_RANGE + 1),
-} XGL_DBG_MSG_TYPE;
+    VK_DBG_MSG_TYPE_BEGIN_RANGE = VK_DBG_MSG_UNKNOWN,
+    VK_DBG_MSG_TYPE_END_RANGE   = VK_DBG_MSG_PERF_WARNING,
+    VK_NUM_DBG_MSG_TYPE         = (VK_DBG_MSG_TYPE_END_RANGE - VK_DBG_MSG_TYPE_BEGIN_RANGE + 1),
+} VK_DBG_MSG_TYPE;
 
-typedef enum _XGL_DBG_MSG_FILTER
+typedef enum _VK_DBG_MSG_FILTER
 {
-    XGL_DBG_MSG_FILTER_NONE     = 0x0,
-    XGL_DBG_MSG_FILTER_REPEATED = 0x1,
-    XGL_DBG_MSG_FILTER_ALL      = 0x2,
+    VK_DBG_MSG_FILTER_NONE     = 0x0,
+    VK_DBG_MSG_FILTER_REPEATED = 0x1,
+    VK_DBG_MSG_FILTER_ALL      = 0x2,
 
-    XGL_DBG_MSG_FILTER_BEGIN_RANGE = XGL_DBG_MSG_FILTER_NONE,
-    XGL_DBG_MSG_FILTER_END_RANGE   = XGL_DBG_MSG_FILTER_ALL,
-    XGL_NUM_DBG_MSG_FILTER         = (XGL_DBG_MSG_FILTER_END_RANGE - XGL_DBG_MSG_FILTER_BEGIN_RANGE + 1),
-} XGL_DBG_MSG_FILTER;
+    VK_DBG_MSG_FILTER_BEGIN_RANGE = VK_DBG_MSG_FILTER_NONE,
+    VK_DBG_MSG_FILTER_END_RANGE   = VK_DBG_MSG_FILTER_ALL,
+    VK_NUM_DBG_MSG_FILTER         = (VK_DBG_MSG_FILTER_END_RANGE - VK_DBG_MSG_FILTER_BEGIN_RANGE + 1),
+} VK_DBG_MSG_FILTER;
 
-typedef enum _XGL_DBG_GLOBAL_OPTION
+typedef enum _VK_DBG_GLOBAL_OPTION
 {
-    XGL_DBG_OPTION_DEBUG_ECHO_ENABLE = 0x0,
-    XGL_DBG_OPTION_BREAK_ON_ERROR    = 0x1,
-    XGL_DBG_OPTION_BREAK_ON_WARNING  = 0x2,
+    VK_DBG_OPTION_DEBUG_ECHO_ENABLE = 0x0,
+    VK_DBG_OPTION_BREAK_ON_ERROR    = 0x1,
+    VK_DBG_OPTION_BREAK_ON_WARNING  = 0x2,
 
-    XGL_DBG_GLOBAL_OPTION_BEGIN_RANGE = XGL_DBG_OPTION_DEBUG_ECHO_ENABLE,
-    XGL_DBG_GLOBAL_OPTION_END_RANGE   = XGL_DBG_OPTION_BREAK_ON_WARNING,
-    XGL_NUM_DBG_GLOBAL_OPTION         = (XGL_DBG_GLOBAL_OPTION_END_RANGE - XGL_DBG_GLOBAL_OPTION_BEGIN_RANGE + 1),
-} XGL_DBG_GLOBAL_OPTION;
+    VK_DBG_GLOBAL_OPTION_BEGIN_RANGE = VK_DBG_OPTION_DEBUG_ECHO_ENABLE,
+    VK_DBG_GLOBAL_OPTION_END_RANGE   = VK_DBG_OPTION_BREAK_ON_WARNING,
+    VK_NUM_DBG_GLOBAL_OPTION         = (VK_DBG_GLOBAL_OPTION_END_RANGE - VK_DBG_GLOBAL_OPTION_BEGIN_RANGE + 1),
+} VK_DBG_GLOBAL_OPTION;
 
-typedef enum _XGL_DBG_DEVICE_OPTION
+typedef enum _VK_DBG_DEVICE_OPTION
 {
-    XGL_DBG_OPTION_DISABLE_PIPELINE_LOADS      = 0x0,
-    XGL_DBG_OPTION_FORCE_OBJECT_MEMORY_REQS    = 0x1,
-    XGL_DBG_OPTION_FORCE_LARGE_IMAGE_ALIGNMENT = 0x2,
+    VK_DBG_OPTION_DISABLE_PIPELINE_LOADS      = 0x0,
+    VK_DBG_OPTION_FORCE_OBJECT_MEMORY_REQS    = 0x1,
+    VK_DBG_OPTION_FORCE_LARGE_IMAGE_ALIGNMENT = 0x2,
 
-    XGL_DBG_DEVICE_OPTION_BEGIN_RANGE = XGL_DBG_OPTION_DISABLE_PIPELINE_LOADS,
-    XGL_DBG_DEVICE_OPTION_END_RANGE   = XGL_DBG_OPTION_FORCE_LARGE_IMAGE_ALIGNMENT,
-    XGL_NUM_DBG_DEVICE_OPTION         = (XGL_DBG_DEVICE_OPTION_END_RANGE - XGL_DBG_DEVICE_OPTION_BEGIN_RANGE + 1),
-} XGL_DBG_DEVICE_OPTION;
+    VK_DBG_DEVICE_OPTION_BEGIN_RANGE = VK_DBG_OPTION_DISABLE_PIPELINE_LOADS,
+    VK_DBG_DEVICE_OPTION_END_RANGE   = VK_DBG_OPTION_FORCE_LARGE_IMAGE_ALIGNMENT,
+    VK_NUM_DBG_DEVICE_OPTION         = (VK_DBG_DEVICE_OPTION_END_RANGE - VK_DBG_DEVICE_OPTION_BEGIN_RANGE + 1),
+} VK_DBG_DEVICE_OPTION;
 
-typedef enum _XGL_DBG_OBJECT_TYPE
+typedef enum _VK_DBG_OBJECT_TYPE
 {
-    XGL_DBG_OBJECT_UNKNOWN                = 0x00,
-    XGL_DBG_OBJECT_DEVICE                 = 0x01,
-    XGL_DBG_OBJECT_QUEUE                  = 0x02,
-    XGL_DBG_OBJECT_GPU_MEMORY             = 0x03,
-    XGL_DBG_OBJECT_IMAGE                  = 0x04,
-    XGL_DBG_OBJECT_IMAGE_VIEW             = 0x05,
-    XGL_DBG_OBJECT_COLOR_TARGET_VIEW      = 0x06,
-    XGL_DBG_OBJECT_DEPTH_STENCIL_VIEW     = 0x07,
-    XGL_DBG_OBJECT_SHADER                 = 0x08,
-    XGL_DBG_OBJECT_GRAPHICS_PIPELINE      = 0x09,
-    XGL_DBG_OBJECT_COMPUTE_PIPELINE       = 0x0a,
-    XGL_DBG_OBJECT_SAMPLER                = 0x0b,
-    XGL_DBG_OBJECT_DESCRIPTOR_SET         = 0x0c,
-    XGL_DBG_OBJECT_VIEWPORT_STATE         = 0x0d,
-    XGL_DBG_OBJECT_RASTER_STATE           = 0x0e,
-    XGL_DBG_OBJECT_MSAA_STATE             = 0x0f,
-    XGL_DBG_OBJECT_COLOR_BLEND_STATE      = 0x10,
-    XGL_DBG_OBJECT_DEPTH_STENCIL_STATE    = 0x11,
-    XGL_DBG_OBJECT_CMD_BUFFER             = 0x12,
-    XGL_DBG_OBJECT_FENCE                  = 0x13,
-    XGL_DBG_OBJECT_SEMAPHORE              = 0x14,
-    XGL_DBG_OBJECT_EVENT                  = 0x15,
-    XGL_DBG_OBJECT_QUERY_POOL             = 0x16,
-    XGL_DBG_OBJECT_SHARED_GPU_MEMORY      = 0x17,
-    XGL_DBG_OBJECT_SHARED_SEMAPHORE       = 0x18,
-    XGL_DBG_OBJECT_PEER_GPU_MEMORY        = 0x19,
-    XGL_DBG_OBJECT_PEER_IMAGE             = 0x1a,
-    XGL_DBG_OBJECT_PINNED_GPU_MEMORY      = 0x1b,
-    XGL_DBG_OBJECT_INTERNAL_GPU_MEMORY    = 0x1c,
-    XGL_DBG_OBJECT_FRAMEBUFFER            = 0x1d,
-    XGL_DBG_OBJECT_RENDER_PASS            = 0x1e,
+    VK_DBG_OBJECT_UNKNOWN                = 0x00,
+    VK_DBG_OBJECT_DEVICE                 = 0x01,
+    VK_DBG_OBJECT_QUEUE                  = 0x02,
+    VK_DBG_OBJECT_GPU_MEMORY             = 0x03,
+    VK_DBG_OBJECT_IMAGE                  = 0x04,
+    VK_DBG_OBJECT_IMAGE_VIEW             = 0x05,
+    VK_DBG_OBJECT_COLOR_TARGET_VIEW      = 0x06,
+    VK_DBG_OBJECT_DEPTH_STENCIL_VIEW     = 0x07,
+    VK_DBG_OBJECT_SHADER                 = 0x08,
+    VK_DBG_OBJECT_GRAPHICS_PIPELINE      = 0x09,
+    VK_DBG_OBJECT_COMPUTE_PIPELINE       = 0x0a,
+    VK_DBG_OBJECT_SAMPLER                = 0x0b,
+    VK_DBG_OBJECT_DESCRIPTOR_SET         = 0x0c,
+    VK_DBG_OBJECT_VIEWPORT_STATE         = 0x0d,
+    VK_DBG_OBJECT_RASTER_STATE           = 0x0e,
+    VK_DBG_OBJECT_MSAA_STATE             = 0x0f,
+    VK_DBG_OBJECT_COLOR_BLEND_STATE      = 0x10,
+    VK_DBG_OBJECT_DEPTH_STENCIL_STATE    = 0x11,
+    VK_DBG_OBJECT_CMD_BUFFER             = 0x12,
+    VK_DBG_OBJECT_FENCE                  = 0x13,
+    VK_DBG_OBJECT_SEMAPHORE              = 0x14,
+    VK_DBG_OBJECT_EVENT                  = 0x15,
+    VK_DBG_OBJECT_QUERY_POOL             = 0x16,
+    VK_DBG_OBJECT_SHARED_GPU_MEMORY      = 0x17,
+    VK_DBG_OBJECT_SHARED_SEMAPHORE       = 0x18,
+    VK_DBG_OBJECT_PEER_GPU_MEMORY        = 0x19,
+    VK_DBG_OBJECT_PEER_IMAGE             = 0x1a,
+    VK_DBG_OBJECT_PINNED_GPU_MEMORY      = 0x1b,
+    VK_DBG_OBJECT_INTERNAL_GPU_MEMORY    = 0x1c,
+    VK_DBG_OBJECT_FRAMEBUFFER            = 0x1d,
+    VK_DBG_OBJECT_RENDER_PASS            = 0x1e,
 
-    XGL_DBG_OBJECT_INSTANCE,
-    XGL_DBG_OBJECT_BUFFER,
-    XGL_DBG_OBJECT_BUFFER_VIEW,
-    XGL_DBG_OBJECT_DESCRIPTOR_SET_LAYOUT,
-    XGL_DBG_OBJECT_DESCRIPTOR_SET_LAYOUT_CHAIN,
-    XGL_DBG_OBJECT_DESCRIPTOR_POOL,
+    VK_DBG_OBJECT_INSTANCE,
+    VK_DBG_OBJECT_BUFFER,
+    VK_DBG_OBJECT_BUFFER_VIEW,
+    VK_DBG_OBJECT_DESCRIPTOR_SET_LAYOUT,
+    VK_DBG_OBJECT_DESCRIPTOR_SET_LAYOUT_CHAIN,
+    VK_DBG_OBJECT_DESCRIPTOR_POOL,
 
-    XGL_DBG_OBJECT_TYPE_BEGIN_RANGE = XGL_DBG_OBJECT_UNKNOWN,
-    XGL_DBG_OBJECT_TYPE_END_RANGE   = XGL_DBG_OBJECT_DESCRIPTOR_POOL,
-    XGL_NUM_DBG_OBJECT_TYPE         = (XGL_DBG_OBJECT_TYPE_END_RANGE - XGL_DBG_OBJECT_TYPE_BEGIN_RANGE + 1),
-} XGL_DBG_OBJECT_TYPE;
+    VK_DBG_OBJECT_TYPE_BEGIN_RANGE = VK_DBG_OBJECT_UNKNOWN,
+    VK_DBG_OBJECT_TYPE_END_RANGE   = VK_DBG_OBJECT_DESCRIPTOR_POOL,
+    VK_NUM_DBG_OBJECT_TYPE         = (VK_DBG_OBJECT_TYPE_END_RANGE - VK_DBG_OBJECT_TYPE_BEGIN_RANGE + 1),
+} VK_DBG_OBJECT_TYPE;
 
-typedef void (XGLAPI *XGL_DBG_MSG_CALLBACK_FUNCTION)(
-    XGL_DBG_MSG_TYPE     msgType,
-    XGL_VALIDATION_LEVEL validationLevel,
-    XGL_BASE_OBJECT      srcObject,
+typedef void (VKAPI *VK_DBG_MSG_CALLBACK_FUNCTION)(
+    VK_DBG_MSG_TYPE     msgType,
+    VK_VALIDATION_LEVEL validationLevel,
+    VK_BASE_OBJECT      srcObject,
     size_t               location,
     int32_t              msgCode,
     const char*          pMsg,
     void*                pUserData);
 
 // Debug functions
-typedef XGL_RESULT (XGLAPI *xglDbgSetValidationLevelType)(XGL_DEVICE device, XGL_VALIDATION_LEVEL validationLevel);
-typedef XGL_RESULT (XGLAPI *xglDbgRegisterMsgCallbackType)(XGL_INSTANCE instance, XGL_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback, void* pUserData);
-typedef XGL_RESULT (XGLAPI *xglDbgUnregisterMsgCallbackType)(XGL_INSTANCE instance, XGL_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback);
-typedef XGL_RESULT (XGLAPI *xglDbgSetMessageFilterType)(XGL_DEVICE device, int32_t msgCode, XGL_DBG_MSG_FILTER filter);
-typedef XGL_RESULT (XGLAPI *xglDbgSetObjectTagType)(XGL_BASE_OBJECT object, size_t tagSize, const void* pTag);
-typedef XGL_RESULT (XGLAPI *xglDbgSetGlobalOptionType)(XGL_INSTANCE instance, XGL_DBG_GLOBAL_OPTION dbgOption, size_t dataSize, const void* pData);
-typedef XGL_RESULT (XGLAPI *xglDbgSetDeviceOptionType)(XGL_DEVICE device, XGL_DBG_DEVICE_OPTION dbgOption, size_t dataSize, const void* pData);
-typedef void (XGLAPI *xglCmdDbgMarkerBeginType)(XGL_CMD_BUFFER cmdBuffer, const char* pMarker);
-typedef void (XGLAPI *xglCmdDbgMarkerEndType)(XGL_CMD_BUFFER cmdBuffer);
+typedef VK_RESULT (VKAPI *vkDbgSetValidationLevelType)(VK_DEVICE device, VK_VALIDATION_LEVEL validationLevel);
+typedef VK_RESULT (VKAPI *vkDbgRegisterMsgCallbackType)(VK_INSTANCE instance, VK_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback, void* pUserData);
+typedef VK_RESULT (VKAPI *vkDbgUnregisterMsgCallbackType)(VK_INSTANCE instance, VK_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback);
+typedef VK_RESULT (VKAPI *vkDbgSetMessageFilterType)(VK_DEVICE device, int32_t msgCode, VK_DBG_MSG_FILTER filter);
+typedef VK_RESULT (VKAPI *vkDbgSetObjectTagType)(VK_BASE_OBJECT object, size_t tagSize, const void* pTag);
+typedef VK_RESULT (VKAPI *vkDbgSetGlobalOptionType)(VK_INSTANCE instance, VK_DBG_GLOBAL_OPTION dbgOption, size_t dataSize, const void* pData);
+typedef VK_RESULT (VKAPI *vkDbgSetDeviceOptionType)(VK_DEVICE device, VK_DBG_DEVICE_OPTION dbgOption, size_t dataSize, const void* pData);
+typedef void (VKAPI *vkCmdDbgMarkerBeginType)(VK_CMD_BUFFER cmdBuffer, const char* pMarker);
+typedef void (VKAPI *vkCmdDbgMarkerEndType)(VK_CMD_BUFFER cmdBuffer);
 
-#ifdef XGL_PROTOTYPES
-XGL_RESULT XGLAPI xglDbgSetValidationLevel(
-    XGL_DEVICE           device,
-    XGL_VALIDATION_LEVEL validationLevel);
+#ifdef VK_PROTOTYPES
+VK_RESULT VKAPI vkDbgSetValidationLevel(
+    VK_DEVICE           device,
+    VK_VALIDATION_LEVEL validationLevel);
 
-XGL_RESULT XGLAPI xglDbgRegisterMsgCallback(
-    XGL_INSTANCE                  instance,
-    XGL_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback,
+VK_RESULT VKAPI vkDbgRegisterMsgCallback(
+    VK_INSTANCE                  instance,
+    VK_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback,
     void*                         pUserData);
 
-XGL_RESULT XGLAPI xglDbgUnregisterMsgCallback(
-    XGL_INSTANCE                  instance,
-    XGL_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback);
+VK_RESULT VKAPI vkDbgUnregisterMsgCallback(
+    VK_INSTANCE                  instance,
+    VK_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback);
 
-XGL_RESULT XGLAPI xglDbgSetMessageFilter(
-    XGL_DEVICE         device,
+VK_RESULT VKAPI vkDbgSetMessageFilter(
+    VK_DEVICE         device,
     int32_t            msgCode,
-    XGL_DBG_MSG_FILTER filter);
+    VK_DBG_MSG_FILTER filter);
 
-XGL_RESULT XGLAPI xglDbgSetObjectTag(
-    XGL_BASE_OBJECT object,
+VK_RESULT VKAPI vkDbgSetObjectTag(
+    VK_BASE_OBJECT object,
     size_t          tagSize,
     const void*     pTag);
 
-XGL_RESULT XGLAPI xglDbgSetGlobalOption(
-    XGL_INSTANCE          instance,
-    XGL_DBG_GLOBAL_OPTION dbgOption,
+VK_RESULT VKAPI vkDbgSetGlobalOption(
+    VK_INSTANCE          instance,
+    VK_DBG_GLOBAL_OPTION dbgOption,
     size_t                dataSize,
     const void*           pData);
 
-XGL_RESULT XGLAPI xglDbgSetDeviceOption(
-    XGL_DEVICE            device,
-    XGL_DBG_DEVICE_OPTION dbgOption,
+VK_RESULT VKAPI vkDbgSetDeviceOption(
+    VK_DEVICE            device,
+    VK_DBG_DEVICE_OPTION dbgOption,
     size_t                dataSize,
     const void*           pData);
 
-void XGLAPI xglCmdDbgMarkerBegin(
-    XGL_CMD_BUFFER  cmdBuffer,
+void VKAPI vkCmdDbgMarkerBegin(
+    VK_CMD_BUFFER  cmdBuffer,
     const char*     pMarker);
 
-void XGLAPI xglCmdDbgMarkerEnd(
-    XGL_CMD_BUFFER  cmdBuffer);
+void VKAPI vkCmdDbgMarkerEnd(
+    VK_CMD_BUFFER  cmdBuffer);
 
-#endif // XGL_PROTOTYPES
+#endif // VK_PROTOTYPES
 
 #ifdef __cplusplus
 }; // extern "C"
 #endif // __cplusplus
 
-#endif // __XGLDBG_H__
+#endif // __VKDBG_H__
diff --git a/include/xglIcd.h b/include/xglIcd.h
index 1c25936..b7916a8 100644
--- a/include/xglIcd.h
+++ b/include/xglIcd.h
@@ -1,9 +1,9 @@
-#ifndef XGLICD_H
-#define XGLICD_H
+#ifndef VKICD_H
+#define VKICD_H
 
 #include <stdint.h>
 #include <stdbool.h>
-#include "xglPlatform.h"
+#include "vkPlatform.h"
 
 /*
  * The ICD must reserve space for a pointer for the loader's dispatch
@@ -13,20 +13,20 @@
 
 #define ICD_LOADER_MAGIC   0x01CDC0DE
 
-typedef union _XGL_LOADER_DATA {
+typedef union _VK_LOADER_DATA {
   uint32_t loaderMagic;
   void *loaderData;
-} XGL_LOADER_DATA;
+} VK_LOADER_DATA;
 
 static inline void set_loader_magic_value(void *pNewObject) {
-    XGL_LOADER_DATA *loader_info = (XGL_LOADER_DATA *) pNewObject;
+    VK_LOADER_DATA *loader_info = (VK_LOADER_DATA *) pNewObject;
     loader_info->loaderMagic = ICD_LOADER_MAGIC;
 }
 
 static inline bool valid_loader_magic_value(void *pNewObject) {
-    const XGL_LOADER_DATA *loader_info = (XGL_LOADER_DATA *) pNewObject;
+    const VK_LOADER_DATA *loader_info = (VK_LOADER_DATA *) pNewObject;
     return loader_info->loaderMagic == ICD_LOADER_MAGIC;
 }
 
-#endif // XGLICD_H
+#endif // VKICD_H
 
diff --git a/include/xglLayer.h b/include/xglLayer.h
index c3d63a6..c3679a0 100644
--- a/include/xglLayer.h
+++ b/include/xglLayer.h
@@ -4,184 +4,184 @@
  */
 #pragma once
 
-#include "xgl.h"
-#include "xglDbg.h"
+#include "vulkan.h"
+#include "vkDbg.h"
 #if defined(__linux__) || defined(XCB_NVIDIA)
-#include "xglWsiX11Ext.h"
+#include "vkWsiX11Ext.h"
 #endif
 #if defined(__GNUC__) && __GNUC__ >= 4
-#  define XGL_LAYER_EXPORT __attribute__((visibility("default")))
+#  define VK_LAYER_EXPORT __attribute__((visibility("default")))
 #elif defined(__SUNPRO_C) && (__SUNPRO_C >= 0x590)
-#  define XGL_LAYER_EXPORT __attribute__((visibility("default")))
+#  define VK_LAYER_EXPORT __attribute__((visibility("default")))
 #else
-#  define XGL_LAYER_EXPORT
+#  define VK_LAYER_EXPORT
 #endif
 
 
-typedef struct _XGL_BASE_LAYER_OBJECT
+typedef struct _VK_BASE_LAYER_OBJECT
 {
-    xglGetProcAddrType pGPA;
-    XGL_BASE_OBJECT nextObject;
-    XGL_BASE_OBJECT baseObject;
-} XGL_BASE_LAYER_OBJECT;
+    vkGetProcAddrType pGPA;
+    VK_BASE_OBJECT nextObject;
+    VK_BASE_OBJECT baseObject;
+} VK_BASE_LAYER_OBJECT;
 
-typedef struct _XGL_LAYER_DISPATCH_TABLE
+typedef struct _VK_LAYER_DISPATCH_TABLE
 {
-    xglGetProcAddrType GetProcAddr;
-    xglCreateInstanceType CreateInstance;
-    xglDestroyInstanceType DestroyInstance;
-    xglEnumerateGpusType EnumerateGpus;
-    xglGetGpuInfoType GetGpuInfo;
-    xglCreateDeviceType CreateDevice;
-    xglDestroyDeviceType DestroyDevice;
-    xglGetExtensionSupportType GetExtensionSupport;
-    xglEnumerateLayersType EnumerateLayers;
-    xglGetDeviceQueueType GetDeviceQueue;
-    xglQueueSubmitType QueueSubmit;
-    xglQueueAddMemReferenceType QueueAddMemReference;
-    xglQueueRemoveMemReferenceType QueueRemoveMemReference;
-    xglQueueWaitIdleType QueueWaitIdle;
-    xglDeviceWaitIdleType DeviceWaitIdle;
-    xglAllocMemoryType AllocMemory;
-    xglFreeMemoryType FreeMemory;
-    xglSetMemoryPriorityType SetMemoryPriority;
-    xglMapMemoryType MapMemory;
-    xglUnmapMemoryType UnmapMemory;
-    xglPinSystemMemoryType PinSystemMemory;
-    xglGetMultiGpuCompatibilityType GetMultiGpuCompatibility;
-    xglOpenSharedMemoryType OpenSharedMemory;
-    xglOpenSharedSemaphoreType OpenSharedSemaphore;
-    xglOpenPeerMemoryType OpenPeerMemory;
-    xglOpenPeerImageType OpenPeerImage;
-    xglDestroyObjectType DestroyObject;
-    xglGetObjectInfoType GetObjectInfo;
-    xglBindObjectMemoryType BindObjectMemory;
-    xglBindObjectMemoryRangeType BindObjectMemoryRange;
-    xglBindImageMemoryRangeType BindImageMemoryRange;
-    xglCreateFenceType CreateFence;
-    xglGetFenceStatusType GetFenceStatus;
-    xglResetFencesType ResetFences;
-    xglWaitForFencesType WaitForFences;
-    xglCreateSemaphoreType CreateSemaphore;
-    xglQueueSignalSemaphoreType QueueSignalSemaphore;
-    xglQueueWaitSemaphoreType QueueWaitSemaphore;
-    xglCreateEventType CreateEvent;
-    xglGetEventStatusType GetEventStatus;
-    xglSetEventType SetEvent;
-    xglResetEventType ResetEvent;
-    xglCreateQueryPoolType CreateQueryPool;
-    xglGetQueryPoolResultsType GetQueryPoolResults;
-    xglGetFormatInfoType GetFormatInfo;
-    xglCreateBufferType CreateBuffer;
-    xglCreateBufferViewType CreateBufferView;
-    xglCreateImageType CreateImage;
-    xglGetImageSubresourceInfoType GetImageSubresourceInfo;
-    xglCreateImageViewType CreateImageView;
-    xglCreateColorAttachmentViewType CreateColorAttachmentView;
-    xglCreateDepthStencilViewType CreateDepthStencilView;
-    xglCreateShaderType CreateShader;
-    xglCreateGraphicsPipelineType CreateGraphicsPipeline;
-    xglCreateGraphicsPipelineDerivativeType CreateGraphicsPipelineDerivative;
-    xglCreateComputePipelineType CreateComputePipeline;
-    xglStorePipelineType StorePipeline;
-    xglLoadPipelineType LoadPipeline;
-    xglLoadPipelineDerivativeType LoadPipelineDerivative;
-    xglCreateSamplerType CreateSampler;
-    xglCreateDescriptorSetLayoutType CreateDescriptorSetLayout;
-    xglCreateDescriptorSetLayoutChainType CreateDescriptorSetLayoutChain;
-    xglBeginDescriptorPoolUpdateType BeginDescriptorPoolUpdate;
-    xglEndDescriptorPoolUpdateType EndDescriptorPoolUpdate;
-    xglCreateDescriptorPoolType CreateDescriptorPool;
-    xglResetDescriptorPoolType ResetDescriptorPool;
-    xglAllocDescriptorSetsType AllocDescriptorSets;
-    xglClearDescriptorSetsType ClearDescriptorSets;
-    xglUpdateDescriptorsType UpdateDescriptors;
-    xglCreateDynamicViewportStateType CreateDynamicViewportState;
-    xglCreateDynamicRasterStateType CreateDynamicRasterState;
-    xglCreateDynamicColorBlendStateType CreateDynamicColorBlendState;
-    xglCreateDynamicDepthStencilStateType CreateDynamicDepthStencilState;
-    xglCreateCommandBufferType CreateCommandBuffer;
-    xglBeginCommandBufferType BeginCommandBuffer;
-    xglEndCommandBufferType EndCommandBuffer;
-    xglResetCommandBufferType ResetCommandBuffer;
-    xglCmdBindPipelineType CmdBindPipeline;
-    xglCmdBindDynamicStateObjectType CmdBindDynamicStateObject;
-    xglCmdBindDescriptorSetsType CmdBindDescriptorSets;
-    xglCmdBindVertexBufferType CmdBindVertexBuffer;
-    xglCmdBindIndexBufferType CmdBindIndexBuffer;
-    xglCmdDrawType CmdDraw;
-    xglCmdDrawIndexedType CmdDrawIndexed;
-    xglCmdDrawIndirectType CmdDrawIndirect;
-    xglCmdDrawIndexedIndirectType CmdDrawIndexedIndirect;
-    xglCmdDispatchType CmdDispatch;
-    xglCmdDispatchIndirectType CmdDispatchIndirect;
-    xglCmdCopyBufferType CmdCopyBuffer;
-    xglCmdCopyImageType CmdCopyImage;
-    xglCmdBlitImageType CmdBlitImage;
-    xglCmdCopyBufferToImageType CmdCopyBufferToImage;
-    xglCmdCopyImageToBufferType CmdCopyImageToBuffer;
-    xglCmdCloneImageDataType CmdCloneImageData;
-    xglCmdUpdateBufferType CmdUpdateBuffer;
-    xglCmdFillBufferType CmdFillBuffer;
-    xglCmdClearColorImageType CmdClearColorImage;
-    xglCmdClearDepthStencilType CmdClearDepthStencil;
-    xglCmdResolveImageType CmdResolveImage;
-    xglCmdSetEventType CmdSetEvent;
-    xglCmdResetEventType CmdResetEvent;
-    xglCmdWaitEventsType CmdWaitEvents;
-    xglCmdPipelineBarrierType CmdPipelineBarrier;
-    xglCmdBeginQueryType CmdBeginQuery;
-    xglCmdEndQueryType CmdEndQuery;
-    xglCmdResetQueryPoolType CmdResetQueryPool;
-    xglCmdWriteTimestampType CmdWriteTimestamp;
-    xglCmdInitAtomicCountersType CmdInitAtomicCounters;
-    xglCmdLoadAtomicCountersType CmdLoadAtomicCounters;
-    xglCmdSaveAtomicCountersType CmdSaveAtomicCounters;
-    xglCreateFramebufferType CreateFramebuffer;
-    xglCreateRenderPassType CreateRenderPass;
-    xglCmdBeginRenderPassType CmdBeginRenderPass;
-    xglCmdEndRenderPassType CmdEndRenderPass;
-    xglDbgSetValidationLevelType DbgSetValidationLevel;
-    xglDbgRegisterMsgCallbackType DbgRegisterMsgCallback;
-    xglDbgUnregisterMsgCallbackType DbgUnregisterMsgCallback;
-    xglDbgSetMessageFilterType DbgSetMessageFilter;
-    xglDbgSetObjectTagType DbgSetObjectTag;
-    xglDbgSetGlobalOptionType DbgSetGlobalOption;
-    xglDbgSetDeviceOptionType DbgSetDeviceOption;
-    xglCmdDbgMarkerBeginType CmdDbgMarkerBegin;
-    xglCmdDbgMarkerEndType CmdDbgMarkerEnd;
+    vkGetProcAddrType GetProcAddr;
+    vkCreateInstanceType CreateInstance;
+    vkDestroyInstanceType DestroyInstance;
+    vkEnumerateGpusType EnumerateGpus;
+    vkGetGpuInfoType GetGpuInfo;
+    vkCreateDeviceType CreateDevice;
+    vkDestroyDeviceType DestroyDevice;
+    vkGetExtensionSupportType GetExtensionSupport;
+    vkEnumerateLayersType EnumerateLayers;
+    vkGetDeviceQueueType GetDeviceQueue;
+    vkQueueSubmitType QueueSubmit;
+    vkQueueAddMemReferenceType QueueAddMemReference;
+    vkQueueRemoveMemReferenceType QueueRemoveMemReference;
+    vkQueueWaitIdleType QueueWaitIdle;
+    vkDeviceWaitIdleType DeviceWaitIdle;
+    vkAllocMemoryType AllocMemory;
+    vkFreeMemoryType FreeMemory;
+    vkSetMemoryPriorityType SetMemoryPriority;
+    vkMapMemoryType MapMemory;
+    vkUnmapMemoryType UnmapMemory;
+    vkPinSystemMemoryType PinSystemMemory;
+    vkGetMultiGpuCompatibilityType GetMultiGpuCompatibility;
+    vkOpenSharedMemoryType OpenSharedMemory;
+    vkOpenSharedSemaphoreType OpenSharedSemaphore;
+    vkOpenPeerMemoryType OpenPeerMemory;
+    vkOpenPeerImageType OpenPeerImage;
+    vkDestroyObjectType DestroyObject;
+    vkGetObjectInfoType GetObjectInfo;
+    vkBindObjectMemoryType BindObjectMemory;
+    vkBindObjectMemoryRangeType BindObjectMemoryRange;
+    vkBindImageMemoryRangeType BindImageMemoryRange;
+    vkCreateFenceType CreateFence;
+    vkGetFenceStatusType GetFenceStatus;
+    vkResetFencesType ResetFences;
+    vkWaitForFencesType WaitForFences;
+    vkCreateSemaphoreType CreateSemaphore;
+    vkQueueSignalSemaphoreType QueueSignalSemaphore;
+    vkQueueWaitSemaphoreType QueueWaitSemaphore;
+    vkCreateEventType CreateEvent;
+    vkGetEventStatusType GetEventStatus;
+    vkSetEventType SetEvent;
+    vkResetEventType ResetEvent;
+    vkCreateQueryPoolType CreateQueryPool;
+    vkGetQueryPoolResultsType GetQueryPoolResults;
+    vkGetFormatInfoType GetFormatInfo;
+    vkCreateBufferType CreateBuffer;
+    vkCreateBufferViewType CreateBufferView;
+    vkCreateImageType CreateImage;
+    vkGetImageSubresourceInfoType GetImageSubresourceInfo;
+    vkCreateImageViewType CreateImageView;
+    vkCreateColorAttachmentViewType CreateColorAttachmentView;
+    vkCreateDepthStencilViewType CreateDepthStencilView;
+    vkCreateShaderType CreateShader;
+    vkCreateGraphicsPipelineType CreateGraphicsPipeline;
+    vkCreateGraphicsPipelineDerivativeType CreateGraphicsPipelineDerivative;
+    vkCreateComputePipelineType CreateComputePipeline;
+    vkStorePipelineType StorePipeline;
+    vkLoadPipelineType LoadPipeline;
+    vkLoadPipelineDerivativeType LoadPipelineDerivative;
+    vkCreateSamplerType CreateSampler;
+    vkCreateDescriptorSetLayoutType CreateDescriptorSetLayout;
+    vkCreateDescriptorSetLayoutChainType CreateDescriptorSetLayoutChain;
+    vkBeginDescriptorPoolUpdateType BeginDescriptorPoolUpdate;
+    vkEndDescriptorPoolUpdateType EndDescriptorPoolUpdate;
+    vkCreateDescriptorPoolType CreateDescriptorPool;
+    vkResetDescriptorPoolType ResetDescriptorPool;
+    vkAllocDescriptorSetsType AllocDescriptorSets;
+    vkClearDescriptorSetsType ClearDescriptorSets;
+    vkUpdateDescriptorsType UpdateDescriptors;
+    vkCreateDynamicViewportStateType CreateDynamicViewportState;
+    vkCreateDynamicRasterStateType CreateDynamicRasterState;
+    vkCreateDynamicColorBlendStateType CreateDynamicColorBlendState;
+    vkCreateDynamicDepthStencilStateType CreateDynamicDepthStencilState;
+    vkCreateCommandBufferType CreateCommandBuffer;
+    vkBeginCommandBufferType BeginCommandBuffer;
+    vkEndCommandBufferType EndCommandBuffer;
+    vkResetCommandBufferType ResetCommandBuffer;
+    vkCmdBindPipelineType CmdBindPipeline;
+    vkCmdBindDynamicStateObjectType CmdBindDynamicStateObject;
+    vkCmdBindDescriptorSetsType CmdBindDescriptorSets;
+    vkCmdBindVertexBufferType CmdBindVertexBuffer;
+    vkCmdBindIndexBufferType CmdBindIndexBuffer;
+    vkCmdDrawType CmdDraw;
+    vkCmdDrawIndexedType CmdDrawIndexed;
+    vkCmdDrawIndirectType CmdDrawIndirect;
+    vkCmdDrawIndexedIndirectType CmdDrawIndexedIndirect;
+    vkCmdDispatchType CmdDispatch;
+    vkCmdDispatchIndirectType CmdDispatchIndirect;
+    vkCmdCopyBufferType CmdCopyBuffer;
+    vkCmdCopyImageType CmdCopyImage;
+    vkCmdBlitImageType CmdBlitImage;
+    vkCmdCopyBufferToImageType CmdCopyBufferToImage;
+    vkCmdCopyImageToBufferType CmdCopyImageToBuffer;
+    vkCmdCloneImageDataType CmdCloneImageData;
+    vkCmdUpdateBufferType CmdUpdateBuffer;
+    vkCmdFillBufferType CmdFillBuffer;
+    vkCmdClearColorImageType CmdClearColorImage;
+    vkCmdClearDepthStencilType CmdClearDepthStencil;
+    vkCmdResolveImageType CmdResolveImage;
+    vkCmdSetEventType CmdSetEvent;
+    vkCmdResetEventType CmdResetEvent;
+    vkCmdWaitEventsType CmdWaitEvents;
+    vkCmdPipelineBarrierType CmdPipelineBarrier;
+    vkCmdBeginQueryType CmdBeginQuery;
+    vkCmdEndQueryType CmdEndQuery;
+    vkCmdResetQueryPoolType CmdResetQueryPool;
+    vkCmdWriteTimestampType CmdWriteTimestamp;
+    vkCmdInitAtomicCountersType CmdInitAtomicCounters;
+    vkCmdLoadAtomicCountersType CmdLoadAtomicCounters;
+    vkCmdSaveAtomicCountersType CmdSaveAtomicCounters;
+    vkCreateFramebufferType CreateFramebuffer;
+    vkCreateRenderPassType CreateRenderPass;
+    vkCmdBeginRenderPassType CmdBeginRenderPass;
+    vkCmdEndRenderPassType CmdEndRenderPass;
+    vkDbgSetValidationLevelType DbgSetValidationLevel;
+    vkDbgRegisterMsgCallbackType DbgRegisterMsgCallback;
+    vkDbgUnregisterMsgCallbackType DbgUnregisterMsgCallback;
+    vkDbgSetMessageFilterType DbgSetMessageFilter;
+    vkDbgSetObjectTagType DbgSetObjectTag;
+    vkDbgSetGlobalOptionType DbgSetGlobalOption;
+    vkDbgSetDeviceOptionType DbgSetDeviceOption;
+    vkCmdDbgMarkerBeginType CmdDbgMarkerBegin;
+    vkCmdDbgMarkerEndType CmdDbgMarkerEnd;
 #if defined(__linux__) || defined(XCB_NVIDIA)
-    xglWsiX11AssociateConnectionType WsiX11AssociateConnection;
-    xglWsiX11GetMSCType WsiX11GetMSC;
-    xglWsiX11CreatePresentableImageType WsiX11CreatePresentableImage;
-    xglWsiX11QueuePresentType WsiX11QueuePresent;
+    vkWsiX11AssociateConnectionType WsiX11AssociateConnection;
+    vkWsiX11GetMSCType WsiX11GetMSC;
+    vkWsiX11CreatePresentableImageType WsiX11CreatePresentableImage;
+    vkWsiX11QueuePresentType WsiX11QueuePresent;
 #endif // WIN32
-} XGL_LAYER_DISPATCH_TABLE;
+} VK_LAYER_DISPATCH_TABLE;
 
 // LL node for tree of dbg callback functions
-typedef struct _XGL_LAYER_DBG_FUNCTION_NODE
+typedef struct _VK_LAYER_DBG_FUNCTION_NODE
 {
-    XGL_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback;
+    VK_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback;
     void *pUserData;
-    struct _XGL_LAYER_DBG_FUNCTION_NODE *pNext;
-} XGL_LAYER_DBG_FUNCTION_NODE;
+    struct _VK_LAYER_DBG_FUNCTION_NODE *pNext;
+} VK_LAYER_DBG_FUNCTION_NODE;
 
-typedef enum _XGL_LAYER_DBG_ACTION
+typedef enum _VK_LAYER_DBG_ACTION
 {
-    XGL_DBG_LAYER_ACTION_IGNORE = 0x0,
-    XGL_DBG_LAYER_ACTION_CALLBACK = 0x1,
-    XGL_DBG_LAYER_ACTION_LOG_MSG = 0x2,
-    XGL_DBG_LAYER_ACTION_BREAK = 0x4
-} XGL_LAYER_DBG_ACTION;
+    VK_DBG_LAYER_ACTION_IGNORE = 0x0,
+    VK_DBG_LAYER_ACTION_CALLBACK = 0x1,
+    VK_DBG_LAYER_ACTION_LOG_MSG = 0x2,
+    VK_DBG_LAYER_ACTION_BREAK = 0x4
+} VK_LAYER_DBG_ACTION;
 
-typedef enum _XGL_LAYER_DBG_REPORT_LEVEL
+typedef enum _VK_LAYER_DBG_REPORT_LEVEL
 {
 
-    XGL_DBG_LAYER_LEVEL_INFO = 0,
-    XGL_DBG_LAYER_LEVEL_WARN,
-    XGL_DBG_LAYER_LEVEL_PERF_WARN,
-    XGL_DBG_LAYER_LEVEL_ERROR,
-    XGL_DBG_LAYER_LEVEL_NONE,
-} XGL_LAYER_DBG_REPORT_LEVEL;
+    VK_DBG_LAYER_LEVEL_INFO = 0,
+    VK_DBG_LAYER_LEVEL_WARN,
+    VK_DBG_LAYER_LEVEL_PERF_WARN,
+    VK_DBG_LAYER_LEVEL_ERROR,
+    VK_DBG_LAYER_LEVEL_NONE,
+} VK_LAYER_DBG_REPORT_LEVEL;
 // ------------------------------------------------------------------------------------------------
 // API functions
diff --git a/include/xglPlatform.h b/include/xglPlatform.h
index fcd3d59..526a1de 100644
--- a/include/xglPlatform.h
+++ b/include/xglPlatform.h
@@ -1,5 +1,5 @@
 //
-// File: xglPlatform.h
+// File: vkPlatform.h
 //
 /*
 ** Copyright (c) 2014 The Khronos Group Inc.
@@ -25,8 +25,8 @@
 */
 
 
-#ifndef __XGLPLATFORM_H__
-#define __XGLPLATFORM_H__
+#ifndef __VKPLATFORM_H__
+#define __VKPLATFORM_H__
 
 #ifdef __cplusplus
 extern "C"
@@ -43,8 +43,8 @@
     // Ensure we don't pick up min/max macros from Winddef.h
     #define NOMINMAX
 
-    // On Windows, XGLAPI should equate to the __stdcall convention
-    #define XGLAPI   __stdcall
+    // On Windows, VKAPI should equate to the __stdcall convention
+    #define VKAPI   __stdcall
 
     // C99:
 #ifndef __cplusplus
@@ -52,8 +52,8 @@
     #define inline __inline
 #endif // __cplusplus
 #elif defined(__GNUC__)
-    // On other platforms using GCC, XGLAPI stays undefined
-    #define XGLAPI
+    // On other platforms using GCC, VKAPI stays undefined
+    #define VKAPI
 #else
     // Unsupported Platform!
     #error "Unsupported OS Platform detected!"
@@ -61,7 +61,7 @@
 
 #include <stddef.h>
 
-#if !defined(XGL_NO_STDINT_H)
+#if !defined(VK_NO_STDINT_H)
     #if defined(_MSC_VER) && (_MSC_VER < 1600)
         typedef signed   __int8  int8_t;
         typedef unsigned __int8  uint8_t;
@@ -74,17 +74,17 @@
     #else
         #include <stdint.h>
     #endif
-#endif // !defined(XGL_NO_STDINT_H)
+#endif // !defined(VK_NO_STDINT_H)
 
-typedef uint64_t   XGL_GPU_SIZE;
+typedef uint64_t   VK_GPU_SIZE;
 typedef uint32_t   bool32_t;
 
-typedef uint32_t   XGL_SAMPLE_MASK;
-typedef uint32_t   XGL_FLAGS;
-typedef int32_t    XGL_ENUM;
+typedef uint32_t   VK_SAMPLE_MASK;
+typedef uint32_t   VK_FLAGS;
+typedef int32_t    VK_ENUM;
 
 #ifdef __cplusplus
 } // extern "C"
 #endif // __cplusplus
 
-#endif // __XGLPLATFORM_H__
+#endif // __VKPLATFORM_H__
diff --git a/include/xglWsiWinExt.h b/include/xglWsiWinExt.h
index b93841b..f3ee0f3 100644
--- a/include/xglWsiWinExt.h
+++ b/include/xglWsiWinExt.h
@@ -1,14 +1,14 @@
 /* IN DEVELOPMENT.  DO NOT SHIP. */
 
-#ifndef __XGLWSIWINEXT_H__
-#define __XGLWSIWINEXT_H__
+#ifndef __VKWSIWINEXT_H__
+#define __VKWSIWINEXT_H__
 
 // This is just to get windows to build.
 // Need to replace with the declarations for Windows wsi.
-typedef void XGL_WSI_X11_CONNECTION_INFO;
+typedef void VK_WSI_X11_CONNECTION_INFO;
 typedef unsigned int xcb_window_t;
 typedef unsigned int xcb_randr_crtc_t;
-typedef void XGL_WSI_X11_PRESENTABLE_IMAGE_CREATE_INFO;
-typedef void XGL_WSI_X11_PRESENT_INFO;
+typedef void VK_WSI_X11_PRESENTABLE_IMAGE_CREATE_INFO;
+typedef void VK_WSI_X11_PRESENT_INFO;
 
-#endif // __XGLWSIWINEXT_H__
+#endif // __VKWSIWINEXT_H__
diff --git a/include/xglWsiX11Ext.h b/include/xglWsiX11Ext.h
index 5235758..f704637 100644
--- a/include/xglWsiX11Ext.h
+++ b/include/xglWsiX11Ext.h
@@ -1,36 +1,36 @@
 /* IN DEVELOPMENT.  DO NOT SHIP. */
 
-#ifndef __XGLWSIX11EXT_H__
-#define __XGLWSIX11EXT_H__
+#ifndef __VKWSIX11EXT_H__
+#define __VKWSIX11EXT_H__
 
 #include <xcb/xcb.h>
 #include <xcb/randr.h>
-#include "xgl.h"
+#include "vulkan.h"
 
 #ifdef __cplusplus
 extern "C"
 {
 #endif // __cplusplus
 
-typedef struct _XGL_WSI_X11_CONNECTION_INFO {
+typedef struct _VK_WSI_X11_CONNECTION_INFO {
     xcb_connection_t*                           pConnection;
     xcb_window_t                                root;
     xcb_randr_provider_t                        provider;
-} XGL_WSI_X11_CONNECTION_INFO;
+} VK_WSI_X11_CONNECTION_INFO;
 
-typedef struct _XGL_WSI_X11_PRESENTABLE_IMAGE_CREATE_INFO
+typedef struct _VK_WSI_X11_PRESENTABLE_IMAGE_CREATE_INFO
 {
-    XGL_FORMAT          format;
-    XGL_FLAGS           usage;           // XGL_IMAGE_USAGE_FLAGS
-    XGL_EXTENT2D        extent;
-    XGL_FLAGS           flags;
-} XGL_WSI_X11_PRESENTABLE_IMAGE_CREATE_INFO;
+    VK_FORMAT          format;
+    VK_FLAGS           usage;           // VK_IMAGE_USAGE_FLAGS
+    VK_EXTENT2D        extent;
+    VK_FLAGS           flags;
+} VK_WSI_X11_PRESENTABLE_IMAGE_CREATE_INFO;
 
-typedef struct _XGL_WSI_X11_PRESENT_INFO
+typedef struct _VK_WSI_X11_PRESENT_INFO
 {
     /* which window to present to */
     xcb_window_t destWindow;
-    XGL_IMAGE srcImage;
+    VK_IMAGE srcImage;
 
     /**
      * After the command buffers in the queue have been completed, if the MSC
@@ -49,7 +49,7 @@
      *   }
      *
      * In other words, either set \p target_msc to an absolute value (require
-     * xglWsiX11GetMSC(), potentially a round-trip to the server, to get the
+     * vkWsiX11GetMSC(), potentially a round-trip to the server, to get the
      * current MSC first), or set \p target_msc to zero and set a "swap
      * interval".
      *
@@ -78,66 +78,66 @@
      * be flipped to.
      */
     bool32_t flip;
-} XGL_WSI_X11_PRESENT_INFO;
+} VK_WSI_X11_PRESENT_INFO;
 
-typedef XGL_RESULT (XGLAPI *xglWsiX11AssociateConnectionType)(XGL_PHYSICAL_GPU gpu, const XGL_WSI_X11_CONNECTION_INFO* pConnectionInfo);
-typedef XGL_RESULT (XGLAPI *xglWsiX11GetMSCType)(XGL_DEVICE device, xcb_window_t window, xcb_randr_crtc_t crtc, uint64_t* pMsc);
-typedef XGL_RESULT (XGLAPI *xglWsiX11CreatePresentableImageType)(XGL_DEVICE device, const XGL_WSI_X11_PRESENTABLE_IMAGE_CREATE_INFO* pCreateInfo, XGL_IMAGE* pImage, XGL_GPU_MEMORY* pMem);
-typedef XGL_RESULT (XGLAPI *xglWsiX11QueuePresentType)(XGL_QUEUE queue, const XGL_WSI_X11_PRESENT_INFO* pPresentInfo, XGL_FENCE fence);
+typedef VK_RESULT (VKAPI *vkWsiX11AssociateConnectionType)(VK_PHYSICAL_GPU gpu, const VK_WSI_X11_CONNECTION_INFO* pConnectionInfo);
+typedef VK_RESULT (VKAPI *vkWsiX11GetMSCType)(VK_DEVICE device, xcb_window_t window, xcb_randr_crtc_t crtc, uint64_t* pMsc);
+typedef VK_RESULT (VKAPI *vkWsiX11CreatePresentableImageType)(VK_DEVICE device, const VK_WSI_X11_PRESENTABLE_IMAGE_CREATE_INFO* pCreateInfo, VK_IMAGE* pImage, VK_GPU_MEMORY* pMem);
+typedef VK_RESULT (VKAPI *vkWsiX11QueuePresentType)(VK_QUEUE queue, const VK_WSI_X11_PRESENT_INFO* pPresentInfo, VK_FENCE fence);
 
 /**
  * Associate an X11 connection with a GPU.  This should be done before device
  * creation.  If the device is already created,
- * XGL_ERROR_DEVICE_ALREADY_CREATED is returned.
+ * VK_ERROR_DEVICE_ALREADY_CREATED is returned.
  *
  * Truth is, given a connection, we could find the associated GPU.  But
  * without having a GPU as the first parameter, the loader could not find the
  * dispatch table.
  *
- * This function is available when xglGetExtensionSupport says "XGL_WSI_X11"
+ * This function is available when vkGetExtensionSupport says "VK_WSI_X11"
  * is supported.
  */
-XGL_RESULT XGLAPI xglWsiX11AssociateConnection(
-    XGL_PHYSICAL_GPU                            gpu,
-    const XGL_WSI_X11_CONNECTION_INFO*          pConnectionInfo);
+VK_RESULT VKAPI vkWsiX11AssociateConnection(
+    VK_PHYSICAL_GPU                            gpu,
+    const VK_WSI_X11_CONNECTION_INFO*          pConnectionInfo);
 
 /**
  * Return the current MSC (Media Stream Counter, incremented for each vblank)
  * of \p crtc.  If crtc is \p XCB_NONE, a suitable CRTC is picked based on \p
  * win.
  */
-XGL_RESULT XGLAPI xglWsiX11GetMSC(
-    XGL_DEVICE                                  device,
+VK_RESULT VKAPI vkWsiX11GetMSC(
+    VK_DEVICE                                  device,
     xcb_window_t                                window,
     xcb_randr_crtc_t                            crtc,
     uint64_t*                                   pMsc);
 
 /**
- * Create an XGL_IMAGE that can be presented.  An XGL_GPU_MEMORY is created
+ * Create an VK_IMAGE that can be presented.  An VK_GPU_MEMORY is created
  * and bound automatically.  The memory returned can only be used in
- * xglQueue[Add|Remove]MemReference.  Destroying the memory or binding another memory to the
+ * vkQueue[Add|Remove]MemReference.  Destroying the memory or binding another memory to the
  * image is not allowed.
  */
-XGL_RESULT XGLAPI xglWsiX11CreatePresentableImage(
-    XGL_DEVICE                                  device,
-    const XGL_WSI_X11_PRESENTABLE_IMAGE_CREATE_INFO* pCreateInfo,
-    XGL_IMAGE*                                  pImage,
-    XGL_GPU_MEMORY*                             pMem);
+VK_RESULT VKAPI vkWsiX11CreatePresentableImage(
+    VK_DEVICE                                  device,
+    const VK_WSI_X11_PRESENTABLE_IMAGE_CREATE_INFO* pCreateInfo,
+    VK_IMAGE*                                  pImage,
+    VK_GPU_MEMORY*                             pMem);
 
 /**
  * Present an image to an X11 window.  The presentation always occurs after
  * the command buffers in the queue have been completed, subject to other
- * parameters specified in XGL_WSI_X11_PRESENT_INFO.
+ * parameters specified in VK_WSI_X11_PRESENT_INFO.
  *
  * Fence is reached when the presentation occurs.
  */
-XGL_RESULT XGLAPI xglWsiX11QueuePresent(
-    XGL_QUEUE                                   queue,
-    const XGL_WSI_X11_PRESENT_INFO*             pPresentInfo,
-    XGL_FENCE                                   fence);
+VK_RESULT VKAPI vkWsiX11QueuePresent(
+    VK_QUEUE                                   queue,
+    const VK_WSI_X11_PRESENT_INFO*             pPresentInfo,
+    VK_FENCE                                   fence);
 
 #ifdef __cplusplus
 } // extern "C"
 #endif // __cplusplus
 
-#endif // __XGLWSIX11EXT_H__
+#endif // __VKWSIX11EXT_H__
diff --git a/layers/CMakeLists.txt b/layers/CMakeLists.txt
index 3a9c3e8..7e3bf59 100644
--- a/layers/CMakeLists.txt
+++ b/layers/CMakeLists.txt
@@ -1,37 +1,37 @@
 cmake_minimum_required (VERSION 2.8.11)
 
-macro(run_xgl_helper subcmd)
+macro(run_vk_helper subcmd)
 	add_custom_command(OUTPUT ${ARGN}
-		COMMAND ${PYTHON_CMD} ${PROJECT_SOURCE_DIR}/xgl_helper.py --${subcmd} ${PROJECT_SOURCE_DIR}/include/xgl.h --abs_out_dir ${CMAKE_CURRENT_BINARY_DIR}
-		DEPENDS ${PROJECT_SOURCE_DIR}/xgl_helper.py ${PROJECT_SOURCE_DIR}/include/xgl.h
+		COMMAND ${PYTHON_CMD} ${PROJECT_SOURCE_DIR}/vk_helper.py --${subcmd} ${PROJECT_SOURCE_DIR}/include/vulkan.h --abs_out_dir ${CMAKE_CURRENT_BINARY_DIR}
+		DEPENDS ${PROJECT_SOURCE_DIR}/vk_helper.py ${PROJECT_SOURCE_DIR}/include/vulkan.h
 	)
 endmacro()
 
-macro(run_xgl_layer_generate subcmd output)
+macro(run_vk_layer_generate subcmd output)
 	add_custom_command(OUTPUT ${output}
-		COMMAND ${PYTHON_CMD} ${PROJECT_SOURCE_DIR}/xgl-layer-generate.py ${subcmd} ${PROJECT_SOURCE_DIR}/include/xgl.h > ${output}
-		DEPENDS ${PROJECT_SOURCE_DIR}/xgl-layer-generate.py ${PROJECT_SOURCE_DIR}/include/xgl.h ${PROJECT_SOURCE_DIR}/xgl.py
+		COMMAND ${PYTHON_CMD} ${PROJECT_SOURCE_DIR}/xgl-layer-generate.py ${subcmd} ${PROJECT_SOURCE_DIR}/include/vulkan.h > ${output}
+		DEPENDS ${PROJECT_SOURCE_DIR}/xgl-layer-generate.py ${PROJECT_SOURCE_DIR}/include/vulkan.h ${PROJECT_SOURCE_DIR}/xgl.py
 	)
 endmacro()
 
 if (WIN32)
-    macro(add_xgl_layer target)
-	add_custom_command(OUTPUT XGLLayer${target}.def
-		COMMAND ${PYTHON_CMD} ${PROJECT_SOURCE_DIR}/xgl-generate.py win-def-file XGLLayer${target} layer > XGLLayer${target}.def
+    macro(add_vk_layer target)
+	add_custom_command(OUTPUT VKLayer${target}.def
+		COMMAND ${PYTHON_CMD} ${PROJECT_SOURCE_DIR}/xgl-generate.py win-def-file VKLayer${target} layer > VKLayer${target}.def
 		DEPENDS ${PROJECT_SOURCE_DIR}/xgl-generate.py ${PROJECT_SOURCE_DIR}/xgl.py
 	)
-	add_library(XGLLayer${target} SHARED ${ARGN} XGLLayer${target}.def)
-        target_link_Libraries(XGLLayer${target} layer_utils)
-	add_dependencies(XGLLayer${target} generate_xgl_layer_helpers)
-	add_dependencies(XGLLayer${target} ${CMAKE_CURRENT_BINARY_DIR}/XGLLayer${target}.def)
-	set_target_properties(XGLLayer${target} PROPERTIES LINK_FLAGS "/DEF:${CMAKE_CURRENT_BINARY_DIR}/XGLLayer${target}.def")
+	add_library(VKLayer${target} SHARED ${ARGN} VKLayer${target}.def)
+        target_link_Libraries(VKLayer${target} layer_utils)
+	add_dependencies(VKLayer${target} generate_vk_layer_helpers)
+	add_dependencies(VKLayer${target} ${CMAKE_CURRENT_BINARY_DIR}/VKLayer${target}.def)
+	set_target_properties(VKLayer${target} PROPERTIES LINK_FLAGS "/DEF:${CMAKE_CURRENT_BINARY_DIR}/VKLayer${target}.def")
     endmacro()
 else()
-    macro(add_xgl_layer target)
-	add_library(XGLLayer${target} SHARED ${ARGN})
-        target_link_Libraries(XGLLayer${target} layer_utils)
-	add_dependencies(XGLLayer${target} generate_xgl_layer_helpers)
-	set_target_properties(XGLLayer${target} PROPERTIES LINK_FLAGS "-Wl,-Bsymbolic")
+    macro(add_vk_layer target)
+	add_library(VKLayer${target} SHARED ${ARGN})
+        target_link_Libraries(VKLayer${target} layer_utils)
+	add_dependencies(VKLayer${target} generate_vk_layer_helpers)
+	set_target_properties(VKLayer${target} PROPERTIES LINK_FLAGS "-Wl,-Bsymbolic")
     endmacro()
 endif()
 
@@ -42,58 +42,58 @@
 )
 
 if (WIN32)
-    set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DXGL_PROTOTYPES -D_CRT_SECURE_NO_WARNINGS")
-    set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DXGL_PROTOTYPES -D_CRT_SECURE_NO_WARNINGS")
+    set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DVK_PROTOTYPES -D_CRT_SECURE_NO_WARNINGS")
+    set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DVK_PROTOTYPES -D_CRT_SECURE_NO_WARNINGS")
 endif()
 if (NOT WIN32)
     set (CMAKE_CXX_FLAGS "-std=c++11")
-    set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DXGL_PROTOTYPES -Wpointer-arith")
-    set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DXGL_PROTOTYPES -Wpointer-arith")
+    set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DVK_PROTOTYPES -Wpointer-arith")
+    set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DVK_PROTOTYPES -Wpointer-arith")
 endif()
 
-add_custom_command(OUTPUT xgl_dispatch_table_helper.h
-	COMMAND ${PYTHON_CMD} ${PROJECT_SOURCE_DIR}/xgl-generate.py dispatch-table-ops layer > xgl_dispatch_table_helper.h
+add_custom_command(OUTPUT vk_dispatch_table_helper.h
+	COMMAND ${PYTHON_CMD} ${PROJECT_SOURCE_DIR}/xgl-generate.py dispatch-table-ops layer > vk_dispatch_table_helper.h
 	DEPENDS ${PROJECT_SOURCE_DIR}/xgl-generate.py ${PROJECT_SOURCE_DIR}/xgl.py)
 
-add_custom_command(OUTPUT xgl_generic_intercept_proc_helper.h
-	COMMAND ${PYTHON_CMD} ${PROJECT_SOURCE_DIR}/xgl-generate.py layer-intercept-proc > xgl_generic_intercept_proc_helper.h
+add_custom_command(OUTPUT vk_generic_intercept_proc_helper.h
+	COMMAND ${PYTHON_CMD} ${PROJECT_SOURCE_DIR}/xgl-generate.py layer-intercept-proc > vk_generic_intercept_proc_helper.h
 	DEPENDS ${PROJECT_SOURCE_DIR}/xgl-generate.py ${PROJECT_SOURCE_DIR}/xgl.py)
 
-run_xgl_helper(gen_enum_string_helper xgl_enum_string_helper.h)
-run_xgl_helper(gen_struct_wrappers
-	xgl_struct_string_helper.h
-        xgl_struct_string_helper_cpp.h
-	xgl_struct_string_helper_no_addr.h
-	xgl_struct_string_helper_no_addr_cpp.h
-        xgl_struct_size_helper.h
-        xgl_struct_size_helper.c
-	xgl_struct_wrappers.h
-	xgl_struct_wrappers.cpp
+run_vk_helper(gen_enum_string_helper vk_enum_string_helper.h)
+run_vk_helper(gen_struct_wrappers
+	vk_struct_string_helper.h
+        vk_struct_string_helper_cpp.h
+	vk_struct_string_helper_no_addr.h
+	vk_struct_string_helper_no_addr_cpp.h
+        vk_struct_size_helper.h
+        vk_struct_size_helper.c
+	vk_struct_wrappers.h
+	vk_struct_wrappers.cpp
 )
-run_xgl_helper(gen_graphviz xgl_struct_graphviz_helper.h)
+run_vk_helper(gen_graphviz vk_struct_graphviz_helper.h)
 
-add_custom_target(generate_xgl_layer_helpers DEPENDS
-	xgl_dispatch_table_helper.h
-	xgl_generic_intercept_proc_helper.h
-	xgl_enum_string_helper.h
-	xgl_struct_string_helper.h
-	xgl_struct_string_helper_no_addr.h
-        xgl_struct_string_helper_cpp.h
-	xgl_struct_string_helper_no_addr_cpp.h
-        xgl_struct_size_helper.h
-        xgl_struct_size_helper.c
-        xgl_struct_wrappers.h
-	xgl_struct_wrappers.cpp
-	xgl_struct_graphviz_helper.h
+add_custom_target(generate_vk_layer_helpers DEPENDS
+	vk_dispatch_table_helper.h
+	vk_generic_intercept_proc_helper.h
+	vk_enum_string_helper.h
+	vk_struct_string_helper.h
+	vk_struct_string_helper_no_addr.h
+        vk_struct_string_helper_cpp.h
+	vk_struct_string_helper_no_addr_cpp.h
+        vk_struct_size_helper.h
+        vk_struct_size_helper.c
+	vk_struct_wrappers.h
+	vk_struct_wrappers.cpp
+	vk_struct_graphviz_helper.h
 )
 
-run_xgl_layer_generate(Generic generic_layer.c)
-run_xgl_layer_generate(ApiDump api_dump.c)
-run_xgl_layer_generate(ApiDumpFile api_dump_file.c)
-run_xgl_layer_generate(ApiDumpNoAddr api_dump_no_addr.c)
-run_xgl_layer_generate(ApiDumpCpp api_dump.cpp)
-run_xgl_layer_generate(ApiDumpNoAddrCpp api_dump_no_addr.cpp)
-run_xgl_layer_generate(ObjectTracker object_track.c)
+run_vk_layer_generate(Generic generic_layer.c)
+run_vk_layer_generate(ApiDump api_dump.c)
+run_vk_layer_generate(ApiDumpFile api_dump_file.c)
+run_vk_layer_generate(ApiDumpNoAddr api_dump_no_addr.c)
+run_vk_layer_generate(ApiDumpCpp api_dump.cpp)
+run_vk_layer_generate(ApiDumpNoAddrCpp api_dump_no_addr.cpp)
+run_vk_layer_generate(ObjectTracker object_track.c)
 
 add_library(layer_utils SHARED layers_config.cpp)
 if (WIN32)
@@ -102,17 +102,17 @@
     target_link_libraries(layer_utils)
 endif()
 
-add_xgl_layer(Basic basic.cpp)
-add_xgl_layer(Multi multi.cpp)
-add_xgl_layer(DrawState draw_state.cpp)
-add_xgl_layer(MemTracker mem_tracker.cpp)
-add_xgl_layer(GlaveSnapshot glave_snapshot.c)
+add_vk_layer(Basic basic.cpp)
+add_vk_layer(Multi multi.cpp)
+add_vk_layer(DrawState draw_state.cpp)
+add_vk_layer(MemTracker mem_tracker.cpp)
+add_vk_layer(GlaveSnapshot glave_snapshot.c)
 # generated
-add_xgl_layer(Generic generic_layer.c)
-add_xgl_layer(APIDump api_dump.c)
-add_xgl_layer(APIDumpFile api_dump_file.c)
-add_xgl_layer(APIDumpNoAddr api_dump_no_addr.c)
-add_xgl_layer(APIDumpCpp api_dump.cpp)
-add_xgl_layer(APIDumpNoAddrCpp api_dump_no_addr.cpp)
-add_xgl_layer(ObjectTracker object_track.c)
-add_xgl_layer(ParamChecker param_checker.cpp)
+add_vk_layer(Generic generic_layer.c)
+add_vk_layer(APIDump api_dump.c)
+add_vk_layer(APIDumpFile api_dump_file.c)
+add_vk_layer(APIDumpNoAddr api_dump_no_addr.c)
+add_vk_layer(APIDumpCpp api_dump.cpp)
+add_vk_layer(APIDumpNoAddrCpp api_dump_no_addr.cpp)
+add_vk_layer(ObjectTracker object_track.c)
+add_vk_layer(ParamChecker param_checker.cpp)
diff --git a/layers/README.md b/layers/README.md
index 21ce969..449f892 100644
--- a/layers/README.md
+++ b/layers/README.md
@@ -2,13 +2,13 @@
 
 ## Overview
 
-Layer libraries can be written to intercept or hook XGL entrypoints for various
-debug and validation purposes.  One or more XGL entrypoints can be defined in your Layer
+Layer libraries can be written to intercept or hook VK entrypoints for various
+debug and validation purposes.  One or more VK entrypoints can be defined in your Layer
 library.  Undefined entrypoints in the Layer library will be passed to the next Layer which
 may be the driver.  Multiple layer libraries can be chained (actually a hierarchy) together.
-xglEnumerateLayer can be called to list the available layer libraries.  xglGetProcAddr is
+vkEnumerateLayer can be called to list the available layer libraries.  vkGetProcAddr is
 used internally by the Layers and ICD Loader to initialize dispatch tables. Layers are
-activated at xglCreateDevice time. xglCreateDevice createInfo struct is extended to allow
+activated at vkCreateDevice time. vkCreateDevice createInfo struct is extended to allow
 a list of layers to be activated.  Layer libraries can alternatively be LD\_PRELOADed depending
 upon how they are implemented.
 
@@ -16,33 +16,33 @@
 
 Note that some layers are code-generated and will therefore exist in the directory (build_dir)/layers
 
--include/xglLayer.h  - header file for layer code.
+-include/vkLayer.h  - header file for layer code.
 
 ### Templates
 layer/Basic.cpp (name=Basic) simple example wrapping a few entrypoints. Shows layer features:
 - Multiple dispatch tables for supporting multiple GPUs.
 - Example layer extension function shown.
-- Layer extension advertised by xglGetExtension().
-- xglEnumerateLayers() supports loader layer name queries and call interception
+- Layer extension advertised by vkGetExtension().
+- vkEnumerateLayers() supports loader layer name queries and call interception
 - Can be LD\_PRELOADed individually
 
 layer/Multi.cpp (name=multi1:multi2) simple example showing multiple layers per library
     
-(build dir)/layer/generic_layer.c (name=Generic) - auto generated example wrapping all XGL entrypoints. Single global dispatch table. Can be LD\_PRELOADed.
+(build dir)/layer/generic_layer.c (name=Generic) - auto generated example wrapping all VK entrypoints. Single global dispatch table. Can be LD\_PRELOADed.
 
 ### Print API Calls and Parameter Values
 (build dir)/layer/api_dump.c (name=APIDump) - print out API calls along with parameter values
 
 (build dir)/layer/api_dump.cpp (name=APIDumpCpp) - same as above but uses c++ strings and i/o streams
 
-(build dir)/layer/api\_dump\_file.c (name=APIDumpFile) - Write API calls along with parameter values to xgl\_apidump.txt file.
+(build dir)/layer/api\_dump\_file.c (name=APIDumpFile) - Write API calls along with parameter values to vk\_apidump.txt file.
 
 (build dir)/layer/api\_dump\_no\_addr.c (name=APIDumpNoAddr) - print out API calls along with parameter values but replace any variable addresses with the static string "addr".
 
 (build dir)/layer/api\_dump\_no\_addr.cpp (name=APIDumpNoAddrCpp) - same as above but uses c++ strings and i/o streams
 
 ### Print Object Stats
-(build dir>/layer/object_track.c (name=ObjectTracker) - Print object CREATE/USE/DESTROY stats. Individually track objects by category. XGL\_OBJECT\_TYPE enum defined in object_track.h. If a Dbg callback function is registered, this layer will use callback function(s) for reporting, otherwise uses stdout. Provides custom interface to query number of live objects of given type  "XGL\_UINT64 objTrackGetObjectCount(XGL\_OBJECT\_TYPE type)" and a secondary call to return an array of those objects "XGL\_RESULT objTrackGetObjects(XGL\_OBJECT\_TYPE type, XGL\_UINT64 objCount, OBJTRACK\_NODE* pObjNodeArray)".
+(build dir>/layer/object_track.c (name=ObjectTracker) - Print object CREATE/USE/DESTROY stats. Individually track objects by category. VK\_OBJECT\_TYPE enum defined in object_track.h. If a Dbg callback function is registered, this layer will use callback function(s) for reporting, otherwise uses stdout. Provides custom interface to query number of live objects of given type  "VK\_UINT64 objTrackGetObjectCount(VK\_OBJECT\_TYPE type)" and a secondary call to return an array of those objects "VK\_RESULT objTrackGetObjects(VK\_OBJECT\_TYPE type, VK\_UINT64 objCount, OBJTRACK\_NODE* pObjNodeArray)".
 
 ### Report Draw State
 layer/draw\_state.c (name=DrawState) - DrawState reports the Descriptor Set, Pipeline State, and dynamic state at each Draw call. DrawState layer performs a number of validation checks on this state. Of primary interest is making sure that the resources bound to Descriptor Sets correctly align with the layout specified for the Set. If a Dbg callback function is registered, this layer will use callback function(s) for reporting, otherwise uses stdout. 
@@ -55,62 +55,62 @@
 
 ## Using Layers
 
-1. Build XGL loader  and i965 icd driver using normal steps (cmake and make)
-2. Place libXGLLayer<name>.so in the same directory as your XGL test or app:
+1. Build VK loader  and i965 icd driver using normal steps (cmake and make)
+2. Place libVKLayer<name>.so in the same directory as your VK test or app:
 
-    cp build/layer/libXGLLayerBasic.so build/layer/libXGLLayerGeneric.so build/tests
+    cp build/layer/libVKLayerBasic.so build/layer/libVKLayerGeneric.so build/tests
 
-    This is required for the Icd loader to be able to scan and enumerate your library. Alternatively, use the LIBXGL\_LAYERS\_PATH environment variable to specify where the layer libraries reside.
+    This is required for the Icd loader to be able to scan and enumerate your library. Alternatively, use the LIBVK\_LAYERS\_PATH environment variable to specify where the layer libraries reside.
 
 3. Specify which Layers to activate by using 
-xglCreateDevice XGL\_LAYER\_CREATE\_INFO struct or environment variable LIBXGL\_LAYER\_NAMES
+vkCreateDevice VK\_LAYER\_CREATE\_INFO struct or environment variable LIBVK\_LAYER\_NAMES
 
-    export LIBXGL\_LAYER\_NAMES=Basic:Generic
-    cd build/tests; ./xglinfo
+    export LIBVK\_LAYER\_NAMES=Basic:Generic
+    cd build/tests; ./vkinfo
 
 ## Tips for writing new layers
 
-1. Must implement xglGetProcAddr() (aka GPA);
-2. Must have a local dispatch table to call next layer (see xglLayer.h);
-3. Should implement xglEnumerateLayers() returning layer name when gpu == NULL; otherwise layer name is extracted from library filename by the Loader;
+1. Must implement vkGetProcAddr() (aka GPA);
+2. Must have a local dispatch table to call next layer (see vkLayer.h);
+3. Should implement vkEnumerateLayers() returning layer name when gpu == NULL; otherwise layer name is extracted from library filename by the Loader;
 4. gpu objects must be unwrapped (gpu->nextObject) when passed to next layer;
 5. next layers GPA can be found in the wrapped gpu object;
 6. Loader calls a layer's GPA first  so initialization should occur here;
 7. all entrypoints can be wrapped but only will be called after layer is activated
-    via the first xglCreatDevice;
-8. entrypoint names can be any name as specified by the layers xglGetProcAddr
-    implementation; exceptions are xglGetProcAddr and xglEnumerateLayers,
+    via the first vkCreatDevice;
+8. entrypoint names can be any name as specified by the layers vkGetProcAddr
+    implementation; exceptions are vkGetProcAddr and vkEnumerateLayers,
     which must have the correct name since the Loader calls these entrypoints;
-9. entrypoint names must be exported to the dynamic loader with XGL\_LAYER\_EXPORT;
-10. For LD\_PRELOAD support: a)entrypoint names should be offical xgl names and
+9. entrypoint names must be exported to the dynamic loader with VK\_LAYER\_EXPORT;
+10. For LD\_PRELOAD support: a)entrypoint names should be offical vk names and
     b) initialization should occur on any call with a gpu object (Loader type
-    initialization must be done if implementing xglInitAndEnumerateGpus).
-11. Implement xglGetExtension() if you want to advertise a layer extension
+    initialization must be done if implementing vkInitAndEnumerateGpus).
+11. Implement vkGetExtension() if you want to advertise a layer extension
     (only available after the layer is activated);
-12. Layer naming convention is camel case same name as in library: libXGLLayer<name>.so
+12. Layer naming convention is camel case same name as in library: libVKLayer<name>.so
 13. For multiple layers in one library should implement a separate GetProcAddr for each
     layer and export them to dynamic loader;  function name is <layerName>GetProcAddr().
-    Main xglGetProcAddr() should also be implemented.
+    Main vkGetProcAddr() should also be implemented.
 
 ## Status
 
 ### Current Features
 
-- scanning of available Layers during xglInitAndEnumerateGpus;
-- layer names retrieved via xglEnumerateLayers();
-- xglEnumerateLayers and xglGetProcAddr supported APIs in xgl.h, ICD loader and i965 driver;
+- scanning of available Layers during vkInitAndEnumerateGpus;
+- layer names retrieved via vkEnumerateLayers();
+- vkEnumerateLayers and vkGetProcAddr supported APIs in vulkan.h, ICD loader and i965 driver;
 - multiple layers in a hierarchy supported;
 - layer enumeration supported per GPU;
 - layers activated per gpu and per icd driver: separate  dispatch table and layer library list in loader for each gpu or icd driver;
-- activation via xglCreateDevice extension struct in CreateInfo or via env var (LIBXGL\_LAYER\_NAMES);
+- activation via vkCreateDevice extension struct in CreateInfo or via env var (LIBVK\_LAYER\_NAMES);
 - layer libraries can be LD\_PRELOADed if implemented correctly;
 
 ### Current known issues
 
 - Layers with multiple threads are not well tested and some layers likely to have issues. APIDump family of layers should be thread-safe.
 - layer libraries (except Basic) don't support multiple dispatch tables for multi-gpus;
-- layer libraries not yet include loader init functionality for full LD\_PRELOAD of entire API including xglInitAndEnumerateGpus;
-- Since Layers aren't activated until xglCreateDevice, any calls to xglGetExtension() will not report layer extensions unless implemented in the layer;
-- layer extensions do NOT need to be enabled in xglCreateDevice to be available;
+- layer libraries not yet include loader init functionality for full LD\_PRELOAD of entire API including vkInitAndEnumerateGpus;
+- Since Layers aren't activated until vkCreateDevice, any calls to vkGetExtension() will not report layer extensions unless implemented in the layer;
+- layer extensions do NOT need to be enabled in vkCreateDevice to be available;
 - no support for apps registering layers, must be discovered via initial scan
 
diff --git a/layers/basic.cpp b/layers/basic.cpp
index 627dc87..dbbb491 100644
--- a/layers/basic.cpp
+++ b/layers/basic.cpp
@@ -1,5 +1,5 @@
 /*
- * XGL
+ * Vulkan
  *
  * Copyright (C) 2014 LunarG, Inc.
  *
@@ -26,110 +26,110 @@
 #include <assert.h>
 #include <unordered_map>
 #include "loader_platform.h"
-#include "xgl_dispatch_table_helper.h"
-#include "xglLayer.h"
+#include "vk_dispatch_table_helper.h"
+#include "vkLayer.h"
 // The following is #included again to catch certain OS-specific functions
 // being used:
 #include "loader_platform.h"
 
-static std::unordered_map<void *, XGL_LAYER_DISPATCH_TABLE *> tableMap;
+static std::unordered_map<void *, VK_LAYER_DISPATCH_TABLE *> tableMap;
 
-static XGL_LAYER_DISPATCH_TABLE * initLayerTable(const XGL_BASE_LAYER_OBJECT *gpuw)
+static VK_LAYER_DISPATCH_TABLE * initLayerTable(const VK_BASE_LAYER_OBJECT *gpuw)
 {
-    XGL_LAYER_DISPATCH_TABLE *pTable;
+    VK_LAYER_DISPATCH_TABLE *pTable;
 
     assert(gpuw);
-    std::unordered_map<void *, XGL_LAYER_DISPATCH_TABLE *>::const_iterator it = tableMap.find((void *) gpuw);
+    std::unordered_map<void *, VK_LAYER_DISPATCH_TABLE *>::const_iterator it = tableMap.find((void *) gpuw);
     if (it == tableMap.end())
     {
-        pTable =  new XGL_LAYER_DISPATCH_TABLE;
+        pTable =  new VK_LAYER_DISPATCH_TABLE;
         tableMap[(void *) gpuw] = pTable;
     } else
     {
         return it->second;
     }
 
-    layer_initialize_dispatch_table(pTable, gpuw->pGPA, (XGL_PHYSICAL_GPU) gpuw->nextObject);
+    layer_initialize_dispatch_table(pTable, gpuw->pGPA, (VK_PHYSICAL_GPU) gpuw->nextObject);
 
     return pTable;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglLayerExtension1(XGL_DEVICE device)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkLayerExtension1(VK_DEVICE device)
 {
-    printf("In xglLayerExtension1() call w/ device: %p\n", (void*)device);
-    printf("xglLayerExtension1 returning SUCCESS\n");
-    return XGL_SUCCESS;
+    printf("In vkLayerExtension1() call w/ device: %p\n", (void*)device);
+    printf("vkLayerExtension1 returning SUCCESS\n");
+    return VK_SUCCESS;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglGetExtensionSupport(XGL_PHYSICAL_GPU gpu, const char* pExtName)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkGetExtensionSupport(VK_PHYSICAL_GPU gpu, const char* pExtName)
 {
-    XGL_RESULT result;
-    XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) gpu;
+    VK_RESULT result;
+    VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
 
     /* This entrypoint is NOT going to init it's own dispatch table since loader calls here early */
-    if (!strncmp(pExtName, "xglLayerExtension1", strlen("xglLayerExtension1")))
+    if (!strncmp(pExtName, "vkLayerExtension1", strlen("vkLayerExtension1")))
     {
-        result = XGL_SUCCESS;
+        result = VK_SUCCESS;
     } else if (!strncmp(pExtName, "Basic", strlen("Basic")))
     {
-        result = XGL_SUCCESS;
+        result = VK_SUCCESS;
     } else if (!tableMap.empty() && (tableMap.find(gpuw) != tableMap.end()))
     {
-        printf("At start of wrapped xglGetExtensionSupport() call w/ gpu: %p\n", (void*)gpu);
-        XGL_LAYER_DISPATCH_TABLE* pTable = tableMap[gpuw];
-        result = pTable->GetExtensionSupport((XGL_PHYSICAL_GPU)gpuw->nextObject, pExtName);
-        printf("Completed wrapped xglGetExtensionSupport() call w/ gpu: %p\n", (void*)gpu);
+        printf("At start of wrapped vkGetExtensionSupport() call w/ gpu: %p\n", (void*)gpu);
+        VK_LAYER_DISPATCH_TABLE* pTable = tableMap[gpuw];
+        result = pTable->GetExtensionSupport((VK_PHYSICAL_GPU)gpuw->nextObject, pExtName);
+        printf("Completed wrapped vkGetExtensionSupport() call w/ gpu: %p\n", (void*)gpu);
     } else
     {
-        result = XGL_ERROR_INVALID_EXTENSION;
+        result = VK_ERROR_INVALID_EXTENSION;
     }
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateDevice(XGL_PHYSICAL_GPU gpu, const XGL_DEVICE_CREATE_INFO* pCreateInfo, XGL_DEVICE* pDevice)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDevice(VK_PHYSICAL_GPU gpu, const VK_DEVICE_CREATE_INFO* pCreateInfo, VK_DEVICE* pDevice)
 {
-    XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) gpu;
-    XGL_LAYER_DISPATCH_TABLE* pTable = tableMap[gpuw];
+    VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
+    VK_LAYER_DISPATCH_TABLE* pTable = tableMap[gpuw];
 
-    printf("At start of wrapped xglCreateDevice() call w/ gpu: %p\n", (void*)gpu);
-    XGL_RESULT result = pTable->CreateDevice((XGL_PHYSICAL_GPU)gpuw->nextObject, pCreateInfo, pDevice);
+    printf("At start of wrapped vkCreateDevice() call w/ gpu: %p\n", (void*)gpu);
+    VK_RESULT result = pTable->CreateDevice((VK_PHYSICAL_GPU)gpuw->nextObject, pCreateInfo, pDevice);
     // create a mapping for the device object into the dispatch table
     tableMap.emplace(*pDevice, pTable);
-    printf("Completed wrapped xglCreateDevice() call w/ pDevice, Device %p: %p\n", (void*)pDevice, (void *) *pDevice);
+    printf("Completed wrapped vkCreateDevice() call w/ pDevice, Device %p: %p\n", (void*)pDevice, (void *) *pDevice);
     return result;
 }
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglGetFormatInfo(XGL_DEVICE device, XGL_FORMAT format, XGL_FORMAT_INFO_TYPE infoType, size_t* pDataSize, void* pData)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkGetFormatInfo(VK_DEVICE device, VK_FORMAT format, VK_FORMAT_INFO_TYPE infoType, size_t* pDataSize, void* pData)
 {
-    XGL_LAYER_DISPATCH_TABLE* pTable = tableMap[device];
+    VK_LAYER_DISPATCH_TABLE* pTable = tableMap[device];
 
-    printf("At start of wrapped xglGetFormatInfo() call w/ device: %p\n", (void*)device);
-    XGL_RESULT result = pTable->GetFormatInfo(device, format, infoType, pDataSize, pData);
-    printf("Completed wrapped xglGetFormatInfo() call w/ device: %p\n", (void*)device);
+    printf("At start of wrapped vkGetFormatInfo() call w/ device: %p\n", (void*)device);
+    VK_RESULT result = pTable->GetFormatInfo(device, format, infoType, pDataSize, pData);
+    printf("Completed wrapped vkGetFormatInfo() call w/ device: %p\n", (void*)device);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglEnumerateLayers(XGL_PHYSICAL_GPU gpu, size_t maxLayerCount, size_t maxStringSize, size_t* pOutLayerCount, char* const* pOutLayers, void* pReserved)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkEnumerateLayers(VK_PHYSICAL_GPU gpu, size_t maxLayerCount, size_t maxStringSize, size_t* pOutLayerCount, char* const* pOutLayers, void* pReserved)
 {
     if (gpu != NULL)
     {
-        XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) gpu;
-        XGL_LAYER_DISPATCH_TABLE* pTable = initLayerTable(gpuw);
+        VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
+        VK_LAYER_DISPATCH_TABLE* pTable = initLayerTable(gpuw);
 
-        printf("At start of wrapped xglEnumerateLayers() call w/ gpu: %p\n", gpu);
-        XGL_RESULT result = pTable->EnumerateLayers((XGL_PHYSICAL_GPU)gpuw->nextObject, maxLayerCount, maxStringSize, pOutLayerCount, pOutLayers, pReserved);
+        printf("At start of wrapped vkEnumerateLayers() call w/ gpu: %p\n", gpu);
+        VK_RESULT result = pTable->EnumerateLayers((VK_PHYSICAL_GPU)gpuw->nextObject, maxLayerCount, maxStringSize, pOutLayerCount, pOutLayers, pReserved);
         return result;
     } else
     {
         if (pOutLayerCount == NULL || pOutLayers == NULL || pOutLayers[0] == NULL || pReserved == NULL)
-            return XGL_ERROR_INVALID_POINTER;
+            return VK_ERROR_INVALID_POINTER;
 
         // Example of a layer that is only compatible with Intel's GPUs
-        XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT*) pReserved;
-        xglGetGpuInfoType fpGetGpuInfo;
-        XGL_PHYSICAL_GPU_PROPERTIES gpuProps;
-        size_t dataSize = sizeof(XGL_PHYSICAL_GPU_PROPERTIES);
-        fpGetGpuInfo = (xglGetGpuInfoType) gpuw->pGPA((XGL_PHYSICAL_GPU) gpuw->nextObject, "xglGetGpuInfo");
-        fpGetGpuInfo((XGL_PHYSICAL_GPU) gpuw->nextObject, XGL_INFO_TYPE_PHYSICAL_GPU_PROPERTIES, &dataSize, &gpuProps);
+        VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT*) pReserved;
+        vkGetGpuInfoType fpGetGpuInfo;
+        VK_PHYSICAL_GPU_PROPERTIES gpuProps;
+        size_t dataSize = sizeof(VK_PHYSICAL_GPU_PROPERTIES);
+        fpGetGpuInfo = (vkGetGpuInfoType) gpuw->pGPA((VK_PHYSICAL_GPU) gpuw->nextObject, "vkGetGpuInfo");
+        fpGetGpuInfo((VK_PHYSICAL_GPU) gpuw->nextObject, VK_INFO_TYPE_PHYSICAL_GPU_PROPERTIES, &dataSize, &gpuProps);
         if (gpuProps.vendorId == 0x8086)
         {
             *pOutLayerCount = 1;
@@ -138,33 +138,33 @@
         {
             *pOutLayerCount = 0;
         }
-        return XGL_SUCCESS;
+        return VK_SUCCESS;
     }
 }
 
-XGL_LAYER_EXPORT void * XGLAPI xglGetProcAddr(XGL_PHYSICAL_GPU gpu, const char* pName)
+VK_LAYER_EXPORT void * VKAPI vkGetProcAddr(VK_PHYSICAL_GPU gpu, const char* pName)
 {
     if (gpu == NULL)
         return NULL;
 
-    initLayerTable((const XGL_BASE_LAYER_OBJECT *) gpu);
+    initLayerTable((const VK_BASE_LAYER_OBJECT *) gpu);
 
-    if (!strncmp("xglGetProcAddr", pName, sizeof("xglGetProcAddr")))
-        return (void *) xglGetProcAddr;
-    else if (!strncmp("xglCreateDevice", pName, sizeof ("xglCreateDevice")))
-        return (void *) xglCreateDevice;
-    else if (!strncmp("xglGetExtensionSupport", pName, sizeof ("xglGetExtensionSupport")))
-        return (void *) xglGetExtensionSupport;
-    else if (!strncmp("xglEnumerateLayers", pName, sizeof ("xglEnumerateLayers")))
-        return (void *) xglEnumerateLayers;
-    else if (!strncmp("xglGetFormatInfo", pName, sizeof ("xglGetFormatInfo")))
-        return (void *) xglGetFormatInfo;
-    else if (!strncmp("xglLayerExtension1", pName, sizeof("xglLayerExtension1")))
-        return (void *) xglLayerExtension1;
+    if (!strncmp("vkGetProcAddr", pName, sizeof("vkGetProcAddr")))
+        return (void *) vkGetProcAddr;
+    else if (!strncmp("vkCreateDevice", pName, sizeof ("vkCreateDevice")))
+        return (void *) vkCreateDevice;
+    else if (!strncmp("vkGetExtensionSupport", pName, sizeof ("vkGetExtensionSupport")))
+        return (void *) vkGetExtensionSupport;
+    else if (!strncmp("vkEnumerateLayers", pName, sizeof ("vkEnumerateLayers")))
+        return (void *) vkEnumerateLayers;
+    else if (!strncmp("vkGetFormatInfo", pName, sizeof ("vkGetFormatInfo")))
+        return (void *) vkGetFormatInfo;
+    else if (!strncmp("vkLayerExtension1", pName, sizeof("vkLayerExtension1")))
+        return (void *) vkLayerExtension1;
     else {
-        XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) gpu;
+        VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
         if (gpuw->pGPA == NULL)
             return NULL;
-        return gpuw->pGPA((XGL_PHYSICAL_GPU) gpuw->nextObject, pName);
+        return gpuw->pGPA((VK_PHYSICAL_GPU) gpuw->nextObject, pName);
     }
 }
diff --git a/layers/draw_state.cpp b/layers/draw_state.cpp
index 503c08a..53ec6cd 100644
--- a/layers/draw_state.cpp
+++ b/layers/draw_state.cpp
@@ -1,5 +1,5 @@
 /*
- * XGL
+ * Vulkan
  *
  * Copyright (C) 2014 LunarG, Inc.
  *
@@ -28,12 +28,12 @@
 #include <unordered_map>
 
 #include "loader_platform.h"
-#include "xgl_dispatch_table_helper.h"
-#include "xgl_struct_string_helper_cpp.h"
+#include "vk_dispatch_table_helper.h"
+#include "vk_struct_string_helper_cpp.h"
 #pragma GCC diagnostic ignored "-Wwrite-strings"
-#include "xgl_struct_graphviz_helper.h"
+#include "vk_struct_graphviz_helper.h"
 #pragma GCC diagnostic warning "-Wwrite-strings"
-#include "xgl_struct_size_helper.h"
+#include "vk_struct_size_helper.h"
 #include "draw_state.h"
 #include "layers_config.h"
 // The following is #included again to catch certain OS-specific functions
@@ -41,21 +41,21 @@
 #include "loader_platform.h"
 #include "layers_msg.h"
 
-unordered_map<XGL_SAMPLER, SAMPLER_NODE*> sampleMap;
-unordered_map<XGL_IMAGE_VIEW, IMAGE_NODE*> imageMap;
-unordered_map<XGL_BUFFER_VIEW, BUFFER_NODE*> bufferMap;
-unordered_map<XGL_DYNAMIC_STATE_OBJECT, DYNAMIC_STATE_NODE*> dynamicStateMap;
-unordered_map<XGL_PIPELINE, PIPELINE_NODE*> pipelineMap;
-unordered_map<XGL_DESCRIPTOR_POOL, POOL_NODE*> poolMap;
-unordered_map<XGL_DESCRIPTOR_SET, SET_NODE*> setMap;
-unordered_map<XGL_DESCRIPTOR_SET_LAYOUT, LAYOUT_NODE*> layoutMap;
+unordered_map<VK_SAMPLER, SAMPLER_NODE*> sampleMap;
+unordered_map<VK_IMAGE_VIEW, IMAGE_NODE*> imageMap;
+unordered_map<VK_BUFFER_VIEW, BUFFER_NODE*> bufferMap;
+unordered_map<VK_DYNAMIC_STATE_OBJECT, DYNAMIC_STATE_NODE*> dynamicStateMap;
+unordered_map<VK_PIPELINE, PIPELINE_NODE*> pipelineMap;
+unordered_map<VK_DESCRIPTOR_POOL, POOL_NODE*> poolMap;
+unordered_map<VK_DESCRIPTOR_SET, SET_NODE*> setMap;
+unordered_map<VK_DESCRIPTOR_SET_LAYOUT, LAYOUT_NODE*> layoutMap;
 // Map for layout chains
-unordered_map<XGL_CMD_BUFFER, GLOBAL_CB_NODE*> cmdBufferMap;
-unordered_map<XGL_RENDER_PASS, XGL_RENDER_PASS_CREATE_INFO*> renderPassMap;
-unordered_map<XGL_FRAMEBUFFER, XGL_FRAMEBUFFER_CREATE_INFO*> frameBufferMap;
+unordered_map<VK_CMD_BUFFER, GLOBAL_CB_NODE*> cmdBufferMap;
+unordered_map<VK_RENDER_PASS, VK_RENDER_PASS_CREATE_INFO*> renderPassMap;
+unordered_map<VK_FRAMEBUFFER, VK_FRAMEBUFFER_CREATE_INFO*> frameBufferMap;
 
-static XGL_LAYER_DISPATCH_TABLE nextTable;
-static XGL_BASE_LAYER_OBJECT *pCurObj;
+static VK_LAYER_DISPATCH_TABLE nextTable;
+static VK_BASE_LAYER_OBJECT *pCurObj;
 static LOADER_PLATFORM_THREAD_ONCE_DECLARATION(g_initOnce);
 // TODO : This can be much smarter, using separate locks for separate global data
 static int globalLockInitialized = 0;
@@ -171,7 +171,7 @@
 }
 // Block of code at start here for managing/tracking Pipeline state that this layer cares about
 // Just track 2 shaders for now
-#define XGL_NUM_GRAPHICS_SHADERS XGL_SHADER_STAGE_COMPUTE
+#define VK_NUM_GRAPHICS_SHADERS VK_SHADER_STAGE_COMPUTE
 #define MAX_SLOTS 2048
 #define NUM_COMMAND_BUFFERS_TO_DISPLAY 10
 
@@ -181,46 +181,46 @@
 //   Then need to synchronize the accesses based on cmd buffer so that if I'm reading state on one cmd buffer, updates
 //   to that same cmd buffer by separate thread are not changing state from underneath us
 // Track the last cmd buffer touched by this thread
-static XGL_CMD_BUFFER    g_lastCmdBuffer[MAX_TID] = {NULL};
+static VK_CMD_BUFFER    g_lastCmdBuffer[MAX_TID] = {NULL};
 // Track the last group of CBs touched for displaying to dot file
 static GLOBAL_CB_NODE*   g_pLastTouchedCB[NUM_COMMAND_BUFFERS_TO_DISPLAY] = {NULL};
 static uint32_t g_lastTouchedCBIndex = 0;
 // Track the last global DrawState of interest touched by any thread
 static GLOBAL_CB_NODE*        g_lastGlobalCB = NULL;
 static PIPELINE_NODE*         g_lastBoundPipeline = NULL;
-static DYNAMIC_STATE_NODE*    g_lastBoundDynamicState[XGL_NUM_STATE_BIND_POINT] = {NULL};
-static XGL_DESCRIPTOR_SET     g_lastBoundDescriptorSet = NULL;
+static DYNAMIC_STATE_NODE*    g_lastBoundDynamicState[VK_NUM_STATE_BIND_POINT] = {NULL};
+static VK_DESCRIPTOR_SET     g_lastBoundDescriptorSet = NULL;
 #define MAX_BINDING 0xFFFFFFFF // Default vtxBinding value in CB Node to identify if no vtxBinding set
 
-//static DYNAMIC_STATE_NODE* g_pDynamicStateHead[XGL_NUM_STATE_BIND_POINT] = {0};
+//static DYNAMIC_STATE_NODE* g_pDynamicStateHead[VK_NUM_STATE_BIND_POINT] = {0};
 
-static void insertDynamicState(const XGL_DYNAMIC_STATE_OBJECT state, const GENERIC_HEADER* pCreateInfo, XGL_STATE_BIND_POINT bindPoint)
+static void insertDynamicState(const VK_DYNAMIC_STATE_OBJECT state, const GENERIC_HEADER* pCreateInfo, VK_STATE_BIND_POINT bindPoint)
 {
-    XGL_DYNAMIC_VP_STATE_CREATE_INFO* pVPCI = NULL;
+    VK_DYNAMIC_VP_STATE_CREATE_INFO* pVPCI = NULL;
     size_t scSize = 0;
     size_t vpSize = 0;
     loader_platform_thread_lock_mutex(&globalLock);
     DYNAMIC_STATE_NODE* pStateNode = new DYNAMIC_STATE_NODE;
     pStateNode->stateObj = state;
     switch (pCreateInfo->sType) {
-        case XGL_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO:
-            memcpy(&pStateNode->create_info, pCreateInfo, sizeof(XGL_DYNAMIC_VP_STATE_CREATE_INFO));
-            pVPCI = (XGL_DYNAMIC_VP_STATE_CREATE_INFO*)pCreateInfo;
-            pStateNode->create_info.vpci.pScissors = new XGL_RECT[pStateNode->create_info.vpci.viewportAndScissorCount];
-            pStateNode->create_info.vpci.pViewports = new XGL_VIEWPORT[pStateNode->create_info.vpci.viewportAndScissorCount];
-            scSize = pVPCI->viewportAndScissorCount * sizeof(XGL_RECT);
-            vpSize = pVPCI->viewportAndScissorCount * sizeof(XGL_VIEWPORT);
+        case VK_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO:
+            memcpy(&pStateNode->create_info, pCreateInfo, sizeof(VK_DYNAMIC_VP_STATE_CREATE_INFO));
+            pVPCI = (VK_DYNAMIC_VP_STATE_CREATE_INFO*)pCreateInfo;
+            pStateNode->create_info.vpci.pScissors = new VK_RECT[pStateNode->create_info.vpci.viewportAndScissorCount];
+            pStateNode->create_info.vpci.pViewports = new VK_VIEWPORT[pStateNode->create_info.vpci.viewportAndScissorCount];
+            scSize = pVPCI->viewportAndScissorCount * sizeof(VK_RECT);
+            vpSize = pVPCI->viewportAndScissorCount * sizeof(VK_VIEWPORT);
             memcpy((void*)pStateNode->create_info.vpci.pScissors, pVPCI->pScissors, scSize);
             memcpy((void*)pStateNode->create_info.vpci.pViewports, pVPCI->pViewports, vpSize);
             break;
-        case XGL_STRUCTURE_TYPE_DYNAMIC_RS_STATE_CREATE_INFO:
-            memcpy(&pStateNode->create_info, pCreateInfo, sizeof(XGL_DYNAMIC_RS_STATE_CREATE_INFO));
+        case VK_STRUCTURE_TYPE_DYNAMIC_RS_STATE_CREATE_INFO:
+            memcpy(&pStateNode->create_info, pCreateInfo, sizeof(VK_DYNAMIC_RS_STATE_CREATE_INFO));
             break;
-        case XGL_STRUCTURE_TYPE_DYNAMIC_CB_STATE_CREATE_INFO:
-            memcpy(&pStateNode->create_info, pCreateInfo, sizeof(XGL_DYNAMIC_CB_STATE_CREATE_INFO));
+        case VK_STRUCTURE_TYPE_DYNAMIC_CB_STATE_CREATE_INFO:
+            memcpy(&pStateNode->create_info, pCreateInfo, sizeof(VK_DYNAMIC_CB_STATE_CREATE_INFO));
             break;
-        case XGL_STRUCTURE_TYPE_DYNAMIC_DS_STATE_CREATE_INFO:
-            memcpy(&pStateNode->create_info, pCreateInfo, sizeof(XGL_DYNAMIC_DS_STATE_CREATE_INFO));
+        case VK_STRUCTURE_TYPE_DYNAMIC_DS_STATE_CREATE_INFO:
+            memcpy(&pStateNode->create_info, pCreateInfo, sizeof(VK_DYNAMIC_DS_STATE_CREATE_INFO));
             break;
         default:
             assert(0);
@@ -233,8 +233,8 @@
 // Free all allocated nodes for Dynamic State objs
 static void freeDynamicState()
 {
-    for (unordered_map<XGL_DYNAMIC_STATE_OBJECT, DYNAMIC_STATE_NODE*>::iterator ii=dynamicStateMap.begin(); ii!=dynamicStateMap.end(); ++ii) {
-        if (XGL_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO == (*ii).second->create_info.vpci.sType) {
+    for (unordered_map<VK_DYNAMIC_STATE_OBJECT, DYNAMIC_STATE_NODE*>::iterator ii=dynamicStateMap.begin(); ii!=dynamicStateMap.end(); ++ii) {
+        if (VK_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO == (*ii).second->create_info.vpci.sType) {
             delete[] (*ii).second->create_info.vpci.pScissors;
             delete[] (*ii).second->create_info.vpci.pViewports;
         }
@@ -244,11 +244,11 @@
 // Free all sampler nodes
 static void freeSamplers()
 {
-    for (unordered_map<XGL_SAMPLER, SAMPLER_NODE*>::iterator ii=sampleMap.begin(); ii!=sampleMap.end(); ++ii) {
+    for (unordered_map<VK_SAMPLER, SAMPLER_NODE*>::iterator ii=sampleMap.begin(); ii!=sampleMap.end(); ++ii) {
         delete (*ii).second;
     }
 }
-static XGL_IMAGE_VIEW_CREATE_INFO* getImageViewCreateInfo(XGL_IMAGE_VIEW view)
+static VK_IMAGE_VIEW_CREATE_INFO* getImageViewCreateInfo(VK_IMAGE_VIEW view)
 {
     loader_platform_thread_lock_mutex(&globalLock);
     if (imageMap.find(view) == imageMap.end()) {
@@ -263,11 +263,11 @@
 // Free all image nodes
 static void freeImages()
 {
-    for (unordered_map<XGL_IMAGE_VIEW, IMAGE_NODE*>::iterator ii=imageMap.begin(); ii!=imageMap.end(); ++ii) {
+    for (unordered_map<VK_IMAGE_VIEW, IMAGE_NODE*>::iterator ii=imageMap.begin(); ii!=imageMap.end(); ++ii) {
         delete (*ii).second;
     }
 }
-static XGL_BUFFER_VIEW_CREATE_INFO* getBufferViewCreateInfo(XGL_BUFFER_VIEW view)
+static VK_BUFFER_VIEW_CREATE_INFO* getBufferViewCreateInfo(VK_BUFFER_VIEW view)
 {
     loader_platform_thread_lock_mutex(&globalLock);
     if (bufferMap.find(view) == bufferMap.end()) {
@@ -282,13 +282,13 @@
 // Free all buffer nodes
 static void freeBuffers()
 {
-    for (unordered_map<XGL_BUFFER_VIEW, BUFFER_NODE*>::iterator ii=bufferMap.begin(); ii!=bufferMap.end(); ++ii) {
+    for (unordered_map<VK_BUFFER_VIEW, BUFFER_NODE*>::iterator ii=bufferMap.begin(); ii!=bufferMap.end(); ++ii) {
         delete (*ii).second;
     }
 }
-static GLOBAL_CB_NODE* getCBNode(XGL_CMD_BUFFER cb);
+static GLOBAL_CB_NODE* getCBNode(VK_CMD_BUFFER cb);
 
-static void updateCBTracking(XGL_CMD_BUFFER cb)
+static void updateCBTracking(VK_CMD_BUFFER cb)
 {
     g_lastCmdBuffer[getTIDIndex()] = cb;
     GLOBAL_CB_NODE* pCB = getCBNode(cb);
@@ -307,22 +307,22 @@
 }
 
 // Print the last bound dynamic state
-static void printDynamicState(const XGL_CMD_BUFFER cb)
+static void printDynamicState(const VK_CMD_BUFFER cb)
 {
     GLOBAL_CB_NODE* pCB = getCBNode(cb);
     if (pCB) {
         loader_platform_thread_lock_mutex(&globalLock);
         char str[4*1024];
-        for (uint32_t i = 0; i < XGL_NUM_STATE_BIND_POINT; i++) {
+        for (uint32_t i = 0; i < VK_NUM_STATE_BIND_POINT; i++) {
             if (pCB->lastBoundDynamicState[i]) {
-                sprintf(str, "Reporting CreateInfo for currently bound %s object %p", string_XGL_STATE_BIND_POINT((XGL_STATE_BIND_POINT)i), pCB->lastBoundDynamicState[i]->stateObj);
-                layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, pCB->lastBoundDynamicState[i]->stateObj, 0, DRAWSTATE_NONE, "DS", str);
-                layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, pCB->lastBoundDynamicState[i]->stateObj, 0, DRAWSTATE_NONE, "DS", dynamic_display(pCB->lastBoundDynamicState[i]->pCreateInfo, "  ").c_str());
+                sprintf(str, "Reporting CreateInfo for currently bound %s object %p", string_VK_STATE_BIND_POINT((VK_STATE_BIND_POINT)i), pCB->lastBoundDynamicState[i]->stateObj);
+                layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, pCB->lastBoundDynamicState[i]->stateObj, 0, DRAWSTATE_NONE, "DS", str);
+                layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, pCB->lastBoundDynamicState[i]->stateObj, 0, DRAWSTATE_NONE, "DS", dynamic_display(pCB->lastBoundDynamicState[i]->pCreateInfo, "  ").c_str());
                 break;
             }
             else {
-                sprintf(str, "No dynamic state of type %s bound", string_XGL_STATE_BIND_POINT((XGL_STATE_BIND_POINT)i));
-                layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_NONE, "DS", str);
+                sprintf(str, "No dynamic state of type %s bound", string_VK_STATE_BIND_POINT((VK_STATE_BIND_POINT)i));
+                layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_NONE, "DS", str);
             }
         }
         loader_platform_thread_unlock_mutex(&globalLock);
@@ -330,11 +330,11 @@
     else {
         char str[1024];
         sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cb);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cb, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cb, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
     }
 }
 // Retrieve pipeline node ptr for given pipeline object
-static PIPELINE_NODE* getPipeline(XGL_PIPELINE pipeline)
+static PIPELINE_NODE* getPipeline(VK_PIPELINE pipeline)
 {
     loader_platform_thread_lock_mutex(&globalLock);
     if (pipelineMap.find(pipeline) == pipelineMap.end()) {
@@ -346,7 +346,7 @@
 }
 
 // For given sampler, return a ptr to its Create Info struct, or NULL if sampler not found
-static XGL_SAMPLER_CREATE_INFO* getSamplerCreateInfo(const XGL_SAMPLER sampler)
+static VK_SAMPLER_CREATE_INFO* getSamplerCreateInfo(const VK_SAMPLER sampler)
 {
     loader_platform_thread_lock_mutex(&globalLock);
     if (sampleMap.find(sampler) == sampleMap.end()) {
@@ -359,116 +359,116 @@
 
 // Init the pipeline mapping info based on pipeline create info LL tree
 //  Threading note : Calls to this function should wrapped in mutex
-static void initPipeline(PIPELINE_NODE* pPipeline, const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo)
+static void initPipeline(PIPELINE_NODE* pPipeline, const VK_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo)
 {
     // First init create info, we'll shadow the structs as we go down the tree
     // TODO : Validate that no create info is incorrectly replicated
-    memcpy(&pPipeline->graphicsPipelineCI, pCreateInfo, sizeof(XGL_GRAPHICS_PIPELINE_CREATE_INFO));
+    memcpy(&pPipeline->graphicsPipelineCI, pCreateInfo, sizeof(VK_GRAPHICS_PIPELINE_CREATE_INFO));
     GENERIC_HEADER* pTrav = (GENERIC_HEADER*)pCreateInfo->pNext;
     GENERIC_HEADER* pPrev = (GENERIC_HEADER*)&pPipeline->graphicsPipelineCI; // Hold prev ptr to tie chain of structs together
     size_t bufferSize = 0;
-    XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO* pVICI = NULL;
-    XGL_PIPELINE_CB_STATE_CREATE_INFO*     pCBCI = NULL;
-    XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pTmpPSSCI = NULL;
+    VK_PIPELINE_VERTEX_INPUT_CREATE_INFO* pVICI = NULL;
+    VK_PIPELINE_CB_STATE_CREATE_INFO*     pCBCI = NULL;
+    VK_PIPELINE_SHADER_STAGE_CREATE_INFO* pTmpPSSCI = NULL;
     while (pTrav) {
         switch (pTrav->sType) {
-            case XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO:
-                pTmpPSSCI = (XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*)pTrav;
+            case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO:
+                pTmpPSSCI = (VK_PIPELINE_SHADER_STAGE_CREATE_INFO*)pTrav;
                 switch (pTmpPSSCI->shader.stage) {
-                    case XGL_SHADER_STAGE_VERTEX:
+                    case VK_SHADER_STAGE_VERTEX:
                         pPrev->pNext = &pPipeline->vsCI;
                         pPrev = (GENERIC_HEADER*)&pPipeline->vsCI;
-                        memcpy(&pPipeline->vsCI, pTmpPSSCI, sizeof(XGL_PIPELINE_SHADER_STAGE_CREATE_INFO));
+                        memcpy(&pPipeline->vsCI, pTmpPSSCI, sizeof(VK_PIPELINE_SHADER_STAGE_CREATE_INFO));
                         break;
-                    case XGL_SHADER_STAGE_TESS_CONTROL:
+                    case VK_SHADER_STAGE_TESS_CONTROL:
                         pPrev->pNext = &pPipeline->tcsCI;
                         pPrev = (GENERIC_HEADER*)&pPipeline->tcsCI;
-                        memcpy(&pPipeline->tcsCI, pTmpPSSCI, sizeof(XGL_PIPELINE_SHADER_STAGE_CREATE_INFO));
+                        memcpy(&pPipeline->tcsCI, pTmpPSSCI, sizeof(VK_PIPELINE_SHADER_STAGE_CREATE_INFO));
                         break;
-                    case XGL_SHADER_STAGE_TESS_EVALUATION:
+                    case VK_SHADER_STAGE_TESS_EVALUATION:
                         pPrev->pNext = &pPipeline->tesCI;
                         pPrev = (GENERIC_HEADER*)&pPipeline->tesCI;
-                        memcpy(&pPipeline->tesCI, pTmpPSSCI, sizeof(XGL_PIPELINE_SHADER_STAGE_CREATE_INFO));
+                        memcpy(&pPipeline->tesCI, pTmpPSSCI, sizeof(VK_PIPELINE_SHADER_STAGE_CREATE_INFO));
                         break;
-                    case XGL_SHADER_STAGE_GEOMETRY:
+                    case VK_SHADER_STAGE_GEOMETRY:
                         pPrev->pNext = &pPipeline->gsCI;
                         pPrev = (GENERIC_HEADER*)&pPipeline->gsCI;
-                        memcpy(&pPipeline->gsCI, pTmpPSSCI, sizeof(XGL_PIPELINE_SHADER_STAGE_CREATE_INFO));
+                        memcpy(&pPipeline->gsCI, pTmpPSSCI, sizeof(VK_PIPELINE_SHADER_STAGE_CREATE_INFO));
                         break;
-                    case XGL_SHADER_STAGE_FRAGMENT:
+                    case VK_SHADER_STAGE_FRAGMENT:
                         pPrev->pNext = &pPipeline->fsCI;
                         pPrev = (GENERIC_HEADER*)&pPipeline->fsCI;
-                        memcpy(&pPipeline->fsCI, pTmpPSSCI, sizeof(XGL_PIPELINE_SHADER_STAGE_CREATE_INFO));
+                        memcpy(&pPipeline->fsCI, pTmpPSSCI, sizeof(VK_PIPELINE_SHADER_STAGE_CREATE_INFO));
                         break;
-                    case XGL_SHADER_STAGE_COMPUTE:
-                        // TODO : Flag error, CS is specified through XGL_COMPUTE_PIPELINE_CREATE_INFO
+                    case VK_SHADER_STAGE_COMPUTE:
+                        // TODO : Flag error, CS is specified through VK_COMPUTE_PIPELINE_CREATE_INFO
                         break;
                     default:
                         // TODO : Flag error
                         break;
                 }
                 break;
-            case XGL_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO:
+            case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO:
                 pPrev->pNext = &pPipeline->vertexInputCI;
                 pPrev = (GENERIC_HEADER*)&pPipeline->vertexInputCI;
-                memcpy((void*)&pPipeline->vertexInputCI, pTrav, sizeof(XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO));
+                memcpy((void*)&pPipeline->vertexInputCI, pTrav, sizeof(VK_PIPELINE_VERTEX_INPUT_CREATE_INFO));
                 // Copy embedded ptrs
-                pVICI = (XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO*)pTrav;
+                pVICI = (VK_PIPELINE_VERTEX_INPUT_CREATE_INFO*)pTrav;
                 pPipeline->vtxBindingCount = pVICI->bindingCount;
                 if (pPipeline->vtxBindingCount) {
-                    pPipeline->pVertexBindingDescriptions = new XGL_VERTEX_INPUT_BINDING_DESCRIPTION[pPipeline->vtxBindingCount];
-                    bufferSize = pPipeline->vtxBindingCount * sizeof(XGL_VERTEX_INPUT_BINDING_DESCRIPTION);
-                    memcpy((void*)pPipeline->pVertexBindingDescriptions, ((XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO*)pTrav)->pVertexAttributeDescriptions, bufferSize);
+                    pPipeline->pVertexBindingDescriptions = new VK_VERTEX_INPUT_BINDING_DESCRIPTION[pPipeline->vtxBindingCount];
+                    bufferSize = pPipeline->vtxBindingCount * sizeof(VK_VERTEX_INPUT_BINDING_DESCRIPTION);
+                    memcpy((void*)pPipeline->pVertexBindingDescriptions, ((VK_PIPELINE_VERTEX_INPUT_CREATE_INFO*)pTrav)->pVertexAttributeDescriptions, bufferSize);
                 }
                 pPipeline->vtxAttributeCount = pVICI->attributeCount;
                 if (pPipeline->vtxAttributeCount) {
-                    pPipeline->pVertexAttributeDescriptions = new XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION[pPipeline->vtxAttributeCount];
-                    bufferSize = pPipeline->vtxAttributeCount * sizeof(XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION);
-                    memcpy((void*)pPipeline->pVertexAttributeDescriptions, ((XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO*)pTrav)->pVertexAttributeDescriptions, bufferSize);
+                    pPipeline->pVertexAttributeDescriptions = new VK_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION[pPipeline->vtxAttributeCount];
+                    bufferSize = pPipeline->vtxAttributeCount * sizeof(VK_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION);
+                    memcpy((void*)pPipeline->pVertexAttributeDescriptions, ((VK_PIPELINE_VERTEX_INPUT_CREATE_INFO*)pTrav)->pVertexAttributeDescriptions, bufferSize);
                 }
                 break;
-            case XGL_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO:
+            case VK_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO:
                 pPrev->pNext = &pPipeline->iaStateCI;
                 pPrev = (GENERIC_HEADER*)&pPipeline->iaStateCI;
-                memcpy((void*)&pPipeline->iaStateCI, pTrav, sizeof(XGL_PIPELINE_IA_STATE_CREATE_INFO));
+                memcpy((void*)&pPipeline->iaStateCI, pTrav, sizeof(VK_PIPELINE_IA_STATE_CREATE_INFO));
                 break;
-            case XGL_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO:
+            case VK_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO:
                 pPrev->pNext = &pPipeline->tessStateCI;
                 pPrev = (GENERIC_HEADER*)&pPipeline->tessStateCI;
-                memcpy((void*)&pPipeline->tessStateCI, pTrav, sizeof(XGL_PIPELINE_TESS_STATE_CREATE_INFO));
+                memcpy((void*)&pPipeline->tessStateCI, pTrav, sizeof(VK_PIPELINE_TESS_STATE_CREATE_INFO));
                 break;
-            case XGL_STRUCTURE_TYPE_PIPELINE_VP_STATE_CREATE_INFO:
+            case VK_STRUCTURE_TYPE_PIPELINE_VP_STATE_CREATE_INFO:
                 pPrev->pNext = &pPipeline->vpStateCI;
                 pPrev = (GENERIC_HEADER*)&pPipeline->vpStateCI;
-                memcpy((void*)&pPipeline->vpStateCI, pTrav, sizeof(XGL_PIPELINE_VP_STATE_CREATE_INFO));
+                memcpy((void*)&pPipeline->vpStateCI, pTrav, sizeof(VK_PIPELINE_VP_STATE_CREATE_INFO));
                 break;
-            case XGL_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO:
+            case VK_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO:
                 pPrev->pNext = &pPipeline->rsStateCI;
                 pPrev = (GENERIC_HEADER*)&pPipeline->rsStateCI;
-                memcpy((void*)&pPipeline->rsStateCI, pTrav, sizeof(XGL_PIPELINE_RS_STATE_CREATE_INFO));
+                memcpy((void*)&pPipeline->rsStateCI, pTrav, sizeof(VK_PIPELINE_RS_STATE_CREATE_INFO));
                 break;
-            case XGL_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO:
+            case VK_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO:
                 pPrev->pNext = &pPipeline->msStateCI;
                 pPrev = (GENERIC_HEADER*)&pPipeline->msStateCI;
-                memcpy((void*)&pPipeline->msStateCI, pTrav, sizeof(XGL_PIPELINE_MS_STATE_CREATE_INFO));
+                memcpy((void*)&pPipeline->msStateCI, pTrav, sizeof(VK_PIPELINE_MS_STATE_CREATE_INFO));
                 break;
-            case XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO:
+            case VK_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO:
                 pPrev->pNext = &pPipeline->cbStateCI;
                 pPrev = (GENERIC_HEADER*)&pPipeline->cbStateCI;
-                memcpy((void*)&pPipeline->cbStateCI, pTrav, sizeof(XGL_PIPELINE_CB_STATE_CREATE_INFO));
+                memcpy((void*)&pPipeline->cbStateCI, pTrav, sizeof(VK_PIPELINE_CB_STATE_CREATE_INFO));
                 // Copy embedded ptrs
-                pCBCI = (XGL_PIPELINE_CB_STATE_CREATE_INFO*)pTrav;
+                pCBCI = (VK_PIPELINE_CB_STATE_CREATE_INFO*)pTrav;
                 pPipeline->attachmentCount = pCBCI->attachmentCount;
                 if (pPipeline->attachmentCount) {
-                    pPipeline->pAttachments = new XGL_PIPELINE_CB_ATTACHMENT_STATE[pPipeline->attachmentCount];
-                    bufferSize = pPipeline->attachmentCount * sizeof(XGL_PIPELINE_CB_ATTACHMENT_STATE);
-                    memcpy((void*)pPipeline->pAttachments, ((XGL_PIPELINE_CB_STATE_CREATE_INFO*)pTrav)->pAttachments, bufferSize);
+                    pPipeline->pAttachments = new VK_PIPELINE_CB_ATTACHMENT_STATE[pPipeline->attachmentCount];
+                    bufferSize = pPipeline->attachmentCount * sizeof(VK_PIPELINE_CB_ATTACHMENT_STATE);
+                    memcpy((void*)pPipeline->pAttachments, ((VK_PIPELINE_CB_STATE_CREATE_INFO*)pTrav)->pAttachments, bufferSize);
                 }
                 break;
-            case XGL_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO:
+            case VK_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO:
                 pPrev->pNext = &pPipeline->dsStateCI;
                 pPrev = (GENERIC_HEADER*)&pPipeline->dsStateCI;
-                memcpy((void*)&pPipeline->dsStateCI, pTrav, sizeof(XGL_PIPELINE_DS_STATE_CREATE_INFO));
+                memcpy((void*)&pPipeline->dsStateCI, pTrav, sizeof(VK_PIPELINE_DS_STATE_CREATE_INFO));
                 break;
             default:
                 assert(0);
@@ -481,7 +481,7 @@
 // Free the Pipeline nodes
 static void freePipelines()
 {
-    for (unordered_map<XGL_PIPELINE, PIPELINE_NODE*>::iterator ii=pipelineMap.begin(); ii!=pipelineMap.end(); ++ii) {
+    for (unordered_map<VK_PIPELINE, PIPELINE_NODE*>::iterator ii=pipelineMap.begin(); ii!=pipelineMap.end(); ++ii) {
         if ((*ii).second->pVertexBindingDescriptions) {
             delete[] (*ii).second->pVertexBindingDescriptions;
         }
@@ -495,28 +495,28 @@
     }
 }
 // For given pipeline, return number of MSAA samples, or one if MSAA disabled
-static uint32_t getNumSamples(const XGL_PIPELINE pipeline)
+static uint32_t getNumSamples(const VK_PIPELINE pipeline)
 {
     PIPELINE_NODE* pPipe = pipelineMap[pipeline];
-    if (XGL_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO == pPipe->msStateCI.sType) {
+    if (VK_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO == pPipe->msStateCI.sType) {
         if (pPipe->msStateCI.multisampleEnable)
             return pPipe->msStateCI.samples;
     }
     return 1;
 }
 // Validate state related to the PSO
-static void validatePipelineState(const GLOBAL_CB_NODE* pCB, const XGL_PIPELINE_BIND_POINT pipelineBindPoint, const XGL_PIPELINE pipeline)
+static void validatePipelineState(const GLOBAL_CB_NODE* pCB, const VK_PIPELINE_BIND_POINT pipelineBindPoint, const VK_PIPELINE pipeline)
 {
-    if (XGL_PIPELINE_BIND_POINT_GRAPHICS == pipelineBindPoint) {
+    if (VK_PIPELINE_BIND_POINT_GRAPHICS == pipelineBindPoint) {
         // Verify that any MSAA request in PSO matches sample# in bound FB
         uint32_t psoNumSamples = getNumSamples(pipeline);
         if (pCB->activeRenderPass) {
-            XGL_RENDER_PASS_CREATE_INFO* pRPCI = renderPassMap[pCB->activeRenderPass];
-            XGL_FRAMEBUFFER_CREATE_INFO* pFBCI = frameBufferMap[pCB->framebuffer];
+            VK_RENDER_PASS_CREATE_INFO* pRPCI = renderPassMap[pCB->activeRenderPass];
+            VK_FRAMEBUFFER_CREATE_INFO* pFBCI = frameBufferMap[pCB->framebuffer];
             if (psoNumSamples != pFBCI->sampleCount) {
                 char str[1024];
                 sprintf(str, "Num samples mismatche! Binding PSO (%p) with %u samples while current RenderPass (%p) uses FB (%p) with %u samples!", (void*)pipeline, psoNumSamples, (void*)pCB->activeRenderPass, (void*)pCB->framebuffer, pFBCI->sampleCount);
-                layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, pipeline, 0, DRAWSTATE_NUM_SAMPLES_MISMATCH, "DS", str);
+                layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, pipeline, 0, DRAWSTATE_NUM_SAMPLES_MISMATCH, "DS", str);
             }
         } else {
             // TODO : I believe it's an error if we reach this point and don't have an activeRenderPass
@@ -531,7 +531,7 @@
 // Block of code at start here specifically for managing/tracking DSs
 
 // Return Pool node ptr for specified pool or else NULL
-static POOL_NODE* getPoolNode(XGL_DESCRIPTOR_POOL pool)
+static POOL_NODE* getPoolNode(VK_DESCRIPTOR_POOL pool)
 {
     loader_platform_thread_lock_mutex(&globalLock);
     if (poolMap.find(pool) == poolMap.end()) {
@@ -542,7 +542,7 @@
     return poolMap[pool];
 }
 // Return Set node ptr for specified set or else NULL
-static SET_NODE* getSetNode(XGL_DESCRIPTOR_SET set)
+static SET_NODE* getSetNode(VK_DESCRIPTOR_SET set)
 {
     loader_platform_thread_lock_mutex(&globalLock);
     if (setMap.find(set) == setMap.end()) {
@@ -553,8 +553,8 @@
     return setMap[set];
 }
 
-// Return XGL_TRUE if DS Exists and is within an xglBeginDescriptorPoolUpdate() call sequence, otherwise XGL_FALSE
-static bool32_t dsUpdateActive(XGL_DESCRIPTOR_SET ds)
+// Return VK_TRUE if DS Exists and is within an vkBeginDescriptorPoolUpdate() call sequence, otherwise VK_FALSE
+static bool32_t dsUpdateActive(VK_DESCRIPTOR_SET ds)
 {
     // Note, both "get" functions use global mutex so this guy does not
     SET_NODE* pTrav = getSetNode(ds);
@@ -564,10 +564,10 @@
             return pPool->updateActive;
         }
     }
-    return XGL_FALSE;
+    return VK_FALSE;
 }
 
-static LAYOUT_NODE* getLayoutNode(const XGL_DESCRIPTOR_SET_LAYOUT layout) {
+static LAYOUT_NODE* getLayoutNode(const VK_DESCRIPTOR_SET_LAYOUT layout) {
     loader_platform_thread_lock_mutex(&globalLock);
     if (layoutMap.find(layout) == layoutMap.end()) {
         loader_platform_thread_unlock_mutex(&globalLock);
@@ -582,16 +582,16 @@
 {
     switch (pUpdateStruct->sType)
     {
-        case XGL_STRUCTURE_TYPE_UPDATE_SAMPLERS:
-            return ((XGL_UPDATE_SAMPLERS*)pUpdateStruct)->binding;
-        case XGL_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES:
-            return ((XGL_UPDATE_SAMPLER_TEXTURES*)pUpdateStruct)->binding;
-        case XGL_STRUCTURE_TYPE_UPDATE_IMAGES:
-            return ((XGL_UPDATE_IMAGES*)pUpdateStruct)->binding;
-        case XGL_STRUCTURE_TYPE_UPDATE_BUFFERS:
-            return ((XGL_UPDATE_BUFFERS*)pUpdateStruct)->binding;
-        case XGL_STRUCTURE_TYPE_UPDATE_AS_COPY:
-            return ((XGL_UPDATE_AS_COPY*)pUpdateStruct)->binding;
+        case VK_STRUCTURE_TYPE_UPDATE_SAMPLERS:
+            return ((VK_UPDATE_SAMPLERS*)pUpdateStruct)->binding;
+        case VK_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES:
+            return ((VK_UPDATE_SAMPLER_TEXTURES*)pUpdateStruct)->binding;
+        case VK_STRUCTURE_TYPE_UPDATE_IMAGES:
+            return ((VK_UPDATE_IMAGES*)pUpdateStruct)->binding;
+        case VK_STRUCTURE_TYPE_UPDATE_BUFFERS:
+            return ((VK_UPDATE_BUFFERS*)pUpdateStruct)->binding;
+        case VK_STRUCTURE_TYPE_UPDATE_AS_COPY:
+            return ((VK_UPDATE_AS_COPY*)pUpdateStruct)->binding;
         default:
             // TODO : Flag specific error for this case
             assert(0);
@@ -603,17 +603,17 @@
 {
     switch (pUpdateStruct->sType)
     {
-        case XGL_STRUCTURE_TYPE_UPDATE_SAMPLERS:
-            return (((XGL_UPDATE_SAMPLERS*)pUpdateStruct)->arrayIndex);
-        case XGL_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES:
-            return (((XGL_UPDATE_SAMPLER_TEXTURES*)pUpdateStruct)->arrayIndex);
-        case XGL_STRUCTURE_TYPE_UPDATE_IMAGES:
-            return (((XGL_UPDATE_IMAGES*)pUpdateStruct)->arrayIndex);
-        case XGL_STRUCTURE_TYPE_UPDATE_BUFFERS:
-            return (((XGL_UPDATE_BUFFERS*)pUpdateStruct)->arrayIndex);
-        case XGL_STRUCTURE_TYPE_UPDATE_AS_COPY:
+        case VK_STRUCTURE_TYPE_UPDATE_SAMPLERS:
+            return (((VK_UPDATE_SAMPLERS*)pUpdateStruct)->arrayIndex);
+        case VK_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES:
+            return (((VK_UPDATE_SAMPLER_TEXTURES*)pUpdateStruct)->arrayIndex);
+        case VK_STRUCTURE_TYPE_UPDATE_IMAGES:
+            return (((VK_UPDATE_IMAGES*)pUpdateStruct)->arrayIndex);
+        case VK_STRUCTURE_TYPE_UPDATE_BUFFERS:
+            return (((VK_UPDATE_BUFFERS*)pUpdateStruct)->arrayIndex);
+        case VK_STRUCTURE_TYPE_UPDATE_AS_COPY:
             // TODO : Need to understand this case better and make sure code is correct
-            return (((XGL_UPDATE_AS_COPY*)pUpdateStruct)->arrayElement);
+            return (((VK_UPDATE_AS_COPY*)pUpdateStruct)->arrayElement);
         default:
             // TODO : Flag specific error for this case
             assert(0);
@@ -625,17 +625,17 @@
 {
     switch (pUpdateStruct->sType)
     {
-        case XGL_STRUCTURE_TYPE_UPDATE_SAMPLERS:
-            return (((XGL_UPDATE_SAMPLERS*)pUpdateStruct)->count);
-        case XGL_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES:
-            return (((XGL_UPDATE_SAMPLER_TEXTURES*)pUpdateStruct)->count);
-        case XGL_STRUCTURE_TYPE_UPDATE_IMAGES:
-            return (((XGL_UPDATE_IMAGES*)pUpdateStruct)->count);
-        case XGL_STRUCTURE_TYPE_UPDATE_BUFFERS:
-            return (((XGL_UPDATE_BUFFERS*)pUpdateStruct)->count);
-        case XGL_STRUCTURE_TYPE_UPDATE_AS_COPY:
+        case VK_STRUCTURE_TYPE_UPDATE_SAMPLERS:
+            return (((VK_UPDATE_SAMPLERS*)pUpdateStruct)->count);
+        case VK_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES:
+            return (((VK_UPDATE_SAMPLER_TEXTURES*)pUpdateStruct)->count);
+        case VK_STRUCTURE_TYPE_UPDATE_IMAGES:
+            return (((VK_UPDATE_IMAGES*)pUpdateStruct)->count);
+        case VK_STRUCTURE_TYPE_UPDATE_BUFFERS:
+            return (((VK_UPDATE_BUFFERS*)pUpdateStruct)->count);
+        case VK_STRUCTURE_TYPE_UPDATE_AS_COPY:
             // TODO : Need to understand this case better and make sure code is correct
-            return (((XGL_UPDATE_AS_COPY*)pUpdateStruct)->count);
+            return (((VK_UPDATE_AS_COPY*)pUpdateStruct)->count);
         default:
             // TODO : Flag specific error for this case
             assert(0);
@@ -674,24 +674,24 @@
 static bool32_t validateUpdateType(const LAYOUT_NODE* pLayout, const GENERIC_HEADER* pUpdateStruct)
 {
     // First get actual type of update
-    XGL_DESCRIPTOR_TYPE actualType;
+    VK_DESCRIPTOR_TYPE actualType;
     uint32_t i = 0;
     switch (pUpdateStruct->sType)
     {
-        case XGL_STRUCTURE_TYPE_UPDATE_SAMPLERS:
-            actualType = XGL_DESCRIPTOR_TYPE_SAMPLER;
+        case VK_STRUCTURE_TYPE_UPDATE_SAMPLERS:
+            actualType = VK_DESCRIPTOR_TYPE_SAMPLER;
             break;
-        case XGL_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES:
-            actualType = XGL_DESCRIPTOR_TYPE_SAMPLER_TEXTURE;
+        case VK_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES:
+            actualType = VK_DESCRIPTOR_TYPE_SAMPLER_TEXTURE;
             break;
-        case XGL_STRUCTURE_TYPE_UPDATE_IMAGES:
-            actualType = ((XGL_UPDATE_IMAGES*)pUpdateStruct)->descriptorType;
+        case VK_STRUCTURE_TYPE_UPDATE_IMAGES:
+            actualType = ((VK_UPDATE_IMAGES*)pUpdateStruct)->descriptorType;
             break;
-        case XGL_STRUCTURE_TYPE_UPDATE_BUFFERS:
-            actualType = ((XGL_UPDATE_BUFFERS*)pUpdateStruct)->descriptorType;
+        case VK_STRUCTURE_TYPE_UPDATE_BUFFERS:
+            actualType = ((VK_UPDATE_BUFFERS*)pUpdateStruct)->descriptorType;
             break;
-        case XGL_STRUCTURE_TYPE_UPDATE_AS_COPY:
-            actualType = ((XGL_UPDATE_AS_COPY*)pUpdateStruct)->descriptorType;
+        case VK_STRUCTURE_TYPE_UPDATE_AS_COPY:
+            actualType = ((VK_UPDATE_AS_COPY*)pUpdateStruct)->descriptorType;
             break;
         default:
             // TODO : Flag specific error for this case
@@ -713,86 +713,86 @@
     size_t base_array_size = 0;
     size_t total_array_size = 0;
     size_t baseBuffAddr = 0;
-    XGL_UPDATE_BUFFERS* pUBCI;
-    XGL_UPDATE_IMAGES* pUICI;
-    XGL_IMAGE_VIEW_ATTACH_INFO** ppLocalImageViews = NULL;
-    XGL_BUFFER_VIEW_ATTACH_INFO** ppLocalBufferViews = NULL;
+    VK_UPDATE_BUFFERS* pUBCI;
+    VK_UPDATE_IMAGES* pUICI;
+    VK_IMAGE_VIEW_ATTACH_INFO** ppLocalImageViews = NULL;
+    VK_BUFFER_VIEW_ATTACH_INFO** ppLocalBufferViews = NULL;
     char str[1024];
     switch (pUpdate->sType)
     {
-        case XGL_STRUCTURE_TYPE_UPDATE_SAMPLERS:
-            pNewNode = (GENERIC_HEADER*)malloc(sizeof(XGL_UPDATE_SAMPLERS));
+        case VK_STRUCTURE_TYPE_UPDATE_SAMPLERS:
+            pNewNode = (GENERIC_HEADER*)malloc(sizeof(VK_UPDATE_SAMPLERS));
 #if ALLOC_DEBUG
             printf("Alloc10 #%lu pNewNode addr(%p)\n", ++g_alloc_count, (void*)pNewNode);
 #endif
-            memcpy(pNewNode, pUpdate, sizeof(XGL_UPDATE_SAMPLERS));
-            array_size = sizeof(XGL_SAMPLER) * ((XGL_UPDATE_SAMPLERS*)pNewNode)->count;
-            ((XGL_UPDATE_SAMPLERS*)pNewNode)->pSamplers = (XGL_SAMPLER*)malloc(array_size);
+            memcpy(pNewNode, pUpdate, sizeof(VK_UPDATE_SAMPLERS));
+            array_size = sizeof(VK_SAMPLER) * ((VK_UPDATE_SAMPLERS*)pNewNode)->count;
+            ((VK_UPDATE_SAMPLERS*)pNewNode)->pSamplers = (VK_SAMPLER*)malloc(array_size);
 #if ALLOC_DEBUG
-            printf("Alloc11 #%lu pNewNode->pSamplers addr(%p)\n", ++g_alloc_count, (void*)((XGL_UPDATE_SAMPLERS*)pNewNode)->pSamplers);
+            printf("Alloc11 #%lu pNewNode->pSamplers addr(%p)\n", ++g_alloc_count, (void*)((VK_UPDATE_SAMPLERS*)pNewNode)->pSamplers);
 #endif
-            memcpy((XGL_SAMPLER*)((XGL_UPDATE_SAMPLERS*)pNewNode)->pSamplers, ((XGL_UPDATE_SAMPLERS*)pUpdate)->pSamplers, array_size);
+            memcpy((VK_SAMPLER*)((VK_UPDATE_SAMPLERS*)pNewNode)->pSamplers, ((VK_UPDATE_SAMPLERS*)pUpdate)->pSamplers, array_size);
             break;
-        case XGL_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES:
-            pNewNode = (GENERIC_HEADER*)malloc(sizeof(XGL_UPDATE_SAMPLER_TEXTURES));
+        case VK_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES:
+            pNewNode = (GENERIC_HEADER*)malloc(sizeof(VK_UPDATE_SAMPLER_TEXTURES));
 #if ALLOC_DEBUG
             printf("Alloc12 #%lu pNewNode addr(%p)\n", ++g_alloc_count, (void*)pNewNode);
 #endif
-            memcpy(pNewNode, pUpdate, sizeof(XGL_UPDATE_SAMPLER_TEXTURES));
-            array_size = sizeof(XGL_SAMPLER_IMAGE_VIEW_INFO) * ((XGL_UPDATE_SAMPLER_TEXTURES*)pNewNode)->count;
-            ((XGL_UPDATE_SAMPLER_TEXTURES*)pNewNode)->pSamplerImageViews = (XGL_SAMPLER_IMAGE_VIEW_INFO*)malloc(array_size);
+            memcpy(pNewNode, pUpdate, sizeof(VK_UPDATE_SAMPLER_TEXTURES));
+            array_size = sizeof(VK_SAMPLER_IMAGE_VIEW_INFO) * ((VK_UPDATE_SAMPLER_TEXTURES*)pNewNode)->count;
+            ((VK_UPDATE_SAMPLER_TEXTURES*)pNewNode)->pSamplerImageViews = (VK_SAMPLER_IMAGE_VIEW_INFO*)malloc(array_size);
 #if ALLOC_DEBUG
-            printf("Alloc13 #%lu pNewNode->pSamplerImageViews addr(%p)\n", ++g_alloc_count, (void*)((XGL_UPDATE_SAMPLER_TEXTURES*)pNewNode)->pSamplerImageViews);
+            printf("Alloc13 #%lu pNewNode->pSamplerImageViews addr(%p)\n", ++g_alloc_count, (void*)((VK_UPDATE_SAMPLER_TEXTURES*)pNewNode)->pSamplerImageViews);
 #endif
-            for (uint32_t i = 0; i < ((XGL_UPDATE_SAMPLER_TEXTURES*)pNewNode)->count; i++) {
-                memcpy((XGL_SAMPLER_IMAGE_VIEW_INFO*)&((XGL_UPDATE_SAMPLER_TEXTURES*)pNewNode)->pSamplerImageViews[i], &((XGL_UPDATE_SAMPLER_TEXTURES*)pUpdate)->pSamplerImageViews[i], sizeof(XGL_SAMPLER_IMAGE_VIEW_INFO));
-                ((XGL_SAMPLER_IMAGE_VIEW_INFO*)((XGL_UPDATE_SAMPLER_TEXTURES*)pNewNode)->pSamplerImageViews)[i].pImageView = (XGL_IMAGE_VIEW_ATTACH_INFO*)malloc(sizeof(XGL_IMAGE_VIEW_ATTACH_INFO));
+            for (uint32_t i = 0; i < ((VK_UPDATE_SAMPLER_TEXTURES*)pNewNode)->count; i++) {
+                memcpy((VK_SAMPLER_IMAGE_VIEW_INFO*)&((VK_UPDATE_SAMPLER_TEXTURES*)pNewNode)->pSamplerImageViews[i], &((VK_UPDATE_SAMPLER_TEXTURES*)pUpdate)->pSamplerImageViews[i], sizeof(VK_SAMPLER_IMAGE_VIEW_INFO));
+                ((VK_SAMPLER_IMAGE_VIEW_INFO*)((VK_UPDATE_SAMPLER_TEXTURES*)pNewNode)->pSamplerImageViews)[i].pImageView = (VK_IMAGE_VIEW_ATTACH_INFO*)malloc(sizeof(VK_IMAGE_VIEW_ATTACH_INFO));
 #if ALLOC_DEBUG
-                printf("Alloc14 #%lu pSamplerImageViews)[%u].pImageView addr(%p)\n", ++g_alloc_count, i, (void*)((XGL_SAMPLER_IMAGE_VIEW_INFO*)((XGL_UPDATE_SAMPLER_TEXTURES*)pNewNode)->pSamplerImageViews)[i].pImageView);
+                printf("Alloc14 #%lu pSamplerImageViews)[%u].pImageView addr(%p)\n", ++g_alloc_count, i, (void*)((VK_SAMPLER_IMAGE_VIEW_INFO*)((VK_UPDATE_SAMPLER_TEXTURES*)pNewNode)->pSamplerImageViews)[i].pImageView);
 #endif
-                memcpy((XGL_IMAGE_VIEW_ATTACH_INFO*)((XGL_UPDATE_SAMPLER_TEXTURES*)pNewNode)->pSamplerImageViews[i].pImageView, ((XGL_UPDATE_SAMPLER_TEXTURES*)pUpdate)->pSamplerImageViews[i].pImageView, sizeof(XGL_IMAGE_VIEW_ATTACH_INFO));
+                memcpy((VK_IMAGE_VIEW_ATTACH_INFO*)((VK_UPDATE_SAMPLER_TEXTURES*)pNewNode)->pSamplerImageViews[i].pImageView, ((VK_UPDATE_SAMPLER_TEXTURES*)pUpdate)->pSamplerImageViews[i].pImageView, sizeof(VK_IMAGE_VIEW_ATTACH_INFO));
             }
             break;
-        case XGL_STRUCTURE_TYPE_UPDATE_IMAGES:
-            pUICI = (XGL_UPDATE_IMAGES*)pUpdate;
-            pNewNode = (GENERIC_HEADER*)malloc(sizeof(XGL_UPDATE_IMAGES));
+        case VK_STRUCTURE_TYPE_UPDATE_IMAGES:
+            pUICI = (VK_UPDATE_IMAGES*)pUpdate;
+            pNewNode = (GENERIC_HEADER*)malloc(sizeof(VK_UPDATE_IMAGES));
 #if ALLOC_DEBUG
             printf("Alloc15 #%lu pNewNode addr(%p)\n", ++g_alloc_count, (void*)pNewNode);
 #endif
-            memcpy(pNewNode, pUpdate, sizeof(XGL_UPDATE_IMAGES));
-            total_array_size = (sizeof(XGL_IMAGE_VIEW_ATTACH_INFO) * ((XGL_UPDATE_IMAGES*)pNewNode)->count);
-            ppLocalImageViews = (XGL_IMAGE_VIEW_ATTACH_INFO**)&(((XGL_UPDATE_IMAGES*)pNewNode)->pImageViews);
-            *ppLocalImageViews = (XGL_IMAGE_VIEW_ATTACH_INFO*)malloc(total_array_size);
+            memcpy(pNewNode, pUpdate, sizeof(VK_UPDATE_IMAGES));
+            total_array_size = (sizeof(VK_IMAGE_VIEW_ATTACH_INFO) * ((VK_UPDATE_IMAGES*)pNewNode)->count);
+            ppLocalImageViews = (VK_IMAGE_VIEW_ATTACH_INFO**)&(((VK_UPDATE_IMAGES*)pNewNode)->pImageViews);
+            *ppLocalImageViews = (VK_IMAGE_VIEW_ATTACH_INFO*)malloc(total_array_size);
 #if ALLOC_DEBUG
             printf("Alloc16 #%lu *pppLocalImageViews addr(%p)\n", ++g_alloc_count, (void*)*ppLocalImageViews);
 #endif
             memcpy((void*)*ppLocalImageViews, pUICI->pImageViews, total_array_size);
             break;
-        case XGL_STRUCTURE_TYPE_UPDATE_BUFFERS:
-            pUBCI = (XGL_UPDATE_BUFFERS*)pUpdate;
-            pNewNode = (GENERIC_HEADER*)malloc(sizeof(XGL_UPDATE_BUFFERS));
+        case VK_STRUCTURE_TYPE_UPDATE_BUFFERS:
+            pUBCI = (VK_UPDATE_BUFFERS*)pUpdate;
+            pNewNode = (GENERIC_HEADER*)malloc(sizeof(VK_UPDATE_BUFFERS));
 #if ALLOC_DEBUG
             printf("Alloc17 #%lu pNewNode addr(%p)\n", ++g_alloc_count, (void*)pNewNode);
 #endif
-            memcpy(pNewNode, pUpdate, sizeof(XGL_UPDATE_BUFFERS));
-            total_array_size = (sizeof(XGL_BUFFER_VIEW_ATTACH_INFO) * pUBCI->count);
-            ppLocalBufferViews = (XGL_BUFFER_VIEW_ATTACH_INFO**)&(((XGL_UPDATE_BUFFERS*)pNewNode)->pBufferViews);
-            *ppLocalBufferViews = (XGL_BUFFER_VIEW_ATTACH_INFO*)malloc(total_array_size);
+            memcpy(pNewNode, pUpdate, sizeof(VK_UPDATE_BUFFERS));
+            total_array_size = (sizeof(VK_BUFFER_VIEW_ATTACH_INFO) * pUBCI->count);
+            ppLocalBufferViews = (VK_BUFFER_VIEW_ATTACH_INFO**)&(((VK_UPDATE_BUFFERS*)pNewNode)->pBufferViews);
+            *ppLocalBufferViews = (VK_BUFFER_VIEW_ATTACH_INFO*)malloc(total_array_size);
 #if ALLOC_DEBUG
             printf("Alloc18 #%lu *pppLocalBufferViews addr(%p)\n", ++g_alloc_count, (void*)*ppLocalBufferViews);
 #endif
             memcpy((void*)*ppLocalBufferViews, pUBCI->pBufferViews, total_array_size);
             break;
-        case XGL_STRUCTURE_TYPE_UPDATE_AS_COPY:
-            pNewNode = (GENERIC_HEADER*)malloc(sizeof(XGL_UPDATE_AS_COPY));
+        case VK_STRUCTURE_TYPE_UPDATE_AS_COPY:
+            pNewNode = (GENERIC_HEADER*)malloc(sizeof(VK_UPDATE_AS_COPY));
 #if ALLOC_DEBUG
             printf("Alloc19 #%lu pNewNode addr(%p)\n", ++g_alloc_count, (void*)pNewNode);
 #endif
-            memcpy(pNewNode, pUpdate, sizeof(XGL_UPDATE_AS_COPY));
+            memcpy(pNewNode, pUpdate, sizeof(VK_UPDATE_AS_COPY));
             break;
         default:
-            sprintf(str, "Unexpected UPDATE struct of type %s (value %u) in xglUpdateDescriptors() struct tree", string_XGL_STRUCTURE_TYPE(pUpdate->sType), pUpdate->sType);
-            layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_INVALID_UPDATE_STRUCT, "DS", str);
+            sprintf(str, "Unexpected UPDATE struct of type %s (value %u) in vkUpdateDescriptors() struct tree", string_VK_STRUCTURE_TYPE(pUpdate->sType), pUpdate->sType);
+            layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_INVALID_UPDATE_STRUCT, "DS", str);
             return NULL;
     }
     // Make sure that pNext for the end of shadow copy is NULL
@@ -800,13 +800,13 @@
     return pNewNode;
 }
 // For given ds, update its mapping based on ppUpdateArray
-static void dsUpdate(XGL_DESCRIPTOR_SET ds, uint32_t updateCount, const void** ppUpdateArray)
+static void dsUpdate(VK_DESCRIPTOR_SET ds, uint32_t updateCount, const void** ppUpdateArray)
 {
     SET_NODE* pSet = getSetNode(ds);
     loader_platform_thread_lock_mutex(&globalLock);
     g_lastBoundDescriptorSet = pSet->set;
     LAYOUT_NODE* pLayout = NULL;
-    XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pLayoutCI = NULL;
+    VK_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pLayoutCI = NULL;
     // TODO : If pCIList is NULL, flag error
     // Perform all updates
     for (uint32_t i = 0; i < updateCount; i++) {
@@ -815,24 +815,24 @@
         // Make sure that binding is within bounds
         if (pLayout->createInfo.count < getUpdateBinding(pUpdate)) {
             char str[1024];
-            sprintf(str, "Descriptor Set %p does not have binding to match update binding %u for update type %s!", ds, getUpdateBinding(pUpdate), string_XGL_STRUCTURE_TYPE(pUpdate->sType));
-            layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, ds, 0, DRAWSTATE_INVALID_UPDATE_INDEX, "DS", str);
+            sprintf(str, "Descriptor Set %p does not have binding to match update binding %u for update type %s!", ds, getUpdateBinding(pUpdate), string_VK_STRUCTURE_TYPE(pUpdate->sType));
+            layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, ds, 0, DRAWSTATE_INVALID_UPDATE_INDEX, "DS", str);
         }
         else {
             // Next verify that update falls within size of given binding
             if (getBindingEndIndex(pLayout, getUpdateBinding(pUpdate)) < getUpdateEndIndex(pLayout, pUpdate)) {
                 char str[48*1024]; // TODO : Keep count of layout CI structs and size this string dynamically based on that count
                 pLayoutCI = &pLayout->createInfo;
-                string DSstr = xgl_print_xgl_descriptor_set_layout_create_info(pLayoutCI, "{DS}    ");
-                sprintf(str, "Descriptor update type of %s is out of bounds for matching binding %u in Layout w/ CI:\n%s!", string_XGL_STRUCTURE_TYPE(pUpdate->sType), getUpdateBinding(pUpdate), DSstr.c_str());
-                layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, ds, 0, DRAWSTATE_DESCRIPTOR_UPDATE_OUT_OF_BOUNDS, "DS", str);
+                string DSstr = vk_print_vk_descriptor_set_layout_create_info(pLayoutCI, "{DS}    ");
+                sprintf(str, "Descriptor update type of %s is out of bounds for matching binding %u in Layout w/ CI:\n%s!", string_VK_STRUCTURE_TYPE(pUpdate->sType), getUpdateBinding(pUpdate), DSstr.c_str());
+                layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, ds, 0, DRAWSTATE_DESCRIPTOR_UPDATE_OUT_OF_BOUNDS, "DS", str);
             }
             else { // TODO : should we skip update on a type mismatch or force it?
                 // Layout bindings match w/ update ok, now verify that update is of the right type
                 if (!validateUpdateType(pLayout, pUpdate)) {
                     char str[1024];
-                    sprintf(str, "Descriptor update type of %s does not match overlapping binding type!", string_XGL_STRUCTURE_TYPE(pUpdate->sType));
-                    layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, ds, 0, DRAWSTATE_DESCRIPTOR_TYPE_MISMATCH, "DS", str);
+                    sprintf(str, "Descriptor update type of %s does not match overlapping binding type!", string_VK_STRUCTURE_TYPE(pUpdate->sType));
+                    layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, ds, 0, DRAWSTATE_DESCRIPTOR_TYPE_MISMATCH, "DS", str);
                 }
                 else {
                     // Save the update info
@@ -841,8 +841,8 @@
                     GENERIC_HEADER* pNewNode = shadowUpdateNode(pUpdate);
                     if (NULL == pNewNode) {
                         char str[1024];
-                        sprintf(str, "Out of memory while attempting to allocate UPDATE struct in xglUpdateDescriptors()");
-                        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, ds, 0, DRAWSTATE_OUT_OF_MEMORY, "DS", str);
+                        sprintf(str, "Out of memory while attempting to allocate UPDATE struct in vkUpdateDescriptors()");
+                        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, ds, 0, DRAWSTATE_OUT_OF_MEMORY, "DS", str);
                     }
                     else {
                         // Insert shadow node into LL of updates for this set
@@ -873,15 +873,15 @@
         pFreeUpdate = pShadowUpdate;
         pShadowUpdate = (GENERIC_HEADER*)pShadowUpdate->pNext;
         uint32_t index = 0;
-        XGL_UPDATE_SAMPLERS* pUS = NULL;
-        XGL_UPDATE_SAMPLER_TEXTURES* pUST = NULL;
-        XGL_UPDATE_IMAGES* pUI = NULL;
-        XGL_UPDATE_BUFFERS* pUB = NULL;
+        VK_UPDATE_SAMPLERS* pUS = NULL;
+        VK_UPDATE_SAMPLER_TEXTURES* pUST = NULL;
+        VK_UPDATE_IMAGES* pUI = NULL;
+        VK_UPDATE_BUFFERS* pUB = NULL;
         void** ppToFree = NULL;
         switch (pFreeUpdate->sType)
         {
-            case XGL_STRUCTURE_TYPE_UPDATE_SAMPLERS:
-                pUS = (XGL_UPDATE_SAMPLERS*)pFreeUpdate;
+            case VK_STRUCTURE_TYPE_UPDATE_SAMPLERS:
+                pUS = (VK_UPDATE_SAMPLERS*)pFreeUpdate;
                 if (pUS->pSamplers) {
                     ppToFree = (void**)&pUS->pSamplers;
 #if ALLOC_DEBUG
@@ -890,8 +890,8 @@
                     free(*ppToFree);
                 }
                 break;
-            case XGL_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES:
-                pUST = (XGL_UPDATE_SAMPLER_TEXTURES*)pFreeUpdate;
+            case VK_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES:
+                pUST = (VK_UPDATE_SAMPLER_TEXTURES*)pFreeUpdate;
                 for (index = 0; index < pUST->count; index++) {
                     if (pUST->pSamplerImageViews[index].pImageView) {
                         ppToFree = (void**)&pUST->pSamplerImageViews[index].pImageView;
@@ -907,8 +907,8 @@
 #endif
                 free(*ppToFree);
                 break;
-            case XGL_STRUCTURE_TYPE_UPDATE_IMAGES:
-                pUI = (XGL_UPDATE_IMAGES*)pFreeUpdate;
+            case VK_STRUCTURE_TYPE_UPDATE_IMAGES:
+                pUI = (VK_UPDATE_IMAGES*)pFreeUpdate;
                 if (pUI->pImageViews) {
                     ppToFree = (void**)&pUI->pImageViews;
 #if ALLOC_DEBUG
@@ -917,8 +917,8 @@
                     free(*ppToFree);
                 }
                 break;
-            case XGL_STRUCTURE_TYPE_UPDATE_BUFFERS:
-                pUB = (XGL_UPDATE_BUFFERS*)pFreeUpdate;
+            case VK_STRUCTURE_TYPE_UPDATE_BUFFERS:
+                pUB = (VK_UPDATE_BUFFERS*)pFreeUpdate;
                 if (pUB->pBufferViews) {
                     ppToFree = (void**)&pUB->pBufferViews;
 #if ALLOC_DEBUG
@@ -927,7 +927,7 @@
                     free(*ppToFree);
                 }
                 break;
-            case XGL_STRUCTURE_TYPE_UPDATE_AS_COPY:
+            case VK_STRUCTURE_TYPE_UPDATE_AS_COPY:
                 break;
             default:
                 assert(0);
@@ -943,7 +943,7 @@
 // NOTE : Calls to this function should be wrapped in mutex
 static void freePools()
 {
-    for (unordered_map<XGL_DESCRIPTOR_POOL, POOL_NODE*>::iterator ii=poolMap.begin(); ii!=poolMap.end(); ++ii) {
+    for (unordered_map<VK_DESCRIPTOR_POOL, POOL_NODE*>::iterator ii=poolMap.begin(); ii!=poolMap.end(); ++ii) {
         SET_NODE* pSet = (*ii).second->pSets;
         SET_NODE* pFreeSet = pSet;
         while (pSet) {
@@ -967,7 +967,7 @@
 // NOTE : Calls to this function should be wrapped in mutex
 static void freeLayouts()
 {
-    for (unordered_map<XGL_DESCRIPTOR_SET_LAYOUT, LAYOUT_NODE*>::iterator ii=layoutMap.begin(); ii!=layoutMap.end(); ++ii) {
+    for (unordered_map<VK_DESCRIPTOR_SET_LAYOUT, LAYOUT_NODE*>::iterator ii=layoutMap.begin(); ii!=layoutMap.end(); ++ii) {
         LAYOUT_NODE* pLayout = (*ii).second;
         if (pLayout->pTypes) {
             delete pLayout->pTypes;
@@ -977,7 +977,7 @@
 }
 // Currently clearing a set is removing all previous updates to that set
 //  TODO : Validate if this is correct clearing behavior
-static void clearDescriptorSet(XGL_DESCRIPTOR_SET set)
+static void clearDescriptorSet(VK_DESCRIPTOR_SET set)
 {
     SET_NODE* pSet = getSetNode(set);
     if (!pSet) {
@@ -990,13 +990,13 @@
     }
 }
 
-static void clearDescriptorPool(XGL_DESCRIPTOR_POOL pool)
+static void clearDescriptorPool(VK_DESCRIPTOR_POOL pool)
 {
     POOL_NODE* pPool = getPoolNode(pool);
     if (!pPool) {
         char str[1024];
-        sprintf(str, "Unable to find pool node for pool %p specified in xglClearDescriptorPool() call", (void*)pool);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, pool, 0, DRAWSTATE_INVALID_POOL, "DS", str);
+        sprintf(str, "Unable to find pool node for pool %p specified in vkClearDescriptorPool() call", (void*)pool);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, pool, 0, DRAWSTATE_INVALID_POOL, "DS", str);
     }
     else
     {
@@ -1008,7 +1008,7 @@
     }
 }
 // Code here to manage the Cmd buffer LL
-static GLOBAL_CB_NODE* getCBNode(XGL_CMD_BUFFER cb)
+static GLOBAL_CB_NODE* getCBNode(VK_CMD_BUFFER cb)
 {
     loader_platform_thread_lock_mutex(&globalLock);
     if (cmdBufferMap.find(cb) == cmdBufferMap.end()) {
@@ -1022,7 +1022,7 @@
 // NOTE : Calls to this function should be wrapped in mutex
 static void freeCmdBuffers()
 {
-    for (unordered_map<XGL_CMD_BUFFER, GLOBAL_CB_NODE*>::iterator ii=cmdBufferMap.begin(); ii!=cmdBufferMap.end(); ++ii) {
+    for (unordered_map<VK_CMD_BUFFER, GLOBAL_CB_NODE*>::iterator ii=cmdBufferMap.begin(); ii!=cmdBufferMap.end(); ++ii) {
         while (!(*ii).second->pCmds.empty()) {
             delete (*ii).second->pCmds.back();
             (*ii).second->pCmds.pop_back();
@@ -1043,10 +1043,10 @@
     else {
         char str[1024];
         sprintf(str, "Out of memory while attempting to allocate new CMD_NODE for cmdBuffer %p", (void*)pCB->cmdBuffer);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, pCB->cmdBuffer, 0, DRAWSTATE_OUT_OF_MEMORY, "DS", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, pCB->cmdBuffer, 0, DRAWSTATE_OUT_OF_MEMORY, "DS", str);
     }
 }
-static void resetCB(const XGL_CMD_BUFFER cb)
+static void resetCB(const VK_CMD_BUFFER cb)
 {
     GLOBAL_CB_NODE* pCB = getCBNode(cb);
     if (pCB) {
@@ -1055,7 +1055,7 @@
             pCB->pCmds.pop_back();
         }
         // Reset CB state
-        XGL_FLAGS saveFlags = pCB->flags;
+        VK_FLAGS saveFlags = pCB->flags;
         uint32_t saveQueueNodeIndex = pCB->queueNodeIndex;
         memset(pCB, 0, sizeof(GLOBAL_CB_NODE));
         pCB->cmdBuffer = cb;
@@ -1066,7 +1066,7 @@
 }
 // Set the last bound dynamic state of given type
 // TODO : Need to track this per cmdBuffer and correlate cmdBuffer for Draw w/ last bound for that cmdBuffer?
-static void setLastBoundDynamicState(const XGL_CMD_BUFFER cmdBuffer, const XGL_DYNAMIC_STATE_OBJECT state, const XGL_STATE_BIND_POINT sType)
+static void setLastBoundDynamicState(const VK_CMD_BUFFER cmdBuffer, const VK_DYNAMIC_STATE_OBJECT state, const VK_STATE_BIND_POINT sType)
 {
     GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
     if (pCB) {
@@ -1076,7 +1076,7 @@
         if (dynamicStateMap.find(state) == dynamicStateMap.end()) {
             char str[1024];
             sprintf(str, "Unable to find dynamic state object %p, was it ever created?", (void*)state);
-            layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, state, 0, DRAWSTATE_INVALID_DYNAMIC_STATE_OBJECT, "DS", str);
+            layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, state, 0, DRAWSTATE_INVALID_DYNAMIC_STATE_OBJECT, "DS", str);
         }
         else {
             pCB->lastBoundDynamicState[sType] = dynamicStateMap[state];
@@ -1087,11 +1087,11 @@
     else {
         char str[1024];
         sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
     }
 }
 // Print the last bound Gfx Pipeline
-static void printPipeline(const XGL_CMD_BUFFER cb)
+static void printPipeline(const VK_CMD_BUFFER cb)
 {
     GLOBAL_CB_NODE* pCB = getCBNode(cb);
     if (pCB) {
@@ -1100,13 +1100,13 @@
             // nothing to print
         }
         else {
-            string pipeStr = xgl_print_xgl_graphics_pipeline_create_info(&pPipeTrav->graphicsPipelineCI, "{DS}").c_str();
-            layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_NONE, "DS", pipeStr.c_str());
+            string pipeStr = vk_print_vk_graphics_pipeline_create_info(&pPipeTrav->graphicsPipelineCI, "{DS}").c_str();
+            layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_NONE, "DS", pipeStr.c_str());
         }
     }
 }
 // Common Dot dumping code
-static void dsCoreDumpDot(const XGL_DESCRIPTOR_SET ds, FILE* pOutFile)
+static void dsCoreDumpDot(const VK_DESCRIPTOR_SET ds, FILE* pOutFile)
 {
     SET_NODE* pSet = getSetNode(ds);
     if (pSet) {
@@ -1114,7 +1114,7 @@
         char tmp_str[4*1024];
         fprintf(pOutFile, "subgraph cluster_DescriptorPool\n{\nlabel=\"Descriptor Pool\"\n");
         sprintf(tmp_str, "Pool (%p)", pPool->pool);
-        char* pGVstr = xgl_gv_print_xgl_descriptor_pool_create_info(&pPool->createInfo, tmp_str);
+        char* pGVstr = vk_gv_print_vk_descriptor_pool_create_info(&pPool->createInfo, tmp_str);
         fprintf(pOutFile, "%s", pGVstr);
         free(pGVstr);
         fprintf(pOutFile, "subgraph cluster_DescriptorSet\n{\nlabel=\"Descriptor Set (%p)\"\n", pSet->set);
@@ -1123,7 +1123,7 @@
         uint32_t layout_index = 0;
         ++layout_index;
         sprintf(tmp_str, "LAYOUT%u", layout_index);
-        pGVstr = xgl_gv_print_xgl_descriptor_set_layout_create_info(&pLayout->createInfo, tmp_str);
+        pGVstr = vk_gv_print_vk_descriptor_set_layout_create_info(&pLayout->createInfo, tmp_str);
         fprintf(pOutFile, "%s", pGVstr);
         free(pGVstr);
         if (pSet->pUpdateStructs) {
@@ -1136,7 +1136,7 @@
             uint32_t i = 0;
             for (i=0; i < pSet->descriptorCount; i++) {
                 if (pSet->ppDescriptors[i]) {
-                    fprintf(pOutFile, "<TR><TD PORT=\"slot%u\">slot%u</TD><TD>%s</TD></TR>", i, i, string_XGL_STRUCTURE_TYPE(pSet->ppDescriptors[i]->sType));
+                    fprintf(pOutFile, "<TR><TD PORT=\"slot%u\">slot%u</TD><TD>%s</TD></TR>", i, i, string_VK_STRUCTURE_TYPE(pSet->ppDescriptors[i]->sType));
                 }
             }
 #define NUM_COLORS 7
@@ -1151,71 +1151,71 @@
             uint32_t colorIdx = 0;
             fprintf(pOutFile, "</TABLE>>\n];\n");
             // Now add the views that are mapped to active descriptors
-            XGL_UPDATE_SAMPLERS* pUS = NULL;
-            XGL_UPDATE_SAMPLER_TEXTURES* pUST = NULL;
-            XGL_UPDATE_IMAGES* pUI = NULL;
-            XGL_UPDATE_BUFFERS* pUB = NULL;
-            XGL_UPDATE_AS_COPY* pUAC = NULL;
-            XGL_SAMPLER_CREATE_INFO* pSCI = NULL;
-            XGL_IMAGE_VIEW_CREATE_INFO* pIVCI = NULL;
-            XGL_BUFFER_VIEW_CREATE_INFO* pBVCI = NULL;
+            VK_UPDATE_SAMPLERS* pUS = NULL;
+            VK_UPDATE_SAMPLER_TEXTURES* pUST = NULL;
+            VK_UPDATE_IMAGES* pUI = NULL;
+            VK_UPDATE_BUFFERS* pUB = NULL;
+            VK_UPDATE_AS_COPY* pUAC = NULL;
+            VK_SAMPLER_CREATE_INFO* pSCI = NULL;
+            VK_IMAGE_VIEW_CREATE_INFO* pIVCI = NULL;
+            VK_BUFFER_VIEW_CREATE_INFO* pBVCI = NULL;
             void** ppNextPtr = NULL;
             void* pSaveNext = NULL;
             for (i=0; i < pSet->descriptorCount; i++) {
                 if (pSet->ppDescriptors[i]) {
                     switch (pSet->ppDescriptors[i]->sType)
                     {
-                        case XGL_STRUCTURE_TYPE_UPDATE_SAMPLERS:
-                            pUS = (XGL_UPDATE_SAMPLERS*)pSet->ppDescriptors[i];
+                        case VK_STRUCTURE_TYPE_UPDATE_SAMPLERS:
+                            pUS = (VK_UPDATE_SAMPLERS*)pSet->ppDescriptors[i];
                             pSCI = getSamplerCreateInfo(pUS->pSamplers[i-pUS->arrayIndex]);
                             if (pSCI) {
                                 sprintf(tmp_str, "SAMPLER%u", i);
-                                fprintf(pOutFile, "%s", xgl_gv_print_xgl_sampler_create_info(pSCI, tmp_str));
+                                fprintf(pOutFile, "%s", vk_gv_print_vk_sampler_create_info(pSCI, tmp_str));
                                 fprintf(pOutFile, "\"DESCRIPTORS\":slot%u -> \"%s\" [color=\"#%s\"];\n", i, tmp_str, edgeColors[colorIdx].c_str());
                             }
                             break;
-                        case XGL_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES:
-                            pUST = (XGL_UPDATE_SAMPLER_TEXTURES*)pSet->ppDescriptors[i];
+                        case VK_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES:
+                            pUST = (VK_UPDATE_SAMPLER_TEXTURES*)pSet->ppDescriptors[i];
                             pSCI = getSamplerCreateInfo(pUST->pSamplerImageViews[i-pUST->arrayIndex].sampler);
                             if (pSCI) {
                                 sprintf(tmp_str, "SAMPLER%u", i);
-                                fprintf(pOutFile, "%s", xgl_gv_print_xgl_sampler_create_info(pSCI, tmp_str));
+                                fprintf(pOutFile, "%s", vk_gv_print_vk_sampler_create_info(pSCI, tmp_str));
                                 fprintf(pOutFile, "\"DESCRIPTORS\":slot%u -> \"%s\" [color=\"#%s\"];\n", i, tmp_str, edgeColors[colorIdx].c_str());
                             }
                             pIVCI = getImageViewCreateInfo(pUST->pSamplerImageViews[i-pUST->arrayIndex].pImageView->view);
                             if (pIVCI) {
                                 sprintf(tmp_str, "IMAGE_VIEW%u", i);
-                                fprintf(pOutFile, "%s", xgl_gv_print_xgl_image_view_create_info(pIVCI, tmp_str));
+                                fprintf(pOutFile, "%s", vk_gv_print_vk_image_view_create_info(pIVCI, tmp_str));
                                 fprintf(pOutFile, "\"DESCRIPTORS\":slot%u -> \"%s\" [color=\"#%s\"];\n", i, tmp_str, edgeColors[colorIdx].c_str());
                             }
                             break;
-                        case XGL_STRUCTURE_TYPE_UPDATE_IMAGES:
-                            pUI = (XGL_UPDATE_IMAGES*)pSet->ppDescriptors[i];
+                        case VK_STRUCTURE_TYPE_UPDATE_IMAGES:
+                            pUI = (VK_UPDATE_IMAGES*)pSet->ppDescriptors[i];
                             pIVCI = getImageViewCreateInfo(pUI->pImageViews[i-pUI->arrayIndex].view);
                             if (pIVCI) {
                                 sprintf(tmp_str, "IMAGE_VIEW%u", i);
-                                fprintf(pOutFile, "%s", xgl_gv_print_xgl_image_view_create_info(pIVCI, tmp_str));
+                                fprintf(pOutFile, "%s", vk_gv_print_vk_image_view_create_info(pIVCI, tmp_str));
                                 fprintf(pOutFile, "\"DESCRIPTORS\":slot%u -> \"%s\" [color=\"#%s\"];\n", i, tmp_str, edgeColors[colorIdx].c_str());
                             }
                             break;
-                        case XGL_STRUCTURE_TYPE_UPDATE_BUFFERS:
-                            pUB = (XGL_UPDATE_BUFFERS*)pSet->ppDescriptors[i];
+                        case VK_STRUCTURE_TYPE_UPDATE_BUFFERS:
+                            pUB = (VK_UPDATE_BUFFERS*)pSet->ppDescriptors[i];
                             pBVCI = getBufferViewCreateInfo(pUB->pBufferViews[i-pUB->arrayIndex].view);
                             if (pBVCI) {
                                 sprintf(tmp_str, "BUFFER_VIEW%u", i);
-                                fprintf(pOutFile, "%s", xgl_gv_print_xgl_buffer_view_create_info(pBVCI, tmp_str));
+                                fprintf(pOutFile, "%s", vk_gv_print_vk_buffer_view_create_info(pBVCI, tmp_str));
                                 fprintf(pOutFile, "\"DESCRIPTORS\":slot%u -> \"%s\" [color=\"#%s\"];\n", i, tmp_str, edgeColors[colorIdx].c_str());
                             }
                             break;
-                        case XGL_STRUCTURE_TYPE_UPDATE_AS_COPY:
-                            pUAC = (XGL_UPDATE_AS_COPY*)pSet->ppDescriptors[i];
+                        case VK_STRUCTURE_TYPE_UPDATE_AS_COPY:
+                            pUAC = (VK_UPDATE_AS_COPY*)pSet->ppDescriptors[i];
                             // TODO : Need to validate this code
                             // Save off pNext and set to NULL while printing this struct, then restore it
                             ppNextPtr = (void**)&pUAC->pNext;
                             pSaveNext = *ppNextPtr;
                             *ppNextPtr = NULL;
                             sprintf(tmp_str, "UPDATE_AS_COPY%u", i);
-                            fprintf(pOutFile, "%s", xgl_gv_print_xgl_update_as_copy(pUAC, tmp_str));
+                            fprintf(pOutFile, "%s", vk_gv_print_vk_update_as_copy(pUAC, tmp_str));
                             fprintf(pOutFile, "\"DESCRIPTORS\":slot%u -> \"%s\" [color=\"#%s\"];\n", i, tmp_str, edgeColors[colorIdx].c_str());
                             // Restore next ptr
                             *ppNextPtr = pSaveNext;
@@ -1232,7 +1232,7 @@
     }
 }
 // Dump subgraph w/ DS info
-static void dsDumpDot(const XGL_CMD_BUFFER cb, FILE* pOutFile)
+static void dsDumpDot(const VK_CMD_BUFFER cb, FILE* pOutFile)
 {
     GLOBAL_CB_NODE* pCB = getCBNode(cb);
     if (pCB && pCB->lastBoundDescriptorSet) {
@@ -1282,16 +1282,16 @@
         fprintf(pOutFile, "digraph g {\ngraph [\nrankdir = \"TB\"\n];\nnode [\nfontsize = \"16\"\nshape = \"plaintext\"\n];\nedge [\n];\n");
         fprintf(pOutFile, "subgraph cluster_dynamicState\n{\nlabel=\"Dynamic State\"\n");
         char* pGVstr = NULL;
-        for (uint32_t i = 0; i < XGL_NUM_STATE_BIND_POINT; i++) {
+        for (uint32_t i = 0; i < VK_NUM_STATE_BIND_POINT; i++) {
             if (g_lastBoundDynamicState[i] && g_lastBoundDynamicState[i]->pCreateInfo) {
-                pGVstr = dynamic_gv_display(g_lastBoundDynamicState[i]->pCreateInfo, string_XGL_STATE_BIND_POINT((XGL_STATE_BIND_POINT)i));
+                pGVstr = dynamic_gv_display(g_lastBoundDynamicState[i]->pCreateInfo, string_VK_STATE_BIND_POINT((VK_STATE_BIND_POINT)i));
                 fprintf(pOutFile, "%s", pGVstr);
                 free(pGVstr);
             }
         }
         fprintf(pOutFile, "}\n"); // close dynamicState subgraph
         fprintf(pOutFile, "subgraph cluster_PipelineStateObject\n{\nlabel=\"Pipeline State Object\"\n");
-        pGVstr = xgl_gv_print_xgl_graphics_pipeline_create_info(&pPipeTrav->graphicsPipelineCI, "PSO HEAD");
+        pGVstr = vk_gv_print_vk_graphics_pipeline_create_info(&pPipeTrav->graphicsPipelineCI, "PSO HEAD");
         fprintf(pOutFile, "%s", pGVstr);
         free(pGVstr);
         fprintf(pOutFile, "}\n");
@@ -1301,7 +1301,7 @@
     }
 }
 // Dump a GraphViz dot file showing the pipeline for a given CB
-static void dumpDotFile(const XGL_CMD_BUFFER cb, string outFileName)
+static void dumpDotFile(const VK_CMD_BUFFER cb, string outFileName)
 {
     GLOBAL_CB_NODE* pCB = getCBNode(cb);
     if (pCB) {
@@ -1312,16 +1312,16 @@
             fprintf(pOutFile, "digraph g {\ngraph [\nrankdir = \"TB\"\n];\nnode [\nfontsize = \"16\"\nshape = \"plaintext\"\n];\nedge [\n];\n");
             fprintf(pOutFile, "subgraph cluster_dynamicState\n{\nlabel=\"Dynamic State\"\n");
             char* pGVstr = NULL;
-            for (uint32_t i = 0; i < XGL_NUM_STATE_BIND_POINT; i++) {
+            for (uint32_t i = 0; i < VK_NUM_STATE_BIND_POINT; i++) {
                 if (pCB->lastBoundDynamicState[i] && pCB->lastBoundDynamicState[i]->pCreateInfo) {
-                    pGVstr = dynamic_gv_display(pCB->lastBoundDynamicState[i]->pCreateInfo, string_XGL_STATE_BIND_POINT((XGL_STATE_BIND_POINT)i));
+                    pGVstr = dynamic_gv_display(pCB->lastBoundDynamicState[i]->pCreateInfo, string_VK_STATE_BIND_POINT((VK_STATE_BIND_POINT)i));
                     fprintf(pOutFile, "%s", pGVstr);
                     free(pGVstr);
                 }
             }
             fprintf(pOutFile, "}\n"); // close dynamicState subgraph
             fprintf(pOutFile, "subgraph cluster_PipelineStateObject\n{\nlabel=\"Pipeline State Object\"\n");
-            pGVstr = xgl_gv_print_xgl_graphics_pipeline_create_info(&pPipeTrav->graphicsPipelineCI, "PSO HEAD");
+            pGVstr = vk_gv_print_vk_graphics_pipeline_create_info(&pPipeTrav->graphicsPipelineCI, "PSO HEAD");
             fprintf(pOutFile, "%s", pGVstr);
             free(pGVstr);
             fprintf(pOutFile, "}\n");
@@ -1332,7 +1332,7 @@
     }
 }
 // Verify VB Buffer binding
-static void validateVBBinding(const XGL_CMD_BUFFER cb)
+static void validateVBBinding(const VK_CMD_BUFFER cb)
 {
     GLOBAL_CB_NODE* pCB = getCBNode(cb);
     if (pCB && pCB->lastBoundPipeline) {
@@ -1341,7 +1341,7 @@
         char str[1024];
         if (!pPipeTrav) {
             sprintf(str, "Can't find last bound Pipeline %p!", (void*)pCB->lastBoundPipeline);
-            layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_NO_PIPELINE_BOUND, "DS", str);
+            layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_NO_PIPELINE_BOUND, "DS", str);
         }
         else {
             // Verify Vtx binding
@@ -1349,23 +1349,23 @@
                 if (pCB->lastVtxBinding >= pPipeTrav->vtxBindingCount) {
                     if (0 == pPipeTrav->vtxBindingCount) {
                         sprintf(str, "Vtx Buffer Index %u was bound, but no vtx buffers are attached to PSO.", pCB->lastVtxBinding);
-                        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_VTX_INDEX_OUT_OF_BOUNDS, "DS", str);
+                        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_VTX_INDEX_OUT_OF_BOUNDS, "DS", str);
                     }
                     else {
                         sprintf(str, "Vtx binding Index of %u exceeds PSO pVertexBindingDescriptions max array index of %u.", pCB->lastVtxBinding, (pPipeTrav->vtxBindingCount - 1));
-                        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_VTX_INDEX_OUT_OF_BOUNDS, "DS", str);
+                        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_VTX_INDEX_OUT_OF_BOUNDS, "DS", str);
                     }
                 }
                 else {
-                    string tmpStr = xgl_print_xgl_vertex_input_binding_description(&pPipeTrav->pVertexBindingDescriptions[pCB->lastVtxBinding], "{DS}INFO : ").c_str();
-                    layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_NONE, "DS", tmpStr.c_str());
+                    string tmpStr = vk_print_vk_vertex_input_binding_description(&pPipeTrav->pVertexBindingDescriptions[pCB->lastVtxBinding], "{DS}INFO : ").c_str();
+                    layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_NONE, "DS", tmpStr.c_str());
                 }
             }
         }
     }
 }
 // Print details of DS config to stdout
-static void printDSConfig(const XGL_CMD_BUFFER cb)
+static void printDSConfig(const VK_CMD_BUFFER cb)
 {
     char tmp_str[1024];
     char ds_config_str[1024*256] = {0}; // TODO : Currently making this buffer HUGE w/o overrun protection.  Need to be smarter, start smaller, and grow as needed.
@@ -1375,50 +1375,50 @@
         POOL_NODE* pPool = getPoolNode(pSet->pool);
         // Print out pool details
         sprintf(tmp_str, "Details for pool %p.", (void*)pPool->pool);
-        layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_NONE, "DS", tmp_str);
-        string poolStr = xgl_print_xgl_descriptor_pool_create_info(&pPool->createInfo, " ");
+        layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_NONE, "DS", tmp_str);
+        string poolStr = vk_print_vk_descriptor_pool_create_info(&pPool->createInfo, " ");
         sprintf(ds_config_str, "%s", poolStr.c_str());
-        layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_NONE, "DS", ds_config_str);
+        layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_NONE, "DS", ds_config_str);
         // Print out set details
         char prefix[10];
         uint32_t index = 0;
         sprintf(tmp_str, "Details for descriptor set %p.", (void*)pSet->set);
-        layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_NONE, "DS", tmp_str);
+        layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_NONE, "DS", tmp_str);
         LAYOUT_NODE* pLayout = pSet->pLayout;
         // Print layout details
         sprintf(tmp_str, "Layout #%u, (object %p) for DS %p.", index+1, (void*)pLayout->layout, (void*)pSet->set);
-        layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_NONE, "DS", tmp_str);
+        layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_NONE, "DS", tmp_str);
         sprintf(prefix, "  [L%u] ", index);
-        string DSLstr = xgl_print_xgl_descriptor_set_layout_create_info(&pLayout->createInfo, prefix).c_str();
+        string DSLstr = vk_print_vk_descriptor_set_layout_create_info(&pLayout->createInfo, prefix).c_str();
         sprintf(ds_config_str, "%s", DSLstr.c_str());
-        layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_NONE, "DS", ds_config_str);
+        layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_NONE, "DS", ds_config_str);
         index++;
         GENERIC_HEADER* pUpdate = pSet->pUpdateStructs;
         if (pUpdate) {
             sprintf(tmp_str, "Update Chain [UC] for descriptor set %p:", (void*)pSet->set);
-            layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_NONE, "DS", tmp_str);
+            layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_NONE, "DS", tmp_str);
             sprintf(prefix, "  [UC] ");
             sprintf(ds_config_str, "%s", dynamic_display(pUpdate, prefix).c_str());
-            layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_NONE, "DS", ds_config_str);
+            layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_NONE, "DS", ds_config_str);
             // TODO : If there is a "view" associated with this update, print CI for that view
         }
         else {
-            sprintf(tmp_str, "No Update Chain for descriptor set %p (xglUpdateDescriptors has not been called)", (void*)pSet->set);
-            layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_NONE, "DS", tmp_str);
+            sprintf(tmp_str, "No Update Chain for descriptor set %p (vkUpdateDescriptors has not been called)", (void*)pSet->set);
+            layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_NONE, "DS", tmp_str);
         }
     }
 }
 
-static void printCB(const XGL_CMD_BUFFER cb)
+static void printCB(const VK_CMD_BUFFER cb)
 {
     GLOBAL_CB_NODE* pCB = getCBNode(cb);
     if (pCB) {
         char str[1024];
         sprintf(str, "Cmds in CB %p", (void*)cb);
-        layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_NONE, "DS", str);
+        layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_NONE, "DS", str);
         for (vector<CMD_NODE*>::iterator ii=pCB->pCmds.begin(); ii!=pCB->pCmds.end(); ++ii) {
             sprintf(str, "  CMD#%lu: %s", (*ii)->cmdNumber, cmdTypeToString((*ii)->type).c_str());
-            layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, cb, 0, DRAWSTATE_NONE, "DS", str);
+            layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, cb, 0, DRAWSTATE_NONE, "DS", str);
         }
     }
     else {
@@ -1427,7 +1427,7 @@
 }
 
 
-static void synchAndPrintDSConfig(const XGL_CMD_BUFFER cb)
+static void synchAndPrintDSConfig(const VK_CMD_BUFFER cb)
 {
     printDSConfig(cb);
     printPipeline(cb);
@@ -1455,7 +1455,7 @@
     getLayerOptionEnum("DrawStateReportLevel", (uint32_t *) &g_reportingLevel);
     g_actionIsDefault = getLayerOptionEnum("DrawStateDebugAction", (uint32_t *) &g_debugAction);
 
-    if (g_debugAction & XGL_DBG_LAYER_ACTION_LOG_MSG)
+    if (g_debugAction & VK_DBG_LAYER_ACTION_LOG_MSG)
     {
         strOpt = getLayerOption("DrawStateLogFilename");
         if (strOpt)
@@ -1467,20 +1467,20 @@
     }
     // initialize Layer dispatch table
     // TODO handle multiple GPUs
-    xglGetProcAddrType fpNextGPA;
+    vkGetProcAddrType fpNextGPA;
     fpNextGPA = pCurObj->pGPA;
     assert(fpNextGPA);
 
-    layer_initialize_dispatch_table(&nextTable, fpNextGPA, (XGL_PHYSICAL_GPU) pCurObj->nextObject);
+    layer_initialize_dispatch_table(&nextTable, fpNextGPA, (VK_PHYSICAL_GPU) pCurObj->nextObject);
 
-    xglGetProcAddrType fpGetProcAddr = (xglGetProcAddrType)fpNextGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (char *) "xglGetProcAddr");
+    vkGetProcAddrType fpGetProcAddr = (vkGetProcAddrType)fpNextGPA((VK_PHYSICAL_GPU) pCurObj->nextObject, (char *) "vkGetProcAddr");
     nextTable.GetProcAddr = fpGetProcAddr;
 
     if (!globalLockInitialized)
     {
         // TODO/TBD: Need to delete this mutex sometime.  How???  One
-        // suggestion is to call this during xglCreateInstance(), and then we
-        // can clean it up during xglDestroyInstance().  However, that requires
+        // suggestion is to call this during vkCreateInstance(), and then we
+        // can clean it up during vkDestroyInstance().  However, that requires
         // that the layer have per-instance locks.  We need to come back and
         // address this soon.
         loader_platform_thread_create_mutex(&globalLock);
@@ -1488,16 +1488,16 @@
     }
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateDevice(XGL_PHYSICAL_GPU gpu, const XGL_DEVICE_CREATE_INFO* pCreateInfo, XGL_DEVICE* pDevice)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDevice(VK_PHYSICAL_GPU gpu, const VK_DEVICE_CREATE_INFO* pCreateInfo, VK_DEVICE* pDevice)
 {
-    XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) gpu;
+    VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
     pCurObj = gpuw;
     loader_platform_thread_once(&g_initOnce, initDrawState);
-    XGL_RESULT result = nextTable.CreateDevice((XGL_PHYSICAL_GPU)gpuw->nextObject, pCreateInfo, pDevice);
+    VK_RESULT result = nextTable.CreateDevice((VK_PHYSICAL_GPU)gpuw->nextObject, pCreateInfo, pDevice);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDestroyDevice(XGL_DEVICE device)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkDestroyDevice(VK_DEVICE device)
 {
     // Free all the memory
     loader_platform_thread_lock_mutex(&globalLock);
@@ -1510,69 +1510,69 @@
     freePools();
     freeLayouts();
     loader_platform_thread_unlock_mutex(&globalLock);
-    XGL_RESULT result = nextTable.DestroyDevice(device);
+    VK_RESULT result = nextTable.DestroyDevice(device);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglGetExtensionSupport(XGL_PHYSICAL_GPU gpu, const char* pExtName)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkGetExtensionSupport(VK_PHYSICAL_GPU gpu, const char* pExtName)
 {
-    XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) gpu;
-    XGL_RESULT result;
+    VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
+    VK_RESULT result;
     /* This entrypoint is NOT going to init its own dispatch table since loader calls here early */
     if (!strcmp(pExtName, "DrawState") || !strcmp(pExtName, "drawStateDumpDotFile") ||
         !strcmp(pExtName, "drawStateDumpCommandBufferDotFile") || !strcmp(pExtName, "drawStateDumpPngFile"))
     {
-        result = XGL_SUCCESS;
+        result = VK_SUCCESS;
     } else if (nextTable.GetExtensionSupport != NULL)
     {
-        result = nextTable.GetExtensionSupport((XGL_PHYSICAL_GPU)gpuw->nextObject, pExtName);
+        result = nextTable.GetExtensionSupport((VK_PHYSICAL_GPU)gpuw->nextObject, pExtName);
     } else
     {
-        result = XGL_ERROR_INVALID_EXTENSION;
+        result = VK_ERROR_INVALID_EXTENSION;
     }
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglEnumerateLayers(XGL_PHYSICAL_GPU gpu, size_t maxLayerCount, size_t maxStringSize, size_t* pOutLayerCount, char* const* pOutLayers, void* pReserved)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkEnumerateLayers(VK_PHYSICAL_GPU gpu, size_t maxLayerCount, size_t maxStringSize, size_t* pOutLayerCount, char* const* pOutLayers, void* pReserved)
 {
     if (gpu != NULL)
     {
-        XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) gpu;
+        VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
         pCurObj = gpuw;
         loader_platform_thread_once(&g_initOnce, initDrawState);
-        XGL_RESULT result = nextTable.EnumerateLayers((XGL_PHYSICAL_GPU)gpuw->nextObject, maxLayerCount, maxStringSize, pOutLayerCount, pOutLayers, pReserved);
+        VK_RESULT result = nextTable.EnumerateLayers((VK_PHYSICAL_GPU)gpuw->nextObject, maxLayerCount, maxStringSize, pOutLayerCount, pOutLayers, pReserved);
         return result;
     } else
     {
         if (pOutLayerCount == NULL || pOutLayers == NULL || pOutLayers[0] == NULL)
-            return XGL_ERROR_INVALID_POINTER;
+            return VK_ERROR_INVALID_POINTER;
         // This layer compatible with all GPUs
         *pOutLayerCount = 1;
         strncpy((char *) pOutLayers[0], "DrawState", maxStringSize);
-        return XGL_SUCCESS;
+        return VK_SUCCESS;
     }
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglQueueSubmit(XGL_QUEUE queue, uint32_t cmdBufferCount, const XGL_CMD_BUFFER* pCmdBuffers, XGL_FENCE fence)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkQueueSubmit(VK_QUEUE queue, uint32_t cmdBufferCount, const VK_CMD_BUFFER* pCmdBuffers, VK_FENCE fence)
 {
     for (uint32_t i=0; i < cmdBufferCount; i++) {
         // Validate that cmd buffers have been updated
     }
-    XGL_RESULT result = nextTable.QueueSubmit(queue, cmdBufferCount, pCmdBuffers, fence);
+    VK_RESULT result = nextTable.QueueSubmit(queue, cmdBufferCount, pCmdBuffers, fence);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDestroyObject(XGL_OBJECT object)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkDestroyObject(VK_OBJECT object)
 {
     // TODO : When wrapped objects (such as dynamic state) are destroyed, need to clean up memory
-    XGL_RESULT result = nextTable.DestroyObject(object);
+    VK_RESULT result = nextTable.DestroyObject(object);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateBufferView(XGL_DEVICE device, const XGL_BUFFER_VIEW_CREATE_INFO* pCreateInfo, XGL_BUFFER_VIEW* pView)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateBufferView(VK_DEVICE device, const VK_BUFFER_VIEW_CREATE_INFO* pCreateInfo, VK_BUFFER_VIEW* pView)
 {
-    XGL_RESULT result = nextTable.CreateBufferView(device, pCreateInfo, pView);
-    if (XGL_SUCCESS == result) {
+    VK_RESULT result = nextTable.CreateBufferView(device, pCreateInfo, pView);
+    if (VK_SUCCESS == result) {
         loader_platform_thread_lock_mutex(&globalLock);
         BUFFER_NODE* pNewNode = new BUFFER_NODE;
         pNewNode->buffer = *pView;
@@ -1583,10 +1583,10 @@
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateImageView(XGL_DEVICE device, const XGL_IMAGE_VIEW_CREATE_INFO* pCreateInfo, XGL_IMAGE_VIEW* pView)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateImageView(VK_DEVICE device, const VK_IMAGE_VIEW_CREATE_INFO* pCreateInfo, VK_IMAGE_VIEW* pView)
 {
-    XGL_RESULT result = nextTable.CreateImageView(device, pCreateInfo, pView);
-    if (XGL_SUCCESS == result) {
+    VK_RESULT result = nextTable.CreateImageView(device, pCreateInfo, pView);
+    if (VK_SUCCESS == result) {
         loader_platform_thread_lock_mutex(&globalLock);
         IMAGE_NODE *pNewNode = new IMAGE_NODE;
         pNewNode->image = *pView;
@@ -1597,51 +1597,51 @@
     return result;
 }
 
-static void track_pipeline(const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo, XGL_PIPELINE* pPipeline)
+static void track_pipeline(const VK_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo, VK_PIPELINE* pPipeline)
 {
+    // Create LL HEAD for this Pipeline
+    loader_platform_thread_lock_mutex(&globalLock);
     PIPELINE_NODE* pPipeNode = new PIPELINE_NODE;
     memset((void*)pPipeNode, 0, sizeof(PIPELINE_NODE));
     pPipeNode->pipeline = *pPipeline;
     initPipeline(pPipeNode, pCreateInfo);
+    loader_platform_thread_unlock_mutex(&globalLock);
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateGraphicsPipeline(XGL_DEVICE device, const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo, XGL_PIPELINE* pPipeline)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateGraphicsPipeline(VK_DEVICE device, const VK_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo, VK_PIPELINE* pPipeline)
 {
-    XGL_RESULT result = nextTable.CreateGraphicsPipeline(device, pCreateInfo, pPipeline);
+    VK_RESULT result = nextTable.CreateGraphicsPipeline(device, pCreateInfo, pPipeline);
     // Create LL HEAD for this Pipeline
     char str[1024];
     sprintf(str, "Created Gfx Pipeline %p", (void*)*pPipeline);
-    layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, (XGL_BASE_OBJECT)pPipeline, 0, DRAWSTATE_NONE, "DS", str);
-    loader_platform_thread_lock_mutex(&globalLock);
+    layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, *pPipeline, 0, DRAWSTATE_NONE, "DS", str);
 
     track_pipeline(pCreateInfo, pPipeline);
 
-    loader_platform_thread_unlock_mutex(&globalLock);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateGraphicsPipelineDerivative(
-       XGL_DEVICE device,
-       const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo,
-       XGL_PIPELINE basePipeline,
-       XGL_PIPELINE* pPipeline)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateGraphicsPipelineDerivative(
+        VK_DEVICE device,
+        const VK_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo,
+        VK_PIPELINE basePipeline,
+        VK_PIPELINE* pPipeline)
 {
-    XGL_RESULT result = nextTable.CreateGraphicsPipelineDerivative(device, pCreateInfo, basePipeline, pPipeline);
+    VK_RESULT result = nextTable.CreateGraphicsPipelineDerivative(device, pCreateInfo, basePipeline, pPipeline);
     // Create LL HEAD for this Pipeline
     char str[1024];
     sprintf(str, "Created Gfx Pipeline %p (derived from pipeline %p)", (void*)*pPipeline, basePipeline);
-    layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, (XGL_BASE_OBJECT)pPipeline, 0, DRAWSTATE_NONE, "DS", str);
-    loader_platform_thread_lock_mutex(&globalLock);
+    layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, *pPipeline, 0, DRAWSTATE_NONE, "DS", str);
 
     track_pipeline(pCreateInfo, pPipeline);
 
     loader_platform_thread_unlock_mutex(&globalLock);
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateSampler(XGL_DEVICE device, const XGL_SAMPLER_CREATE_INFO* pCreateInfo, XGL_SAMPLER* pSampler)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateSampler(VK_DEVICE device, const VK_SAMPLER_CREATE_INFO* pCreateInfo, VK_SAMPLER* pSampler)
 {
-    XGL_RESULT result = nextTable.CreateSampler(device, pCreateInfo, pSampler);
-    if (XGL_SUCCESS == result) {
+    VK_RESULT result = nextTable.CreateSampler(device, pCreateInfo, pSampler);
+    if (VK_SUCCESS == result) {
         loader_platform_thread_lock_mutex(&globalLock);
         SAMPLER_NODE* pNewNode = new SAMPLER_NODE;
         pNewNode->sampler = *pSampler;
@@ -1652,31 +1652,31 @@
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateDescriptorSetLayout(XGL_DEVICE device, const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pCreateInfo, XGL_DESCRIPTOR_SET_LAYOUT* pSetLayout)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDescriptorSetLayout(VK_DEVICE device, const VK_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pCreateInfo, VK_DESCRIPTOR_SET_LAYOUT* pSetLayout)
 {
-    XGL_RESULT result = nextTable.CreateDescriptorSetLayout(device, pCreateInfo, pSetLayout);
-    if (XGL_SUCCESS == result) {
+    VK_RESULT result = nextTable.CreateDescriptorSetLayout(device, pCreateInfo, pSetLayout);
+    if (VK_SUCCESS == result) {
         LAYOUT_NODE* pNewNode = new LAYOUT_NODE;
         if (NULL == pNewNode) {
             char str[1024];
-            sprintf(str, "Out of memory while attempting to allocate LAYOUT_NODE in xglCreateDescriptorSetLayout()");
-            layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, *pSetLayout, 0, DRAWSTATE_OUT_OF_MEMORY, "DS", str);
+            sprintf(str, "Out of memory while attempting to allocate LAYOUT_NODE in vkCreateDescriptorSetLayout()");
+            layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, *pSetLayout, 0, DRAWSTATE_OUT_OF_MEMORY, "DS", str);
         }
         memset(pNewNode, 0, sizeof(LAYOUT_NODE));
-        memcpy((void*)&pNewNode->createInfo, pCreateInfo, sizeof(XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO));
-        pNewNode->createInfo.pBinding = new XGL_DESCRIPTOR_SET_LAYOUT_BINDING[pCreateInfo->count];
-        memcpy((void*)pNewNode->createInfo.pBinding, pCreateInfo->pBinding, sizeof(XGL_DESCRIPTOR_SET_LAYOUT_BINDING)*pCreateInfo->count);
+        memcpy((void*)&pNewNode->createInfo, pCreateInfo, sizeof(VK_DESCRIPTOR_SET_LAYOUT_CREATE_INFO));
+        pNewNode->createInfo.pBinding = new VK_DESCRIPTOR_SET_LAYOUT_BINDING[pCreateInfo->count];
+        memcpy((void*)pNewNode->createInfo.pBinding, pCreateInfo->pBinding, sizeof(VK_DESCRIPTOR_SET_LAYOUT_BINDING)*pCreateInfo->count);
         uint32_t totalCount = 0;
         for (uint32_t i=0; i<pCreateInfo->count; i++) {
             totalCount += pCreateInfo->pBinding[i].count;
             if (pCreateInfo->pBinding[i].pImmutableSamplers) {
                 void** ppImmutableSamplers = (void**)&pNewNode->createInfo.pBinding[i].pImmutableSamplers;
-                *ppImmutableSamplers = malloc(sizeof(XGL_SAMPLER)*pCreateInfo->pBinding[i].count);
-                memcpy(*ppImmutableSamplers, pCreateInfo->pBinding[i].pImmutableSamplers, pCreateInfo->pBinding[i].count*sizeof(XGL_SAMPLER));
+                *ppImmutableSamplers = malloc(sizeof(VK_SAMPLER)*pCreateInfo->pBinding[i].count);
+                memcpy(*ppImmutableSamplers, pCreateInfo->pBinding[i].pImmutableSamplers, pCreateInfo->pBinding[i].count*sizeof(VK_SAMPLER));
             }
         }
         if (totalCount > 0) {
-            pNewNode->pTypes = new XGL_DESCRIPTOR_TYPE[totalCount];
+            pNewNode->pTypes = new VK_DESCRIPTOR_TYPE[totalCount];
             uint32_t offset = 0;
             uint32_t j = 0;
             for (uint32_t i=0; i<pCreateInfo->count; i++) {
@@ -1698,25 +1698,25 @@
     return result;
 }
 
-XGL_RESULT XGLAPI xglCreateDescriptorSetLayoutChain(XGL_DEVICE device, uint32_t setLayoutArrayCount, const XGL_DESCRIPTOR_SET_LAYOUT* pSetLayoutArray, XGL_DESCRIPTOR_SET_LAYOUT_CHAIN* pLayoutChain)
+VK_RESULT VKAPI vkCreateDescriptorSetLayoutChain(VK_DEVICE device, uint32_t setLayoutArrayCount, const VK_DESCRIPTOR_SET_LAYOUT* pSetLayoutArray, VK_DESCRIPTOR_SET_LAYOUT_CHAIN* pLayoutChain)
 {
-    XGL_RESULT result = nextTable.CreateDescriptorSetLayoutChain(device, setLayoutArrayCount, pSetLayoutArray, pLayoutChain);
-    if (XGL_SUCCESS == result) {
+    VK_RESULT result = nextTable.CreateDescriptorSetLayoutChain(device, setLayoutArrayCount, pSetLayoutArray, pLayoutChain);
+    if (VK_SUCCESS == result) {
         // TODO : Need to capture the layout chains
     }
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglBeginDescriptorPoolUpdate(XGL_DEVICE device, XGL_DESCRIPTOR_UPDATE_MODE updateMode)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkBeginDescriptorPoolUpdate(VK_DEVICE device, VK_DESCRIPTOR_UPDATE_MODE updateMode)
 {
-    XGL_RESULT result = nextTable.BeginDescriptorPoolUpdate(device, updateMode);
-    if (XGL_SUCCESS == result) {
+    VK_RESULT result = nextTable.BeginDescriptorPoolUpdate(device, updateMode);
+    if (VK_SUCCESS == result) {
         loader_platform_thread_lock_mutex(&globalLock);
         POOL_NODE* pPoolNode = poolMap.begin()->second;
         if (!pPoolNode) {
             char str[1024];
             sprintf(str, "Unable to find pool node");
-            layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_INTERNAL_ERROR, "DS", str);
+            layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_INTERNAL_ERROR, "DS", str);
         }
         else {
             pPoolNode->updateActive = 1;
@@ -1726,22 +1726,22 @@
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglEndDescriptorPoolUpdate(XGL_DEVICE device, XGL_CMD_BUFFER cmd)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkEndDescriptorPoolUpdate(VK_DEVICE device, VK_CMD_BUFFER cmd)
 {
-    XGL_RESULT result = nextTable.EndDescriptorPoolUpdate(device, cmd);
-    if (XGL_SUCCESS == result) {
+    VK_RESULT result = nextTable.EndDescriptorPoolUpdate(device, cmd);
+    if (VK_SUCCESS == result) {
         loader_platform_thread_lock_mutex(&globalLock);
         POOL_NODE* pPoolNode = poolMap.begin()->second;
         if (!pPoolNode) {
             char str[1024];
             sprintf(str, "Unable to find pool node");
-            layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_INTERNAL_ERROR, "DS", str);
+            layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_INTERNAL_ERROR, "DS", str);
         }
         else {
             if (!pPoolNode->updateActive) {
                 char str[1024];
-                sprintf(str, "You must call xglBeginDescriptorPoolUpdate() before this call to xglEndDescriptorPoolUpdate()!");
-                layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_DS_END_WITHOUT_BEGIN, "DS", str);
+                sprintf(str, "You must call vkBeginDescriptorPoolUpdate() before this call to vkEndDescriptorPoolUpdate()!");
+                layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_DS_END_WITHOUT_BEGIN, "DS", str);
             }
             else {
                 pPoolNode->updateActive = 0;
@@ -1753,28 +1753,28 @@
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateDescriptorPool(XGL_DEVICE device, XGL_DESCRIPTOR_POOL_USAGE poolUsage, uint32_t maxSets, const XGL_DESCRIPTOR_POOL_CREATE_INFO* pCreateInfo, XGL_DESCRIPTOR_POOL* pDescriptorPool)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDescriptorPool(VK_DEVICE device, VK_DESCRIPTOR_POOL_USAGE poolUsage, uint32_t maxSets, const VK_DESCRIPTOR_POOL_CREATE_INFO* pCreateInfo, VK_DESCRIPTOR_POOL* pDescriptorPool)
 {
-    XGL_RESULT result = nextTable.CreateDescriptorPool(device, poolUsage, maxSets, pCreateInfo, pDescriptorPool);
-    if (XGL_SUCCESS == result) {
+    VK_RESULT result = nextTable.CreateDescriptorPool(device, poolUsage, maxSets, pCreateInfo, pDescriptorPool);
+    if (VK_SUCCESS == result) {
         // Insert this pool into Global Pool LL at head
         char str[1024];
         sprintf(str, "Created Descriptor Pool %p", (void*)*pDescriptorPool);
-        layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, (XGL_BASE_OBJECT)pDescriptorPool, 0, DRAWSTATE_NONE, "DS", str);
+        layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, (VK_BASE_OBJECT)pDescriptorPool, 0, DRAWSTATE_NONE, "DS", str);
         loader_platform_thread_lock_mutex(&globalLock);
         POOL_NODE* pNewNode = new POOL_NODE;
         if (NULL == pNewNode) {
             char str[1024];
-            sprintf(str, "Out of memory while attempting to allocate POOL_NODE in xglCreateDescriptorPool()");
-            layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, (XGL_BASE_OBJECT)*pDescriptorPool, 0, DRAWSTATE_OUT_OF_MEMORY, "DS", str);
+            sprintf(str, "Out of memory while attempting to allocate POOL_NODE in vkCreateDescriptorPool()");
+            layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, (VK_BASE_OBJECT)*pDescriptorPool, 0, DRAWSTATE_OUT_OF_MEMORY, "DS", str);
         }
         else {
             memset(pNewNode, 0, sizeof(POOL_NODE));
-            XGL_DESCRIPTOR_POOL_CREATE_INFO* pCI = (XGL_DESCRIPTOR_POOL_CREATE_INFO*)&pNewNode->createInfo;
-            memcpy((void*)pCI, pCreateInfo, sizeof(XGL_DESCRIPTOR_POOL_CREATE_INFO));
+            VK_DESCRIPTOR_POOL_CREATE_INFO* pCI = (VK_DESCRIPTOR_POOL_CREATE_INFO*)&pNewNode->createInfo;
+            memcpy((void*)pCI, pCreateInfo, sizeof(VK_DESCRIPTOR_POOL_CREATE_INFO));
             if (pNewNode->createInfo.count) {
-                size_t typeCountSize = pNewNode->createInfo.count * sizeof(XGL_DESCRIPTOR_TYPE_COUNT);
-                pNewNode->createInfo.pTypeCount = new XGL_DESCRIPTOR_TYPE_COUNT[typeCountSize];
+                size_t typeCountSize = pNewNode->createInfo.count * sizeof(VK_DESCRIPTOR_TYPE_COUNT);
+                pNewNode->createInfo.pTypeCount = new VK_DESCRIPTOR_TYPE_COUNT[typeCountSize];
                 memcpy((void*)pNewNode->createInfo.pTypeCount, pCreateInfo->pTypeCount, typeCountSize);
             }
             pNewNode->poolUsage  = poolUsage;
@@ -1791,36 +1791,36 @@
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglResetDescriptorPool(XGL_DESCRIPTOR_POOL descriptorPool)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkResetDescriptorPool(VK_DESCRIPTOR_POOL descriptorPool)
 {
-    XGL_RESULT result = nextTable.ResetDescriptorPool(descriptorPool);
-    if (XGL_SUCCESS == result) {
+    VK_RESULT result = nextTable.ResetDescriptorPool(descriptorPool);
+    if (VK_SUCCESS == result) {
         clearDescriptorPool(descriptorPool);
     }
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglAllocDescriptorSets(XGL_DESCRIPTOR_POOL descriptorPool, XGL_DESCRIPTOR_SET_USAGE setUsage, uint32_t count, const XGL_DESCRIPTOR_SET_LAYOUT* pSetLayouts, XGL_DESCRIPTOR_SET* pDescriptorSets, uint32_t* pCount)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkAllocDescriptorSets(VK_DESCRIPTOR_POOL descriptorPool, VK_DESCRIPTOR_SET_USAGE setUsage, uint32_t count, const VK_DESCRIPTOR_SET_LAYOUT* pSetLayouts, VK_DESCRIPTOR_SET* pDescriptorSets, uint32_t* pCount)
 {
-    XGL_RESULT result = nextTable.AllocDescriptorSets(descriptorPool, setUsage, count, pSetLayouts, pDescriptorSets, pCount);
-    if ((XGL_SUCCESS == result) || (*pCount > 0)) {
+    VK_RESULT result = nextTable.AllocDescriptorSets(descriptorPool, setUsage, count, pSetLayouts, pDescriptorSets, pCount);
+    if ((VK_SUCCESS == result) || (*pCount > 0)) {
         POOL_NODE *pPoolNode = getPoolNode(descriptorPool);
         if (!pPoolNode) {
             char str[1024];
-            sprintf(str, "Unable to find pool node for pool %p specified in xglAllocDescriptorSets() call", (void*)descriptorPool);
-            layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, descriptorPool, 0, DRAWSTATE_INVALID_POOL, "DS", str);
+            sprintf(str, "Unable to find pool node for pool %p specified in vkAllocDescriptorSets() call", (void*)descriptorPool);
+            layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, descriptorPool, 0, DRAWSTATE_INVALID_POOL, "DS", str);
         }
         else {
             for (uint32_t i = 0; i < *pCount; i++) {
                 char str[1024];
                 sprintf(str, "Created Descriptor Set %p", (void*)pDescriptorSets[i]);
-                layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, pDescriptorSets[i], 0, DRAWSTATE_NONE, "DS", str);
+                layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, pDescriptorSets[i], 0, DRAWSTATE_NONE, "DS", str);
                 // Create new set node and add to head of pool nodes
                 SET_NODE* pNewNode = new SET_NODE;
                 if (NULL == pNewNode) {
                     char str[1024];
-                    sprintf(str, "Out of memory while attempting to allocate SET_NODE in xglAllocDescriptorSets()");
-                    layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, pDescriptorSets[i], 0, DRAWSTATE_OUT_OF_MEMORY, "DS", str);
+                    sprintf(str, "Out of memory while attempting to allocate SET_NODE in vkAllocDescriptorSets()");
+                    layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, pDescriptorSets[i], 0, DRAWSTATE_OUT_OF_MEMORY, "DS", str);
                 }
                 else {
                     memset(pNewNode, 0, sizeof(SET_NODE));
@@ -1830,8 +1830,8 @@
                     LAYOUT_NODE* pLayout = getLayoutNode(pSetLayouts[i]);
                     if (NULL == pLayout) {
                         char str[1024];
-                        sprintf(str, "Unable to find set layout node for layout %p specified in xglAllocDescriptorSets() call", (void*)pSetLayouts[i]);
-                        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, pSetLayouts[i], 0, DRAWSTATE_INVALID_LAYOUT, "DS", str);
+                        sprintf(str, "Unable to find set layout node for layout %p specified in vkAllocDescriptorSets() call", (void*)pSetLayouts[i]);
+                        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, pSetLayouts[i], 0, DRAWSTATE_INVALID_LAYOUT, "DS", str);
                     }
                     pNewNode->pLayout = pLayout;
                     pNewNode->pool = descriptorPool;
@@ -1851,7 +1851,7 @@
     return result;
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglClearDescriptorSets(XGL_DESCRIPTOR_POOL descriptorPool, uint32_t count, const XGL_DESCRIPTOR_SET* pDescriptorSets)
+VK_LAYER_EXPORT void VKAPI vkClearDescriptorSets(VK_DESCRIPTOR_POOL descriptorPool, uint32_t count, const VK_DESCRIPTOR_SET* pDescriptorSets)
 {
     for (uint32_t i = 0; i < count; i++) {
         clearDescriptorSet(pDescriptorSets[i]);
@@ -1859,54 +1859,54 @@
     nextTable.ClearDescriptorSets(descriptorPool, count, pDescriptorSets);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglUpdateDescriptors(XGL_DESCRIPTOR_SET descriptorSet, uint32_t updateCount, const void** ppUpdateArray)
+VK_LAYER_EXPORT void VKAPI vkUpdateDescriptors(VK_DESCRIPTOR_SET descriptorSet, uint32_t updateCount, const void** ppUpdateArray)
 {
     SET_NODE* pSet = getSetNode(descriptorSet);
     if (!dsUpdateActive(descriptorSet)) {
         char str[1024];
-        sprintf(str, "You must call xglBeginDescriptorPoolUpdate() before this call to xglUpdateDescriptors()!");
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, pSet->pool, 0, DRAWSTATE_UPDATE_WITHOUT_BEGIN, "DS", str);
+        sprintf(str, "You must call vkBeginDescriptorPoolUpdate() before this call to vkUpdateDescriptors()!");
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, pSet->pool, 0, DRAWSTATE_UPDATE_WITHOUT_BEGIN, "DS", str);
     }
     else {
-        // pUpdateChain is a Linked-list of XGL_UPDATE_* structures defining the mappings for the descriptors
+        // pUpdateChain is a Linked-list of VK_UPDATE_* structures defining the mappings for the descriptors
         dsUpdate(descriptorSet, updateCount, ppUpdateArray);
     }
 
     nextTable.UpdateDescriptors(descriptorSet, updateCount, ppUpdateArray);
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateDynamicViewportState(XGL_DEVICE device, const XGL_DYNAMIC_VP_STATE_CREATE_INFO* pCreateInfo, XGL_DYNAMIC_VP_STATE_OBJECT* pState)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDynamicViewportState(VK_DEVICE device, const VK_DYNAMIC_VP_STATE_CREATE_INFO* pCreateInfo, VK_DYNAMIC_VP_STATE_OBJECT* pState)
 {
-    XGL_RESULT result = nextTable.CreateDynamicViewportState(device, pCreateInfo, pState);
-    insertDynamicState(*pState, (GENERIC_HEADER*)pCreateInfo, XGL_STATE_BIND_VIEWPORT);
+    VK_RESULT result = nextTable.CreateDynamicViewportState(device, pCreateInfo, pState);
+    insertDynamicState(*pState, (GENERIC_HEADER*)pCreateInfo, VK_STATE_BIND_VIEWPORT);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateDynamicRasterState(XGL_DEVICE device, const XGL_DYNAMIC_RS_STATE_CREATE_INFO* pCreateInfo, XGL_DYNAMIC_RS_STATE_OBJECT* pState)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDynamicRasterState(VK_DEVICE device, const VK_DYNAMIC_RS_STATE_CREATE_INFO* pCreateInfo, VK_DYNAMIC_RS_STATE_OBJECT* pState)
 {
-    XGL_RESULT result = nextTable.CreateDynamicRasterState(device, pCreateInfo, pState);
-    insertDynamicState(*pState, (GENERIC_HEADER*)pCreateInfo, XGL_STATE_BIND_RASTER);
+    VK_RESULT result = nextTable.CreateDynamicRasterState(device, pCreateInfo, pState);
+    insertDynamicState(*pState, (GENERIC_HEADER*)pCreateInfo, VK_STATE_BIND_RASTER);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateDynamicColorBlendState(XGL_DEVICE device, const XGL_DYNAMIC_CB_STATE_CREATE_INFO* pCreateInfo, XGL_DYNAMIC_CB_STATE_OBJECT* pState)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDynamicColorBlendState(VK_DEVICE device, const VK_DYNAMIC_CB_STATE_CREATE_INFO* pCreateInfo, VK_DYNAMIC_CB_STATE_OBJECT* pState)
 {
-    XGL_RESULT result = nextTable.CreateDynamicColorBlendState(device, pCreateInfo, pState);
-    insertDynamicState(*pState, (GENERIC_HEADER*)pCreateInfo, XGL_STATE_BIND_COLOR_BLEND);
+    VK_RESULT result = nextTable.CreateDynamicColorBlendState(device, pCreateInfo, pState);
+    insertDynamicState(*pState, (GENERIC_HEADER*)pCreateInfo, VK_STATE_BIND_COLOR_BLEND);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateDynamicDepthStencilState(XGL_DEVICE device, const XGL_DYNAMIC_DS_STATE_CREATE_INFO* pCreateInfo, XGL_DYNAMIC_DS_STATE_OBJECT* pState)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDynamicDepthStencilState(VK_DEVICE device, const VK_DYNAMIC_DS_STATE_CREATE_INFO* pCreateInfo, VK_DYNAMIC_DS_STATE_OBJECT* pState)
 {
-    XGL_RESULT result = nextTable.CreateDynamicDepthStencilState(device, pCreateInfo, pState);
-    insertDynamicState(*pState, (GENERIC_HEADER*)pCreateInfo, XGL_STATE_BIND_DEPTH_STENCIL);
+    VK_RESULT result = nextTable.CreateDynamicDepthStencilState(device, pCreateInfo, pState);
+    insertDynamicState(*pState, (GENERIC_HEADER*)pCreateInfo, VK_STATE_BIND_DEPTH_STENCIL);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateCommandBuffer(XGL_DEVICE device, const XGL_CMD_BUFFER_CREATE_INFO* pCreateInfo, XGL_CMD_BUFFER* pCmdBuffer)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateCommandBuffer(VK_DEVICE device, const VK_CMD_BUFFER_CREATE_INFO* pCreateInfo, VK_CMD_BUFFER* pCmdBuffer)
 {
-    XGL_RESULT result = nextTable.CreateCommandBuffer(device, pCreateInfo, pCmdBuffer);
-    if (XGL_SUCCESS == result) {
+    VK_RESULT result = nextTable.CreateCommandBuffer(device, pCreateInfo, pCmdBuffer);
+    if (VK_SUCCESS == result) {
         loader_platform_thread_lock_mutex(&globalLock);
         GLOBAL_CB_NODE* pCB = new GLOBAL_CB_NODE;
         memset(pCB, 0, sizeof(GLOBAL_CB_NODE));
@@ -1921,36 +1921,36 @@
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglBeginCommandBuffer(XGL_CMD_BUFFER cmdBuffer, const XGL_CMD_BUFFER_BEGIN_INFO* pBeginInfo)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkBeginCommandBuffer(VK_CMD_BUFFER cmdBuffer, const VK_CMD_BUFFER_BEGIN_INFO* pBeginInfo)
 {
-    XGL_RESULT result = nextTable.BeginCommandBuffer(cmdBuffer, pBeginInfo);
-    if (XGL_SUCCESS == result) {
+    VK_RESULT result = nextTable.BeginCommandBuffer(cmdBuffer, pBeginInfo);
+    if (VK_SUCCESS == result) {
         GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
         if (pCB) {
             if (CB_NEW != pCB->state)
                 resetCB(cmdBuffer);
             pCB->state = CB_UPDATE_ACTIVE;
             if (pBeginInfo->pNext) {
-                XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO* pCbGfxBI = (XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO*)pBeginInfo->pNext;
-                if (XGL_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO == pCbGfxBI->sType) {
+                VK_CMD_BUFFER_GRAPHICS_BEGIN_INFO* pCbGfxBI = (VK_CMD_BUFFER_GRAPHICS_BEGIN_INFO*)pBeginInfo->pNext;
+                if (VK_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO == pCbGfxBI->sType) {
                     pCB->activeRenderPass = pCbGfxBI->renderPassContinue.renderPass;
                 }
             }
         }
         else {
             char str[1024];
-            sprintf(str, "In xglBeginCommandBuffer() and unable to find CmdBuffer Node for CB %p!", (void*)cmdBuffer);
-            layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
+            sprintf(str, "In vkBeginCommandBuffer() and unable to find CmdBuffer Node for CB %p!", (void*)cmdBuffer);
+            layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
         }
         updateCBTracking(cmdBuffer);
     }
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglEndCommandBuffer(XGL_CMD_BUFFER cmdBuffer)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkEndCommandBuffer(VK_CMD_BUFFER cmdBuffer)
 {
-    XGL_RESULT result = nextTable.EndCommandBuffer(cmdBuffer);
-    if (XGL_SUCCESS == result) {
+    VK_RESULT result = nextTable.EndCommandBuffer(cmdBuffer);
+    if (VK_SUCCESS == result) {
         GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
         if (pCB) {
             pCB->state = CB_UPDATE_COMPLETE;
@@ -1958,8 +1958,8 @@
         }
         else {
             char str[1024];
-            sprintf(str, "In xglEndCommandBuffer() and unable to find CmdBuffer Node for CB %p!", (void*)cmdBuffer);
-            layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
+            sprintf(str, "In vkEndCommandBuffer() and unable to find CmdBuffer Node for CB %p!", (void*)cmdBuffer);
+            layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
         }
         updateCBTracking(cmdBuffer);
         //cbDumpDotFile("cb_dump.dot");
@@ -1967,17 +1967,17 @@
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglResetCommandBuffer(XGL_CMD_BUFFER cmdBuffer)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkResetCommandBuffer(VK_CMD_BUFFER cmdBuffer)
 {
-    XGL_RESULT result = nextTable.ResetCommandBuffer(cmdBuffer);
-    if (XGL_SUCCESS == result) {
+    VK_RESULT result = nextTable.ResetCommandBuffer(cmdBuffer);
+    if (VK_SUCCESS == result) {
         resetCB(cmdBuffer);
         updateCBTracking(cmdBuffer);
     }
     return result;
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdBindPipeline(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, XGL_PIPELINE pipeline)
+VK_LAYER_EXPORT void VKAPI vkCmdBindPipeline(VK_CMD_BUFFER cmdBuffer, VK_PIPELINE_BIND_POINT pipelineBindPoint, VK_PIPELINE pipeline)
 {
     GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
     if (pCB) {
@@ -1994,24 +1994,24 @@
         else {
             char str[1024];
             sprintf(str, "Attempt to bind Pipeline %p that doesn't exist!", (void*)pipeline);
-            layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, pipeline, 0, DRAWSTATE_INVALID_PIPELINE, "DS", str);
+            layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, pipeline, 0, DRAWSTATE_INVALID_PIPELINE, "DS", str);
         }
     }
     else {
         char str[1024];
         sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
     }
     nextTable.CmdBindPipeline(cmdBuffer, pipelineBindPoint, pipeline);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdBindDynamicStateObject(XGL_CMD_BUFFER cmdBuffer, XGL_STATE_BIND_POINT stateBindPoint, XGL_DYNAMIC_STATE_OBJECT state)
+VK_LAYER_EXPORT void VKAPI vkCmdBindDynamicStateObject(VK_CMD_BUFFER cmdBuffer, VK_STATE_BIND_POINT stateBindPoint, VK_DYNAMIC_STATE_OBJECT state)
 {
     setLastBoundDynamicState(cmdBuffer, state, stateBindPoint);
     nextTable.CmdBindDynamicStateObject(cmdBuffer, stateBindPoint, state);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdBindDescriptorSets(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, XGL_DESCRIPTOR_SET_LAYOUT_CHAIN layoutChain, uint32_t layoutChainSlot, uint32_t count, const XGL_DESCRIPTOR_SET* pDescriptorSets, const uint32_t* pUserData)
+VK_LAYER_EXPORT void VKAPI vkCmdBindDescriptorSets(VK_CMD_BUFFER cmdBuffer, VK_PIPELINE_BIND_POINT pipelineBindPoint, VK_DESCRIPTOR_SET_LAYOUT_CHAIN layoutChain, uint32_t layoutChainSlot, uint32_t count, const VK_DESCRIPTOR_SET* pDescriptorSets, const uint32_t* pUserData)
 {
     GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
     if (pCB) {
@@ -2023,8 +2023,8 @@
                     // TODO : This check here needs to be made at QueueSubmit time
     /*
                     char str[1024];
-                    sprintf(str, "You must call xglEndDescriptorPoolUpdate(%p) before this call to xglCmdBindDescriptorSet()!", (void*)descriptorSet);
-                    layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, descriptorSet, 0, DRAWSTATE_BINDING_DS_NO_END_UPDATE, "DS", str);
+                    sprintf(str, "You must call vkEndDescriptorPoolUpdate(%p) before this call to vkCmdBindDescriptorSet()!", (void*)descriptorSet);
+                    layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, descriptorSet, 0, DRAWSTATE_BINDING_DS_NO_END_UPDATE, "DS", str);
     */
                 }
                 loader_platform_thread_lock_mutex(&globalLock);
@@ -2032,26 +2032,26 @@
                 g_lastBoundDescriptorSet = pDescriptorSets[i];
                 loader_platform_thread_unlock_mutex(&globalLock);
                 char str[1024];
-                sprintf(str, "DS %p bound on pipeline %s", (void*)pDescriptorSets[i], string_XGL_PIPELINE_BIND_POINT(pipelineBindPoint));
-                layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, pDescriptorSets[i], 0, DRAWSTATE_NONE, "DS", str);
+                sprintf(str, "DS %p bound on pipeline %s", (void*)pDescriptorSets[i], string_VK_PIPELINE_BIND_POINT(pipelineBindPoint));
+                layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, pDescriptorSets[i], 0, DRAWSTATE_NONE, "DS", str);
                 synchAndPrintDSConfig(cmdBuffer);
             }
             else {
                 char str[1024];
                 sprintf(str, "Attempt to bind DS %p that doesn't exist!", (void*)pDescriptorSets[i]);
-                layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, pDescriptorSets[i], 0, DRAWSTATE_INVALID_SET, "DS", str);
+                layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, pDescriptorSets[i], 0, DRAWSTATE_INVALID_SET, "DS", str);
             }
         }
     }
     else {
         char str[1024];
         sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
     }
     nextTable.CmdBindDescriptorSets(cmdBuffer, pipelineBindPoint, layoutChain, layoutChainSlot, count, pDescriptorSets, pUserData);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdBindIndexBuffer(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER buffer, XGL_GPU_SIZE offset, XGL_INDEX_TYPE indexType)
+VK_LAYER_EXPORT void VKAPI vkCmdBindIndexBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFFER buffer, VK_GPU_SIZE offset, VK_INDEX_TYPE indexType)
 {
     GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
     if (pCB) {
@@ -2062,12 +2062,12 @@
     else {
         char str[1024];
         sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
     }
     nextTable.CmdBindIndexBuffer(cmdBuffer, buffer, offset, indexType);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdBindVertexBuffer(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER buffer, XGL_GPU_SIZE offset, uint32_t binding)
+VK_LAYER_EXPORT void VKAPI vkCmdBindVertexBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFFER buffer, VK_GPU_SIZE offset, uint32_t binding)
 {
     GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
     if (pCB) {
@@ -2079,12 +2079,12 @@
     else {
         char str[1024];
         sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
     }
     nextTable.CmdBindVertexBuffer(cmdBuffer, buffer, offset, binding);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdDraw(XGL_CMD_BUFFER cmdBuffer, uint32_t firstVertex, uint32_t vertexCount, uint32_t firstInstance, uint32_t instanceCount)
+VK_LAYER_EXPORT void VKAPI vkCmdDraw(VK_CMD_BUFFER cmdBuffer, uint32_t firstVertex, uint32_t vertexCount, uint32_t firstInstance, uint32_t instanceCount)
 {
     GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
     if (pCB) {
@@ -2092,19 +2092,19 @@
         addCmd(pCB, CMD_DRAW);
         pCB->drawCount[DRAW]++;
         char str[1024];
-        sprintf(str, "xglCmdDraw() call #%lu, reporting DS state:", g_drawCount[DRAW]++);
-        layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_NONE, "DS", str);
+        sprintf(str, "vkCmdDraw() call #%lu, reporting DS state:", g_drawCount[DRAW]++);
+        layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_NONE, "DS", str);
         synchAndPrintDSConfig(cmdBuffer);
     }
     else {
         char str[1024];
         sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
     }
     nextTable.CmdDraw(cmdBuffer, firstVertex, vertexCount, firstInstance, instanceCount);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdDrawIndexed(XGL_CMD_BUFFER cmdBuffer, uint32_t firstIndex, uint32_t indexCount, int32_t vertexOffset, uint32_t firstInstance, uint32_t instanceCount)
+VK_LAYER_EXPORT void VKAPI vkCmdDrawIndexed(VK_CMD_BUFFER cmdBuffer, uint32_t firstIndex, uint32_t indexCount, int32_t vertexOffset, uint32_t firstInstance, uint32_t instanceCount)
 {
     GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
     if (pCB) {
@@ -2112,19 +2112,19 @@
         addCmd(pCB, CMD_DRAWINDEXED);
         pCB->drawCount[DRAW_INDEXED]++;
         char str[1024];
-        sprintf(str, "xglCmdDrawIndexed() call #%lu, reporting DS state:", g_drawCount[DRAW_INDEXED]++);
-        layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_NONE, "DS", str);
+        sprintf(str, "vkCmdDrawIndexed() call #%lu, reporting DS state:", g_drawCount[DRAW_INDEXED]++);
+        layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_NONE, "DS", str);
         synchAndPrintDSConfig(cmdBuffer);
     }
     else {
         char str[1024];
         sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
     }
     nextTable.CmdDrawIndexed(cmdBuffer, firstIndex, indexCount, vertexOffset, firstInstance, instanceCount);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdDrawIndirect(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER buffer, XGL_GPU_SIZE offset, uint32_t count, uint32_t stride)
+VK_LAYER_EXPORT void VKAPI vkCmdDrawIndirect(VK_CMD_BUFFER cmdBuffer, VK_BUFFER buffer, VK_GPU_SIZE offset, uint32_t count, uint32_t stride)
 {
     GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
     if (pCB) {
@@ -2132,19 +2132,19 @@
         addCmd(pCB, CMD_DRAWINDIRECT);
         pCB->drawCount[DRAW_INDIRECT]++;
         char str[1024];
-        sprintf(str, "xglCmdDrawIndirect() call #%lu, reporting DS state:", g_drawCount[DRAW_INDIRECT]++);
-        layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_NONE, "DS", str);
+        sprintf(str, "vkCmdDrawIndirect() call #%lu, reporting DS state:", g_drawCount[DRAW_INDIRECT]++);
+        layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_NONE, "DS", str);
         synchAndPrintDSConfig(cmdBuffer);
     }
     else {
         char str[1024];
         sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
     }
     nextTable.CmdDrawIndirect(cmdBuffer, buffer, offset, count, stride);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdDrawIndexedIndirect(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER buffer, XGL_GPU_SIZE offset, uint32_t count, uint32_t stride)
+VK_LAYER_EXPORT void VKAPI vkCmdDrawIndexedIndirect(VK_CMD_BUFFER cmdBuffer, VK_BUFFER buffer, VK_GPU_SIZE offset, uint32_t count, uint32_t stride)
 {
     GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
     if (pCB) {
@@ -2152,19 +2152,19 @@
         addCmd(pCB, CMD_DRAWINDEXEDINDIRECT);
         pCB->drawCount[DRAW_INDEXED_INDIRECT]++;
         char str[1024];
-        sprintf(str, "xglCmdDrawIndexedIndirect() call #%lu, reporting DS state:", g_drawCount[DRAW_INDEXED_INDIRECT]++);
-        layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_NONE, "DS", str);
+        sprintf(str, "vkCmdDrawIndexedIndirect() call #%lu, reporting DS state:", g_drawCount[DRAW_INDEXED_INDIRECT]++);
+        layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_NONE, "DS", str);
         synchAndPrintDSConfig(cmdBuffer);
     }
     else {
         char str[1024];
         sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
     }
     nextTable.CmdDrawIndexedIndirect(cmdBuffer, buffer, offset, count, stride);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdDispatch(XGL_CMD_BUFFER cmdBuffer, uint32_t x, uint32_t y, uint32_t z)
+VK_LAYER_EXPORT void VKAPI vkCmdDispatch(VK_CMD_BUFFER cmdBuffer, uint32_t x, uint32_t y, uint32_t z)
 {
     GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
     if (pCB) {
@@ -2174,12 +2174,12 @@
     else {
         char str[1024];
         sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
     }
     nextTable.CmdDispatch(cmdBuffer, x, y, z);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdDispatchIndirect(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER buffer, XGL_GPU_SIZE offset)
+VK_LAYER_EXPORT void VKAPI vkCmdDispatchIndirect(VK_CMD_BUFFER cmdBuffer, VK_BUFFER buffer, VK_GPU_SIZE offset)
 {
     GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
     if (pCB) {
@@ -2189,12 +2189,12 @@
     else {
         char str[1024];
         sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
     }
     nextTable.CmdDispatchIndirect(cmdBuffer, buffer, offset);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdCopyBuffer(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER srcBuffer, XGL_BUFFER destBuffer, uint32_t regionCount, const XGL_BUFFER_COPY* pRegions)
+VK_LAYER_EXPORT void VKAPI vkCmdCopyBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFFER srcBuffer, VK_BUFFER destBuffer, uint32_t regionCount, const VK_BUFFER_COPY* pRegions)
 {
     GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
     if (pCB) {
@@ -2204,16 +2204,17 @@
     else {
         char str[1024];
         sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
     }
     nextTable.CmdCopyBuffer(cmdBuffer, srcBuffer, destBuffer, regionCount, pRegions);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdCopyImage(
-        XGL_CMD_BUFFER cmdBuffer,
-        XGL_IMAGE srcImage, XGL_IMAGE_LAYOUT srcImageLayout,
-        XGL_IMAGE destImage, XGL_IMAGE_LAYOUT destImageLayout,
-        uint32_t regionCount, const XGL_IMAGE_COPY* pRegions)
+VK_LAYER_EXPORT void VKAPI vkCmdCopyImage(VK_CMD_BUFFER cmdBuffer,
+                                             VK_IMAGE srcImage,
+                                             VK_IMAGE_LAYOUT srcImageLayout,
+                                             VK_IMAGE destImage,
+                                             VK_IMAGE_LAYOUT destImageLayout,
+                                             uint32_t regionCount, const VK_IMAGE_COPY* pRegions)
 {
     GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
     if (pCB) {
@@ -2223,15 +2224,15 @@
     else {
         char str[1024];
         sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
     }
     nextTable.CmdCopyImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdBlitImage(XGL_CMD_BUFFER cmdBuffer,
-                                             XGL_IMAGE srcImage, XGL_IMAGE_LAYOUT srcImageLayout,
-                                             XGL_IMAGE destImage, XGL_IMAGE_LAYOUT destImageLayout,
-                                             uint32_t regionCount, const XGL_IMAGE_BLIT* pRegions)
+VK_LAYER_EXPORT void VKAPI vkCmdBlitImage(VK_CMD_BUFFER cmdBuffer,
+                                             VK_IMAGE srcImage, VK_IMAGE_LAYOUT srcImageLayout,
+                                             VK_IMAGE destImage, VK_IMAGE_LAYOUT destImageLayout,
+                                             uint32_t regionCount, const VK_IMAGE_BLIT* pRegions)
 {
     GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
     if (pCB) {
@@ -2241,16 +2242,15 @@
     else {
         char str[1024];
         sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
     }
     nextTable.CmdBlitImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdCopyBufferToImage(
-        XGL_CMD_BUFFER cmdBuffer,
-        XGL_BUFFER srcBuffer,
-        XGL_IMAGE destImage, XGL_IMAGE_LAYOUT destImageLayout,
-        uint32_t regionCount, const XGL_BUFFER_IMAGE_COPY* pRegions)
+VK_LAYER_EXPORT void VKAPI vkCmdCopyBufferToImage(VK_CMD_BUFFER cmdBuffer,
+                                                     VK_BUFFER srcBuffer,
+                                                     VK_IMAGE destImage, VK_IMAGE_LAYOUT destImageLayout,
+                                                     uint32_t regionCount, const VK_BUFFER_IMAGE_COPY* pRegions)
 {
     GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
     if (pCB) {
@@ -2260,16 +2260,15 @@
     else {
         char str[1024];
         sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
     }
     nextTable.CmdCopyBufferToImage(cmdBuffer, srcBuffer, destImage, destImageLayout, regionCount, pRegions);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdCopyImageToBuffer(
-        XGL_CMD_BUFFER cmdBuffer,
-        XGL_IMAGE srcImage, XGL_IMAGE_LAYOUT srcImageLayout,
-        XGL_BUFFER destBuffer,
-        uint32_t regionCount, const XGL_BUFFER_IMAGE_COPY* pRegions)
+VK_LAYER_EXPORT void VKAPI vkCmdCopyImageToBuffer(VK_CMD_BUFFER cmdBuffer,
+                                                     VK_IMAGE srcImage, VK_IMAGE_LAYOUT srcImageLayout,
+                                                     VK_BUFFER destBuffer,
+                                                     uint32_t regionCount, const VK_BUFFER_IMAGE_COPY* pRegions)
 {
     GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
     if (pCB) {
@@ -2279,12 +2278,12 @@
     else {
         char str[1024];
         sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
     }
     nextTable.CmdCopyImageToBuffer(cmdBuffer, srcImage, srcImageLayout, destBuffer, regionCount, pRegions);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdCloneImageData(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE srcImage, XGL_IMAGE_LAYOUT srcImageLayout, XGL_IMAGE destImage, XGL_IMAGE_LAYOUT destImageLayout)
+VK_LAYER_EXPORT void VKAPI vkCmdCloneImageData(VK_CMD_BUFFER cmdBuffer, VK_IMAGE srcImage, VK_IMAGE_LAYOUT srcImageLayout, VK_IMAGE destImage, VK_IMAGE_LAYOUT destImageLayout)
 {
     GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
     if (pCB) {
@@ -2294,12 +2293,12 @@
     else {
         char str[1024];
         sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
     }
     nextTable.CmdCloneImageData(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdUpdateBuffer(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER destBuffer, XGL_GPU_SIZE destOffset, XGL_GPU_SIZE dataSize, const uint32_t* pData)
+VK_LAYER_EXPORT void VKAPI vkCmdUpdateBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFFER destBuffer, VK_GPU_SIZE destOffset, VK_GPU_SIZE dataSize, const uint32_t* pData)
 {
     GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
     if (pCB) {
@@ -2309,12 +2308,12 @@
     else {
         char str[1024];
         sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
     }
     nextTable.CmdUpdateBuffer(cmdBuffer, destBuffer, destOffset, dataSize, pData);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdFillBuffer(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER destBuffer, XGL_GPU_SIZE destOffset, XGL_GPU_SIZE fillSize, uint32_t data)
+VK_LAYER_EXPORT void VKAPI vkCmdFillBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFFER destBuffer, VK_GPU_SIZE destOffset, VK_GPU_SIZE fillSize, uint32_t data)
 {
     GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
     if (pCB) {
@@ -2324,16 +2323,15 @@
     else {
         char str[1024];
         sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
     }
     nextTable.CmdFillBuffer(cmdBuffer, destBuffer, destOffset, fillSize, data);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdClearColorImage(
-        XGL_CMD_BUFFER cmdBuffer,
-        XGL_IMAGE image, XGL_IMAGE_LAYOUT imageLayout,
-        XGL_CLEAR_COLOR color,
-        uint32_t rangeCount, const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges)
+VK_LAYER_EXPORT void VKAPI vkCmdClearColorImage(VK_CMD_BUFFER cmdBuffer,
+                                                   VK_IMAGE image, VK_IMAGE_LAYOUT imageLayout,
+                                                   VK_CLEAR_COLOR color,
+                                                   uint32_t rangeCount, const VK_IMAGE_SUBRESOURCE_RANGE* pRanges)
 {
     GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
     if (pCB) {
@@ -2343,16 +2341,15 @@
     else {
         char str[1024];
         sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
     }
     nextTable.CmdClearColorImage(cmdBuffer, image, imageLayout, color, rangeCount, pRanges);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdClearDepthStencil(
-        XGL_CMD_BUFFER cmdBuffer,
-        XGL_IMAGE image, XGL_IMAGE_LAYOUT imageLayout,
-        float depth, uint32_t stencil,
-        uint32_t rangeCount, const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges)
+VK_LAYER_EXPORT void VKAPI vkCmdClearDepthStencil(VK_CMD_BUFFER cmdBuffer,
+                                                     VK_IMAGE image, VK_IMAGE_LAYOUT imageLayout,
+                                                     float depth, uint32_t stencil,
+                                                     uint32_t rangeCount, const VK_IMAGE_SUBRESOURCE_RANGE* pRanges)
 {
     GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
     if (pCB) {
@@ -2362,16 +2359,15 @@
     else {
         char str[1024];
         sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
     }
     nextTable.CmdClearDepthStencil(cmdBuffer, image, imageLayout, depth, stencil, rangeCount, pRanges);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdResolveImage(
-        XGL_CMD_BUFFER cmdBuffer,
-        XGL_IMAGE srcImage, XGL_IMAGE_LAYOUT srcImageLayout,
-        XGL_IMAGE destImage, XGL_IMAGE_LAYOUT destImageLayout,
-        uint32_t rectCount, const XGL_IMAGE_RESOLVE* pRects)
+VK_LAYER_EXPORT void VKAPI vkCmdResolveImage(VK_CMD_BUFFER cmdBuffer,
+                                                VK_IMAGE srcImage, VK_IMAGE_LAYOUT srcImageLayout,
+                                                VK_IMAGE destImage, VK_IMAGE_LAYOUT destImageLayout,
+                                                uint32_t rectCount, const VK_IMAGE_RESOLVE* pRects)
 {
     GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
     if (pCB) {
@@ -2381,12 +2377,12 @@
     else {
         char str[1024];
         sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
     }
     nextTable.CmdResolveImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, rectCount, pRects);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdSetEvent(XGL_CMD_BUFFER cmdBuffer, XGL_EVENT event, XGL_PIPE_EVENT pipeEvent)
+VK_LAYER_EXPORT void VKAPI vkCmdSetEvent(VK_CMD_BUFFER cmdBuffer, VK_EVENT event, VK_PIPE_EVENT pipeEvent)
 {
     GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
     if (pCB) {
@@ -2396,12 +2392,12 @@
     else {
         char str[1024];
         sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
     }
     nextTable.CmdSetEvent(cmdBuffer, event, pipeEvent);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdResetEvent(XGL_CMD_BUFFER cmdBuffer, XGL_EVENT event, XGL_PIPE_EVENT pipeEvent)
+VK_LAYER_EXPORT void VKAPI vkCmdResetEvent(VK_CMD_BUFFER cmdBuffer, VK_EVENT event, VK_PIPE_EVENT pipeEvent)
 {
     GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
     if (pCB) {
@@ -2411,12 +2407,12 @@
     else {
         char str[1024];
         sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
     }
     nextTable.CmdResetEvent(cmdBuffer, event, pipeEvent);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdWaitEvents(XGL_CMD_BUFFER cmdBuffer, const XGL_EVENT_WAIT_INFO* pWaitInfo)
+VK_LAYER_EXPORT void VKAPI vkCmdWaitEvents(VK_CMD_BUFFER cmdBuffer, const VK_EVENT_WAIT_INFO* pWaitInfo)
 {
     GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
     if (pCB) {
@@ -2426,12 +2422,12 @@
     else {
         char str[1024];
         sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
     }
     nextTable.CmdWaitEvents(cmdBuffer, pWaitInfo);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdPipelineBarrier(XGL_CMD_BUFFER cmdBuffer, const XGL_PIPELINE_BARRIER* pBarrier)
+VK_LAYER_EXPORT void VKAPI vkCmdPipelineBarrier(VK_CMD_BUFFER cmdBuffer, const VK_PIPELINE_BARRIER* pBarrier)
 {
     GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
     if (pCB) {
@@ -2441,12 +2437,12 @@
     else {
         char str[1024];
         sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
     }
     nextTable.CmdPipelineBarrier(cmdBuffer, pBarrier);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdBeginQuery(XGL_CMD_BUFFER cmdBuffer, XGL_QUERY_POOL queryPool, uint32_t slot, XGL_FLAGS flags)
+VK_LAYER_EXPORT void VKAPI vkCmdBeginQuery(VK_CMD_BUFFER cmdBuffer, VK_QUERY_POOL queryPool, uint32_t slot, VK_FLAGS flags)
 {
     GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
     if (pCB) {
@@ -2456,12 +2452,12 @@
     else {
         char str[1024];
         sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
     }
     nextTable.CmdBeginQuery(cmdBuffer, queryPool, slot, flags);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdEndQuery(XGL_CMD_BUFFER cmdBuffer, XGL_QUERY_POOL queryPool, uint32_t slot)
+VK_LAYER_EXPORT void VKAPI vkCmdEndQuery(VK_CMD_BUFFER cmdBuffer, VK_QUERY_POOL queryPool, uint32_t slot)
 {
     GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
     if (pCB) {
@@ -2471,12 +2467,12 @@
     else {
         char str[1024];
         sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
     }
     nextTable.CmdEndQuery(cmdBuffer, queryPool, slot);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdResetQueryPool(XGL_CMD_BUFFER cmdBuffer, XGL_QUERY_POOL queryPool, uint32_t startQuery, uint32_t queryCount)
+VK_LAYER_EXPORT void VKAPI vkCmdResetQueryPool(VK_CMD_BUFFER cmdBuffer, VK_QUERY_POOL queryPool, uint32_t startQuery, uint32_t queryCount)
 {
     GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
     if (pCB) {
@@ -2486,12 +2482,12 @@
     else {
         char str[1024];
         sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
     }
     nextTable.CmdResetQueryPool(cmdBuffer, queryPool, startQuery, queryCount);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdWriteTimestamp(XGL_CMD_BUFFER cmdBuffer, XGL_TIMESTAMP_TYPE timestampType, XGL_BUFFER destBuffer, XGL_GPU_SIZE destOffset)
+VK_LAYER_EXPORT void VKAPI vkCmdWriteTimestamp(VK_CMD_BUFFER cmdBuffer, VK_TIMESTAMP_TYPE timestampType, VK_BUFFER destBuffer, VK_GPU_SIZE destOffset)
 {
     GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
     if (pCB) {
@@ -2501,12 +2497,12 @@
     else {
         char str[1024];
         sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
     }
     nextTable.CmdWriteTimestamp(cmdBuffer, timestampType, destBuffer, destOffset);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdInitAtomicCounters(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, const uint32_t* pData)
+VK_LAYER_EXPORT void VKAPI vkCmdInitAtomicCounters(VK_CMD_BUFFER cmdBuffer, VK_PIPELINE_BIND_POINT pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, const uint32_t* pData)
 {
     GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
     if (pCB) {
@@ -2516,12 +2512,12 @@
     else {
         char str[1024];
         sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
     }
     nextTable.CmdInitAtomicCounters(cmdBuffer, pipelineBindPoint, startCounter, counterCount, pData);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdLoadAtomicCounters(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, XGL_BUFFER srcBuffer, XGL_GPU_SIZE srcOffset)
+VK_LAYER_EXPORT void VKAPI vkCmdLoadAtomicCounters(VK_CMD_BUFFER cmdBuffer, VK_PIPELINE_BIND_POINT pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, VK_BUFFER srcBuffer, VK_GPU_SIZE srcOffset)
 {
     GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
     if (pCB) {
@@ -2531,12 +2527,12 @@
     else {
         char str[1024];
         sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
     }
     nextTable.CmdLoadAtomicCounters(cmdBuffer, pipelineBindPoint, startCounter, counterCount, srcBuffer, srcOffset);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdSaveAtomicCounters(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, XGL_BUFFER destBuffer, XGL_GPU_SIZE destOffset)
+VK_LAYER_EXPORT void VKAPI vkCmdSaveAtomicCounters(VK_CMD_BUFFER cmdBuffer, VK_PIPELINE_BIND_POINT pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, VK_BUFFER destBuffer, VK_GPU_SIZE destOffset)
 {
     GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
     if (pCB) {
@@ -2546,54 +2542,54 @@
     else {
         char str[1024];
         sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
     }
     nextTable.CmdSaveAtomicCounters(cmdBuffer, pipelineBindPoint, startCounter, counterCount, destBuffer, destOffset);
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateFramebuffer(XGL_DEVICE device, const XGL_FRAMEBUFFER_CREATE_INFO* pCreateInfo, XGL_FRAMEBUFFER* pFramebuffer)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateFramebuffer(VK_DEVICE device, const VK_FRAMEBUFFER_CREATE_INFO* pCreateInfo, VK_FRAMEBUFFER* pFramebuffer)
 {
-    XGL_RESULT result = nextTable.CreateFramebuffer(device, pCreateInfo, pFramebuffer);
-    if (XGL_SUCCESS == result) {
+    VK_RESULT result = nextTable.CreateFramebuffer(device, pCreateInfo, pFramebuffer);
+    if (VK_SUCCESS == result) {
         // Shadow create info and store in map
-        XGL_FRAMEBUFFER_CREATE_INFO* localFBCI = new XGL_FRAMEBUFFER_CREATE_INFO(*pCreateInfo);
+        VK_FRAMEBUFFER_CREATE_INFO* localFBCI = new VK_FRAMEBUFFER_CREATE_INFO(*pCreateInfo);
         if (pCreateInfo->pColorAttachments) {
-            localFBCI->pColorAttachments = new XGL_COLOR_ATTACHMENT_BIND_INFO[localFBCI->colorAttachmentCount];
-            memcpy((void*)localFBCI->pColorAttachments, pCreateInfo->pColorAttachments, localFBCI->colorAttachmentCount*sizeof(XGL_COLOR_ATTACHMENT_BIND_INFO));
+            localFBCI->pColorAttachments = new VK_COLOR_ATTACHMENT_BIND_INFO[localFBCI->colorAttachmentCount];
+            memcpy((void*)localFBCI->pColorAttachments, pCreateInfo->pColorAttachments, localFBCI->colorAttachmentCount*sizeof(VK_COLOR_ATTACHMENT_BIND_INFO));
         }
         if (pCreateInfo->pDepthStencilAttachment) {
-            localFBCI->pDepthStencilAttachment = new XGL_DEPTH_STENCIL_BIND_INFO[localFBCI->colorAttachmentCount];
-            memcpy((void*)localFBCI->pDepthStencilAttachment, pCreateInfo->pDepthStencilAttachment, localFBCI->colorAttachmentCount*sizeof(XGL_DEPTH_STENCIL_BIND_INFO));
+            localFBCI->pDepthStencilAttachment = new VK_DEPTH_STENCIL_BIND_INFO[localFBCI->colorAttachmentCount];
+            memcpy((void*)localFBCI->pDepthStencilAttachment, pCreateInfo->pDepthStencilAttachment, localFBCI->colorAttachmentCount*sizeof(VK_DEPTH_STENCIL_BIND_INFO));
         }
         frameBufferMap[*pFramebuffer] = localFBCI;
     }
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateRenderPass(XGL_DEVICE device, const XGL_RENDER_PASS_CREATE_INFO* pCreateInfo, XGL_RENDER_PASS* pRenderPass)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateRenderPass(VK_DEVICE device, const VK_RENDER_PASS_CREATE_INFO* pCreateInfo, VK_RENDER_PASS* pRenderPass)
 {
-    XGL_RESULT result = nextTable.CreateRenderPass(device, pCreateInfo, pRenderPass);
-    if (XGL_SUCCESS == result) {
+    VK_RESULT result = nextTable.CreateRenderPass(device, pCreateInfo, pRenderPass);
+    if (VK_SUCCESS == result) {
         // Shadow create info and store in map
-        XGL_RENDER_PASS_CREATE_INFO* localRPCI = new XGL_RENDER_PASS_CREATE_INFO(*pCreateInfo);
+        VK_RENDER_PASS_CREATE_INFO* localRPCI = new VK_RENDER_PASS_CREATE_INFO(*pCreateInfo);
         if (pCreateInfo->pColorLoadOps) {
-            localRPCI->pColorLoadOps = new XGL_ATTACHMENT_LOAD_OP[localRPCI->colorAttachmentCount];
-            memcpy((void*)localRPCI->pColorLoadOps, pCreateInfo->pColorLoadOps, localRPCI->colorAttachmentCount*sizeof(XGL_ATTACHMENT_LOAD_OP));
+            localRPCI->pColorLoadOps = new VK_ATTACHMENT_LOAD_OP[localRPCI->colorAttachmentCount];
+            memcpy((void*)localRPCI->pColorLoadOps, pCreateInfo->pColorLoadOps, localRPCI->colorAttachmentCount*sizeof(VK_ATTACHMENT_LOAD_OP));
         }
         if (pCreateInfo->pColorStoreOps) {
-            localRPCI->pColorStoreOps = new XGL_ATTACHMENT_STORE_OP[localRPCI->colorAttachmentCount];
-            memcpy((void*)localRPCI->pColorStoreOps, pCreateInfo->pColorStoreOps, localRPCI->colorAttachmentCount*sizeof(XGL_ATTACHMENT_STORE_OP));
+            localRPCI->pColorStoreOps = new VK_ATTACHMENT_STORE_OP[localRPCI->colorAttachmentCount];
+            memcpy((void*)localRPCI->pColorStoreOps, pCreateInfo->pColorStoreOps, localRPCI->colorAttachmentCount*sizeof(VK_ATTACHMENT_STORE_OP));
         }
         if (pCreateInfo->pColorLoadClearValues) {
-            localRPCI->pColorLoadClearValues = new XGL_CLEAR_COLOR[localRPCI->colorAttachmentCount];
-            memcpy((void*)localRPCI->pColorLoadClearValues, pCreateInfo->pColorLoadClearValues, localRPCI->colorAttachmentCount*sizeof(XGL_CLEAR_COLOR));
+            localRPCI->pColorLoadClearValues = new VK_CLEAR_COLOR[localRPCI->colorAttachmentCount];
+            memcpy((void*)localRPCI->pColorLoadClearValues, pCreateInfo->pColorLoadClearValues, localRPCI->colorAttachmentCount*sizeof(VK_CLEAR_COLOR));
         }
         renderPassMap[*pRenderPass] = localRPCI;
     }
     return result;
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdBeginRenderPass(XGL_CMD_BUFFER cmdBuffer, const XGL_RENDER_PASS_BEGIN *pRenderPassBegin)
+VK_LAYER_EXPORT void VKAPI vkCmdBeginRenderPass(VK_CMD_BUFFER cmdBuffer, const VK_RENDER_PASS_BEGIN *pRenderPassBegin)
 {
     GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
     if (pCB) {
@@ -2602,17 +2598,17 @@
         pCB->activeRenderPass = pRenderPassBegin->renderPass;
         pCB->framebuffer = pRenderPassBegin->framebuffer;
         if (pCB->lastBoundPipeline) {
-            validatePipelineState(pCB, XGL_PIPELINE_BIND_POINT_GRAPHICS, pCB->lastBoundPipeline);
+            validatePipelineState(pCB, VK_PIPELINE_BIND_POINT_GRAPHICS, pCB->lastBoundPipeline);
         }
     } else {
         char str[1024];
         sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
     }
     nextTable.CmdBeginRenderPass(cmdBuffer, pRenderPassBegin);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdEndRenderPass(XGL_CMD_BUFFER cmdBuffer, XGL_RENDER_PASS renderPass)
+VK_LAYER_EXPORT void VKAPI vkCmdEndRenderPass(VK_CMD_BUFFER cmdBuffer, VK_RENDER_PASS renderPass)
 {
     GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
     if (pCB) {
@@ -2623,36 +2619,36 @@
     else {
         char str[1024];
         sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
     }
     nextTable.CmdEndRenderPass(cmdBuffer, renderPass);
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDbgRegisterMsgCallback(XGL_INSTANCE instance, XGL_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback, void* pUserData)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkDbgRegisterMsgCallback(VK_INSTANCE instance, VK_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback, void* pUserData)
 {
     // This layer intercepts callbacks
-    XGL_LAYER_DBG_FUNCTION_NODE* pNewDbgFuncNode = (XGL_LAYER_DBG_FUNCTION_NODE*)malloc(sizeof(XGL_LAYER_DBG_FUNCTION_NODE));
+    VK_LAYER_DBG_FUNCTION_NODE* pNewDbgFuncNode = (VK_LAYER_DBG_FUNCTION_NODE*)malloc(sizeof(VK_LAYER_DBG_FUNCTION_NODE));
 #if ALLOC_DEBUG
     printf("Alloc34 #%lu pNewDbgFuncNode addr(%p)\n", ++g_alloc_count, (void*)pNewDbgFuncNode);
 #endif
     if (!pNewDbgFuncNode)
-        return XGL_ERROR_OUT_OF_MEMORY;
+        return VK_ERROR_OUT_OF_MEMORY;
     pNewDbgFuncNode->pfnMsgCallback = pfnMsgCallback;
     pNewDbgFuncNode->pUserData = pUserData;
     pNewDbgFuncNode->pNext = g_pDbgFunctionHead;
     g_pDbgFunctionHead = pNewDbgFuncNode;
     // force callbacks if DebugAction hasn't been set already other than initial value
 	if (g_actionIsDefault) {
-		g_debugAction = XGL_DBG_LAYER_ACTION_CALLBACK;
+		g_debugAction = VK_DBG_LAYER_ACTION_CALLBACK;
 	}
-    XGL_RESULT result = nextTable.DbgRegisterMsgCallback(instance, pfnMsgCallback, pUserData);
+    VK_RESULT result = nextTable.DbgRegisterMsgCallback(instance, pfnMsgCallback, pUserData);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDbgUnregisterMsgCallback(XGL_INSTANCE instance, XGL_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkDbgUnregisterMsgCallback(VK_INSTANCE instance, VK_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback)
 {
-    XGL_LAYER_DBG_FUNCTION_NODE *pTrav = g_pDbgFunctionHead;
-    XGL_LAYER_DBG_FUNCTION_NODE *pPrev = pTrav;
+    VK_LAYER_DBG_FUNCTION_NODE *pTrav = g_pDbgFunctionHead;
+    VK_LAYER_DBG_FUNCTION_NODE *pPrev = pTrav;
     while (pTrav) {
         if (pTrav->pfnMsgCallback == pfnMsgCallback) {
             pPrev->pNext = pTrav->pNext;
@@ -2670,15 +2666,15 @@
     if (g_pDbgFunctionHead == NULL)
     {
         if (g_actionIsDefault)
-            g_debugAction = XGL_DBG_LAYER_ACTION_LOG_MSG;
+            g_debugAction = VK_DBG_LAYER_ACTION_LOG_MSG;
         else
-            g_debugAction = (XGL_LAYER_DBG_ACTION)(g_debugAction & ~((uint32_t)XGL_DBG_LAYER_ACTION_CALLBACK));
+            g_debugAction = (VK_LAYER_DBG_ACTION)(g_debugAction & ~((uint32_t)VK_DBG_LAYER_ACTION_CALLBACK));
     }
-    XGL_RESULT result = nextTable.DbgUnregisterMsgCallback(instance, pfnMsgCallback);
+    VK_RESULT result = nextTable.DbgUnregisterMsgCallback(instance, pfnMsgCallback);
     return result;
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdDbgMarkerBegin(XGL_CMD_BUFFER cmdBuffer, const char* pMarker)
+VK_LAYER_EXPORT void VKAPI vkCmdDbgMarkerBegin(VK_CMD_BUFFER cmdBuffer, const char* pMarker)
 {
     GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
     if (pCB) {
@@ -2688,12 +2684,12 @@
     else {
         char str[1024];
         sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
     }
     nextTable.CmdDbgMarkerBegin(cmdBuffer, pMarker);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdDbgMarkerEnd(XGL_CMD_BUFFER cmdBuffer)
+VK_LAYER_EXPORT void VKAPI vkCmdDbgMarkerEnd(VK_CMD_BUFFER cmdBuffer)
 {
     GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
     if (pCB) {
@@ -2703,7 +2699,7 @@
     else {
         char str[1024];
         sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
     }
     nextTable.CmdDbgMarkerEnd(cmdBuffer);
 }
@@ -2727,7 +2723,7 @@
 // FIXME: NEED WINDOWS EQUIVALENT
         char str[1024];
         sprintf(str, "Cannot execute dot program yet on Windows.");
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_MISSING_DOT_PROGRAM, "DS", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_MISSING_DOT_PROGRAM, "DS", str);
 #else // WIN32
     char dotExe[32] = "/usr/bin/dot";
     if( access(dotExe, X_OK) != -1) {
@@ -2740,158 +2736,158 @@
     else {
         char str[1024];
         sprintf(str, "Cannot execute dot program at (%s) to dump requested %s file.", dotExe, outFileName);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_MISSING_DOT_PROGRAM, "DS", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_MISSING_DOT_PROGRAM, "DS", str);
     }
 #endif // WIN32
 }
 
-XGL_LAYER_EXPORT void* XGLAPI xglGetProcAddr(XGL_PHYSICAL_GPU gpu, const char* funcName)
+VK_LAYER_EXPORT void* VKAPI vkGetProcAddr(VK_PHYSICAL_GPU gpu, const char* funcName)
 {
-    XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) gpu;
+    VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
 
     if (gpu == NULL)
         return NULL;
     pCurObj = gpuw;
     loader_platform_thread_once(&g_initOnce, initDrawState);
 
-    if (!strcmp(funcName, "xglGetProcAddr"))
-        return (void *) xglGetProcAddr;
-    if (!strcmp(funcName, "xglCreateDevice"))
-        return (void*) xglCreateDevice;
-    if (!strcmp(funcName, "xglDestroyDevice"))
-        return (void*) xglDestroyDevice;
-    if (!strcmp(funcName, "xglGetExtensionSupport"))
-        return (void*) xglGetExtensionSupport;
-    if (!strcmp(funcName, "xglEnumerateLayers"))
-        return (void*) xglEnumerateLayers;
-    if (!strcmp(funcName, "xglQueueSubmit"))
-        return (void*) xglQueueSubmit;
-    if (!strcmp(funcName, "xglDestroyObject"))
-        return (void*) xglDestroyObject;
-    if (!strcmp(funcName, "xglCreateBufferView"))
-        return (void*) xglCreateBufferView;
-    if (!strcmp(funcName, "xglCreateImageView"))
-        return (void*) xglCreateImageView;
-    if (!strcmp(funcName, "xglCreateGraphicsPipeline"))
-        return (void*) xglCreateGraphicsPipeline;
-    if (!strcmp(funcName, "xglCreateGraphicsPipelineDerivative"))
-        return (void*) xglCreateGraphicsPipelineDerivative;
-    if (!strcmp(funcName, "xglCreateSampler"))
-        return (void*) xglCreateSampler;
-    if (!strcmp(funcName, "xglCreateDescriptorSetLayout"))
-        return (void*) xglCreateDescriptorSetLayout;
-    if (!strcmp(funcName, "xglCreateDescriptorSetLayoutChain"))
-        return (void*) xglCreateDescriptorSetLayoutChain;
-    if (!strcmp(funcName, "xglBeginDescriptorPoolUpdate"))
-        return (void*) xglBeginDescriptorPoolUpdate;
-    if (!strcmp(funcName, "xglEndDescriptorPoolUpdate"))
-        return (void*) xglEndDescriptorPoolUpdate;
-    if (!strcmp(funcName, "xglCreateDescriptorPool"))
-        return (void*) xglCreateDescriptorPool;
-    if (!strcmp(funcName, "xglResetDescriptorPool"))
-        return (void*) xglResetDescriptorPool;
-    if (!strcmp(funcName, "xglAllocDescriptorSets"))
-        return (void*) xglAllocDescriptorSets;
-    if (!strcmp(funcName, "xglClearDescriptorSets"))
-        return (void*) xglClearDescriptorSets;
-    if (!strcmp(funcName, "xglUpdateDescriptors"))
-        return (void*) xglUpdateDescriptors;
-    if (!strcmp(funcName, "xglCreateDynamicViewportState"))
-        return (void*) xglCreateDynamicViewportState;
-    if (!strcmp(funcName, "xglCreateDynamicRasterState"))
-        return (void*) xglCreateDynamicRasterState;
-    if (!strcmp(funcName, "xglCreateDynamicColorBlendState"))
-        return (void*) xglCreateDynamicColorBlendState;
-    if (!strcmp(funcName, "xglCreateDynamicDepthStencilState"))
-        return (void*) xglCreateDynamicDepthStencilState;
-    if (!strcmp(funcName, "xglCreateCommandBuffer"))
-        return (void*) xglCreateCommandBuffer;
-    if (!strcmp(funcName, "xglBeginCommandBuffer"))
-        return (void*) xglBeginCommandBuffer;
-    if (!strcmp(funcName, "xglEndCommandBuffer"))
-        return (void*) xglEndCommandBuffer;
-    if (!strcmp(funcName, "xglResetCommandBuffer"))
-        return (void*) xglResetCommandBuffer;
-    if (!strcmp(funcName, "xglCmdBindPipeline"))
-        return (void*) xglCmdBindPipeline;
-    if (!strcmp(funcName, "xglCmdBindDynamicStateObject"))
-        return (void*) xglCmdBindDynamicStateObject;
-    if (!strcmp(funcName, "xglCmdBindDescriptorSets"))
-        return (void*) xglCmdBindDescriptorSets;
-    if (!strcmp(funcName, "xglCmdBindVertexBuffer"))
-        return (void*) xglCmdBindVertexBuffer;
-    if (!strcmp(funcName, "xglCmdBindIndexBuffer"))
-        return (void*) xglCmdBindIndexBuffer;
-    if (!strcmp(funcName, "xglCmdDraw"))
-        return (void*) xglCmdDraw;
-    if (!strcmp(funcName, "xglCmdDrawIndexed"))
-        return (void*) xglCmdDrawIndexed;
-    if (!strcmp(funcName, "xglCmdDrawIndirect"))
-        return (void*) xglCmdDrawIndirect;
-    if (!strcmp(funcName, "xglCmdDrawIndexedIndirect"))
-        return (void*) xglCmdDrawIndexedIndirect;
-    if (!strcmp(funcName, "xglCmdDispatch"))
-        return (void*) xglCmdDispatch;
-    if (!strcmp(funcName, "xglCmdDispatchIndirect"))
-        return (void*) xglCmdDispatchIndirect;
-    if (!strcmp(funcName, "xglCmdCopyBuffer"))
-        return (void*) xglCmdCopyBuffer;
-    if (!strcmp(funcName, "xglCmdCopyImage"))
-        return (void*) xglCmdCopyImage;
-    if (!strcmp(funcName, "xglCmdCopyBufferToImage"))
-        return (void*) xglCmdCopyBufferToImage;
-    if (!strcmp(funcName, "xglCmdCopyImageToBuffer"))
-        return (void*) xglCmdCopyImageToBuffer;
-    if (!strcmp(funcName, "xglCmdCloneImageData"))
-        return (void*) xglCmdCloneImageData;
-    if (!strcmp(funcName, "xglCmdUpdateBuffer"))
-        return (void*) xglCmdUpdateBuffer;
-    if (!strcmp(funcName, "xglCmdFillBuffer"))
-        return (void*) xglCmdFillBuffer;
-    if (!strcmp(funcName, "xglCmdClearColorImage"))
-        return (void*) xglCmdClearColorImage;
-    if (!strcmp(funcName, "xglCmdClearDepthStencil"))
-        return (void*) xglCmdClearDepthStencil;
-    if (!strcmp(funcName, "xglCmdResolveImage"))
-        return (void*) xglCmdResolveImage;
-    if (!strcmp(funcName, "xglCmdSetEvent"))
-        return (void*) xglCmdSetEvent;
-    if (!strcmp(funcName, "xglCmdResetEvent"))
-        return (void*) xglCmdResetEvent;
-    if (!strcmp(funcName, "xglCmdWaitEvents"))
-        return (void*) xglCmdWaitEvents;
-    if (!strcmp(funcName, "xglCmdPipelineBarrier"))
-        return (void*) xglCmdPipelineBarrier;
-    if (!strcmp(funcName, "xglCmdBeginQuery"))
-        return (void*) xglCmdBeginQuery;
-    if (!strcmp(funcName, "xglCmdEndQuery"))
-        return (void*) xglCmdEndQuery;
-    if (!strcmp(funcName, "xglCmdResetQueryPool"))
-        return (void*) xglCmdResetQueryPool;
-    if (!strcmp(funcName, "xglCmdWriteTimestamp"))
-        return (void*) xglCmdWriteTimestamp;
-    if (!strcmp(funcName, "xglCmdInitAtomicCounters"))
-        return (void*) xglCmdInitAtomicCounters;
-    if (!strcmp(funcName, "xglCmdLoadAtomicCounters"))
-        return (void*) xglCmdLoadAtomicCounters;
-    if (!strcmp(funcName, "xglCmdSaveAtomicCounters"))
-        return (void*) xglCmdSaveAtomicCounters;
-    if (!strcmp(funcName, "xglCreateFramebuffer"))
-        return (void*) xglCreateFramebuffer;
-    if (!strcmp(funcName, "xglCreateRenderPass"))
-        return (void*) xglCreateRenderPass;
-    if (!strcmp(funcName, "xglCmdBeginRenderPass"))
-        return (void*) xglCmdBeginRenderPass;
-    if (!strcmp(funcName, "xglCmdEndRenderPass"))
-        return (void*) xglCmdEndRenderPass;
-    if (!strcmp(funcName, "xglDbgRegisterMsgCallback"))
-        return (void*) xglDbgRegisterMsgCallback;
-    if (!strcmp(funcName, "xglDbgUnregisterMsgCallback"))
-        return (void*) xglDbgUnregisterMsgCallback;
-    if (!strcmp(funcName, "xglCmdDbgMarkerBegin"))
-        return (void*) xglCmdDbgMarkerBegin;
-    if (!strcmp(funcName, "xglCmdDbgMarkerEnd"))
-        return (void*) xglCmdDbgMarkerEnd;
+    if (!strcmp(funcName, "vkGetProcAddr"))
+        return (void *) vkGetProcAddr;
+    if (!strcmp(funcName, "vkCreateDevice"))
+        return (void*) vkCreateDevice;
+    if (!strcmp(funcName, "vkDestroyDevice"))
+        return (void*) vkDestroyDevice;
+    if (!strcmp(funcName, "vkGetExtensionSupport"))
+        return (void*) vkGetExtensionSupport;
+    if (!strcmp(funcName, "vkEnumerateLayers"))
+        return (void*) vkEnumerateLayers;
+    if (!strcmp(funcName, "vkQueueSubmit"))
+        return (void*) vkQueueSubmit;
+    if (!strcmp(funcName, "vkDestroyObject"))
+        return (void*) vkDestroyObject;
+    if (!strcmp(funcName, "vkCreateBufferView"))
+        return (void*) vkCreateBufferView;
+    if (!strcmp(funcName, "vkCreateImageView"))
+        return (void*) vkCreateImageView;
+    if (!strcmp(funcName, "vkCreateGraphicsPipeline"))
+        return (void*) vkCreateGraphicsPipeline;
+    if (!strcmp(funcName, "vkCreateGraphicsPipelineDerivative"))
+        return (void*) vkCreateGraphicsPipelineDerivative;
+    if (!strcmp(funcName, "vkCreateSampler"))
+        return (void*) vkCreateSampler;
+    if (!strcmp(funcName, "vkCreateDescriptorSetLayout"))
+        return (void*) vkCreateDescriptorSetLayout;
+    if (!strcmp(funcName, "vkCreateDescriptorSetLayoutChain"))
+        return (void*) vkCreateDescriptorSetLayoutChain;
+    if (!strcmp(funcName, "vkBeginDescriptorPoolUpdate"))
+        return (void*) vkBeginDescriptorPoolUpdate;
+    if (!strcmp(funcName, "vkEndDescriptorPoolUpdate"))
+        return (void*) vkEndDescriptorPoolUpdate;
+    if (!strcmp(funcName, "vkCreateDescriptorPool"))
+        return (void*) vkCreateDescriptorPool;
+    if (!strcmp(funcName, "vkResetDescriptorPool"))
+        return (void*) vkResetDescriptorPool;
+    if (!strcmp(funcName, "vkAllocDescriptorSets"))
+        return (void*) vkAllocDescriptorSets;
+    if (!strcmp(funcName, "vkClearDescriptorSets"))
+        return (void*) vkClearDescriptorSets;
+    if (!strcmp(funcName, "vkUpdateDescriptors"))
+        return (void*) vkUpdateDescriptors;
+    if (!strcmp(funcName, "vkCreateDynamicViewportState"))
+        return (void*) vkCreateDynamicViewportState;
+    if (!strcmp(funcName, "vkCreateDynamicRasterState"))
+        return (void*) vkCreateDynamicRasterState;
+    if (!strcmp(funcName, "vkCreateDynamicColorBlendState"))
+        return (void*) vkCreateDynamicColorBlendState;
+    if (!strcmp(funcName, "vkCreateDynamicDepthStencilState"))
+        return (void*) vkCreateDynamicDepthStencilState;
+    if (!strcmp(funcName, "vkCreateCommandBuffer"))
+        return (void*) vkCreateCommandBuffer;
+    if (!strcmp(funcName, "vkBeginCommandBuffer"))
+        return (void*) vkBeginCommandBuffer;
+    if (!strcmp(funcName, "vkEndCommandBuffer"))
+        return (void*) vkEndCommandBuffer;
+    if (!strcmp(funcName, "vkResetCommandBuffer"))
+        return (void*) vkResetCommandBuffer;
+    if (!strcmp(funcName, "vkCmdBindPipeline"))
+        return (void*) vkCmdBindPipeline;
+    if (!strcmp(funcName, "vkCmdBindDynamicStateObject"))
+        return (void*) vkCmdBindDynamicStateObject;
+    if (!strcmp(funcName, "vkCmdBindDescriptorSets"))
+        return (void*) vkCmdBindDescriptorSets;
+    if (!strcmp(funcName, "vkCmdBindVertexBuffer"))
+        return (void*) vkCmdBindVertexBuffer;
+    if (!strcmp(funcName, "vkCmdBindIndexBuffer"))
+        return (void*) vkCmdBindIndexBuffer;
+    if (!strcmp(funcName, "vkCmdDraw"))
+        return (void*) vkCmdDraw;
+    if (!strcmp(funcName, "vkCmdDrawIndexed"))
+        return (void*) vkCmdDrawIndexed;
+    if (!strcmp(funcName, "vkCmdDrawIndirect"))
+        return (void*) vkCmdDrawIndirect;
+    if (!strcmp(funcName, "vkCmdDrawIndexedIndirect"))
+        return (void*) vkCmdDrawIndexedIndirect;
+    if (!strcmp(funcName, "vkCmdDispatch"))
+        return (void*) vkCmdDispatch;
+    if (!strcmp(funcName, "vkCmdDispatchIndirect"))
+        return (void*) vkCmdDispatchIndirect;
+    if (!strcmp(funcName, "vkCmdCopyBuffer"))
+        return (void*) vkCmdCopyBuffer;
+    if (!strcmp(funcName, "vkCmdCopyImage"))
+        return (void*) vkCmdCopyImage;
+    if (!strcmp(funcName, "vkCmdCopyBufferToImage"))
+        return (void*) vkCmdCopyBufferToImage;
+    if (!strcmp(funcName, "vkCmdCopyImageToBuffer"))
+        return (void*) vkCmdCopyImageToBuffer;
+    if (!strcmp(funcName, "vkCmdCloneImageData"))
+        return (void*) vkCmdCloneImageData;
+    if (!strcmp(funcName, "vkCmdUpdateBuffer"))
+        return (void*) vkCmdUpdateBuffer;
+    if (!strcmp(funcName, "vkCmdFillBuffer"))
+        return (void*) vkCmdFillBuffer;
+    if (!strcmp(funcName, "vkCmdClearColorImage"))
+        return (void*) vkCmdClearColorImage;
+    if (!strcmp(funcName, "vkCmdClearDepthStencil"))
+        return (void*) vkCmdClearDepthStencil;
+    if (!strcmp(funcName, "vkCmdResolveImage"))
+        return (void*) vkCmdResolveImage;
+    if (!strcmp(funcName, "vkCmdSetEvent"))
+        return (void*) vkCmdSetEvent;
+    if (!strcmp(funcName, "vkCmdResetEvent"))
+        return (void*) vkCmdResetEvent;
+    if (!strcmp(funcName, "vkCmdWaitEvents"))
+        return (void*) vkCmdWaitEvents;
+    if (!strcmp(funcName, "vkCmdPipelineBarrier"))
+        return (void*) vkCmdPipelineBarrier;
+    if (!strcmp(funcName, "vkCmdBeginQuery"))
+        return (void*) vkCmdBeginQuery;
+    if (!strcmp(funcName, "vkCmdEndQuery"))
+        return (void*) vkCmdEndQuery;
+    if (!strcmp(funcName, "vkCmdResetQueryPool"))
+        return (void*) vkCmdResetQueryPool;
+    if (!strcmp(funcName, "vkCmdWriteTimestamp"))
+        return (void*) vkCmdWriteTimestamp;
+    if (!strcmp(funcName, "vkCmdInitAtomicCounters"))
+        return (void*) vkCmdInitAtomicCounters;
+    if (!strcmp(funcName, "vkCmdLoadAtomicCounters"))
+        return (void*) vkCmdLoadAtomicCounters;
+    if (!strcmp(funcName, "vkCmdSaveAtomicCounters"))
+        return (void*) vkCmdSaveAtomicCounters;
+    if (!strcmp(funcName, "vkCreateFramebuffer"))
+        return (void*) vkCreateFramebuffer;
+    if (!strcmp(funcName, "vkCreateRenderPass"))
+        return (void*) vkCreateRenderPass;
+    if (!strcmp(funcName, "vkCmdBeginRenderPass"))
+        return (void*) vkCmdBeginRenderPass;
+    if (!strcmp(funcName, "vkCmdEndRenderPass"))
+        return (void*) vkCmdEndRenderPass;
+    if (!strcmp(funcName, "vkDbgRegisterMsgCallback"))
+        return (void*) vkDbgRegisterMsgCallback;
+    if (!strcmp(funcName, "vkDbgUnregisterMsgCallback"))
+        return (void*) vkDbgUnregisterMsgCallback;
+    if (!strcmp(funcName, "vkCmdDbgMarkerBegin"))
+        return (void*) vkCmdDbgMarkerBegin;
+    if (!strcmp(funcName, "vkCmdDbgMarkerEnd"))
+        return (void*) vkCmdDbgMarkerEnd;
     if (!strcmp("drawStateDumpDotFile", funcName))
         return (void*) drawStateDumpDotFile;
     if (!strcmp("drawStateDumpCommandBufferDotFile", funcName))
@@ -2901,6 +2897,6 @@
     else {
         if (gpuw->pGPA == NULL)
             return NULL;
-        return gpuw->pGPA((XGL_PHYSICAL_GPU)gpuw->nextObject, funcName);
+        return gpuw->pGPA((VK_PHYSICAL_GPU)gpuw->nextObject, funcName);
     }
 }
diff --git a/layers/draw_state.h b/layers/draw_state.h
index d2d7650..0bf33c4 100644
--- a/layers/draw_state.h
+++ b/layers/draw_state.h
@@ -1,5 +1,5 @@
 /*
- * XGL
+ * Vulkan
  *
  * Copyright (C) 2014 LunarG, Inc.
  *
@@ -21,7 +21,7 @@
  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  * DEALINGS IN THE SOFTWARE.
  */
-#include "xglLayer.h"
+#include "vkLayer.h"
 #include <vector>
 
 using namespace std;
@@ -39,10 +39,10 @@
     DRAWSTATE_UPDATE_WITHOUT_BEGIN,             // Attempt to update descriptors w/o calling BeginDescriptorPoolUpdate
     DRAWSTATE_INVALID_PIPELINE,                 // Invalid Pipeline referenced
     DRAWSTATE_INVALID_CMD_BUFFER,               // Invalid CmdBuffer referenced
-    DRAWSTATE_VTX_INDEX_OUT_OF_BOUNDS,          // binding in xglCmdBindVertexData() too large for PSO's pVertexBindingDescriptions array
+    DRAWSTATE_VTX_INDEX_OUT_OF_BOUNDS,          // binding in vkCmdBindVertexData() too large for PSO's pVertexBindingDescriptions array
     DRAWSTATE_INVALID_DYNAMIC_STATE_OBJECT,     // Invalid dyn state object
     DRAWSTATE_MISSING_DOT_PROGRAM,              // No "dot" program in order to generate png image
-    DRAWSTATE_BINDING_DS_NO_END_UPDATE,         // DS bound to CmdBuffer w/o call to xglEndDescriptorSetUpdate())
+    DRAWSTATE_BINDING_DS_NO_END_UPDATE,         // DS bound to CmdBuffer w/o call to vkEndDescriptorSetUpdate())
     DRAWSTATE_NO_DS_POOL,                       // No DS Pool is available
     DRAWSTATE_OUT_OF_MEMORY,                    // malloc failed
     DRAWSTATE_DESCRIPTOR_TYPE_MISMATCH,         // Type in layout vs. update are not the same
@@ -65,84 +65,84 @@
 
 typedef struct _SHADER_DS_MAPPING {
     uint32_t slotCount;
-    XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pShaderMappingSlot;
+    VK_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pShaderMappingSlot;
 } SHADER_DS_MAPPING;
 
 typedef struct _GENERIC_HEADER {
-    XGL_STRUCTURE_TYPE sType;
+    VK_STRUCTURE_TYPE sType;
     const void*    pNext;
 } GENERIC_HEADER;
 
 typedef struct _PIPELINE_NODE {
-    XGL_PIPELINE           pipeline;
+    VK_PIPELINE           pipeline;
 
-    XGL_GRAPHICS_PIPELINE_CREATE_INFO     graphicsPipelineCI;
-    XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO vertexInputCI;
-    XGL_PIPELINE_IA_STATE_CREATE_INFO     iaStateCI;
-    XGL_PIPELINE_TESS_STATE_CREATE_INFO   tessStateCI;
-    XGL_PIPELINE_VP_STATE_CREATE_INFO     vpStateCI;
-    XGL_PIPELINE_RS_STATE_CREATE_INFO     rsStateCI;
-    XGL_PIPELINE_MS_STATE_CREATE_INFO     msStateCI;
-    XGL_PIPELINE_CB_STATE_CREATE_INFO     cbStateCI;
-    XGL_PIPELINE_DS_STATE_CREATE_INFO     dsStateCI;
-    XGL_PIPELINE_SHADER_STAGE_CREATE_INFO vsCI;
-    XGL_PIPELINE_SHADER_STAGE_CREATE_INFO tcsCI;
-    XGL_PIPELINE_SHADER_STAGE_CREATE_INFO tesCI;
-    XGL_PIPELINE_SHADER_STAGE_CREATE_INFO gsCI;
-    XGL_PIPELINE_SHADER_STAGE_CREATE_INFO fsCI;
-    // Compute shader is include in XGL_COMPUTE_PIPELINE_CREATE_INFO
-    XGL_COMPUTE_PIPELINE_CREATE_INFO      computePipelineCI;
+    VK_GRAPHICS_PIPELINE_CREATE_INFO     graphicsPipelineCI;
+    VK_PIPELINE_VERTEX_INPUT_CREATE_INFO vertexInputCI;
+    VK_PIPELINE_IA_STATE_CREATE_INFO     iaStateCI;
+    VK_PIPELINE_TESS_STATE_CREATE_INFO   tessStateCI;
+    VK_PIPELINE_VP_STATE_CREATE_INFO     vpStateCI;
+    VK_PIPELINE_RS_STATE_CREATE_INFO     rsStateCI;
+    VK_PIPELINE_MS_STATE_CREATE_INFO     msStateCI;
+    VK_PIPELINE_CB_STATE_CREATE_INFO     cbStateCI;
+    VK_PIPELINE_DS_STATE_CREATE_INFO     dsStateCI;
+    VK_PIPELINE_SHADER_STAGE_CREATE_INFO vsCI;
+    VK_PIPELINE_SHADER_STAGE_CREATE_INFO tcsCI;
+    VK_PIPELINE_SHADER_STAGE_CREATE_INFO tesCI;
+    VK_PIPELINE_SHADER_STAGE_CREATE_INFO gsCI;
+    VK_PIPELINE_SHADER_STAGE_CREATE_INFO fsCI;
+    // Compute shader is include in VK_COMPUTE_PIPELINE_CREATE_INFO
+    VK_COMPUTE_PIPELINE_CREATE_INFO      computePipelineCI;
 
-    XGL_GRAPHICS_PIPELINE_CREATE_INFO*      pCreateTree; // Ptr to shadow of data in create tree
+    VK_GRAPHICS_PIPELINE_CREATE_INFO*      pCreateTree; // Ptr to shadow of data in create tree
     // Vtx input info (if any)
     uint32_t                                vtxBindingCount;   // number of bindings
-    XGL_VERTEX_INPUT_BINDING_DESCRIPTION*   pVertexBindingDescriptions;
+    VK_VERTEX_INPUT_BINDING_DESCRIPTION*   pVertexBindingDescriptions;
     uint32_t                                vtxAttributeCount; // number of attributes
-    XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* pVertexAttributeDescriptions;
+    VK_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* pVertexAttributeDescriptions;
     uint32_t                                attachmentCount;   // number of CB attachments
-    XGL_PIPELINE_CB_ATTACHMENT_STATE*       pAttachments;
+    VK_PIPELINE_CB_ATTACHMENT_STATE*       pAttachments;
 } PIPELINE_NODE;
 
 typedef struct _SAMPLER_NODE {
-    XGL_SAMPLER              sampler;
-    XGL_SAMPLER_CREATE_INFO  createInfo;
+    VK_SAMPLER              sampler;
+    VK_SAMPLER_CREATE_INFO  createInfo;
 } SAMPLER_NODE;
 
 typedef struct _IMAGE_NODE {
-    XGL_IMAGE_VIEW             image;
-    XGL_IMAGE_VIEW_CREATE_INFO createInfo;
-    XGL_IMAGE_VIEW_ATTACH_INFO attachInfo;
+    VK_IMAGE_VIEW             image;
+    VK_IMAGE_VIEW_CREATE_INFO createInfo;
+    VK_IMAGE_VIEW_ATTACH_INFO attachInfo;
 } IMAGE_NODE;
 
 typedef struct _BUFFER_NODE {
-    XGL_BUFFER_VIEW             buffer;
-    XGL_BUFFER_VIEW_CREATE_INFO createInfo;
-    XGL_BUFFER_VIEW_ATTACH_INFO attachInfo;
+    VK_BUFFER_VIEW             buffer;
+    VK_BUFFER_VIEW_CREATE_INFO createInfo;
+    VK_BUFFER_VIEW_ATTACH_INFO attachInfo;
 } BUFFER_NODE;
 
 typedef struct _DYNAMIC_STATE_NODE {
-    XGL_DYNAMIC_STATE_OBJECT    stateObj;
+    VK_DYNAMIC_STATE_OBJECT    stateObj;
     GENERIC_HEADER*             pCreateInfo;
     union {
-        XGL_DYNAMIC_VP_STATE_CREATE_INFO vpci;
-        XGL_DYNAMIC_RS_STATE_CREATE_INFO rsci;
-        XGL_DYNAMIC_CB_STATE_CREATE_INFO cbci;
-        XGL_DYNAMIC_DS_STATE_CREATE_INFO dsci;
+        VK_DYNAMIC_VP_STATE_CREATE_INFO vpci;
+        VK_DYNAMIC_RS_STATE_CREATE_INFO rsci;
+        VK_DYNAMIC_CB_STATE_CREATE_INFO cbci;
+        VK_DYNAMIC_DS_STATE_CREATE_INFO dsci;
     } create_info;
 } DYNAMIC_STATE_NODE;
 // Descriptor Data structures
 // Layout Node has the core layout data
 typedef struct _LAYOUT_NODE {
-    XGL_DESCRIPTOR_SET_LAYOUT                    layout;
-    XGL_DESCRIPTOR_TYPE*                         pTypes; // Dynamic array that will be created to verify descriptor types
-    XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO        createInfo;
+    VK_DESCRIPTOR_SET_LAYOUT                    layout;
+    VK_DESCRIPTOR_TYPE*                         pTypes; // Dynamic array that will be created to verify descriptor types
+    VK_DESCRIPTOR_SET_LAYOUT_CREATE_INFO        createInfo;
     uint32_t                                     startIndex; // 1st index of this layout
     uint32_t                                     endIndex; // last index of this layout
 } LAYOUT_NODE;
 typedef struct _SET_NODE {
-    XGL_DESCRIPTOR_SET                           set;
-    XGL_DESCRIPTOR_POOL                          pool;
-    XGL_DESCRIPTOR_SET_USAGE                     setUsage;
+    VK_DESCRIPTOR_SET                           set;
+    VK_DESCRIPTOR_POOL                          pool;
+    VK_DESCRIPTOR_SET_USAGE                     setUsage;
     // Head of LL of all Update structs for this set
     GENERIC_HEADER*                              pUpdateStructs;
     // Total num of descriptors in this set (count of its layout plus all prior layouts)
@@ -153,10 +153,10 @@
 } SET_NODE;
 
 typedef struct _POOL_NODE {
-    XGL_DESCRIPTOR_POOL                          pool;
-    XGL_DESCRIPTOR_POOL_USAGE                    poolUsage;
+    VK_DESCRIPTOR_POOL                          pool;
+    VK_DESCRIPTOR_POOL_USAGE                    poolUsage;
     uint32_t                                     maxSets;
-    XGL_DESCRIPTOR_POOL_CREATE_INFO              createInfo;
+    VK_DESCRIPTOR_POOL_CREATE_INFO              createInfo;
     bool32_t                                     updateActive; // Track if Pool is in an update block
     SET_NODE*                                    pSets; // Head of LL of sets for this Pool
 } POOL_NODE;
@@ -218,10 +218,10 @@
 } CB_STATE;
 // Cmd Buffer Wrapper Struct
 typedef struct _GLOBAL_CB_NODE {
-    XGL_CMD_BUFFER                  cmdBuffer;
+    VK_CMD_BUFFER                  cmdBuffer;
     uint32_t                        queueNodeIndex;
-    XGL_FLAGS                       flags;
-    XGL_FENCE                       fence;    // fence tracking this cmd buffer
+    VK_FLAGS                       flags;
+    VK_FENCE                       fence;    // fence tracking this cmd buffer
     uint64_t                        numCmds;  // number of cmds in this CB
     uint64_t                        drawCount[NUM_DRAW_TYPES]; // Count of each type of draw in this CB
     CB_STATE                        state; // Track if cmd buffer update status
@@ -229,12 +229,12 @@
     // Currently storing "lastBound" objects on per-CB basis
     //  long-term may want to create caches of "lastBound" states and could have
     //  each individual CMD_NODE referencing its own "lastBound" state
-    XGL_PIPELINE                    lastBoundPipeline;
+    VK_PIPELINE                    lastBoundPipeline;
     uint32_t                        lastVtxBinding;
-    DYNAMIC_STATE_NODE*             lastBoundDynamicState[XGL_NUM_STATE_BIND_POINT];
-    XGL_DESCRIPTOR_SET              lastBoundDescriptorSet;
-    XGL_RENDER_PASS                 activeRenderPass;
-    XGL_FRAMEBUFFER                 framebuffer;
+    DYNAMIC_STATE_NODE*             lastBoundDynamicState[VK_NUM_STATE_BIND_POINT];
+    VK_DESCRIPTOR_SET              lastBoundDescriptorSet;
+    VK_RENDER_PASS                 activeRenderPass;
+    VK_FRAMEBUFFER                 framebuffer;
 } GLOBAL_CB_NODE;
 
 //prototypes for extension functions
diff --git a/layers/glave_snapshot.c b/layers/glave_snapshot.c
index e757f2b..12caf3c 100644
--- a/layers/glave_snapshot.c
+++ b/layers/glave_snapshot.c
@@ -27,13 +27,13 @@
 #include <string.h>
 #include "loader_platform.h"
 #include "glave_snapshot.h"
-#include "xgl_struct_string_helper.h"
+#include "vk_struct_string_helper.h"
 
 #define LAYER_NAME_STR "GlaveSnapshot"
 #define LAYER_ABBREV_STR "GLVSnap"
 
-static XGL_LAYER_DISPATCH_TABLE nextTable;
-static XGL_BASE_LAYER_OBJECT *pCurObj;
+static VK_LAYER_DISPATCH_TABLE nextTable;
+static VK_BASE_LAYER_OBJECT *pCurObj;
 
 // The following is #included again to catch certain OS-specific functions being used:
 #include "loader_platform.h"
@@ -62,15 +62,15 @@
     memcpy(*ppDest, pSrc, size);
 }
 
-XGL_DEVICE_CREATE_INFO* glv_deepcopy_xgl_device_create_info(const XGL_DEVICE_CREATE_INFO* pSrcCreateInfo)
+VK_DEVICE_CREATE_INFO* glv_deepcopy_VK_DEVICE_CREATE_INFO(const VK_DEVICE_CREATE_INFO* pSrcCreateInfo)
 {
-    XGL_DEVICE_CREATE_INFO* pDestCreateInfo;
+    VK_DEVICE_CREATE_INFO* pDestCreateInfo;
 
-    // NOTE: partially duplicated code from add_XGL_DEVICE_CREATE_INFO_to_packet(...)
+    // NOTE: partially duplicated code from add_VK_DEVICE_CREATE_INFO_to_packet(...)
     {
         uint32_t i;
-        glv_vk_malloc_and_copy((void**)&pDestCreateInfo, sizeof(XGL_DEVICE_CREATE_INFO), pSrcCreateInfo);
-        glv_vk_malloc_and_copy((void**)&pDestCreateInfo->pRequestedQueues, pSrcCreateInfo->queueRecordCount*sizeof(XGL_DEVICE_QUEUE_CREATE_INFO), pSrcCreateInfo->pRequestedQueues);
+        glv_vk_malloc_and_copy((void**)&pDestCreateInfo, sizeof(VK_DEVICE_CREATE_INFO), pSrcCreateInfo);
+        glv_vk_malloc_and_copy((void**)&pDestCreateInfo->pRequestedQueues, pSrcCreateInfo->queueRecordCount*sizeof(VK_DEVICE_QUEUE_CREATE_INFO), pSrcCreateInfo->pRequestedQueues);
 
         if (pSrcCreateInfo->extensionCount > 0)
         {
@@ -80,29 +80,29 @@
                 glv_vk_malloc_and_copy((void**)&pDestCreateInfo->ppEnabledExtensionNames[i], strlen(pSrcCreateInfo->ppEnabledExtensionNames[i]) + 1, pSrcCreateInfo->ppEnabledExtensionNames[i]);
             }
         }
-        XGL_LAYER_CREATE_INFO *pSrcNext = ( XGL_LAYER_CREATE_INFO *) pSrcCreateInfo->pNext;
-        XGL_LAYER_CREATE_INFO **ppDstNext = ( XGL_LAYER_CREATE_INFO **) &pDestCreateInfo->pNext;
+        VK_LAYER_CREATE_INFO *pSrcNext = ( VK_LAYER_CREATE_INFO *) pSrcCreateInfo->pNext;
+        VK_LAYER_CREATE_INFO **ppDstNext = ( VK_LAYER_CREATE_INFO **) &pDestCreateInfo->pNext;
         while (pSrcNext != NULL)
         {
-            if ((pSrcNext->sType == XGL_STRUCTURE_TYPE_LAYER_CREATE_INFO) && pSrcNext->layerCount > 0)
+            if ((pSrcNext->sType == VK_STRUCTURE_TYPE_LAYER_CREATE_INFO) && pSrcNext->layerCount > 0)
             {
-                glv_vk_malloc_and_copy((void**)ppDstNext, sizeof(XGL_LAYER_CREATE_INFO), pSrcNext);
+                glv_vk_malloc_and_copy((void**)ppDstNext, sizeof(VK_LAYER_CREATE_INFO), pSrcNext);
                 glv_vk_malloc_and_copy((void**)&(*ppDstNext)->ppActiveLayerNames, pSrcNext->layerCount * sizeof(char*), pSrcNext->ppActiveLayerNames);
                 for (i = 0; i < pSrcNext->layerCount; i++)
                 {
                     glv_vk_malloc_and_copy((void**)&(*ppDstNext)->ppActiveLayerNames[i], strlen(pSrcNext->ppActiveLayerNames[i]) + 1, pSrcNext->ppActiveLayerNames[i]);
                 }
 
-                ppDstNext = (XGL_LAYER_CREATE_INFO**) &(*ppDstNext)->pNext;
+                ppDstNext = (VK_LAYER_CREATE_INFO**) &(*ppDstNext)->pNext;
             }
-            pSrcNext = (XGL_LAYER_CREATE_INFO*) pSrcNext->pNext;
+            pSrcNext = (VK_LAYER_CREATE_INFO*) pSrcNext->pNext;
         }
     }
 
     return pDestCreateInfo;
 }
 
-void glv_deepfree_xgl_device_create_info(XGL_DEVICE_CREATE_INFO* pCreateInfo)
+void glv_deepfree_VK_DEVICE_CREATE_INFO(VK_DEVICE_CREATE_INFO* pCreateInfo)
 {
     uint32_t i;
     if (pCreateInfo->pRequestedQueues != NULL)
@@ -119,11 +119,11 @@
         free((void*)pCreateInfo->ppEnabledExtensionNames);
     }
 
-    XGL_LAYER_CREATE_INFO *pSrcNext = (XGL_LAYER_CREATE_INFO*)pCreateInfo->pNext;
+    VK_LAYER_CREATE_INFO *pSrcNext = (VK_LAYER_CREATE_INFO*)pCreateInfo->pNext;
     while (pSrcNext != NULL)
     {
-        XGL_LAYER_CREATE_INFO* pTmp = (XGL_LAYER_CREATE_INFO*)pSrcNext->pNext;
-        if ((pSrcNext->sType == XGL_STRUCTURE_TYPE_LAYER_CREATE_INFO) && pSrcNext->layerCount > 0)
+        VK_LAYER_CREATE_INFO* pTmp = (VK_LAYER_CREATE_INFO*)pSrcNext->pNext;
+        if ((pSrcNext->sType == VK_STRUCTURE_TYPE_LAYER_CREATE_INFO) && pSrcNext->layerCount > 0)
         {
             for (i = 0; i < pSrcNext->layerCount; i++)
             {
@@ -139,21 +139,21 @@
     free(pCreateInfo);
 }
 
-void glv_vk_snapshot_copy_createdevice_params(GLV_VK_SNAPSHOT_CREATEDEVICE_PARAMS* pDest, XGL_PHYSICAL_GPU gpu, const XGL_DEVICE_CREATE_INFO* pCreateInfo, XGL_DEVICE* pDevice)
+void glv_vk_snapshot_copy_createdevice_params(GLV_VK_SNAPSHOT_CREATEDEVICE_PARAMS* pDest, VK_PHYSICAL_GPU gpu, const VK_DEVICE_CREATE_INFO* pCreateInfo, VK_DEVICE* pDevice)
 {
     pDest->gpu = gpu;
 
-    pDest->pCreateInfo = glv_deepcopy_xgl_device_create_info(pCreateInfo);
+    pDest->pCreateInfo = glv_deepcopy_VK_DEVICE_CREATE_INFO(pCreateInfo);
 
-    pDest->pDevice = (XGL_DEVICE*)malloc(sizeof(XGL_DEVICE));
+    pDest->pDevice = (VK_DEVICE*)malloc(sizeof(VK_DEVICE));
     *pDest->pDevice = *pDevice;
 }
 
 void glv_vk_snapshot_destroy_createdevice_params(GLV_VK_SNAPSHOT_CREATEDEVICE_PARAMS* pSrc)
 {
-    memset(&pSrc->gpu, 0, sizeof(XGL_PHYSICAL_GPU));
+    memset(&pSrc->gpu, 0, sizeof(VK_PHYSICAL_GPU));
 
-    glv_deepfree_xgl_device_create_info(pSrc->pCreateInfo);
+    glv_deepfree_VK_DEVICE_CREATE_INFO(pSrc->pCreateInfo);
     pSrc->pCreateInfo = NULL;
 
     free(pSrc->pDevice);
@@ -163,7 +163,7 @@
 
 
 // add a new node to the global and object lists, then return it so the caller can populate the object information.
-static GLV_VK_SNAPSHOT_LL_NODE* snapshot_insert_object(GLV_VK_SNAPSHOT* pSnapshot, void* pObject, XGL_OBJECT_TYPE type)
+static GLV_VK_SNAPSHOT_LL_NODE* snapshot_insert_object(GLV_VK_SNAPSHOT* pSnapshot, void* pObject, VK_OBJECT_TYPE type)
 {
     // Create a new node
     GLV_VK_SNAPSHOT_LL_NODE* pNewObjNode = (GLV_VK_SNAPSHOT_LL_NODE*)malloc(sizeof(GLV_VK_SNAPSHOT_LL_NODE));
@@ -188,7 +188,7 @@
 }
 
 // This is just a helper function to snapshot_remove_object(..). It is not intended for this to be called directly.
-static void snapshot_remove_obj_type(GLV_VK_SNAPSHOT* pSnapshot, void* pObj, XGL_OBJECT_TYPE objType) {
+static void snapshot_remove_obj_type(GLV_VK_SNAPSHOT* pSnapshot, void* pObj, VK_OBJECT_TYPE objType) {
     GLV_VK_SNAPSHOT_LL_NODE *pTrav = pSnapshot->pObjectHead[objType];
     GLV_VK_SNAPSHOT_LL_NODE *pPrev = pSnapshot->pObjectHead[objType];
     while (pTrav) {
@@ -207,8 +207,8 @@
         pTrav = pTrav->pNextObj;
     }
     char str[1024];
-    sprintf(str, "OBJ INTERNAL ERROR : Obj %p was in global list but not in %s list", pObj, string_XGL_OBJECT_TYPE(objType));
-    layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, pObj, 0, GLVSNAPSHOT_INTERNAL_ERROR, LAYER_ABBREV_STR, str);
+    sprintf(str, "OBJ INTERNAL ERROR : Obj %p was in global list but not in %s list", pObj, string_VK_OBJECT_TYPE(objType));
+    layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, pObj, 0, GLVSNAPSHOT_INTERNAL_ERROR, LAYER_ABBREV_STR, str);
 }
 
 // Search global list to find object,
@@ -245,12 +245,12 @@
     // Object not found.
     char str[1024];
     sprintf(str, "Object %p was not found in the created object list. It should be added as a deleted object.", pObject);
-    layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, pObject, 0, GLVSNAPSHOT_UNKNOWN_OBJECT, LAYER_ABBREV_STR, str);
+    layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, pObject, 0, GLVSNAPSHOT_UNKNOWN_OBJECT, LAYER_ABBREV_STR, str);
     return NULL;
 }
 
 // Add a new deleted object node to the list
-static void snapshot_insert_deleted_object(GLV_VK_SNAPSHOT* pSnapshot, void* pObject, XGL_OBJECT_TYPE type)
+static void snapshot_insert_deleted_object(GLV_VK_SNAPSHOT* pSnapshot, void* pObject, VK_OBJECT_TYPE type)
 {
     // Create a new node
     GLV_VK_SNAPSHOT_DELETED_OBJ_NODE* pNewObjNode = (GLV_VK_SNAPSHOT_DELETED_OBJ_NODE*)malloc(sizeof(GLV_VK_SNAPSHOT_DELETED_OBJ_NODE));
@@ -267,9 +267,9 @@
 }
 
 // Note: the parameters after pSnapshot match the order of vkCreateDevice(..)
-static void snapshot_insert_device(GLV_VK_SNAPSHOT* pSnapshot, XGL_PHYSICAL_GPU gpu, const XGL_DEVICE_CREATE_INFO* pCreateInfo, XGL_DEVICE* pDevice)
+static void snapshot_insert_device(GLV_VK_SNAPSHOT* pSnapshot, VK_PHYSICAL_GPU gpu, const VK_DEVICE_CREATE_INFO* pCreateInfo, VK_DEVICE* pDevice)
 {
-    GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(pSnapshot, *pDevice, XGL_OBJECT_TYPE_DEVICE);
+    GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(pSnapshot, *pDevice, VK_OBJECT_TYPE_DEVICE);
     pNode->obj.pStruct = malloc(sizeof(GLV_VK_SNAPSHOT_DEVICE_NODE));
 
     GLV_VK_SNAPSHOT_DEVICE_NODE* pDevNode = (GLV_VK_SNAPSHOT_DEVICE_NODE*)pNode->obj.pStruct;
@@ -283,7 +283,7 @@
     pSnapshot->deviceCount++;
 }
 
-static void snapshot_remove_device(GLV_VK_SNAPSHOT* pSnapshot, XGL_DEVICE device)
+static void snapshot_remove_device(GLV_VK_SNAPSHOT* pSnapshot, VK_DEVICE device)
 {
     GLV_VK_SNAPSHOT_LL_NODE* pFoundObject = snapshot_remove_object(pSnapshot, device);
 
@@ -327,11 +327,11 @@
 
     // If the code got here, then the device wasn't in the devices list.
     // That means we should add this device to the deleted items list.
-    snapshot_insert_deleted_object(&s_delta, device, XGL_OBJECT_TYPE_DEVICE);
+    snapshot_insert_deleted_object(&s_delta, device, VK_OBJECT_TYPE_DEVICE);
 }
 
 // Traverse global list and return type for given object
-static XGL_OBJECT_TYPE ll_get_obj_type(XGL_OBJECT object) {
+static VK_OBJECT_TYPE ll_get_obj_type(VK_OBJECT object) {
     GLV_VK_SNAPSHOT_LL_NODE *pTrav = s_delta.pGlobalObjs;
     while (pTrav) {
         if (pTrav->obj.pVkObject == object)
@@ -340,11 +340,11 @@
     }
     char str[1024];
     sprintf(str, "Attempting look-up on obj %p but it is NOT in the global list!", (void*)object);
-    layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, object, 0, GLVSNAPSHOT_MISSING_OBJECT, LAYER_ABBREV_STR, str);
-    return XGL_OBJECT_TYPE_UNKNOWN;
+    layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, object, 0, GLVSNAPSHOT_MISSING_OBJECT, LAYER_ABBREV_STR, str);
+    return VK_OBJECT_TYPE_UNKNOWN;
 }
 
-static void ll_increment_use_count(void* pObj, XGL_OBJECT_TYPE objType) {
+static void ll_increment_use_count(void* pObj, VK_OBJECT_TYPE objType) {
     GLV_VK_SNAPSHOT_LL_NODE *pTrav = s_delta.pObjectHead[objType];
     while (pTrav) {
         if (pTrav->obj.pVkObject == pObj) {
@@ -359,15 +359,15 @@
     // Instead, we need to make a list of referenced objects. When the delta is merged with a snapshot, we'll need
     // to confirm that the referenced objects actually exist in the snapshot; otherwise I guess the merge should fail.
     char str[1024];
-    sprintf(str, "Unable to increment count for obj %p, will add to list as %s type and increment count", pObj, string_XGL_OBJECT_TYPE(objType));
-    layerCbMsg(XGL_DBG_MSG_WARNING, XGL_VALIDATION_LEVEL_0, pObj, 0, GLVSNAPSHOT_UNKNOWN_OBJECT, LAYER_ABBREV_STR, str);
+    sprintf(str, "Unable to increment count for obj %p, will add to list as %s type and increment count", pObj, string_VK_OBJECT_TYPE(objType));
+    layerCbMsg(VK_DBG_MSG_WARNING, VK_VALIDATION_LEVEL_0, pObj, 0, GLVSNAPSHOT_UNKNOWN_OBJECT, LAYER_ABBREV_STR, str);
 
 //    ll_insert_obj(pObj, objType);
 //    ll_increment_use_count(pObj, objType);
 }
 
 // Set selected flag state for an object node
-static void set_status(void* pObj, XGL_OBJECT_TYPE objType, OBJECT_STATUS status_flag) {
+static void set_status(void* pObj, VK_OBJECT_TYPE objType, OBJECT_STATUS status_flag) {
     if (pObj != NULL) {
         GLV_VK_SNAPSHOT_LL_NODE *pTrav = s_delta.pObjectHead[objType];
         while (pTrav) {
@@ -380,24 +380,24 @@
 
         // If we do not find it print an error
         char str[1024];
-        sprintf(str, "Unable to set status for non-existent object %p of %s type", pObj, string_XGL_OBJECT_TYPE(objType));
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, pObj, 0, GLVSNAPSHOT_UNKNOWN_OBJECT, LAYER_ABBREV_STR, str);
+        sprintf(str, "Unable to set status for non-existent object %p of %s type", pObj, string_VK_OBJECT_TYPE(objType));
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, pObj, 0, GLVSNAPSHOT_UNKNOWN_OBJECT, LAYER_ABBREV_STR, str);
     }
 }
 
 // Track selected state for an object node
-static void track_object_status(void* pObj, XGL_STATE_BIND_POINT stateBindPoint) {
-    GLV_VK_SNAPSHOT_LL_NODE *pTrav = s_delta.pObjectHead[XGL_OBJECT_TYPE_CMD_BUFFER];
+static void track_object_status(void* pObj, VK_STATE_BIND_POINT stateBindPoint) {
+    GLV_VK_SNAPSHOT_LL_NODE *pTrav = s_delta.pObjectHead[VK_OBJECT_TYPE_CMD_BUFFER];
 
     while (pTrav) {
         if (pTrav->obj.pVkObject == pObj) {
-            if (stateBindPoint == XGL_STATE_BIND_VIEWPORT) {
+            if (stateBindPoint == VK_STATE_BIND_VIEWPORT) {
                 pTrav->obj.status |= OBJSTATUS_VIEWPORT_BOUND;
-            } else if (stateBindPoint == XGL_STATE_BIND_RASTER) {
+            } else if (stateBindPoint == VK_STATE_BIND_RASTER) {
                 pTrav->obj.status |= OBJSTATUS_RASTER_BOUND;
-            } else if (stateBindPoint == XGL_STATE_BIND_COLOR_BLEND) {
+            } else if (stateBindPoint == VK_STATE_BIND_COLOR_BLEND) {
                 pTrav->obj.status |= OBJSTATUS_COLOR_BLEND_BOUND;
-            } else if (stateBindPoint == XGL_STATE_BIND_DEPTH_STENCIL) {
+            } else if (stateBindPoint == VK_STATE_BIND_DEPTH_STENCIL) {
                 pTrav->obj.status |= OBJSTATUS_DEPTH_STENCIL_BOUND;
             }
             return;
@@ -408,11 +408,11 @@
     // If we do not find it print an error
     char str[1024];
     sprintf(str, "Unable to track status for non-existent Command Buffer object %p", pObj);
-    layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, pObj, 0, GLVSNAPSHOT_UNKNOWN_OBJECT, LAYER_ABBREV_STR, str);
+    layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, pObj, 0, GLVSNAPSHOT_UNKNOWN_OBJECT, LAYER_ABBREV_STR, str);
 }
 
 // Reset selected flag state for an object node
-static void reset_status(void* pObj, XGL_OBJECT_TYPE objType, OBJECT_STATUS status_flag) {
+static void reset_status(void* pObj, VK_OBJECT_TYPE objType, OBJECT_STATUS status_flag) {
     GLV_VK_SNAPSHOT_LL_NODE *pTrav = s_delta.pObjectHead[objType];
     while (pTrav) {
         if (pTrav->obj.pVkObject == pObj) {
@@ -424,11 +424,11 @@
 
     // If we do not find it print an error
     char str[1024];
-    sprintf(str, "Unable to reset status for non-existent object %p of %s type", pObj, string_XGL_OBJECT_TYPE(objType));
-    layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, pObj, 0, GLVSNAPSHOT_UNKNOWN_OBJECT, LAYER_ABBREV_STR, str);
+    sprintf(str, "Unable to reset status for non-existent object %p of %s type", pObj, string_VK_OBJECT_TYPE(objType));
+    layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, pObj, 0, GLVSNAPSHOT_UNKNOWN_OBJECT, LAYER_ABBREV_STR, str);
 }
 
-#include "xgl_dispatch_table_helper.h"
+#include "vk_dispatch_table_helper.h"
 static void initGlaveSnapshot(void)
 {
     const char *strOpt;
@@ -436,7 +436,7 @@
     getLayerOptionEnum(LAYER_NAME_STR "ReportLevel", (uint32_t *) &g_reportingLevel);
     g_actionIsDefault = getLayerOptionEnum(LAYER_NAME_STR "DebugAction", (uint32_t *) &g_debugAction);
 
-    if (g_debugAction & XGL_DBG_LAYER_ACTION_LOG_MSG)
+    if (g_debugAction & VK_DBG_LAYER_ACTION_LOG_MSG)
     {
         strOpt = getLayerOption(LAYER_NAME_STR "LogFilename");
         if (strOpt)
@@ -447,11 +447,11 @@
             g_logFile = stdout;
     }
 
-    xglGetProcAddrType fpNextGPA;
+    vkGetProcAddrType fpNextGPA;
     fpNextGPA = pCurObj->pGPA;
     assert(fpNextGPA);
 
-    layer_initialize_dispatch_table(&nextTable, fpNextGPA, (XGL_PHYSICAL_GPU) pCurObj->nextObject);
+    layer_initialize_dispatch_table(&nextTable, fpNextGPA, (VK_PHYSICAL_GPU) pCurObj->nextObject);
     if (!objLockInitialized)
     {
         // TODO/TBD: Need to delete this mutex sometime.  How???
@@ -463,49 +463,49 @@
 //=============================================================================
 // vulkan entrypoints
 //=============================================================================
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateInstance(const XGL_INSTANCE_CREATE_INFO* pCreateInfo, XGL_INSTANCE* pInstance)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateInstance(const VK_INSTANCE_CREATE_INFO* pCreateInfo, VK_INSTANCE* pInstance)
 {
-    XGL_RESULT result = nextTable.CreateInstance(pCreateInfo, pInstance);
+    VK_RESULT result = nextTable.CreateInstance(pCreateInfo, pInstance);
     loader_platform_thread_lock_mutex(&objLock);
-    snapshot_insert_object(&s_delta, *pInstance, XGL_OBJECT_TYPE_INSTANCE);
+    snapshot_insert_object(&s_delta, *pInstance, VK_OBJECT_TYPE_INSTANCE);
     loader_platform_thread_unlock_mutex(&objLock);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDestroyInstance(XGL_INSTANCE instance)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkDestroyInstance(VK_INSTANCE instance)
 {
-    XGL_RESULT result = nextTable.DestroyInstance(instance);
+    VK_RESULT result = nextTable.DestroyInstance(instance);
     loader_platform_thread_lock_mutex(&objLock);
     snapshot_remove_object(&s_delta, (void*)instance);
     loader_platform_thread_unlock_mutex(&objLock);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglEnumerateGpus(XGL_INSTANCE instance, uint32_t maxGpus, uint32_t* pGpuCount, XGL_PHYSICAL_GPU* pGpus)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkEnumerateGpus(VK_INSTANCE instance, uint32_t maxGpus, uint32_t* pGpuCount, VK_PHYSICAL_GPU* pGpus)
 {
     loader_platform_thread_lock_mutex(&objLock);
-    ll_increment_use_count((void*)instance, XGL_OBJECT_TYPE_INSTANCE);
+    ll_increment_use_count((void*)instance, VK_OBJECT_TYPE_INSTANCE);
     loader_platform_thread_unlock_mutex(&objLock);
-    XGL_RESULT result = nextTable.EnumerateGpus(instance, maxGpus, pGpuCount, pGpus);
+    VK_RESULT result = nextTable.EnumerateGpus(instance, maxGpus, pGpuCount, pGpus);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglGetGpuInfo(XGL_PHYSICAL_GPU gpu, XGL_PHYSICAL_GPU_INFO_TYPE infoType, size_t* pDataSize, void* pData)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkGetGpuInfo(VK_PHYSICAL_GPU gpu, VK_PHYSICAL_GPU_INFO_TYPE infoType, size_t* pDataSize, void* pData)
 {
-    XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) gpu;
+    VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
     pCurObj = gpuw;
     loader_platform_thread_once(&tabOnce, initGlaveSnapshot);
-    XGL_RESULT result = nextTable.GetGpuInfo((XGL_PHYSICAL_GPU)gpuw->nextObject, infoType, pDataSize, pData);
+    VK_RESULT result = nextTable.GetGpuInfo((VK_PHYSICAL_GPU)gpuw->nextObject, infoType, pDataSize, pData);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateDevice(XGL_PHYSICAL_GPU gpu, const XGL_DEVICE_CREATE_INFO* pCreateInfo, XGL_DEVICE* pDevice)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDevice(VK_PHYSICAL_GPU gpu, const VK_DEVICE_CREATE_INFO* pCreateInfo, VK_DEVICE* pDevice)
 {
-    XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) gpu;
+    VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
     pCurObj = gpuw;
     loader_platform_thread_once(&tabOnce, initGlaveSnapshot);
-    XGL_RESULT result = nextTable.CreateDevice((XGL_PHYSICAL_GPU)gpuw->nextObject, pCreateInfo, pDevice);
-    if (result == XGL_SUCCESS)
+    VK_RESULT result = nextTable.CreateDevice((VK_PHYSICAL_GPU)gpuw->nextObject, pCreateInfo, pDevice);
+    if (result == VK_SUCCESS)
     {
         loader_platform_thread_lock_mutex(&objLock);
         snapshot_insert_device(&s_delta, gpu, pCreateInfo, pDevice);
@@ -514,9 +514,9 @@
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDestroyDevice(XGL_DEVICE device)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkDestroyDevice(VK_DEVICE device)
 {
-    XGL_RESULT result = nextTable.DestroyDevice(device);
+    VK_RESULT result = nextTable.DestroyDevice(device);
     loader_platform_thread_lock_mutex(&objLock);
     snapshot_remove_device(&s_delta, device);
     loader_platform_thread_unlock_mutex(&objLock);
@@ -525,15 +525,15 @@
     GLV_VK_SNAPSHOT_LL_NODE *pTrav = s_delta.pGlobalObjs;
     while (pTrav != NULL)
     {
-        if (pTrav->obj.objType == XGL_OBJECT_TYPE_PRESENTABLE_IMAGE_MEMORY)
+        if (pTrav->obj.objType == VK_OBJECT_TYPE_PRESENTABLE_IMAGE_MEMORY)
         {
             GLV_VK_SNAPSHOT_LL_NODE *pDel = pTrav;
             pTrav = pTrav->pNextGlobal;
             snapshot_remove_object(&s_delta, (void*)(pDel->obj.pVkObject));
         } else {
             char str[1024];
-            sprintf(str, "OBJ ERROR : %s object %p has not been destroyed (was used %lu times).", string_XGL_OBJECT_TYPE(pTrav->obj.objType), pTrav->obj.pVkObject, pTrav->obj.numUses);
-            layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, device, 0, GLVSNAPSHOT_OBJECT_LEAK, LAYER_ABBREV_STR, str);
+            sprintf(str, "OBJ ERROR : %s object %p has not been destroyed (was used %lu times).", string_VK_OBJECT_TYPE(pTrav->obj.objType), pTrav->obj.pVkObject, pTrav->obj.numUses);
+            layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, device, 0, GLVSNAPSHOT_OBJECT_LEAK, LAYER_ABBREV_STR, str);
             pTrav = pTrav->pNextGlobal;
         }
     }
@@ -541,623 +541,623 @@
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglGetExtensionSupport(XGL_PHYSICAL_GPU gpu, const char* pExtName)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkGetExtensionSupport(VK_PHYSICAL_GPU gpu, const char* pExtName)
 {
-    XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) gpu;
+    VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
     loader_platform_thread_lock_mutex(&objLock);
-    ll_increment_use_count((void*)gpu, XGL_OBJECT_TYPE_PHYSICAL_GPU);
+    ll_increment_use_count((void*)gpu, VK_OBJECT_TYPE_PHYSICAL_GPU);
     loader_platform_thread_unlock_mutex(&objLock);
     pCurObj = gpuw;
     loader_platform_thread_once(&tabOnce, initGlaveSnapshot);
-    XGL_RESULT result = nextTable.GetExtensionSupport((XGL_PHYSICAL_GPU)gpuw->nextObject, pExtName);
+    VK_RESULT result = nextTable.GetExtensionSupport((VK_PHYSICAL_GPU)gpuw->nextObject, pExtName);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglEnumerateLayers(XGL_PHYSICAL_GPU gpu, size_t maxLayerCount, size_t maxStringSize, size_t* pOutLayerCount, char* const* pOutLayers, void* pReserved)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkEnumerateLayers(VK_PHYSICAL_GPU gpu, size_t maxLayerCount, size_t maxStringSize, size_t* pOutLayerCount, char* const* pOutLayers, void* pReserved)
 {
     if (gpu != NULL) {
-        XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) gpu;
+        VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
         loader_platform_thread_lock_mutex(&objLock);
-    ll_increment_use_count((void*)gpu, XGL_OBJECT_TYPE_PHYSICAL_GPU);
+    ll_increment_use_count((void*)gpu, VK_OBJECT_TYPE_PHYSICAL_GPU);
     loader_platform_thread_unlock_mutex(&objLock);
         pCurObj = gpuw;
         loader_platform_thread_once(&tabOnce, initGlaveSnapshot);
-        XGL_RESULT result = nextTable.EnumerateLayers((XGL_PHYSICAL_GPU)gpuw->nextObject, maxLayerCount, maxStringSize, pOutLayerCount, pOutLayers, pReserved);
+        VK_RESULT result = nextTable.EnumerateLayers((VK_PHYSICAL_GPU)gpuw->nextObject, maxLayerCount, maxStringSize, pOutLayerCount, pOutLayers, pReserved);
             return result;
     } else {
         if (pOutLayerCount == NULL || pOutLayers == NULL || pOutLayers[0] == NULL)
-            return XGL_ERROR_INVALID_POINTER;
+            return VK_ERROR_INVALID_POINTER;
         // This layer compatible with all GPUs
         *pOutLayerCount = 1;
         strncpy((char *) pOutLayers[0], LAYER_NAME_STR, maxStringSize);
-        return XGL_SUCCESS;
+        return VK_SUCCESS;
     }
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglGetDeviceQueue(XGL_DEVICE device, uint32_t queueNodeIndex, uint32_t queueIndex, XGL_QUEUE* pQueue)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkGetDeviceQueue(VK_DEVICE device, uint32_t queueNodeIndex, uint32_t queueIndex, VK_QUEUE* pQueue)
 {
     loader_platform_thread_lock_mutex(&objLock);
-    ll_increment_use_count((void*)device, XGL_OBJECT_TYPE_DEVICE);
+    ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE);
     loader_platform_thread_unlock_mutex(&objLock);
-    XGL_RESULT result = nextTable.GetDeviceQueue(device, queueNodeIndex, queueIndex, pQueue);
+    VK_RESULT result = nextTable.GetDeviceQueue(device, queueNodeIndex, queueIndex, pQueue);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglQueueSubmit(XGL_QUEUE queue, uint32_t cmdBufferCount, const XGL_CMD_BUFFER* pCmdBuffers, XGL_FENCE fence)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkQueueSubmit(VK_QUEUE queue, uint32_t cmdBufferCount, const VK_CMD_BUFFER* pCmdBuffers, VK_FENCE fence)
 {
-    set_status((void*)fence, XGL_OBJECT_TYPE_FENCE, OBJSTATUS_FENCE_IS_SUBMITTED);
-    XGL_RESULT result = nextTable.QueueSubmit(queue, cmdBufferCount, pCmdBuffers, fence);
+    set_status((void*)fence, VK_OBJECT_TYPE_FENCE, OBJSTATUS_FENCE_IS_SUBMITTED);
+    VK_RESULT result = nextTable.QueueSubmit(queue, cmdBufferCount, pCmdBuffers, fence);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglQueueWaitIdle(XGL_QUEUE queue)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkQueueWaitIdle(VK_QUEUE queue)
 {
-    XGL_RESULT result = nextTable.QueueWaitIdle(queue);
+    VK_RESULT result = nextTable.QueueWaitIdle(queue);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDeviceWaitIdle(XGL_DEVICE device)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkDeviceWaitIdle(VK_DEVICE device)
 {
     loader_platform_thread_lock_mutex(&objLock);
-    ll_increment_use_count((void*)device, XGL_OBJECT_TYPE_DEVICE);
+    ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE);
     loader_platform_thread_unlock_mutex(&objLock);
-    XGL_RESULT result = nextTable.DeviceWaitIdle(device);
+    VK_RESULT result = nextTable.DeviceWaitIdle(device);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglAllocMemory(XGL_DEVICE device, const XGL_MEMORY_ALLOC_INFO* pAllocInfo, XGL_GPU_MEMORY* pMem)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkAllocMemory(VK_DEVICE device, const VK_MEMORY_ALLOC_INFO* pAllocInfo, VK_GPU_MEMORY* pMem)
 {
     loader_platform_thread_lock_mutex(&objLock);
-    ll_increment_use_count((void*)device, XGL_OBJECT_TYPE_DEVICE);
+    ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE);
     loader_platform_thread_unlock_mutex(&objLock);
-    XGL_RESULT result = nextTable.AllocMemory(device, pAllocInfo, pMem);
-    if (result == XGL_SUCCESS)
+    VK_RESULT result = nextTable.AllocMemory(device, pAllocInfo, pMem);
+    if (result == VK_SUCCESS)
     {
         loader_platform_thread_lock_mutex(&objLock);
-        GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pMem, XGL_OBJECT_TYPE_GPU_MEMORY);
+        GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pMem, VK_OBJECT_TYPE_GPU_MEMORY);
         pNode->obj.pStruct = NULL;
         loader_platform_thread_unlock_mutex(&objLock);
     }
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglFreeMemory(XGL_GPU_MEMORY mem)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkFreeMemory(VK_GPU_MEMORY mem)
 {
-    XGL_RESULT result = nextTable.FreeMemory(mem);
+    VK_RESULT result = nextTable.FreeMemory(mem);
     loader_platform_thread_lock_mutex(&objLock);
     snapshot_remove_object(&s_delta, (void*)mem);
     loader_platform_thread_unlock_mutex(&objLock);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglSetMemoryPriority(XGL_GPU_MEMORY mem, XGL_MEMORY_PRIORITY priority)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkSetMemoryPriority(VK_GPU_MEMORY mem, VK_MEMORY_PRIORITY priority)
 {
     loader_platform_thread_lock_mutex(&objLock);
-    ll_increment_use_count((void*)mem, XGL_OBJECT_TYPE_GPU_MEMORY);
+    ll_increment_use_count((void*)mem, VK_OBJECT_TYPE_GPU_MEMORY);
     loader_platform_thread_unlock_mutex(&objLock);
-    XGL_RESULT result = nextTable.SetMemoryPriority(mem, priority);
+    VK_RESULT result = nextTable.SetMemoryPriority(mem, priority);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglMapMemory(XGL_GPU_MEMORY mem, XGL_FLAGS flags, void** ppData)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkMapMemory(VK_GPU_MEMORY mem, VK_FLAGS flags, void** ppData)
 {
     loader_platform_thread_lock_mutex(&objLock);
-    ll_increment_use_count((void*)mem, XGL_OBJECT_TYPE_GPU_MEMORY);
+    ll_increment_use_count((void*)mem, VK_OBJECT_TYPE_GPU_MEMORY);
     loader_platform_thread_unlock_mutex(&objLock);
-    set_status((void*)mem, XGL_OBJECT_TYPE_GPU_MEMORY, OBJSTATUS_GPU_MEM_MAPPED);
-    XGL_RESULT result = nextTable.MapMemory(mem, flags, ppData);
+    set_status((void*)mem, VK_OBJECT_TYPE_GPU_MEMORY, OBJSTATUS_GPU_MEM_MAPPED);
+    VK_RESULT result = nextTable.MapMemory(mem, flags, ppData);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglUnmapMemory(XGL_GPU_MEMORY mem)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkUnmapMemory(VK_GPU_MEMORY mem)
 {
     loader_platform_thread_lock_mutex(&objLock);
-    ll_increment_use_count((void*)mem, XGL_OBJECT_TYPE_GPU_MEMORY);
+    ll_increment_use_count((void*)mem, VK_OBJECT_TYPE_GPU_MEMORY);
     loader_platform_thread_unlock_mutex(&objLock);
-    reset_status((void*)mem, XGL_OBJECT_TYPE_GPU_MEMORY, OBJSTATUS_GPU_MEM_MAPPED);
-    XGL_RESULT result = nextTable.UnmapMemory(mem);
+    reset_status((void*)mem, VK_OBJECT_TYPE_GPU_MEMORY, OBJSTATUS_GPU_MEM_MAPPED);
+    VK_RESULT result = nextTable.UnmapMemory(mem);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglPinSystemMemory(XGL_DEVICE device, const void* pSysMem, size_t memSize, XGL_GPU_MEMORY* pMem)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkPinSystemMemory(VK_DEVICE device, const void* pSysMem, size_t memSize, VK_GPU_MEMORY* pMem)
 {
     loader_platform_thread_lock_mutex(&objLock);
-    ll_increment_use_count((void*)device, XGL_OBJECT_TYPE_DEVICE);
+    ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE);
     loader_platform_thread_unlock_mutex(&objLock);
-    XGL_RESULT result = nextTable.PinSystemMemory(device, pSysMem, memSize, pMem);
+    VK_RESULT result = nextTable.PinSystemMemory(device, pSysMem, memSize, pMem);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglGetMultiGpuCompatibility(XGL_PHYSICAL_GPU gpu0, XGL_PHYSICAL_GPU gpu1, XGL_GPU_COMPATIBILITY_INFO* pInfo)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkGetMultiGpuCompatibility(VK_PHYSICAL_GPU gpu0, VK_PHYSICAL_GPU gpu1, VK_GPU_COMPATIBILITY_INFO* pInfo)
 {
-    XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) gpu0;
+    VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu0;
     loader_platform_thread_lock_mutex(&objLock);
-    ll_increment_use_count((void*)gpu0, XGL_OBJECT_TYPE_PHYSICAL_GPU);
+    ll_increment_use_count((void*)gpu0, VK_OBJECT_TYPE_PHYSICAL_GPU);
     loader_platform_thread_unlock_mutex(&objLock);
     pCurObj = gpuw;
     loader_platform_thread_once(&tabOnce, initGlaveSnapshot);
-    XGL_RESULT result = nextTable.GetMultiGpuCompatibility((XGL_PHYSICAL_GPU)gpuw->nextObject, gpu1, pInfo);
+    VK_RESULT result = nextTable.GetMultiGpuCompatibility((VK_PHYSICAL_GPU)gpuw->nextObject, gpu1, pInfo);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglOpenSharedMemory(XGL_DEVICE device, const XGL_MEMORY_OPEN_INFO* pOpenInfo, XGL_GPU_MEMORY* pMem)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkOpenSharedMemory(VK_DEVICE device, const VK_MEMORY_OPEN_INFO* pOpenInfo, VK_GPU_MEMORY* pMem)
 {
     loader_platform_thread_lock_mutex(&objLock);
-    ll_increment_use_count((void*)device, XGL_OBJECT_TYPE_DEVICE);
+    ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE);
     loader_platform_thread_unlock_mutex(&objLock);
-    XGL_RESULT result = nextTable.OpenSharedMemory(device, pOpenInfo, pMem);
+    VK_RESULT result = nextTable.OpenSharedMemory(device, pOpenInfo, pMem);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglOpenSharedSemaphore(XGL_DEVICE device, const XGL_SEMAPHORE_OPEN_INFO* pOpenInfo, XGL_SEMAPHORE* pSemaphore)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkOpenSharedSemaphore(VK_DEVICE device, const VK_SEMAPHORE_OPEN_INFO* pOpenInfo, VK_SEMAPHORE* pSemaphore)
 {
     loader_platform_thread_lock_mutex(&objLock);
-    ll_increment_use_count((void*)device, XGL_OBJECT_TYPE_DEVICE);
+    ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE);
     loader_platform_thread_unlock_mutex(&objLock);
-    XGL_RESULT result = nextTable.OpenSharedSemaphore(device, pOpenInfo, pSemaphore);
+    VK_RESULT result = nextTable.OpenSharedSemaphore(device, pOpenInfo, pSemaphore);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglOpenPeerMemory(XGL_DEVICE device, const XGL_PEER_MEMORY_OPEN_INFO* pOpenInfo, XGL_GPU_MEMORY* pMem)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkOpenPeerMemory(VK_DEVICE device, const VK_PEER_MEMORY_OPEN_INFO* pOpenInfo, VK_GPU_MEMORY* pMem)
 {
     loader_platform_thread_lock_mutex(&objLock);
-    ll_increment_use_count((void*)device, XGL_OBJECT_TYPE_DEVICE);
+    ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE);
     loader_platform_thread_unlock_mutex(&objLock);
-    XGL_RESULT result = nextTable.OpenPeerMemory(device, pOpenInfo, pMem);
+    VK_RESULT result = nextTable.OpenPeerMemory(device, pOpenInfo, pMem);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglOpenPeerImage(XGL_DEVICE device, const XGL_PEER_IMAGE_OPEN_INFO* pOpenInfo, XGL_IMAGE* pImage, XGL_GPU_MEMORY* pMem)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkOpenPeerImage(VK_DEVICE device, const VK_PEER_IMAGE_OPEN_INFO* pOpenInfo, VK_IMAGE* pImage, VK_GPU_MEMORY* pMem)
 {
     loader_platform_thread_lock_mutex(&objLock);
-    ll_increment_use_count((void*)device, XGL_OBJECT_TYPE_DEVICE);
+    ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE);
     loader_platform_thread_unlock_mutex(&objLock);
-    XGL_RESULT result = nextTable.OpenPeerImage(device, pOpenInfo, pImage, pMem);
+    VK_RESULT result = nextTable.OpenPeerImage(device, pOpenInfo, pImage, pMem);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDestroyObject(XGL_OBJECT object)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkDestroyObject(VK_OBJECT object)
 {
-    XGL_RESULT result = nextTable.DestroyObject(object);
+    VK_RESULT result = nextTable.DestroyObject(object);
     loader_platform_thread_lock_mutex(&objLock);
     snapshot_remove_object(&s_delta, (void*)object);
     loader_platform_thread_unlock_mutex(&objLock);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglGetObjectInfo(XGL_BASE_OBJECT object, XGL_OBJECT_INFO_TYPE infoType, size_t* pDataSize, void* pData)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkGetObjectInfo(VK_BASE_OBJECT object, VK_OBJECT_INFO_TYPE infoType, size_t* pDataSize, void* pData)
 {
     loader_platform_thread_lock_mutex(&objLock);
     ll_increment_use_count((void*)object, ll_get_obj_type(object));
     loader_platform_thread_unlock_mutex(&objLock);
-    XGL_RESULT result = nextTable.GetObjectInfo(object, infoType, pDataSize, pData);
+    VK_RESULT result = nextTable.GetObjectInfo(object, infoType, pDataSize, pData);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglBindObjectMemory(XGL_OBJECT object, uint32_t allocationIdx, XGL_GPU_MEMORY mem, XGL_GPU_SIZE offset)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkBindObjectMemory(VK_OBJECT object, uint32_t allocationIdx, VK_GPU_MEMORY mem, VK_GPU_SIZE offset)
 {
     loader_platform_thread_lock_mutex(&objLock);
     ll_increment_use_count((void*)object, ll_get_obj_type(object));
     loader_platform_thread_unlock_mutex(&objLock);
-    XGL_RESULT result = nextTable.BindObjectMemory(object, allocationIdx, mem, offset);
+    VK_RESULT result = nextTable.BindObjectMemory(object, allocationIdx, mem, offset);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglBindObjectMemoryRange(XGL_OBJECT object, uint32_t allocationIdx, XGL_GPU_SIZE rangeOffset, XGL_GPU_SIZE rangeSize, XGL_GPU_MEMORY mem, XGL_GPU_SIZE memOffset)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkBindObjectMemoryRange(VK_OBJECT object, uint32_t allocationIdx, VK_GPU_SIZE rangeOffset, VK_GPU_SIZE rangeSize, VK_GPU_MEMORY mem, VK_GPU_SIZE memOffset)
 {
     loader_platform_thread_lock_mutex(&objLock);
     ll_increment_use_count((void*)object, ll_get_obj_type(object));
     loader_platform_thread_unlock_mutex(&objLock);
-    XGL_RESULT result = nextTable.BindObjectMemoryRange(object, allocationIdx, rangeOffset, rangeSize, mem, memOffset);
+    VK_RESULT result = nextTable.BindObjectMemoryRange(object, allocationIdx, rangeOffset, rangeSize, mem, memOffset);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglBindImageMemoryRange(XGL_IMAGE image, uint32_t allocationIdx, const XGL_IMAGE_MEMORY_BIND_INFO* bindInfo, XGL_GPU_MEMORY mem, XGL_GPU_SIZE memOffset)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkBindImageMemoryRange(VK_IMAGE image, uint32_t allocationIdx, const VK_IMAGE_MEMORY_BIND_INFO* bindInfo, VK_GPU_MEMORY mem, VK_GPU_SIZE memOffset)
 {
     loader_platform_thread_lock_mutex(&objLock);
-    ll_increment_use_count((void*)image, XGL_OBJECT_TYPE_IMAGE);
+    ll_increment_use_count((void*)image, VK_OBJECT_TYPE_IMAGE);
     loader_platform_thread_unlock_mutex(&objLock);
-    XGL_RESULT result = nextTable.BindImageMemoryRange(image, allocationIdx, bindInfo, mem, memOffset);
+    VK_RESULT result = nextTable.BindImageMemoryRange(image, allocationIdx, bindInfo, mem, memOffset);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateFence(XGL_DEVICE device, const XGL_FENCE_CREATE_INFO* pCreateInfo, XGL_FENCE* pFence)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateFence(VK_DEVICE device, const VK_FENCE_CREATE_INFO* pCreateInfo, VK_FENCE* pFence)
 {
     loader_platform_thread_lock_mutex(&objLock);
-    ll_increment_use_count((void*)device, XGL_OBJECT_TYPE_DEVICE);
+    ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE);
     loader_platform_thread_unlock_mutex(&objLock);
-    XGL_RESULT result = nextTable.CreateFence(device, pCreateInfo, pFence);
-    if (result == XGL_SUCCESS)
+    VK_RESULT result = nextTable.CreateFence(device, pCreateInfo, pFence);
+    if (result == VK_SUCCESS)
     {
         loader_platform_thread_lock_mutex(&objLock);
-        GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pFence, XGL_OBJECT_TYPE_FENCE);
+        GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pFence, VK_OBJECT_TYPE_FENCE);
         pNode->obj.pStruct = NULL;
         loader_platform_thread_unlock_mutex(&objLock);
     }
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglGetFenceStatus(XGL_FENCE fence)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkGetFenceStatus(VK_FENCE fence)
 {
     loader_platform_thread_lock_mutex(&objLock);
-    ll_increment_use_count((void*)fence, XGL_OBJECT_TYPE_FENCE);
+    ll_increment_use_count((void*)fence, VK_OBJECT_TYPE_FENCE);
     loader_platform_thread_unlock_mutex(&objLock);
     // Warn if submitted_flag is not set
-    XGL_RESULT result = nextTable.GetFenceStatus(fence);
+    VK_RESULT result = nextTable.GetFenceStatus(fence);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglWaitForFences(XGL_DEVICE device, uint32_t fenceCount, const XGL_FENCE* pFences, bool32_t waitAll, uint64_t timeout)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkWaitForFences(VK_DEVICE device, uint32_t fenceCount, const VK_FENCE* pFences, bool32_t waitAll, uint64_t timeout)
 {
     loader_platform_thread_lock_mutex(&objLock);
-    ll_increment_use_count((void*)device, XGL_OBJECT_TYPE_DEVICE);
+    ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE);
     loader_platform_thread_unlock_mutex(&objLock);
-    XGL_RESULT result = nextTable.WaitForFences(device, fenceCount, pFences, waitAll, timeout);
+    VK_RESULT result = nextTable.WaitForFences(device, fenceCount, pFences, waitAll, timeout);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateSemaphore(XGL_DEVICE device, const XGL_SEMAPHORE_CREATE_INFO* pCreateInfo, XGL_SEMAPHORE* pSemaphore)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateSemaphore(VK_DEVICE device, const VK_SEMAPHORE_CREATE_INFO* pCreateInfo, VK_SEMAPHORE* pSemaphore)
 {
     loader_platform_thread_lock_mutex(&objLock);
-    ll_increment_use_count((void*)device, XGL_OBJECT_TYPE_DEVICE);
+    ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE);
     loader_platform_thread_unlock_mutex(&objLock);
-    XGL_RESULT result = nextTable.CreateSemaphore(device, pCreateInfo, pSemaphore);
-    if (result == XGL_SUCCESS)
+    VK_RESULT result = nextTable.CreateSemaphore(device, pCreateInfo, pSemaphore);
+    if (result == VK_SUCCESS)
     {
         loader_platform_thread_lock_mutex(&objLock);
-        GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pSemaphore, XGL_OBJECT_TYPE_QUEUE_SEMAPHORE);
+        GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pSemaphore, VK_OBJECT_TYPE_QUEUE_SEMAPHORE);
         pNode->obj.pStruct = NULL;
         loader_platform_thread_unlock_mutex(&objLock);
     }
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglQueueSignalSemaphore(XGL_QUEUE queue, XGL_SEMAPHORE semaphore)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkQueueSignalSemaphore(VK_QUEUE queue, VK_SEMAPHORE semaphore)
 {
-    XGL_RESULT result = nextTable.QueueSignalSemaphore(queue, semaphore);
+    VK_RESULT result = nextTable.QueueSignalSemaphore(queue, semaphore);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglQueueWaitSemaphore(XGL_QUEUE queue, XGL_SEMAPHORE semaphore)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkQueueWaitSemaphore(VK_QUEUE queue, VK_SEMAPHORE semaphore)
 {
-    XGL_RESULT result = nextTable.QueueWaitSemaphore(queue, semaphore);
+    VK_RESULT result = nextTable.QueueWaitSemaphore(queue, semaphore);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateEvent(XGL_DEVICE device, const XGL_EVENT_CREATE_INFO* pCreateInfo, XGL_EVENT* pEvent)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateEvent(VK_DEVICE device, const VK_EVENT_CREATE_INFO* pCreateInfo, VK_EVENT* pEvent)
 {
     loader_platform_thread_lock_mutex(&objLock);
-    ll_increment_use_count((void*)device, XGL_OBJECT_TYPE_DEVICE);
+    ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE);
     loader_platform_thread_unlock_mutex(&objLock);
-    XGL_RESULT result = nextTable.CreateEvent(device, pCreateInfo, pEvent);
-    if (result == XGL_SUCCESS)
+    VK_RESULT result = nextTable.CreateEvent(device, pCreateInfo, pEvent);
+    if (result == VK_SUCCESS)
     {
         loader_platform_thread_lock_mutex(&objLock);
-        GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pEvent, XGL_OBJECT_TYPE_EVENT);
+        GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pEvent, VK_OBJECT_TYPE_EVENT);
         pNode->obj.pStruct = NULL;
         loader_platform_thread_unlock_mutex(&objLock);
     }
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglGetEventStatus(XGL_EVENT event)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkGetEventStatus(VK_EVENT event)
 {
     loader_platform_thread_lock_mutex(&objLock);
-    ll_increment_use_count((void*)event, XGL_OBJECT_TYPE_EVENT);
+    ll_increment_use_count((void*)event, VK_OBJECT_TYPE_EVENT);
     loader_platform_thread_unlock_mutex(&objLock);
-    XGL_RESULT result = nextTable.GetEventStatus(event);
+    VK_RESULT result = nextTable.GetEventStatus(event);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglSetEvent(XGL_EVENT event)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkSetEvent(VK_EVENT event)
 {
     loader_platform_thread_lock_mutex(&objLock);
-    ll_increment_use_count((void*)event, XGL_OBJECT_TYPE_EVENT);
+    ll_increment_use_count((void*)event, VK_OBJECT_TYPE_EVENT);
     loader_platform_thread_unlock_mutex(&objLock);
-    XGL_RESULT result = nextTable.SetEvent(event);
+    VK_RESULT result = nextTable.SetEvent(event);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglResetEvent(XGL_EVENT event)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkResetEvent(VK_EVENT event)
 {
     loader_platform_thread_lock_mutex(&objLock);
-    ll_increment_use_count((void*)event, XGL_OBJECT_TYPE_EVENT);
+    ll_increment_use_count((void*)event, VK_OBJECT_TYPE_EVENT);
     loader_platform_thread_unlock_mutex(&objLock);
-    XGL_RESULT result = nextTable.ResetEvent(event);
+    VK_RESULT result = nextTable.ResetEvent(event);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateQueryPool(XGL_DEVICE device, const XGL_QUERY_POOL_CREATE_INFO* pCreateInfo, XGL_QUERY_POOL* pQueryPool)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateQueryPool(VK_DEVICE device, const VK_QUERY_POOL_CREATE_INFO* pCreateInfo, VK_QUERY_POOL* pQueryPool)
 {
     loader_platform_thread_lock_mutex(&objLock);
-    ll_increment_use_count((void*)device, XGL_OBJECT_TYPE_DEVICE);
+    ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE);
     loader_platform_thread_unlock_mutex(&objLock);
-    XGL_RESULT result = nextTable.CreateQueryPool(device, pCreateInfo, pQueryPool);
-    if (result == XGL_SUCCESS)
+    VK_RESULT result = nextTable.CreateQueryPool(device, pCreateInfo, pQueryPool);
+    if (result == VK_SUCCESS)
     {
         loader_platform_thread_lock_mutex(&objLock);
-        GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pQueryPool, XGL_OBJECT_TYPE_QUERY_POOL);
+        GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pQueryPool, VK_OBJECT_TYPE_QUERY_POOL);
         pNode->obj.pStruct = NULL;
         loader_platform_thread_unlock_mutex(&objLock);
     }
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglGetQueryPoolResults(XGL_QUERY_POOL queryPool, uint32_t startQuery, uint32_t queryCount, size_t* pDataSize, void* pData)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkGetQueryPoolResults(VK_QUERY_POOL queryPool, uint32_t startQuery, uint32_t queryCount, size_t* pDataSize, void* pData)
 {
     loader_platform_thread_lock_mutex(&objLock);
-    ll_increment_use_count((void*)queryPool, XGL_OBJECT_TYPE_QUERY_POOL);
+    ll_increment_use_count((void*)queryPool, VK_OBJECT_TYPE_QUERY_POOL);
     loader_platform_thread_unlock_mutex(&objLock);
-    XGL_RESULT result = nextTable.GetQueryPoolResults(queryPool, startQuery, queryCount, pDataSize, pData);
+    VK_RESULT result = nextTable.GetQueryPoolResults(queryPool, startQuery, queryCount, pDataSize, pData);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglGetFormatInfo(XGL_DEVICE device, XGL_FORMAT format, XGL_FORMAT_INFO_TYPE infoType, size_t* pDataSize, void* pData)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkGetFormatInfo(VK_DEVICE device, VK_FORMAT format, VK_FORMAT_INFO_TYPE infoType, size_t* pDataSize, void* pData)
 {
     loader_platform_thread_lock_mutex(&objLock);
-    ll_increment_use_count((void*)device, XGL_OBJECT_TYPE_DEVICE);
+    ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE);
     loader_platform_thread_unlock_mutex(&objLock);
-    XGL_RESULT result = nextTable.GetFormatInfo(device, format, infoType, pDataSize, pData);
+    VK_RESULT result = nextTable.GetFormatInfo(device, format, infoType, pDataSize, pData);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateBuffer(XGL_DEVICE device, const XGL_BUFFER_CREATE_INFO* pCreateInfo, XGL_BUFFER* pBuffer)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateBuffer(VK_DEVICE device, const VK_BUFFER_CREATE_INFO* pCreateInfo, VK_BUFFER* pBuffer)
 {
     loader_platform_thread_lock_mutex(&objLock);
-    ll_increment_use_count((void*)device, XGL_OBJECT_TYPE_DEVICE);
+    ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE);
     loader_platform_thread_unlock_mutex(&objLock);
-    XGL_RESULT result = nextTable.CreateBuffer(device, pCreateInfo, pBuffer);
-    if (result == XGL_SUCCESS)
+    VK_RESULT result = nextTable.CreateBuffer(device, pCreateInfo, pBuffer);
+    if (result == VK_SUCCESS)
     {
         loader_platform_thread_lock_mutex(&objLock);
-        GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pBuffer, XGL_OBJECT_TYPE_BUFFER);
+        GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pBuffer, VK_OBJECT_TYPE_BUFFER);
         pNode->obj.pStruct = NULL;
         loader_platform_thread_unlock_mutex(&objLock);
     }
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateBufferView(XGL_DEVICE device, const XGL_BUFFER_VIEW_CREATE_INFO* pCreateInfo, XGL_BUFFER_VIEW* pView)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateBufferView(VK_DEVICE device, const VK_BUFFER_VIEW_CREATE_INFO* pCreateInfo, VK_BUFFER_VIEW* pView)
 {
     loader_platform_thread_lock_mutex(&objLock);
-    ll_increment_use_count((void*)device, XGL_OBJECT_TYPE_DEVICE);
+    ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE);
     loader_platform_thread_unlock_mutex(&objLock);
-    XGL_RESULT result = nextTable.CreateBufferView(device, pCreateInfo, pView);
-    if (result == XGL_SUCCESS)
+    VK_RESULT result = nextTable.CreateBufferView(device, pCreateInfo, pView);
+    if (result == VK_SUCCESS)
     {
         loader_platform_thread_lock_mutex(&objLock);
-        GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pView, XGL_OBJECT_TYPE_BUFFER_VIEW);
+        GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pView, VK_OBJECT_TYPE_BUFFER_VIEW);
         pNode->obj.pStruct = NULL;
         loader_platform_thread_unlock_mutex(&objLock);
     }
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateImage(XGL_DEVICE device, const XGL_IMAGE_CREATE_INFO* pCreateInfo, XGL_IMAGE* pImage)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateImage(VK_DEVICE device, const VK_IMAGE_CREATE_INFO* pCreateInfo, VK_IMAGE* pImage)
 {
     loader_platform_thread_lock_mutex(&objLock);
-    ll_increment_use_count((void*)device, XGL_OBJECT_TYPE_DEVICE);
+    ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE);
     loader_platform_thread_unlock_mutex(&objLock);
-    XGL_RESULT result = nextTable.CreateImage(device, pCreateInfo, pImage);
-    if (result == XGL_SUCCESS)
+    VK_RESULT result = nextTable.CreateImage(device, pCreateInfo, pImage);
+    if (result == VK_SUCCESS)
     {
         loader_platform_thread_lock_mutex(&objLock);
-        GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pImage, XGL_OBJECT_TYPE_IMAGE);
+        GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pImage, VK_OBJECT_TYPE_IMAGE);
         pNode->obj.pStruct = NULL;
         loader_platform_thread_unlock_mutex(&objLock);
     }
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglGetImageSubresourceInfo(XGL_IMAGE image, const XGL_IMAGE_SUBRESOURCE* pSubresource, XGL_SUBRESOURCE_INFO_TYPE infoType, size_t* pDataSize, void* pData)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkGetImageSubresourceInfo(VK_IMAGE image, const VK_IMAGE_SUBRESOURCE* pSubresource, VK_SUBRESOURCE_INFO_TYPE infoType, size_t* pDataSize, void* pData)
 {
     loader_platform_thread_lock_mutex(&objLock);
-    ll_increment_use_count((void*)image, XGL_OBJECT_TYPE_IMAGE);
+    ll_increment_use_count((void*)image, VK_OBJECT_TYPE_IMAGE);
     loader_platform_thread_unlock_mutex(&objLock);
-    XGL_RESULT result = nextTable.GetImageSubresourceInfo(image, pSubresource, infoType, pDataSize, pData);
+    VK_RESULT result = nextTable.GetImageSubresourceInfo(image, pSubresource, infoType, pDataSize, pData);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateImageView(XGL_DEVICE device, const XGL_IMAGE_VIEW_CREATE_INFO* pCreateInfo, XGL_IMAGE_VIEW* pView)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateImageView(VK_DEVICE device, const VK_IMAGE_VIEW_CREATE_INFO* pCreateInfo, VK_IMAGE_VIEW* pView)
 {
     loader_platform_thread_lock_mutex(&objLock);
-    ll_increment_use_count((void*)device, XGL_OBJECT_TYPE_DEVICE);
+    ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE);
     loader_platform_thread_unlock_mutex(&objLock);
-    XGL_RESULT result = nextTable.CreateImageView(device, pCreateInfo, pView);
-    if (result == XGL_SUCCESS)
+    VK_RESULT result = nextTable.CreateImageView(device, pCreateInfo, pView);
+    if (result == VK_SUCCESS)
     {
         loader_platform_thread_lock_mutex(&objLock);
-        GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pView, XGL_OBJECT_TYPE_IMAGE_VIEW);
+        GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pView, VK_OBJECT_TYPE_IMAGE_VIEW);
         pNode->obj.pStruct = NULL;
         loader_platform_thread_unlock_mutex(&objLock);
     }
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateColorAttachmentView(XGL_DEVICE device, const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pCreateInfo, XGL_COLOR_ATTACHMENT_VIEW* pView)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateColorAttachmentView(VK_DEVICE device, const VK_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pCreateInfo, VK_COLOR_ATTACHMENT_VIEW* pView)
 {
     loader_platform_thread_lock_mutex(&objLock);
-    ll_increment_use_count((void*)device, XGL_OBJECT_TYPE_DEVICE);
+    ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE);
     loader_platform_thread_unlock_mutex(&objLock);
-    XGL_RESULT result = nextTable.CreateColorAttachmentView(device, pCreateInfo, pView);
-    if (result == XGL_SUCCESS)
+    VK_RESULT result = nextTable.CreateColorAttachmentView(device, pCreateInfo, pView);
+    if (result == VK_SUCCESS)
     {
         loader_platform_thread_lock_mutex(&objLock);
-        GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pView, XGL_OBJECT_TYPE_COLOR_ATTACHMENT_VIEW);
+        GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pView, VK_OBJECT_TYPE_COLOR_ATTACHMENT_VIEW);
         pNode->obj.pStruct = NULL;
         loader_platform_thread_unlock_mutex(&objLock);
     }
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateDepthStencilView(XGL_DEVICE device, const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pCreateInfo, XGL_DEPTH_STENCIL_VIEW* pView)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDepthStencilView(VK_DEVICE device, const VK_DEPTH_STENCIL_VIEW_CREATE_INFO* pCreateInfo, VK_DEPTH_STENCIL_VIEW* pView)
 {
     loader_platform_thread_lock_mutex(&objLock);
-    ll_increment_use_count((void*)device, XGL_OBJECT_TYPE_DEVICE);
+    ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE);
     loader_platform_thread_unlock_mutex(&objLock);
-    XGL_RESULT result = nextTable.CreateDepthStencilView(device, pCreateInfo, pView);
-    if (result == XGL_SUCCESS)
+    VK_RESULT result = nextTable.CreateDepthStencilView(device, pCreateInfo, pView);
+    if (result == VK_SUCCESS)
     {
         loader_platform_thread_lock_mutex(&objLock);
-        GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pView, XGL_OBJECT_TYPE_DEPTH_STENCIL_VIEW);
+        GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pView, VK_OBJECT_TYPE_DEPTH_STENCIL_VIEW);
         pNode->obj.pStruct = NULL;
         loader_platform_thread_unlock_mutex(&objLock);
     }
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateShader(XGL_DEVICE device, const XGL_SHADER_CREATE_INFO* pCreateInfo, XGL_SHADER* pShader)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateShader(VK_DEVICE device, const VK_SHADER_CREATE_INFO* pCreateInfo, VK_SHADER* pShader)
 {
     loader_platform_thread_lock_mutex(&objLock);
-    ll_increment_use_count((void*)device, XGL_OBJECT_TYPE_DEVICE);
+    ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE);
     loader_platform_thread_unlock_mutex(&objLock);
-    XGL_RESULT result = nextTable.CreateShader(device, pCreateInfo, pShader);
-    if (result == XGL_SUCCESS)
+    VK_RESULT result = nextTable.CreateShader(device, pCreateInfo, pShader);
+    if (result == VK_SUCCESS)
     {
         loader_platform_thread_lock_mutex(&objLock);
-        GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pShader, XGL_OBJECT_TYPE_SHADER);
+        GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pShader, VK_OBJECT_TYPE_SHADER);
         pNode->obj.pStruct = NULL;
         loader_platform_thread_unlock_mutex(&objLock);
     }
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateGraphicsPipeline(XGL_DEVICE device, const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo, XGL_PIPELINE* pPipeline)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateGraphicsPipeline(VK_DEVICE device, const VK_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo, VK_PIPELINE* pPipeline)
 {
     loader_platform_thread_lock_mutex(&objLock);
-    ll_increment_use_count((void*)device, XGL_OBJECT_TYPE_DEVICE);
+    ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE);
     loader_platform_thread_unlock_mutex(&objLock);
-    XGL_RESULT result = nextTable.CreateGraphicsPipeline(device, pCreateInfo, pPipeline);
-    if (result == XGL_SUCCESS)
+    VK_RESULT result = nextTable.CreateGraphicsPipeline(device, pCreateInfo, pPipeline);
+    if (result == VK_SUCCESS)
     {
         loader_platform_thread_lock_mutex(&objLock);
-        GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pPipeline, XGL_OBJECT_TYPE_PIPELINE);
+        GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pPipeline, VK_OBJECT_TYPE_PIPELINE);
         pNode->obj.pStruct = NULL;
         loader_platform_thread_unlock_mutex(&objLock);
     }
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateComputePipeline(XGL_DEVICE device, const XGL_COMPUTE_PIPELINE_CREATE_INFO* pCreateInfo, XGL_PIPELINE* pPipeline)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateComputePipeline(VK_DEVICE device, const VK_COMPUTE_PIPELINE_CREATE_INFO* pCreateInfo, VK_PIPELINE* pPipeline)
 {
     loader_platform_thread_lock_mutex(&objLock);
-    ll_increment_use_count((void*)device, XGL_OBJECT_TYPE_DEVICE);
+    ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE);
     loader_platform_thread_unlock_mutex(&objLock);
-    XGL_RESULT result = nextTable.CreateComputePipeline(device, pCreateInfo, pPipeline);
-    if (result == XGL_SUCCESS)
+    VK_RESULT result = nextTable.CreateComputePipeline(device, pCreateInfo, pPipeline);
+    if (result == VK_SUCCESS)
     {
         loader_platform_thread_lock_mutex(&objLock);
-        GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pPipeline, XGL_OBJECT_TYPE_PIPELINE);
+        GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pPipeline, VK_OBJECT_TYPE_PIPELINE);
         pNode->obj.pStruct = NULL;
         loader_platform_thread_unlock_mutex(&objLock);
     }
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglStorePipeline(XGL_PIPELINE pipeline, size_t* pDataSize, void* pData)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkStorePipeline(VK_PIPELINE pipeline, size_t* pDataSize, void* pData)
 {
     loader_platform_thread_lock_mutex(&objLock);
-    ll_increment_use_count((void*)pipeline, XGL_OBJECT_TYPE_PIPELINE);
+    ll_increment_use_count((void*)pipeline, VK_OBJECT_TYPE_PIPELINE);
     loader_platform_thread_unlock_mutex(&objLock);
-    XGL_RESULT result = nextTable.StorePipeline(pipeline, pDataSize, pData);
+    VK_RESULT result = nextTable.StorePipeline(pipeline, pDataSize, pData);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglLoadPipeline(XGL_DEVICE device, size_t dataSize, const void* pData, XGL_PIPELINE* pPipeline)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkLoadPipeline(VK_DEVICE device, size_t dataSize, const void* pData, VK_PIPELINE* pPipeline)
 {
     loader_platform_thread_lock_mutex(&objLock);
-    ll_increment_use_count((void*)device, XGL_OBJECT_TYPE_DEVICE);
+    ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE);
     loader_platform_thread_unlock_mutex(&objLock);
-    XGL_RESULT result = nextTable.LoadPipeline(device, dataSize, pData, pPipeline);
+    VK_RESULT result = nextTable.LoadPipeline(device, dataSize, pData, pPipeline);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateSampler(XGL_DEVICE device, const XGL_SAMPLER_CREATE_INFO* pCreateInfo, XGL_SAMPLER* pSampler)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateSampler(VK_DEVICE device, const VK_SAMPLER_CREATE_INFO* pCreateInfo, VK_SAMPLER* pSampler)
 {
     loader_platform_thread_lock_mutex(&objLock);
-    ll_increment_use_count((void*)device, XGL_OBJECT_TYPE_DEVICE);
+    ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE);
     loader_platform_thread_unlock_mutex(&objLock);
-    XGL_RESULT result = nextTable.CreateSampler(device, pCreateInfo, pSampler);
-    if (result == XGL_SUCCESS)
+    VK_RESULT result = nextTable.CreateSampler(device, pCreateInfo, pSampler);
+    if (result == VK_SUCCESS)
     {
         loader_platform_thread_lock_mutex(&objLock);
-        GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pSampler, XGL_OBJECT_TYPE_SAMPLER);
+        GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pSampler, VK_OBJECT_TYPE_SAMPLER);
         pNode->obj.pStruct = NULL;
         loader_platform_thread_unlock_mutex(&objLock);
     }
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateDescriptorSetLayout( XGL_DEVICE device, const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pCreateInfo, XGL_DESCRIPTOR_SET_LAYOUT* pSetLayout)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDescriptorSetLayout( VK_DEVICE device, const VK_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pCreateInfo, VK_DESCRIPTOR_SET_LAYOUT* pSetLayout)
 {
     loader_platform_thread_lock_mutex(&objLock);
-    ll_increment_use_count((void*)device, XGL_OBJECT_TYPE_DEVICE);
+    ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE);
     loader_platform_thread_unlock_mutex(&objLock);
-    XGL_RESULT result = nextTable.CreateDescriptorSetLayout(device, pCreateInfo, pSetLayout);
-    if (result == XGL_SUCCESS)
+    VK_RESULT result = nextTable.CreateDescriptorSetLayout(device, pCreateInfo, pSetLayout);
+    if (result == VK_SUCCESS)
     {
         loader_platform_thread_lock_mutex(&objLock);
-        GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pSetLayout, XGL_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT);
+        GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pSetLayout, VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT);
         pNode->obj.pStruct = NULL;
         loader_platform_thread_unlock_mutex(&objLock);
     }
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglBeginDescriptorPoolUpdate(XGL_DEVICE device, XGL_DESCRIPTOR_UPDATE_MODE updateMode)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkBeginDescriptorPoolUpdate(VK_DEVICE device, VK_DESCRIPTOR_UPDATE_MODE updateMode)
 {
     loader_platform_thread_lock_mutex(&objLock);
-    ll_increment_use_count((void*)device, XGL_OBJECT_TYPE_DEVICE);
+    ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE);
     loader_platform_thread_unlock_mutex(&objLock);
-    XGL_RESULT result = nextTable.BeginDescriptorPoolUpdate(device, updateMode);
+    VK_RESULT result = nextTable.BeginDescriptorPoolUpdate(device, updateMode);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglEndDescriptorPoolUpdate(XGL_DEVICE device, XGL_CMD_BUFFER cmd)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkEndDescriptorPoolUpdate(VK_DEVICE device, VK_CMD_BUFFER cmd)
 {
     loader_platform_thread_lock_mutex(&objLock);
-    ll_increment_use_count((void*)device, XGL_OBJECT_TYPE_DEVICE);
+    ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE);
     loader_platform_thread_unlock_mutex(&objLock);
-    XGL_RESULT result = nextTable.EndDescriptorPoolUpdate(device, cmd);
+    VK_RESULT result = nextTable.EndDescriptorPoolUpdate(device, cmd);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateDescriptorPool(XGL_DEVICE device, XGL_DESCRIPTOR_POOL_USAGE poolUsage, uint32_t maxSets, const XGL_DESCRIPTOR_POOL_CREATE_INFO* pCreateInfo, XGL_DESCRIPTOR_POOL* pDescriptorPool)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDescriptorPool(VK_DEVICE device, VK_DESCRIPTOR_POOL_USAGE poolUsage, uint32_t maxSets, const VK_DESCRIPTOR_POOL_CREATE_INFO* pCreateInfo, VK_DESCRIPTOR_POOL* pDescriptorPool)
 {
     loader_platform_thread_lock_mutex(&objLock);
-    ll_increment_use_count((void*)device, XGL_OBJECT_TYPE_DEVICE);
+    ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE);
     loader_platform_thread_unlock_mutex(&objLock);
-    XGL_RESULT result = nextTable.CreateDescriptorPool(device, poolUsage, maxSets, pCreateInfo, pDescriptorPool);
-    if (result == XGL_SUCCESS)
+    VK_RESULT result = nextTable.CreateDescriptorPool(device, poolUsage, maxSets, pCreateInfo, pDescriptorPool);
+    if (result == VK_SUCCESS)
     {
         loader_platform_thread_lock_mutex(&objLock);
-        GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pDescriptorPool, XGL_OBJECT_TYPE_DESCRIPTOR_POOL);
+        GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pDescriptorPool, VK_OBJECT_TYPE_DESCRIPTOR_POOL);
         pNode->obj.pStruct = NULL;
         loader_platform_thread_unlock_mutex(&objLock);
     }
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglResetDescriptorPool(XGL_DESCRIPTOR_POOL descriptorPool)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkResetDescriptorPool(VK_DESCRIPTOR_POOL descriptorPool)
 {
     loader_platform_thread_lock_mutex(&objLock);
-    ll_increment_use_count((void*)descriptorPool, XGL_OBJECT_TYPE_DESCRIPTOR_POOL);
+    ll_increment_use_count((void*)descriptorPool, VK_OBJECT_TYPE_DESCRIPTOR_POOL);
     loader_platform_thread_unlock_mutex(&objLock);
-    XGL_RESULT result = nextTable.ResetDescriptorPool(descriptorPool);
+    VK_RESULT result = nextTable.ResetDescriptorPool(descriptorPool);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglAllocDescriptorSets(XGL_DESCRIPTOR_POOL descriptorPool, XGL_DESCRIPTOR_SET_USAGE setUsage, uint32_t count, const XGL_DESCRIPTOR_SET_LAYOUT* pSetLayouts, XGL_DESCRIPTOR_SET* pDescriptorSets, uint32_t* pCount)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkAllocDescriptorSets(VK_DESCRIPTOR_POOL descriptorPool, VK_DESCRIPTOR_SET_USAGE setUsage, uint32_t count, const VK_DESCRIPTOR_SET_LAYOUT* pSetLayouts, VK_DESCRIPTOR_SET* pDescriptorSets, uint32_t* pCount)
 {
     loader_platform_thread_lock_mutex(&objLock);
-    ll_increment_use_count((void*)descriptorPool, XGL_OBJECT_TYPE_DESCRIPTOR_POOL);
+    ll_increment_use_count((void*)descriptorPool, VK_OBJECT_TYPE_DESCRIPTOR_POOL);
     loader_platform_thread_unlock_mutex(&objLock);
-    XGL_RESULT result = nextTable.AllocDescriptorSets(descriptorPool, setUsage, count, pSetLayouts, pDescriptorSets, pCount);
-    if (result == XGL_SUCCESS)
+    VK_RESULT result = nextTable.AllocDescriptorSets(descriptorPool, setUsage, count, pSetLayouts, pDescriptorSets, pCount);
+    if (result == VK_SUCCESS)
     {
         for (uint32_t i = 0; i < *pCount; i++) {
             loader_platform_thread_lock_mutex(&objLock);
-            GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, pDescriptorSets[i], XGL_OBJECT_TYPE_DESCRIPTOR_SET);
+            GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, pDescriptorSets[i], VK_OBJECT_TYPE_DESCRIPTOR_SET);
             pNode->obj.pStruct = NULL;
             loader_platform_thread_unlock_mutex(&objLock);
         }
@@ -1165,468 +1165,468 @@
     return result;
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglClearDescriptorSets(XGL_DESCRIPTOR_POOL descriptorPool, uint32_t count, const XGL_DESCRIPTOR_SET* pDescriptorSets)
+VK_LAYER_EXPORT void VKAPI vkClearDescriptorSets(VK_DESCRIPTOR_POOL descriptorPool, uint32_t count, const VK_DESCRIPTOR_SET* pDescriptorSets)
 {
     loader_platform_thread_lock_mutex(&objLock);
-    ll_increment_use_count((void*)descriptorPool, XGL_OBJECT_TYPE_DESCRIPTOR_POOL);
+    ll_increment_use_count((void*)descriptorPool, VK_OBJECT_TYPE_DESCRIPTOR_POOL);
     loader_platform_thread_unlock_mutex(&objLock);
     nextTable.ClearDescriptorSets(descriptorPool, count, pDescriptorSets);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglUpdateDescriptors(XGL_DESCRIPTOR_SET descriptorSet, uint32_t updateCount, const void** ppUpdateArray)
+VK_LAYER_EXPORT void VKAPI vkUpdateDescriptors(VK_DESCRIPTOR_SET descriptorSet, uint32_t updateCount, const void** ppUpdateArray)
 {
     loader_platform_thread_lock_mutex(&objLock);
-    ll_increment_use_count((void*)descriptorSet, XGL_OBJECT_TYPE_DESCRIPTOR_SET);
+    ll_increment_use_count((void*)descriptorSet, VK_OBJECT_TYPE_DESCRIPTOR_SET);
     loader_platform_thread_unlock_mutex(&objLock);
     nextTable.UpdateDescriptors(descriptorSet, updateCount, ppUpdateArray);
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateDynamicViewportState(XGL_DEVICE device, const XGL_DYNAMIC_VP_STATE_CREATE_INFO* pCreateInfo, XGL_DYNAMIC_VP_STATE_OBJECT* pState)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDynamicViewportState(VK_DEVICE device, const VK_DYNAMIC_VP_STATE_CREATE_INFO* pCreateInfo, VK_DYNAMIC_VP_STATE_OBJECT* pState)
 {
     loader_platform_thread_lock_mutex(&objLock);
-    ll_increment_use_count((void*)device, XGL_OBJECT_TYPE_DEVICE);
+    ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE);
     loader_platform_thread_unlock_mutex(&objLock);
-    XGL_RESULT result = nextTable.CreateDynamicViewportState(device, pCreateInfo, pState);
-    if (result == XGL_SUCCESS)
+    VK_RESULT result = nextTable.CreateDynamicViewportState(device, pCreateInfo, pState);
+    if (result == VK_SUCCESS)
     {
         loader_platform_thread_lock_mutex(&objLock);
-        GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pState, XGL_OBJECT_TYPE_DYNAMIC_VP_STATE_OBJECT);
+        GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pState, VK_OBJECT_TYPE_DYNAMIC_VP_STATE_OBJECT);
         pNode->obj.pStruct = NULL;
         loader_platform_thread_unlock_mutex(&objLock);
     }
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateDynamicRasterState(XGL_DEVICE device, const XGL_DYNAMIC_RS_STATE_CREATE_INFO* pCreateInfo, XGL_DYNAMIC_RS_STATE_OBJECT* pState)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDynamicRasterState(VK_DEVICE device, const VK_DYNAMIC_RS_STATE_CREATE_INFO* pCreateInfo, VK_DYNAMIC_RS_STATE_OBJECT* pState)
 {
     loader_platform_thread_lock_mutex(&objLock);
-    ll_increment_use_count((void*)device, XGL_OBJECT_TYPE_DEVICE);
+    ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE);
     loader_platform_thread_unlock_mutex(&objLock);
-    XGL_RESULT result = nextTable.CreateDynamicRasterState(device, pCreateInfo, pState);
-    if (result == XGL_SUCCESS)
+    VK_RESULT result = nextTable.CreateDynamicRasterState(device, pCreateInfo, pState);
+    if (result == VK_SUCCESS)
     {
         loader_platform_thread_lock_mutex(&objLock);
-        GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pState, XGL_OBJECT_TYPE_DYNAMIC_RS_STATE_OBJECT);
+        GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pState, VK_OBJECT_TYPE_DYNAMIC_RS_STATE_OBJECT);
         pNode->obj.pStruct = NULL;
         loader_platform_thread_unlock_mutex(&objLock);
     }
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateDynamicColorBlendState(XGL_DEVICE device, const XGL_DYNAMIC_CB_STATE_CREATE_INFO* pCreateInfo, XGL_DYNAMIC_CB_STATE_OBJECT* pState)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDynamicColorBlendState(VK_DEVICE device, const VK_DYNAMIC_CB_STATE_CREATE_INFO* pCreateInfo, VK_DYNAMIC_CB_STATE_OBJECT* pState)
 {
     loader_platform_thread_lock_mutex(&objLock);
-    ll_increment_use_count((void*)device, XGL_OBJECT_TYPE_DEVICE);
+    ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE);
     loader_platform_thread_unlock_mutex(&objLock);
-    XGL_RESULT result = nextTable.CreateDynamicColorBlendState(device, pCreateInfo, pState);
-    if (result == XGL_SUCCESS)
+    VK_RESULT result = nextTable.CreateDynamicColorBlendState(device, pCreateInfo, pState);
+    if (result == VK_SUCCESS)
     {
         loader_platform_thread_lock_mutex(&objLock);
-        GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pState, XGL_OBJECT_TYPE_DYNAMIC_CB_STATE_OBJECT);
+        GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pState, VK_OBJECT_TYPE_DYNAMIC_CB_STATE_OBJECT);
         pNode->obj.pStruct = NULL;
         loader_platform_thread_unlock_mutex(&objLock);
     }
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateDynamicDepthStencilState(XGL_DEVICE device, const XGL_DYNAMIC_DS_STATE_CREATE_INFO* pCreateInfo, XGL_DYNAMIC_DS_STATE_OBJECT* pState)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDynamicDepthStencilState(VK_DEVICE device, const VK_DYNAMIC_DS_STATE_CREATE_INFO* pCreateInfo, VK_DYNAMIC_DS_STATE_OBJECT* pState)
 {
     loader_platform_thread_lock_mutex(&objLock);
-    ll_increment_use_count((void*)device, XGL_OBJECT_TYPE_DEVICE);
+    ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE);
     loader_platform_thread_unlock_mutex(&objLock);
-    XGL_RESULT result = nextTable.CreateDynamicDepthStencilState(device, pCreateInfo, pState);
-    if (result == XGL_SUCCESS)
+    VK_RESULT result = nextTable.CreateDynamicDepthStencilState(device, pCreateInfo, pState);
+    if (result == VK_SUCCESS)
     {
         loader_platform_thread_lock_mutex(&objLock);
-        GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pState, XGL_OBJECT_TYPE_DYNAMIC_DS_STATE_OBJECT);
+        GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pState, VK_OBJECT_TYPE_DYNAMIC_DS_STATE_OBJECT);
         pNode->obj.pStruct = NULL;
         loader_platform_thread_unlock_mutex(&objLock);
     }
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateCommandBuffer(XGL_DEVICE device, const XGL_CMD_BUFFER_CREATE_INFO* pCreateInfo, XGL_CMD_BUFFER* pCmdBuffer)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateCommandBuffer(VK_DEVICE device, const VK_CMD_BUFFER_CREATE_INFO* pCreateInfo, VK_CMD_BUFFER* pCmdBuffer)
 {
     loader_platform_thread_lock_mutex(&objLock);
-    ll_increment_use_count((void*)device, XGL_OBJECT_TYPE_DEVICE);
+    ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE);
     loader_platform_thread_unlock_mutex(&objLock);
-    XGL_RESULT result = nextTable.CreateCommandBuffer(device, pCreateInfo, pCmdBuffer);
-    if (result == XGL_SUCCESS)
+    VK_RESULT result = nextTable.CreateCommandBuffer(device, pCreateInfo, pCmdBuffer);
+    if (result == VK_SUCCESS)
     {
         loader_platform_thread_lock_mutex(&objLock);
-        GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pCmdBuffer, XGL_OBJECT_TYPE_CMD_BUFFER);
+        GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pCmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER);
         pNode->obj.pStruct = NULL;
         loader_platform_thread_unlock_mutex(&objLock);
     }
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglBeginCommandBuffer(XGL_CMD_BUFFER cmdBuffer, const XGL_CMD_BUFFER_BEGIN_INFO* pBeginInfo)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkBeginCommandBuffer(VK_CMD_BUFFER cmdBuffer, const VK_CMD_BUFFER_BEGIN_INFO* pBeginInfo)
 {
     loader_platform_thread_lock_mutex(&objLock);
-    ll_increment_use_count((void*)cmdBuffer, XGL_OBJECT_TYPE_CMD_BUFFER);
+    ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER);
     loader_platform_thread_unlock_mutex(&objLock);
-    XGL_RESULT result = nextTable.BeginCommandBuffer(cmdBuffer, pBeginInfo);
+    VK_RESULT result = nextTable.BeginCommandBuffer(cmdBuffer, pBeginInfo);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglEndCommandBuffer(XGL_CMD_BUFFER cmdBuffer)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkEndCommandBuffer(VK_CMD_BUFFER cmdBuffer)
 {
     loader_platform_thread_lock_mutex(&objLock);
-    ll_increment_use_count((void*)cmdBuffer, XGL_OBJECT_TYPE_CMD_BUFFER);
+    ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER);
     loader_platform_thread_unlock_mutex(&objLock);
-    reset_status((void*)cmdBuffer, XGL_OBJECT_TYPE_CMD_BUFFER, (OBJSTATUS_VIEWPORT_BOUND    |
+    reset_status((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER, (OBJSTATUS_VIEWPORT_BOUND    |
                                                                 OBJSTATUS_RASTER_BOUND      |
                                                                 OBJSTATUS_COLOR_BLEND_BOUND |
                                                                 OBJSTATUS_DEPTH_STENCIL_BOUND));
-    XGL_RESULT result = nextTable.EndCommandBuffer(cmdBuffer);
+    VK_RESULT result = nextTable.EndCommandBuffer(cmdBuffer);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglResetCommandBuffer(XGL_CMD_BUFFER cmdBuffer)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkResetCommandBuffer(VK_CMD_BUFFER cmdBuffer)
 {
     loader_platform_thread_lock_mutex(&objLock);
-    ll_increment_use_count((void*)cmdBuffer, XGL_OBJECT_TYPE_CMD_BUFFER);
+    ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER);
     loader_platform_thread_unlock_mutex(&objLock);
-    XGL_RESULT result = nextTable.ResetCommandBuffer(cmdBuffer);
+    VK_RESULT result = nextTable.ResetCommandBuffer(cmdBuffer);
     return result;
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdBindPipeline(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, XGL_PIPELINE pipeline)
+VK_LAYER_EXPORT void VKAPI vkCmdBindPipeline(VK_CMD_BUFFER cmdBuffer, VK_PIPELINE_BIND_POINT pipelineBindPoint, VK_PIPELINE pipeline)
 {
     loader_platform_thread_lock_mutex(&objLock);
-    ll_increment_use_count((void*)cmdBuffer, XGL_OBJECT_TYPE_CMD_BUFFER);
+    ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER);
     loader_platform_thread_unlock_mutex(&objLock);
     nextTable.CmdBindPipeline(cmdBuffer, pipelineBindPoint, pipeline);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdBindDynamicStateObject(XGL_CMD_BUFFER cmdBuffer, XGL_STATE_BIND_POINT stateBindPoint, XGL_DYNAMIC_STATE_OBJECT state)
+VK_LAYER_EXPORT void VKAPI vkCmdBindDynamicStateObject(VK_CMD_BUFFER cmdBuffer, VK_STATE_BIND_POINT stateBindPoint, VK_DYNAMIC_STATE_OBJECT state)
 {
     loader_platform_thread_lock_mutex(&objLock);
-    ll_increment_use_count((void*)cmdBuffer, XGL_OBJECT_TYPE_CMD_BUFFER);
+    ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER);
     loader_platform_thread_unlock_mutex(&objLock);
     track_object_status((void*)cmdBuffer, stateBindPoint);
     nextTable.CmdBindDynamicStateObject(cmdBuffer, stateBindPoint, state);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdBindDescriptorSets(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, XGL_DESCRIPTOR_SET_LAYOUT_CHAIN layoutChain, uint32_t layoutChainSlot, uint32_t count, const XGL_DESCRIPTOR_SET* pDescriptorSets, const uint32_t* pUserData)
+VK_LAYER_EXPORT void VKAPI vkCmdBindDescriptorSets(VK_CMD_BUFFER cmdBuffer, VK_PIPELINE_BIND_POINT pipelineBindPoint, VK_DESCRIPTOR_SET_LAYOUT_CHAIN layoutChain, uint32_t layoutChainSlot, uint32_t count, const VK_DESCRIPTOR_SET* pDescriptorSets, const uint32_t* pUserData)
 {
     loader_platform_thread_lock_mutex(&objLock);
-    ll_increment_use_count((void*)cmdBuffer, XGL_OBJECT_TYPE_CMD_BUFFER);
+    ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER);
     loader_platform_thread_unlock_mutex(&objLock);
     nextTable.CmdBindDescriptorSets(cmdBuffer, pipelineBindPoint, layoutChain, layoutChainSlot, count, pDescriptorSets, pUserData);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdBindVertexBuffer(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER buffer, XGL_GPU_SIZE offset, uint32_t binding)
+VK_LAYER_EXPORT void VKAPI vkCmdBindVertexBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFFER buffer, VK_GPU_SIZE offset, uint32_t binding)
 {
     loader_platform_thread_lock_mutex(&objLock);
-    ll_increment_use_count((void*)cmdBuffer, XGL_OBJECT_TYPE_CMD_BUFFER);
+    ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER);
     loader_platform_thread_unlock_mutex(&objLock);
     nextTable.CmdBindVertexBuffer(cmdBuffer, buffer, offset, binding);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdBindIndexBuffer(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER buffer, XGL_GPU_SIZE offset, XGL_INDEX_TYPE indexType)
+VK_LAYER_EXPORT void VKAPI vkCmdBindIndexBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFFER buffer, VK_GPU_SIZE offset, VK_INDEX_TYPE indexType)
 {
     loader_platform_thread_lock_mutex(&objLock);
-    ll_increment_use_count((void*)cmdBuffer, XGL_OBJECT_TYPE_CMD_BUFFER);
+    ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER);
     loader_platform_thread_unlock_mutex(&objLock);
     nextTable.CmdBindIndexBuffer(cmdBuffer, buffer, offset, indexType);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdDraw(XGL_CMD_BUFFER cmdBuffer, uint32_t firstVertex, uint32_t vertexCount, uint32_t firstInstance, uint32_t instanceCount)
+VK_LAYER_EXPORT void VKAPI vkCmdDraw(VK_CMD_BUFFER cmdBuffer, uint32_t firstVertex, uint32_t vertexCount, uint32_t firstInstance, uint32_t instanceCount)
 {
     loader_platform_thread_lock_mutex(&objLock);
-    ll_increment_use_count((void*)cmdBuffer, XGL_OBJECT_TYPE_CMD_BUFFER);
+    ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER);
     loader_platform_thread_unlock_mutex(&objLock);
     nextTable.CmdDraw(cmdBuffer, firstVertex, vertexCount, firstInstance, instanceCount);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdDrawIndexed(XGL_CMD_BUFFER cmdBuffer, uint32_t firstIndex, uint32_t indexCount, int32_t vertexOffset, uint32_t firstInstance, uint32_t instanceCount)
+VK_LAYER_EXPORT void VKAPI vkCmdDrawIndexed(VK_CMD_BUFFER cmdBuffer, uint32_t firstIndex, uint32_t indexCount, int32_t vertexOffset, uint32_t firstInstance, uint32_t instanceCount)
 {
     loader_platform_thread_lock_mutex(&objLock);
-    ll_increment_use_count((void*)cmdBuffer, XGL_OBJECT_TYPE_CMD_BUFFER);
+    ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER);
     loader_platform_thread_unlock_mutex(&objLock);
     nextTable.CmdDrawIndexed(cmdBuffer, firstIndex, indexCount, vertexOffset, firstInstance, instanceCount);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdDrawIndirect(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER buffer, XGL_GPU_SIZE offset, uint32_t count, uint32_t stride)
+VK_LAYER_EXPORT void VKAPI vkCmdDrawIndirect(VK_CMD_BUFFER cmdBuffer, VK_BUFFER buffer, VK_GPU_SIZE offset, uint32_t count, uint32_t stride)
 {
     loader_platform_thread_lock_mutex(&objLock);
-    ll_increment_use_count((void*)cmdBuffer, XGL_OBJECT_TYPE_CMD_BUFFER);
+    ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER);
     loader_platform_thread_unlock_mutex(&objLock);
     nextTable.CmdDrawIndirect(cmdBuffer, buffer, offset, count, stride);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdDrawIndexedIndirect(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER buffer, XGL_GPU_SIZE offset, uint32_t count, uint32_t stride)
+VK_LAYER_EXPORT void VKAPI vkCmdDrawIndexedIndirect(VK_CMD_BUFFER cmdBuffer, VK_BUFFER buffer, VK_GPU_SIZE offset, uint32_t count, uint32_t stride)
 {
     loader_platform_thread_lock_mutex(&objLock);
-    ll_increment_use_count((void*)cmdBuffer, XGL_OBJECT_TYPE_CMD_BUFFER);
+    ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER);
     loader_platform_thread_unlock_mutex(&objLock);
     nextTable.CmdDrawIndexedIndirect(cmdBuffer, buffer, offset, count, stride);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdDispatch(XGL_CMD_BUFFER cmdBuffer, uint32_t x, uint32_t y, uint32_t z)
+VK_LAYER_EXPORT void VKAPI vkCmdDispatch(VK_CMD_BUFFER cmdBuffer, uint32_t x, uint32_t y, uint32_t z)
 {
     loader_platform_thread_lock_mutex(&objLock);
-    ll_increment_use_count((void*)cmdBuffer, XGL_OBJECT_TYPE_CMD_BUFFER);
+    ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER);
     loader_platform_thread_unlock_mutex(&objLock);
     nextTable.CmdDispatch(cmdBuffer, x, y, z);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdDispatchIndirect(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER buffer, XGL_GPU_SIZE offset)
+VK_LAYER_EXPORT void VKAPI vkCmdDispatchIndirect(VK_CMD_BUFFER cmdBuffer, VK_BUFFER buffer, VK_GPU_SIZE offset)
 {
     loader_platform_thread_lock_mutex(&objLock);
-    ll_increment_use_count((void*)cmdBuffer, XGL_OBJECT_TYPE_CMD_BUFFER);
+    ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER);
     loader_platform_thread_unlock_mutex(&objLock);
     nextTable.CmdDispatchIndirect(cmdBuffer, buffer, offset);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdCopyBuffer(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER srcBuffer, XGL_BUFFER destBuffer, uint32_t regionCount, const XGL_BUFFER_COPY* pRegions)
+VK_LAYER_EXPORT void VKAPI vkCmdCopyBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFFER srcBuffer, VK_BUFFER destBuffer, uint32_t regionCount, const VK_BUFFER_COPY* pRegions)
 {
     loader_platform_thread_lock_mutex(&objLock);
-    ll_increment_use_count((void*)cmdBuffer, XGL_OBJECT_TYPE_CMD_BUFFER);
+    ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER);
     loader_platform_thread_unlock_mutex(&objLock);
     nextTable.CmdCopyBuffer(cmdBuffer, srcBuffer, destBuffer, regionCount, pRegions);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdCopyImage(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE srcImage, XGL_IMAGE_LAYOUT srcImageLayout, XGL_IMAGE destImage, XGL_IMAGE_LAYOUT destImageLayout, uint32_t regionCount, const XGL_IMAGE_COPY* pRegions)
+VK_LAYER_EXPORT void VKAPI vkCmdCopyImage(VK_CMD_BUFFER cmdBuffer, VK_IMAGE srcImage, VK_IMAGE_LAYOUT srcImageLayout, VK_IMAGE destImage, VK_IMAGE_LAYOUT destImageLayout, uint32_t regionCount, const VK_IMAGE_COPY* pRegions)
 {
     loader_platform_thread_lock_mutex(&objLock);
-    ll_increment_use_count((void*)cmdBuffer, XGL_OBJECT_TYPE_CMD_BUFFER);
+    ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER);
     loader_platform_thread_unlock_mutex(&objLock);
     nextTable.CmdCopyImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdCopyBufferToImage(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER srcBuffer, XGL_IMAGE destImage, XGL_IMAGE_LAYOUT destImageLayout, uint32_t regionCount, const XGL_BUFFER_IMAGE_COPY* pRegions)
+VK_LAYER_EXPORT void VKAPI vkCmdCopyBufferToImage(VK_CMD_BUFFER cmdBuffer, VK_BUFFER srcBuffer, VK_IMAGE destImage, VK_IMAGE_LAYOUT destImageLayout, uint32_t regionCount, const VK_BUFFER_IMAGE_COPY* pRegions)
 {
     loader_platform_thread_lock_mutex(&objLock);
-    ll_increment_use_count((void*)cmdBuffer, XGL_OBJECT_TYPE_CMD_BUFFER);
+    ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER);
     loader_platform_thread_unlock_mutex(&objLock);
     nextTable.CmdCopyBufferToImage(cmdBuffer, srcBuffer, destImage, destImageLayout, regionCount, pRegions);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdCopyImageToBuffer(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE srcImage, XGL_IMAGE_LAYOUT srcImageLayout, XGL_BUFFER destBuffer, uint32_t regionCount, const XGL_BUFFER_IMAGE_COPY* pRegions)
+VK_LAYER_EXPORT void VKAPI vkCmdCopyImageToBuffer(VK_CMD_BUFFER cmdBuffer, VK_IMAGE srcImage, VK_IMAGE_LAYOUT srcImageLayout, VK_BUFFER destBuffer, uint32_t regionCount, const VK_BUFFER_IMAGE_COPY* pRegions)
 {
     loader_platform_thread_lock_mutex(&objLock);
-    ll_increment_use_count((void*)cmdBuffer, XGL_OBJECT_TYPE_CMD_BUFFER);
+    ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER);
     loader_platform_thread_unlock_mutex(&objLock);
     nextTable.CmdCopyImageToBuffer(cmdBuffer, srcImage, srcImageLayout, destBuffer, regionCount, pRegions);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdCloneImageData(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE srcImage, XGL_IMAGE_LAYOUT srcImageLayout, XGL_IMAGE destImage, XGL_IMAGE_LAYOUT destImageLayout)
+VK_LAYER_EXPORT void VKAPI vkCmdCloneImageData(VK_CMD_BUFFER cmdBuffer, VK_IMAGE srcImage, VK_IMAGE_LAYOUT srcImageLayout, VK_IMAGE destImage, VK_IMAGE_LAYOUT destImageLayout)
 {
     loader_platform_thread_lock_mutex(&objLock);
-    ll_increment_use_count((void*)cmdBuffer, XGL_OBJECT_TYPE_CMD_BUFFER);
+    ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER);
     loader_platform_thread_unlock_mutex(&objLock);
     nextTable.CmdCloneImageData(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdUpdateBuffer(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER destBuffer, XGL_GPU_SIZE destOffset, XGL_GPU_SIZE dataSize, const uint32_t* pData)
+VK_LAYER_EXPORT void VKAPI vkCmdUpdateBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFFER destBuffer, VK_GPU_SIZE destOffset, VK_GPU_SIZE dataSize, const uint32_t* pData)
 {
     loader_platform_thread_lock_mutex(&objLock);
-    ll_increment_use_count((void*)cmdBuffer, XGL_OBJECT_TYPE_CMD_BUFFER);
+    ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER);
     loader_platform_thread_unlock_mutex(&objLock);
     nextTable.CmdUpdateBuffer(cmdBuffer, destBuffer, destOffset, dataSize, pData);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdFillBuffer(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER destBuffer, XGL_GPU_SIZE destOffset, XGL_GPU_SIZE fillSize, uint32_t data)
+VK_LAYER_EXPORT void VKAPI vkCmdFillBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFFER destBuffer, VK_GPU_SIZE destOffset, VK_GPU_SIZE fillSize, uint32_t data)
 {
     loader_platform_thread_lock_mutex(&objLock);
-    ll_increment_use_count((void*)cmdBuffer, XGL_OBJECT_TYPE_CMD_BUFFER);
+    ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER);
     loader_platform_thread_unlock_mutex(&objLock);
     nextTable.CmdFillBuffer(cmdBuffer, destBuffer, destOffset, fillSize, data);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdClearColorImage(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE image, XGL_IMAGE_LAYOUT imageLayout, XGL_CLEAR_COLOR color, uint32_t rangeCount, const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges)
+VK_LAYER_EXPORT void VKAPI vkCmdClearColorImage(VK_CMD_BUFFER cmdBuffer, VK_IMAGE image, VK_IMAGE_LAYOUT imageLayout, VK_CLEAR_COLOR color, uint32_t rangeCount, const VK_IMAGE_SUBRESOURCE_RANGE* pRanges)
 {
     loader_platform_thread_lock_mutex(&objLock);
-    ll_increment_use_count((void*)cmdBuffer, XGL_OBJECT_TYPE_CMD_BUFFER);
+    ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER);
     loader_platform_thread_unlock_mutex(&objLock);
     nextTable.CmdClearColorImage(cmdBuffer, image, imageLayout, color, rangeCount, pRanges);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdClearDepthStencil(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE image, XGL_IMAGE_LAYOUT imageLayout, float depth, uint32_t stencil, uint32_t rangeCount, const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges)
+VK_LAYER_EXPORT void VKAPI vkCmdClearDepthStencil(VK_CMD_BUFFER cmdBuffer, VK_IMAGE image, VK_IMAGE_LAYOUT imageLayout, float depth, uint32_t stencil, uint32_t rangeCount, const VK_IMAGE_SUBRESOURCE_RANGE* pRanges)
 {
     loader_platform_thread_lock_mutex(&objLock);
-    ll_increment_use_count((void*)cmdBuffer, XGL_OBJECT_TYPE_CMD_BUFFER);
+    ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER);
     loader_platform_thread_unlock_mutex(&objLock);
     nextTable.CmdClearDepthStencil(cmdBuffer, image, imageLayout, depth, stencil, rangeCount, pRanges);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdResolveImage(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE srcImage, XGL_IMAGE_LAYOUT srcImageLayout, XGL_IMAGE destImage, XGL_IMAGE_LAYOUT destImageLayout, uint32_t rectCount, const XGL_IMAGE_RESOLVE* pRects)
+VK_LAYER_EXPORT void VKAPI vkCmdResolveImage(VK_CMD_BUFFER cmdBuffer, VK_IMAGE srcImage, VK_IMAGE_LAYOUT srcImageLayout, VK_IMAGE destImage, VK_IMAGE_LAYOUT destImageLayout, uint32_t rectCount, const VK_IMAGE_RESOLVE* pRects)
 {
     loader_platform_thread_lock_mutex(&objLock);
-    ll_increment_use_count((void*)cmdBuffer, XGL_OBJECT_TYPE_CMD_BUFFER);
+    ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER);
     loader_platform_thread_unlock_mutex(&objLock);
     nextTable.CmdResolveImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, rectCount, pRects);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdSetEvent(XGL_CMD_BUFFER cmdBuffer, XGL_EVENT event, XGL_PIPE_EVENT pipeEvent)
+VK_LAYER_EXPORT void VKAPI vkCmdSetEvent(VK_CMD_BUFFER cmdBuffer, VK_EVENT event, VK_PIPE_EVENT pipeEvent)
 {
     loader_platform_thread_lock_mutex(&objLock);
-    ll_increment_use_count((void*)cmdBuffer, XGL_OBJECT_TYPE_CMD_BUFFER);
+    ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER);
     loader_platform_thread_unlock_mutex(&objLock);
     nextTable.CmdSetEvent(cmdBuffer, event, pipeEvent);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdResetEvent(XGL_CMD_BUFFER cmdBuffer, XGL_EVENT event, XGL_PIPE_EVENT pipeEvent)
+VK_LAYER_EXPORT void VKAPI vkCmdResetEvent(VK_CMD_BUFFER cmdBuffer, VK_EVENT event, VK_PIPE_EVENT pipeEvent)
 {
     loader_platform_thread_lock_mutex(&objLock);
-    ll_increment_use_count((void*)cmdBuffer, XGL_OBJECT_TYPE_CMD_BUFFER);
+    ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER);
     loader_platform_thread_unlock_mutex(&objLock);
     nextTable.CmdResetEvent(cmdBuffer, event, pipeEvent);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdWaitEvents(XGL_CMD_BUFFER cmdBuffer, const XGL_EVENT_WAIT_INFO* pWaitInfo)
+VK_LAYER_EXPORT void VKAPI vkCmdWaitEvents(VK_CMD_BUFFER cmdBuffer, const VK_EVENT_WAIT_INFO* pWaitInfo)
 {
     loader_platform_thread_lock_mutex(&objLock);
-    ll_increment_use_count((void*)cmdBuffer, XGL_OBJECT_TYPE_CMD_BUFFER);
+    ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER);
     loader_platform_thread_unlock_mutex(&objLock);
     nextTable.CmdWaitEvents(cmdBuffer, pWaitInfo);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdPipelineBarrier(XGL_CMD_BUFFER cmdBuffer, const XGL_PIPELINE_BARRIER* pBarrier)
+VK_LAYER_EXPORT void VKAPI vkCmdPipelineBarrier(VK_CMD_BUFFER cmdBuffer, const VK_PIPELINE_BARRIER* pBarrier)
 {
     loader_platform_thread_lock_mutex(&objLock);
-    ll_increment_use_count((void*)cmdBuffer, XGL_OBJECT_TYPE_CMD_BUFFER);
+    ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER);
     loader_platform_thread_unlock_mutex(&objLock);
     nextTable.CmdPipelineBarrier(cmdBuffer, pBarrier);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdBeginQuery(XGL_CMD_BUFFER cmdBuffer, XGL_QUERY_POOL queryPool, uint32_t slot, XGL_FLAGS flags)
+VK_LAYER_EXPORT void VKAPI vkCmdBeginQuery(VK_CMD_BUFFER cmdBuffer, VK_QUERY_POOL queryPool, uint32_t slot, VK_FLAGS flags)
 {
     loader_platform_thread_lock_mutex(&objLock);
-    ll_increment_use_count((void*)cmdBuffer, XGL_OBJECT_TYPE_CMD_BUFFER);
+    ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER);
     loader_platform_thread_unlock_mutex(&objLock);
     nextTable.CmdBeginQuery(cmdBuffer, queryPool, slot, flags);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdEndQuery(XGL_CMD_BUFFER cmdBuffer, XGL_QUERY_POOL queryPool, uint32_t slot)
+VK_LAYER_EXPORT void VKAPI vkCmdEndQuery(VK_CMD_BUFFER cmdBuffer, VK_QUERY_POOL queryPool, uint32_t slot)
 {
     loader_platform_thread_lock_mutex(&objLock);
-    ll_increment_use_count((void*)cmdBuffer, XGL_OBJECT_TYPE_CMD_BUFFER);
+    ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER);
     loader_platform_thread_unlock_mutex(&objLock);
     nextTable.CmdEndQuery(cmdBuffer, queryPool, slot);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdResetQueryPool(XGL_CMD_BUFFER cmdBuffer, XGL_QUERY_POOL queryPool, uint32_t startQuery, uint32_t queryCount)
+VK_LAYER_EXPORT void VKAPI vkCmdResetQueryPool(VK_CMD_BUFFER cmdBuffer, VK_QUERY_POOL queryPool, uint32_t startQuery, uint32_t queryCount)
 {
     loader_platform_thread_lock_mutex(&objLock);
-    ll_increment_use_count((void*)cmdBuffer, XGL_OBJECT_TYPE_CMD_BUFFER);
+    ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER);
     loader_platform_thread_unlock_mutex(&objLock);
     nextTable.CmdResetQueryPool(cmdBuffer, queryPool, startQuery, queryCount);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdWriteTimestamp(XGL_CMD_BUFFER cmdBuffer, XGL_TIMESTAMP_TYPE timestampType, XGL_BUFFER destBuffer, XGL_GPU_SIZE destOffset)
+VK_LAYER_EXPORT void VKAPI vkCmdWriteTimestamp(VK_CMD_BUFFER cmdBuffer, VK_TIMESTAMP_TYPE timestampType, VK_BUFFER destBuffer, VK_GPU_SIZE destOffset)
 {
     loader_platform_thread_lock_mutex(&objLock);
-    ll_increment_use_count((void*)cmdBuffer, XGL_OBJECT_TYPE_CMD_BUFFER);
+    ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER);
     loader_platform_thread_unlock_mutex(&objLock);
     nextTable.CmdWriteTimestamp(cmdBuffer, timestampType, destBuffer, destOffset);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdInitAtomicCounters(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, const uint32_t* pData)
+VK_LAYER_EXPORT void VKAPI vkCmdInitAtomicCounters(VK_CMD_BUFFER cmdBuffer, VK_PIPELINE_BIND_POINT pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, const uint32_t* pData)
 {
     loader_platform_thread_lock_mutex(&objLock);
-    ll_increment_use_count((void*)cmdBuffer, XGL_OBJECT_TYPE_CMD_BUFFER);
+    ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER);
     loader_platform_thread_unlock_mutex(&objLock);
     nextTable.CmdInitAtomicCounters(cmdBuffer, pipelineBindPoint, startCounter, counterCount, pData);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdLoadAtomicCounters(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, XGL_BUFFER srcBuffer, XGL_GPU_SIZE srcOffset)
+VK_LAYER_EXPORT void VKAPI vkCmdLoadAtomicCounters(VK_CMD_BUFFER cmdBuffer, VK_PIPELINE_BIND_POINT pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, VK_BUFFER srcBuffer, VK_GPU_SIZE srcOffset)
 {
     loader_platform_thread_lock_mutex(&objLock);
-    ll_increment_use_count((void*)cmdBuffer, XGL_OBJECT_TYPE_CMD_BUFFER);
+    ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER);
     loader_platform_thread_unlock_mutex(&objLock);
     nextTable.CmdLoadAtomicCounters(cmdBuffer, pipelineBindPoint, startCounter, counterCount, srcBuffer, srcOffset);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdSaveAtomicCounters(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, XGL_BUFFER destBuffer, XGL_GPU_SIZE destOffset)
+VK_LAYER_EXPORT void VKAPI vkCmdSaveAtomicCounters(VK_CMD_BUFFER cmdBuffer, VK_PIPELINE_BIND_POINT pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, VK_BUFFER destBuffer, VK_GPU_SIZE destOffset)
 {
     loader_platform_thread_lock_mutex(&objLock);
-    ll_increment_use_count((void*)cmdBuffer, XGL_OBJECT_TYPE_CMD_BUFFER);
+    ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER);
     loader_platform_thread_unlock_mutex(&objLock);
     nextTable.CmdSaveAtomicCounters(cmdBuffer, pipelineBindPoint, startCounter, counterCount, destBuffer, destOffset);
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateFramebuffer(XGL_DEVICE device, const XGL_FRAMEBUFFER_CREATE_INFO* pCreateInfo, XGL_FRAMEBUFFER* pFramebuffer)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateFramebuffer(VK_DEVICE device, const VK_FRAMEBUFFER_CREATE_INFO* pCreateInfo, VK_FRAMEBUFFER* pFramebuffer)
 {
     loader_platform_thread_lock_mutex(&objLock);
-    ll_increment_use_count((void*)device, XGL_OBJECT_TYPE_DEVICE);
+    ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE);
     loader_platform_thread_unlock_mutex(&objLock);
-    XGL_RESULT result = nextTable.CreateFramebuffer(device, pCreateInfo, pFramebuffer);
-    if (result == XGL_SUCCESS)
+    VK_RESULT result = nextTable.CreateFramebuffer(device, pCreateInfo, pFramebuffer);
+    if (result == VK_SUCCESS)
     {
         loader_platform_thread_lock_mutex(&objLock);
-        GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pFramebuffer, XGL_OBJECT_TYPE_FRAMEBUFFER);
+        GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pFramebuffer, VK_OBJECT_TYPE_FRAMEBUFFER);
         pNode->obj.pStruct = NULL;
         loader_platform_thread_unlock_mutex(&objLock);
     }
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateRenderPass(XGL_DEVICE device, const XGL_RENDER_PASS_CREATE_INFO* pCreateInfo, XGL_RENDER_PASS* pRenderPass)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateRenderPass(VK_DEVICE device, const VK_RENDER_PASS_CREATE_INFO* pCreateInfo, VK_RENDER_PASS* pRenderPass)
 {
     loader_platform_thread_lock_mutex(&objLock);
-    ll_increment_use_count((void*)device, XGL_OBJECT_TYPE_DEVICE);
+    ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE);
     loader_platform_thread_unlock_mutex(&objLock);
-    XGL_RESULT result = nextTable.CreateRenderPass(device, pCreateInfo, pRenderPass);
-    if (result == XGL_SUCCESS)
+    VK_RESULT result = nextTable.CreateRenderPass(device, pCreateInfo, pRenderPass);
+    if (result == VK_SUCCESS)
     {
         loader_platform_thread_lock_mutex(&objLock);
-        GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pRenderPass, XGL_OBJECT_TYPE_RENDER_PASS);
+        GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pRenderPass, VK_OBJECT_TYPE_RENDER_PASS);
         pNode->obj.pStruct = NULL;
         loader_platform_thread_unlock_mutex(&objLock);
     }
     return result;
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdBeginRenderPass(XGL_CMD_BUFFER cmdBuffer, const XGL_RENDER_PASS_BEGIN *pRenderPassBegin)
+VK_LAYER_EXPORT void VKAPI vkCmdBeginRenderPass(VK_CMD_BUFFER cmdBuffer, const VK_RENDER_PASS_BEGIN *pRenderPassBegin)
 {
     loader_platform_thread_lock_mutex(&objLock);
-    ll_increment_use_count((void*)cmdBuffer, XGL_OBJECT_TYPE_CMD_BUFFER);
+    ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER);
     loader_platform_thread_unlock_mutex(&objLock);
     nextTable.CmdBeginRenderPass(cmdBuffer, pRenderPassBegin);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdEndRenderPass(XGL_CMD_BUFFER cmdBuffer, XGL_RENDER_PASS renderPass)
+VK_LAYER_EXPORT void VKAPI vkCmdEndRenderPass(VK_CMD_BUFFER cmdBuffer, VK_RENDER_PASS renderPass)
 {
     loader_platform_thread_lock_mutex(&objLock);
-    ll_increment_use_count((void*)cmdBuffer, XGL_OBJECT_TYPE_CMD_BUFFER);
+    ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER);
     loader_platform_thread_unlock_mutex(&objLock);
     nextTable.CmdEndRenderPass(cmdBuffer, renderPass);
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDbgSetValidationLevel(XGL_DEVICE device, XGL_VALIDATION_LEVEL validationLevel)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkDbgSetValidationLevel(VK_DEVICE device, VK_VALIDATION_LEVEL validationLevel)
 {
     loader_platform_thread_lock_mutex(&objLock);
-    ll_increment_use_count((void*)device, XGL_OBJECT_TYPE_DEVICE);
+    ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE);
     loader_platform_thread_unlock_mutex(&objLock);
-    XGL_RESULT result = nextTable.DbgSetValidationLevel(device, validationLevel);
+    VK_RESULT result = nextTable.DbgSetValidationLevel(device, validationLevel);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDbgRegisterMsgCallback(XGL_INSTANCE instance, XGL_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback, void* pUserData)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkDbgRegisterMsgCallback(VK_INSTANCE instance, VK_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback, void* pUserData)
 {
     // This layer intercepts callbacks
-    XGL_LAYER_DBG_FUNCTION_NODE *pNewDbgFuncNode = (XGL_LAYER_DBG_FUNCTION_NODE*)malloc(sizeof(XGL_LAYER_DBG_FUNCTION_NODE));
+    VK_LAYER_DBG_FUNCTION_NODE *pNewDbgFuncNode = (VK_LAYER_DBG_FUNCTION_NODE*)malloc(sizeof(VK_LAYER_DBG_FUNCTION_NODE));
     if (!pNewDbgFuncNode)
-        return XGL_ERROR_OUT_OF_MEMORY;
+        return VK_ERROR_OUT_OF_MEMORY;
     pNewDbgFuncNode->pfnMsgCallback = pfnMsgCallback;
     pNewDbgFuncNode->pUserData = pUserData;
     pNewDbgFuncNode->pNext = g_pDbgFunctionHead;
     g_pDbgFunctionHead = pNewDbgFuncNode;
     // force callbacks if DebugAction hasn't been set already other than initial value
     if (g_actionIsDefault) {
-        g_debugAction = XGL_DBG_LAYER_ACTION_CALLBACK;
-    }    XGL_RESULT result = nextTable.DbgRegisterMsgCallback(instance, pfnMsgCallback, pUserData);
+        g_debugAction = VK_DBG_LAYER_ACTION_CALLBACK;
+    }    VK_RESULT result = nextTable.DbgRegisterMsgCallback(instance, pfnMsgCallback, pUserData);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDbgUnregisterMsgCallback(XGL_INSTANCE instance, XGL_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkDbgUnregisterMsgCallback(VK_INSTANCE instance, VK_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback)
 {
-    XGL_LAYER_DBG_FUNCTION_NODE *pTrav = g_pDbgFunctionHead;
-    XGL_LAYER_DBG_FUNCTION_NODE *pPrev = pTrav;
+    VK_LAYER_DBG_FUNCTION_NODE *pTrav = g_pDbgFunctionHead;
+    VK_LAYER_DBG_FUNCTION_NODE *pPrev = pTrav;
     while (pTrav) {
         if (pTrav->pfnMsgCallback == pfnMsgCallback) {
             pPrev->pNext = pTrav->pNext;
@@ -1641,101 +1641,101 @@
     if (g_pDbgFunctionHead == NULL)
     {
         if (g_actionIsDefault)
-            g_debugAction = XGL_DBG_LAYER_ACTION_LOG_MSG;
+            g_debugAction = VK_DBG_LAYER_ACTION_LOG_MSG;
         else
-            g_debugAction &= ~XGL_DBG_LAYER_ACTION_CALLBACK;
+            g_debugAction &= ~VK_DBG_LAYER_ACTION_CALLBACK;
     }
-    XGL_RESULT result = nextTable.DbgUnregisterMsgCallback(instance, pfnMsgCallback);
+    VK_RESULT result = nextTable.DbgUnregisterMsgCallback(instance, pfnMsgCallback);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDbgSetMessageFilter(XGL_DEVICE device, int32_t msgCode, XGL_DBG_MSG_FILTER filter)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkDbgSetMessageFilter(VK_DEVICE device, int32_t msgCode, VK_DBG_MSG_FILTER filter)
 {
     loader_platform_thread_lock_mutex(&objLock);
-    ll_increment_use_count((void*)device, XGL_OBJECT_TYPE_DEVICE);
+    ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE);
     loader_platform_thread_unlock_mutex(&objLock);
-    XGL_RESULT result = nextTable.DbgSetMessageFilter(device, msgCode, filter);
+    VK_RESULT result = nextTable.DbgSetMessageFilter(device, msgCode, filter);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDbgSetObjectTag(XGL_BASE_OBJECT object, size_t tagSize, const void* pTag)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkDbgSetObjectTag(VK_BASE_OBJECT object, size_t tagSize, const void* pTag)
 {
     loader_platform_thread_lock_mutex(&objLock);
     ll_increment_use_count((void*)object, ll_get_obj_type(object));
     loader_platform_thread_unlock_mutex(&objLock);
-    XGL_RESULT result = nextTable.DbgSetObjectTag(object, tagSize, pTag);
+    VK_RESULT result = nextTable.DbgSetObjectTag(object, tagSize, pTag);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDbgSetGlobalOption(XGL_INSTANCE instance, XGL_DBG_GLOBAL_OPTION dbgOption, size_t dataSize, const void* pData)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkDbgSetGlobalOption(VK_INSTANCE instance, VK_DBG_GLOBAL_OPTION dbgOption, size_t dataSize, const void* pData)
 {
-    XGL_RESULT result = nextTable.DbgSetGlobalOption(instance, dbgOption, dataSize, pData);
+    VK_RESULT result = nextTable.DbgSetGlobalOption(instance, dbgOption, dataSize, pData);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDbgSetDeviceOption(XGL_DEVICE device, XGL_DBG_DEVICE_OPTION dbgOption, size_t dataSize, const void* pData)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkDbgSetDeviceOption(VK_DEVICE device, VK_DBG_DEVICE_OPTION dbgOption, size_t dataSize, const void* pData)
 {
     loader_platform_thread_lock_mutex(&objLock);
-    ll_increment_use_count((void*)device, XGL_OBJECT_TYPE_DEVICE);
+    ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE);
     loader_platform_thread_unlock_mutex(&objLock);
-    XGL_RESULT result = nextTable.DbgSetDeviceOption(device, dbgOption, dataSize, pData);
+    VK_RESULT result = nextTable.DbgSetDeviceOption(device, dbgOption, dataSize, pData);
     return result;
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdDbgMarkerBegin(XGL_CMD_BUFFER cmdBuffer, const char* pMarker)
+VK_LAYER_EXPORT void VKAPI vkCmdDbgMarkerBegin(VK_CMD_BUFFER cmdBuffer, const char* pMarker)
 {
     loader_platform_thread_lock_mutex(&objLock);
-    ll_increment_use_count((void*)cmdBuffer, XGL_OBJECT_TYPE_CMD_BUFFER);
+    ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER);
     loader_platform_thread_unlock_mutex(&objLock);
     nextTable.CmdDbgMarkerBegin(cmdBuffer, pMarker);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdDbgMarkerEnd(XGL_CMD_BUFFER cmdBuffer)
+VK_LAYER_EXPORT void VKAPI vkCmdDbgMarkerEnd(VK_CMD_BUFFER cmdBuffer)
 {
     loader_platform_thread_lock_mutex(&objLock);
-    ll_increment_use_count((void*)cmdBuffer, XGL_OBJECT_TYPE_CMD_BUFFER);
+    ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER);
     loader_platform_thread_unlock_mutex(&objLock);
     nextTable.CmdDbgMarkerEnd(cmdBuffer);
 }
 
 #if defined(__linux__) || defined(XCB_NVIDIA)
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglWsiX11AssociateConnection(XGL_PHYSICAL_GPU gpu, const XGL_WSI_X11_CONNECTION_INFO* pConnectionInfo)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkWsiX11AssociateConnection(VK_PHYSICAL_GPU gpu, const VK_WSI_X11_CONNECTION_INFO* pConnectionInfo)
 {
-    XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) gpu;
+    VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
     loader_platform_thread_lock_mutex(&objLock);
-    ll_increment_use_count((void*)gpu, XGL_OBJECT_TYPE_PHYSICAL_GPU);
+    ll_increment_use_count((void*)gpu, VK_OBJECT_TYPE_PHYSICAL_GPU);
     loader_platform_thread_unlock_mutex(&objLock);
     pCurObj = gpuw;
     loader_platform_thread_once(&tabOnce, initGlaveSnapshot);
-    XGL_RESULT result = nextTable.WsiX11AssociateConnection((XGL_PHYSICAL_GPU)gpuw->nextObject, pConnectionInfo);
+    VK_RESULT result = nextTable.WsiX11AssociateConnection((VK_PHYSICAL_GPU)gpuw->nextObject, pConnectionInfo);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglWsiX11GetMSC(XGL_DEVICE device, xcb_window_t window, xcb_randr_crtc_t crtc, uint64_t* pMsc)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkWsiX11GetMSC(VK_DEVICE device, xcb_window_t window, xcb_randr_crtc_t crtc, uint64_t* pMsc)
 {
     loader_platform_thread_lock_mutex(&objLock);
-    ll_increment_use_count((void*)device, XGL_OBJECT_TYPE_DEVICE);
+    ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE);
     loader_platform_thread_unlock_mutex(&objLock);
-    XGL_RESULT result = nextTable.WsiX11GetMSC(device, window, crtc, pMsc);
+    VK_RESULT result = nextTable.WsiX11GetMSC(device, window, crtc, pMsc);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglWsiX11CreatePresentableImage(XGL_DEVICE device, const XGL_WSI_X11_PRESENTABLE_IMAGE_CREATE_INFO* pCreateInfo, XGL_IMAGE* pImage, XGL_GPU_MEMORY* pMem)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkWsiX11CreatePresentableImage(VK_DEVICE device, const VK_WSI_X11_PRESENTABLE_IMAGE_CREATE_INFO* pCreateInfo, VK_IMAGE* pImage, VK_GPU_MEMORY* pMem)
 {
     loader_platform_thread_lock_mutex(&objLock);
-    ll_increment_use_count((void*)device, XGL_OBJECT_TYPE_DEVICE);
+    ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE);
     loader_platform_thread_unlock_mutex(&objLock);
-    XGL_RESULT result = nextTable.WsiX11CreatePresentableImage(device, pCreateInfo, pImage, pMem);
+    VK_RESULT result = nextTable.WsiX11CreatePresentableImage(device, pCreateInfo, pImage, pMem);
 
-    if (result == XGL_SUCCESS)
+    if (result == VK_SUCCESS)
     {
         loader_platform_thread_lock_mutex(&objLock);
 
-        GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pImage, XGL_OBJECT_TYPE_IMAGE);
+        GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pImage, VK_OBJECT_TYPE_IMAGE);
         pNode->obj.pStruct = NULL;
 
-        GLV_VK_SNAPSHOT_LL_NODE* pMemNode = snapshot_insert_object(&s_delta, *pMem, XGL_OBJECT_TYPE_PRESENTABLE_IMAGE_MEMORY);
+        GLV_VK_SNAPSHOT_LL_NODE* pMemNode = snapshot_insert_object(&s_delta, *pMem, VK_OBJECT_TYPE_PRESENTABLE_IMAGE_MEMORY);
         pMemNode->obj.pStruct = NULL;
 
         loader_platform_thread_unlock_mutex(&objLock);
@@ -1743,9 +1743,9 @@
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglWsiX11QueuePresent(XGL_QUEUE queue, const XGL_WSI_X11_PRESENT_INFO* pPresentInfo, XGL_FENCE fence)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkWsiX11QueuePresent(VK_QUEUE queue, const VK_WSI_X11_PRESENT_INFO* pPresentInfo, VK_FENCE fence)
 {
-    XGL_RESULT result = nextTable.WsiX11QueuePresent(queue, pPresentInfo, fence);
+    VK_RESULT result = nextTable.WsiX11QueuePresent(queue, pPresentInfo, fence);
     return result;
 }
 
@@ -1785,17 +1785,17 @@
     char str[2048];
     GLV_VK_SNAPSHOT_LL_NODE* pTrav = s_delta.pGlobalObjs;
     sprintf(str, "==== DELTA SNAPSHOT contains %lu objects, %lu devices, and %lu deleted objects", s_delta.globalObjCount, s_delta.deviceCount, s_delta.deltaDeletedObjectCount);
-    layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, GLVSNAPSHOT_SNAPSHOT_DATA, LAYER_ABBREV_STR, str);
+    layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, GLVSNAPSHOT_SNAPSHOT_DATA, LAYER_ABBREV_STR, str);
 
     // print all objects
     if (s_delta.globalObjCount > 0)
     {
         sprintf(str, "======== DELTA SNAPSHOT Created Objects:");
-        layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, pTrav->obj.pVkObject, 0, GLVSNAPSHOT_SNAPSHOT_DATA, LAYER_ABBREV_STR, str);
+        layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, pTrav->obj.pVkObject, 0, GLVSNAPSHOT_SNAPSHOT_DATA, LAYER_ABBREV_STR, str);
         while (pTrav != NULL)
         {
-            sprintf(str, "\t%s obj %p", string_XGL_OBJECT_TYPE(pTrav->obj.objType), pTrav->obj.pVkObject);
-            layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, pTrav->obj.pVkObject, 0, GLVSNAPSHOT_SNAPSHOT_DATA, LAYER_ABBREV_STR, str);
+            sprintf(str, "\t%s obj %p", string_VK_OBJECT_TYPE(pTrav->obj.objType), pTrav->obj.pVkObject);
+            layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, pTrav->obj.pVkObject, 0, GLVSNAPSHOT_SNAPSHOT_DATA, LAYER_ABBREV_STR, str);
             pTrav = pTrav->pNextGlobal;
         }
     }
@@ -1805,13 +1805,13 @@
     {
         GLV_VK_SNAPSHOT_LL_NODE* pDeviceNode = s_delta.pDevices;
         sprintf(str, "======== DELTA SNAPSHOT Devices:");
-        layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, GLVSNAPSHOT_SNAPSHOT_DATA, LAYER_ABBREV_STR, str);
+        layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, GLVSNAPSHOT_SNAPSHOT_DATA, LAYER_ABBREV_STR, str);
         while (pDeviceNode != NULL)
         {
             GLV_VK_SNAPSHOT_DEVICE_NODE* pDev = (GLV_VK_SNAPSHOT_DEVICE_NODE*)pDeviceNode->obj.pStruct;
-            char * createInfoStr = xgl_print_xgl_device_create_info(pDev->params.pCreateInfo, "\t\t");
-            sprintf(str, "\t%s obj %p:\n%s", string_XGL_OBJECT_TYPE(XGL_OBJECT_TYPE_DEVICE), pDeviceNode->obj.pVkObject, createInfoStr);
-            layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, pDeviceNode->obj.pVkObject, 0, GLVSNAPSHOT_SNAPSHOT_DATA, LAYER_ABBREV_STR, str);
+            char * createInfoStr = vk_print_vk_device_create_info(pDev->params.pCreateInfo, "\t\t");
+            sprintf(str, "\t%s obj %p:\n%s", string_VK_OBJECT_TYPE(VK_OBJECT_TYPE_DEVICE), pDeviceNode->obj.pVkObject, createInfoStr);
+            layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, pDeviceNode->obj.pVkObject, 0, GLVSNAPSHOT_SNAPSHOT_DATA, LAYER_ABBREV_STR, str);
             pDeviceNode = pDeviceNode->pNextObj;
         }
     }
@@ -1821,11 +1821,11 @@
     {
         GLV_VK_SNAPSHOT_DELETED_OBJ_NODE* pDelObjNode = s_delta.pDeltaDeletedObjects;
         sprintf(str, "======== DELTA SNAPSHOT Deleted Objects:");
-        layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, GLVSNAPSHOT_SNAPSHOT_DATA, LAYER_ABBREV_STR, str);
+        layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, GLVSNAPSHOT_SNAPSHOT_DATA, LAYER_ABBREV_STR, str);
         while (pDelObjNode != NULL)
         {
-            sprintf(str, "         %s obj %p", string_XGL_OBJECT_TYPE(pDelObjNode->objType), pDelObjNode->pVkObject);
-            layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, pDelObjNode->pVkObject, 0, GLVSNAPSHOT_SNAPSHOT_DATA, LAYER_ABBREV_STR, str);
+            sprintf(str, "         %s obj %p", string_VK_OBJECT_TYPE(pDelObjNode->objType), pDelObjNode->pVkObject);
+            layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, pDelObjNode->pVkObject, 0, GLVSNAPSHOT_SNAPSHOT_DATA, LAYER_ABBREV_STR, str);
             pDelObjNode = pDelObjNode->pNextObj;
         }
     }
@@ -1852,23 +1852,23 @@
 //=============================================================================
 // Old Exported methods
 //=============================================================================
-uint64_t glvSnapshotGetObjectCount(XGL_OBJECT_TYPE type)
+uint64_t glvSnapshotGetObjectCount(VK_OBJECT_TYPE type)
 {
-    uint64_t retVal = (type == XGL_OBJECT_TYPE_ANY) ? s_delta.globalObjCount : s_delta.numObjs[type];
+    uint64_t retVal = (type == VK_OBJECT_TYPE_ANY) ? s_delta.globalObjCount : s_delta.numObjs[type];
     return retVal;
 }
 
-XGL_RESULT glvSnapshotGetObjects(XGL_OBJECT_TYPE type, uint64_t objCount, GLV_VK_SNAPSHOT_OBJECT_NODE *pObjNodeArray)
+VK_RESULT glvSnapshotGetObjects(VK_OBJECT_TYPE type, uint64_t objCount, GLV_VK_SNAPSHOT_OBJECT_NODE *pObjNodeArray)
 {
     // This bool flags if we're pulling all objs or just a single class of objs
-    bool32_t bAllObjs = (type == XGL_OBJECT_TYPE_ANY);
+    bool32_t bAllObjs = (type == VK_OBJECT_TYPE_ANY);
     // Check the count first thing
     uint64_t maxObjCount = (bAllObjs) ? s_delta.globalObjCount : s_delta.numObjs[type];
     if (objCount > maxObjCount) {
         char str[1024];
-        sprintf(str, "OBJ ERROR : Received objTrackGetObjects() request for %lu objs, but there are only %lu objs of type %s", objCount, maxObjCount, string_XGL_OBJECT_TYPE(type));
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, 0, 0, GLVSNAPSHOT_OBJCOUNT_MAX_EXCEEDED, LAYER_ABBREV_STR, str);
-        return XGL_ERROR_INVALID_VALUE;
+        sprintf(str, "OBJ ERROR : Received objTrackGetObjects() request for %lu objs, but there are only %lu objs of type %s", objCount, maxObjCount, string_VK_OBJECT_TYPE(type));
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, 0, 0, GLVSNAPSHOT_OBJCOUNT_MAX_EXCEEDED, LAYER_ABBREV_STR, str);
+        return VK_ERROR_INVALID_VALUE;
     }
 
     GLV_VK_SNAPSHOT_LL_NODE* pTrav = (bAllObjs) ? s_delta.pGlobalObjs : s_delta.pObjectHead[type];
@@ -1876,14 +1876,14 @@
     for (uint64_t i = 0; i < objCount; i++) {
         if (!pTrav) {
             char str[1024];
-            sprintf(str, "OBJ INTERNAL ERROR : Ran out of %s objs! Should have %lu, but only copied %lu and not the requested %lu.", string_XGL_OBJECT_TYPE(type), maxObjCount, i, objCount);
-            layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, 0, 0, GLVSNAPSHOT_INTERNAL_ERROR, LAYER_ABBREV_STR, str);
-            return XGL_ERROR_UNKNOWN;
+            sprintf(str, "OBJ INTERNAL ERROR : Ran out of %s objs! Should have %lu, but only copied %lu and not the requested %lu.", string_VK_OBJECT_TYPE(type), maxObjCount, i, objCount);
+            layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, 0, 0, GLVSNAPSHOT_INTERNAL_ERROR, LAYER_ABBREV_STR, str);
+            return VK_ERROR_UNKNOWN;
         }
         memcpy(&pObjNodeArray[i], pTrav, sizeof(GLV_VK_SNAPSHOT_OBJECT_NODE));
         pTrav = (bAllObjs) ? pTrav->pNextGlobal : pTrav->pNextObj;
     }
-    return XGL_SUCCESS;
+    return VK_SUCCESS;
 }
 
 void glvSnapshotPrintObjects(void)
@@ -1891,10 +1891,10 @@
     glvSnapshotPrintDelta();
 }
 
-#include "xgl_generic_intercept_proc_helper.h"
-XGL_LAYER_EXPORT void* XGLAPI xglGetProcAddr(XGL_PHYSICAL_GPU gpu, const char* funcName)
+#include "vk_generic_intercept_proc_helper.h"
+VK_LAYER_EXPORT void* VKAPI vkGetProcAddr(VK_PHYSICAL_GPU gpu, const char* funcName)
 {
-    XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) gpu;
+    VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
     void* addr;
     if (gpu == NULL)
         return NULL;
@@ -1927,7 +1927,7 @@
     else {
         if (gpuw->pGPA == NULL)
             return NULL;
-        return gpuw->pGPA((XGL_PHYSICAL_GPU)gpuw->nextObject, funcName);
+        return gpuw->pGPA((VK_PHYSICAL_GPU)gpuw->nextObject, funcName);
     }
 }
 
diff --git a/layers/glave_snapshot.h b/layers/glave_snapshot.h
index 8bd1b09..6e56b35 100644
--- a/layers/glave_snapshot.h
+++ b/layers/glave_snapshot.h
@@ -58,106 +58,106 @@
 } OBJECT_STATUS;
 
 // Object type enum
-typedef enum _XGL_OBJECT_TYPE
+typedef enum _VK_OBJECT_TYPE
 {
-    XGL_OBJECT_TYPE_UNKNOWN,
-    XGL_OBJECT_TYPE_SAMPLER,
-    XGL_OBJECT_TYPE_DYNAMIC_DS_STATE_OBJECT,
-    XGL_OBJECT_TYPE_DESCRIPTOR_SET,
-    XGL_OBJECT_TYPE_DESCRIPTOR_POOL,
-    XGL_OBJECT_TYPE_DYNAMIC_CB_STATE_OBJECT,
-    XGL_OBJECT_TYPE_IMAGE_VIEW,
-    XGL_OBJECT_TYPE_QUEUE_SEMAPHORE,
-    XGL_OBJECT_TYPE_SHADER,
-    XGL_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT,
-    XGL_OBJECT_TYPE_BUFFER,
-    XGL_OBJECT_TYPE_PIPELINE,
-    XGL_OBJECT_TYPE_DEVICE,
-    XGL_OBJECT_TYPE_QUERY_POOL,
-    XGL_OBJECT_TYPE_EVENT,
-    XGL_OBJECT_TYPE_QUEUE,
-    XGL_OBJECT_TYPE_PHYSICAL_GPU,
-    XGL_OBJECT_TYPE_RENDER_PASS,
-    XGL_OBJECT_TYPE_FRAMEBUFFER,
-    XGL_OBJECT_TYPE_IMAGE,
-    XGL_OBJECT_TYPE_BUFFER_VIEW,
-    XGL_OBJECT_TYPE_DEPTH_STENCIL_VIEW,
-    XGL_OBJECT_TYPE_INSTANCE,
-    XGL_OBJECT_TYPE_PIPELINE_DELTA,
-    XGL_OBJECT_TYPE_DYNAMIC_VP_STATE_OBJECT,
-    XGL_OBJECT_TYPE_COLOR_ATTACHMENT_VIEW,
-    XGL_OBJECT_TYPE_GPU_MEMORY,
-    XGL_OBJECT_TYPE_DYNAMIC_RS_STATE_OBJECT,
-    XGL_OBJECT_TYPE_FENCE,
-    XGL_OBJECT_TYPE_CMD_BUFFER,
-    XGL_OBJECT_TYPE_PRESENTABLE_IMAGE_MEMORY,
+    VK_OBJECT_TYPE_UNKNOWN,
+    VK_OBJECT_TYPE_SAMPLER,
+    VK_OBJECT_TYPE_DYNAMIC_DS_STATE_OBJECT,
+    VK_OBJECT_TYPE_DESCRIPTOR_SET,
+    VK_OBJECT_TYPE_DESCRIPTOR_POOL,
+    VK_OBJECT_TYPE_DYNAMIC_CB_STATE_OBJECT,
+    VK_OBJECT_TYPE_IMAGE_VIEW,
+    VK_OBJECT_TYPE_QUEUE_SEMAPHORE,
+    VK_OBJECT_TYPE_SHADER,
+    VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT,
+    VK_OBJECT_TYPE_BUFFER,
+    VK_OBJECT_TYPE_PIPELINE,
+    VK_OBJECT_TYPE_DEVICE,
+    VK_OBJECT_TYPE_QUERY_POOL,
+    VK_OBJECT_TYPE_EVENT,
+    VK_OBJECT_TYPE_QUEUE,
+    VK_OBJECT_TYPE_PHYSICAL_GPU,
+    VK_OBJECT_TYPE_RENDER_PASS,
+    VK_OBJECT_TYPE_FRAMEBUFFER,
+    VK_OBJECT_TYPE_IMAGE,
+    VK_OBJECT_TYPE_BUFFER_VIEW,
+    VK_OBJECT_TYPE_DEPTH_STENCIL_VIEW,
+    VK_OBJECT_TYPE_INSTANCE,
+    VK_OBJECT_TYPE_PIPELINE_DELTA,
+    VK_OBJECT_TYPE_DYNAMIC_VP_STATE_OBJECT,
+    VK_OBJECT_TYPE_COLOR_ATTACHMENT_VIEW,
+    VK_OBJECT_TYPE_GPU_MEMORY,
+    VK_OBJECT_TYPE_DYNAMIC_RS_STATE_OBJECT,
+    VK_OBJECT_TYPE_FENCE,
+    VK_OBJECT_TYPE_CMD_BUFFER,
+    VK_OBJECT_TYPE_PRESENTABLE_IMAGE_MEMORY,
 
-    XGL_NUM_OBJECT_TYPE,
-    XGL_OBJECT_TYPE_ANY, // Allow global object list to be queried/retrieved
-} XGL_OBJECT_TYPE;
+    VK_NUM_OBJECT_TYPE,
+    VK_OBJECT_TYPE_ANY, // Allow global object list to be queried/retrieved
+} VK_OBJECT_TYPE;
 
-static const char* string_XGL_OBJECT_TYPE(XGL_OBJECT_TYPE type) {
+static const char* string_VK_OBJECT_TYPE(VK_OBJECT_TYPE type) {
     switch (type)
     {
-        case XGL_OBJECT_TYPE_DEVICE:
+        case VK_OBJECT_TYPE_DEVICE:
             return "DEVICE";
-        case XGL_OBJECT_TYPE_PIPELINE:
+        case VK_OBJECT_TYPE_PIPELINE:
             return "PIPELINE";
-        case XGL_OBJECT_TYPE_FENCE:
+        case VK_OBJECT_TYPE_FENCE:
             return "FENCE";
-        case XGL_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT:
+        case VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT:
             return "DESCRIPTOR_SET_LAYOUT";
-        case XGL_OBJECT_TYPE_GPU_MEMORY:
+        case VK_OBJECT_TYPE_GPU_MEMORY:
             return "GPU_MEMORY";
-        case XGL_OBJECT_TYPE_QUEUE:
+        case VK_OBJECT_TYPE_QUEUE:
             return "QUEUE";
-        case XGL_OBJECT_TYPE_IMAGE:
+        case VK_OBJECT_TYPE_IMAGE:
             return "IMAGE";
-        case XGL_OBJECT_TYPE_CMD_BUFFER:
+        case VK_OBJECT_TYPE_CMD_BUFFER:
             return "CMD_BUFFER";
-        case XGL_OBJECT_TYPE_QUEUE_SEMAPHORE:
+        case VK_OBJECT_TYPE_QUEUE_SEMAPHORE:
             return "QUEUE_SEMAPHORE";
-        case XGL_OBJECT_TYPE_FRAMEBUFFER:
+        case VK_OBJECT_TYPE_FRAMEBUFFER:
             return "FRAMEBUFFER";
-        case XGL_OBJECT_TYPE_SAMPLER:
+        case VK_OBJECT_TYPE_SAMPLER:
             return "SAMPLER";
-        case XGL_OBJECT_TYPE_COLOR_ATTACHMENT_VIEW:
+        case VK_OBJECT_TYPE_COLOR_ATTACHMENT_VIEW:
             return "COLOR_ATTACHMENT_VIEW";
-        case XGL_OBJECT_TYPE_BUFFER_VIEW:
+        case VK_OBJECT_TYPE_BUFFER_VIEW:
             return "BUFFER_VIEW";
-        case XGL_OBJECT_TYPE_DESCRIPTOR_SET:
+        case VK_OBJECT_TYPE_DESCRIPTOR_SET:
             return "DESCRIPTOR_SET";
-        case XGL_OBJECT_TYPE_PHYSICAL_GPU:
+        case VK_OBJECT_TYPE_PHYSICAL_GPU:
             return "PHYSICAL_GPU";
-        case XGL_OBJECT_TYPE_IMAGE_VIEW:
+        case VK_OBJECT_TYPE_IMAGE_VIEW:
             return "IMAGE_VIEW";
-        case XGL_OBJECT_TYPE_BUFFER:
+        case VK_OBJECT_TYPE_BUFFER:
             return "BUFFER";
-        case XGL_OBJECT_TYPE_PIPELINE_DELTA:
+        case VK_OBJECT_TYPE_PIPELINE_DELTA:
             return "PIPELINE_DELTA";
-        case XGL_OBJECT_TYPE_DYNAMIC_RS_STATE_OBJECT:
+        case VK_OBJECT_TYPE_DYNAMIC_RS_STATE_OBJECT:
             return "DYNAMIC_RS_STATE_OBJECT";
-        case XGL_OBJECT_TYPE_EVENT:
+        case VK_OBJECT_TYPE_EVENT:
             return "EVENT";
-        case XGL_OBJECT_TYPE_DEPTH_STENCIL_VIEW:
+        case VK_OBJECT_TYPE_DEPTH_STENCIL_VIEW:
             return "DEPTH_STENCIL_VIEW";
-        case XGL_OBJECT_TYPE_SHADER:
+        case VK_OBJECT_TYPE_SHADER:
             return "SHADER";
-        case XGL_OBJECT_TYPE_DYNAMIC_DS_STATE_OBJECT:
+        case VK_OBJECT_TYPE_DYNAMIC_DS_STATE_OBJECT:
             return "DYNAMIC_DS_STATE_OBJECT";
-        case XGL_OBJECT_TYPE_DYNAMIC_VP_STATE_OBJECT:
+        case VK_OBJECT_TYPE_DYNAMIC_VP_STATE_OBJECT:
             return "DYNAMIC_VP_STATE_OBJECT";
-        case XGL_OBJECT_TYPE_DYNAMIC_CB_STATE_OBJECT:
+        case VK_OBJECT_TYPE_DYNAMIC_CB_STATE_OBJECT:
             return "DYNAMIC_CB_STATE_OBJECT";
-        case XGL_OBJECT_TYPE_INSTANCE:
+        case VK_OBJECT_TYPE_INSTANCE:
             return "INSTANCE";
-        case XGL_OBJECT_TYPE_RENDER_PASS:
+        case VK_OBJECT_TYPE_RENDER_PASS:
             return "RENDER_PASS";
-        case XGL_OBJECT_TYPE_QUERY_POOL:
+        case VK_OBJECT_TYPE_QUERY_POOL:
             return "QUERY_POOL";
-        case XGL_OBJECT_TYPE_DESCRIPTOR_POOL:
+        case VK_OBJECT_TYPE_DESCRIPTOR_POOL:
             return "DESCRIPTOR_POOL";
-        case XGL_OBJECT_TYPE_PRESENTABLE_IMAGE_MEMORY:
+        case VK_OBJECT_TYPE_PRESENTABLE_IMAGE_MEMORY:
             return "PRESENTABLE_IMAGE_MEMORY";
         default:
             return "UNKNOWN";
@@ -173,13 +173,13 @@
 
 typedef struct _GLV_VK_SNAPSHOT_CREATEDEVICE_PARAMS
 {
-    XGL_PHYSICAL_GPU gpu;
-    XGL_DEVICE_CREATE_INFO* pCreateInfo;
-    XGL_DEVICE* pDevice;
+    VK_PHYSICAL_GPU gpu;
+    VK_DEVICE_CREATE_INFO* pCreateInfo;
+    VK_DEVICE* pDevice;
 } GLV_VK_SNAPSHOT_CREATEDEVICE_PARAMS;
 
-XGL_DEVICE_CREATE_INFO* glv_deepcopy_xgl_device_create_info(const XGL_DEVICE_CREATE_INFO* pSrcCreateInfo);void glv_deepfree_xgl_device_create_info(XGL_DEVICE_CREATE_INFO* pCreateInfo);
-void glv_vk_snapshot_copy_createdevice_params(GLV_VK_SNAPSHOT_CREATEDEVICE_PARAMS* pDest, XGL_PHYSICAL_GPU gpu, const XGL_DEVICE_CREATE_INFO* pCreateInfo, XGL_DEVICE* pDevice);
+VK_DEVICE_CREATE_INFO* glv_deepcopy_xgl_device_create_info(const VK_DEVICE_CREATE_INFO* pSrcCreateInfo);void glv_deepfree_xgl_device_create_info(VK_DEVICE_CREATE_INFO* pCreateInfo);
+void glv_vk_snapshot_copy_createdevice_params(GLV_VK_SNAPSHOT_CREATEDEVICE_PARAMS* pDest, VK_PHYSICAL_GPU gpu, const VK_DEVICE_CREATE_INFO* pCreateInfo, VK_DEVICE* pDevice);
 void glv_vk_snapshot_destroy_createdevice_params(GLV_VK_SNAPSHOT_CREATEDEVICE_PARAMS* pSrc);
 
 //=============================================================================
@@ -189,16 +189,16 @@
 // Node that stores information about an object
 typedef struct _GLV_VK_SNAPSHOT_OBJECT_NODE {
     void*           pVkObject;
-    XGL_OBJECT_TYPE objType;
+    VK_OBJECT_TYPE objType;
     uint64_t        numUses;
     OBJECT_STATUS   status;
     void*           pStruct;    //< optionally points to a device-specific struct (ie, GLV_VK_SNAPSHOT_DEVICE_NODE)
 } GLV_VK_SNAPSHOT_OBJECT_NODE;
 
-// Node that stores information about an XGL_DEVICE
+// Node that stores information about an VK_DEVICE
 typedef struct _GLV_VK_SNAPSHOT_DEVICE_NODE {
     // This object
-    XGL_DEVICE device;
+    VK_DEVICE device;
 
     // CreateDevice parameters
     GLV_VK_SNAPSHOT_CREATEDEVICE_PARAMS params;
@@ -222,7 +222,7 @@
 typedef struct _GLV_VK_SNAPSHOT_DELETED_OBJ_NODE {
     struct _GLV_VK_SNAPSHOT_DELETED_OBJ_NODE* pNextObj;
     void* pVkObject;
-    XGL_OBJECT_TYPE objType;
+    VK_OBJECT_TYPE objType;
 } GLV_VK_SNAPSHOT_DELETED_OBJ_NODE;
 
 //=============================================================================
@@ -235,8 +235,8 @@
     GLV_VK_SNAPSHOT_LL_NODE* pGlobalObjs;
 
     // TEMPORARY: Keep track of all objects of each type
-    uint64_t numObjs[XGL_NUM_OBJECT_TYPE];
-    GLV_VK_SNAPSHOT_LL_NODE *pObjectHead[XGL_NUM_OBJECT_TYPE];
+    uint64_t numObjs[VK_NUM_OBJECT_TYPE];
+    GLV_VK_SNAPSHOT_LL_NODE *pObjectHead[VK_NUM_OBJECT_TYPE];
 
     // List of created devices and [potentially] hierarchical tree of the objects on it.
     // This is used to represent ownership of the objects
@@ -290,13 +290,13 @@
 // merge a delta into a snapshot and return the updated snapshot
 GLV_VK_SNAPSHOT glvSnapshotMerge(const GLV_VK_SNAPSHOT * const pDelta, const GLV_VK_SNAPSHOT * const pSnapshot);
 
-uint64_t glvSnapshotGetObjectCount(XGL_OBJECT_TYPE type);
-XGL_RESULT glvSnapshotGetObjects(XGL_OBJECT_TYPE type, uint64_t objCount, GLV_VK_SNAPSHOT_OBJECT_NODE* pObjNodeArray);
+uint64_t glvSnapshotGetObjectCount(VK_OBJECT_TYPE type);
+VK_RESULT glvSnapshotGetObjects(VK_OBJECT_TYPE type, uint64_t objCount, GLV_VK_SNAPSHOT_OBJECT_NODE* pObjNodeArray);
 void glvSnapshotPrintObjects(void);
 
 // Func ptr typedefs
-typedef uint64_t (*GLVSNAPSHOT_GET_OBJECT_COUNT)(XGL_OBJECT_TYPE);
-typedef XGL_RESULT (*GLVSNAPSHOT_GET_OBJECTS)(XGL_OBJECT_TYPE, uint64_t, GLV_VK_SNAPSHOT_OBJECT_NODE*);
+typedef uint64_t (*GLVSNAPSHOT_GET_OBJECT_COUNT)(VK_OBJECT_TYPE);
+typedef VK_RESULT (*GLVSNAPSHOT_GET_OBJECTS)(VK_OBJECT_TYPE, uint64_t, GLV_VK_SNAPSHOT_OBJECT_NODE*);
 typedef void (*GLVSNAPSHOT_PRINT_OBJECTS)(void);
 typedef void (*GLVSNAPSHOT_START_TRACKING)(void);
 typedef GLV_VK_SNAPSHOT (*GLVSNAPSHOT_GET_DELTA)(void);
diff --git a/layers/layers_config.cpp b/layers/layers_config.cpp
index 6992f06..134bf16 100644
--- a/layers/layers_config.cpp
+++ b/layers/layers_config.cpp
@@ -26,7 +26,7 @@
 #include <string>
 #include <map>
 #include <string.h>
-#include <xglLayer.h>
+#include <vkLayer.h>
 #include "loader_platform.h"
 #include "layers_config.h"
 // The following is #included again to catch certain OS-specific functions
@@ -56,24 +56,24 @@
 static unsigned int convertStringEnumVal(const char *_enum)
 {
     // only handles single enum values
-    if (!strcmp(_enum, "XGL_DBG_LAYER_ACTION_IGNORE"))
-        return XGL_DBG_LAYER_ACTION_IGNORE;
-    else if (!strcmp(_enum, "XGL_DBG_LAYER_ACTION_CALLBACK"))
-        return XGL_DBG_LAYER_ACTION_CALLBACK;
-    else if (!strcmp(_enum, "XGL_DBG_LAYER_ACTION_LOG_MSG"))
-        return XGL_DBG_LAYER_ACTION_LOG_MSG;
-    else if (!strcmp(_enum, "XGL_DBG_LAYER_ACTION_BREAK"))
-        return XGL_DBG_LAYER_ACTION_BREAK;
-    else if (!strcmp(_enum, "XGL_DBG_LAYER_LEVEL_INFO"))
-        return XGL_DBG_LAYER_LEVEL_INFO;
-    else if (!strcmp(_enum, "XGL_DBG_LAYER_LEVEL_WARN"))
-        return XGL_DBG_LAYER_LEVEL_WARN;
-    else if (!strcmp(_enum, "XGL_DBG_LAYER_LEVEL_PERF_WARN"))
-        return XGL_DBG_LAYER_LEVEL_PERF_WARN;
-    else if (!strcmp(_enum, "XGL_DBG_LAYER_LEVEL_ERROR"))
-        return XGL_DBG_LAYER_LEVEL_ERROR;
-    else if (!strcmp(_enum, "XGL_DBG_LAYER_LEVEL_NONE"))
-        return XGL_DBG_LAYER_LEVEL_NONE;
+    if (!strcmp(_enum, "VK_DBG_LAYER_ACTION_IGNORE"))
+        return VK_DBG_LAYER_ACTION_IGNORE;
+    else if (!strcmp(_enum, "VK_DBG_LAYER_ACTION_CALLBACK"))
+        return VK_DBG_LAYER_ACTION_CALLBACK;
+    else if (!strcmp(_enum, "VK_DBG_LAYER_ACTION_LOG_MSG"))
+        return VK_DBG_LAYER_ACTION_LOG_MSG;
+    else if (!strcmp(_enum, "VK_DBG_LAYER_ACTION_BREAK"))
+        return VK_DBG_LAYER_ACTION_BREAK;
+    else if (!strcmp(_enum, "VK_DBG_LAYER_LEVEL_INFO"))
+        return VK_DBG_LAYER_LEVEL_INFO;
+    else if (!strcmp(_enum, "VK_DBG_LAYER_LEVEL_WARN"))
+        return VK_DBG_LAYER_LEVEL_WARN;
+    else if (!strcmp(_enum, "VK_DBG_LAYER_LEVEL_PERF_WARN"))
+        return VK_DBG_LAYER_LEVEL_PERF_WARN;
+    else if (!strcmp(_enum, "VK_DBG_LAYER_LEVEL_ERROR"))
+        return VK_DBG_LAYER_LEVEL_ERROR;
+    else if (!strcmp(_enum, "VK_DBG_LAYER_LEVEL_NONE"))
+        return VK_DBG_LAYER_LEVEL_NONE;
     return 0;
 }
 const char *getLayerOption(const char *_option)
@@ -120,7 +120,7 @@
     std::map<std::string, std::string>::const_iterator it;
     if (!m_fileIsParsed)
     {
-        parseFile("xgl_layer_settings.txt");
+        parseFile("vk_layer_settings.txt");
     }
 
     if ((it = m_valueMap.find(_option)) == m_valueMap.end())
@@ -133,7 +133,7 @@
 {
     if (!m_fileIsParsed)
     {
-        parseFile("xgl_layer_settings.txt");
+        parseFile("vk_layer_settings.txt");
     }
 
     m_valueMap[_option] = _val;
diff --git a/layers/layers_msg.h b/layers/layers_msg.h
index 3f57250..b352596 100644
--- a/layers/layers_msg.h
+++ b/layers/layers_msg.h
@@ -1,5 +1,5 @@
 /*
- * XGL
+ * Vulkan
  *
  * Copyright (C) 2014 LunarG, Inc.
  *
@@ -24,17 +24,17 @@
 #include <stdio.h>
 #include <stdbool.h>
 
-static XGL_LAYER_DBG_FUNCTION_NODE *g_pDbgFunctionHead = NULL;
-static XGL_LAYER_DBG_REPORT_LEVEL g_reportingLevel = XGL_DBG_LAYER_LEVEL_INFO;
-static XGL_LAYER_DBG_ACTION g_debugAction = XGL_DBG_LAYER_ACTION_LOG_MSG;
+static VK_LAYER_DBG_FUNCTION_NODE *g_pDbgFunctionHead = NULL;
+static VK_LAYER_DBG_REPORT_LEVEL g_reportingLevel = VK_DBG_LAYER_LEVEL_INFO;
+static VK_LAYER_DBG_ACTION g_debugAction = VK_DBG_LAYER_ACTION_LOG_MSG;
 static bool g_actionIsDefault = true;
 static FILE *g_logFile = NULL;
 
 // Utility function to handle reporting
 //  If callbacks are enabled, use them, otherwise use printf
-static void layerCbMsg(XGL_DBG_MSG_TYPE msgType,
-    XGL_VALIDATION_LEVEL validationLevel,
-    XGL_BASE_OBJECT      srcObject,
+static void layerCbMsg(VK_DBG_MSG_TYPE msgType,
+    VK_VALIDATION_LEVEL validationLevel,
+    VK_BASE_OBJECT      srcObject,
     size_t               location,
     int32_t              msgCode,
     const char*          pLayerPrefix,
@@ -44,38 +44,38 @@
 	g_logFile = stdout;
     }
 
-    if (g_debugAction & (XGL_DBG_LAYER_ACTION_LOG_MSG | XGL_DBG_LAYER_ACTION_CALLBACK)) {
-        XGL_LAYER_DBG_FUNCTION_NODE *pTrav = g_pDbgFunctionHead;
+    if (g_debugAction & (VK_DBG_LAYER_ACTION_LOG_MSG | VK_DBG_LAYER_ACTION_CALLBACK)) {
+        VK_LAYER_DBG_FUNCTION_NODE *pTrav = g_pDbgFunctionHead;
         switch (msgType) {
-            case XGL_DBG_MSG_ERROR:
-                if (g_reportingLevel <= XGL_DBG_LAYER_LEVEL_ERROR) {
-                    if (g_debugAction & XGL_DBG_LAYER_ACTION_LOG_MSG) {
+            case VK_DBG_MSG_ERROR:
+                if (g_reportingLevel <= VK_DBG_LAYER_LEVEL_ERROR) {
+                    if (g_debugAction & VK_DBG_LAYER_ACTION_LOG_MSG) {
                         fprintf(g_logFile, "{%s}ERROR : %s\n", pLayerPrefix, pMsg);
                         fflush(g_logFile);
                     }
-                    if (g_debugAction & XGL_DBG_LAYER_ACTION_CALLBACK)
+                    if (g_debugAction & VK_DBG_LAYER_ACTION_CALLBACK)
                         while (pTrav) {
 				            pTrav->pfnMsgCallback(msgType, validationLevel, srcObject, location, msgCode, pMsg, pTrav->pUserData);
                             pTrav = pTrav->pNext;
                         }
                 }
                 break;
-            case XGL_DBG_MSG_WARNING:
-                if (g_reportingLevel <= XGL_DBG_LAYER_LEVEL_WARN) {
-                    if (g_debugAction & XGL_DBG_LAYER_ACTION_LOG_MSG)
+            case VK_DBG_MSG_WARNING:
+                if (g_reportingLevel <= VK_DBG_LAYER_LEVEL_WARN) {
+                    if (g_debugAction & VK_DBG_LAYER_ACTION_LOG_MSG)
                         fprintf(g_logFile, "{%s}WARN : %s\n", pLayerPrefix, pMsg);
-                    if (g_debugAction & XGL_DBG_LAYER_ACTION_CALLBACK)
+                    if (g_debugAction & VK_DBG_LAYER_ACTION_CALLBACK)
                         while (pTrav) {
 				            pTrav->pfnMsgCallback(msgType, validationLevel, srcObject, location, msgCode, pMsg, pTrav->pUserData);
                             pTrav = pTrav->pNext;
                         }
                 }
                 break;
-            case XGL_DBG_MSG_PERF_WARNING:
-                if (g_reportingLevel <= XGL_DBG_LAYER_LEVEL_PERF_WARN) {
-                    if (g_debugAction & XGL_DBG_LAYER_ACTION_LOG_MSG)
+            case VK_DBG_MSG_PERF_WARNING:
+                if (g_reportingLevel <= VK_DBG_LAYER_LEVEL_PERF_WARN) {
+                    if (g_debugAction & VK_DBG_LAYER_ACTION_LOG_MSG)
                         fprintf(g_logFile, "{%s}PERF_WARN : %s\n", pLayerPrefix, pMsg);
-                    if (g_debugAction & XGL_DBG_LAYER_ACTION_CALLBACK)
+                    if (g_debugAction & VK_DBG_LAYER_ACTION_CALLBACK)
                         while (pTrav) {
 				            pTrav->pfnMsgCallback(msgType, validationLevel, srcObject, location, msgCode, pMsg, pTrav->pUserData);
                             pTrav = pTrav->pNext;
@@ -83,10 +83,10 @@
                 }
                 break;
             default:
-                if (g_reportingLevel <= XGL_DBG_LAYER_LEVEL_INFO) {
-                    if (g_debugAction & XGL_DBG_LAYER_ACTION_LOG_MSG)
+                if (g_reportingLevel <= VK_DBG_LAYER_LEVEL_INFO) {
+                    if (g_debugAction & VK_DBG_LAYER_ACTION_LOG_MSG)
                         fprintf(g_logFile, "{%s}INFO : %s\n", pLayerPrefix, pMsg);
-                    if (g_debugAction & XGL_DBG_LAYER_ACTION_CALLBACK)
+                    if (g_debugAction & VK_DBG_LAYER_ACTION_CALLBACK)
                         while (pTrav) {
 				            pTrav->pfnMsgCallback(msgType, validationLevel, srcObject, location, msgCode, pMsg, pTrav->pUserData);
                             pTrav = pTrav->pNext;
diff --git a/layers/mem_tracker.cpp b/layers/mem_tracker.cpp
index 5b47bfc..71b8a5a 100644
--- a/layers/mem_tracker.cpp
+++ b/layers/mem_tracker.cpp
@@ -32,8 +32,8 @@
 using namespace std;
 
 #include "loader_platform.h"
-#include "xgl_dispatch_table_helper.h"
-#include "xgl_struct_string_helper_cpp.h"
+#include "vk_dispatch_table_helper.h"
+#include "vk_struct_string_helper_cpp.h"
 #include "mem_tracker.h"
 #include "layers_config.h"
 // The following is #included again to catch certain OS-specific functions
@@ -41,8 +41,8 @@
 #include "loader_platform.h"
 #include "layers_msg.h"
 
-static XGL_LAYER_DISPATCH_TABLE nextTable;
-static XGL_BASE_LAYER_OBJECT *pCurObj;
+static VK_LAYER_DISPATCH_TABLE nextTable;
+static VK_BASE_LAYER_OBJECT *pCurObj;
 static LOADER_PLATFORM_THREAD_ONCE_DECLARATION(g_initOnce);
 // TODO : This can be much smarter, using separate locks for separate global data
 static int globalLockInitialized = 0;
@@ -50,18 +50,18 @@
 
 #define MAX_BINDING 0xFFFFFFFF
 
-map<XGL_CMD_BUFFER, MT_CB_INFO*>      cbMap;
-map<XGL_GPU_MEMORY, MT_MEM_OBJ_INFO*> memObjMap;
-map<XGL_OBJECT,     MT_OBJ_INFO*>     objectMap;
+map<VK_CMD_BUFFER, MT_CB_INFO*>      cbMap;
+map<VK_GPU_MEMORY, MT_MEM_OBJ_INFO*> memObjMap;
+map<VK_OBJECT,     MT_OBJ_INFO*>     objectMap;
 map<uint64_t,       MT_FENCE_INFO*>   fenceMap;    // Map fenceId to fence info
-map<XGL_QUEUE,      MT_QUEUE_INFO*>   queueMap;
+map<VK_QUEUE,      MT_QUEUE_INFO*>   queueMap;
 
 // TODO : Add per-device fence completion
 static uint64_t     g_currentFenceId  = 1;
-static XGL_DEVICE   globalDevice      = NULL;
+static VK_DEVICE   globalDevice      = NULL;
 
 // Add new queue for this device to map container
-static void addQueueInfo(const XGL_QUEUE queue)
+static void addQueueInfo(const VK_QUEUE queue)
 {
     MT_QUEUE_INFO* pInfo   = new MT_QUEUE_INFO;
     pInfo->lastRetiredId   = 0;
@@ -72,23 +72,23 @@
 static void deleteQueueInfoList(void)
 {
     // Process queue list, cleaning up each entry before deleting
-    for (map<XGL_QUEUE, MT_QUEUE_INFO*>::iterator ii=queueMap.begin(); ii!=queueMap.end(); ++ii) {
+    for (map<VK_QUEUE, MT_QUEUE_INFO*>::iterator ii=queueMap.begin(); ii!=queueMap.end(); ++ii) {
         (*ii).second->pQueueCmdBuffers.clear();
     }
     queueMap.clear();
 }
 
 // Add new CBInfo for this cb to map container
-static void addCBInfo(const XGL_CMD_BUFFER cb)
+static void addCBInfo(const VK_CMD_BUFFER cb)
 {
     MT_CB_INFO* pInfo = new MT_CB_INFO;
-    memset(pInfo, 0, (sizeof(MT_CB_INFO) - sizeof(list<XGL_GPU_MEMORY>)));
+    memset(pInfo, 0, (sizeof(MT_CB_INFO) - sizeof(list<VK_GPU_MEMORY>)));
     pInfo->cmdBuffer = cb;
     cbMap[cb]        = pInfo;
 }
 
 // Return ptr to Info in CB map, or NULL if not found
-static MT_CB_INFO* getCBInfo(const XGL_CMD_BUFFER cb)
+static MT_CB_INFO* getCBInfo(const VK_CMD_BUFFER cb)
 {
     MT_CB_INFO* pCBInfo = NULL;
     if (cbMap.find(cb) != cbMap.end()) {
@@ -98,7 +98,7 @@
 }
 
 // Return object info for 'object' or return NULL if no info exists
-static MT_OBJ_INFO* getObjectInfo(const XGL_OBJECT object)
+static MT_OBJ_INFO* getObjectInfo(const VK_OBJECT object)
 {
     MT_OBJ_INFO* pObjInfo = NULL;
 
@@ -108,7 +108,7 @@
     return pObjInfo;
 }
 
-static MT_OBJ_INFO* addObjectInfo(XGL_OBJECT object, XGL_STRUCTURE_TYPE sType, const void *pCreateInfo, const int struct_size, const char *name_prefix)
+static MT_OBJ_INFO* addObjectInfo(VK_OBJECT object, VK_STRUCTURE_TYPE sType, const void *pCreateInfo, const int struct_size, const char *name_prefix)
 {
     MT_OBJ_INFO* pInfo = new MT_OBJ_INFO;
     memset(pInfo, 0, sizeof(MT_OBJ_INFO));
@@ -124,7 +124,7 @@
 }
 
 // Add a fence, creating one if necessary to our list of fences/fenceIds
-static uint64_t addFenceInfo(XGL_FENCE fence, XGL_QUEUE queue)
+static uint64_t addFenceInfo(VK_FENCE fence, VK_QUEUE queue)
 {
     // Create fence object
     MT_FENCE_INFO* pFenceInfo = new MT_FENCE_INFO;
@@ -133,15 +133,15 @@
     memset(pFenceInfo, 0, sizeof(MT_FENCE_INFO));
     // If no fence, create an internal fence to track the submissions
     if (fence == NULL) {
-        XGL_FENCE_CREATE_INFO fci;
-        fci.sType = XGL_STRUCTURE_TYPE_FENCE_CREATE_INFO;
+        VK_FENCE_CREATE_INFO fci;
+        fci.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
         fci.pNext = NULL;
-        fci.flags = static_cast<XGL_FENCE_CREATE_FLAGS>(0);
+        fci.flags = static_cast<VK_FENCE_CREATE_FLAGS>(0);
         nextTable.CreateFence(globalDevice, &fci, &pFenceInfo->fence);
-        addObjectInfo(pFenceInfo->fence, fci.sType, &fci, sizeof(XGL_FENCE_CREATE_INFO), "internalFence");
-        pFenceInfo->localFence = XGL_TRUE;
+        addObjectInfo(pFenceInfo->fence, fci.sType, &fci, sizeof(VK_FENCE_CREATE_INFO), "internalFence");
+        pFenceInfo->localFence = VK_TRUE;
     } else {
-        pFenceInfo->localFence = XGL_FALSE;
+        pFenceInfo->localFence = VK_FALSE;
         pFenceInfo->fence      = fence;
     }
     pFenceInfo->queue = queue;
@@ -159,7 +159,7 @@
             map<uint64_t, MT_FENCE_INFO*>::iterator item;
             MT_FENCE_INFO* pDelInfo = fenceMap[fenceId];
             if (pDelInfo != NULL) {
-                if (pDelInfo->localFence == XGL_TRUE) {
+                if (pDelInfo->localFence == VK_TRUE) {
                     nextTable.DestroyObject(pDelInfo->fence);
                 }
                 delete pDelInfo;
@@ -171,11 +171,11 @@
 }
 
 // Search through list for this fence, deleting all items before it (with lower IDs) and updating lastRetiredId
-static void updateFenceTracking(XGL_FENCE fence)
+static void updateFenceTracking(VK_FENCE fence)
 {
     MT_FENCE_INFO *pCurFenceInfo = NULL;
     uint64_t       fenceId       = 0;
-    XGL_QUEUE      queue         = NULL;
+    VK_QUEUE      queue         = NULL;
 
     for (map<uint64_t, MT_FENCE_INFO*>::iterator ii=fenceMap.begin(); ii!=fenceMap.end(); ++ii) {
         if ((*ii).second != NULL) {
@@ -189,7 +189,7 @@
             // Update fence state in fenceCreateInfo structure
             MT_OBJ_INFO* pObjectInfo = getObjectInfo(fence);
             if (pObjectInfo != NULL) {
-                pObjectInfo->create_info.fence_create_info.flags = XGL_FENCE_CREATE_SIGNALED_BIT;
+                pObjectInfo->create_info.fence_create_info.flags = VK_FENCE_CREATE_SIGNALED_BIT;
             }
         }
     }
@@ -198,25 +198,25 @@
 // Utility function that determines if a fenceId has been retired yet
 static bool32_t fenceRetired(uint64_t fenceId)
 {
-    bool32_t result = XGL_FALSE;
+    bool32_t result = VK_FALSE;
     MT_FENCE_INFO* pFenceInfo = fenceMap[fenceId];
     if (pFenceInfo != 0)
     {
         MT_QUEUE_INFO* pQueueInfo = queueMap[pFenceInfo->queue];
         if (fenceId <= pQueueInfo->lastRetiredId)
         {
-             result = XGL_TRUE;
+             result = VK_TRUE;
         }
     } else {                 // If not in list, fence has been retired and deleted
-       result = XGL_TRUE;
+       result = VK_TRUE;
     }
     return result;
 }
 
 // Return the fence associated with a fenceId
-static XGL_FENCE getFenceFromId(uint64_t fenceId)
+static VK_FENCE getFenceFromId(uint64_t fenceId)
 {
-    XGL_FENCE fence = NULL;
+    VK_FENCE fence = NULL;
     if (fenceId != 0) {
         // Search for an item with this fenceId
         if (fenceMap.find(fenceId) != fenceMap.end()) {
@@ -233,7 +233,7 @@
 }
 
 // Helper routine that updates the fence list for a specific queue to all-retired
-static void retireQueueFences(XGL_QUEUE queue)
+static void retireQueueFences(VK_QUEUE queue)
 {
     MT_QUEUE_INFO *pQueueInfo = queueMap[queue];
     pQueueInfo->lastRetiredId = pQueueInfo->lastSubmittedId;
@@ -253,11 +253,11 @@
 }
 
 // Helper routine that updates fence list for all queues to all-retired
-static void retireDeviceFences(XGL_DEVICE device)
+static void retireDeviceFences(VK_DEVICE device)
 {
     // Process each queue for device
     // TODO: Add multiple device support
-    for (map<XGL_QUEUE, MT_QUEUE_INFO*>::iterator ii=queueMap.begin(); ii!=queueMap.end(); ++ii) {
+    for (map<VK_QUEUE, MT_QUEUE_INFO*>::iterator ii=queueMap.begin(); ii!=queueMap.end(); ++ii) {
         retireQueueFences((*ii).first);
     }
 }
@@ -265,15 +265,15 @@
 // Returns True if a memory reference is present in a Queue's memory reference list
 // Queue is validated by caller
 static bool32_t checkMemRef(
-    XGL_QUEUE      queue,
-    XGL_GPU_MEMORY mem)
+    VK_QUEUE      queue,
+    VK_GPU_MEMORY mem)
 {
-    bool32_t result = XGL_FALSE;
-    list<XGL_GPU_MEMORY>::iterator it;
+    bool32_t result = VK_FALSE;
+    list<VK_GPU_MEMORY>::iterator it;
     MT_QUEUE_INFO *pQueueInfo = queueMap[queue];
     for (it = pQueueInfo->pMemRefList.begin(); it != pQueueInfo->pMemRefList.end(); ++it) {
         if ((*it) == mem) {
-            result = XGL_TRUE;
+            result = VK_TRUE;
             break;
         }
     }
@@ -281,18 +281,18 @@
 }
 
 static bool32_t validateQueueMemRefs(
-    XGL_QUEUE             queue,
+    VK_QUEUE             queue,
     uint32_t              cmdBufferCount,
-    const XGL_CMD_BUFFER *pCmdBuffers)
+    const VK_CMD_BUFFER *pCmdBuffers)
 {
-    bool32_t result = XGL_TRUE;
+    bool32_t result = VK_TRUE;
 
     //  Verify Queue
     MT_QUEUE_INFO *pQueueInfo = queueMap[queue];
     if (pQueueInfo == NULL) {
         char str[1024];
-        sprintf(str, "Unknown Queue %p specified in xglQueueSubmit", queue);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, queue, 0, MEMTRACK_INVALID_QUEUE, "MEM", str);
+        sprintf(str, "Unknown Queue %p specified in vkQueueSubmit", queue);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, queue, 0, MEMTRACK_INVALID_QUEUE, "MEM", str);
     }
     else {
         //  Iterate through all CBs in pCmdBuffers
@@ -300,31 +300,31 @@
             MT_CB_INFO* pCBInfo = getCBInfo(pCmdBuffers[i]);
             if (!pCBInfo) {
                 char str[1024];
-                sprintf(str, "Unable to find info for CB %p in order to check memory references in xglQueueSubmit for queue %p", (void*)pCmdBuffers[i], queue);
-                layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, pCmdBuffers[i], 0, MEMTRACK_INVALID_CB, "MEM", str);
-                result = XGL_FALSE;
+                sprintf(str, "Unable to find info for CB %p in order to check memory references in vkQueueSubmit for queue %p", (void*)pCmdBuffers[i], queue);
+                layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, pCmdBuffers[i], 0, MEMTRACK_INVALID_CB, "MEM", str);
+                result = VK_FALSE;
             } else {
                 // Validate that all actual references are accounted for in pMemRefs
-                for (list<XGL_GPU_MEMORY>::iterator it = pCBInfo->pMemObjList.begin(); it != pCBInfo->pMemObjList.end(); ++it) {
+                for (list<VK_GPU_MEMORY>::iterator it = pCBInfo->pMemObjList.begin(); it != pCBInfo->pMemObjList.end(); ++it) {
                     // Search for each memref in queues memreflist.
                     if (checkMemRef(queue, *it)) {
                         char str[1024];
                         sprintf(str, "Found Mem Obj %p binding to CB %p for queue %p", (*it), pCmdBuffers[i], queue);
-                        layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, pCmdBuffers[i], 0, MEMTRACK_NONE, "MEM", str);
+                        layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, pCmdBuffers[i], 0, MEMTRACK_NONE, "MEM", str);
                     }
                     else {
                         char str[1024];
                         sprintf(str, "Queue %p Memory reference list for Command Buffer %p is missing ref to mem obj %p", queue, pCmdBuffers[i], (*it));
-                        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, pCmdBuffers[i], 0, MEMTRACK_INVALID_MEM_REF, "MEM", str);
-                        result = XGL_FALSE;
+                        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, pCmdBuffers[i], 0, MEMTRACK_INVALID_MEM_REF, "MEM", str);
+                        result = VK_FALSE;
                     }
                 }
             }
         }
-        if (result == XGL_TRUE) {
+        if (result == VK_TRUE) {
             char str[1024];
             sprintf(str, "Verified all memory dependencies for Queue %p are included in pMemRefs list", queue);
-            layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, queue, 0, MEMTRACK_NONE, "MEM", str);
+            layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, queue, 0, MEMTRACK_NONE, "MEM", str);
             // TODO : Could report mem refs in pMemRefs that AREN'T in mem list, that would be primarily informational
             //   Currently just noting that there is a difference
         }
@@ -335,7 +335,7 @@
 
 // Return ptr to info in map container containing mem, or NULL if not found
 //  Calls to this function should be wrapped in mutex
-static MT_MEM_OBJ_INFO* getMemObjInfo(const XGL_GPU_MEMORY mem)
+static MT_MEM_OBJ_INFO* getMemObjInfo(const VK_GPU_MEMORY mem)
 {
     MT_MEM_OBJ_INFO* pMemObjInfo = NULL;
 
@@ -345,14 +345,14 @@
     return pMemObjInfo;
 }
 
-static void addMemObjInfo(const XGL_GPU_MEMORY mem, const XGL_MEMORY_ALLOC_INFO* pAllocInfo)
+static void addMemObjInfo(const VK_GPU_MEMORY mem, const VK_MEMORY_ALLOC_INFO* pAllocInfo)
 {
     MT_MEM_OBJ_INFO* pInfo = new MT_MEM_OBJ_INFO;
     pInfo->refCount           = 0;
-    memset(&pInfo->allocInfo, 0, sizeof(XGL_MEMORY_ALLOC_INFO));
+    memset(&pInfo->allocInfo, 0, sizeof(VK_MEMORY_ALLOC_INFO));
 
-    if (pAllocInfo) {  // MEM alloc created by xglWsiX11CreatePresentableImage() doesn't have alloc info struct
-        memcpy(&pInfo->allocInfo, pAllocInfo, sizeof(XGL_MEMORY_ALLOC_INFO));
+    if (pAllocInfo) {  // MEM alloc created by vkWsiX11CreatePresentableImage() doesn't have alloc info struct
+        memcpy(&pInfo->allocInfo, pAllocInfo, sizeof(VK_MEMORY_ALLOC_INFO));
         // TODO:  Update for real hardware, actually process allocation info structures
         pInfo->allocInfo.pNext = NULL;
     }
@@ -362,27 +362,27 @@
 
 // Find CB Info and add mem binding to list container
 // Find Mem Obj Info and add CB binding to list container
-static bool32_t updateCBBinding(const XGL_CMD_BUFFER cb, const XGL_GPU_MEMORY mem)
+static bool32_t updateCBBinding(const VK_CMD_BUFFER cb, const VK_GPU_MEMORY mem)
 {
-    bool32_t result = XGL_TRUE;
+    bool32_t result = VK_TRUE;
     // First update CB binding in MemObj mini CB list
     MT_MEM_OBJ_INFO* pMemInfo = getMemObjInfo(mem);
     if (!pMemInfo) {
         char str[1024];
         sprintf(str, "Trying to bind mem obj %p to CB %p but no info for that mem obj.\n    Was it correctly allocated? Did it already get freed?", mem, cb);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cb, 0, MEMTRACK_INVALID_MEM_OBJ, "MEM", str);
-        result = XGL_FALSE;
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cb, 0, MEMTRACK_INVALID_MEM_OBJ, "MEM", str);
+        result = VK_FALSE;
     } else {
         // Search for cmd buffer object in memory object's binding list
-        bool32_t found  = XGL_FALSE;
-        for (list<XGL_CMD_BUFFER>::iterator it = pMemInfo->pCmdBufferBindings.begin(); it != pMemInfo->pCmdBufferBindings.end(); ++it) {
+        bool32_t found  = VK_FALSE;
+        for (list<VK_CMD_BUFFER>::iterator it = pMemInfo->pCmdBufferBindings.begin(); it != pMemInfo->pCmdBufferBindings.end(); ++it) {
             if ((*it) == cb) {
-                found = XGL_TRUE;
+                found = VK_TRUE;
                 break;
             }
         }
         // If not present, add to list
-        if (found == XGL_FALSE) {
+        if (found == VK_FALSE) {
             pMemInfo->pCmdBufferBindings.push_front(cb);
             pMemInfo->refCount++;
         }
@@ -392,19 +392,19 @@
         if (!pCBInfo) {
             char str[1024];
             sprintf(str, "Trying to bind mem obj %p to CB %p but no info for that CB.    Was it CB incorrectly destroyed?", mem, cb);
-            layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cb, 0, MEMTRACK_INVALID_MEM_OBJ, "MEM", str);
-            result = XGL_FALSE;
+            layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cb, 0, MEMTRACK_INVALID_MEM_OBJ, "MEM", str);
+            result = VK_FALSE;
         } else {
             // Search for memory object in cmd buffer's binding list
-            bool32_t found  = XGL_FALSE;
-            for (list<XGL_GPU_MEMORY>::iterator it = pCBInfo->pMemObjList.begin(); it != pCBInfo->pMemObjList.end(); ++it) {
+            bool32_t found  = VK_FALSE;
+            for (list<VK_GPU_MEMORY>::iterator it = pCBInfo->pMemObjList.begin(); it != pCBInfo->pMemObjList.end(); ++it) {
                 if ((*it) == mem) {
-                    found = XGL_TRUE;
+                    found = VK_TRUE;
                     break;
                 }
             }
             // If not present, add to list
-            if (found == XGL_FALSE) {
+            if (found == VK_FALSE) {
                 pCBInfo->pMemObjList.push_front(mem);
             }
         }
@@ -414,7 +414,7 @@
 
 // Clear the CB Binding for mem
 //  Calls to this function should be wrapped in mutex
-static void clearCBBinding(const XGL_CMD_BUFFER cb, const XGL_GPU_MEMORY mem)
+static void clearCBBinding(const VK_CMD_BUFFER cb, const VK_GPU_MEMORY mem)
 {
     MT_MEM_OBJ_INFO* pInfo = getMemObjInfo(mem);
     // TODO : Having this check is not ideal, really if memInfo was deleted,
@@ -427,21 +427,21 @@
 }
 
 // Free bindings related to CB
-static bool32_t freeCBBindings(const XGL_CMD_BUFFER cb)
+static bool32_t freeCBBindings(const VK_CMD_BUFFER cb)
 {
-    bool32_t result = XGL_TRUE;
+    bool32_t result = VK_TRUE;
     MT_CB_INFO* pCBInfo = getCBInfo(cb);
     if (!pCBInfo) {
         char str[1024];
         sprintf(str, "Unable to find global CB info %p for deletion", cb);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cb, 0, MEMTRACK_INVALID_CB, "MEM", str);
-        result = XGL_FALSE;
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cb, 0, MEMTRACK_INVALID_CB, "MEM", str);
+        result = VK_FALSE;
     } else {
         if (!fenceRetired(pCBInfo->fenceId)) {
             deleteFenceInfo(pCBInfo->fenceId);
         }
 
-        for (list<XGL_GPU_MEMORY>::iterator it=pCBInfo->pMemObjList.begin(); it!=pCBInfo->pMemObjList.end(); ++it) {
+        for (list<VK_GPU_MEMORY>::iterator it=pCBInfo->pMemObjList.begin(); it!=pCBInfo->pMemObjList.end(); ++it) {
             clearCBBinding(cb, (*it));
         }
         pCBInfo->pMemObjList.clear();
@@ -452,12 +452,12 @@
 // Delete CBInfo from list along with all of it's mini MemObjInfo
 //   and also clear mem references to CB
 // TODO : When should this be called?  There's no Destroy of CBs that I see
-static bool32_t deleteCBInfo(const XGL_CMD_BUFFER cb)
+static bool32_t deleteCBInfo(const VK_CMD_BUFFER cb)
 {
-    bool32_t result = XGL_TRUE;
+    bool32_t result = VK_TRUE;
     result = freeCBBindings(cb);
     // Delete the CBInfo info
-    if (result == XGL_TRUE) {
+    if (result == VK_TRUE) {
         if (cbMap.find(cb) != cbMap.end()) {
             MT_CB_INFO* pDelInfo = cbMap[cb];
             delete pDelInfo;
@@ -470,8 +470,8 @@
 // Delete the entire CB list
 static bool32_t deleteCBInfoList()
 {
-    bool32_t result = XGL_TRUE;
-    for (map<XGL_CMD_BUFFER, MT_CB_INFO*>::iterator ii=cbMap.begin(); ii!=cbMap.end(); ++ii) {
+    bool32_t result = VK_TRUE;
+    for (map<VK_CMD_BUFFER, MT_CB_INFO*>::iterator ii=cbMap.begin(); ii!=cbMap.end(); ++ii) {
         freeCBBindings((*ii).first);
         delete (*ii).second;
     }
@@ -483,25 +483,25 @@
 {
     uint32_t refCount = 0; // Count found references
 
-    for (list<XGL_CMD_BUFFER>::const_iterator it = pMemObjInfo->pCmdBufferBindings.begin(); it != pMemObjInfo->pCmdBufferBindings.end(); ++it) {
+    for (list<VK_CMD_BUFFER>::const_iterator it = pMemObjInfo->pCmdBufferBindings.begin(); it != pMemObjInfo->pCmdBufferBindings.end(); ++it) {
         refCount++;
         char str[1024];
         sprintf(str, "Command Buffer %p has reference to mem obj %p", (*it), pMemObjInfo->mem);
-        layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, (*it), 0, MEMTRACK_NONE, "MEM", str);
+        layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, (*it), 0, MEMTRACK_NONE, "MEM", str);
     }
-    for (list<XGL_OBJECT>::const_iterator it = pMemObjInfo->pObjBindings.begin(); it != pMemObjInfo->pObjBindings.end(); ++it) {
+    for (list<VK_OBJECT>::const_iterator it = pMemObjInfo->pObjBindings.begin(); it != pMemObjInfo->pObjBindings.end(); ++it) {
         char str[1024];
-        sprintf(str, "XGL Object %p has reference to mem obj %p", (*it), pMemObjInfo->mem);
-        layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, (*it), 0, MEMTRACK_NONE, "MEM", str);
+        sprintf(str, "VK Object %p has reference to mem obj %p", (*it), pMemObjInfo->mem);
+        layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, (*it), 0, MEMTRACK_NONE, "MEM", str);
     }
     if (refCount != pMemObjInfo->refCount) {
         char str[1024];
         sprintf(str, "Refcount of %u for Mem Obj %p does't match reported refs of %u", pMemObjInfo->refCount, pMemObjInfo->mem, refCount);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, pMemObjInfo->mem, 0, MEMTRACK_INTERNAL_ERROR, "MEM", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, pMemObjInfo->mem, 0, MEMTRACK_INTERNAL_ERROR, "MEM", str);
     }
 }
 
-static void deleteMemObjInfo(XGL_GPU_MEMORY mem)
+static void deleteMemObjInfo(VK_GPU_MEMORY mem)
 {
     MT_MEM_OBJ_INFO* pDelInfo = memObjMap[mem];
     if (memObjMap.find(mem) != memObjMap.end()) {
@@ -512,50 +512,50 @@
 }
 
 // Check if fence for given CB is completed
-static bool32_t checkCBCompleted(const XGL_CMD_BUFFER cb)
+static bool32_t checkCBCompleted(const VK_CMD_BUFFER cb)
 {
-    bool32_t result = XGL_TRUE;
+    bool32_t result = VK_TRUE;
     MT_CB_INFO* pCBInfo = getCBInfo(cb);
     if (!pCBInfo) {
         char str[1024];
         sprintf(str, "Unable to find global CB info %p to check for completion", cb);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cb, 0, MEMTRACK_INVALID_CB, "MEM", str);
-        result = XGL_FALSE;
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cb, 0, MEMTRACK_INVALID_CB, "MEM", str);
+        result = VK_FALSE;
     } else {
         if (!fenceRetired(pCBInfo->fenceId)) {
             char str[1024];
             sprintf(str, "FenceId %" PRIx64", fence %p for CB %p has not been checked for completion", pCBInfo->fenceId, getFenceFromId(pCBInfo->fenceId), cb);
-            layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, cb, 0, MEMTRACK_NONE, "MEM", str);
-            result = XGL_FALSE;
+            layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, cb, 0, MEMTRACK_NONE, "MEM", str);
+            result = VK_FALSE;
         }
     }
     return result;
 }
 
-static bool32_t freeMemObjInfo(XGL_GPU_MEMORY mem, bool internal)
+static bool32_t freeMemObjInfo(VK_GPU_MEMORY mem, bool internal)
 {
-    bool32_t result = XGL_TRUE;
+    bool32_t result = VK_TRUE;
     // Parse global list to find info w/ mem
     MT_MEM_OBJ_INFO* pInfo = getMemObjInfo(mem);
     if (!pInfo) {
         char str[1024];
         sprintf(str, "Couldn't find mem info object for %p\n    Was %p never allocated or previously freed?", (void*)mem, (void*)mem);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, mem, 0, MEMTRACK_INVALID_MEM_OBJ, "MEM", str);
-        result = XGL_FALSE;
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, mem, 0, MEMTRACK_INVALID_MEM_OBJ, "MEM", str);
+        result = VK_FALSE;
     } else {
         if (pInfo->allocInfo.allocationSize == 0 && !internal) {
             char str[1024];
             sprintf(str, "Attempting to free memory associated with a Presentable Image, %p, this should not be explicitly freed\n", (void*)mem);
-            layerCbMsg(XGL_DBG_MSG_WARNING, XGL_VALIDATION_LEVEL_0, mem, 0, MEMTRACK_INVALID_MEM_OBJ, "MEM", str);
-            result = XGL_FALSE;
+            layerCbMsg(VK_DBG_MSG_WARNING, VK_VALIDATION_LEVEL_0, mem, 0, MEMTRACK_INVALID_MEM_OBJ, "MEM", str);
+            result = VK_FALSE;
         } else {
             // Clear any CB bindings for completed CBs
             //   TODO : Is there a better place to do this?
 
-            list<XGL_CMD_BUFFER>::iterator it = pInfo->pCmdBufferBindings.begin();
-            list<XGL_CMD_BUFFER>::iterator temp;
+            list<VK_CMD_BUFFER>::iterator it = pInfo->pCmdBufferBindings.begin();
+            list<VK_CMD_BUFFER>::iterator temp;
             while (it != pInfo->pCmdBufferBindings.end()) {
-                if (XGL_TRUE == checkCBCompleted(*it)) {
+                if (VK_TRUE == checkCBCompleted(*it)) {
                     temp = it;
                     ++temp;
                     freeCBBindings(*it);
@@ -570,9 +570,9 @@
                 // If references remain, report the error and can search CB list to find references
                 char str[1024];
                 sprintf(str, "Freeing mem obj %p while it still has references", (void*)mem);
-                layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, mem, 0, MEMTRACK_FREED_MEM_REF, "MEM", str);
+                layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, mem, 0, MEMTRACK_FREED_MEM_REF, "MEM", str);
                 reportMemReferences(pInfo);
-                result = XGL_FALSE;
+                result = VK_FALSE;
             }
             // Delete mem obj info
             deleteMemObjInfo(mem);
@@ -585,32 +585,32 @@
 // 1. Remove ObjectInfo from MemObjInfo list container of obj bindings & free it
 // 2. Decrement refCount for MemObjInfo
 // 3. Clear MemObjInfo ptr from ObjectInfo
-static bool32_t clearObjectBinding(XGL_OBJECT object)
+static bool32_t clearObjectBinding(VK_OBJECT object)
 {
-    bool32_t result = XGL_FALSE;
+    bool32_t result = VK_FALSE;
     MT_OBJ_INFO* pObjInfo = getObjectInfo(object);
     if (!pObjInfo) {
         char str[1024];
         sprintf(str, "Attempting to clear mem binding for object %p: devices, queues, command buffers, shaders and memory objects do not have external memory requirements and it is unneccessary to call bind/unbindObjectMemory on them.", object);
-        layerCbMsg(XGL_DBG_MSG_WARNING, XGL_VALIDATION_LEVEL_0, object, 0, MEMTRACK_INVALID_OBJECT, "MEM", str);
+        layerCbMsg(VK_DBG_MSG_WARNING, VK_VALIDATION_LEVEL_0, object, 0, MEMTRACK_INVALID_OBJECT, "MEM", str);
     } else {
         if (!pObjInfo->pMemObjInfo) {
             char str[1024];
             sprintf(str, "Attempting to clear mem binding on obj %p but it has no binding.", (void*)object);
-            layerCbMsg(XGL_DBG_MSG_WARNING, XGL_VALIDATION_LEVEL_0, object, 0, MEMTRACK_MEM_OBJ_CLEAR_EMPTY_BINDINGS, "MEM", str);
+            layerCbMsg(VK_DBG_MSG_WARNING, VK_VALIDATION_LEVEL_0, object, 0, MEMTRACK_MEM_OBJ_CLEAR_EMPTY_BINDINGS, "MEM", str);
         } else {
-            for (list<XGL_OBJECT>::iterator it = pObjInfo->pMemObjInfo->pObjBindings.begin(); it != pObjInfo->pMemObjInfo->pObjBindings.end(); ++it) {
+            for (list<VK_OBJECT>::iterator it = pObjInfo->pMemObjInfo->pObjBindings.begin(); it != pObjInfo->pMemObjInfo->pObjBindings.end(); ++it) {
                 pObjInfo->pMemObjInfo->refCount--;
                 pObjInfo->pMemObjInfo = NULL;
                 it = pObjInfo->pMemObjInfo->pObjBindings.erase(it);
-                result = XGL_TRUE;
+                result = VK_TRUE;
                 break;
             }
-            if (result == XGL_FALSE) {
+            if (result == VK_FALSE) {
                 char str[1024];
                 sprintf(str, "While trying to clear mem binding for object %p, unable to find that object referenced by mem obj %p",
                     object, pObjInfo->pMemObjInfo->mem);
-                layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, object, 0, MEMTRACK_INTERNAL_ERROR, "MEM", str);
+                layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, object, 0, MEMTRACK_INTERNAL_ERROR, "MEM", str);
             }
         }
     }
@@ -622,38 +622,38 @@
 //  IF a previous binding existed, clear it
 //  Add reference from objectInfo to memoryInfo
 //  Add reference off of objInfo
-// Return XGL_TRUE if addition is successful, XGL_FALSE otherwise
-static bool32_t updateObjectBinding(XGL_OBJECT object, XGL_GPU_MEMORY mem)
+// Return VK_TRUE if addition is successful, VK_FALSE otherwise
+static bool32_t updateObjectBinding(VK_OBJECT object, VK_GPU_MEMORY mem)
 {
-    bool32_t result = XGL_FALSE;
+    bool32_t result = VK_FALSE;
     // Handle NULL case separately, just clear previous binding & decrement reference
-    if (mem == XGL_NULL_HANDLE) {
+    if (mem == VK_NULL_HANDLE) {
         clearObjectBinding(object);
-        result = XGL_TRUE;
+        result = VK_TRUE;
     } else {
         char str[1024];
         MT_OBJ_INFO* pObjInfo = getObjectInfo(object);
         if (!pObjInfo) {
             sprintf(str, "Attempting to update Binding of Obj(%p) that's not in global list()", (void*)object);
-            layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, object, 0, MEMTRACK_INTERNAL_ERROR, "MEM", str);
-            return XGL_FALSE;
+            layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, object, 0, MEMTRACK_INTERNAL_ERROR, "MEM", str);
+            return VK_FALSE;
         }
         // non-null case so should have real mem obj
         MT_MEM_OBJ_INFO* pInfo = getMemObjInfo(mem);
         if (!pInfo) {
             sprintf(str, "While trying to bind mem for obj %p, couldn't find info for mem obj %p", (void*)object, (void*)mem);
-            layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, mem, 0, MEMTRACK_INVALID_MEM_OBJ, "MEM", str);
+            layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, mem, 0, MEMTRACK_INVALID_MEM_OBJ, "MEM", str);
         } else {
             // Search for object in memory object's binding list
-            bool32_t found  = XGL_FALSE;
-            for (list<XGL_OBJECT>::iterator it = pInfo->pObjBindings.begin(); it != pInfo->pObjBindings.end(); ++it) {
+            bool32_t found  = VK_FALSE;
+            for (list<VK_OBJECT>::iterator it = pInfo->pObjBindings.begin(); it != pInfo->pObjBindings.end(); ++it) {
                 if ((*it) == object) {
-                    found = XGL_TRUE;
+                    found = VK_TRUE;
                     break;
                 }
             }
             // If not present, add to list
-            if (found == XGL_FALSE) {
+            if (found == VK_FALSE) {
                 pInfo->pObjBindings.push_front(object);
                 pInfo->refCount++;
             }
@@ -661,19 +661,19 @@
             if (pObjInfo->pMemObjInfo) {
                 clearObjectBinding(object); // Need to clear the previous object binding before setting new binding
                 sprintf(str, "Updating memory binding for object %p from mem obj %p to %p", object, pObjInfo->pMemObjInfo->mem, mem);
-                layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, object, 0, MEMTRACK_NONE, "MEM", str);
+                layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, object, 0, MEMTRACK_NONE, "MEM", str);
             }
             // For image objects, make sure default memory state is correctly set
             // TODO : What's the best/correct way to handle this?
-            if (XGL_STRUCTURE_TYPE_IMAGE_CREATE_INFO == pObjInfo->sType) {
-                if (pObjInfo->create_info.image_create_info.usage & (XGL_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | XGL_IMAGE_USAGE_DEPTH_STENCIL_BIT)) {
+            if (VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO == pObjInfo->sType) {
+                if (pObjInfo->create_info.image_create_info.usage & (VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_DEPTH_STENCIL_BIT)) {
                     // TODO::  More memory state transition stuff.
                 }
             }
             pObjInfo->pMemObjInfo = pInfo;
         }
     }
-    return XGL_TRUE;
+    return VK_TRUE;
 }
 
 // Print details of global Obj tracking list
@@ -682,18 +682,18 @@
     MT_OBJ_INFO* pInfo = NULL;
     char str[1024];
     sprintf(str, "Details of Object list of size %lu elements", objectMap.size());
-    layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, MEMTRACK_NONE, "MEM", str);
-    for (map<XGL_OBJECT, MT_OBJ_INFO*>::iterator ii=objectMap.begin(); ii!=objectMap.end(); ++ii) {
+    layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, MEMTRACK_NONE, "MEM", str);
+    for (map<VK_OBJECT, MT_OBJ_INFO*>::iterator ii=objectMap.begin(); ii!=objectMap.end(); ++ii) {
         pInfo = (*ii).second;
         sprintf(str, "    ObjInfo %p has object %p, pMemObjInfo %p", pInfo, pInfo->object, pInfo->pMemObjInfo);
-        layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, pInfo->object, 0, MEMTRACK_NONE, "MEM", str);
+        layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, pInfo->object, 0, MEMTRACK_NONE, "MEM", str);
     }
 }
 
 // For given Object, get 'mem' obj that it's bound to or NULL if no binding
-static XGL_GPU_MEMORY getMemBindingFromObject(const XGL_OBJECT object)
+static VK_GPU_MEMORY getMemBindingFromObject(const VK_OBJECT object)
 {
-    XGL_GPU_MEMORY mem = NULL;
+    VK_GPU_MEMORY mem = NULL;
     MT_OBJ_INFO* pObjInfo = getObjectInfo(object);
     if (pObjInfo) {
         if (pObjInfo->pMemObjInfo) {
@@ -702,14 +702,14 @@
         else {
             char str[1024];
             sprintf(str, "Trying to get mem binding for object %p but object has no mem binding", (void*)object);
-            layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, object, 0, MEMTRACK_MISSING_MEM_BINDINGS, "MEM", str);
+            layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, object, 0, MEMTRACK_MISSING_MEM_BINDINGS, "MEM", str);
             printObjList();
         }
     }
     else {
         char str[1024];
         sprintf(str, "Trying to get mem binding for object %p but no such object in global list", (void*)object);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, object, 0, MEMTRACK_INVALID_OBJECT, "MEM", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, object, 0, MEMTRACK_INVALID_OBJECT, "MEM", str);
         printObjList();
     }
     return mem;
@@ -722,38 +722,38 @@
     // Just printing each msg individually for now, may want to package these into single large print
     char str[1024];
     sprintf(str, "MEM INFO : Details of Memory Object list of size %lu elements", memObjMap.size());
-    layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, MEMTRACK_NONE, "MEM", str);
+    layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, MEMTRACK_NONE, "MEM", str);
 
-    for (map<XGL_GPU_MEMORY, MT_MEM_OBJ_INFO*>::iterator ii=memObjMap.begin(); ii!=memObjMap.end(); ++ii) {
+    for (map<VK_GPU_MEMORY, MT_MEM_OBJ_INFO*>::iterator ii=memObjMap.begin(); ii!=memObjMap.end(); ++ii) {
         pInfo = (*ii).second;
 
         sprintf(str, "    ===MemObjInfo at %p===", (void*)pInfo);
-        layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, MEMTRACK_NONE, "MEM", str);
+        layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, MEMTRACK_NONE, "MEM", str);
         sprintf(str, "    Mem object: %p", (void*)pInfo->mem);
-        layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, MEMTRACK_NONE, "MEM", str);
+        layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, MEMTRACK_NONE, "MEM", str);
         sprintf(str, "    Ref Count: %u", pInfo->refCount);
-        layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, MEMTRACK_NONE, "MEM", str);
+        layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, MEMTRACK_NONE, "MEM", str);
         if (0 != pInfo->allocInfo.allocationSize) {
-            string pAllocInfoMsg = xgl_print_xgl_memory_alloc_info(&pInfo->allocInfo, "{MEM}INFO :       ");
+            string pAllocInfoMsg = vk_print_vk_memory_alloc_info(&pInfo->allocInfo, "{MEM}INFO :       ");
             sprintf(str, "    Mem Alloc info:\n%s", pAllocInfoMsg.c_str());
-            layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, MEMTRACK_NONE, "MEM", str);
+            layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, MEMTRACK_NONE, "MEM", str);
         } else {
-            sprintf(str, "    Mem Alloc info is NULL (alloc done by xglWsiX11CreatePresentableImage())");
-            layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, MEMTRACK_NONE, "MEM", str);
+            sprintf(str, "    Mem Alloc info is NULL (alloc done by vkWsiX11CreatePresentableImage())");
+            layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, MEMTRACK_NONE, "MEM", str);
         }
 
-        sprintf(str, "    XGL OBJECT Binding list of size %lu elements:", pInfo->pObjBindings.size());
-        layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, MEMTRACK_NONE, "MEM", str);
-        for (list<XGL_OBJECT>::iterator it = pInfo->pObjBindings.begin(); it != pInfo->pObjBindings.end(); ++it) {
-            sprintf(str, "       XGL OBJECT %p", (*it));
-            layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, MEMTRACK_NONE, "MEM", str);
+        sprintf(str, "    VK OBJECT Binding list of size %lu elements:", pInfo->pObjBindings.size());
+        layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, MEMTRACK_NONE, "MEM", str);
+        for (list<VK_OBJECT>::iterator it = pInfo->pObjBindings.begin(); it != pInfo->pObjBindings.end(); ++it) {
+            sprintf(str, "       VK OBJECT %p", (*it));
+            layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, MEMTRACK_NONE, "MEM", str);
         }
 
-        sprintf(str, "    XGL Command Buffer (CB) binding list of size %lu elements", pInfo->pCmdBufferBindings.size());
-        layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, MEMTRACK_NONE, "MEM", str);
-        for (list<XGL_CMD_BUFFER>::iterator it = pInfo->pCmdBufferBindings.begin(); it != pInfo->pCmdBufferBindings.end(); ++it) {
-            sprintf(str, "      XGL CB %p", (*it));
-            layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, MEMTRACK_NONE, "MEM", str);
+        sprintf(str, "    VK Command Buffer (CB) binding list of size %lu elements", pInfo->pCmdBufferBindings.size());
+        layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, MEMTRACK_NONE, "MEM", str);
+        for (list<VK_CMD_BUFFER>::iterator it = pInfo->pCmdBufferBindings.begin(); it != pInfo->pCmdBufferBindings.end(); ++it) {
+            sprintf(str, "      VK CB %p", (*it));
+            layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, MEMTRACK_NONE, "MEM", str);
         }
     }
 }
@@ -763,19 +763,19 @@
     char str[1024] = {0};
     MT_CB_INFO* pCBInfo = NULL;
     sprintf(str, "Details of CB list of size %lu elements", cbMap.size());
-    layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, MEMTRACK_NONE, "MEM", str);
+    layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, MEMTRACK_NONE, "MEM", str);
 
-    for (map<XGL_CMD_BUFFER, MT_CB_INFO*>::iterator ii=cbMap.begin(); ii!=cbMap.end(); ++ii) {
+    for (map<VK_CMD_BUFFER, MT_CB_INFO*>::iterator ii=cbMap.begin(); ii!=cbMap.end(); ++ii) {
         pCBInfo = (*ii).second;
 
         sprintf(str, "    CB Info (%p) has CB %p, fenceId %" PRIx64", and fence %p",
             (void*)pCBInfo, (void*)pCBInfo->cmdBuffer, pCBInfo->fenceId,
             (void*)getFenceFromId(pCBInfo->fenceId));
-        layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, MEMTRACK_NONE, "MEM", str);
+        layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, MEMTRACK_NONE, "MEM", str);
 
-        for (list<XGL_GPU_MEMORY>::iterator it = pCBInfo->pMemObjList.begin(); it != pCBInfo->pMemObjList.end(); ++it) {
+        for (list<VK_GPU_MEMORY>::iterator it = pCBInfo->pMemObjList.begin(); it != pCBInfo->pMemObjList.end(); ++it) {
             sprintf(str, "      Mem obj %p", (*it));
-            layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, MEMTRACK_NONE, "MEM", str);
+            layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, MEMTRACK_NONE, "MEM", str);
         }
     }
 }
@@ -787,7 +787,7 @@
     getLayerOptionEnum("MemTrackerReportLevel", (uint32_t *) &g_reportingLevel);
     g_actionIsDefault = getLayerOptionEnum("MemTrackerDebugAction", (uint32_t *) &g_debugAction);
 
-    if (g_debugAction & XGL_DBG_LAYER_ACTION_LOG_MSG)
+    if (g_debugAction & VK_DBG_LAYER_ACTION_LOG_MSG)
     {
         strOpt = getLayerOption("MemTrackerLogFilename");
         if (strOpt)
@@ -800,20 +800,20 @@
 
     // initialize Layer dispatch table
     // TODO handle multiple GPUs
-    xglGetProcAddrType fpNextGPA;
+    vkGetProcAddrType fpNextGPA;
     fpNextGPA = pCurObj->pGPA;
     assert(fpNextGPA);
 
-    layer_initialize_dispatch_table(&nextTable, fpNextGPA, (XGL_PHYSICAL_GPU) pCurObj->nextObject);
+    layer_initialize_dispatch_table(&nextTable, fpNextGPA, (VK_PHYSICAL_GPU) pCurObj->nextObject);
 
-    xglGetProcAddrType fpGetProcAddr = (xglGetProcAddrType)fpNextGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (char *) "xglGetProcAddr");
+    vkGetProcAddrType fpGetProcAddr = (vkGetProcAddrType)fpNextGPA((VK_PHYSICAL_GPU) pCurObj->nextObject, (char *) "vkGetProcAddr");
     nextTable.GetProcAddr = fpGetProcAddr;
 
     if (!globalLockInitialized)
     {
         // TODO/TBD: Need to delete this mutex sometime.  How???  One
-        // suggestion is to call this during xglCreateInstance(), and then we
-        // can clean it up during xglDestroyInstance().  However, that requires
+        // suggestion is to call this during vkCreateInstance(), and then we
+        // can clean it up during vkDestroyInstance().  However, that requires
         // that the layer have per-instance locks.  We need to come back and
         // address this soon.
         loader_platform_thread_create_mutex(&globalLock);
@@ -821,39 +821,39 @@
     }
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateDevice(XGL_PHYSICAL_GPU gpu, const XGL_DEVICE_CREATE_INFO* pCreateInfo, XGL_DEVICE* pDevice)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDevice(VK_PHYSICAL_GPU gpu, const VK_DEVICE_CREATE_INFO* pCreateInfo, VK_DEVICE* pDevice)
 {
-    XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) gpu;
+    VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
     pCurObj = gpuw;
     loader_platform_thread_once(&g_initOnce, initMemTracker);
-    XGL_RESULT result = nextTable.CreateDevice((XGL_PHYSICAL_GPU)gpuw->nextObject, pCreateInfo, pDevice);
+    VK_RESULT result = nextTable.CreateDevice((VK_PHYSICAL_GPU)gpuw->nextObject, pCreateInfo, pDevice);
     // Save off device in case we need it to create Fences
     globalDevice = *pDevice;
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDestroyDevice(XGL_DEVICE device)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkDestroyDevice(VK_DEVICE device)
 {
     char str[1024];
-    sprintf(str, "Printing List details prior to xglDestroyDevice()");
+    sprintf(str, "Printing List details prior to vkDestroyDevice()");
     loader_platform_thread_lock_mutex(&globalLock);
-    layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, device, 0, MEMTRACK_NONE, "MEM", str);
+    layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, device, 0, MEMTRACK_NONE, "MEM", str);
     printMemList();
     printCBList();
     printObjList();
-    if (XGL_FALSE == deleteCBInfoList()) {
-        sprintf(str, "Issue deleting global CB list in xglDestroyDevice()");
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, device, 0, MEMTRACK_INTERNAL_ERROR, "MEM", str);
+    if (VK_FALSE == deleteCBInfoList()) {
+        sprintf(str, "Issue deleting global CB list in vkDestroyDevice()");
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, device, 0, MEMTRACK_INTERNAL_ERROR, "MEM", str);
     }
     // Report any memory leaks
     MT_MEM_OBJ_INFO* pInfo = NULL;
-    for (map<XGL_GPU_MEMORY, MT_MEM_OBJ_INFO*>::iterator ii=memObjMap.begin(); ii!=memObjMap.end(); ++ii) {
+    for (map<VK_GPU_MEMORY, MT_MEM_OBJ_INFO*>::iterator ii=memObjMap.begin(); ii!=memObjMap.end(); ++ii) {
         pInfo = (*ii).second;
 
         if (pInfo->allocInfo.allocationSize != 0) {
-            sprintf(str, "Mem Object %p has not been freed. You should clean up this memory by calling xglFreeMemory(%p) prior to xglDestroyDevice().",
+            sprintf(str, "Mem Object %p has not been freed. You should clean up this memory by calling vkFreeMemory(%p) prior to vkDestroyDevice().",
                 pInfo->mem, pInfo->mem);
-            layerCbMsg(XGL_DBG_MSG_WARNING, XGL_VALIDATION_LEVEL_0, pInfo->mem, 0, MEMTRACK_MEMORY_LEAK, "MEM", str);
+            layerCbMsg(VK_DBG_MSG_WARNING, VK_VALIDATION_LEVEL_0, pInfo->mem, 0, MEMTRACK_MEMORY_LEAK, "MEM", str);
         }
     }
 
@@ -861,54 +861,54 @@
     deleteQueueInfoList();
 
     loader_platform_thread_unlock_mutex(&globalLock);
-    XGL_RESULT result = nextTable.DestroyDevice(device);
+    VK_RESULT result = nextTable.DestroyDevice(device);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglGetExtensionSupport(XGL_PHYSICAL_GPU gpu, const char* pExtName)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkGetExtensionSupport(VK_PHYSICAL_GPU gpu, const char* pExtName)
 {
-    XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) gpu;
-    XGL_RESULT result;
+    VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
+    VK_RESULT result;
     /* This entrypoint is NOT going to init its own dispatch table since loader calls here early */
     if (!strcmp(pExtName, "MemTracker"))
     {
-        result = XGL_SUCCESS;
+        result = VK_SUCCESS;
     } else if (nextTable.GetExtensionSupport != NULL)
     {
-        result = nextTable.GetExtensionSupport((XGL_PHYSICAL_GPU)gpuw->nextObject, pExtName);
+        result = nextTable.GetExtensionSupport((VK_PHYSICAL_GPU)gpuw->nextObject, pExtName);
     } else
     {
-        result = XGL_ERROR_INVALID_EXTENSION;
+        result = VK_ERROR_INVALID_EXTENSION;
     }
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglEnumerateLayers(XGL_PHYSICAL_GPU gpu, size_t maxLayerCount,
+VK_LAYER_EXPORT VK_RESULT VKAPI vkEnumerateLayers(VK_PHYSICAL_GPU gpu, size_t maxLayerCount,
     size_t maxStringSize, size_t* pOutLayerCount, char* const* pOutLayers, void* pReserved)
 {
         if (gpu != NULL)
     {
-        XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) gpu;
+        VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
         pCurObj = gpuw;
         loader_platform_thread_once(&g_initOnce, initMemTracker);
-        XGL_RESULT result = nextTable.EnumerateLayers((XGL_PHYSICAL_GPU)gpuw->nextObject, maxLayerCount,
+        VK_RESULT result = nextTable.EnumerateLayers((VK_PHYSICAL_GPU)gpuw->nextObject, maxLayerCount,
             maxStringSize, pOutLayerCount, pOutLayers, pReserved);
         return result;
     } else
     {
         if (pOutLayerCount == NULL || pOutLayers == NULL || pOutLayers[0] == NULL)
-            return XGL_ERROR_INVALID_POINTER;
+            return VK_ERROR_INVALID_POINTER;
         // This layer compatible with all GPUs
         *pOutLayerCount = 1;
         strncpy((char *) pOutLayers[0], "MemTracker", maxStringSize);
-        return XGL_SUCCESS;
+        return VK_SUCCESS;
     }
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglGetDeviceQueue(XGL_DEVICE device, uint32_t queueNodeIndex, uint32_t queueIndex, XGL_QUEUE* pQueue)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkGetDeviceQueue(VK_DEVICE device, uint32_t queueNodeIndex, uint32_t queueIndex, VK_QUEUE* pQueue)
 {
-    XGL_RESULT result = nextTable.GetDeviceQueue(device, queueNodeIndex, queueIndex, pQueue);
-    if (result == XGL_SUCCESS) {
+    VK_RESULT result = nextTable.GetDeviceQueue(device, queueNodeIndex, queueIndex, pQueue);
+    if (result == VK_SUCCESS) {
         loader_platform_thread_lock_mutex(&globalLock);
         addQueueInfo(*pQueue);
         loader_platform_thread_unlock_mutex(&globalLock);
@@ -916,24 +916,24 @@
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglQueueAddMemReference(XGL_QUEUE queue, XGL_GPU_MEMORY mem)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkQueueAddMemReference(VK_QUEUE queue, VK_GPU_MEMORY mem)
 {
-    XGL_RESULT result = nextTable.QueueAddMemReference(queue, mem);
-    if (result == XGL_SUCCESS) {
+    VK_RESULT result = nextTable.QueueAddMemReference(queue, mem);
+    if (result == VK_SUCCESS) {
         loader_platform_thread_lock_mutex(&globalLock);
 
         MT_QUEUE_INFO *pQueueInfo = queueMap[queue];
         if (pQueueInfo == NULL) {
             char str[1024];
             sprintf(str, "Unknown Queue %p", queue);
-            layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, queue, 0, MEMTRACK_INVALID_QUEUE, "MEM", str);
+            layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, queue, 0, MEMTRACK_INVALID_QUEUE, "MEM", str);
         }
         else {
-            if (checkMemRef(queue, mem) == XGL_TRUE) {
+            if (checkMemRef(queue, mem) == VK_TRUE) {
                 // Alread in list, just warn
                 char str[1024];
                 sprintf(str, "Request to add a memory reference (%p) to Queue %p -- ref is already present in the queue's reference list", mem, queue);
-                layerCbMsg(XGL_DBG_MSG_WARNING, XGL_VALIDATION_LEVEL_0, mem, 0, MEMTRACK_INVALID_MEM_REF, "MEM", str);
+                layerCbMsg(VK_DBG_MSG_WARNING, VK_VALIDATION_LEVEL_0, mem, 0, MEMTRACK_INVALID_MEM_REF, "MEM", str);
             }
             else {
                 // Add to queue's memory reference list
@@ -945,21 +945,21 @@
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglQueueRemoveMemReference(XGL_QUEUE queue, XGL_GPU_MEMORY mem)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkQueueRemoveMemReference(VK_QUEUE queue, VK_GPU_MEMORY mem)
 {
     // TODO : Decrement ref count for this memory reference on this queue. Remove if ref count is zero.
-    XGL_RESULT result = nextTable.QueueRemoveMemReference(queue, mem);
-    if (result == XGL_SUCCESS) {
+    VK_RESULT result = nextTable.QueueRemoveMemReference(queue, mem);
+    if (result == VK_SUCCESS) {
         loader_platform_thread_lock_mutex(&globalLock);
 
         MT_QUEUE_INFO *pQueueInfo = queueMap[queue];
         if (pQueueInfo == NULL) {
             char str[1024];
             sprintf(str, "Unknown Queue %p", queue);
-            layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, queue, 0, MEMTRACK_INVALID_QUEUE, "MEM", str);
+            layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, queue, 0, MEMTRACK_INVALID_QUEUE, "MEM", str);
         }
         else {
-            for (list<XGL_GPU_MEMORY>::iterator it = pQueueInfo->pMemRefList.begin(); it != pQueueInfo->pMemRefList.end(); ++it) {
+            for (list<VK_GPU_MEMORY>::iterator it = pQueueInfo->pMemRefList.begin(); it != pQueueInfo->pMemRefList.end(); ++it) {
                 if ((*it) == mem) {
                     it = pQueueInfo->pMemRefList.erase(it);
                 }
@@ -970,11 +970,11 @@
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglQueueSubmit(
-    XGL_QUEUE             queue,
+VK_LAYER_EXPORT VK_RESULT VKAPI vkQueueSubmit(
+    VK_QUEUE             queue,
     uint32_t              cmdBufferCount,
-    const XGL_CMD_BUFFER *pCmdBuffers,
-    XGL_FENCE             fence)
+    const VK_CMD_BUFFER *pCmdBuffers,
+    VK_FENCE             fence)
 {
     loader_platform_thread_lock_mutex(&globalLock);
     // TODO : Need to track fence and clear mem references when fence clears
@@ -988,20 +988,20 @@
         pCBInfo->fenceId = fenceId;
     }
 
-    if (XGL_FALSE == validateQueueMemRefs(queue, cmdBufferCount, pCmdBuffers)) {
+    if (VK_FALSE == validateQueueMemRefs(queue, cmdBufferCount, pCmdBuffers)) {
         char str[1024];
         sprintf(str, "Unable to verify memory references for Queue %p", queue);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, queue, 0, MEMTRACK_INVALID_MEM_REF, "MEM", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, queue, 0, MEMTRACK_INVALID_MEM_REF, "MEM", str);
     }
 
     loader_platform_thread_unlock_mutex(&globalLock);
-    XGL_RESULT result = nextTable.QueueSubmit(queue, cmdBufferCount, pCmdBuffers, getFenceFromId(fenceId));
+    VK_RESULT result = nextTable.QueueSubmit(queue, cmdBufferCount, pCmdBuffers, getFenceFromId(fenceId));
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglAllocMemory(XGL_DEVICE device, const XGL_MEMORY_ALLOC_INFO* pAllocInfo, XGL_GPU_MEMORY* pMem)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkAllocMemory(VK_DEVICE device, const VK_MEMORY_ALLOC_INFO* pAllocInfo, VK_GPU_MEMORY* pMem)
 {
-    XGL_RESULT result = nextTable.AllocMemory(device, pAllocInfo, pMem);
+    VK_RESULT result = nextTable.AllocMemory(device, pAllocInfo, pMem);
     // TODO : Track allocations and overall size here
     loader_platform_thread_lock_mutex(&globalLock);
     addMemObjInfo(*pMem, pAllocInfo);
@@ -1010,93 +1010,93 @@
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglFreeMemory(XGL_GPU_MEMORY mem)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkFreeMemory(VK_GPU_MEMORY mem)
 {
-    /* From spec : A memory object is freed by calling xglFreeMemory() when it is no longer needed. Before
+    /* From spec : A memory object is freed by calling vkFreeMemory() when it is no longer needed. Before
      * freeing a memory object, an application must ensure the memory object is unbound from
      * all API objects referencing it and that it is not referenced by any queued command buffers
      */
     loader_platform_thread_lock_mutex(&globalLock);
-    if (XGL_FALSE == freeMemObjInfo(mem, false)) {
+    if (VK_FALSE == freeMemObjInfo(mem, false)) {
         char str[1024];
         sprintf(str, "Issue while freeing mem obj %p", (void*)mem);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, mem, 0, MEMTRACK_FREE_MEM_ERROR, "MEM", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, mem, 0, MEMTRACK_FREE_MEM_ERROR, "MEM", str);
     }
     printMemList();
     printObjList();
     printCBList();
     loader_platform_thread_unlock_mutex(&globalLock);
-    XGL_RESULT result = nextTable.FreeMemory(mem);
+    VK_RESULT result = nextTable.FreeMemory(mem);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglSetMemoryPriority(XGL_GPU_MEMORY mem, XGL_MEMORY_PRIORITY priority)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkSetMemoryPriority(VK_GPU_MEMORY mem, VK_MEMORY_PRIORITY priority)
 {
     // TODO : Update tracking for this alloc
     //  Make sure memory is not pinned, which can't have priority set
-    XGL_RESULT result = nextTable.SetMemoryPriority(mem, priority);
+    VK_RESULT result = nextTable.SetMemoryPriority(mem, priority);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglMapMemory(XGL_GPU_MEMORY mem, XGL_FLAGS flags, void** ppData)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkMapMemory(VK_GPU_MEMORY mem, VK_FLAGS flags, void** ppData)
 {
     // TODO : Track when memory is mapped
     loader_platform_thread_lock_mutex(&globalLock);
     MT_MEM_OBJ_INFO *pMemObj = getMemObjInfo(mem);
-    if ((pMemObj->allocInfo.memProps & XGL_MEMORY_PROPERTY_CPU_VISIBLE_BIT) == 0) {
+    if ((pMemObj->allocInfo.memProps & VK_MEMORY_PROPERTY_CPU_VISIBLE_BIT) == 0) {
         char str[1024];
-        sprintf(str, "Mapping Memory (%p) without XGL_MEMORY_PROPERTY_CPU_VISIBLE_BIT set", (void*)mem);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, mem, 0, MEMTRACK_INVALID_STATE, "MEM", str);
+        sprintf(str, "Mapping Memory (%p) without VK_MEMORY_PROPERTY_CPU_VISIBLE_BIT set", (void*)mem);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, mem, 0, MEMTRACK_INVALID_STATE, "MEM", str);
     }
     loader_platform_thread_unlock_mutex(&globalLock);
-    XGL_RESULT result = nextTable.MapMemory(mem, flags, ppData);
+    VK_RESULT result = nextTable.MapMemory(mem, flags, ppData);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglUnmapMemory(XGL_GPU_MEMORY mem)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkUnmapMemory(VK_GPU_MEMORY mem)
 {
     // TODO : Track as memory gets unmapped, do we want to check what changed following map?
     //   Make sure that memory was ever mapped to begin with
-    XGL_RESULT result = nextTable.UnmapMemory(mem);
+    VK_RESULT result = nextTable.UnmapMemory(mem);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglPinSystemMemory(XGL_DEVICE device, const void* pSysMem, size_t memSize, XGL_GPU_MEMORY* pMem)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkPinSystemMemory(VK_DEVICE device, const void* pSysMem, size_t memSize, VK_GPU_MEMORY* pMem)
 {
     // TODO : Track this
     //  Verify that memory is actually pinnable
-    XGL_RESULT result = nextTable.PinSystemMemory(device, pSysMem, memSize, pMem);
+    VK_RESULT result = nextTable.PinSystemMemory(device, pSysMem, memSize, pMem);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglOpenSharedMemory(XGL_DEVICE device, const XGL_MEMORY_OPEN_INFO* pOpenInfo, XGL_GPU_MEMORY* pMem)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkOpenSharedMemory(VK_DEVICE device, const VK_MEMORY_OPEN_INFO* pOpenInfo, VK_GPU_MEMORY* pMem)
 {
     // TODO : Track this
-    XGL_RESULT result = nextTable.OpenSharedMemory(device, pOpenInfo, pMem);
+    VK_RESULT result = nextTable.OpenSharedMemory(device, pOpenInfo, pMem);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglOpenPeerMemory(XGL_DEVICE device, const XGL_PEER_MEMORY_OPEN_INFO* pOpenInfo, XGL_GPU_MEMORY* pMem)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkOpenPeerMemory(VK_DEVICE device, const VK_PEER_MEMORY_OPEN_INFO* pOpenInfo, VK_GPU_MEMORY* pMem)
 {
     // TODO : Track this
-    XGL_RESULT result = nextTable.OpenPeerMemory(device, pOpenInfo, pMem);
+    VK_RESULT result = nextTable.OpenPeerMemory(device, pOpenInfo, pMem);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglOpenPeerImage(XGL_DEVICE device, const XGL_PEER_IMAGE_OPEN_INFO* pOpenInfo, XGL_IMAGE* pImage, XGL_GPU_MEMORY* pMem)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkOpenPeerImage(VK_DEVICE device, const VK_PEER_IMAGE_OPEN_INFO* pOpenInfo, VK_IMAGE* pImage, VK_GPU_MEMORY* pMem)
 {
     // TODO : Track this
-    XGL_RESULT result = nextTable.OpenPeerImage(device, pOpenInfo, pImage, pMem);
+    VK_RESULT result = nextTable.OpenPeerImage(device, pOpenInfo, pImage, pMem);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDestroyObject(XGL_OBJECT object)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkDestroyObject(VK_OBJECT object)
 {
     loader_platform_thread_lock_mutex(&globalLock);
 
     // First check if this is a CmdBuffer
-    if (NULL != getCBInfo((XGL_CMD_BUFFER)object)) {
-        deleteCBInfo((XGL_CMD_BUFFER)object);
+    if (NULL != getCBInfo((VK_CMD_BUFFER)object)) {
+        deleteCBInfo((VK_CMD_BUFFER)object);
     }
 
     if (objectMap.find(object) != objectMap.end()) {
@@ -1104,14 +1104,14 @@
         if (pDelInfo->pMemObjInfo) {
             // Wsi allocated Memory is tied to image object so clear the binding and free that memory automatically
             if (0 == pDelInfo->pMemObjInfo->allocInfo.allocationSize) { // Wsi allocated memory has NULL allocInfo w/ 0 size
-                XGL_GPU_MEMORY memToFree = pDelInfo->pMemObjInfo->mem;
+                VK_GPU_MEMORY memToFree = pDelInfo->pMemObjInfo->mem;
                 clearObjectBinding(object);
                 freeMemObjInfo(memToFree, true);
             }
             else {
                 char str[1024];
-                sprintf(str, "Destroying obj %p that is still bound to memory object %p\nYou should first clear binding by calling xglBindObjectMemory(%p, 0, XGL_NULL_HANDLE, 0)", object, (void*)pDelInfo->pMemObjInfo->mem, object);
-                layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, object, 0, MEMTRACK_DESTROY_OBJECT_ERROR, "MEM", str);
+                sprintf(str, "Destroying obj %p that is still bound to memory object %p\nYou should first clear binding by calling vkBindObjectMemory(%p, 0, VK_NULL_HANDLE, 0)", object, (void*)pDelInfo->pMemObjInfo->mem, object);
+                layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, object, 0, MEMTRACK_DESTROY_OBJECT_ERROR, "MEM", str);
                 // From the spec : If an object has previous memory binding, it is required to unbind memory from an API object before it is destroyed.
                 clearObjectBinding(object);
             }
@@ -1121,28 +1121,28 @@
     }
 
     loader_platform_thread_unlock_mutex(&globalLock);
-    XGL_RESULT result = nextTable.DestroyObject(object);
+    VK_RESULT result = nextTable.DestroyObject(object);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglGetObjectInfo(XGL_BASE_OBJECT object, XGL_OBJECT_INFO_TYPE infoType, size_t* pDataSize, void* pData)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkGetObjectInfo(VK_BASE_OBJECT object, VK_OBJECT_INFO_TYPE infoType, size_t* pDataSize, void* pData)
 {
     // TODO : What to track here?
     //   Could potentially save returned mem requirements and validate values passed into BindObjectMemory for this object
     // From spec : The only objects that are guaranteed to have no external memory requirements are devices, queues, command buffers, shaders and memory objects.
-    XGL_RESULT result = nextTable.GetObjectInfo(object, infoType, pDataSize, pData);
+    VK_RESULT result = nextTable.GetObjectInfo(object, infoType, pDataSize, pData);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglBindObjectMemory(XGL_OBJECT object, uint32_t allocationIdx, XGL_GPU_MEMORY mem, XGL_GPU_SIZE offset)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkBindObjectMemory(VK_OBJECT object, uint32_t allocationIdx, VK_GPU_MEMORY mem, VK_GPU_SIZE offset)
 {
-    XGL_RESULT result = nextTable.BindObjectMemory(object, allocationIdx, mem, offset);
+    VK_RESULT result = nextTable.BindObjectMemory(object, allocationIdx, mem, offset);
     loader_platform_thread_lock_mutex(&globalLock);
     // Track objects tied to memory
-    if (XGL_FALSE == updateObjectBinding(object, mem)) {
+    if (VK_FALSE == updateObjectBinding(object, mem)) {
         char str[1024];
         sprintf(str, "Unable to set object %p binding to mem obj %p", (void*)object, (void*)mem);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, object, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, object, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
     }
     printObjList();
     printMemList();
@@ -1150,28 +1150,28 @@
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateFence(XGL_DEVICE device, const XGL_FENCE_CREATE_INFO* pCreateInfo, XGL_FENCE* pFence)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateFence(VK_DEVICE device, const VK_FENCE_CREATE_INFO* pCreateInfo, VK_FENCE* pFence)
 {
-    XGL_RESULT result = nextTable.CreateFence(device, pCreateInfo, pFence);
-    if (XGL_SUCCESS == result) {
+    VK_RESULT result = nextTable.CreateFence(device, pCreateInfo, pFence);
+    if (VK_SUCCESS == result) {
         loader_platform_thread_lock_mutex(&globalLock);
-        addObjectInfo(*pFence, pCreateInfo->sType, pCreateInfo, sizeof(XGL_FENCE_CREATE_INFO), "fence");
+        addObjectInfo(*pFence, pCreateInfo->sType, pCreateInfo, sizeof(VK_FENCE_CREATE_INFO), "fence");
         loader_platform_thread_unlock_mutex(&globalLock);
     }
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglResetFences(XGL_DEVICE device, uint32_t fenceCount, XGL_FENCE* pFences)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkResetFences(VK_DEVICE device, uint32_t fenceCount, VK_FENCE* pFences)
 {
-    XGL_RESULT result = nextTable.ResetFences(device, fenceCount, pFences);
-    if (XGL_SUCCESS == result) {
+    VK_RESULT result = nextTable.ResetFences(device, fenceCount, pFences);
+    if (VK_SUCCESS == result) {
         loader_platform_thread_lock_mutex(&globalLock);
         // Reset fence state in fenceCreateInfo structure
         for (uint32_t i = 0; i < fenceCount; i++) {
             MT_OBJ_INFO* pObjectInfo = getObjectInfo(pFences[i]);
             if (pObjectInfo != NULL) {
                 pObjectInfo->create_info.fence_create_info.flags =
-                    static_cast<XGL_FENCE_CREATE_FLAGS>(pObjectInfo->create_info.fence_create_info.flags & ~XGL_FENCE_CREATE_SIGNALED_BIT);
+                    static_cast<VK_FENCE_CREATE_FLAGS>(pObjectInfo->create_info.fence_create_info.flags & ~VK_FENCE_CREATE_SIGNALED_BIT);
             }
         }
         loader_platform_thread_unlock_mutex(&globalLock);
@@ -1179,10 +1179,10 @@
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglGetFenceStatus(XGL_FENCE fence)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkGetFenceStatus(VK_FENCE fence)
 {
-    XGL_RESULT result = nextTable.GetFenceStatus(fence);
-    if (XGL_SUCCESS == result) {
+    VK_RESULT result = nextTable.GetFenceStatus(fence);
+    if (VK_SUCCESS == result) {
         loader_platform_thread_lock_mutex(&globalLock);
         updateFenceTracking(fence);
         loader_platform_thread_unlock_mutex(&globalLock);
@@ -1190,24 +1190,24 @@
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglWaitForFences(XGL_DEVICE device, uint32_t fenceCount, const XGL_FENCE* pFences, bool32_t waitAll, uint64_t timeout)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkWaitForFences(VK_DEVICE device, uint32_t fenceCount, const VK_FENCE* pFences, bool32_t waitAll, uint64_t timeout)
 {
     // Verify fence status of submitted fences
     for(uint32_t i = 0; i < fenceCount; i++) {
         MT_OBJ_INFO* pObjectInfo = getObjectInfo(pFences[i]);
         if (pObjectInfo != NULL) {
-            if (pObjectInfo->create_info.fence_create_info.flags == XGL_FENCE_CREATE_SIGNALED_BIT) {
+            if (pObjectInfo->create_info.fence_create_info.flags == VK_FENCE_CREATE_SIGNALED_BIT) {
                 char str[1024];
-                sprintf(str, "xglWaitForFences specified signaled-state Fence %p.  Fences must be reset before being submitted", pFences[i]);
-                layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, pFences[i], 0, MEMTRACK_INVALID_FENCE_STATE, "MEM", str);
+                sprintf(str, "vkWaitForFences specified signaled-state Fence %p.  Fences must be reset before being submitted", pFences[i]);
+                layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, pFences[i], 0, MEMTRACK_INVALID_FENCE_STATE, "MEM", str);
             }
         }
     }
 
-    XGL_RESULT result = nextTable.WaitForFences(device, fenceCount, pFences, waitAll, timeout);
+    VK_RESULT result = nextTable.WaitForFences(device, fenceCount, pFences, waitAll, timeout);
     loader_platform_thread_lock_mutex(&globalLock);
 
-    if (XGL_SUCCESS == result) {
+    if (VK_SUCCESS == result) {
         if (waitAll || fenceCount == 1) { // Clear all the fences
             for(uint32_t i = 0; i < fenceCount; i++) {
                 updateFenceTracking(pFences[i]);
@@ -1218,10 +1218,10 @@
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglQueueWaitIdle(XGL_QUEUE queue)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkQueueWaitIdle(VK_QUEUE queue)
 {
-    XGL_RESULT result = nextTable.QueueWaitIdle(queue);
-    if (XGL_SUCCESS == result) {
+    VK_RESULT result = nextTable.QueueWaitIdle(queue);
+    if (VK_SUCCESS == result) {
         loader_platform_thread_lock_mutex(&globalLock);
         retireQueueFences(queue);
         loader_platform_thread_unlock_mutex(&globalLock);
@@ -1229,10 +1229,10 @@
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDeviceWaitIdle(XGL_DEVICE device)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkDeviceWaitIdle(VK_DEVICE device)
 {
-    XGL_RESULT result = nextTable.DeviceWaitIdle(device);
-    if (XGL_SUCCESS == result) {
+    VK_RESULT result = nextTable.DeviceWaitIdle(device);
+    if (VK_SUCCESS == result) {
         loader_platform_thread_lock_mutex(&globalLock);
         retireDeviceFences(device);
         loader_platform_thread_unlock_mutex(&globalLock);
@@ -1240,200 +1240,200 @@
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateEvent(XGL_DEVICE device, const XGL_EVENT_CREATE_INFO* pCreateInfo, XGL_EVENT* pEvent)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateEvent(VK_DEVICE device, const VK_EVENT_CREATE_INFO* pCreateInfo, VK_EVENT* pEvent)
 {
-    XGL_RESULT result = nextTable.CreateEvent(device, pCreateInfo, pEvent);
-    if (XGL_SUCCESS == result) {
+    VK_RESULT result = nextTable.CreateEvent(device, pCreateInfo, pEvent);
+    if (VK_SUCCESS == result) {
         loader_platform_thread_lock_mutex(&globalLock);
-        addObjectInfo(*pEvent, pCreateInfo->sType, pCreateInfo, sizeof(XGL_EVENT_CREATE_INFO), "event");
+        addObjectInfo(*pEvent, pCreateInfo->sType, pCreateInfo, sizeof(VK_EVENT_CREATE_INFO), "event");
         loader_platform_thread_unlock_mutex(&globalLock);
     }
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateQueryPool(XGL_DEVICE device, const XGL_QUERY_POOL_CREATE_INFO* pCreateInfo, XGL_QUERY_POOL* pQueryPool)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateQueryPool(VK_DEVICE device, const VK_QUERY_POOL_CREATE_INFO* pCreateInfo, VK_QUERY_POOL* pQueryPool)
 {
-    XGL_RESULT result = nextTable.CreateQueryPool(device, pCreateInfo, pQueryPool);
-    if (XGL_SUCCESS == result) {
+    VK_RESULT result = nextTable.CreateQueryPool(device, pCreateInfo, pQueryPool);
+    if (VK_SUCCESS == result) {
         loader_platform_thread_lock_mutex(&globalLock);
-        addObjectInfo(*pQueryPool, pCreateInfo->sType, pCreateInfo, sizeof(XGL_QUERY_POOL_CREATE_INFO), "query_pool");
+        addObjectInfo(*pQueryPool, pCreateInfo->sType, pCreateInfo, sizeof(VK_QUERY_POOL_CREATE_INFO), "query_pool");
         loader_platform_thread_unlock_mutex(&globalLock);
     }
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateBuffer(XGL_DEVICE device, const XGL_BUFFER_CREATE_INFO* pCreateInfo, XGL_BUFFER* pBuffer)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateBuffer(VK_DEVICE device, const VK_BUFFER_CREATE_INFO* pCreateInfo, VK_BUFFER* pBuffer)
 {
-    XGL_RESULT result = nextTable.CreateBuffer(device, pCreateInfo, pBuffer);
-    if (XGL_SUCCESS == result) {
+    VK_RESULT result = nextTable.CreateBuffer(device, pCreateInfo, pBuffer);
+    if (VK_SUCCESS == result) {
         loader_platform_thread_lock_mutex(&globalLock);
-        addObjectInfo(*pBuffer, pCreateInfo->sType, pCreateInfo, sizeof(XGL_BUFFER_CREATE_INFO), "buffer");
+        addObjectInfo(*pBuffer, pCreateInfo->sType, pCreateInfo, sizeof(VK_BUFFER_CREATE_INFO), "buffer");
         loader_platform_thread_unlock_mutex(&globalLock);
     }
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateBufferView(XGL_DEVICE device, const XGL_BUFFER_VIEW_CREATE_INFO* pCreateInfo, XGL_BUFFER_VIEW* pView)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateBufferView(VK_DEVICE device, const VK_BUFFER_VIEW_CREATE_INFO* pCreateInfo, VK_BUFFER_VIEW* pView)
 {
-    XGL_RESULT result = nextTable.CreateBufferView(device, pCreateInfo, pView);
-    if (result == XGL_SUCCESS) {
+    VK_RESULT result = nextTable.CreateBufferView(device, pCreateInfo, pView);
+    if (result == VK_SUCCESS) {
         loader_platform_thread_lock_mutex(&globalLock);
-        addObjectInfo(*pView, pCreateInfo->sType, pCreateInfo, sizeof(XGL_BUFFER_VIEW_CREATE_INFO), "buffer_view");
+        addObjectInfo(*pView, pCreateInfo->sType, pCreateInfo, sizeof(VK_BUFFER_VIEW_CREATE_INFO), "buffer_view");
         loader_platform_thread_unlock_mutex(&globalLock);
     }
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateImage(XGL_DEVICE device, const XGL_IMAGE_CREATE_INFO* pCreateInfo, XGL_IMAGE* pImage)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateImage(VK_DEVICE device, const VK_IMAGE_CREATE_INFO* pCreateInfo, VK_IMAGE* pImage)
 {
-    XGL_RESULT result = nextTable.CreateImage(device, pCreateInfo, pImage);
-    if (XGL_SUCCESS == result) {
+    VK_RESULT result = nextTable.CreateImage(device, pCreateInfo, pImage);
+    if (VK_SUCCESS == result) {
         loader_platform_thread_lock_mutex(&globalLock);
-        addObjectInfo(*pImage, pCreateInfo->sType, pCreateInfo, sizeof(XGL_IMAGE_CREATE_INFO), "image");
+        addObjectInfo(*pImage, pCreateInfo->sType, pCreateInfo, sizeof(VK_IMAGE_CREATE_INFO), "image");
         loader_platform_thread_unlock_mutex(&globalLock);
     }
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateImageView(XGL_DEVICE device, const XGL_IMAGE_VIEW_CREATE_INFO* pCreateInfo, XGL_IMAGE_VIEW* pView)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateImageView(VK_DEVICE device, const VK_IMAGE_VIEW_CREATE_INFO* pCreateInfo, VK_IMAGE_VIEW* pView)
 {
-    XGL_RESULT result = nextTable.CreateImageView(device, pCreateInfo, pView);
-    if (result == XGL_SUCCESS) {
+    VK_RESULT result = nextTable.CreateImageView(device, pCreateInfo, pView);
+    if (result == VK_SUCCESS) {
         loader_platform_thread_lock_mutex(&globalLock);
-        addObjectInfo(*pView, pCreateInfo->sType, pCreateInfo, sizeof(XGL_IMAGE_VIEW_CREATE_INFO), "image_view");
+        addObjectInfo(*pView, pCreateInfo->sType, pCreateInfo, sizeof(VK_IMAGE_VIEW_CREATE_INFO), "image_view");
         loader_platform_thread_unlock_mutex(&globalLock);
     }
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateColorAttachmentView(XGL_DEVICE device, const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pCreateInfo,
-    XGL_COLOR_ATTACHMENT_VIEW* pView)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateColorAttachmentView(VK_DEVICE device, const VK_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pCreateInfo,
+    VK_COLOR_ATTACHMENT_VIEW* pView)
 {
-    XGL_RESULT result = nextTable.CreateColorAttachmentView(device, pCreateInfo, pView);
-    if (result == XGL_SUCCESS) {
+    VK_RESULT result = nextTable.CreateColorAttachmentView(device, pCreateInfo, pView);
+    if (result == VK_SUCCESS) {
         loader_platform_thread_lock_mutex(&globalLock);
-        addObjectInfo(*pView, pCreateInfo->sType, pCreateInfo, sizeof(XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO), "color_attachment_view");
+        addObjectInfo(*pView, pCreateInfo->sType, pCreateInfo, sizeof(VK_COLOR_ATTACHMENT_VIEW_CREATE_INFO), "color_attachment_view");
         loader_platform_thread_unlock_mutex(&globalLock);
     }
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateDepthStencilView(XGL_DEVICE device, const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pCreateInfo, XGL_DEPTH_STENCIL_VIEW* pView)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDepthStencilView(VK_DEVICE device, const VK_DEPTH_STENCIL_VIEW_CREATE_INFO* pCreateInfo, VK_DEPTH_STENCIL_VIEW* pView)
 {
-    XGL_RESULT result = nextTable.CreateDepthStencilView(device, pCreateInfo, pView);
-    if (result == XGL_SUCCESS) {
+    VK_RESULT result = nextTable.CreateDepthStencilView(device, pCreateInfo, pView);
+    if (result == VK_SUCCESS) {
         loader_platform_thread_lock_mutex(&globalLock);
-        addObjectInfo(*pView, pCreateInfo->sType, pCreateInfo, sizeof(XGL_DEPTH_STENCIL_VIEW_CREATE_INFO), "ds_view");
+        addObjectInfo(*pView, pCreateInfo->sType, pCreateInfo, sizeof(VK_DEPTH_STENCIL_VIEW_CREATE_INFO), "ds_view");
         loader_platform_thread_unlock_mutex(&globalLock);
     }
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateShader(XGL_DEVICE device, const XGL_SHADER_CREATE_INFO* pCreateInfo, XGL_SHADER* pShader)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateShader(VK_DEVICE device, const VK_SHADER_CREATE_INFO* pCreateInfo, VK_SHADER* pShader)
 {
-    XGL_RESULT result = nextTable.CreateShader(device, pCreateInfo, pShader);
+    VK_RESULT result = nextTable.CreateShader(device, pCreateInfo, pShader);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateGraphicsPipeline(XGL_DEVICE device, const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo, XGL_PIPELINE* pPipeline)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateGraphicsPipeline(VK_DEVICE device, const VK_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo, VK_PIPELINE* pPipeline)
 {
-    XGL_RESULT result = nextTable.CreateGraphicsPipeline(device, pCreateInfo, pPipeline);
-    if (result == XGL_SUCCESS) {
+    VK_RESULT result = nextTable.CreateGraphicsPipeline(device, pCreateInfo, pPipeline);
+    if (result == VK_SUCCESS) {
         loader_platform_thread_lock_mutex(&globalLock);
-        addObjectInfo(*pPipeline, pCreateInfo->sType, pCreateInfo, sizeof(XGL_GRAPHICS_PIPELINE_CREATE_INFO), "graphics_pipeline");
+        addObjectInfo(*pPipeline, pCreateInfo->sType, pCreateInfo, sizeof(VK_GRAPHICS_PIPELINE_CREATE_INFO), "graphics_pipeline");
         loader_platform_thread_unlock_mutex(&globalLock);
     }
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateGraphicsPipelineDerivative(
-        XGL_DEVICE device,
-        const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo,
-        XGL_PIPELINE basePipeline,
-        XGL_PIPELINE* pPipeline)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateGraphicsPipelineDerivative(
+        VK_DEVICE device,
+        const VK_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo,
+        VK_PIPELINE basePipeline,
+        VK_PIPELINE* pPipeline)
 {
-    XGL_RESULT result = nextTable.CreateGraphicsPipelineDerivative(device, pCreateInfo, basePipeline, pPipeline);
-    if (result == XGL_SUCCESS) {
+    VK_RESULT result = nextTable.CreateGraphicsPipelineDerivative(device, pCreateInfo, basePipeline, pPipeline);
+    if (result == VK_SUCCESS) {
         loader_platform_thread_lock_mutex(&globalLock);
-        addObjectInfo(*pPipeline, pCreateInfo->sType, pCreateInfo, sizeof(XGL_GRAPHICS_PIPELINE_CREATE_INFO), "graphics_pipeline");
+        addObjectInfo(*pPipeline, pCreateInfo->sType, pCreateInfo, sizeof(VK_GRAPHICS_PIPELINE_CREATE_INFO), "graphics_pipeline");
         loader_platform_thread_unlock_mutex(&globalLock);
     }
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateComputePipeline(XGL_DEVICE device, const XGL_COMPUTE_PIPELINE_CREATE_INFO* pCreateInfo, XGL_PIPELINE* pPipeline)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateComputePipeline(VK_DEVICE device, const VK_COMPUTE_PIPELINE_CREATE_INFO* pCreateInfo, VK_PIPELINE* pPipeline)
 {
-    XGL_RESULT result = nextTable.CreateComputePipeline(device, pCreateInfo, pPipeline);
-    if (result == XGL_SUCCESS) {
+    VK_RESULT result = nextTable.CreateComputePipeline(device, pCreateInfo, pPipeline);
+    if (result == VK_SUCCESS) {
         loader_platform_thread_lock_mutex(&globalLock);
-        addObjectInfo(*pPipeline, pCreateInfo->sType, pCreateInfo, sizeof(XGL_COMPUTE_PIPELINE_CREATE_INFO), "compute_pipeline");
+        addObjectInfo(*pPipeline, pCreateInfo->sType, pCreateInfo, sizeof(VK_COMPUTE_PIPELINE_CREATE_INFO), "compute_pipeline");
         loader_platform_thread_unlock_mutex(&globalLock);
     }
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateSampler(XGL_DEVICE device, const XGL_SAMPLER_CREATE_INFO* pCreateInfo, XGL_SAMPLER* pSampler)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateSampler(VK_DEVICE device, const VK_SAMPLER_CREATE_INFO* pCreateInfo, VK_SAMPLER* pSampler)
 {
-    XGL_RESULT result = nextTable.CreateSampler(device, pCreateInfo, pSampler);
-    if (result == XGL_SUCCESS) {
+    VK_RESULT result = nextTable.CreateSampler(device, pCreateInfo, pSampler);
+    if (result == VK_SUCCESS) {
         loader_platform_thread_lock_mutex(&globalLock);
-        addObjectInfo(*pSampler, pCreateInfo->sType, pCreateInfo, sizeof(XGL_SAMPLER_CREATE_INFO), "sampler");
+        addObjectInfo(*pSampler, pCreateInfo->sType, pCreateInfo, sizeof(VK_SAMPLER_CREATE_INFO), "sampler");
         loader_platform_thread_unlock_mutex(&globalLock);
     }
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateDynamicViewportState(XGL_DEVICE device, const XGL_DYNAMIC_VP_STATE_CREATE_INFO* pCreateInfo,
-    XGL_DYNAMIC_VP_STATE_OBJECT* pState)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDynamicViewportState(VK_DEVICE device, const VK_DYNAMIC_VP_STATE_CREATE_INFO* pCreateInfo,
+    VK_DYNAMIC_VP_STATE_OBJECT* pState)
 {
-    XGL_RESULT result = nextTable.CreateDynamicViewportState(device, pCreateInfo, pState);
-    if (result == XGL_SUCCESS) {
+    VK_RESULT result = nextTable.CreateDynamicViewportState(device, pCreateInfo, pState);
+    if (result == VK_SUCCESS) {
         loader_platform_thread_lock_mutex(&globalLock);
-        addObjectInfo(*pState, pCreateInfo->sType, pCreateInfo, sizeof(XGL_DYNAMIC_VP_STATE_CREATE_INFO), "viewport_state");
+        addObjectInfo(*pState, pCreateInfo->sType, pCreateInfo, sizeof(VK_DYNAMIC_VP_STATE_CREATE_INFO), "viewport_state");
         loader_platform_thread_unlock_mutex(&globalLock);
     }
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateDynamicRasterState(XGL_DEVICE device, const XGL_DYNAMIC_RS_STATE_CREATE_INFO* pCreateInfo,
-    XGL_DYNAMIC_RS_STATE_OBJECT* pState)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDynamicRasterState(VK_DEVICE device, const VK_DYNAMIC_RS_STATE_CREATE_INFO* pCreateInfo,
+    VK_DYNAMIC_RS_STATE_OBJECT* pState)
 {
-    XGL_RESULT result = nextTable.CreateDynamicRasterState(device, pCreateInfo, pState);
-    if (result == XGL_SUCCESS) {
+    VK_RESULT result = nextTable.CreateDynamicRasterState(device, pCreateInfo, pState);
+    if (result == VK_SUCCESS) {
         loader_platform_thread_lock_mutex(&globalLock);
-        addObjectInfo(*pState, pCreateInfo->sType, pCreateInfo, sizeof(XGL_DYNAMIC_RS_STATE_CREATE_INFO), "raster_state");
+        addObjectInfo(*pState, pCreateInfo->sType, pCreateInfo, sizeof(VK_DYNAMIC_RS_STATE_CREATE_INFO), "raster_state");
         loader_platform_thread_unlock_mutex(&globalLock);
     }
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateDynamicColorBlendState(XGL_DEVICE device, const XGL_DYNAMIC_CB_STATE_CREATE_INFO* pCreateInfo,
-    XGL_DYNAMIC_CB_STATE_OBJECT*  pState)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDynamicColorBlendState(VK_DEVICE device, const VK_DYNAMIC_CB_STATE_CREATE_INFO* pCreateInfo,
+    VK_DYNAMIC_CB_STATE_OBJECT*  pState)
 {
-    XGL_RESULT result = nextTable.CreateDynamicColorBlendState(device, pCreateInfo, pState);
-    if (result == XGL_SUCCESS) {
+    VK_RESULT result = nextTable.CreateDynamicColorBlendState(device, pCreateInfo, pState);
+    if (result == VK_SUCCESS) {
         loader_platform_thread_lock_mutex(&globalLock);
-        addObjectInfo(*pState, pCreateInfo->sType, pCreateInfo, sizeof(XGL_DYNAMIC_CB_STATE_CREATE_INFO), "cb_state");
+        addObjectInfo(*pState, pCreateInfo->sType, pCreateInfo, sizeof(VK_DYNAMIC_CB_STATE_CREATE_INFO), "cb_state");
         loader_platform_thread_unlock_mutex(&globalLock);
     }
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateDynamicDepthStencilState(XGL_DEVICE device, const XGL_DYNAMIC_DS_STATE_CREATE_INFO* pCreateInfo,
-    XGL_DYNAMIC_DS_STATE_OBJECT*    pState)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDynamicDepthStencilState(VK_DEVICE device, const VK_DYNAMIC_DS_STATE_CREATE_INFO* pCreateInfo,
+    VK_DYNAMIC_DS_STATE_OBJECT*    pState)
 {
-    XGL_RESULT result = nextTable.CreateDynamicDepthStencilState(device, pCreateInfo, pState);
-    if (result == XGL_SUCCESS) {
+    VK_RESULT result = nextTable.CreateDynamicDepthStencilState(device, pCreateInfo, pState);
+    if (result == VK_SUCCESS) {
         loader_platform_thread_lock_mutex(&globalLock);
-        addObjectInfo(*pState, pCreateInfo->sType, pCreateInfo, sizeof(XGL_DYNAMIC_DS_STATE_CREATE_INFO), "ds_state");
+        addObjectInfo(*pState, pCreateInfo->sType, pCreateInfo, sizeof(VK_DYNAMIC_DS_STATE_CREATE_INFO), "ds_state");
         loader_platform_thread_unlock_mutex(&globalLock);
     }
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateCommandBuffer(XGL_DEVICE device, const XGL_CMD_BUFFER_CREATE_INFO* pCreateInfo, XGL_CMD_BUFFER* pCmdBuffer)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateCommandBuffer(VK_DEVICE device, const VK_CMD_BUFFER_CREATE_INFO* pCreateInfo, VK_CMD_BUFFER* pCmdBuffer)
 {
-    XGL_RESULT result = nextTable.CreateCommandBuffer(device, pCreateInfo, pCmdBuffer);
+    VK_RESULT result = nextTable.CreateCommandBuffer(device, pCreateInfo, pCmdBuffer);
     // At time of cmd buffer creation, create global cmd buffer info for the returned cmd buffer
     loader_platform_thread_lock_mutex(&globalLock);
     if (*pCmdBuffer)
@@ -1443,54 +1443,54 @@
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglBeginCommandBuffer(XGL_CMD_BUFFER cmdBuffer, const XGL_CMD_BUFFER_BEGIN_INFO* pBeginInfo)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkBeginCommandBuffer(VK_CMD_BUFFER cmdBuffer, const VK_CMD_BUFFER_BEGIN_INFO* pBeginInfo)
 {
     // This implicitly resets the Cmd Buffer so make sure any fence is done and then clear memory references
     MT_CB_INFO* pCBInfo = getCBInfo(cmdBuffer);
     if (pCBInfo && (!fenceRetired(pCBInfo->fenceId))) {
         bool32_t cbDone = checkCBCompleted(cmdBuffer);
-        if (XGL_FALSE == cbDone) {
+        if (VK_FALSE == cbDone) {
             char str[1024];
-            sprintf(str, "Calling xglBeginCommandBuffer() on active CB %p before it has completed. You must check CB flag before this call.", cmdBuffer);
-            layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_RESET_CB_WHILE_IN_FLIGHT, "MEM", str);
+            sprintf(str, "Calling vkBeginCommandBuffer() on active CB %p before it has completed. You must check CB flag before this call.", cmdBuffer);
+            layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_RESET_CB_WHILE_IN_FLIGHT, "MEM", str);
         }
     }
-    XGL_RESULT result = nextTable.BeginCommandBuffer(cmdBuffer, pBeginInfo);
+    VK_RESULT result = nextTable.BeginCommandBuffer(cmdBuffer, pBeginInfo);
     loader_platform_thread_lock_mutex(&globalLock);
     freeCBBindings(cmdBuffer);
     loader_platform_thread_unlock_mutex(&globalLock);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglEndCommandBuffer(XGL_CMD_BUFFER cmdBuffer)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkEndCommandBuffer(VK_CMD_BUFFER cmdBuffer)
 {
     // TODO : Anything to do here?
-    XGL_RESULT result = nextTable.EndCommandBuffer(cmdBuffer);
+    VK_RESULT result = nextTable.EndCommandBuffer(cmdBuffer);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglResetCommandBuffer(XGL_CMD_BUFFER cmdBuffer)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkResetCommandBuffer(VK_CMD_BUFFER cmdBuffer)
 {
     // Verify that CB is complete (not in-flight)
     MT_CB_INFO* pCBInfo = getCBInfo(cmdBuffer);
     if (pCBInfo && (!fenceRetired(pCBInfo->fenceId))) {
         bool32_t cbDone = checkCBCompleted(cmdBuffer);
-        if (XGL_FALSE == cbDone) {
+        if (VK_FALSE == cbDone) {
             char str[1024];
-            sprintf(str, "Resetting CB %p before it has completed. You must check CB flag before calling xglResetCommandBuffer().", cmdBuffer);
-            layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_RESET_CB_WHILE_IN_FLIGHT, "MEM", str);
+            sprintf(str, "Resetting CB %p before it has completed. You must check CB flag before calling vkResetCommandBuffer().", cmdBuffer);
+            layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_RESET_CB_WHILE_IN_FLIGHT, "MEM", str);
         }
     }
     // Clear memory references as this point.
     loader_platform_thread_lock_mutex(&globalLock);
     freeCBBindings(cmdBuffer);
     loader_platform_thread_unlock_mutex(&globalLock);
-    XGL_RESULT result = nextTable.ResetCommandBuffer(cmdBuffer);
+    VK_RESULT result = nextTable.ResetCommandBuffer(cmdBuffer);
     return result;
 }
-// TODO : For any xglCmdBind* calls that include an object which has mem bound to it,
+// TODO : For any vkCmdBind* calls that include an object which has mem bound to it,
 //    need to account for that mem now having binding to given cmdBuffer
-XGL_LAYER_EXPORT void XGLAPI xglCmdBindPipeline(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, XGL_PIPELINE pipeline)
+VK_LAYER_EXPORT void VKAPI vkCmdBindPipeline(VK_CMD_BUFFER cmdBuffer, VK_PIPELINE_BIND_POINT pipelineBindPoint, VK_PIPELINE pipeline)
 {
 #if 0
     // TODO : If memory bound to pipeline, then need to tie that mem to cmdBuffer
@@ -1501,19 +1501,19 @@
         } else {
             char str[1024];
             sprintf(str, "Attempt to bind Pipeline %p to non-existant command buffer %p!", (void*)pipeline, cmdBuffer);
-            layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_INVALID_CB, (char *) "DS", (char *) str);
+            layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_INVALID_CB, (char *) "DS", (char *) str);
         }
     }
     else {
         char str[1024];
         sprintf(str, "Attempt to bind Pipeline %p that doesn't exist!", (void*)pipeline);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, pipeline, 0, MEMTRACK_INVALID_OBJECT, (char *) "DS", (char *) str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, pipeline, 0, MEMTRACK_INVALID_OBJECT, (char *) "DS", (char *) str);
     }
 #endif
     nextTable.CmdBindPipeline(cmdBuffer, pipelineBindPoint, pipeline);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdBindDynamicStateObject(XGL_CMD_BUFFER cmdBuffer, XGL_STATE_BIND_POINT stateBindPoint, XGL_DYNAMIC_STATE_OBJECT state)
+VK_LAYER_EXPORT void VKAPI vkCmdBindDynamicStateObject(VK_CMD_BUFFER cmdBuffer, VK_STATE_BIND_POINT stateBindPoint, VK_DYNAMIC_STATE_OBJECT state)
 {
     MT_OBJ_INFO *pObjInfo;
     loader_platform_thread_lock_mutex(&globalLock);
@@ -1521,330 +1521,330 @@
     if (!pCmdBuf) {
         char str[1024];
         sprintf(str, "Unable to find command buffer object %p, was it ever created?", (void*)cmdBuffer);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_INVALID_CB, "DD", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_INVALID_CB, "DD", str);
     }
     pObjInfo = getObjectInfo(state);
     if (!pObjInfo) {
         char str[1024];
         sprintf(str, "Unable to find dynamic state object %p, was it ever created?", (void*)state);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, state, 0, MEMTRACK_INVALID_OBJECT, "DD", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, state, 0, MEMTRACK_INVALID_OBJECT, "DD", str);
     }
     pCmdBuf->pDynamicState[stateBindPoint] = pObjInfo;
     loader_platform_thread_unlock_mutex(&globalLock);
     nextTable.CmdBindDynamicStateObject(cmdBuffer, stateBindPoint, state);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdBindDescriptorSets(
-    XGL_CMD_BUFFER                              cmdBuffer,
-    XGL_PIPELINE_BIND_POINT                     pipelineBindPoint,
-    XGL_DESCRIPTOR_SET_LAYOUT_CHAIN             layoutChain,
+VK_LAYER_EXPORT void VKAPI vkCmdBindDescriptorSets(
+    VK_CMD_BUFFER                              cmdBuffer,
+    VK_PIPELINE_BIND_POINT                     pipelineBindPoint,
+    VK_DESCRIPTOR_SET_LAYOUT_CHAIN             layoutChain,
     uint32_t                                    layoutChainSlot,
     uint32_t                                    count,
-    const XGL_DESCRIPTOR_SET*                   pDescriptorSets,
+    const VK_DESCRIPTOR_SET*                   pDescriptorSets,
     const uint32_t*                             pUserData)
 {
     // TODO : Somewhere need to verify that all textures referenced by shaders in DS are in some type of *SHADER_READ* state
     nextTable.CmdBindDescriptorSets(cmdBuffer, pipelineBindPoint, layoutChain, layoutChainSlot, count, pDescriptorSets, pUserData);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdBindVertexBuffer(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER buffer, XGL_GPU_SIZE offset, uint32_t binding)
+VK_LAYER_EXPORT void VKAPI vkCmdBindVertexBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFFER buffer, VK_GPU_SIZE offset, uint32_t binding)
 {
     nextTable.CmdBindVertexBuffer(cmdBuffer, buffer, offset, binding);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdBindIndexBuffer(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER buffer, XGL_GPU_SIZE offset, XGL_INDEX_TYPE indexType)
+VK_LAYER_EXPORT void VKAPI vkCmdBindIndexBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFFER buffer, VK_GPU_SIZE offset, VK_INDEX_TYPE indexType)
 {
     nextTable.CmdBindIndexBuffer(cmdBuffer, buffer, offset, indexType);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdDrawIndirect(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER buffer, XGL_GPU_SIZE offset, uint32_t count, uint32_t stride)
+VK_LAYER_EXPORT void VKAPI vkCmdDrawIndirect(VK_CMD_BUFFER cmdBuffer, VK_BUFFER buffer, VK_GPU_SIZE offset, uint32_t count, uint32_t stride)
 {
     loader_platform_thread_lock_mutex(&globalLock);
-    XGL_GPU_MEMORY mem = getMemBindingFromObject(buffer);
-    if (XGL_FALSE == updateCBBinding(cmdBuffer, mem)) {
+    VK_GPU_MEMORY mem = getMemBindingFromObject(buffer);
+    if (VK_FALSE == updateCBBinding(cmdBuffer, mem)) {
         char str[1024];
-        sprintf(str, "In xglCmdDrawIndirect() call unable to update binding of buffer %p to cmdBuffer %p", buffer, cmdBuffer);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
+        sprintf(str, "In vkCmdDrawIndirect() call unable to update binding of buffer %p to cmdBuffer %p", buffer, cmdBuffer);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
     }
     loader_platform_thread_unlock_mutex(&globalLock);
     nextTable.CmdDrawIndirect(cmdBuffer, buffer, offset, count, stride);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdDrawIndexedIndirect(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER buffer, XGL_GPU_SIZE offset, uint32_t count, uint32_t stride)
+VK_LAYER_EXPORT void VKAPI vkCmdDrawIndexedIndirect(VK_CMD_BUFFER cmdBuffer, VK_BUFFER buffer, VK_GPU_SIZE offset, uint32_t count, uint32_t stride)
 {
     loader_platform_thread_lock_mutex(&globalLock);
-    XGL_GPU_MEMORY mem = getMemBindingFromObject(buffer);
-    if (XGL_FALSE == updateCBBinding(cmdBuffer, mem)) {
+    VK_GPU_MEMORY mem = getMemBindingFromObject(buffer);
+    if (VK_FALSE == updateCBBinding(cmdBuffer, mem)) {
         char str[1024];
-        sprintf(str, "In xglCmdDrawIndexedIndirect() call unable to update binding of buffer %p to cmdBuffer %p", buffer, cmdBuffer);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
+        sprintf(str, "In vkCmdDrawIndexedIndirect() call unable to update binding of buffer %p to cmdBuffer %p", buffer, cmdBuffer);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
     }
     loader_platform_thread_unlock_mutex(&globalLock);
     nextTable.CmdDrawIndexedIndirect(cmdBuffer, buffer, offset, count, stride);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdDispatchIndirect(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER buffer, XGL_GPU_SIZE offset)
+VK_LAYER_EXPORT void VKAPI vkCmdDispatchIndirect(VK_CMD_BUFFER cmdBuffer, VK_BUFFER buffer, VK_GPU_SIZE offset)
 {
     loader_platform_thread_lock_mutex(&globalLock);
-    XGL_GPU_MEMORY mem = getMemBindingFromObject(buffer);
-    if (XGL_FALSE == updateCBBinding(cmdBuffer, mem)) {
+    VK_GPU_MEMORY mem = getMemBindingFromObject(buffer);
+    if (VK_FALSE == updateCBBinding(cmdBuffer, mem)) {
         char str[1024];
-        sprintf(str, "In xglCmdDispatchIndirect() call unable to update binding of buffer %p to cmdBuffer %p", buffer, cmdBuffer);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
+        sprintf(str, "In vkCmdDispatchIndirect() call unable to update binding of buffer %p to cmdBuffer %p", buffer, cmdBuffer);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
     }
     loader_platform_thread_unlock_mutex(&globalLock);
     nextTable.CmdDispatchIndirect(cmdBuffer, buffer, offset);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdCopyBuffer(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER srcBuffer, XGL_BUFFER destBuffer,
-    uint32_t regionCount, const XGL_BUFFER_COPY* pRegions)
+VK_LAYER_EXPORT void VKAPI vkCmdCopyBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFFER srcBuffer, VK_BUFFER destBuffer,
+    uint32_t regionCount, const VK_BUFFER_COPY* pRegions)
 {
     loader_platform_thread_lock_mutex(&globalLock);
-    XGL_GPU_MEMORY mem = getMemBindingFromObject(srcBuffer);
-    if (XGL_FALSE == updateCBBinding(cmdBuffer, mem)) {
+    VK_GPU_MEMORY mem = getMemBindingFromObject(srcBuffer);
+    if (VK_FALSE == updateCBBinding(cmdBuffer, mem)) {
         char str[1024];
-        sprintf(str, "In xglCmdCopyBuffer() call unable to update binding of srcBuffer %p to cmdBuffer %p", srcBuffer, cmdBuffer);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
+        sprintf(str, "In vkCmdCopyBuffer() call unable to update binding of srcBuffer %p to cmdBuffer %p", srcBuffer, cmdBuffer);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
     }
     mem = getMemBindingFromObject(destBuffer);
-    if (XGL_FALSE == updateCBBinding(cmdBuffer, mem)) {
+    if (VK_FALSE == updateCBBinding(cmdBuffer, mem)) {
         char str[1024];
-        sprintf(str, "In xglCmdCopyBuffer() call unable to update binding of destBuffer %p to cmdBuffer %p", destBuffer, cmdBuffer);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
+        sprintf(str, "In vkCmdCopyBuffer() call unable to update binding of destBuffer %p to cmdBuffer %p", destBuffer, cmdBuffer);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
     }
     loader_platform_thread_unlock_mutex(&globalLock);
     nextTable.CmdCopyBuffer(cmdBuffer, srcBuffer, destBuffer, regionCount, pRegions);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdCopyImage(XGL_CMD_BUFFER cmdBuffer,
-                                             XGL_IMAGE srcImage, XGL_IMAGE_LAYOUT srcImageLayout,
-                                             XGL_IMAGE destImage, XGL_IMAGE_LAYOUT destImageLayout,
-                                             uint32_t regionCount, const XGL_IMAGE_COPY* pRegions)
+VK_LAYER_EXPORT void VKAPI vkCmdCopyImage(VK_CMD_BUFFER cmdBuffer,
+                                             VK_IMAGE srcImage, VK_IMAGE_LAYOUT srcImageLayout,
+                                             VK_IMAGE destImage, VK_IMAGE_LAYOUT destImageLayout,
+                                             uint32_t regionCount, const VK_IMAGE_COPY* pRegions)
 {
     // TODO : Each image will have mem mapping so track them
     nextTable.CmdCopyImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdBlitImage(XGL_CMD_BUFFER cmdBuffer,
-                                             XGL_IMAGE srcImage, XGL_IMAGE_LAYOUT srcImageLayout,
-                                             XGL_IMAGE destImage, XGL_IMAGE_LAYOUT destImageLayout,
-                                             uint32_t regionCount, const XGL_IMAGE_BLIT* pRegions)
+VK_LAYER_EXPORT void VKAPI vkCmdBlitImage(VK_CMD_BUFFER cmdBuffer,
+                                             VK_IMAGE srcImage, VK_IMAGE_LAYOUT srcImageLayout,
+                                             VK_IMAGE destImage, VK_IMAGE_LAYOUT destImageLayout,
+                                             uint32_t regionCount, const VK_IMAGE_BLIT* pRegions)
 {
     // TODO : Each image will have mem mapping so track them
     nextTable.CmdBlitImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdCopyBufferToImage(XGL_CMD_BUFFER cmdBuffer,
-                                                     XGL_BUFFER srcBuffer,
-                                                     XGL_IMAGE destImage, XGL_IMAGE_LAYOUT destImageLayout,
-                                                     uint32_t regionCount, const XGL_BUFFER_IMAGE_COPY* pRegions)
+VK_LAYER_EXPORT void VKAPI vkCmdCopyBufferToImage(VK_CMD_BUFFER cmdBuffer,
+                                                     VK_BUFFER srcBuffer,
+                                                     VK_IMAGE destImage, VK_IMAGE_LAYOUT destImageLayout,
+                                                     uint32_t regionCount, const VK_BUFFER_IMAGE_COPY* pRegions)
 {
     // TODO : Track this
     loader_platform_thread_lock_mutex(&globalLock);
-    XGL_GPU_MEMORY mem = getMemBindingFromObject(destImage);
-    if (XGL_FALSE == updateCBBinding(cmdBuffer, mem)) {
+    VK_GPU_MEMORY mem = getMemBindingFromObject(destImage);
+    if (VK_FALSE == updateCBBinding(cmdBuffer, mem)) {
         char str[1024];
-        sprintf(str, "In xglCmdCopyMemoryToImage() call unable to update binding of destImage buffer %p to cmdBuffer %p", destImage, cmdBuffer);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
+        sprintf(str, "In vkCmdCopyMemoryToImage() call unable to update binding of destImage buffer %p to cmdBuffer %p", destImage, cmdBuffer);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
     }
 
     mem = getMemBindingFromObject(srcBuffer);
-    if (XGL_FALSE == updateCBBinding(cmdBuffer, mem)) {
+    if (VK_FALSE == updateCBBinding(cmdBuffer, mem)) {
         char str[1024];
-        sprintf(str, "In xglCmdCopyMemoryToImage() call unable to update binding of srcBuffer %p to cmdBuffer %p", srcBuffer, cmdBuffer);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
+        sprintf(str, "In vkCmdCopyMemoryToImage() call unable to update binding of srcBuffer %p to cmdBuffer %p", srcBuffer, cmdBuffer);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
     }
     loader_platform_thread_unlock_mutex(&globalLock);
     nextTable.CmdCopyBufferToImage(cmdBuffer, srcBuffer, destImage, destImageLayout, regionCount, pRegions);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdCopyImageToBuffer(XGL_CMD_BUFFER cmdBuffer,
-                                                     XGL_IMAGE srcImage, XGL_IMAGE_LAYOUT srcImageLayout,
-                                                     XGL_BUFFER destBuffer,
-                                                     uint32_t regionCount, const XGL_BUFFER_IMAGE_COPY* pRegions)
+VK_LAYER_EXPORT void VKAPI vkCmdCopyImageToBuffer(VK_CMD_BUFFER cmdBuffer,
+                                                     VK_IMAGE srcImage, VK_IMAGE_LAYOUT srcImageLayout,
+                                                     VK_BUFFER destBuffer,
+                                                     uint32_t regionCount, const VK_BUFFER_IMAGE_COPY* pRegions)
 {
     // TODO : Track this
     loader_platform_thread_lock_mutex(&globalLock);
-    XGL_GPU_MEMORY mem = getMemBindingFromObject(srcImage);
-    if (XGL_FALSE == updateCBBinding(cmdBuffer, mem)) {
+    VK_GPU_MEMORY mem = getMemBindingFromObject(srcImage);
+    if (VK_FALSE == updateCBBinding(cmdBuffer, mem)) {
         char str[1024];
-        sprintf(str, "In xglCmdCopyImageToMemory() call unable to update binding of srcImage buffer %p to cmdBuffer %p", srcImage, cmdBuffer);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
+        sprintf(str, "In vkCmdCopyImageToMemory() call unable to update binding of srcImage buffer %p to cmdBuffer %p", srcImage, cmdBuffer);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
     }
     mem = getMemBindingFromObject(destBuffer);
-    if (XGL_FALSE == updateCBBinding(cmdBuffer, mem)) {
+    if (VK_FALSE == updateCBBinding(cmdBuffer, mem)) {
         char str[1024];
-        sprintf(str, "In xglCmdCopyImageToMemory() call unable to update binding of destBuffer %p to cmdBuffer %p", destBuffer, cmdBuffer);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
+        sprintf(str, "In vkCmdCopyImageToMemory() call unable to update binding of destBuffer %p to cmdBuffer %p", destBuffer, cmdBuffer);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
     }
     loader_platform_thread_unlock_mutex(&globalLock);
     nextTable.CmdCopyImageToBuffer(cmdBuffer, srcImage, srcImageLayout, destBuffer, regionCount, pRegions);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdCloneImageData(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE srcImage, XGL_IMAGE_LAYOUT srcImageLayout,
-    XGL_IMAGE destImage, XGL_IMAGE_LAYOUT destImageLayout)
+VK_LAYER_EXPORT void VKAPI vkCmdCloneImageData(VK_CMD_BUFFER cmdBuffer, VK_IMAGE srcImage, VK_IMAGE_LAYOUT srcImageLayout,
+    VK_IMAGE destImage, VK_IMAGE_LAYOUT destImageLayout)
 {
     // TODO : Each image will have mem mapping so track them
     loader_platform_thread_lock_mutex(&globalLock);
-    XGL_GPU_MEMORY mem = getMemBindingFromObject(srcImage);
-    if (XGL_FALSE == updateCBBinding(cmdBuffer, mem)) {
+    VK_GPU_MEMORY mem = getMemBindingFromObject(srcImage);
+    if (VK_FALSE == updateCBBinding(cmdBuffer, mem)) {
         char str[1024];
-        sprintf(str, "In xglCmdCloneImageData() call unable to update binding of srcImage buffer %p to cmdBuffer %p", srcImage, cmdBuffer);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
+        sprintf(str, "In vkCmdCloneImageData() call unable to update binding of srcImage buffer %p to cmdBuffer %p", srcImage, cmdBuffer);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
     }
     mem = getMemBindingFromObject(destImage);
-    if (XGL_FALSE == updateCBBinding(cmdBuffer, mem)) {
+    if (VK_FALSE == updateCBBinding(cmdBuffer, mem)) {
         char str[1024];
-        sprintf(str, "In xglCmdCloneImageData() call unable to update binding of destImage buffer %p to cmdBuffer %p", destImage, cmdBuffer);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
+        sprintf(str, "In vkCmdCloneImageData() call unable to update binding of destImage buffer %p to cmdBuffer %p", destImage, cmdBuffer);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
     }
     loader_platform_thread_unlock_mutex(&globalLock);
     nextTable.CmdCloneImageData(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdUpdateBuffer(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER destBuffer, XGL_GPU_SIZE destOffset, XGL_GPU_SIZE dataSize, const uint32_t* pData)
+VK_LAYER_EXPORT void VKAPI vkCmdUpdateBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFFER destBuffer, VK_GPU_SIZE destOffset, VK_GPU_SIZE dataSize, const uint32_t* pData)
 {
     loader_platform_thread_lock_mutex(&globalLock);
-    XGL_GPU_MEMORY mem = getMemBindingFromObject(destBuffer);
-    if (XGL_FALSE == updateCBBinding(cmdBuffer, mem)) {
+    VK_GPU_MEMORY mem = getMemBindingFromObject(destBuffer);
+    if (VK_FALSE == updateCBBinding(cmdBuffer, mem)) {
         char str[1024];
-        sprintf(str, "In xglCmdUpdateMemory() call unable to update binding of destBuffer %p to cmdBuffer %p", destBuffer, cmdBuffer);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
+        sprintf(str, "In vkCmdUpdateMemory() call unable to update binding of destBuffer %p to cmdBuffer %p", destBuffer, cmdBuffer);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
     }
     loader_platform_thread_unlock_mutex(&globalLock);
     nextTable.CmdUpdateBuffer(cmdBuffer, destBuffer, destOffset, dataSize, pData);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdFillBuffer(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER destBuffer, XGL_GPU_SIZE destOffset, XGL_GPU_SIZE fillSize, uint32_t data)
+VK_LAYER_EXPORT void VKAPI vkCmdFillBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFFER destBuffer, VK_GPU_SIZE destOffset, VK_GPU_SIZE fillSize, uint32_t data)
 {
     loader_platform_thread_lock_mutex(&globalLock);
-    XGL_GPU_MEMORY mem = getMemBindingFromObject(destBuffer);
-    if (XGL_FALSE == updateCBBinding(cmdBuffer, mem)) {
+    VK_GPU_MEMORY mem = getMemBindingFromObject(destBuffer);
+    if (VK_FALSE == updateCBBinding(cmdBuffer, mem)) {
         char str[1024];
-        sprintf(str, "In xglCmdFillMemory() call unable to update binding of destBuffer %p to cmdBuffer %p", destBuffer, cmdBuffer);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
+        sprintf(str, "In vkCmdFillMemory() call unable to update binding of destBuffer %p to cmdBuffer %p", destBuffer, cmdBuffer);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
     }
     loader_platform_thread_unlock_mutex(&globalLock);
     nextTable.CmdFillBuffer(cmdBuffer, destBuffer, destOffset, fillSize, data);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdClearColorImage(XGL_CMD_BUFFER cmdBuffer,
-                                                   XGL_IMAGE image, XGL_IMAGE_LAYOUT imageLayout,
-                                                   XGL_CLEAR_COLOR color,
-                                                   uint32_t rangeCount, const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges)
+VK_LAYER_EXPORT void VKAPI vkCmdClearColorImage(VK_CMD_BUFFER cmdBuffer,
+                                                   VK_IMAGE image, VK_IMAGE_LAYOUT imageLayout,
+                                                   VK_CLEAR_COLOR color,
+                                                   uint32_t rangeCount, const VK_IMAGE_SUBRESOURCE_RANGE* pRanges)
 {
-    // TODO : Verify memory is in XGL_IMAGE_STATE_CLEAR state
+    // TODO : Verify memory is in VK_IMAGE_STATE_CLEAR state
     loader_platform_thread_lock_mutex(&globalLock);
-    XGL_GPU_MEMORY mem = getMemBindingFromObject(image);
-    if (XGL_FALSE == updateCBBinding(cmdBuffer, mem)) {
+    VK_GPU_MEMORY mem = getMemBindingFromObject(image);
+    if (VK_FALSE == updateCBBinding(cmdBuffer, mem)) {
         char str[1024];
-        sprintf(str, "In xglCmdClearColorImage() call unable to update binding of image buffer %p to cmdBuffer %p", image, cmdBuffer);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
+        sprintf(str, "In vkCmdClearColorImage() call unable to update binding of image buffer %p to cmdBuffer %p", image, cmdBuffer);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
     }
     loader_platform_thread_unlock_mutex(&globalLock);
     nextTable.CmdClearColorImage(cmdBuffer, image, imageLayout, color, rangeCount, pRanges);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdClearDepthStencil(XGL_CMD_BUFFER cmdBuffer,
-                                                     XGL_IMAGE image, XGL_IMAGE_LAYOUT imageLayout,
+VK_LAYER_EXPORT void VKAPI vkCmdClearDepthStencil(VK_CMD_BUFFER cmdBuffer,
+                                                     VK_IMAGE image, VK_IMAGE_LAYOUT imageLayout,
                                                      float depth, uint32_t stencil,
-                                                     uint32_t rangeCount, const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges)
+                                                     uint32_t rangeCount, const VK_IMAGE_SUBRESOURCE_RANGE* pRanges)
 {
-    // TODO : Verify memory is in XGL_IMAGE_STATE_CLEAR state
+    // TODO : Verify memory is in VK_IMAGE_STATE_CLEAR state
     loader_platform_thread_lock_mutex(&globalLock);
-    XGL_GPU_MEMORY mem = getMemBindingFromObject(image);
-    if (XGL_FALSE == updateCBBinding(cmdBuffer, mem)) {
+    VK_GPU_MEMORY mem = getMemBindingFromObject(image);
+    if (VK_FALSE == updateCBBinding(cmdBuffer, mem)) {
         char str[1024];
-        sprintf(str, "In xglCmdClearDepthStencil() call unable to update binding of image buffer %p to cmdBuffer %p", image, cmdBuffer);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
+        sprintf(str, "In vkCmdClearDepthStencil() call unable to update binding of image buffer %p to cmdBuffer %p", image, cmdBuffer);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
     }
     loader_platform_thread_unlock_mutex(&globalLock);
     nextTable.CmdClearDepthStencil(cmdBuffer, image, imageLayout, depth, stencil, rangeCount, pRanges);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdResolveImage(XGL_CMD_BUFFER cmdBuffer,
-                                                XGL_IMAGE srcImage, XGL_IMAGE_LAYOUT srcImageLayout,
-                                                XGL_IMAGE destImage, XGL_IMAGE_LAYOUT destImageLayout,
-                                                uint32_t rectCount, const XGL_IMAGE_RESOLVE* pRects)
+VK_LAYER_EXPORT void VKAPI vkCmdResolveImage(VK_CMD_BUFFER cmdBuffer,
+                                                VK_IMAGE srcImage, VK_IMAGE_LAYOUT srcImageLayout,
+                                                VK_IMAGE destImage, VK_IMAGE_LAYOUT destImageLayout,
+                                                uint32_t rectCount, const VK_IMAGE_RESOLVE* pRects)
 {
     loader_platform_thread_lock_mutex(&globalLock);
-    XGL_GPU_MEMORY mem = getMemBindingFromObject(srcImage);
-    if (XGL_FALSE == updateCBBinding(cmdBuffer, mem)) {
+    VK_GPU_MEMORY mem = getMemBindingFromObject(srcImage);
+    if (VK_FALSE == updateCBBinding(cmdBuffer, mem)) {
         char str[1024];
-        sprintf(str, "In xglCmdResolveImage() call unable to update binding of srcImage buffer %p to cmdBuffer %p", srcImage, cmdBuffer);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
+        sprintf(str, "In vkCmdResolveImage() call unable to update binding of srcImage buffer %p to cmdBuffer %p", srcImage, cmdBuffer);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
     }
     mem = getMemBindingFromObject(destImage);
-    if (XGL_FALSE == updateCBBinding(cmdBuffer, mem)) {
+    if (VK_FALSE == updateCBBinding(cmdBuffer, mem)) {
         char str[1024];
-        sprintf(str, "In xglCmdResolveImage() call unable to update binding of destImage buffer %p to cmdBuffer %p", destImage, cmdBuffer);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
+        sprintf(str, "In vkCmdResolveImage() call unable to update binding of destImage buffer %p to cmdBuffer %p", destImage, cmdBuffer);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
     }
     loader_platform_thread_unlock_mutex(&globalLock);
     nextTable.CmdResolveImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, rectCount, pRects);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdBeginQuery(XGL_CMD_BUFFER cmdBuffer, XGL_QUERY_POOL queryPool, uint32_t slot, XGL_FLAGS flags)
+VK_LAYER_EXPORT void VKAPI vkCmdBeginQuery(VK_CMD_BUFFER cmdBuffer, VK_QUERY_POOL queryPool, uint32_t slot, VK_FLAGS flags)
 {
     loader_platform_thread_lock_mutex(&globalLock);
-    XGL_GPU_MEMORY mem = getMemBindingFromObject(queryPool);
-    if (XGL_FALSE == updateCBBinding(cmdBuffer, mem)) {
+    VK_GPU_MEMORY mem = getMemBindingFromObject(queryPool);
+    if (VK_FALSE == updateCBBinding(cmdBuffer, mem)) {
         char str[1024];
-        sprintf(str, "In xglCmdBeginQuery() call unable to update binding of queryPool buffer %p to cmdBuffer %p", queryPool, cmdBuffer);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
+        sprintf(str, "In vkCmdBeginQuery() call unable to update binding of queryPool buffer %p to cmdBuffer %p", queryPool, cmdBuffer);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
     }
     loader_platform_thread_unlock_mutex(&globalLock);
     nextTable.CmdBeginQuery(cmdBuffer, queryPool, slot, flags);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdEndQuery(XGL_CMD_BUFFER cmdBuffer, XGL_QUERY_POOL queryPool, uint32_t slot)
+VK_LAYER_EXPORT void VKAPI vkCmdEndQuery(VK_CMD_BUFFER cmdBuffer, VK_QUERY_POOL queryPool, uint32_t slot)
 {
     loader_platform_thread_lock_mutex(&globalLock);
-    XGL_GPU_MEMORY mem = getMemBindingFromObject(queryPool);
-    if (XGL_FALSE == updateCBBinding(cmdBuffer, mem)) {
+    VK_GPU_MEMORY mem = getMemBindingFromObject(queryPool);
+    if (VK_FALSE == updateCBBinding(cmdBuffer, mem)) {
         char str[1024];
-        sprintf(str, "In xglCmdEndQuery() call unable to update binding of queryPool buffer %p to cmdBuffer %p", queryPool, cmdBuffer);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
+        sprintf(str, "In vkCmdEndQuery() call unable to update binding of queryPool buffer %p to cmdBuffer %p", queryPool, cmdBuffer);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
     }
     loader_platform_thread_unlock_mutex(&globalLock);
     nextTable.CmdEndQuery(cmdBuffer, queryPool, slot);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdResetQueryPool(XGL_CMD_BUFFER cmdBuffer, XGL_QUERY_POOL queryPool, uint32_t startQuery, uint32_t queryCount)
+VK_LAYER_EXPORT void VKAPI vkCmdResetQueryPool(VK_CMD_BUFFER cmdBuffer, VK_QUERY_POOL queryPool, uint32_t startQuery, uint32_t queryCount)
 {
     loader_platform_thread_lock_mutex(&globalLock);
-    XGL_GPU_MEMORY mem = getMemBindingFromObject(queryPool);
-    if (XGL_FALSE == updateCBBinding(cmdBuffer, mem)) {
+    VK_GPU_MEMORY mem = getMemBindingFromObject(queryPool);
+    if (VK_FALSE == updateCBBinding(cmdBuffer, mem)) {
         char str[1024];
-        sprintf(str, "In xglCmdResetQueryPool() call unable to update binding of queryPool buffer %p to cmdBuffer %p", queryPool, cmdBuffer);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
+        sprintf(str, "In vkCmdResetQueryPool() call unable to update binding of queryPool buffer %p to cmdBuffer %p", queryPool, cmdBuffer);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
     }
     loader_platform_thread_unlock_mutex(&globalLock);
     nextTable.CmdResetQueryPool(cmdBuffer, queryPool, startQuery, queryCount);
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDbgRegisterMsgCallback(XGL_INSTANCE instance, XGL_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback, void* pUserData)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkDbgRegisterMsgCallback(VK_INSTANCE instance, VK_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback, void* pUserData)
 {
     // This layer intercepts callbacks
-    XGL_LAYER_DBG_FUNCTION_NODE *pNewDbgFuncNode = (XGL_LAYER_DBG_FUNCTION_NODE*)malloc(sizeof(XGL_LAYER_DBG_FUNCTION_NODE));
+    VK_LAYER_DBG_FUNCTION_NODE *pNewDbgFuncNode = (VK_LAYER_DBG_FUNCTION_NODE*)malloc(sizeof(VK_LAYER_DBG_FUNCTION_NODE));
     if (!pNewDbgFuncNode)
-        return XGL_ERROR_OUT_OF_MEMORY;
+        return VK_ERROR_OUT_OF_MEMORY;
     pNewDbgFuncNode->pfnMsgCallback = pfnMsgCallback;
     pNewDbgFuncNode->pUserData = pUserData;
     pNewDbgFuncNode->pNext = g_pDbgFunctionHead;
     g_pDbgFunctionHead = pNewDbgFuncNode;
     // force callbacks if DebugAction hasn't been set already other than initial value
     if (g_actionIsDefault) {
-        g_debugAction = XGL_DBG_LAYER_ACTION_CALLBACK;
+        g_debugAction = VK_DBG_LAYER_ACTION_CALLBACK;
     }
-    XGL_RESULT result = nextTable.DbgRegisterMsgCallback(instance, pfnMsgCallback, pUserData);
+    VK_RESULT result = nextTable.DbgRegisterMsgCallback(instance, pfnMsgCallback, pUserData);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDbgUnregisterMsgCallback(XGL_INSTANCE instance, XGL_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkDbgUnregisterMsgCallback(VK_INSTANCE instance, VK_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback)
 {
-    XGL_LAYER_DBG_FUNCTION_NODE *pInfo = g_pDbgFunctionHead;
-    XGL_LAYER_DBG_FUNCTION_NODE *pPrev = pInfo;
+    VK_LAYER_DBG_FUNCTION_NODE *pInfo = g_pDbgFunctionHead;
+    VK_LAYER_DBG_FUNCTION_NODE *pPrev = pInfo;
     while (pInfo) {
         if (pInfo->pfnMsgCallback == pfnMsgCallback) {
             pPrev->pNext = pInfo->pNext;
@@ -1859,29 +1859,29 @@
     if (g_pDbgFunctionHead == NULL)
     {
         if (g_actionIsDefault) {
-            g_debugAction = XGL_DBG_LAYER_ACTION_LOG_MSG;
+            g_debugAction = VK_DBG_LAYER_ACTION_LOG_MSG;
         } else {
-            g_debugAction = (XGL_LAYER_DBG_ACTION)(g_debugAction & ~((uint32_t)XGL_DBG_LAYER_ACTION_CALLBACK));
+            g_debugAction = (VK_LAYER_DBG_ACTION)(g_debugAction & ~((uint32_t)VK_DBG_LAYER_ACTION_CALLBACK));
         }
     }
-    XGL_RESULT result = nextTable.DbgUnregisterMsgCallback(instance, pfnMsgCallback);
+    VK_RESULT result = nextTable.DbgUnregisterMsgCallback(instance, pfnMsgCallback);
     return result;
 }
 
 #if !defined(WIN32)
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglWsiX11CreatePresentableImage(XGL_DEVICE device, const XGL_WSI_X11_PRESENTABLE_IMAGE_CREATE_INFO* pCreateInfo,
-    XGL_IMAGE* pImage, XGL_GPU_MEMORY* pMem)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkWsiX11CreatePresentableImage(VK_DEVICE device, const VK_WSI_X11_PRESENTABLE_IMAGE_CREATE_INFO* pCreateInfo,
+    VK_IMAGE* pImage, VK_GPU_MEMORY* pMem)
 {
-    XGL_RESULT result = nextTable.WsiX11CreatePresentableImage(device, pCreateInfo, pImage, pMem);
+    VK_RESULT result = nextTable.WsiX11CreatePresentableImage(device, pCreateInfo, pImage, pMem);
     loader_platform_thread_lock_mutex(&globalLock);
-    if (XGL_SUCCESS == result) {
+    if (VK_SUCCESS == result) {
         // Add image object, then insert the new Mem Object and then bind it to created image
-        addObjectInfo(*pImage, _XGL_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, sizeof(XGL_WSI_X11_PRESENTABLE_IMAGE_CREATE_INFO), "wsi_x11_image");
+        addObjectInfo(*pImage, _VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, sizeof(VK_WSI_X11_PRESENTABLE_IMAGE_CREATE_INFO), "wsi_x11_image");
         addMemObjInfo(*pMem, NULL);
-        if (XGL_FALSE == updateObjectBinding(*pImage, *pMem)) {
+        if (VK_FALSE == updateObjectBinding(*pImage, *pMem)) {
             char str[1024];
-            sprintf(str, "In xglWsiX11CreatePresentableImage(), unable to set image %p binding to mem obj %p", (void*)*pImage, (void*)*pMem);
-            layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, *pImage, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
+            sprintf(str, "In vkWsiX11CreatePresentableImage(), unable to set image %p binding to mem obj %p", (void*)*pImage, (void*)*pMem);
+            layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, *pImage, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
         }
     }
     printObjList();
@@ -1890,179 +1890,179 @@
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglWsiX11QueuePresent(XGL_QUEUE queue, const XGL_WSI_X11_PRESENT_INFO*  pPresentInfo, XGL_FENCE fence)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkWsiX11QueuePresent(VK_QUEUE queue, const VK_WSI_X11_PRESENT_INFO*  pPresentInfo, VK_FENCE fence)
 {
     loader_platform_thread_lock_mutex(&globalLock);
     addFenceInfo(fence, queue);
     char            str[1024];
-    sprintf(str, "In xglWsiX11QueuePresent(), checking queue %p for fence %p", queue, fence);
-    layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, queue, 0, MEMTRACK_NONE, "MEM", str);
+    sprintf(str, "In vkWsiX11QueuePresent(), checking queue %p for fence %p", queue, fence);
+    layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, queue, 0, MEMTRACK_NONE, "MEM", str);
     loader_platform_thread_unlock_mutex(&globalLock);
-    XGL_RESULT result = nextTable.WsiX11QueuePresent(queue, pPresentInfo, fence);
+    VK_RESULT result = nextTable.WsiX11QueuePresent(queue, pPresentInfo, fence);
     return result;
 }
 #endif // WIN32
 
-XGL_LAYER_EXPORT void* XGLAPI xglGetProcAddr(XGL_PHYSICAL_GPU gpu, const char* funcName)
+VK_LAYER_EXPORT void* VKAPI vkGetProcAddr(VK_PHYSICAL_GPU gpu, const char* funcName)
 {
-    XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) gpu;
+    VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
 
     if (gpu == NULL)
         return NULL;
     pCurObj = gpuw;
     loader_platform_thread_once(&g_initOnce, initMemTracker);
 
-    if (!strcmp(funcName, "xglGetProcAddr"))
-        return (void *) xglGetProcAddr;
-    if (!strcmp(funcName, "xglCreateDevice"))
-        return (void*) xglCreateDevice;
-    if (!strcmp(funcName, "xglDestroyDevice"))
-        return (void*) xglDestroyDevice;
-    if (!strcmp(funcName, "xglGetExtensionSupport"))
-        return (void*) xglGetExtensionSupport;
-    if (!strcmp(funcName, "xglEnumerateLayers"))
-        return (void*) xglEnumerateLayers;
-    if (!strcmp(funcName, "xglQueueSubmit"))
-        return (void*) xglQueueSubmit;
-    if (!strcmp(funcName, "xglAllocMemory"))
-        return (void*) xglAllocMemory;
-    if (!strcmp(funcName, "xglFreeMemory"))
-        return (void*) xglFreeMemory;
-    if (!strcmp(funcName, "xglSetMemoryPriority"))
-        return (void*) xglSetMemoryPriority;
-    if (!strcmp(funcName, "xglMapMemory"))
-        return (void*) xglMapMemory;
-    if (!strcmp(funcName, "xglUnmapMemory"))
-        return (void*) xglUnmapMemory;
-    if (!strcmp(funcName, "xglPinSystemMemory"))
-        return (void*) xglPinSystemMemory;
-    if (!strcmp(funcName, "xglOpenSharedMemory"))
-        return (void*) xglOpenSharedMemory;
-    if (!strcmp(funcName, "xglOpenPeerMemory"))
-        return (void*) xglOpenPeerMemory;
-    if (!strcmp(funcName, "xglOpenPeerImage"))
-        return (void*) xglOpenPeerImage;
-    if (!strcmp(funcName, "xglDestroyObject"))
-        return (void*) xglDestroyObject;
-    if (!strcmp(funcName, "xglGetObjectInfo"))
-        return (void*) xglGetObjectInfo;
-    if (!strcmp(funcName, "xglBindObjectMemory"))
-        return (void*) xglBindObjectMemory;
-    if (!strcmp(funcName, "xglCreateFence"))
-        return (void*) xglCreateFence;
-    if (!strcmp(funcName, "xglGetFenceStatus"))
-        return (void*) xglGetFenceStatus;
-    if (!strcmp(funcName, "xglResetFences"))
-        return (void*) xglResetFences;
-    if (!strcmp(funcName, "xglWaitForFences"))
-        return (void*) xglWaitForFences;
-    if (!strcmp(funcName, "xglQueueWaitIdle"))
-        return (void*) xglQueueWaitIdle;
-    if (!strcmp(funcName, "xglDeviceWaitIdle"))
-        return (void*) xglDeviceWaitIdle;
-    if (!strcmp(funcName, "xglCreateEvent"))
-        return (void*) xglCreateEvent;
-    if (!strcmp(funcName, "xglCreateQueryPool"))
-        return (void*) xglCreateQueryPool;
-    if (!strcmp(funcName, "xglCreateBuffer"))
-        return (void*) xglCreateBuffer;
-    if (!strcmp(funcName, "xglCreateBufferView"))
-        return (void*) xglCreateBufferView;
-    if (!strcmp(funcName, "xglCreateImage"))
-        return (void*) xglCreateImage;
-    if (!strcmp(funcName, "xglCreateImageView"))
-        return (void*) xglCreateImageView;
-    if (!strcmp(funcName, "xglCreateColorAttachmentView"))
-        return (void*) xglCreateColorAttachmentView;
-    if (!strcmp(funcName, "xglCreateDepthStencilView"))
-        return (void*) xglCreateDepthStencilView;
-    if (!strcmp(funcName, "xglCreateShader"))
-        return (void*) xglCreateShader;
-    if (!strcmp(funcName, "xglCreateGraphicsPipeline"))
-        return (void*) xglCreateGraphicsPipeline;
-    if (!strcmp(funcName, "xglCreateGraphicsPipelineDerivative"))
-        return (void*) xglCreateGraphicsPipelineDerivative;
-    if (!strcmp(funcName, "xglCreateComputePipeline"))
-        return (void*) xglCreateComputePipeline;
-    if (!strcmp(funcName, "xglCreateSampler"))
-        return (void*) xglCreateSampler;
-    if (!strcmp(funcName, "xglCreateDynamicViewportState"))
-        return (void*) xglCreateDynamicViewportState;
-    if (!strcmp(funcName, "xglCreateDynamicRasterState"))
-        return (void*) xglCreateDynamicRasterState;
-    if (!strcmp(funcName, "xglCreateDynamicColorBlendState"))
-        return (void*) xglCreateDynamicColorBlendState;
-    if (!strcmp(funcName, "xglCreateDynamicDepthStencilState"))
-        return (void*) xglCreateDynamicDepthStencilState;
-    if (!strcmp(funcName, "xglCreateCommandBuffer"))
-        return (void*) xglCreateCommandBuffer;
-    if (!strcmp(funcName, "xglBeginCommandBuffer"))
-        return (void*) xglBeginCommandBuffer;
-    if (!strcmp(funcName, "xglEndCommandBuffer"))
-        return (void*) xglEndCommandBuffer;
-    if (!strcmp(funcName, "xglResetCommandBuffer"))
-        return (void*) xglResetCommandBuffer;
-    if (!strcmp(funcName, "xglCmdBindPipeline"))
-        return (void*) xglCmdBindPipeline;
-    if (!strcmp(funcName, "xglCmdBindDynamicStateObject"))
-        return (void*) xglCmdBindDynamicStateObject;
-    if (!strcmp(funcName, "xglCmdBindDescriptorSets"))
-        return (void*) xglCmdBindDescriptorSets;
-    if (!strcmp(funcName, "xglCmdBindVertexBuffer"))
-        return (void*) xglCmdBindVertexBuffer;
-    if (!strcmp(funcName, "xglCmdBindIndexBuffer"))
-        return (void*) xglCmdBindIndexBuffer;
-    if (!strcmp(funcName, "xglCmdDrawIndirect"))
-        return (void*) xglCmdDrawIndirect;
-    if (!strcmp(funcName, "xglCmdDrawIndexedIndirect"))
-        return (void*) xglCmdDrawIndexedIndirect;
-    if (!strcmp(funcName, "xglCmdDispatchIndirect"))
-        return (void*) xglCmdDispatchIndirect;
-    if (!strcmp(funcName, "xglCmdCopyBuffer"))
-        return (void*) xglCmdCopyBuffer;
-    if (!strcmp(funcName, "xglCmdCopyImage"))
-        return (void*) xglCmdCopyImage;
-    if (!strcmp(funcName, "xglCmdCopyBufferToImage"))
-        return (void*) xglCmdCopyBufferToImage;
-    if (!strcmp(funcName, "xglCmdCopyImageToBuffer"))
-        return (void*) xglCmdCopyImageToBuffer;
-    if (!strcmp(funcName, "xglCmdCloneImageData"))
-        return (void*) xglCmdCloneImageData;
-    if (!strcmp(funcName, "xglCmdUpdateBuffer"))
-        return (void*) xglCmdUpdateBuffer;
-    if (!strcmp(funcName, "xglCmdFillBuffer"))
-        return (void*) xglCmdFillBuffer;
-    if (!strcmp(funcName, "xglCmdClearColorImage"))
-        return (void*) xglCmdClearColorImage;
-    if (!strcmp(funcName, "xglCmdClearDepthStencil"))
-        return (void*) xglCmdClearDepthStencil;
-    if (!strcmp(funcName, "xglCmdResolveImage"))
-        return (void*) xglCmdResolveImage;
-    if (!strcmp(funcName, "xglCmdBeginQuery"))
-        return (void*) xglCmdBeginQuery;
-    if (!strcmp(funcName, "xglCmdEndQuery"))
-        return (void*) xglCmdEndQuery;
-    if (!strcmp(funcName, "xglCmdResetQueryPool"))
-        return (void*) xglCmdResetQueryPool;
-    if (!strcmp(funcName, "xglDbgRegisterMsgCallback"))
-        return (void*) xglDbgRegisterMsgCallback;
-    if (!strcmp(funcName, "xglDbgUnregisterMsgCallback"))
-        return (void*) xglDbgUnregisterMsgCallback;
-    if (!strcmp(funcName, "xglGetDeviceQueue"))
-        return (void*) xglGetDeviceQueue;
-    if (!strcmp(funcName, "xglQueueAddMemReference"))
-        return (void*) xglQueueAddMemReference;
-    if (!strcmp(funcName, "xglQueueRemoveMemReference"))
-        return (void*) xglQueueRemoveMemReference;
+    if (!strcmp(funcName, "vkGetProcAddr"))
+        return (void *) vkGetProcAddr;
+    if (!strcmp(funcName, "vkCreateDevice"))
+        return (void*) vkCreateDevice;
+    if (!strcmp(funcName, "vkDestroyDevice"))
+        return (void*) vkDestroyDevice;
+    if (!strcmp(funcName, "vkGetExtensionSupport"))
+        return (void*) vkGetExtensionSupport;
+    if (!strcmp(funcName, "vkEnumerateLayers"))
+        return (void*) vkEnumerateLayers;
+    if (!strcmp(funcName, "vkQueueSubmit"))
+        return (void*) vkQueueSubmit;
+    if (!strcmp(funcName, "vkAllocMemory"))
+        return (void*) vkAllocMemory;
+    if (!strcmp(funcName, "vkFreeMemory"))
+        return (void*) vkFreeMemory;
+    if (!strcmp(funcName, "vkSetMemoryPriority"))
+        return (void*) vkSetMemoryPriority;
+    if (!strcmp(funcName, "vkMapMemory"))
+        return (void*) vkMapMemory;
+    if (!strcmp(funcName, "vkUnmapMemory"))
+        return (void*) vkUnmapMemory;
+    if (!strcmp(funcName, "vkPinSystemMemory"))
+        return (void*) vkPinSystemMemory;
+    if (!strcmp(funcName, "vkOpenSharedMemory"))
+        return (void*) vkOpenSharedMemory;
+    if (!strcmp(funcName, "vkOpenPeerMemory"))
+        return (void*) vkOpenPeerMemory;
+    if (!strcmp(funcName, "vkOpenPeerImage"))
+        return (void*) vkOpenPeerImage;
+    if (!strcmp(funcName, "vkDestroyObject"))
+        return (void*) vkDestroyObject;
+    if (!strcmp(funcName, "vkGetObjectInfo"))
+        return (void*) vkGetObjectInfo;
+    if (!strcmp(funcName, "vkBindObjectMemory"))
+        return (void*) vkBindObjectMemory;
+    if (!strcmp(funcName, "vkCreateFence"))
+        return (void*) vkCreateFence;
+    if (!strcmp(funcName, "vkGetFenceStatus"))
+        return (void*) vkGetFenceStatus;
+    if (!strcmp(funcName, "vkResetFences"))
+        return (void*) vkResetFences;
+    if (!strcmp(funcName, "vkWaitForFences"))
+        return (void*) vkWaitForFences;
+    if (!strcmp(funcName, "vkQueueWaitIdle"))
+        return (void*) vkQueueWaitIdle;
+    if (!strcmp(funcName, "vkDeviceWaitIdle"))
+        return (void*) vkDeviceWaitIdle;
+    if (!strcmp(funcName, "vkCreateEvent"))
+        return (void*) vkCreateEvent;
+    if (!strcmp(funcName, "vkCreateQueryPool"))
+        return (void*) vkCreateQueryPool;
+    if (!strcmp(funcName, "vkCreateBuffer"))
+        return (void*) vkCreateBuffer;
+    if (!strcmp(funcName, "vkCreateBufferView"))
+        return (void*) vkCreateBufferView;
+    if (!strcmp(funcName, "vkCreateImage"))
+        return (void*) vkCreateImage;
+    if (!strcmp(funcName, "vkCreateImageView"))
+        return (void*) vkCreateImageView;
+    if (!strcmp(funcName, "vkCreateColorAttachmentView"))
+        return (void*) vkCreateColorAttachmentView;
+    if (!strcmp(funcName, "vkCreateDepthStencilView"))
+        return (void*) vkCreateDepthStencilView;
+    if (!strcmp(funcName, "vkCreateShader"))
+        return (void*) vkCreateShader;
+    if (!strcmp(funcName, "vkCreateGraphicsPipeline"))
+        return (void*) vkCreateGraphicsPipeline;
+    if (!strcmp(funcName, "vkCreateGraphicsPipelineDerivative"))
+        return (void*) vkCreateGraphicsPipelineDerivative;
+    if (!strcmp(funcName, "vkCreateComputePipeline"))
+        return (void*) vkCreateComputePipeline;
+    if (!strcmp(funcName, "vkCreateSampler"))
+        return (void*) vkCreateSampler;
+    if (!strcmp(funcName, "vkCreateDynamicViewportState"))
+        return (void*) vkCreateDynamicViewportState;
+    if (!strcmp(funcName, "vkCreateDynamicRasterState"))
+        return (void*) vkCreateDynamicRasterState;
+    if (!strcmp(funcName, "vkCreateDynamicColorBlendState"))
+        return (void*) vkCreateDynamicColorBlendState;
+    if (!strcmp(funcName, "vkCreateDynamicDepthStencilState"))
+        return (void*) vkCreateDynamicDepthStencilState;
+    if (!strcmp(funcName, "vkCreateCommandBuffer"))
+        return (void*) vkCreateCommandBuffer;
+    if (!strcmp(funcName, "vkBeginCommandBuffer"))
+        return (void*) vkBeginCommandBuffer;
+    if (!strcmp(funcName, "vkEndCommandBuffer"))
+        return (void*) vkEndCommandBuffer;
+    if (!strcmp(funcName, "vkResetCommandBuffer"))
+        return (void*) vkResetCommandBuffer;
+    if (!strcmp(funcName, "vkCmdBindPipeline"))
+        return (void*) vkCmdBindPipeline;
+    if (!strcmp(funcName, "vkCmdBindDynamicStateObject"))
+        return (void*) vkCmdBindDynamicStateObject;
+    if (!strcmp(funcName, "vkCmdBindDescriptorSets"))
+        return (void*) vkCmdBindDescriptorSets;
+    if (!strcmp(funcName, "vkCmdBindVertexBuffer"))
+        return (void*) vkCmdBindVertexBuffer;
+    if (!strcmp(funcName, "vkCmdBindIndexBuffer"))
+        return (void*) vkCmdBindIndexBuffer;
+    if (!strcmp(funcName, "vkCmdDrawIndirect"))
+        return (void*) vkCmdDrawIndirect;
+    if (!strcmp(funcName, "vkCmdDrawIndexedIndirect"))
+        return (void*) vkCmdDrawIndexedIndirect;
+    if (!strcmp(funcName, "vkCmdDispatchIndirect"))
+        return (void*) vkCmdDispatchIndirect;
+    if (!strcmp(funcName, "vkCmdCopyBuffer"))
+        return (void*) vkCmdCopyBuffer;
+    if (!strcmp(funcName, "vkCmdCopyImage"))
+        return (void*) vkCmdCopyImage;
+    if (!strcmp(funcName, "vkCmdCopyBufferToImage"))
+        return (void*) vkCmdCopyBufferToImage;
+    if (!strcmp(funcName, "vkCmdCopyImageToBuffer"))
+        return (void*) vkCmdCopyImageToBuffer;
+    if (!strcmp(funcName, "vkCmdCloneImageData"))
+        return (void*) vkCmdCloneImageData;
+    if (!strcmp(funcName, "vkCmdUpdateBuffer"))
+        return (void*) vkCmdUpdateBuffer;
+    if (!strcmp(funcName, "vkCmdFillBuffer"))
+        return (void*) vkCmdFillBuffer;
+    if (!strcmp(funcName, "vkCmdClearColorImage"))
+        return (void*) vkCmdClearColorImage;
+    if (!strcmp(funcName, "vkCmdClearDepthStencil"))
+        return (void*) vkCmdClearDepthStencil;
+    if (!strcmp(funcName, "vkCmdResolveImage"))
+        return (void*) vkCmdResolveImage;
+    if (!strcmp(funcName, "vkCmdBeginQuery"))
+        return (void*) vkCmdBeginQuery;
+    if (!strcmp(funcName, "vkCmdEndQuery"))
+        return (void*) vkCmdEndQuery;
+    if (!strcmp(funcName, "vkCmdResetQueryPool"))
+        return (void*) vkCmdResetQueryPool;
+    if (!strcmp(funcName, "vkDbgRegisterMsgCallback"))
+        return (void*) vkDbgRegisterMsgCallback;
+    if (!strcmp(funcName, "vkDbgUnregisterMsgCallback"))
+        return (void*) vkDbgUnregisterMsgCallback;
+    if (!strcmp(funcName, "vkGetDeviceQueue"))
+        return (void*) vkGetDeviceQueue;
+    if (!strcmp(funcName, "vkQueueAddMemReference"))
+        return (void*) vkQueueAddMemReference;
+    if (!strcmp(funcName, "vkQueueRemoveMemReference"))
+        return (void*) vkQueueRemoveMemReference;
 #if !defined(WIN32)
-    if (!strcmp(funcName, "xglWsiX11CreatePresentableImage"))
-        return (void*) xglWsiX11CreatePresentableImage;
-    if (!strcmp(funcName, "xglWsiX11QueuePresent"))
-        return (void*) xglWsiX11QueuePresent;
+    if (!strcmp(funcName, "vkWsiX11CreatePresentableImage"))
+        return (void*) vkWsiX11CreatePresentableImage;
+    if (!strcmp(funcName, "vkWsiX11QueuePresent"))
+        return (void*) vkWsiX11QueuePresent;
 #endif
     else {
         if (gpuw->pGPA == NULL)
             return NULL;
-        return gpuw->pGPA((XGL_PHYSICAL_GPU)gpuw->nextObject, funcName);
+        return gpuw->pGPA((VK_PHYSICAL_GPU)gpuw->nextObject, funcName);
     }
 }
diff --git a/layers/mem_tracker.h b/layers/mem_tracker.h
index 2548036..bb12132 100644
--- a/layers/mem_tracker.h
+++ b/layers/mem_tracker.h
@@ -1,5 +1,5 @@
 /*
- * XGL
+ * Vulkan
  *
  * Copyright (C) 2015 LunarG, Inc.
  *
@@ -22,7 +22,7 @@
  * DEALINGS IN THE SOFTWARE.
  */
 #pragma once
-#include "xglLayer.h"
+#include "vkLayer.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -40,14 +40,14 @@
     MEMTRACK_FREED_MEM_REF                 = 6,  // MEM Obj freed while it still has obj and/or CB refs
     MEMTRACK_MEM_OBJ_CLEAR_EMPTY_BINDINGS  = 7,  // Clearing bindings on mem obj that doesn't have any bindings
     MEMTRACK_MISSING_MEM_BINDINGS          = 8,  // Trying to retrieve mem bindings, but none found (may be internal error)
-    MEMTRACK_INVALID_OBJECT                = 9,  // Attempting to reference generic XGL Object that is invalid
-    MEMTRACK_FREE_MEM_ERROR                = 10, // Error while calling xglFreeMemory
+    MEMTRACK_INVALID_OBJECT                = 9,  // Attempting to reference generic VK Object that is invalid
+    MEMTRACK_FREE_MEM_ERROR                = 10, // Error while calling vkFreeMemory
     MEMTRACK_DESTROY_OBJECT_ERROR          = 11, // Destroying an object that has a memory reference
     MEMTRACK_MEMORY_BINDING_ERROR          = 12, // Error during one of many calls that bind memory to object or CB
     MEMTRACK_OUT_OF_MEMORY_ERROR           = 13, // malloc failed
-    MEMTRACK_MEMORY_LEAK                   = 14, // Failure to call xglFreeMemory on Mem Obj prior to DestroyDevice
+    MEMTRACK_MEMORY_LEAK                   = 14, // Failure to call vkFreeMemory on Mem Obj prior to DestroyDevice
     MEMTRACK_INVALID_STATE                 = 15, // Memory not in the correct state
-    MEMTRACK_RESET_CB_WHILE_IN_FLIGHT      = 16, // xglResetCommandBuffer() called on a CB that hasn't completed
+    MEMTRACK_RESET_CB_WHILE_IN_FLIGHT      = 16, // vkResetCommandBuffer() called on a CB that hasn't completed
     MEMTRACK_INVALID_QUEUE                 = 17, // Invalid queue requested or selected
     MEMTRACK_INVALID_FENCE_STATE           = 18, // Invalid Fence State signaled or used
 } MEM_TRACK_ERROR;
@@ -61,7 +61,7 @@
  *  memObjMap -- map of Memory Objects to MT_MEM_OBJ_INFO structures
  *    Each MT_MEM_OBJ_INFO has two stl list containers with:
  *      -- all CBs referencing this mem obj
- *      -- all XGL Objects that are bound to this memory
+ *      -- all VK Objects that are bound to this memory
  *  objectMap -- map of objects to MT_OBJ_INFO structures
  *
  * Algorithm overview
@@ -85,31 +85,31 @@
 // Data struct for tracking memory object
 struct MT_MEM_OBJ_INFO {
     uint32_t                     refCount;           // Count of references (obj bindings or CB use)
-    XGL_GPU_MEMORY               mem;
-    XGL_MEMORY_ALLOC_INFO        allocInfo;
-    list<XGL_OBJECT>             pObjBindings;       // list container of objects bound to this memory
-    list<XGL_CMD_BUFFER>         pCmdBufferBindings; // list container of cmd buffers that reference this mem object
+    VK_GPU_MEMORY               mem;
+    VK_MEMORY_ALLOC_INFO        allocInfo;
+    list<VK_OBJECT>             pObjBindings;       // list container of objects bound to this memory
+    list<VK_CMD_BUFFER>         pCmdBufferBindings; // list container of cmd buffers that reference this mem object
 };
 
 struct MT_OBJ_INFO {
     MT_MEM_OBJ_INFO*            pMemObjInfo;
-    XGL_OBJECT                  object;
-    XGL_STRUCTURE_TYPE          sType;
+    VK_OBJECT                  object;
+    VK_STRUCTURE_TYPE          sType;
     uint32_t                    ref_count;
     // Capture all object types that may have memory bound. From prog guide:
     // The only objects that are guaranteed to have no external memory
     //   requirements are devices, queues, command buffers, shaders and memory objects.
     union {
-        XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO     color_attachment_view_create_info;
-        XGL_DEPTH_STENCIL_VIEW_CREATE_INFO        ds_view_create_info;
-        XGL_IMAGE_VIEW_CREATE_INFO                image_view_create_info;
-        XGL_IMAGE_CREATE_INFO                     image_create_info;
-        XGL_GRAPHICS_PIPELINE_CREATE_INFO         graphics_pipeline_create_info;
-        XGL_COMPUTE_PIPELINE_CREATE_INFO          compute_pipeline_create_info;
-        XGL_SAMPLER_CREATE_INFO                   sampler_create_info;
-        XGL_FENCE_CREATE_INFO                     fence_create_info;
+        VK_COLOR_ATTACHMENT_VIEW_CREATE_INFO     color_attachment_view_create_info;
+        VK_DEPTH_STENCIL_VIEW_CREATE_INFO        ds_view_create_info;
+        VK_IMAGE_VIEW_CREATE_INFO                image_view_create_info;
+        VK_IMAGE_CREATE_INFO                     image_create_info;
+        VK_GRAPHICS_PIPELINE_CREATE_INFO         graphics_pipeline_create_info;
+        VK_COMPUTE_PIPELINE_CREATE_INFO          compute_pipeline_create_info;
+        VK_SAMPLER_CREATE_INFO                   sampler_create_info;
+        VK_FENCE_CREATE_INFO                     fence_create_info;
 #ifndef _WIN32
-        XGL_WSI_X11_PRESENTABLE_IMAGE_CREATE_INFO wsi_x11_presentable_image_create_info;
+        VK_WSI_X11_PRESENTABLE_IMAGE_CREATE_INFO wsi_x11_presentable_image_create_info;
 #endif // _WIN32
     } create_info;
     char object_name[64];
@@ -117,21 +117,21 @@
 
 // Track all command buffers
 struct MT_CB_INFO {
-    XGL_CMD_BUFFER_CREATE_INFO      createInfo;
-    MT_OBJ_INFO*                    pDynamicState[XGL_NUM_STATE_BIND_POINT];
-    XGL_PIPELINE                    pipelines[XGL_NUM_PIPELINE_BIND_POINT];
+    VK_CMD_BUFFER_CREATE_INFO      createInfo;
+    MT_OBJ_INFO*                    pDynamicState[VK_NUM_STATE_BIND_POINT];
+    VK_PIPELINE                    pipelines[VK_NUM_PIPELINE_BIND_POINT];
     uint32_t                        colorAttachmentCount;
-    XGL_DEPTH_STENCIL_BIND_INFO     dsBindInfo;
-    XGL_CMD_BUFFER                  cmdBuffer;
+    VK_DEPTH_STENCIL_BIND_INFO     dsBindInfo;
+    VK_CMD_BUFFER                  cmdBuffer;
     uint64_t                        fenceId;
     // Order dependent, stl containers must be at end of struct
-    list<XGL_GPU_MEMORY>            pMemObjList; // List container of Mem objs referenced by this CB
+    list<VK_GPU_MEMORY>            pMemObjList; // List container of Mem objs referenced by this CB
 };
 
 // Associate fenceId with a fence object
 struct MT_FENCE_INFO {
-    XGL_FENCE   fence;         // Handle to fence object
-    XGL_QUEUE   queue;         // Queue that this fence is submitted against
+    VK_FENCE   fence;         // Handle to fence object
+    VK_QUEUE   queue;         // Queue that this fence is submitted against
     bool32_t    localFence;    // Is fence created by layer?
 };
 
@@ -139,8 +139,8 @@
 struct MT_QUEUE_INFO {
     uint64_t                      lastRetiredId;
     uint64_t                      lastSubmittedId;
-    list<XGL_CMD_BUFFER>          pQueueCmdBuffers;
-    list<XGL_GPU_MEMORY>          pMemRefList;
+    list<VK_CMD_BUFFER>          pQueueCmdBuffers;
+    list<VK_GPU_MEMORY>          pMemRefList;
 };
 
 #ifdef __cplusplus
diff --git a/layers/multi.cpp b/layers/multi.cpp
index f8c2bc9..a4856eb 100644
--- a/layers/multi.cpp
+++ b/layers/multi.cpp
@@ -1,5 +1,5 @@
 /*
- * XGL
+ * Vulkan
  *
  * Copyright (C) 2014 LunarG, Inc.
  *
@@ -28,27 +28,27 @@
 #include <assert.h>
 #include <unordered_map>
 #include "loader_platform.h"
-#include "xgl_dispatch_table_helper.h"
-#include "xglLayer.h"
+#include "vk_dispatch_table_helper.h"
+#include "vkLayer.h"
 // The following is #included again to catch certain OS-specific functions
 // being used:
 #include "loader_platform.h"
 
-static void initLayerTable(const XGL_BASE_LAYER_OBJECT *gpuw, XGL_LAYER_DISPATCH_TABLE *pTable, const unsigned int layerNum);
+static void initLayerTable(const VK_BASE_LAYER_OBJECT *gpuw, VK_LAYER_DISPATCH_TABLE *pTable, const unsigned int layerNum);
 
 /******************************** Layer multi1 functions **************************/
-static std::unordered_map<void *, XGL_LAYER_DISPATCH_TABLE *> tableMap1;
+static std::unordered_map<void *, VK_LAYER_DISPATCH_TABLE *> tableMap1;
 static bool layer1_first_activated = false;
 
-static XGL_LAYER_DISPATCH_TABLE * getLayer1Table(const XGL_BASE_LAYER_OBJECT *gpuw)
+static VK_LAYER_DISPATCH_TABLE * getLayer1Table(const VK_BASE_LAYER_OBJECT *gpuw)
 {
-    XGL_LAYER_DISPATCH_TABLE *pTable;
+    VK_LAYER_DISPATCH_TABLE *pTable;
 
     assert(gpuw);
-    std::unordered_map<void *, XGL_LAYER_DISPATCH_TABLE *>::const_iterator it = tableMap1.find((void *) gpuw);
+    std::unordered_map<void *, VK_LAYER_DISPATCH_TABLE *>::const_iterator it = tableMap1.find((void *) gpuw);
     if (it == tableMap1.end())
     {
-        pTable =  new XGL_LAYER_DISPATCH_TABLE;
+        pTable =  new VK_LAYER_DISPATCH_TABLE;
         tableMap1[(void *) gpuw] = pTable;
         initLayerTable(gpuw, pTable, 1);
         return pTable;
@@ -62,98 +62,98 @@
 #endif
 
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI multi1CreateDevice(XGL_PHYSICAL_GPU gpu, const XGL_DEVICE_CREATE_INFO* pCreateInfo,
-                                                      XGL_DEVICE* pDevice)
+VK_LAYER_EXPORT VK_RESULT VKAPI multi1CreateDevice(VK_PHYSICAL_GPU gpu, const VK_DEVICE_CREATE_INFO* pCreateInfo,
+                                                      VK_DEVICE* pDevice)
 {
-    XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) gpu;
-    XGL_LAYER_DISPATCH_TABLE* pTable = getLayer1Table(gpuw);
+    VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
+    VK_LAYER_DISPATCH_TABLE* pTable = getLayer1Table(gpuw);
 
-    printf("At start of multi1 layer xglCreateDevice()\n");
-    XGL_RESULT result = pTable->CreateDevice((XGL_PHYSICAL_GPU)gpuw->nextObject, pCreateInfo, pDevice);
+    printf("At start of multi1 layer vkCreateDevice()\n");
+    VK_RESULT result = pTable->CreateDevice((VK_PHYSICAL_GPU)gpuw->nextObject, pCreateInfo, pDevice);
     // create a mapping for the device object into the dispatch table
     tableMap1.emplace(*pDevice, pTable);
-    printf("Completed multi1 layer xglCreateDevice()\n");
+    printf("Completed multi1 layer vkCreateDevice()\n");
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI multi1CreateGraphicsPipeline(XGL_DEVICE device, const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo,
-                                                                XGL_PIPELINE* pPipeline)
+VK_LAYER_EXPORT VK_RESULT VKAPI multi1CreateGraphicsPipeline(VK_DEVICE device, const VK_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo,
+                                                                VK_PIPELINE* pPipeline)
 {
-    XGL_LAYER_DISPATCH_TABLE* pTable = tableMap1[device];
+    VK_LAYER_DISPATCH_TABLE* pTable = tableMap1[device];
 
-    printf("At start of multi1 layer xglCreateGraphicsPipeline()\n");
-    XGL_RESULT result = pTable->CreateGraphicsPipeline(device, pCreateInfo, pPipeline);
+    printf("At start of multi1 layer vkCreateGraphicsPipeline()\n");
+    VK_RESULT result = pTable->CreateGraphicsPipeline(device, pCreateInfo, pPipeline);
     // create a mapping for the pipeline object into the dispatch table
     tableMap1.emplace(*pPipeline, pTable);
-    printf("Completed multi1 layer xglCreateGraphicsPipeline()\n");
+    printf("Completed multi1 layer vkCreateGraphicsPipeline()\n");
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI multi1StorePipeline(XGL_PIPELINE pipeline, size_t* pDataSize, void* pData)
+VK_LAYER_EXPORT VK_RESULT VKAPI multi1StorePipeline(VK_PIPELINE pipeline, size_t* pDataSize, void* pData)
 {
-    XGL_LAYER_DISPATCH_TABLE* pTable = tableMap1[pipeline];
+    VK_LAYER_DISPATCH_TABLE* pTable = tableMap1[pipeline];
 
-    printf("At start of multi1 layer xglStorePipeline()\n");
-    XGL_RESULT result = pTable->StorePipeline(pipeline, pDataSize, pData);
-    printf("Completed multi1 layer xglStorePipeline()\n");
+    printf("At start of multi1 layer vkStorePipeline()\n");
+    VK_RESULT result = pTable->StorePipeline(pipeline, pDataSize, pData);
+    printf("Completed multi1 layer vkStorePipeline()\n");
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI multi1EnumerateLayers(XGL_PHYSICAL_GPU gpu, size_t maxLayerCount, size_t maxStringSize,
+VK_LAYER_EXPORT VK_RESULT VKAPI multi1EnumerateLayers(VK_PHYSICAL_GPU gpu, size_t maxLayerCount, size_t maxStringSize,
                                                          size_t* pOutLayerCount, char* const* pOutLayers,
                                                          void* pReserved)
 {
     if (gpu == NULL)
-        return xglEnumerateLayers(gpu, maxLayerCount, maxStringSize, pOutLayerCount, pOutLayers, pReserved);
+        return vkEnumerateLayers(gpu, maxLayerCount, maxStringSize, pOutLayerCount, pOutLayers, pReserved);
 
-    XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) gpu;
-    XGL_LAYER_DISPATCH_TABLE* pTable = getLayer1Table(gpuw);
+    VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
+    VK_LAYER_DISPATCH_TABLE* pTable = getLayer1Table(gpuw);
 
-    printf("At start of multi1 layer xglEnumerateLayers()\n");
-    XGL_RESULT result = pTable->EnumerateLayers((XGL_PHYSICAL_GPU)gpuw->nextObject, maxLayerCount, maxStringSize, pOutLayerCount, pOutLayers, pReserved);
-    printf("Completed multi1 layer xglEnumerateLayers()\n");
+    printf("At start of multi1 layer vkEnumerateLayers()\n");
+    VK_RESULT result = pTable->EnumerateLayers((VK_PHYSICAL_GPU)gpuw->nextObject, maxLayerCount, maxStringSize, pOutLayerCount, pOutLayers, pReserved);
+    printf("Completed multi1 layer vkEnumerateLayers()\n");
     return result;
 }
 
-XGL_LAYER_EXPORT void * XGLAPI multi1GetProcAddr(XGL_PHYSICAL_GPU gpu, const char* pName)
+VK_LAYER_EXPORT void * VKAPI multi1GetProcAddr(VK_PHYSICAL_GPU gpu, const char* pName)
 {
-    XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) gpu;
+    VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
 
     if (gpu == NULL)
         return NULL;
 
     getLayer1Table(gpuw);
 
-    if (!strncmp("xglCreateDevice", pName, sizeof ("xglCreateDevice")))
+    if (!strncmp("vkCreateDevice", pName, sizeof ("vkCreateDevice")))
         return (void *) multi1CreateDevice;
-    else if (!strncmp("xglEnumerateLayers", pName, sizeof ("xglEnumerateLayers")))
+    else if (!strncmp("vkEnumerateLayers", pName, sizeof ("vkEnumerateLayers")))
         return (void *) multi1EnumerateLayers;
-    else if (!strncmp("xglCreateGraphicsPipeline", pName, sizeof ("xglCreateGraphicsPipeline")))
+    else if (!strncmp("vkCreateGraphicsPipeline", pName, sizeof ("vkCreateGraphicsPipeline")))
         return (void *) multi1CreateGraphicsPipeline;
-    else if (!strncmp("xglStorePipeline", pName, sizeof ("xglStorePipeline")))
+    else if (!strncmp("vkStorePipeline", pName, sizeof ("vkStorePipeline")))
         return (void *) multi1StorePipeline;
-    else if (!strncmp("xglGetExtensionSupport", pName, sizeof ("xglGetExtensionSupport")))
-        return (void *) xglGetExtensionSupport;
+    else if (!strncmp("vkGetExtensionSupport", pName, sizeof ("vkGetExtensionSupport")))
+        return (void *) vkGetExtensionSupport;
     else {
         if (gpuw->pGPA == NULL)
             return NULL;
-        return gpuw->pGPA((XGL_PHYSICAL_GPU) gpuw->nextObject, pName);
+        return gpuw->pGPA((VK_PHYSICAL_GPU) gpuw->nextObject, pName);
     }
 }
 
 /******************************** Layer multi2 functions **************************/
-static std::unordered_map<void *, XGL_LAYER_DISPATCH_TABLE *> tableMap2;
+static std::unordered_map<void *, VK_LAYER_DISPATCH_TABLE *> tableMap2;
 static bool layer2_first_activated = false;
 
-static XGL_LAYER_DISPATCH_TABLE * getLayer2Table(const XGL_BASE_LAYER_OBJECT *gpuw)
+static VK_LAYER_DISPATCH_TABLE * getLayer2Table(const VK_BASE_LAYER_OBJECT *gpuw)
 {
-    XGL_LAYER_DISPATCH_TABLE *pTable;
+    VK_LAYER_DISPATCH_TABLE *pTable;
 
     assert(gpuw);
-    std::unordered_map<void *, XGL_LAYER_DISPATCH_TABLE *>::const_iterator it = tableMap2.find((void *) gpuw);
+    std::unordered_map<void *, VK_LAYER_DISPATCH_TABLE *>::const_iterator it = tableMap2.find((void *) gpuw);
     if (it == tableMap2.end())
     {
-        pTable =  new XGL_LAYER_DISPATCH_TABLE;
+        pTable =  new VK_LAYER_DISPATCH_TABLE;
         tableMap2[(void *) gpuw] = pTable;
         initLayerTable(gpuw, pTable, 2);
         return pTable;
@@ -163,138 +163,138 @@
     }
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI multi2CreateDevice(XGL_PHYSICAL_GPU gpu, const XGL_DEVICE_CREATE_INFO* pCreateInfo,
-                                                      XGL_DEVICE* pDevice)
+VK_LAYER_EXPORT VK_RESULT VKAPI multi2CreateDevice(VK_PHYSICAL_GPU gpu, const VK_DEVICE_CREATE_INFO* pCreateInfo,
+                                                      VK_DEVICE* pDevice)
 {
-    XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) gpu;
-    XGL_LAYER_DISPATCH_TABLE* pTable = getLayer2Table(gpuw);
+    VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
+    VK_LAYER_DISPATCH_TABLE* pTable = getLayer2Table(gpuw);
 
-    printf("At start of multi2 xglCreateDevice()\n");
-    XGL_RESULT result = pTable->CreateDevice((XGL_PHYSICAL_GPU)gpuw->nextObject, pCreateInfo, pDevice);
+    printf("At start of multi2 vkCreateDevice()\n");
+    VK_RESULT result = pTable->CreateDevice((VK_PHYSICAL_GPU)gpuw->nextObject, pCreateInfo, pDevice);
     // create a mapping for the device object into the dispatch table for layer2
     tableMap2.emplace(*pDevice, pTable);
-    printf("Completed multi2 layer xglCreateDevice()\n");
+    printf("Completed multi2 layer vkCreateDevice()\n");
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI multi2CreateCommandBuffer(XGL_DEVICE device, const XGL_CMD_BUFFER_CREATE_INFO* pCreateInfo,
-                                                             XGL_CMD_BUFFER* pCmdBuffer)
+VK_LAYER_EXPORT VK_RESULT VKAPI multi2CreateCommandBuffer(VK_DEVICE device, const VK_CMD_BUFFER_CREATE_INFO* pCreateInfo,
+                                                             VK_CMD_BUFFER* pCmdBuffer)
 {
-    XGL_LAYER_DISPATCH_TABLE* pTable = tableMap2[device];
+    VK_LAYER_DISPATCH_TABLE* pTable = tableMap2[device];
 
-    printf("At start of multi2 layer xglCreateCommandBuffer()\n");
-    XGL_RESULT result = pTable->CreateCommandBuffer(device, pCreateInfo, pCmdBuffer);
+    printf("At start of multi2 layer vkCreateCommandBuffer()\n");
+    VK_RESULT result = pTable->CreateCommandBuffer(device, pCreateInfo, pCmdBuffer);
     // create a mapping for CmdBuffer object into the dispatch table for layer 2
     tableMap2.emplace(*pCmdBuffer, pTable);
-    printf("Completed multi2 layer xglCreateCommandBuffer()\n");
+    printf("Completed multi2 layer vkCreateCommandBuffer()\n");
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI multi2BeginCommandBuffer(XGL_CMD_BUFFER cmdBuffer, const XGL_CMD_BUFFER_BEGIN_INFO* pBeginInfo)
+VK_LAYER_EXPORT VK_RESULT VKAPI multi2BeginCommandBuffer(VK_CMD_BUFFER cmdBuffer, const VK_CMD_BUFFER_BEGIN_INFO* pBeginInfo)
 {
-    XGL_LAYER_DISPATCH_TABLE* pTable = tableMap2[cmdBuffer];
+    VK_LAYER_DISPATCH_TABLE* pTable = tableMap2[cmdBuffer];
 
-    printf("At start of multi2 layer xglBeginCommandBuffer()\n");
-    XGL_RESULT result = pTable->BeginCommandBuffer(cmdBuffer, pBeginInfo);
-    printf("Completed multi2 layer xglBeginCommandBuffer()\n");
+    printf("At start of multi2 layer vkBeginCommandBuffer()\n");
+    VK_RESULT result = pTable->BeginCommandBuffer(cmdBuffer, pBeginInfo);
+    printf("Completed multi2 layer vkBeginCommandBuffer()\n");
     return result;
 
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI multi2EnumerateLayers(XGL_PHYSICAL_GPU gpu, size_t maxLayerCount, size_t maxStringSize,
+VK_LAYER_EXPORT VK_RESULT VKAPI multi2EnumerateLayers(VK_PHYSICAL_GPU gpu, size_t maxLayerCount, size_t maxStringSize,
                                                          size_t* pOutLayerCount, char* const* pOutLayers,
                                                          void* pReserved)
 {
     if (gpu == NULL)
-        return xglEnumerateLayers(gpu, maxLayerCount, maxStringSize, pOutLayerCount, pOutLayers, pReserved);
+        return vkEnumerateLayers(gpu, maxLayerCount, maxStringSize, pOutLayerCount, pOutLayers, pReserved);
 
-    XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) gpu;
-    XGL_LAYER_DISPATCH_TABLE* pTable = getLayer2Table(gpuw);
+    VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
+    VK_LAYER_DISPATCH_TABLE* pTable = getLayer2Table(gpuw);
 
-    printf("At start of multi2 layer xglEnumerateLayers()\n");
-    XGL_RESULT result = pTable->EnumerateLayers((XGL_PHYSICAL_GPU)gpuw->nextObject, maxLayerCount, maxStringSize, pOutLayerCount, pOutLayers, pReserved);
-    printf("Completed multi2 layer xglEnumerateLayers()\n");
+    printf("At start of multi2 layer vkEnumerateLayers()\n");
+    VK_RESULT result = pTable->EnumerateLayers((VK_PHYSICAL_GPU)gpuw->nextObject, maxLayerCount, maxStringSize, pOutLayerCount, pOutLayers, pReserved);
+    printf("Completed multi2 layer vkEnumerateLayers()\n");
     return result;
 }
 
-XGL_LAYER_EXPORT void * XGLAPI multi2GetProcAddr(XGL_PHYSICAL_GPU gpu, const char* pName)
+VK_LAYER_EXPORT void * VKAPI multi2GetProcAddr(VK_PHYSICAL_GPU gpu, const char* pName)
 {
-    XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) gpu;
+    VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
 
     if (gpu == NULL)
         return NULL;
 
     getLayer2Table(gpuw);
 
-    if (!strncmp("xglCreateDevice", pName, sizeof ("xglCreateDevice")))
+    if (!strncmp("vkCreateDevice", pName, sizeof ("vkCreateDevice")))
         return (void *) multi2CreateDevice;
-    else if (!strncmp("xglEnumerateLayers", pName, sizeof ("xglEnumerateLayers")))
+    else if (!strncmp("vkEnumerateLayers", pName, sizeof ("vkEnumerateLayers")))
         return (void *) multi2EnumerateLayers;
-    else if (!strncmp("xglCreateCommandBuffer", pName, sizeof ("xglCreateCommandBuffer")))
+    else if (!strncmp("vkCreateCommandBuffer", pName, sizeof ("vkCreateCommandBuffer")))
         return (void *) multi2CreateCommandBuffer;
-    else if (!strncmp("xglBeginCommandBuffer", pName, sizeof ("xglBeginCommandBuffer")))
+    else if (!strncmp("vkBeginCommandBuffer", pName, sizeof ("vkBeginCommandBuffer")))
         return (void *) multi2BeginCommandBuffer;
-    else if (!strncmp("xglGetExtensionSupport", pName, sizeof ("xglGetExtensionSupport")))
-        return (void *) xglGetExtensionSupport;
+    else if (!strncmp("vkGetExtensionSupport", pName, sizeof ("vkGetExtensionSupport")))
+        return (void *) vkGetExtensionSupport;
     else {
         if (gpuw->pGPA == NULL)
             return NULL;
-        return gpuw->pGPA((XGL_PHYSICAL_GPU) gpuw->nextObject, pName);
+        return gpuw->pGPA((VK_PHYSICAL_GPU) gpuw->nextObject, pName);
     }
 }
 
 /********************************* Common functions ********************************/
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglEnumerateLayers(XGL_PHYSICAL_GPU gpu, size_t maxLayerCount, size_t maxStringSize,
+VK_LAYER_EXPORT VK_RESULT VKAPI vkEnumerateLayers(VK_PHYSICAL_GPU gpu, size_t maxLayerCount, size_t maxStringSize,
                                                       size_t* pOutLayerCount, char* const* pOutLayers,
                                                       void* pReserved)
 {
     if (pOutLayerCount == NULL || pOutLayers == NULL || pOutLayers[0] == NULL || pOutLayers[1] == NULL || pReserved == NULL)
-        return XGL_ERROR_INVALID_POINTER;
+        return VK_ERROR_INVALID_POINTER;
 
     if (maxLayerCount < 2)
-        return XGL_ERROR_INITIALIZATION_FAILED;
+        return VK_ERROR_INITIALIZATION_FAILED;
     *pOutLayerCount = 2;
     strncpy((char *) pOutLayers[0], "multi1", maxStringSize);
     strncpy((char *) pOutLayers[1], "multi2", maxStringSize);
-    return XGL_SUCCESS;
+    return VK_SUCCESS;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglGetExtensionSupport(XGL_PHYSICAL_GPU gpu, const char* pExtName)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkGetExtensionSupport(VK_PHYSICAL_GPU gpu, const char* pExtName)
 {
-    XGL_RESULT result;
-    XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) gpu;
+    VK_RESULT result;
+    VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
 
     /* This entrypoint is NOT going to init it's own dispatch table since loader calls here early */
     if (!strncmp(pExtName, "multi1", strlen("multi1")))
     {
-        result = XGL_SUCCESS;
+        result = VK_SUCCESS;
     } else if (!strncmp(pExtName, "multi2", strlen("multi2")))
     {
-        result = XGL_SUCCESS;
+        result = VK_SUCCESS;
     } else if (!tableMap1.empty() && (tableMap1.find(gpuw) != tableMap1.end()))
     {
-        XGL_LAYER_DISPATCH_TABLE* pTable = tableMap1[gpuw];
-        result = pTable->GetExtensionSupport((XGL_PHYSICAL_GPU)gpuw->nextObject, pExtName);
+        VK_LAYER_DISPATCH_TABLE* pTable = tableMap1[gpuw];
+        result = pTable->GetExtensionSupport((VK_PHYSICAL_GPU)gpuw->nextObject, pExtName);
     } else if (!tableMap2.empty() && (tableMap2.find(gpuw) != tableMap2.end()))
     {
-        XGL_LAYER_DISPATCH_TABLE* pTable = tableMap2[gpuw];
-        result = pTable->GetExtensionSupport((XGL_PHYSICAL_GPU)gpuw->nextObject, pExtName);
+        VK_LAYER_DISPATCH_TABLE* pTable = tableMap2[gpuw];
+        result = pTable->GetExtensionSupport((VK_PHYSICAL_GPU)gpuw->nextObject, pExtName);
     } else
     {
-        result = XGL_ERROR_INVALID_EXTENSION;
+        result = VK_ERROR_INVALID_EXTENSION;
     }
     return result;
 }
 
-XGL_LAYER_EXPORT void * XGLAPI xglGetProcAddr(XGL_PHYSICAL_GPU gpu, const char* pName)
+VK_LAYER_EXPORT void * VKAPI vkGetProcAddr(VK_PHYSICAL_GPU gpu, const char* pName)
 {
     // to find each layers GPA routine Loader will search via "<layerName>GetProcAddr"
     if (!strncmp("multi1GetProcAddr", pName, sizeof("multi1GetProcAddr")))
         return (void *) multi1GetProcAddr;
     else if (!strncmp("multi2GetProcAddr", pName, sizeof("multi2GetProcAddr")))
         return (void *) multi2GetProcAddr;
-    else if (!strncmp("xglGetProcAddr", pName, sizeof("xglGetProcAddr")))
-        return (void *) xglGetProcAddr;
+    else if (!strncmp("vkGetProcAddr", pName, sizeof("vkGetProcAddr")))
+        return (void *) vkGetProcAddr;
 
     // use first layer activated as GPA dispatch table activation happens in order
     else if (layer1_first_activated)
@@ -310,12 +310,12 @@
 }    //extern "C"
 #endif
 
-static void initLayerTable(const XGL_BASE_LAYER_OBJECT *gpuw, XGL_LAYER_DISPATCH_TABLE *pTable, const unsigned int layerNum)
+static void initLayerTable(const VK_BASE_LAYER_OBJECT *gpuw, VK_LAYER_DISPATCH_TABLE *pTable, const unsigned int layerNum)
 {
     if (layerNum == 2 && layer1_first_activated == false)
         layer2_first_activated = true;
     if (layerNum == 1 && layer2_first_activated == false)
         layer1_first_activated = true;
 
-    layer_initialize_dispatch_table(pTable, gpuw->pGPA, (XGL_PHYSICAL_GPU) gpuw->nextObject);
+    layer_initialize_dispatch_table(pTable, gpuw->pGPA, (VK_PHYSICAL_GPU) gpuw->nextObject);
 }
diff --git a/layers/object_track.h b/layers/object_track.h
index 65e1fef..a0050c8 100644
--- a/layers/object_track.h
+++ b/layers/object_track.h
@@ -1,5 +1,5 @@
 /*
- * XGL
+ * Vulkan
  *
  * Copyright (C) 2014 LunarG, Inc.
  *
@@ -22,7 +22,7 @@
  * DEALINGS IN THE SOFTWARE.
  */
 
-#include "xglLayer.h"
+#include "vkLayer.h"
 // Object Tracker ERROR codes
 typedef enum _OBJECT_TRACK_ERROR
 {
@@ -56,109 +56,109 @@
 } OBJECT_STATUS;
 // TODO : Make this code-generated
 // Object type enum
-typedef enum _XGL_OBJECT_TYPE
+typedef enum _VK_OBJECT_TYPE
 {
-    XGL_OBJECT_TYPE_SAMPLER,
-    XGL_OBJECT_TYPE_DYNAMIC_DS_STATE_OBJECT,
-    XGL_OBJECT_TYPE_DESCRIPTOR_SET,
-    XGL_OBJECT_TYPE_DESCRIPTOR_POOL,
-    XGL_OBJECT_TYPE_DYNAMIC_CB_STATE_OBJECT,
-    XGL_OBJECT_TYPE_IMAGE_VIEW,
-    XGL_OBJECT_TYPE_SEMAPHORE,
-    XGL_OBJECT_TYPE_SHADER,
-    XGL_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT,
-    XGL_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_CHAIN,
-    XGL_OBJECT_TYPE_BUFFER,
-    XGL_OBJECT_TYPE_PIPELINE,
-    XGL_OBJECT_TYPE_DEVICE,
-    XGL_OBJECT_TYPE_QUERY_POOL,
-    XGL_OBJECT_TYPE_EVENT,
-    XGL_OBJECT_TYPE_QUEUE,
-    XGL_OBJECT_TYPE_PHYSICAL_GPU,
-    XGL_OBJECT_TYPE_RENDER_PASS,
-    XGL_OBJECT_TYPE_FRAMEBUFFER,
-    XGL_OBJECT_TYPE_IMAGE,
-    XGL_OBJECT_TYPE_BUFFER_VIEW,
-    XGL_OBJECT_TYPE_DEPTH_STENCIL_VIEW,
-    XGL_OBJECT_TYPE_INSTANCE,
-    XGL_OBJECT_TYPE_PIPELINE_DELTA,
-    XGL_OBJECT_TYPE_DYNAMIC_VP_STATE_OBJECT,
-    XGL_OBJECT_TYPE_COLOR_ATTACHMENT_VIEW,
-    XGL_OBJECT_TYPE_GPU_MEMORY,
-    XGL_OBJECT_TYPE_DYNAMIC_RS_STATE_OBJECT,
-    XGL_OBJECT_TYPE_FENCE,
-    XGL_OBJECT_TYPE_CMD_BUFFER,
-    XGL_OBJECT_TYPE_PRESENTABLE_IMAGE_MEMORY,
+    VK_OBJECT_TYPE_SAMPLER,
+    VK_OBJECT_TYPE_DYNAMIC_DS_STATE_OBJECT,
+    VK_OBJECT_TYPE_DESCRIPTOR_SET,
+    VK_OBJECT_TYPE_DESCRIPTOR_POOL,
+    VK_OBJECT_TYPE_DYNAMIC_CB_STATE_OBJECT,
+    VK_OBJECT_TYPE_IMAGE_VIEW,
+    VK_OBJECT_TYPE_SEMAPHORE,
+    VK_OBJECT_TYPE_SHADER,
+    VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT,
+    VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_CHAIN,
+    VK_OBJECT_TYPE_BUFFER,
+    VK_OBJECT_TYPE_PIPELINE,
+    VK_OBJECT_TYPE_DEVICE,
+    VK_OBJECT_TYPE_QUERY_POOL,
+    VK_OBJECT_TYPE_EVENT,
+    VK_OBJECT_TYPE_QUEUE,
+    VK_OBJECT_TYPE_PHYSICAL_GPU,
+    VK_OBJECT_TYPE_RENDER_PASS,
+    VK_OBJECT_TYPE_FRAMEBUFFER,
+    VK_OBJECT_TYPE_IMAGE,
+    VK_OBJECT_TYPE_BUFFER_VIEW,
+    VK_OBJECT_TYPE_DEPTH_STENCIL_VIEW,
+    VK_OBJECT_TYPE_INSTANCE,
+    VK_OBJECT_TYPE_PIPELINE_DELTA,
+    VK_OBJECT_TYPE_DYNAMIC_VP_STATE_OBJECT,
+    VK_OBJECT_TYPE_COLOR_ATTACHMENT_VIEW,
+    VK_OBJECT_TYPE_GPU_MEMORY,
+    VK_OBJECT_TYPE_DYNAMIC_RS_STATE_OBJECT,
+    VK_OBJECT_TYPE_FENCE,
+    VK_OBJECT_TYPE_CMD_BUFFER,
+    VK_OBJECT_TYPE_PRESENTABLE_IMAGE_MEMORY,
 
-    XGL_OBJECT_TYPE_UNKNOWN,
-    XGL_NUM_OBJECT_TYPE,
-    XGL_OBJECT_TYPE_ANY, // Allow global object list to be queried/retrieved
-} XGL_OBJECT_TYPE;
+    VK_OBJECT_TYPE_UNKNOWN,
+    VK_NUM_OBJECT_TYPE,
+    VK_OBJECT_TYPE_ANY, // Allow global object list to be queried/retrieved
+} VK_OBJECT_TYPE;
 
-static const char* string_XGL_OBJECT_TYPE(XGL_OBJECT_TYPE type) {
+static const char* string_VK_OBJECT_TYPE(VK_OBJECT_TYPE type) {
     switch (type)
     {
-        case XGL_OBJECT_TYPE_DEVICE:
+        case VK_OBJECT_TYPE_DEVICE:
             return "DEVICE";
-        case XGL_OBJECT_TYPE_PIPELINE:
+        case VK_OBJECT_TYPE_PIPELINE:
             return "PIPELINE";
-        case XGL_OBJECT_TYPE_FENCE:
+        case VK_OBJECT_TYPE_FENCE:
             return "FENCE";
-        case XGL_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT:
+        case VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT:
             return "DESCRIPTOR_SET_LAYOUT";
-        case XGL_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_CHAIN:
+        case VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_CHAIN:
             return "DESCRIPTOR_SET_LAYOUT_CHAIN";
-        case XGL_OBJECT_TYPE_GPU_MEMORY:
+        case VK_OBJECT_TYPE_GPU_MEMORY:
             return "GPU_MEMORY";
-        case XGL_OBJECT_TYPE_QUEUE:
+        case VK_OBJECT_TYPE_QUEUE:
             return "QUEUE";
-        case XGL_OBJECT_TYPE_IMAGE:
+        case VK_OBJECT_TYPE_IMAGE:
             return "IMAGE";
-        case XGL_OBJECT_TYPE_CMD_BUFFER:
+        case VK_OBJECT_TYPE_CMD_BUFFER:
             return "CMD_BUFFER";
-        case XGL_OBJECT_TYPE_SEMAPHORE:
+        case VK_OBJECT_TYPE_SEMAPHORE:
             return "SEMAPHORE";
-        case XGL_OBJECT_TYPE_FRAMEBUFFER:
+        case VK_OBJECT_TYPE_FRAMEBUFFER:
             return "FRAMEBUFFER";
-        case XGL_OBJECT_TYPE_SAMPLER:
+        case VK_OBJECT_TYPE_SAMPLER:
             return "SAMPLER";
-        case XGL_OBJECT_TYPE_COLOR_ATTACHMENT_VIEW:
+        case VK_OBJECT_TYPE_COLOR_ATTACHMENT_VIEW:
             return "COLOR_ATTACHMENT_VIEW";
-        case XGL_OBJECT_TYPE_BUFFER_VIEW:
+        case VK_OBJECT_TYPE_BUFFER_VIEW:
             return "BUFFER_VIEW";
-        case XGL_OBJECT_TYPE_DESCRIPTOR_SET:
+        case VK_OBJECT_TYPE_DESCRIPTOR_SET:
             return "DESCRIPTOR_SET";
-        case XGL_OBJECT_TYPE_PHYSICAL_GPU:
+        case VK_OBJECT_TYPE_PHYSICAL_GPU:
             return "PHYSICAL_GPU";
-        case XGL_OBJECT_TYPE_IMAGE_VIEW:
+        case VK_OBJECT_TYPE_IMAGE_VIEW:
             return "IMAGE_VIEW";
-        case XGL_OBJECT_TYPE_BUFFER:
+        case VK_OBJECT_TYPE_BUFFER:
             return "BUFFER";
-        case XGL_OBJECT_TYPE_PIPELINE_DELTA:
+        case VK_OBJECT_TYPE_PIPELINE_DELTA:
             return "PIPELINE_DELTA";
-        case XGL_OBJECT_TYPE_DYNAMIC_RS_STATE_OBJECT:
+        case VK_OBJECT_TYPE_DYNAMIC_RS_STATE_OBJECT:
             return "DYNAMIC_RS_STATE_OBJECT";
-        case XGL_OBJECT_TYPE_EVENT:
+        case VK_OBJECT_TYPE_EVENT:
             return "EVENT";
-        case XGL_OBJECT_TYPE_DEPTH_STENCIL_VIEW:
+        case VK_OBJECT_TYPE_DEPTH_STENCIL_VIEW:
             return "DEPTH_STENCIL_VIEW";
-        case XGL_OBJECT_TYPE_SHADER:
+        case VK_OBJECT_TYPE_SHADER:
             return "SHADER";
-        case XGL_OBJECT_TYPE_DYNAMIC_DS_STATE_OBJECT:
+        case VK_OBJECT_TYPE_DYNAMIC_DS_STATE_OBJECT:
             return "DYNAMIC_DS_STATE_OBJECT";
-        case XGL_OBJECT_TYPE_DYNAMIC_VP_STATE_OBJECT:
+        case VK_OBJECT_TYPE_DYNAMIC_VP_STATE_OBJECT:
             return "DYNAMIC_VP_STATE_OBJECT";
-        case XGL_OBJECT_TYPE_DYNAMIC_CB_STATE_OBJECT:
+        case VK_OBJECT_TYPE_DYNAMIC_CB_STATE_OBJECT:
             return "DYNAMIC_CB_STATE_OBJECT";
-        case XGL_OBJECT_TYPE_INSTANCE:
+        case VK_OBJECT_TYPE_INSTANCE:
             return "INSTANCE";
-        case XGL_OBJECT_TYPE_RENDER_PASS:
+        case VK_OBJECT_TYPE_RENDER_PASS:
             return "RENDER_PASS";
-        case XGL_OBJECT_TYPE_QUERY_POOL:
+        case VK_OBJECT_TYPE_QUERY_POOL:
             return "QUERY_POOL";
-        case XGL_OBJECT_TYPE_DESCRIPTOR_POOL:
+        case VK_OBJECT_TYPE_DESCRIPTOR_POOL:
             return "DESCRIPTOR_POOL";
-        case XGL_OBJECT_TYPE_PRESENTABLE_IMAGE_MEMORY:
+        case VK_OBJECT_TYPE_PRESENTABLE_IMAGE_MEMORY:
             return "PRESENTABLE_IMAGE_MEMORY";
         default:
             return "UNKNOWN";
@@ -167,15 +167,15 @@
 
 typedef struct _OBJTRACK_NODE {
     void            *pObj;
-    XGL_OBJECT_TYPE objType;
+    VK_OBJECT_TYPE objType;
     uint64_t        numUses;
     OBJECT_STATUS   status;
 } OBJTRACK_NODE;
 
 // prototype for extension functions
-uint64_t objTrackGetObjectCount(XGL_OBJECT_TYPE type);
-XGL_RESULT objTrackGetObjects(XGL_OBJECT_TYPE type, uint64_t objCount, OBJTRACK_NODE* pObjNodeArray);
+uint64_t objTrackGetObjectCount(VK_OBJECT_TYPE type);
+VK_RESULT objTrackGetObjects(VK_OBJECT_TYPE type, uint64_t objCount, OBJTRACK_NODE* pObjNodeArray);
 
 // Func ptr typedefs
-typedef uint64_t (*OBJ_TRACK_GET_OBJECT_COUNT)(XGL_OBJECT_TYPE);
-typedef XGL_RESULT (*OBJ_TRACK_GET_OBJECTS)(XGL_OBJECT_TYPE, uint64_t, OBJTRACK_NODE*);
+typedef uint64_t (*OBJ_TRACK_GET_OBJECT_COUNT)(VK_OBJECT_TYPE);
+typedef VK_RESULT (*OBJ_TRACK_GET_OBJECTS)(VK_OBJECT_TYPE, uint64_t, OBJTRACK_NODE*);
diff --git a/layers/param_checker.cpp b/layers/param_checker.cpp
index 700dca3..fb1189e 100644
--- a/layers/param_checker.cpp
+++ b/layers/param_checker.cpp
@@ -1,5 +1,5 @@
 /*
- * XGL
+ * Vulkan
  *
  * Copyright (C) 2014 LunarG, Inc.
  *
@@ -31,20 +31,20 @@
 #include <sstream>
 
 #include "loader_platform.h"
-#include "xglLayer.h"
+#include "vkLayer.h"
 #include "layers_config.h"
-#include "xgl_enum_validate_helper.h"
-#include "xgl_struct_validate_helper.h"
+#include "vk_enum_validate_helper.h"
+#include "vk_struct_validate_helper.h"
 //The following is #included again to catch certain OS-specific functions being used:
 #include "loader_platform.h"
 
 #include "layers_msg.h"
 
-static XGL_LAYER_DISPATCH_TABLE nextTable;
-static XGL_BASE_LAYER_OBJECT *pCurObj;
+static VK_LAYER_DISPATCH_TABLE nextTable;
+static VK_BASE_LAYER_OBJECT *pCurObj;
 static LOADER_PLATFORM_THREAD_ONCE_DECLARATION(tabOnce);
 
-#include "xgl_dispatch_table_helper.h"
+#include "vk_dispatch_table_helper.h"
 static void initParamChecker(void)
 {
 
@@ -53,7 +53,7 @@
     getLayerOptionEnum("ParamCheckerReportLevel", (uint32_t *) &g_reportingLevel);
     g_actionIsDefault = getLayerOptionEnum("ParamCheckerDebugAction", (uint32_t *) &g_debugAction);
 
-    if (g_debugAction & XGL_DBG_LAYER_ACTION_LOG_MSG)
+    if (g_debugAction & VK_DBG_LAYER_ACTION_LOG_MSG)
     {
         strOpt = getLayerOption("ParamCheckerLogFilename");
         if (strOpt)
@@ -64,1547 +64,1548 @@
             g_logFile = stdout;
     }
 
-    xglGetProcAddrType fpNextGPA;
+    vkGetProcAddrType fpNextGPA;
     fpNextGPA = pCurObj->pGPA;
     assert(fpNextGPA);
 
-    layer_initialize_dispatch_table(&nextTable, fpNextGPA, (XGL_PHYSICAL_GPU) pCurObj->nextObject);
+    layer_initialize_dispatch_table(&nextTable, fpNextGPA, (VK_PHYSICAL_GPU) pCurObj->nextObject);
 }
 
-void PreCreateInstance(const XGL_APPLICATION_INFO* pAppInfo, const XGL_ALLOC_CALLBACKS* pAllocCb)
+void PreCreateInstance(const VK_APPLICATION_INFO* pAppInfo, const VK_ALLOC_CALLBACKS* pAllocCb)
 {
     if(pAppInfo == nullptr)
     {
-        char const str[] = "xglCreateInstance parameter, XGL_APPLICATION_INFO* pAppInfo, is "\
+        char const str[] = "vkCreateInstance parameter, VK_APPLICATION_INFO* pAppInfo, is "\
             "nullptr (precondition).";
-        layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
         return;
     }
 
-    if(pAppInfo->sType != XGL_STRUCTURE_TYPE_APPLICATION_INFO)
+    if(pAppInfo->sType != VK_STRUCTURE_TYPE_APPLICATION_INFO)
     {
-        char const str[] = "xglCreateInstance parameter, XGL_STRUCTURE_TYPE_APPLICATION_INFO "\
-            "pAppInfo->sType, is not XGL_STRUCTURE_TYPE_APPLICATION_INFO (precondition).";
-        layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        char const str[] = "vkCreateInstance parameter, VK_STRUCTURE_TYPE_APPLICATION_INFO "\
+            "pAppInfo->sType, is not VK_STRUCTURE_TYPE_APPLICATION_INFO (precondition).";
+        layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
         return;
     }
 
     // TODO: What else can validated in pAppInfo?
-    // TODO: XGL_API_VERSION validation.
+    // TODO: VK_API_VERSION validation.
 
     // It's okay if pAllocCb is a nullptr.
     if(pAllocCb != nullptr)
     {
-        if(!xgl_validate_xgl_alloc_callbacks(pAllocCb))
+        if(!vk_validate_vk_alloc_callbacks(pAllocCb))
         {
-            char const str[] = "xglCreateInstance parameter, XGL_ALLOC_CALLBACKS* pAllocCb, "\
+            char const str[] = "vkCreateInstance parameter, VK_ALLOC_CALLBACKS* pAllocCb, "\
                 "contains an invalid value (precondition).";
-            layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+            layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
             return;
         }
     }
 }
 
-void PostCreateInstance(XGL_RESULT result, XGL_INSTANCE* pInstance)
+void PostCreateInstance(VK_RESULT result, VK_INSTANCE* pInstance)
 {
-    if(result != XGL_SUCCESS)
+    if(result != VK_SUCCESS)
     {
-        // TODO: Spit out XGL_RESULT value.
-        char const str[] = "xglCreateInstance failed (postcondition).";
-        layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        // TODO: Spit out VK_RESULT value.
+        char const str[] = "vkCreateInstance failed (postcondition).";
+        layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
         return;
     }
 
     if(pInstance == nullptr)
     {
-        char const str[] = "xglCreateInstance parameter, XGL_INSTANCE* pInstance, is nullptr (postcondition).";
-        layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        char const str[] = "vkCreateInstance parameter, VK_INSTANCE* pInstance, is nullptr "\
+            "(postcondition).";
+        layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
         return;
     }
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateInstance(const XGL_INSTANCE_CREATE_INFO* pCreateInfo, XGL_INSTANCE* pInstance)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateInstance(const VK_INSTANCE_CREATE_INFO* pCreateInfo, VK_INSTANCE* pInstance)
 {
     PreCreateInstance(pCreateInfo->pAppInfo, pCreateInfo->pAllocCb);
-    XGL_RESULT result = nextTable.CreateInstance(pCreateInfo, pInstance);
+    VK_RESULT result = nextTable.CreateInstance(pCreateInfo, pInstance);
     PostCreateInstance(result, pInstance);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDestroyInstance(XGL_INSTANCE instance)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkDestroyInstance(VK_INSTANCE instance)
 {
 
-    XGL_RESULT result = nextTable.DestroyInstance(instance);
+    VK_RESULT result = nextTable.DestroyInstance(instance);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglEnumerateGpus(XGL_INSTANCE instance, uint32_t maxGpus, uint32_t* pGpuCount, XGL_PHYSICAL_GPU* pGpus)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkEnumerateGpus(VK_INSTANCE instance, uint32_t maxGpus, uint32_t* pGpuCount, VK_PHYSICAL_GPU* pGpus)
 {
 
-    XGL_RESULT result = nextTable.EnumerateGpus(instance, maxGpus, pGpuCount, pGpus);
+    VK_RESULT result = nextTable.EnumerateGpus(instance, maxGpus, pGpuCount, pGpus);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglGetGpuInfo(XGL_PHYSICAL_GPU gpu, XGL_PHYSICAL_GPU_INFO_TYPE infoType, size_t* pDataSize, void* pData)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkGetGpuInfo(VK_PHYSICAL_GPU gpu, VK_PHYSICAL_GPU_INFO_TYPE infoType, size_t* pDataSize, void* pData)
 {
-    XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) gpu;
+    VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
     pCurObj = gpuw;
     loader_platform_thread_once(&tabOnce, initParamChecker);
     char str[1024];
-    if (!validate_XGL_PHYSICAL_GPU_INFO_TYPE(infoType)) {
+    if (!validate_VK_PHYSICAL_GPU_INFO_TYPE(infoType)) {
         sprintf(str, "Parameter infoType to function GetGpuInfo has invalid value of %i.", (int)infoType);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
     }
-    XGL_RESULT result = nextTable.GetGpuInfo((XGL_PHYSICAL_GPU)gpuw->nextObject, infoType, pDataSize, pData);
+    VK_RESULT result = nextTable.GetGpuInfo((VK_PHYSICAL_GPU)gpuw->nextObject, infoType, pDataSize, pData);
     return result;
 }
 
-void PreCreateDevice(XGL_PHYSICAL_GPU gpu, const XGL_DEVICE_CREATE_INFO* pCreateInfo)
+void PreCreateDevice(VK_PHYSICAL_GPU gpu, const VK_DEVICE_CREATE_INFO* pCreateInfo)
 {
     if(gpu == nullptr)
     {
-        char const str[] = "xglCreateDevice parameter, XGL_PHYSICAL_GPU gpu, is nullptr "\
+        char const str[] = "vkCreateDevice parameter, VK_PHYSICAL_GPU gpu, is nullptr "\
             "(precondition).";
-        layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
         return;
     }
 
     if(pCreateInfo == nullptr)
     {
-        char const str[] = "xglCreateDevice parameter, XGL_DEVICE_CREATE_INFO* pCreateInfo, is "\
+        char const str[] = "vkCreateDevice parameter, VK_DEVICE_CREATE_INFO* pCreateInfo, is "\
             "nullptr (precondition).";
-        layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
         return;
     }
 
-    if(pCreateInfo->sType !=  XGL_STRUCTURE_TYPE_DEVICE_CREATE_INFO)
+    if(pCreateInfo->sType !=  VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO)
     {
-        char const str[] = "xglCreateDevice parameter, XGL_STRUCTURE_TYPE_DEVICE_CREATE_INFO "\
-            "pCreateInfo->sType, is not XGL_STRUCTURE_TYPE_DEVICE_CREATE_INFO (precondition).";
-        layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        char const str[] = "vkCreateDevice parameter, VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO "\
+            "pCreateInfo->sType, is not VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO (precondition).";
+        layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
         return;
     }
 
     if(pCreateInfo->queueRecordCount == 0)
     {
-        char const str[] = "xglCreateDevice parameter, uint32_t pCreateInfo->queueRecordCount, is "\
+        char const str[] = "vkCreateDevice parameter, uint32_t pCreateInfo->queueRecordCount, is "\
             "zero (precondition).";
-        layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
         return;
     }
 
     if(pCreateInfo->pRequestedQueues == nullptr)
     {
-        char const str[] = "xglCreateDevice parameter, XGL_DEVICE_QUEUE_CREATE_INFO* pCreateInfo->pRequestedQueues, is "\
+        char const str[] = "vkCreateDevice parameter, VK_DEVICE_QUEUE_CREATE_INFO* pCreateInfo->pRequestedQueues, is "\
             "nullptr (precondition).";
-        layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
         return;
     }
 
     for(uint32_t i = 0; i < pCreateInfo->queueRecordCount; ++i)
     {
-        if(!xgl_validate_xgl_device_queue_create_info(&(pCreateInfo->pRequestedQueues[i])))
+        if(!vk_validate_vk_device_queue_create_info(&(pCreateInfo->pRequestedQueues[i])))
         {
             std::stringstream ss;
-            ss << "xglCreateDevice parameter, XGL_DEVICE_QUEUE_CREATE_INFO pCreateInfo->pRequestedQueues[" << i <<
+            ss << "vkCreateDevice parameter, VK_DEVICE_QUEUE_CREATE_INFO pCreateInfo->pRequestedQueues[" << i <<
                 "], is invalid (precondition).";
-            layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", ss.str().c_str());
+            layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", ss.str().c_str());
             continue;
         }
     }
 
-    if(!validate_XGL_VALIDATION_LEVEL(pCreateInfo->maxValidationLevel))
+    if(!validate_VK_VALIDATION_LEVEL(pCreateInfo->maxValidationLevel))
     {
-        char const str[] = "xglCreateDevice parameter, XGL_VALIDATION_LEVEL pCreateInfo->maxValidationLevel, is "\
+        char const str[] = "vkCreateDevice parameter, VK_VALIDATION_LEVEL pCreateInfo->maxValidationLevel, is "\
             "unrecognized (precondition).";
-        layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
         return;
     }
 }
 
-void PostCreateDevice(XGL_RESULT result, XGL_DEVICE* pDevice)
+void PostCreateDevice(VK_RESULT result, VK_DEVICE* pDevice)
 {
-    if(result != XGL_SUCCESS)
+    if(result != VK_SUCCESS)
     {
-        // TODO: Spit out XGL_RESULT value.
-        char const str[] = "xglCreateDevice failed (postcondition).";
-        layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        // TODO: Spit out VK_RESULT value.
+        char const str[] = "vkCreateDevice failed (postcondition).";
+        layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
         return;
     }
 
     if(pDevice == nullptr)
     {
-        char const str[] = "xglCreateDevice parameter, XGL_DEVICE* pDevice, is nullptr (postcondition).";
-        layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        char const str[] = "vkCreateDevice parameter, VK_DEVICE* pDevice, is nullptr (postcondition).";
+        layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
         return;
     }
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateDevice(XGL_PHYSICAL_GPU gpu, const XGL_DEVICE_CREATE_INFO* pCreateInfo, XGL_DEVICE* pDevice)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDevice(VK_PHYSICAL_GPU gpu, const VK_DEVICE_CREATE_INFO* pCreateInfo, VK_DEVICE* pDevice)
 {
-    XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) gpu;
+    VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
     pCurObj = gpuw;
     loader_platform_thread_once(&tabOnce, initParamChecker);
     PreCreateDevice(gpu, pCreateInfo);
-    XGL_RESULT result = nextTable.CreateDevice((XGL_PHYSICAL_GPU)gpuw->nextObject, pCreateInfo, pDevice);
+    VK_RESULT result = nextTable.CreateDevice((VK_PHYSICAL_GPU)gpuw->nextObject, pCreateInfo, pDevice);
     PostCreateDevice(result, pDevice);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDestroyDevice(XGL_DEVICE device)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkDestroyDevice(VK_DEVICE device)
 {
 
-    XGL_RESULT result = nextTable.DestroyDevice(device);
+    VK_RESULT result = nextTable.DestroyDevice(device);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglGetExtensionSupport(XGL_PHYSICAL_GPU gpu, const char* pExtName)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkGetExtensionSupport(VK_PHYSICAL_GPU gpu, const char* pExtName)
 {
-    XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) gpu;
+    VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
     pCurObj = gpuw;
     loader_platform_thread_once(&tabOnce, initParamChecker);
 
-    XGL_RESULT result = nextTable.GetExtensionSupport((XGL_PHYSICAL_GPU)gpuw->nextObject, pExtName);
+    VK_RESULT result = nextTable.GetExtensionSupport((VK_PHYSICAL_GPU)gpuw->nextObject, pExtName);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglEnumerateLayers(XGL_PHYSICAL_GPU gpu, size_t maxLayerCount, size_t maxStringSize, size_t* pOutLayerCount, char* const* pOutLayers, void* pReserved)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkEnumerateLayers(VK_PHYSICAL_GPU gpu, size_t maxLayerCount, size_t maxStringSize, size_t* pOutLayerCount, char* const* pOutLayers, void* pReserved)
 {
     char str[1024];
     if (gpu != NULL) {
-        XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) gpu;
+        VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
         sprintf(str, "At start of layered EnumerateLayers\n");
-        layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, nullptr, 0, 0, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, nullptr, 0, 0, "PARAMCHECK", str);
         pCurObj = gpuw;
         loader_platform_thread_once(&tabOnce, initParamChecker);
-        XGL_RESULT result = nextTable.EnumerateLayers((XGL_PHYSICAL_GPU)gpuw->nextObject, maxLayerCount, maxStringSize, pOutLayerCount, pOutLayers, pReserved);
+        VK_RESULT result = nextTable.EnumerateLayers((VK_PHYSICAL_GPU)gpuw->nextObject, maxLayerCount, maxStringSize, pOutLayerCount, pOutLayers, pReserved);
         sprintf(str, "Completed layered EnumerateLayers\n");
-        layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, nullptr, 0, 0, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, nullptr, 0, 0, "PARAMCHECK", str);
         fflush(stdout);
         return result;
     } else {
         if (pOutLayerCount == NULL || pOutLayers == NULL || pOutLayers[0] == NULL)
-            return XGL_ERROR_INVALID_POINTER;
+            return VK_ERROR_INVALID_POINTER;
         // This layer compatible with all GPUs
         *pOutLayerCount = 1;
         strncpy(pOutLayers[0], "ParamChecker", maxStringSize);
-        return XGL_SUCCESS;
+        return VK_SUCCESS;
     }
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglGetDeviceQueue(XGL_DEVICE device, uint32_t queueNodeIndex, uint32_t queueIndex, XGL_QUEUE* pQueue)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkGetDeviceQueue(VK_DEVICE device, uint32_t queueNodeIndex, uint32_t queueIndex, VK_QUEUE* pQueue)
 {
 
-    XGL_RESULT result = nextTable.GetDeviceQueue(device, queueNodeIndex, queueIndex, pQueue);
+    VK_RESULT result = nextTable.GetDeviceQueue(device, queueNodeIndex, queueIndex, pQueue);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglQueueSubmit(XGL_QUEUE queue, uint32_t cmdBufferCount, const XGL_CMD_BUFFER* pCmdBuffers, XGL_FENCE fence)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkQueueSubmit(VK_QUEUE queue, uint32_t cmdBufferCount, const VK_CMD_BUFFER* pCmdBuffers, VK_FENCE fence)
 {
-    XGL_RESULT result = nextTable.QueueSubmit(queue, cmdBufferCount, pCmdBuffers, fence);
+    VK_RESULT result = nextTable.QueueSubmit(queue, cmdBufferCount, pCmdBuffers, fence);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglQueueAddMemReference(XGL_QUEUE queue, XGL_GPU_MEMORY mem)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkQueueAddMemReference(VK_QUEUE queue, VK_GPU_MEMORY mem)
 {
-    XGL_RESULT result = nextTable.QueueAddMemReference(queue, mem);
+    VK_RESULT result = nextTable.QueueAddMemReference(queue, mem);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglQueueRemoveMemReference(XGL_QUEUE queue, XGL_GPU_MEMORY mem)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkQueueRemoveMemReference(VK_QUEUE queue, VK_GPU_MEMORY mem)
 {
-    XGL_RESULT result = nextTable.QueueRemoveMemReference(queue, mem);
+    VK_RESULT result = nextTable.QueueRemoveMemReference(queue, mem);
     return result;
 }
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglQueueWaitIdle(XGL_QUEUE queue)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkQueueWaitIdle(VK_QUEUE queue)
 {
 
-    XGL_RESULT result = nextTable.QueueWaitIdle(queue);
+    VK_RESULT result = nextTable.QueueWaitIdle(queue);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDeviceWaitIdle(XGL_DEVICE device)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkDeviceWaitIdle(VK_DEVICE device)
 {
 
-    XGL_RESULT result = nextTable.DeviceWaitIdle(device);
+    VK_RESULT result = nextTable.DeviceWaitIdle(device);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglAllocMemory(XGL_DEVICE device, const XGL_MEMORY_ALLOC_INFO* pAllocInfo, XGL_GPU_MEMORY* pMem)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkAllocMemory(VK_DEVICE device, const VK_MEMORY_ALLOC_INFO* pAllocInfo, VK_GPU_MEMORY* pMem)
 {
     char str[1024];
     if (!pAllocInfo) {
         sprintf(str, "Struct ptr parameter pAllocInfo to function AllocMemory is NULL.");
-        layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
     }
-    else if (!xgl_validate_xgl_memory_alloc_info(pAllocInfo)) {
+    else if (!vk_validate_vk_memory_alloc_info(pAllocInfo)) {
         sprintf(str, "Parameter pAllocInfo to function AllocMemory contains an invalid value.");
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
     }
-    XGL_RESULT result = nextTable.AllocMemory(device, pAllocInfo, pMem);
+    VK_RESULT result = nextTable.AllocMemory(device, pAllocInfo, pMem);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglFreeMemory(XGL_GPU_MEMORY mem)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkFreeMemory(VK_GPU_MEMORY mem)
 {
 
-    XGL_RESULT result = nextTable.FreeMemory(mem);
+    VK_RESULT result = nextTable.FreeMemory(mem);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglSetMemoryPriority(XGL_GPU_MEMORY mem, XGL_MEMORY_PRIORITY priority)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkSetMemoryPriority(VK_GPU_MEMORY mem, VK_MEMORY_PRIORITY priority)
 {
     char str[1024];
-    if (!validate_XGL_MEMORY_PRIORITY(priority)) {
+    if (!validate_VK_MEMORY_PRIORITY(priority)) {
         sprintf(str, "Parameter priority to function SetMemoryPriority has invalid value of %i.", (int)priority);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
     }
-    XGL_RESULT result = nextTable.SetMemoryPriority(mem, priority);
+    VK_RESULT result = nextTable.SetMemoryPriority(mem, priority);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglMapMemory(XGL_GPU_MEMORY mem, XGL_FLAGS flags, void** ppData)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkMapMemory(VK_GPU_MEMORY mem, VK_FLAGS flags, void** ppData)
 {
 
-    XGL_RESULT result = nextTable.MapMemory(mem, flags, ppData);
+    VK_RESULT result = nextTable.MapMemory(mem, flags, ppData);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglUnmapMemory(XGL_GPU_MEMORY mem)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkUnmapMemory(VK_GPU_MEMORY mem)
 {
 
-    XGL_RESULT result = nextTable.UnmapMemory(mem);
+    VK_RESULT result = nextTable.UnmapMemory(mem);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglPinSystemMemory(XGL_DEVICE device, const void* pSysMem, size_t memSize, XGL_GPU_MEMORY* pMem)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkPinSystemMemory(VK_DEVICE device, const void* pSysMem, size_t memSize, VK_GPU_MEMORY* pMem)
 {
 
-    XGL_RESULT result = nextTable.PinSystemMemory(device, pSysMem, memSize, pMem);
+    VK_RESULT result = nextTable.PinSystemMemory(device, pSysMem, memSize, pMem);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglGetMultiGpuCompatibility(XGL_PHYSICAL_GPU gpu0, XGL_PHYSICAL_GPU gpu1, XGL_GPU_COMPATIBILITY_INFO* pInfo)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkGetMultiGpuCompatibility(VK_PHYSICAL_GPU gpu0, VK_PHYSICAL_GPU gpu1, VK_GPU_COMPATIBILITY_INFO* pInfo)
 {
-    XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) gpu0;
+    VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu0;
     pCurObj = gpuw;
     loader_platform_thread_once(&tabOnce, initParamChecker);
 
-    XGL_RESULT result = nextTable.GetMultiGpuCompatibility((XGL_PHYSICAL_GPU)gpuw->nextObject, gpu1, pInfo);
+    VK_RESULT result = nextTable.GetMultiGpuCompatibility((VK_PHYSICAL_GPU)gpuw->nextObject, gpu1, pInfo);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglOpenSharedMemory(XGL_DEVICE device, const XGL_MEMORY_OPEN_INFO* pOpenInfo, XGL_GPU_MEMORY* pMem)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkOpenSharedMemory(VK_DEVICE device, const VK_MEMORY_OPEN_INFO* pOpenInfo, VK_GPU_MEMORY* pMem)
 {
     char str[1024];
     if (!pOpenInfo) {
         sprintf(str, "Struct ptr parameter pOpenInfo to function OpenSharedMemory is NULL.");
-        layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
     }
-    else if (!xgl_validate_xgl_memory_open_info(pOpenInfo)) {
+    else if (!vk_validate_vk_memory_open_info(pOpenInfo)) {
         sprintf(str, "Parameter pOpenInfo to function OpenSharedMemory contains an invalid value.");
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
     }
-    XGL_RESULT result = nextTable.OpenSharedMemory(device, pOpenInfo, pMem);
+    VK_RESULT result = nextTable.OpenSharedMemory(device, pOpenInfo, pMem);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglOpenSharedSemaphore(XGL_DEVICE device, const XGL_SEMAPHORE_OPEN_INFO* pOpenInfo, XGL_SEMAPHORE* pSemaphore)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkOpenSharedSemaphore(VK_DEVICE device, const VK_SEMAPHORE_OPEN_INFO* pOpenInfo, VK_SEMAPHORE* pSemaphore)
 {
     char str[1024];
     if (!pOpenInfo) {
         sprintf(str, "Struct ptr parameter pOpenInfo to function OpenSharedSemaphore is NULL.");
-        layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
     }
-    else if (!xgl_validate_xgl_semaphore_open_info(pOpenInfo)) {
+    else if (!vk_validate_vk_semaphore_open_info(pOpenInfo)) {
         sprintf(str, "Parameter pOpenInfo to function OpenSharedSemaphore contains an invalid value.");
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
     }
-    XGL_RESULT result = nextTable.OpenSharedSemaphore(device, pOpenInfo, pSemaphore);
+    VK_RESULT result = nextTable.OpenSharedSemaphore(device, pOpenInfo, pSemaphore);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglOpenPeerMemory(XGL_DEVICE device, const XGL_PEER_MEMORY_OPEN_INFO* pOpenInfo, XGL_GPU_MEMORY* pMem)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkOpenPeerMemory(VK_DEVICE device, const VK_PEER_MEMORY_OPEN_INFO* pOpenInfo, VK_GPU_MEMORY* pMem)
 {
     char str[1024];
     if (!pOpenInfo) {
         sprintf(str, "Struct ptr parameter pOpenInfo to function OpenPeerMemory is NULL.");
-        layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
     }
-    else if (!xgl_validate_xgl_peer_memory_open_info(pOpenInfo)) {
+    else if (!vk_validate_vk_peer_memory_open_info(pOpenInfo)) {
         sprintf(str, "Parameter pOpenInfo to function OpenPeerMemory contains an invalid value.");
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
     }
-    XGL_RESULT result = nextTable.OpenPeerMemory(device, pOpenInfo, pMem);
+    VK_RESULT result = nextTable.OpenPeerMemory(device, pOpenInfo, pMem);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglOpenPeerImage(XGL_DEVICE device, const XGL_PEER_IMAGE_OPEN_INFO* pOpenInfo, XGL_IMAGE* pImage, XGL_GPU_MEMORY* pMem)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkOpenPeerImage(VK_DEVICE device, const VK_PEER_IMAGE_OPEN_INFO* pOpenInfo, VK_IMAGE* pImage, VK_GPU_MEMORY* pMem)
 {
     char str[1024];
     if (!pOpenInfo) {
         sprintf(str, "Struct ptr parameter pOpenInfo to function OpenPeerImage is NULL.");
-        layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
     }
-    else if (!xgl_validate_xgl_peer_image_open_info(pOpenInfo)) {
+    else if (!vk_validate_vk_peer_image_open_info(pOpenInfo)) {
         sprintf(str, "Parameter pOpenInfo to function OpenPeerImage contains an invalid value.");
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
     }
-    XGL_RESULT result = nextTable.OpenPeerImage(device, pOpenInfo, pImage, pMem);
+    VK_RESULT result = nextTable.OpenPeerImage(device, pOpenInfo, pImage, pMem);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDestroyObject(XGL_OBJECT object)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkDestroyObject(VK_OBJECT object)
 {
 
-    XGL_RESULT result = nextTable.DestroyObject(object);
+    VK_RESULT result = nextTable.DestroyObject(object);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglGetObjectInfo(XGL_BASE_OBJECT object, XGL_OBJECT_INFO_TYPE infoType, size_t* pDataSize, void* pData)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkGetObjectInfo(VK_BASE_OBJECT object, VK_OBJECT_INFO_TYPE infoType, size_t* pDataSize, void* pData)
 {
     char str[1024];
-    if (!validate_XGL_OBJECT_INFO_TYPE(infoType)) {
+    if (!validate_VK_OBJECT_INFO_TYPE(infoType)) {
         sprintf(str, "Parameter infoType to function GetObjectInfo has invalid value of %i.", (int)infoType);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
     }
-    XGL_RESULT result = nextTable.GetObjectInfo(object, infoType, pDataSize, pData);
+    VK_RESULT result = nextTable.GetObjectInfo(object, infoType, pDataSize, pData);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglBindObjectMemory(XGL_OBJECT object, uint32_t allocationIdx, XGL_GPU_MEMORY mem, XGL_GPU_SIZE offset)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkBindObjectMemory(VK_OBJECT object, uint32_t allocationIdx, VK_GPU_MEMORY mem, VK_GPU_SIZE offset)
 {
 
-    XGL_RESULT result = nextTable.BindObjectMemory(object, allocationIdx, mem, offset);
+    VK_RESULT result = nextTable.BindObjectMemory(object, allocationIdx, mem, offset);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglBindObjectMemoryRange(XGL_OBJECT object, uint32_t allocationIdx, XGL_GPU_SIZE rangeOffset, XGL_GPU_SIZE rangeSize, XGL_GPU_MEMORY mem, XGL_GPU_SIZE memOffset)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkBindObjectMemoryRange(VK_OBJECT object, uint32_t allocationIdx, VK_GPU_SIZE rangeOffset, VK_GPU_SIZE rangeSize, VK_GPU_MEMORY mem, VK_GPU_SIZE memOffset)
 {
 
-    XGL_RESULT result = nextTable.BindObjectMemoryRange(object, allocationIdx, rangeOffset, rangeSize, mem, memOffset);
+    VK_RESULT result = nextTable.BindObjectMemoryRange(object, allocationIdx, rangeOffset, rangeSize, mem, memOffset);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglBindImageMemoryRange(XGL_IMAGE image, uint32_t allocationIdx, const XGL_IMAGE_MEMORY_BIND_INFO* bindInfo, XGL_GPU_MEMORY mem, XGL_GPU_SIZE memOffset)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkBindImageMemoryRange(VK_IMAGE image, uint32_t allocationIdx, const VK_IMAGE_MEMORY_BIND_INFO* bindInfo, VK_GPU_MEMORY mem, VK_GPU_SIZE memOffset)
 {
     char str[1024];
     if (!bindInfo) {
         sprintf(str, "Struct ptr parameter bindInfo to function BindImageMemoryRange is NULL.");
-        layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
     }
-    else if (!xgl_validate_xgl_image_memory_bind_info(bindInfo)) {
+    else if (!vk_validate_vk_image_memory_bind_info(bindInfo)) {
         sprintf(str, "Parameter bindInfo to function BindImageMemoryRange contains an invalid value.");
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
     }
-    XGL_RESULT result = nextTable.BindImageMemoryRange(image, allocationIdx, bindInfo, mem, memOffset);
+    VK_RESULT result = nextTable.BindImageMemoryRange(image, allocationIdx, bindInfo, mem, memOffset);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateFence(XGL_DEVICE device, const XGL_FENCE_CREATE_INFO* pCreateInfo, XGL_FENCE* pFence)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateFence(VK_DEVICE device, const VK_FENCE_CREATE_INFO* pCreateInfo, VK_FENCE* pFence)
 {
     char str[1024];
     if (!pCreateInfo) {
         sprintf(str, "Struct ptr parameter pCreateInfo to function CreateFence is NULL.");
-        layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
     }
-    else if (!xgl_validate_xgl_fence_create_info(pCreateInfo)) {
+    else if (!vk_validate_vk_fence_create_info(pCreateInfo)) {
         sprintf(str, "Parameter pCreateInfo to function CreateFence contains an invalid value.");
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
     }
-    XGL_RESULT result = nextTable.CreateFence(device, pCreateInfo, pFence);
+    VK_RESULT result = nextTable.CreateFence(device, pCreateInfo, pFence);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglGetFenceStatus(XGL_FENCE fence)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkGetFenceStatus(VK_FENCE fence)
 {
 
-    XGL_RESULT result = nextTable.GetFenceStatus(fence);
+    VK_RESULT result = nextTable.GetFenceStatus(fence);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglWaitForFences(XGL_DEVICE device, uint32_t fenceCount, const XGL_FENCE* pFences, bool32_t waitAll, uint64_t timeout)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkWaitForFences(VK_DEVICE device, uint32_t fenceCount, const VK_FENCE* pFences, bool32_t waitAll, uint64_t timeout)
 {
 
-    XGL_RESULT result = nextTable.WaitForFences(device, fenceCount, pFences, waitAll, timeout);
+    VK_RESULT result = nextTable.WaitForFences(device, fenceCount, pFences, waitAll, timeout);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglResetFences(XGL_DEVICE device, uint32_t fenceCount, XGL_FENCE* pFences)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkResetFences(VK_DEVICE device, uint32_t fenceCount, VK_FENCE* pFences)
 {
 
-    XGL_RESULT result = nextTable.ResetFences(device, fenceCount, pFences);
+    VK_RESULT result = nextTable.ResetFences(device, fenceCount, pFences);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateSemaphore(XGL_DEVICE device, const XGL_SEMAPHORE_CREATE_INFO* pCreateInfo, XGL_SEMAPHORE* pSemaphore)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateSemaphore(VK_DEVICE device, const VK_SEMAPHORE_CREATE_INFO* pCreateInfo, VK_SEMAPHORE* pSemaphore)
 {
     char str[1024];
     if (!pCreateInfo) {
         sprintf(str, "Struct ptr parameter pCreateInfo to function CreateSemaphore is NULL.");
-        layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
     }
-    else if (!xgl_validate_xgl_semaphore_create_info(pCreateInfo)) {
+    else if (!vk_validate_vk_semaphore_create_info(pCreateInfo)) {
         sprintf(str, "Parameter pCreateInfo to function CreateSemaphore contains an invalid value.");
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
     }
-    XGL_RESULT result = nextTable.CreateSemaphore(device, pCreateInfo, pSemaphore);
+    VK_RESULT result = nextTable.CreateSemaphore(device, pCreateInfo, pSemaphore);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglQueueSignalSemaphore(XGL_QUEUE queue, XGL_SEMAPHORE semaphore)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkQueueSignalSemaphore(VK_QUEUE queue, VK_SEMAPHORE semaphore)
 {
 
-    XGL_RESULT result = nextTable.QueueSignalSemaphore(queue, semaphore);
+    VK_RESULT result = nextTable.QueueSignalSemaphore(queue, semaphore);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglQueueWaitSemaphore(XGL_QUEUE queue, XGL_SEMAPHORE semaphore)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkQueueWaitSemaphore(VK_QUEUE queue, VK_SEMAPHORE semaphore)
 {
 
-    XGL_RESULT result = nextTable.QueueWaitSemaphore(queue, semaphore);
+    VK_RESULT result = nextTable.QueueWaitSemaphore(queue, semaphore);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateEvent(XGL_DEVICE device, const XGL_EVENT_CREATE_INFO* pCreateInfo, XGL_EVENT* pEvent)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateEvent(VK_DEVICE device, const VK_EVENT_CREATE_INFO* pCreateInfo, VK_EVENT* pEvent)
 {
     char str[1024];
     if (!pCreateInfo) {
         sprintf(str, "Struct ptr parameter pCreateInfo to function CreateEvent is NULL.");
-        layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
     }
-    else if (!xgl_validate_xgl_event_create_info(pCreateInfo)) {
+    else if (!vk_validate_vk_event_create_info(pCreateInfo)) {
         sprintf(str, "Parameter pCreateInfo to function CreateEvent contains an invalid value.");
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
     }
-    XGL_RESULT result = nextTable.CreateEvent(device, pCreateInfo, pEvent);
+    VK_RESULT result = nextTable.CreateEvent(device, pCreateInfo, pEvent);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglGetEventStatus(XGL_EVENT event)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkGetEventStatus(VK_EVENT event)
 {
 
-    XGL_RESULT result = nextTable.GetEventStatus(event);
+    VK_RESULT result = nextTable.GetEventStatus(event);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglSetEvent(XGL_EVENT event)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkSetEvent(VK_EVENT event)
 {
 
-    XGL_RESULT result = nextTable.SetEvent(event);
+    VK_RESULT result = nextTable.SetEvent(event);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglResetEvent(XGL_EVENT event)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkResetEvent(VK_EVENT event)
 {
 
-    XGL_RESULT result = nextTable.ResetEvent(event);
+    VK_RESULT result = nextTable.ResetEvent(event);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateQueryPool(XGL_DEVICE device, const XGL_QUERY_POOL_CREATE_INFO* pCreateInfo, XGL_QUERY_POOL* pQueryPool)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateQueryPool(VK_DEVICE device, const VK_QUERY_POOL_CREATE_INFO* pCreateInfo, VK_QUERY_POOL* pQueryPool)
 {
     char str[1024];
     if (!pCreateInfo) {
         sprintf(str, "Struct ptr parameter pCreateInfo to function CreateQueryPool is NULL.");
-        layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
     }
-    else if (!xgl_validate_xgl_query_pool_create_info(pCreateInfo)) {
+    else if (!vk_validate_vk_query_pool_create_info(pCreateInfo)) {
         sprintf(str, "Parameter pCreateInfo to function CreateQueryPool contains an invalid value.");
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
     }
-    XGL_RESULT result = nextTable.CreateQueryPool(device, pCreateInfo, pQueryPool);
+    VK_RESULT result = nextTable.CreateQueryPool(device, pCreateInfo, pQueryPool);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglGetQueryPoolResults(XGL_QUERY_POOL queryPool, uint32_t startQuery, uint32_t queryCount, size_t* pDataSize, void* pData)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkGetQueryPoolResults(VK_QUERY_POOL queryPool, uint32_t startQuery, uint32_t queryCount, size_t* pDataSize, void* pData)
 {
 
-    XGL_RESULT result = nextTable.GetQueryPoolResults(queryPool, startQuery, queryCount, pDataSize, pData);
+    VK_RESULT result = nextTable.GetQueryPoolResults(queryPool, startQuery, queryCount, pDataSize, pData);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglGetFormatInfo(XGL_DEVICE device, XGL_FORMAT format, XGL_FORMAT_INFO_TYPE infoType, size_t* pDataSize, void* pData)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkGetFormatInfo(VK_DEVICE device, VK_FORMAT format, VK_FORMAT_INFO_TYPE infoType, size_t* pDataSize, void* pData)
 {
     char str[1024];
-    if (!validate_XGL_FORMAT(format)) {
+    if (!validate_VK_FORMAT(format)) {
         sprintf(str, "Parameter format to function GetFormatInfo has invalid value of %i.", (int)format);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
     }
-    if (!validate_XGL_FORMAT_INFO_TYPE(infoType)) {
+    if (!validate_VK_FORMAT_INFO_TYPE(infoType)) {
         sprintf(str, "Parameter infoType to function GetFormatInfo has invalid value of %i.", (int)infoType);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
     }
-    XGL_RESULT result = nextTable.GetFormatInfo(device, format, infoType, pDataSize, pData);
+    VK_RESULT result = nextTable.GetFormatInfo(device, format, infoType, pDataSize, pData);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateBuffer(XGL_DEVICE device, const XGL_BUFFER_CREATE_INFO* pCreateInfo, XGL_BUFFER* pBuffer)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateBuffer(VK_DEVICE device, const VK_BUFFER_CREATE_INFO* pCreateInfo, VK_BUFFER* pBuffer)
 {
     char str[1024];
     if (!pCreateInfo) {
         sprintf(str, "Struct ptr parameter pCreateInfo to function CreateBuffer is NULL.");
-        layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
     }
-    else if (!xgl_validate_xgl_buffer_create_info(pCreateInfo)) {
+    else if (!vk_validate_vk_buffer_create_info(pCreateInfo)) {
         sprintf(str, "Parameter pCreateInfo to function CreateBuffer contains an invalid value.");
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
     }
-    XGL_RESULT result = nextTable.CreateBuffer(device, pCreateInfo, pBuffer);
+    VK_RESULT result = nextTable.CreateBuffer(device, pCreateInfo, pBuffer);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateBufferView(XGL_DEVICE device, const XGL_BUFFER_VIEW_CREATE_INFO* pCreateInfo, XGL_BUFFER_VIEW* pView)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateBufferView(VK_DEVICE device, const VK_BUFFER_VIEW_CREATE_INFO* pCreateInfo, VK_BUFFER_VIEW* pView)
 {
     char str[1024];
     if (!pCreateInfo) {
         sprintf(str, "Struct ptr parameter pCreateInfo to function CreateBufferView is NULL.");
-        layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
     }
-    else if (!xgl_validate_xgl_buffer_view_create_info(pCreateInfo)) {
+    else if (!vk_validate_vk_buffer_view_create_info(pCreateInfo)) {
         sprintf(str, "Parameter pCreateInfo to function CreateBufferView contains an invalid value.");
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
     }
-    XGL_RESULT result = nextTable.CreateBufferView(device, pCreateInfo, pView);
+    VK_RESULT result = nextTable.CreateBufferView(device, pCreateInfo, pView);
     return result;
 }
 
-void PreCreateImage(XGL_DEVICE device, const XGL_IMAGE_CREATE_INFO* pCreateInfo)
+void PreCreateImage(VK_DEVICE device, const VK_IMAGE_CREATE_INFO* pCreateInfo)
 {
     if(pCreateInfo == nullptr)
     {
-        char const str[] = "xglCreateImage parameter, XGL_IMAGE_CREATE_INFO* pCreateInfo, is "\
+        char const str[] = "vkCreateImage parameter, VK_IMAGE_CREATE_INFO* pCreateInfo, is "\
             "nullptr (precondition).";
-        layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
         return;
     }
 
-    if(pCreateInfo->sType != XGL_STRUCTURE_TYPE_IMAGE_CREATE_INFO)
+    if(pCreateInfo->sType != VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO)
     {
-        char const str[] = "xglCreateImage parameter, XGL_STRUCTURE_TYPE_IMAGE_CREATE_INFO "\
-            "pCreateInfo->sType, is not XGL_STRUCTURE_TYPE_IMAGE_CREATE_INFO (precondition).";
-        layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        char const str[] = "vkCreateImage parameter, VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO "\
+            "pCreateInfo->sType, is not VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO (precondition).";
+        layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
         return;
     }
 
-    if (!validate_XGL_IMAGE_TYPE(pCreateInfo->imageType))
+    if (!validate_VK_IMAGE_TYPE(pCreateInfo->imageType))
     {
-        char const str[] = "xglCreateImage parameter, XGL_IMAGE_TYPE pCreateInfo->imageType, is "\
+        char const str[] = "vkCreateImage parameter, VK_IMAGE_TYPE pCreateInfo->imageType, is "\
             "unrecognized (precondition).";
-        layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
         return;
     }
 
-    if (!validate_XGL_FORMAT(pCreateInfo->format))
+    if (!validate_VK_FORMAT(pCreateInfo->format))
     {
-        char const str[] = "xglCreateImage parameter, XGL_FORMAT pCreateInfo->format, is "\
+        char const str[] = "vkCreateImage parameter, VK_FORMAT pCreateInfo->format, is "\
             "unrecognized (precondition).";
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
         return;
     }
 
-    XGL_FORMAT_PROPERTIES properties;
+    VK_FORMAT_PROPERTIES properties;
     size_t size = sizeof(properties);
-    XGL_RESULT result = nextTable.GetFormatInfo(device, pCreateInfo->format,
-        XGL_INFO_TYPE_FORMAT_PROPERTIES, &size, &properties);
-    if(result != XGL_SUCCESS)
+    VK_RESULT result = nextTable.GetFormatInfo(device, pCreateInfo->format,
+        VK_INFO_TYPE_FORMAT_PROPERTIES, &size, &properties);
+    if(result != VK_SUCCESS)
     {
-        char const str[] = "xglCreateImage parameter, XGL_FORMAT pCreateInfo->format, cannot be "\
+        char const str[] = "vkCreateImage parameter, VK_FORMAT pCreateInfo->format, cannot be "\
             "validated (precondition).";
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
         return;
     }
 
     if((properties.linearTilingFeatures) == 0 && (properties.optimalTilingFeatures == 0))
     {
-        char const str[] = "xglCreateImage parameter, XGL_FORMAT pCreateInfo->format, contains "\
+        char const str[] = "vkCreateImage parameter, VK_FORMAT pCreateInfo->format, contains "\
             "unsupported format (precondition).";
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
         return;
     }
 
     // TODO: Can we check device-specific limits?
-    if (!xgl_validate_xgl_extent3d(&pCreateInfo->extent))
+    if (!vk_validate_vk_extent3d(&pCreateInfo->extent))
     {
-        char const str[] = "xglCreateImage parameter, XGL_EXTENT3D pCreateInfo->extent, is invalid "\
+        char const str[] = "vkCreateImage parameter, VK_EXTENT3D pCreateInfo->extent, is invalid "\
             "(precondition).";
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
         return;
     }
 
-    if (!validate_XGL_IMAGE_TILING(pCreateInfo->tiling))
+    if (!validate_VK_IMAGE_TILING(pCreateInfo->tiling))
     {
-        char const str[] = "xglCreateImage parameter, XGL_IMAGE_TILING pCreateInfo->tiling, is "\
+        char const str[] = "vkCreateImage parameter, VK_IMAGE_TILING pCreateInfo->tiling, is "\
             "unrecoginized (precondition).";
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
         return;
     }
 }
 
-void PostCreateImage(XGL_RESULT result, XGL_IMAGE* pImage)
+void PostCreateImage(VK_RESULT result, VK_IMAGE* pImage)
 {
-    if(result != XGL_SUCCESS)
+    if(result != VK_SUCCESS)
     {
-        // TODO: Spit out XGL_RESULT value.
-        char const str[] = "xglCreateImage failed (postcondition).";
-        layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        // TODO: Spit out VK_RESULT value.
+        char const str[] = "vkCreateImage failed (postcondition).";
+        layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
         return;
     }
 
     if(pImage == nullptr)
     {
-        char const str[] = "xglCreateImage parameter, XGL_IMAGE* pImage, is nullptr (postcondition).";
-        layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        char const str[] = "vkCreateImage parameter, VK_IMAGE* pImage, is nullptr (postcondition).";
+        layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
         return;
     }
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateImage(XGL_DEVICE device, const XGL_IMAGE_CREATE_INFO* pCreateInfo, XGL_IMAGE* pImage)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateImage(VK_DEVICE device, const VK_IMAGE_CREATE_INFO* pCreateInfo, VK_IMAGE* pImage)
 {
     PreCreateImage(device, pCreateInfo);
-    XGL_RESULT result = nextTable.CreateImage(device, pCreateInfo, pImage);
+    VK_RESULT result = nextTable.CreateImage(device, pCreateInfo, pImage);
     PostCreateImage(result, pImage);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglGetImageSubresourceInfo(XGL_IMAGE image, const XGL_IMAGE_SUBRESOURCE* pSubresource, XGL_SUBRESOURCE_INFO_TYPE infoType, size_t* pDataSize, void* pData)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkGetImageSubresourceInfo(VK_IMAGE image, const VK_IMAGE_SUBRESOURCE* pSubresource, VK_SUBRESOURCE_INFO_TYPE infoType, size_t* pDataSize, void* pData)
 {
     char str[1024];
     if (!pSubresource) {
         sprintf(str, "Struct ptr parameter pSubresource to function GetImageSubresourceInfo is NULL.");
-        layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
     }
-    else if (!xgl_validate_xgl_image_subresource(pSubresource)) {
+    else if (!vk_validate_vk_image_subresource(pSubresource)) {
         sprintf(str, "Parameter pSubresource to function GetImageSubresourceInfo contains an invalid value.");
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
     }
-    if (!validate_XGL_SUBRESOURCE_INFO_TYPE(infoType)) {
+    if (!validate_VK_SUBRESOURCE_INFO_TYPE(infoType)) {
         sprintf(str, "Parameter infoType to function GetImageSubresourceInfo has invalid value of %i.", (int)infoType);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
     }
-    XGL_RESULT result = nextTable.GetImageSubresourceInfo(image, pSubresource, infoType, pDataSize, pData);
+    VK_RESULT result = nextTable.GetImageSubresourceInfo(image, pSubresource, infoType, pDataSize, pData);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateImageView(XGL_DEVICE device, const XGL_IMAGE_VIEW_CREATE_INFO* pCreateInfo, XGL_IMAGE_VIEW* pView)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateImageView(VK_DEVICE device, const VK_IMAGE_VIEW_CREATE_INFO* pCreateInfo, VK_IMAGE_VIEW* pView)
 {
     char str[1024];
     if (!pCreateInfo) {
         sprintf(str, "Struct ptr parameter pCreateInfo to function CreateImageView is NULL.");
-        layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
     }
-    else if (!xgl_validate_xgl_image_view_create_info(pCreateInfo)) {
+    else if (!vk_validate_vk_image_view_create_info(pCreateInfo)) {
         sprintf(str, "Parameter pCreateInfo to function CreateImageView contains an invalid value.");
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
     }
-    XGL_RESULT result = nextTable.CreateImageView(device, pCreateInfo, pView);
+    VK_RESULT result = nextTable.CreateImageView(device, pCreateInfo, pView);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateColorAttachmentView(XGL_DEVICE device, const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pCreateInfo, XGL_COLOR_ATTACHMENT_VIEW* pView)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateColorAttachmentView(VK_DEVICE device, const VK_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pCreateInfo, VK_COLOR_ATTACHMENT_VIEW* pView)
 {
     char str[1024];
     if (!pCreateInfo) {
         sprintf(str, "Struct ptr parameter pCreateInfo to function CreateColorAttachmentView is NULL.");
-        layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
     }
-    else if (!xgl_validate_xgl_color_attachment_view_create_info(pCreateInfo)) {
+    else if (!vk_validate_vk_color_attachment_view_create_info(pCreateInfo)) {
         sprintf(str, "Parameter pCreateInfo to function CreateColorAttachmentView contains an invalid value.");
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
     }
-    XGL_RESULT result = nextTable.CreateColorAttachmentView(device, pCreateInfo, pView);
+    VK_RESULT result = nextTable.CreateColorAttachmentView(device, pCreateInfo, pView);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateDepthStencilView(XGL_DEVICE device, const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pCreateInfo, XGL_DEPTH_STENCIL_VIEW* pView)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDepthStencilView(VK_DEVICE device, const VK_DEPTH_STENCIL_VIEW_CREATE_INFO* pCreateInfo, VK_DEPTH_STENCIL_VIEW* pView)
 {
     char str[1024];
     if (!pCreateInfo) {
         sprintf(str, "Struct ptr parameter pCreateInfo to function CreateDepthStencilView is NULL.");
-        layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
     }
-    else if (!xgl_validate_xgl_depth_stencil_view_create_info(pCreateInfo)) {
+    else if (!vk_validate_vk_depth_stencil_view_create_info(pCreateInfo)) {
         sprintf(str, "Parameter pCreateInfo to function CreateDepthStencilView contains an invalid value.");
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
     }
-    XGL_RESULT result = nextTable.CreateDepthStencilView(device, pCreateInfo, pView);
+    VK_RESULT result = nextTable.CreateDepthStencilView(device, pCreateInfo, pView);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateShader(XGL_DEVICE device, const XGL_SHADER_CREATE_INFO* pCreateInfo, XGL_SHADER* pShader)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateShader(VK_DEVICE device, const VK_SHADER_CREATE_INFO* pCreateInfo, VK_SHADER* pShader)
 {
     char str[1024];
     if (!pCreateInfo) {
         sprintf(str, "Struct ptr parameter pCreateInfo to function CreateShader is NULL.");
-        layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
     }
-    else if (!xgl_validate_xgl_shader_create_info(pCreateInfo)) {
+    else if (!vk_validate_vk_shader_create_info(pCreateInfo)) {
         sprintf(str, "Parameter pCreateInfo to function CreateShader contains an invalid value.");
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
     }
-    XGL_RESULT result = nextTable.CreateShader(device, pCreateInfo, pShader);
+    VK_RESULT result = nextTable.CreateShader(device, pCreateInfo, pShader);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateGraphicsPipeline(XGL_DEVICE device, const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo, XGL_PIPELINE* pPipeline)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateGraphicsPipeline(VK_DEVICE device, const VK_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo, VK_PIPELINE* pPipeline)
 {
     char str[1024];
     if (!pCreateInfo) {
         sprintf(str, "Struct ptr parameter pCreateInfo to function CreateGraphicsPipeline is NULL.");
-        layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
     }
-    else if (!xgl_validate_xgl_graphics_pipeline_create_info(pCreateInfo)) {
+    else if (!vk_validate_vk_graphics_pipeline_create_info(pCreateInfo)) {
         sprintf(str, "Parameter pCreateInfo to function CreateGraphicsPipeline contains an invalid value.");
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
     }
-    XGL_RESULT result = nextTable.CreateGraphicsPipeline(device, pCreateInfo, pPipeline);
+    VK_RESULT result = nextTable.CreateGraphicsPipeline(device, pCreateInfo, pPipeline);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateGraphicsPipelineDerivative(XGL_DEVICE device, const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo, XGL_PIPELINE basePipeline, XGL_PIPELINE* pPipeline)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateGraphicsPipelineDerivative(VK_DEVICE device, const VK_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo, VK_PIPELINE basePipeline, VK_PIPELINE* pPipeline)
 {
     char str[1024];
     if (!pCreateInfo) {
         sprintf(str, "Struct ptr parameter pCreateInfo to function CreateGraphicsPipelineDerivative is NULL.");
-        layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
     }
-    else if (!xgl_validate_xgl_graphics_pipeline_create_info(pCreateInfo)) {
+    else if (!vk_validate_vk_graphics_pipeline_create_info(pCreateInfo)) {
         sprintf(str, "Parameter pCreateInfo to function CreateGraphicsPipelineDerivative contains an invalid value.");
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
     }
-    XGL_RESULT result = nextTable.CreateGraphicsPipelineDerivative(device, pCreateInfo, basePipeline, pPipeline);
+    VK_RESULT result = nextTable.CreateGraphicsPipelineDerivative(device, pCreateInfo, basePipeline, pPipeline);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateComputePipeline(XGL_DEVICE device, const XGL_COMPUTE_PIPELINE_CREATE_INFO* pCreateInfo, XGL_PIPELINE* pPipeline)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateComputePipeline(VK_DEVICE device, const VK_COMPUTE_PIPELINE_CREATE_INFO* pCreateInfo, VK_PIPELINE* pPipeline)
 {
     char str[1024];
     if (!pCreateInfo) {
         sprintf(str, "Struct ptr parameter pCreateInfo to function CreateComputePipeline is NULL.");
-        layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
     }
-    else if (!xgl_validate_xgl_compute_pipeline_create_info(pCreateInfo)) {
+    else if (!vk_validate_vk_compute_pipeline_create_info(pCreateInfo)) {
         sprintf(str, "Parameter pCreateInfo to function CreateComputePipeline contains an invalid value.");
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
     }
-    XGL_RESULT result = nextTable.CreateComputePipeline(device, pCreateInfo, pPipeline);
+    VK_RESULT result = nextTable.CreateComputePipeline(device, pCreateInfo, pPipeline);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglStorePipeline(XGL_PIPELINE pipeline, size_t* pDataSize, void* pData)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkStorePipeline(VK_PIPELINE pipeline, size_t* pDataSize, void* pData)
 {
 
-    XGL_RESULT result = nextTable.StorePipeline(pipeline, pDataSize, pData);
+    VK_RESULT result = nextTable.StorePipeline(pipeline, pDataSize, pData);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglLoadPipeline(XGL_DEVICE device, size_t dataSize, const void* pData, XGL_PIPELINE* pPipeline)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkLoadPipeline(VK_DEVICE device, size_t dataSize, const void* pData, VK_PIPELINE* pPipeline)
 {
 
-    XGL_RESULT result = nextTable.LoadPipeline(device, dataSize, pData, pPipeline);
+    VK_RESULT result = nextTable.LoadPipeline(device, dataSize, pData, pPipeline);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglLoadPipelineDerivative(XGL_DEVICE device, size_t dataSize, const void* pData, XGL_PIPELINE basePipeline, XGL_PIPELINE* pPipeline)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkLoadPipelineDerivative(VK_DEVICE device, size_t dataSize, const void* pData, VK_PIPELINE basePipeline, VK_PIPELINE* pPipeline)
 {
 
-    XGL_RESULT result = nextTable.LoadPipelineDerivative(device, dataSize, pData, basePipeline, pPipeline);
+    VK_RESULT result = nextTable.LoadPipelineDerivative(device, dataSize, pData, basePipeline, pPipeline);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateSampler(XGL_DEVICE device, const XGL_SAMPLER_CREATE_INFO* pCreateInfo, XGL_SAMPLER* pSampler)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateSampler(VK_DEVICE device, const VK_SAMPLER_CREATE_INFO* pCreateInfo, VK_SAMPLER* pSampler)
 {
     char str[1024];
     if (!pCreateInfo) {
         sprintf(str, "Struct ptr parameter pCreateInfo to function CreateSampler is NULL.");
-        layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
     }
-    else if (!xgl_validate_xgl_sampler_create_info(pCreateInfo)) {
+    else if (!vk_validate_vk_sampler_create_info(pCreateInfo)) {
         sprintf(str, "Parameter pCreateInfo to function CreateSampler contains an invalid value.");
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
     }
-    XGL_RESULT result = nextTable.CreateSampler(device, pCreateInfo, pSampler);
+    VK_RESULT result = nextTable.CreateSampler(device, pCreateInfo, pSampler);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateDescriptorSetLayout(XGL_DEVICE device, const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pCreateInfo, XGL_DESCRIPTOR_SET_LAYOUT* pSetLayout)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDescriptorSetLayout(VK_DEVICE device, const VK_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pCreateInfo, VK_DESCRIPTOR_SET_LAYOUT* pSetLayout)
 {
     char str[1024];
     if (!pCreateInfo) {
         sprintf(str, "Struct ptr parameter pCreateInfo to function CreateDescriptorSetLayout is NULL.");
-        layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
     }
-    else if (!xgl_validate_xgl_descriptor_set_layout_create_info(pCreateInfo)) {
+    else if (!vk_validate_vk_descriptor_set_layout_create_info(pCreateInfo)) {
         sprintf(str, "Parameter pCreateInfo to function CreateDescriptorSetLayout contains an invalid value.");
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
     }
-    XGL_RESULT result = nextTable.CreateDescriptorSetLayout(device, pCreateInfo, pSetLayout);
+    VK_RESULT result = nextTable.CreateDescriptorSetLayout(device, pCreateInfo, pSetLayout);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateDescriptorSetLayoutChain(XGL_DEVICE device, uint32_t setLayoutArrayCount, const XGL_DESCRIPTOR_SET_LAYOUT* pSetLayoutArray, XGL_DESCRIPTOR_SET_LAYOUT_CHAIN* pLayoutChain)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDescriptorSetLayoutChain(VK_DEVICE device, uint32_t setLayoutArrayCount, const VK_DESCRIPTOR_SET_LAYOUT* pSetLayoutArray, VK_DESCRIPTOR_SET_LAYOUT_CHAIN* pLayoutChain)
 {
 
-    XGL_RESULT result = nextTable.CreateDescriptorSetLayoutChain(device, setLayoutArrayCount, pSetLayoutArray, pLayoutChain);
+    VK_RESULT result = nextTable.CreateDescriptorSetLayoutChain(device, setLayoutArrayCount, pSetLayoutArray, pLayoutChain);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglBeginDescriptorPoolUpdate(XGL_DEVICE device, XGL_DESCRIPTOR_UPDATE_MODE updateMode)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkBeginDescriptorPoolUpdate(VK_DEVICE device, VK_DESCRIPTOR_UPDATE_MODE updateMode)
 {
     char str[1024];
-    if (!validate_XGL_DESCRIPTOR_UPDATE_MODE(updateMode)) {
+    if (!validate_VK_DESCRIPTOR_UPDATE_MODE(updateMode)) {
         sprintf(str, "Parameter updateMode to function BeginDescriptorPoolUpdate has invalid value of %i.", (int)updateMode);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
     }
-    XGL_RESULT result = nextTable.BeginDescriptorPoolUpdate(device, updateMode);
+    VK_RESULT result = nextTable.BeginDescriptorPoolUpdate(device, updateMode);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglEndDescriptorPoolUpdate(XGL_DEVICE device, XGL_CMD_BUFFER cmd)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkEndDescriptorPoolUpdate(VK_DEVICE device, VK_CMD_BUFFER cmd)
 {
 
-    XGL_RESULT result = nextTable.EndDescriptorPoolUpdate(device, cmd);
+    VK_RESULT result = nextTable.EndDescriptorPoolUpdate(device, cmd);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateDescriptorPool(XGL_DEVICE device, XGL_DESCRIPTOR_POOL_USAGE poolUsage, uint32_t maxSets, const XGL_DESCRIPTOR_POOL_CREATE_INFO* pCreateInfo, XGL_DESCRIPTOR_POOL* pDescriptorPool)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDescriptorPool(VK_DEVICE device, VK_DESCRIPTOR_POOL_USAGE poolUsage, uint32_t maxSets, const VK_DESCRIPTOR_POOL_CREATE_INFO* pCreateInfo, VK_DESCRIPTOR_POOL* pDescriptorPool)
 {
     char str[1024];
-    if (!validate_XGL_DESCRIPTOR_POOL_USAGE(poolUsage)) {
+    if (!validate_VK_DESCRIPTOR_POOL_USAGE(poolUsage)) {
         sprintf(str, "Parameter poolUsage to function CreateDescriptorPool has invalid value of %i.", (int)poolUsage);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
     }
     if (!pCreateInfo) {
         sprintf(str, "Struct ptr parameter pCreateInfo to function CreateDescriptorPool is NULL.");
-        layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
     }
-    else if (!xgl_validate_xgl_descriptor_pool_create_info(pCreateInfo)) {
+    else if (!vk_validate_vk_descriptor_pool_create_info(pCreateInfo)) {
         sprintf(str, "Parameter pCreateInfo to function CreateDescriptorPool contains an invalid value.");
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
     }
-    XGL_RESULT result = nextTable.CreateDescriptorPool(device, poolUsage, maxSets, pCreateInfo, pDescriptorPool);
+    VK_RESULT result = nextTable.CreateDescriptorPool(device, poolUsage, maxSets, pCreateInfo, pDescriptorPool);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglResetDescriptorPool(XGL_DESCRIPTOR_POOL descriptorPool)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkResetDescriptorPool(VK_DESCRIPTOR_POOL descriptorPool)
 {
 
-    XGL_RESULT result = nextTable.ResetDescriptorPool(descriptorPool);
+    VK_RESULT result = nextTable.ResetDescriptorPool(descriptorPool);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglAllocDescriptorSets(XGL_DESCRIPTOR_POOL descriptorPool, XGL_DESCRIPTOR_SET_USAGE setUsage, uint32_t count, const XGL_DESCRIPTOR_SET_LAYOUT* pSetLayouts, XGL_DESCRIPTOR_SET* pDescriptorSets, uint32_t* pCount)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkAllocDescriptorSets(VK_DESCRIPTOR_POOL descriptorPool, VK_DESCRIPTOR_SET_USAGE setUsage, uint32_t count, const VK_DESCRIPTOR_SET_LAYOUT* pSetLayouts, VK_DESCRIPTOR_SET* pDescriptorSets, uint32_t* pCount)
 {
     char str[1024];
-    if (!validate_XGL_DESCRIPTOR_SET_USAGE(setUsage)) {
+    if (!validate_VK_DESCRIPTOR_SET_USAGE(setUsage)) {
         sprintf(str, "Parameter setUsage to function AllocDescriptorSets has invalid value of %i.", (int)setUsage);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
     }
-    XGL_RESULT result = nextTable.AllocDescriptorSets(descriptorPool, setUsage, count, pSetLayouts, pDescriptorSets, pCount);
+    VK_RESULT result = nextTable.AllocDescriptorSets(descriptorPool, setUsage, count, pSetLayouts, pDescriptorSets, pCount);
     return result;
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglClearDescriptorSets(XGL_DESCRIPTOR_POOL descriptorPool, uint32_t count, const XGL_DESCRIPTOR_SET* pDescriptorSets)
+VK_LAYER_EXPORT void VKAPI vkClearDescriptorSets(VK_DESCRIPTOR_POOL descriptorPool, uint32_t count, const VK_DESCRIPTOR_SET* pDescriptorSets)
 {
 
     nextTable.ClearDescriptorSets(descriptorPool, count, pDescriptorSets);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglUpdateDescriptors(XGL_DESCRIPTOR_SET descriptorSet, uint32_t updateCount, const void** ppUpdateArray)
+VK_LAYER_EXPORT void VKAPI vkUpdateDescriptors(VK_DESCRIPTOR_SET descriptorSet, uint32_t updateCount, const void** ppUpdateArray)
 {
 
     nextTable.UpdateDescriptors(descriptorSet, updateCount, ppUpdateArray);
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateDynamicViewportState(XGL_DEVICE device, const XGL_DYNAMIC_VP_STATE_CREATE_INFO* pCreateInfo, XGL_DYNAMIC_VP_STATE_OBJECT* pState)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDynamicViewportState(VK_DEVICE device, const VK_DYNAMIC_VP_STATE_CREATE_INFO* pCreateInfo, VK_DYNAMIC_VP_STATE_OBJECT* pState)
 {
     char str[1024];
     if (!pCreateInfo) {
         sprintf(str, "Struct ptr parameter pCreateInfo to function CreateDynamicViewportState is NULL.");
-        layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
     }
-    else if (!xgl_validate_xgl_dynamic_vp_state_create_info(pCreateInfo)) {
+    else if (!vk_validate_vk_dynamic_vp_state_create_info(pCreateInfo)) {
         sprintf(str, "Parameter pCreateInfo to function CreateDynamicViewportState contains an invalid value.");
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
     }
-    XGL_RESULT result = nextTable.CreateDynamicViewportState(device, pCreateInfo, pState);
+    VK_RESULT result = nextTable.CreateDynamicViewportState(device, pCreateInfo, pState);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateDynamicRasterState(XGL_DEVICE device, const XGL_DYNAMIC_RS_STATE_CREATE_INFO* pCreateInfo, XGL_DYNAMIC_RS_STATE_OBJECT* pState)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDynamicRasterState(VK_DEVICE device, const VK_DYNAMIC_RS_STATE_CREATE_INFO* pCreateInfo, VK_DYNAMIC_RS_STATE_OBJECT* pState)
 {
     char str[1024];
     if (!pCreateInfo) {
         sprintf(str, "Struct ptr parameter pCreateInfo to function CreateDynamicRasterState is NULL.");
-        layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
     }
-    else if (!xgl_validate_xgl_dynamic_rs_state_create_info(pCreateInfo)) {
+    else if (!vk_validate_vk_dynamic_rs_state_create_info(pCreateInfo)) {
         sprintf(str, "Parameter pCreateInfo to function CreateDynamicRasterState contains an invalid value.");
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
     }
-    XGL_RESULT result = nextTable.CreateDynamicRasterState(device, pCreateInfo, pState);
+    VK_RESULT result = nextTable.CreateDynamicRasterState(device, pCreateInfo, pState);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateDynamicColorBlendState(XGL_DEVICE device, const XGL_DYNAMIC_CB_STATE_CREATE_INFO* pCreateInfo, XGL_DYNAMIC_CB_STATE_OBJECT* pState)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDynamicColorBlendState(VK_DEVICE device, const VK_DYNAMIC_CB_STATE_CREATE_INFO* pCreateInfo, VK_DYNAMIC_CB_STATE_OBJECT* pState)
 {
     char str[1024];
     if (!pCreateInfo) {
         sprintf(str, "Struct ptr parameter pCreateInfo to function CreateDynamicColorBlendState is NULL.");
-        layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
     }
-    else if (!xgl_validate_xgl_dynamic_cb_state_create_info(pCreateInfo)) {
+    else if (!vk_validate_vk_dynamic_cb_state_create_info(pCreateInfo)) {
         sprintf(str, "Parameter pCreateInfo to function CreateDynamicColorBlendState contains an invalid value.");
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
     }
-    XGL_RESULT result = nextTable.CreateDynamicColorBlendState(device, pCreateInfo, pState);
+    VK_RESULT result = nextTable.CreateDynamicColorBlendState(device, pCreateInfo, pState);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateDynamicDepthStencilState(XGL_DEVICE device, const XGL_DYNAMIC_DS_STATE_CREATE_INFO* pCreateInfo, XGL_DYNAMIC_DS_STATE_OBJECT* pState)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDynamicDepthStencilState(VK_DEVICE device, const VK_DYNAMIC_DS_STATE_CREATE_INFO* pCreateInfo, VK_DYNAMIC_DS_STATE_OBJECT* pState)
 {
     char str[1024];
     if (!pCreateInfo) {
         sprintf(str, "Struct ptr parameter pCreateInfo to function CreateDynamicDepthStencilState is NULL.");
-        layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
     }
-    else if (!xgl_validate_xgl_dynamic_ds_state_create_info(pCreateInfo)) {
+    else if (!vk_validate_vk_dynamic_ds_state_create_info(pCreateInfo)) {
         sprintf(str, "Parameter pCreateInfo to function CreateDynamicDepthStencilState contains an invalid value.");
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
     }
-    XGL_RESULT result = nextTable.CreateDynamicDepthStencilState(device, pCreateInfo, pState);
+    VK_RESULT result = nextTable.CreateDynamicDepthStencilState(device, pCreateInfo, pState);
     return result;
 }
 
-void PreCreateCommandBuffer(XGL_DEVICE device, const XGL_CMD_BUFFER_CREATE_INFO* pCreateInfo)
+void PreCreateCommandBuffer(VK_DEVICE device, const VK_CMD_BUFFER_CREATE_INFO* pCreateInfo)
 {
     if(device == nullptr)
     {
-        char const str[] = "xglCreateCommandBuffer parameter, XGL_DEVICE device, is "\
+        char const str[] = "vkCreateCommandBuffer parameter, VK_DEVICE device, is "\
             "nullptr (precondition).";
-        layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
         return;
     }
 
     if(pCreateInfo == nullptr)
     {
-        char const str[] = "xglCreateCommandBuffer parameter, XGL_CMD_BUFFER_CREATE_INFO* pCreateInfo, is "\
+        char const str[] = "vkCreateCommandBuffer parameter, VK_CMD_BUFFER_CREATE_INFO* pCreateInfo, is "\
             "nullptr (precondition).";
-        layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
         return;
     }
 
-    if(pCreateInfo->sType != XGL_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO)
+    if(pCreateInfo->sType != VK_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO)
     {
-        char const str[] = "xglCreateCommandBuffer parameter, XGL_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO "\
-            "pCreateInfo->sType, is not XGL_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO (precondition).";
-        layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        char const str[] = "vkCreateCommandBuffer parameter, VK_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO "\
+            "pCreateInfo->sType, is not VK_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO (precondition).";
+        layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
         return;
     }
 }
 
-void PostCreateCommandBuffer(XGL_RESULT result, XGL_CMD_BUFFER* pCmdBuffer)
+void PostCreateCommandBuffer(VK_RESULT result, VK_CMD_BUFFER* pCmdBuffer)
 {
-    if(result != XGL_SUCCESS)
+    if(result != VK_SUCCESS)
     {
-        // TODO: Spit out XGL_RESULT value.
-        char const str[] = "xglCreateCommandBuffer failed (postcondition).";
-        layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        // TODO: Spit out VK_RESULT value.
+        char const str[] = "vkCreateCommandBuffer failed (postcondition).";
+        layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
         return;
     }
 
     if(pCmdBuffer == nullptr)
     {
-        char const str[] = "xglCreateCommandBuffer parameter, XGL_CMD_BUFFER* pCmdBuffer, is nullptr (postcondition).";
-        layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        char const str[] = "vkCreateCommandBuffer parameter, VK_CMD_BUFFER* pCmdBuffer, is nullptr (postcondition).";
+        layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
         return;
     }
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateCommandBuffer(XGL_DEVICE device,
-    const XGL_CMD_BUFFER_CREATE_INFO* pCreateInfo, XGL_CMD_BUFFER* pCmdBuffer)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateCommandBuffer(VK_DEVICE device,
+    const VK_CMD_BUFFER_CREATE_INFO* pCreateInfo, VK_CMD_BUFFER* pCmdBuffer)
 {
     PreCreateCommandBuffer(device, pCreateInfo);
-    XGL_RESULT result = nextTable.CreateCommandBuffer(device, pCreateInfo, pCmdBuffer);
+    VK_RESULT result = nextTable.CreateCommandBuffer(device, pCreateInfo, pCmdBuffer);
     PostCreateCommandBuffer(result, pCmdBuffer);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglBeginCommandBuffer(XGL_CMD_BUFFER cmdBuffer, const XGL_CMD_BUFFER_BEGIN_INFO* pBeginInfo)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkBeginCommandBuffer(VK_CMD_BUFFER cmdBuffer, const VK_CMD_BUFFER_BEGIN_INFO* pBeginInfo)
 {
     char str[1024];
     if (!pBeginInfo) {
         sprintf(str, "Struct ptr parameter pBeginInfo to function BeginCommandBuffer is NULL.");
-        layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
     }
-    else if (!xgl_validate_xgl_cmd_buffer_begin_info(pBeginInfo)) {
+    else if (!vk_validate_vk_cmd_buffer_begin_info(pBeginInfo)) {
         sprintf(str, "Parameter pBeginInfo to function BeginCommandBuffer contains an invalid value.");
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
     }
-    XGL_RESULT result = nextTable.BeginCommandBuffer(cmdBuffer, pBeginInfo);
+    VK_RESULT result = nextTable.BeginCommandBuffer(cmdBuffer, pBeginInfo);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglEndCommandBuffer(XGL_CMD_BUFFER cmdBuffer)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkEndCommandBuffer(VK_CMD_BUFFER cmdBuffer)
 {
 
-    XGL_RESULT result = nextTable.EndCommandBuffer(cmdBuffer);
+    VK_RESULT result = nextTable.EndCommandBuffer(cmdBuffer);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglResetCommandBuffer(XGL_CMD_BUFFER cmdBuffer)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkResetCommandBuffer(VK_CMD_BUFFER cmdBuffer)
 {
 
-    XGL_RESULT result = nextTable.ResetCommandBuffer(cmdBuffer);
+    VK_RESULT result = nextTable.ResetCommandBuffer(cmdBuffer);
     return result;
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdBindPipeline(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, XGL_PIPELINE pipeline)
+VK_LAYER_EXPORT void VKAPI vkCmdBindPipeline(VK_CMD_BUFFER cmdBuffer, VK_PIPELINE_BIND_POINT pipelineBindPoint, VK_PIPELINE pipeline)
 {
     char str[1024];
-    if (!validate_XGL_PIPELINE_BIND_POINT(pipelineBindPoint)) {
+    if (!validate_VK_PIPELINE_BIND_POINT(pipelineBindPoint)) {
         sprintf(str, "Parameter pipelineBindPoint to function CmdBindPipeline has invalid value of %i.", (int)pipelineBindPoint);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
     }
     nextTable.CmdBindPipeline(cmdBuffer, pipelineBindPoint, pipeline);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdBindDynamicStateObject(XGL_CMD_BUFFER cmdBuffer, XGL_STATE_BIND_POINT stateBindPoint, XGL_DYNAMIC_STATE_OBJECT state)
+VK_LAYER_EXPORT void VKAPI vkCmdBindDynamicStateObject(VK_CMD_BUFFER cmdBuffer, VK_STATE_BIND_POINT stateBindPoint, VK_DYNAMIC_STATE_OBJECT state)
 {
     char str[1024];
-    if (!validate_XGL_STATE_BIND_POINT(stateBindPoint)) {
+    if (!validate_VK_STATE_BIND_POINT(stateBindPoint)) {
         sprintf(str, "Parameter stateBindPoint to function CmdBindDynamicStateObject has invalid value of %i.", (int)stateBindPoint);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
     }
     nextTable.CmdBindDynamicStateObject(cmdBuffer, stateBindPoint, state);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdBindDescriptorSets(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, XGL_DESCRIPTOR_SET_LAYOUT_CHAIN layoutChain, uint32_t layoutChainSlot, uint32_t count, const XGL_DESCRIPTOR_SET* pDescriptorSets, const uint32_t* pUserData)
+VK_LAYER_EXPORT void VKAPI vkCmdBindDescriptorSets(VK_CMD_BUFFER cmdBuffer, VK_PIPELINE_BIND_POINT pipelineBindPoint, VK_DESCRIPTOR_SET_LAYOUT_CHAIN layoutChain, uint32_t layoutChainSlot, uint32_t count, const VK_DESCRIPTOR_SET* pDescriptorSets, const uint32_t* pUserData)
 {
     char str[1024];
-    if (!validate_XGL_PIPELINE_BIND_POINT(pipelineBindPoint)) {
+    if (!validate_VK_PIPELINE_BIND_POINT(pipelineBindPoint)) {
         sprintf(str, "Parameter pipelineBindPoint to function CmdBindDescriptorSets has invalid value of %i.", (int)pipelineBindPoint);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
     }
     nextTable.CmdBindDescriptorSets(cmdBuffer, pipelineBindPoint, layoutChain, layoutChainSlot, count, pDescriptorSets, pUserData);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdBindVertexBuffer(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER buffer, XGL_GPU_SIZE offset, uint32_t binding)
+VK_LAYER_EXPORT void VKAPI vkCmdBindVertexBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFFER buffer, VK_GPU_SIZE offset, uint32_t binding)
 {
 
     nextTable.CmdBindVertexBuffer(cmdBuffer, buffer, offset, binding);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdBindIndexBuffer(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER buffer, XGL_GPU_SIZE offset, XGL_INDEX_TYPE indexType)
+VK_LAYER_EXPORT void VKAPI vkCmdBindIndexBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFFER buffer, VK_GPU_SIZE offset, VK_INDEX_TYPE indexType)
 {
     char str[1024];
-    if (!validate_XGL_INDEX_TYPE(indexType)) {
+    if (!validate_VK_INDEX_TYPE(indexType)) {
         sprintf(str, "Parameter indexType to function CmdBindIndexBuffer has invalid value of %i.", (int)indexType);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
     }
     nextTable.CmdBindIndexBuffer(cmdBuffer, buffer, offset, indexType);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdDraw(XGL_CMD_BUFFER cmdBuffer, uint32_t firstVertex, uint32_t vertexCount, uint32_t firstInstance, uint32_t instanceCount)
+VK_LAYER_EXPORT void VKAPI vkCmdDraw(VK_CMD_BUFFER cmdBuffer, uint32_t firstVertex, uint32_t vertexCount, uint32_t firstInstance, uint32_t instanceCount)
 {
 
     nextTable.CmdDraw(cmdBuffer, firstVertex, vertexCount, firstInstance, instanceCount);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdDrawIndexed(XGL_CMD_BUFFER cmdBuffer, uint32_t firstIndex, uint32_t indexCount, int32_t vertexOffset, uint32_t firstInstance, uint32_t instanceCount)
+VK_LAYER_EXPORT void VKAPI vkCmdDrawIndexed(VK_CMD_BUFFER cmdBuffer, uint32_t firstIndex, uint32_t indexCount, int32_t vertexOffset, uint32_t firstInstance, uint32_t instanceCount)
 {
 
     nextTable.CmdDrawIndexed(cmdBuffer, firstIndex, indexCount, vertexOffset, firstInstance, instanceCount);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdDrawIndirect(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER buffer, XGL_GPU_SIZE offset, uint32_t count, uint32_t stride)
+VK_LAYER_EXPORT void VKAPI vkCmdDrawIndirect(VK_CMD_BUFFER cmdBuffer, VK_BUFFER buffer, VK_GPU_SIZE offset, uint32_t count, uint32_t stride)
 {
 
     nextTable.CmdDrawIndirect(cmdBuffer, buffer, offset, count, stride);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdDrawIndexedIndirect(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER buffer, XGL_GPU_SIZE offset, uint32_t count, uint32_t stride)
+VK_LAYER_EXPORT void VKAPI vkCmdDrawIndexedIndirect(VK_CMD_BUFFER cmdBuffer, VK_BUFFER buffer, VK_GPU_SIZE offset, uint32_t count, uint32_t stride)
 {
 
     nextTable.CmdDrawIndexedIndirect(cmdBuffer, buffer, offset, count, stride);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdDispatch(XGL_CMD_BUFFER cmdBuffer, uint32_t x, uint32_t y, uint32_t z)
+VK_LAYER_EXPORT void VKAPI vkCmdDispatch(VK_CMD_BUFFER cmdBuffer, uint32_t x, uint32_t y, uint32_t z)
 {
 
     nextTable.CmdDispatch(cmdBuffer, x, y, z);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdDispatchIndirect(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER buffer, XGL_GPU_SIZE offset)
+VK_LAYER_EXPORT void VKAPI vkCmdDispatchIndirect(VK_CMD_BUFFER cmdBuffer, VK_BUFFER buffer, VK_GPU_SIZE offset)
 {
 
     nextTable.CmdDispatchIndirect(cmdBuffer, buffer, offset);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdCopyBuffer(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER srcBuffer, XGL_BUFFER destBuffer, uint32_t regionCount, const XGL_BUFFER_COPY* pRegions)
+VK_LAYER_EXPORT void VKAPI vkCmdCopyBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFFER srcBuffer, VK_BUFFER destBuffer, uint32_t regionCount, const VK_BUFFER_COPY* pRegions)
 {
     char str[1024];
     uint32_t i;
     for (i = 0; i < regionCount; i++) {
-        if (!xgl_validate_xgl_buffer_copy(&pRegions[i])) {
+        if (!vk_validate_vk_buffer_copy(&pRegions[i])) {
             sprintf(str, "Parameter pRegions[%i] to function CmdCopyBuffer contains an invalid value.", i);
-            layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+            layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
         }
     }
     nextTable.CmdCopyBuffer(cmdBuffer, srcBuffer, destBuffer, regionCount, pRegions);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdCopyImage(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE srcImage, XGL_IMAGE_LAYOUT srcImageLayout, XGL_IMAGE destImage, XGL_IMAGE_LAYOUT destImageLayout, uint32_t regionCount, const XGL_IMAGE_COPY* pRegions)
+VK_LAYER_EXPORT void VKAPI vkCmdCopyImage(VK_CMD_BUFFER cmdBuffer, VK_IMAGE srcImage, VK_IMAGE_LAYOUT srcImageLayout, VK_IMAGE destImage, VK_IMAGE_LAYOUT destImageLayout, uint32_t regionCount, const VK_IMAGE_COPY* pRegions)
 {
     char str[1024];
-    if (!validate_XGL_IMAGE_LAYOUT(srcImageLayout)) {
+    if (!validate_VK_IMAGE_LAYOUT(srcImageLayout)) {
         sprintf(str, "Parameter srcImageLayout to function CmdCopyImage has invalid value of %i.", (int)srcImageLayout);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
     }
-    if (!validate_XGL_IMAGE_LAYOUT(destImageLayout)) {
+    if (!validate_VK_IMAGE_LAYOUT(destImageLayout)) {
         sprintf(str, "Parameter destImageLayout to function CmdCopyImage has invalid value of %i.", (int)destImageLayout);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
     }
     uint32_t i;
     for (i = 0; i < regionCount; i++) {
-        if (!xgl_validate_xgl_image_copy(&pRegions[i])) {
+        if (!vk_validate_vk_image_copy(&pRegions[i])) {
             sprintf(str, "Parameter pRegions[%i] to function CmdCopyImage contains an invalid value.", i);
-            layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+            layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
         }
     }
     nextTable.CmdCopyImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdBlitImage(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE srcImage, XGL_IMAGE_LAYOUT srcImageLayout, XGL_IMAGE destImage, XGL_IMAGE_LAYOUT destImageLayout, uint32_t regionCount, const XGL_IMAGE_BLIT* pRegions)
+VK_LAYER_EXPORT void VKAPI vkCmdBlitImage(VK_CMD_BUFFER cmdBuffer, VK_IMAGE srcImage, VK_IMAGE_LAYOUT srcImageLayout, VK_IMAGE destImage, VK_IMAGE_LAYOUT destImageLayout, uint32_t regionCount, const VK_IMAGE_BLIT* pRegions)
 {
     char str[1024];
-    if (!validate_XGL_IMAGE_LAYOUT(srcImageLayout)) {
+    if (!validate_VK_IMAGE_LAYOUT(srcImageLayout)) {
         sprintf(str, "Parameter srcImageLayout to function CmdBlitImage has invalid value of %i.", (int)srcImageLayout);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
     }
-    if (!validate_XGL_IMAGE_LAYOUT(destImageLayout)) {
+    if (!validate_VK_IMAGE_LAYOUT(destImageLayout)) {
         sprintf(str, "Parameter destImageLayout to function CmdBlitImage has invalid value of %i.", (int)destImageLayout);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
     }
     uint32_t i;
     for (i = 0; i < regionCount; i++) {
-        if (!xgl_validate_xgl_image_blit(&pRegions[i])) {
+        if (!vk_validate_vk_image_blit(&pRegions[i])) {
             sprintf(str, "Parameter pRegions[%i] to function CmdBlitImage contains an invalid value.", i);
-            layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+            layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
         }
     }
     nextTable.CmdBlitImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdCopyBufferToImage(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER srcBuffer, XGL_IMAGE destImage, XGL_IMAGE_LAYOUT destImageLayout, uint32_t regionCount, const XGL_BUFFER_IMAGE_COPY* pRegions)
+VK_LAYER_EXPORT void VKAPI vkCmdCopyBufferToImage(VK_CMD_BUFFER cmdBuffer, VK_BUFFER srcBuffer, VK_IMAGE destImage, VK_IMAGE_LAYOUT destImageLayout, uint32_t regionCount, const VK_BUFFER_IMAGE_COPY* pRegions)
 {
     char str[1024];
-    if (!validate_XGL_IMAGE_LAYOUT(destImageLayout)) {
+    if (!validate_VK_IMAGE_LAYOUT(destImageLayout)) {
         sprintf(str, "Parameter destImageLayout to function CmdCopyBufferToImage has invalid value of %i.", (int)destImageLayout);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
     }
     uint32_t i;
     for (i = 0; i < regionCount; i++) {
-        if (!xgl_validate_xgl_buffer_image_copy(&pRegions[i])) {
+        if (!vk_validate_vk_buffer_image_copy(&pRegions[i])) {
             sprintf(str, "Parameter pRegions[%i] to function CmdCopyBufferToImage contains an invalid value.", i);
-            layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+            layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
         }
     }
     nextTable.CmdCopyBufferToImage(cmdBuffer, srcBuffer, destImage, destImageLayout, regionCount, pRegions);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdCopyImageToBuffer(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE srcImage, XGL_IMAGE_LAYOUT srcImageLayout, XGL_BUFFER destBuffer, uint32_t regionCount, const XGL_BUFFER_IMAGE_COPY* pRegions)
+VK_LAYER_EXPORT void VKAPI vkCmdCopyImageToBuffer(VK_CMD_BUFFER cmdBuffer, VK_IMAGE srcImage, VK_IMAGE_LAYOUT srcImageLayout, VK_BUFFER destBuffer, uint32_t regionCount, const VK_BUFFER_IMAGE_COPY* pRegions)
 {
     char str[1024];
-    if (!validate_XGL_IMAGE_LAYOUT(srcImageLayout)) {
+    if (!validate_VK_IMAGE_LAYOUT(srcImageLayout)) {
         sprintf(str, "Parameter srcImageLayout to function CmdCopyImageToBuffer has invalid value of %i.", (int)srcImageLayout);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
     }
     uint32_t i;
     for (i = 0; i < regionCount; i++) {
-        if (!xgl_validate_xgl_buffer_image_copy(&pRegions[i])) {
+        if (!vk_validate_vk_buffer_image_copy(&pRegions[i])) {
             sprintf(str, "Parameter pRegions[%i] to function CmdCopyImageToBuffer contains an invalid value.", i);
-            layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+            layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
         }
     }
     nextTable.CmdCopyImageToBuffer(cmdBuffer, srcImage, srcImageLayout, destBuffer, regionCount, pRegions);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdCloneImageData(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE srcImage, XGL_IMAGE_LAYOUT srcImageLayout, XGL_IMAGE destImage, XGL_IMAGE_LAYOUT destImageLayout)
+VK_LAYER_EXPORT void VKAPI vkCmdCloneImageData(VK_CMD_BUFFER cmdBuffer, VK_IMAGE srcImage, VK_IMAGE_LAYOUT srcImageLayout, VK_IMAGE destImage, VK_IMAGE_LAYOUT destImageLayout)
 {
     char str[1024];
-    if (!validate_XGL_IMAGE_LAYOUT(srcImageLayout)) {
+    if (!validate_VK_IMAGE_LAYOUT(srcImageLayout)) {
         sprintf(str, "Parameter srcImageLayout to function CmdCloneImageData has invalid value of %i.", (int)srcImageLayout);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
     }
-    if (!validate_XGL_IMAGE_LAYOUT(destImageLayout)) {
+    if (!validate_VK_IMAGE_LAYOUT(destImageLayout)) {
         sprintf(str, "Parameter destImageLayout to function CmdCloneImageData has invalid value of %i.", (int)destImageLayout);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
     }
     nextTable.CmdCloneImageData(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdUpdateBuffer(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER destBuffer, XGL_GPU_SIZE destOffset, XGL_GPU_SIZE dataSize, const uint32_t* pData)
+VK_LAYER_EXPORT void VKAPI vkCmdUpdateBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFFER destBuffer, VK_GPU_SIZE destOffset, VK_GPU_SIZE dataSize, const uint32_t* pData)
 {
 
     nextTable.CmdUpdateBuffer(cmdBuffer, destBuffer, destOffset, dataSize, pData);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdFillBuffer(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER destBuffer, XGL_GPU_SIZE destOffset, XGL_GPU_SIZE fillSize, uint32_t data)
+VK_LAYER_EXPORT void VKAPI vkCmdFillBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFFER destBuffer, VK_GPU_SIZE destOffset, VK_GPU_SIZE fillSize, uint32_t data)
 {
 
     nextTable.CmdFillBuffer(cmdBuffer, destBuffer, destOffset, fillSize, data);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdClearColorImage(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE image, XGL_IMAGE_LAYOUT imageLayout, XGL_CLEAR_COLOR color, uint32_t rangeCount, const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges)
+VK_LAYER_EXPORT void VKAPI vkCmdClearColorImage(VK_CMD_BUFFER cmdBuffer, VK_IMAGE image, VK_IMAGE_LAYOUT imageLayout, VK_CLEAR_COLOR color, uint32_t rangeCount, const VK_IMAGE_SUBRESOURCE_RANGE* pRanges)
 {
     char str[1024];
-    if (!validate_XGL_IMAGE_LAYOUT(imageLayout)) {
+    if (!validate_VK_IMAGE_LAYOUT(imageLayout)) {
         sprintf(str, "Parameter imageLayout to function CmdClearColorImage has invalid value of %i.", (int)imageLayout);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
     }
     uint32_t i;
     for (i = 0; i < rangeCount; i++) {
-        if (!xgl_validate_xgl_image_subresource_range(&pRanges[i])) {
+        if (!vk_validate_vk_image_subresource_range(&pRanges[i])) {
             sprintf(str, "Parameter pRanges[%i] to function CmdClearColorImage contains an invalid value.", i);
-            layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+            layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
         }
     }
     nextTable.CmdClearColorImage(cmdBuffer, image, imageLayout, color, rangeCount, pRanges);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdClearDepthStencil(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE image, XGL_IMAGE_LAYOUT imageLayout, float depth, uint32_t stencil, uint32_t rangeCount, const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges)
+VK_LAYER_EXPORT void VKAPI vkCmdClearDepthStencil(VK_CMD_BUFFER cmdBuffer, VK_IMAGE image, VK_IMAGE_LAYOUT imageLayout, float depth, uint32_t stencil, uint32_t rangeCount, const VK_IMAGE_SUBRESOURCE_RANGE* pRanges)
 {
     char str[1024];
-    if (!validate_XGL_IMAGE_LAYOUT(imageLayout)) {
+    if (!validate_VK_IMAGE_LAYOUT(imageLayout)) {
         sprintf(str, "Parameter imageLayout to function CmdClearDepthStencil has invalid value of %i.", (int)imageLayout);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
     }
     uint32_t i;
     for (i = 0; i < rangeCount; i++) {
-        if (!xgl_validate_xgl_image_subresource_range(&pRanges[i])) {
+        if (!vk_validate_vk_image_subresource_range(&pRanges[i])) {
             sprintf(str, "Parameter pRanges[%i] to function CmdClearDepthStencil contains an invalid value.", i);
-            layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+            layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
         }
     }
     nextTable.CmdClearDepthStencil(cmdBuffer, image, imageLayout, depth, stencil, rangeCount, pRanges);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdResolveImage(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE srcImage, XGL_IMAGE_LAYOUT srcImageLayout, XGL_IMAGE destImage, XGL_IMAGE_LAYOUT destImageLayout, uint32_t rectCount, const XGL_IMAGE_RESOLVE* pRects)
+VK_LAYER_EXPORT void VKAPI vkCmdResolveImage(VK_CMD_BUFFER cmdBuffer, VK_IMAGE srcImage, VK_IMAGE_LAYOUT srcImageLayout, VK_IMAGE destImage, VK_IMAGE_LAYOUT destImageLayout, uint32_t rectCount, const VK_IMAGE_RESOLVE* pRects)
 {
     char str[1024];
-    if (!validate_XGL_IMAGE_LAYOUT(srcImageLayout)) {
+    if (!validate_VK_IMAGE_LAYOUT(srcImageLayout)) {
         sprintf(str, "Parameter srcImageLayout to function CmdResolveImage has invalid value of %i.", (int)srcImageLayout);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
     }
-    if (!validate_XGL_IMAGE_LAYOUT(destImageLayout)) {
+    if (!validate_VK_IMAGE_LAYOUT(destImageLayout)) {
         sprintf(str, "Parameter destImageLayout to function CmdResolveImage has invalid value of %i.", (int)destImageLayout);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
     }
     uint32_t i;
     for (i = 0; i < rectCount; i++) {
-        if (!xgl_validate_xgl_image_resolve(&pRects[i])) {
+        if (!vk_validate_vk_image_resolve(&pRects[i])) {
             sprintf(str, "Parameter pRects[%i] to function CmdResolveImage contains an invalid value.", i);
-            layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+            layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
         }
     }
     nextTable.CmdResolveImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, rectCount, pRects);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdSetEvent(XGL_CMD_BUFFER cmdBuffer, XGL_EVENT event, XGL_PIPE_EVENT pipeEvent)
+VK_LAYER_EXPORT void VKAPI vkCmdSetEvent(VK_CMD_BUFFER cmdBuffer, VK_EVENT event, VK_PIPE_EVENT pipeEvent)
 {
     char str[1024];
-    if (!validate_XGL_PIPE_EVENT(pipeEvent)) {
+    if (!validate_VK_PIPE_EVENT(pipeEvent)) {
         sprintf(str, "Parameter pipeEvent to function CmdSetEvent has invalid value of %i.", (int)pipeEvent);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
     }
     nextTable.CmdSetEvent(cmdBuffer, event, pipeEvent);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdResetEvent(XGL_CMD_BUFFER cmdBuffer, XGL_EVENT event, XGL_PIPE_EVENT pipeEvent)
+VK_LAYER_EXPORT void VKAPI vkCmdResetEvent(VK_CMD_BUFFER cmdBuffer, VK_EVENT event, VK_PIPE_EVENT pipeEvent)
 {
     char str[1024];
-    if (!validate_XGL_PIPE_EVENT(pipeEvent)) {
+    if (!validate_VK_PIPE_EVENT(pipeEvent)) {
         sprintf(str, "Parameter pipeEvent to function CmdResetEvent has invalid value of %i.", (int)pipeEvent);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
     }
     nextTable.CmdResetEvent(cmdBuffer, event, pipeEvent);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdWaitEvents(XGL_CMD_BUFFER cmdBuffer, const XGL_EVENT_WAIT_INFO* pWaitInfo)
+VK_LAYER_EXPORT void VKAPI vkCmdWaitEvents(VK_CMD_BUFFER cmdBuffer, const VK_EVENT_WAIT_INFO* pWaitInfo)
 {
     char str[1024];
     if (!pWaitInfo) {
         sprintf(str, "Struct ptr parameter pWaitInfo to function CmdWaitEvents is NULL.");
-        layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
     }
-    else if (!xgl_validate_xgl_event_wait_info(pWaitInfo)) {
+    else if (!vk_validate_vk_event_wait_info(pWaitInfo)) {
         sprintf(str, "Parameter pWaitInfo to function CmdWaitEvents contains an invalid value.");
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
     }
     nextTable.CmdWaitEvents(cmdBuffer, pWaitInfo);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdPipelineBarrier(XGL_CMD_BUFFER cmdBuffer, const XGL_PIPELINE_BARRIER* pBarrier)
+VK_LAYER_EXPORT void VKAPI vkCmdPipelineBarrier(VK_CMD_BUFFER cmdBuffer, const VK_PIPELINE_BARRIER* pBarrier)
 {
     char str[1024];
     if (!pBarrier) {
         sprintf(str, "Struct ptr parameter pBarrier to function CmdPipelineBarrier is NULL.");
-        layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
     }
-    else if (!xgl_validate_xgl_pipeline_barrier(pBarrier)) {
+    else if (!vk_validate_vk_pipeline_barrier(pBarrier)) {
         sprintf(str, "Parameter pBarrier to function CmdPipelineBarrier contains an invalid value.");
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
     }
     nextTable.CmdPipelineBarrier(cmdBuffer, pBarrier);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdBeginQuery(XGL_CMD_BUFFER cmdBuffer, XGL_QUERY_POOL queryPool, uint32_t slot, XGL_FLAGS flags)
+VK_LAYER_EXPORT void VKAPI vkCmdBeginQuery(VK_CMD_BUFFER cmdBuffer, VK_QUERY_POOL queryPool, uint32_t slot, VK_FLAGS flags)
 {
 
     nextTable.CmdBeginQuery(cmdBuffer, queryPool, slot, flags);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdEndQuery(XGL_CMD_BUFFER cmdBuffer, XGL_QUERY_POOL queryPool, uint32_t slot)
+VK_LAYER_EXPORT void VKAPI vkCmdEndQuery(VK_CMD_BUFFER cmdBuffer, VK_QUERY_POOL queryPool, uint32_t slot)
 {
 
     nextTable.CmdEndQuery(cmdBuffer, queryPool, slot);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdResetQueryPool(XGL_CMD_BUFFER cmdBuffer, XGL_QUERY_POOL queryPool, uint32_t startQuery, uint32_t queryCount)
+VK_LAYER_EXPORT void VKAPI vkCmdResetQueryPool(VK_CMD_BUFFER cmdBuffer, VK_QUERY_POOL queryPool, uint32_t startQuery, uint32_t queryCount)
 {
 
     nextTable.CmdResetQueryPool(cmdBuffer, queryPool, startQuery, queryCount);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdWriteTimestamp(XGL_CMD_BUFFER cmdBuffer, XGL_TIMESTAMP_TYPE timestampType, XGL_BUFFER destBuffer, XGL_GPU_SIZE destOffset)
+VK_LAYER_EXPORT void VKAPI vkCmdWriteTimestamp(VK_CMD_BUFFER cmdBuffer, VK_TIMESTAMP_TYPE timestampType, VK_BUFFER destBuffer, VK_GPU_SIZE destOffset)
 {
     char str[1024];
-    if (!validate_XGL_TIMESTAMP_TYPE(timestampType)) {
+    if (!validate_VK_TIMESTAMP_TYPE(timestampType)) {
         sprintf(str, "Parameter timestampType to function CmdWriteTimestamp has invalid value of %i.", (int)timestampType);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
     }
     nextTable.CmdWriteTimestamp(cmdBuffer, timestampType, destBuffer, destOffset);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdInitAtomicCounters(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, const uint32_t* pData)
+VK_LAYER_EXPORT void VKAPI vkCmdInitAtomicCounters(VK_CMD_BUFFER cmdBuffer, VK_PIPELINE_BIND_POINT pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, const uint32_t* pData)
 {
     char str[1024];
-    if (!validate_XGL_PIPELINE_BIND_POINT(pipelineBindPoint)) {
+    if (!validate_VK_PIPELINE_BIND_POINT(pipelineBindPoint)) {
         sprintf(str, "Parameter pipelineBindPoint to function CmdInitAtomicCounters has invalid value of %i.", (int)pipelineBindPoint);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
     }
     nextTable.CmdInitAtomicCounters(cmdBuffer, pipelineBindPoint, startCounter, counterCount, pData);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdLoadAtomicCounters(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, XGL_BUFFER srcBuffer, XGL_GPU_SIZE srcOffset)
+VK_LAYER_EXPORT void VKAPI vkCmdLoadAtomicCounters(VK_CMD_BUFFER cmdBuffer, VK_PIPELINE_BIND_POINT pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, VK_BUFFER srcBuffer, VK_GPU_SIZE srcOffset)
 {
     char str[1024];
-    if (!validate_XGL_PIPELINE_BIND_POINT(pipelineBindPoint)) {
+    if (!validate_VK_PIPELINE_BIND_POINT(pipelineBindPoint)) {
         sprintf(str, "Parameter pipelineBindPoint to function CmdLoadAtomicCounters has invalid value of %i.", (int)pipelineBindPoint);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
     }
     nextTable.CmdLoadAtomicCounters(cmdBuffer, pipelineBindPoint, startCounter, counterCount, srcBuffer, srcOffset);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdSaveAtomicCounters(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, XGL_BUFFER destBuffer, XGL_GPU_SIZE destOffset)
+VK_LAYER_EXPORT void VKAPI vkCmdSaveAtomicCounters(VK_CMD_BUFFER cmdBuffer, VK_PIPELINE_BIND_POINT pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, VK_BUFFER destBuffer, VK_GPU_SIZE destOffset)
 {
     char str[1024];
-    if (!validate_XGL_PIPELINE_BIND_POINT(pipelineBindPoint)) {
+    if (!validate_VK_PIPELINE_BIND_POINT(pipelineBindPoint)) {
         sprintf(str, "Parameter pipelineBindPoint to function CmdSaveAtomicCounters has invalid value of %i.", (int)pipelineBindPoint);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
     }
     nextTable.CmdSaveAtomicCounters(cmdBuffer, pipelineBindPoint, startCounter, counterCount, destBuffer, destOffset);
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateFramebuffer(XGL_DEVICE device, const XGL_FRAMEBUFFER_CREATE_INFO* pCreateInfo, XGL_FRAMEBUFFER* pFramebuffer)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateFramebuffer(VK_DEVICE device, const VK_FRAMEBUFFER_CREATE_INFO* pCreateInfo, VK_FRAMEBUFFER* pFramebuffer)
 {
     char str[1024];
     if (!pCreateInfo) {
         sprintf(str, "Struct ptr parameter pCreateInfo to function CreateFramebuffer is NULL.");
-        layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
     }
-    else if (!xgl_validate_xgl_framebuffer_create_info(pCreateInfo)) {
+    else if (!vk_validate_vk_framebuffer_create_info(pCreateInfo)) {
         sprintf(str, "Parameter pCreateInfo to function CreateFramebuffer contains an invalid value.");
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
     }
-    XGL_RESULT result = nextTable.CreateFramebuffer(device, pCreateInfo, pFramebuffer);
+    VK_RESULT result = nextTable.CreateFramebuffer(device, pCreateInfo, pFramebuffer);
     return result;
 }
 
 
-void PreCreateRenderPass(XGL_DEVICE device, const XGL_RENDER_PASS_CREATE_INFO* pCreateInfo)
+void PreCreateRenderPass(VK_DEVICE device, const VK_RENDER_PASS_CREATE_INFO* pCreateInfo)
 {
     if(pCreateInfo == nullptr)
     {
-        char const str[] = "xglCreateRenderPass parameter, XGL_RENDER_PASS_CREATE_INFO* pCreateInfo, is "\
+        char const str[] = "vkCreateRenderPass parameter, VK_RENDER_PASS_CREATE_INFO* pCreateInfo, is "\
             "nullptr (precondition).";
-        layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
         return;
     }
 
-    if(pCreateInfo->sType != XGL_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO)
+    if(pCreateInfo->sType != VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO)
     {
-        char const str[] = "xglCreateRenderPass parameter, XGL_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO "\
-            "pCreateInfo->sType, is not XGL_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO (precondition).";
-        layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        char const str[] = "vkCreateRenderPass parameter, VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO "\
+            "pCreateInfo->sType, is not VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO (precondition).";
+        layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
         return;
     }
 
-    if(!xgl_validate_xgl_rect(&pCreateInfo->renderArea))
+    if(!vk_validate_vk_rect(&pCreateInfo->renderArea))
     {
-        char const str[] = "xglCreateRenderPass parameter, XGL_RECT pCreateInfo->renderArea, is invalid "\
+        char const str[] = "vkCreateRenderPass parameter, VK_RECT pCreateInfo->renderArea, is invalid "\
             "(precondition).";
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
         return;
     }
 
-    if(!xgl_validate_xgl_extent2d(&pCreateInfo->extent))
+    if(!vk_validate_vk_extent2d(&pCreateInfo->extent))
     {
-        char const str[] = "xglCreateRenderPass parameter, XGL_EXTENT2D pCreateInfo->extent, is invalid "\
+        char const str[] = "vkCreateRenderPass parameter, VK_EXTENT2D pCreateInfo->extent, is invalid "\
             "(precondition).";
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
         return;
     }
 
     if(pCreateInfo->pColorFormats == nullptr)
     {
-        char const str[] = "xglCreateRenderPass parameter, XGL_FORMAT* pCreateInfo->pColorFormats, "\
+        char const str[] = "vkCreateRenderPass parameter, VK_FORMAT* pCreateInfo->pColorFormats, "\
             "is nullptr (precondition).";
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
         return;
     }
 
     for(uint32_t i = 0; i < pCreateInfo->colorAttachmentCount; ++i)
     {
-        if(!validate_XGL_FORMAT(pCreateInfo->pColorFormats[i]))
+        if(!validate_VK_FORMAT(pCreateInfo->pColorFormats[i]))
         {
             std::stringstream ss;
-            ss << "xglCreateRenderPass parameter, XGL_FORMAT pCreateInfo->pColorFormats[" << i <<
+            ss << "vkCreateRenderPass parameter, VK_FORMAT pCreateInfo->pColorFormats[" << i <<
                 "], is unrecognized (precondition).";
-            layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", ss.str().c_str());
+            layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", ss.str().c_str());
             continue;
         }
 
-        XGL_FORMAT_PROPERTIES properties;
+        VK_FORMAT_PROPERTIES properties;
         size_t size = sizeof(properties);
-        XGL_RESULT result = nextTable.GetFormatInfo(device, pCreateInfo->pColorFormats[i],
-            XGL_INFO_TYPE_FORMAT_PROPERTIES, &size, &properties);
-        if(result != XGL_SUCCESS)
+        VK_RESULT result = nextTable.GetFormatInfo(device, pCreateInfo->pColorFormats[i],
+            VK_INFO_TYPE_FORMAT_PROPERTIES, &size, &properties);
+        if(result != VK_SUCCESS)
         {
             std::stringstream ss;
-            ss << "xglCreateRenderPass parameter, XGL_FORMAT pCreateInfo->pColorFormats[" << i <<
+            ss << "vkCreateRenderPass parameter, VK_FORMAT pCreateInfo->pColorFormats[" << i <<
                 "], cannot be validated (precondition).";
-            layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", ss.str().c_str());
+            layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", ss.str().c_str());
             continue;
         }
 
         if((properties.linearTilingFeatures) == 0 && (properties.optimalTilingFeatures == 0))
         {
             std::stringstream ss;
-            ss << "xglCreateRenderPass parameter, XGL_FORMAT pCreateInfo->pColorFormats[" << i <<
+            ss << "vkCreateRenderPass parameter, VK_FORMAT pCreateInfo->pColorFormats[" << i <<
                 "], contains unsupported format (precondition).";
-            layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", ss.str().c_str());
+            layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", ss.str().c_str());
             continue;
         }
 
@@ -1612,260 +1613,260 @@
 
     if(pCreateInfo->pColorLayouts == nullptr)
     {
-        char const str[] = "xglCreateRenderPass parameter, XGL_IMAGE_LAYOUT* pCreateInfo->pColorLayouts, "\
+        char const str[] = "vkCreateRenderPass parameter, VK_IMAGE_LAYOUT* pCreateInfo->pColorLayouts, "\
             "is nullptr (precondition).";
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
         return;
     }
 
     for(uint32_t i = 0; i < pCreateInfo->colorAttachmentCount; ++i)
     {
-        if(!validate_XGL_IMAGE_LAYOUT(pCreateInfo->pColorLayouts[i]))
+        if(!validate_VK_IMAGE_LAYOUT(pCreateInfo->pColorLayouts[i]))
         {
             std::stringstream ss;
-            ss << "xglCreateRenderPass parameter, XGL_IMAGE_LAYOUT pCreateInfo->pColorLayouts[" << i <<
+            ss << "vkCreateRenderPass parameter, VK_IMAGE_LAYOUT pCreateInfo->pColorLayouts[" << i <<
                 "], is unrecognized (precondition).";
-            layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", ss.str().c_str());
+            layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", ss.str().c_str());
             continue;
         }
     }
 
     if(pCreateInfo->pColorLoadOps == nullptr)
     {
-        char const str[] = "xglCreateRenderPass parameter, XGL_ATTACHMENT_LOAD_OP* pCreateInfo->pColorLoadOps, "\
+        char const str[] = "vkCreateRenderPass parameter, VK_ATTACHMENT_LOAD_OP* pCreateInfo->pColorLoadOps, "\
             "is nullptr (precondition).";
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
         return;
     }
 
     for(uint32_t i = 0; i < pCreateInfo->colorAttachmentCount; ++i)
     {
-        if(!validate_XGL_ATTACHMENT_LOAD_OP(pCreateInfo->pColorLoadOps[i]))
+        if(!validate_VK_ATTACHMENT_LOAD_OP(pCreateInfo->pColorLoadOps[i]))
         {
             std::stringstream ss;
-            ss << "xglCreateRenderPass parameter, XGL_ATTACHMENT_LOAD_OP pCreateInfo->pColorLoadOps[" << i <<
+            ss << "vkCreateRenderPass parameter, VK_ATTACHMENT_LOAD_OP pCreateInfo->pColorLoadOps[" << i <<
                 "], is unrecognized (precondition).";
-            layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", ss.str().c_str());
+            layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", ss.str().c_str());
             continue;
         }
     }
 
     if(pCreateInfo->pColorStoreOps == nullptr)
     {
-        char const str[] = "xglCreateRenderPass parameter, XGL_ATTACHMENT_STORE_OP* pCreateInfo->pColorStoreOps, "\
+        char const str[] = "vkCreateRenderPass parameter, VK_ATTACHMENT_STORE_OP* pCreateInfo->pColorStoreOps, "\
             "is nullptr (precondition).";
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
         return;
     }
 
     for(uint32_t i = 0; i < pCreateInfo->colorAttachmentCount; ++i)
     {
-        if(!validate_XGL_ATTACHMENT_STORE_OP(pCreateInfo->pColorStoreOps[i]))
+        if(!validate_VK_ATTACHMENT_STORE_OP(pCreateInfo->pColorStoreOps[i]))
         {
             std::stringstream ss;
-            ss << "xglCreateRenderPass parameter, XGL_ATTACHMENT_STORE_OP pCreateInfo->pColorStoreOps[" << i <<
+            ss << "vkCreateRenderPass parameter, VK_ATTACHMENT_STORE_OP pCreateInfo->pColorStoreOps[" << i <<
                 "], is unrecognized (precondition).";
-            layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", ss.str().c_str());
+            layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", ss.str().c_str());
             continue;
         }
     }
 
     if(pCreateInfo->pColorLoadClearValues == nullptr)
     {
-        char const str[] = "xglCreateRenderPass parameter, XGL_CLEAR_COLOR* pCreateInfo->"\
+        char const str[] = "vkCreateRenderPass parameter, VK_CLEAR_COLOR* pCreateInfo->"\
             "pColorLoadClearValues, is nullptr (precondition).";
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
         return;
     }
 
     if(pCreateInfo->pColorStoreOps == nullptr)
     {
-        char const str[] = "xglCreateRenderPass parameter, XGL_ATTACHMENT_STORE_OP* pCreateInfo->pColorStoreOps, "\
+        char const str[] = "vkCreateRenderPass parameter, VK_ATTACHMENT_STORE_OP* pCreateInfo->pColorStoreOps, "\
             "is nullptr (precondition).";
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
         return;
     }
 
     for(uint32_t i = 0; i < pCreateInfo->colorAttachmentCount; ++i)
     {
-        if(!validate_XGL_ATTACHMENT_STORE_OP(pCreateInfo->pColorStoreOps[i]))
+        if(!validate_VK_ATTACHMENT_STORE_OP(pCreateInfo->pColorStoreOps[i]))
         {
             std::stringstream ss;
-            ss << "xglCreateRenderPass parameter, XGL_ATTACHMENT_STORE_OP pCreateInfo->pColorStoreOps[" << i <<
+            ss << "vkCreateRenderPass parameter, VK_ATTACHMENT_STORE_OP pCreateInfo->pColorStoreOps[" << i <<
                 "], is unrecognized (precondition).";
-            layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", ss.str().c_str());
+            layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", ss.str().c_str());
             continue;
         }
     }
 
     if(pCreateInfo->pColorLoadClearValues == nullptr)
     {
-        char const str[] = "xglCreateRenderPass parameter, XGL_CLEAR_COLOR* pCreateInfo->"\
+        char const str[] = "vkCreateRenderPass parameter, VK_CLEAR_COLOR* pCreateInfo->"\
             "pColorLoadClearValues, is nullptr (precondition).";
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
         return;
     }
    
     for(uint32_t i = 0; i < pCreateInfo->colorAttachmentCount; ++i)
     {
-        if(!xgl_validate_xgl_clear_color(&(pCreateInfo->pColorLoadClearValues[i])))
+        if(!vk_validate_vk_clear_color(&(pCreateInfo->pColorLoadClearValues[i])))
         {
             std::stringstream ss;
-            ss << "xglCreateRenderPass parameter, XGL_CLEAR_COLOR pCreateInfo->pColorLoadClearValues[" << i <<
+            ss << "vkCreateRenderPass parameter, VK_CLEAR_COLOR pCreateInfo->pColorLoadClearValues[" << i <<
                 "], is invalid (precondition).";
-            layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", ss.str().c_str());
+            layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", ss.str().c_str());
             continue;
         }
     }
 
-    if(!validate_XGL_FORMAT(pCreateInfo->depthStencilFormat))
+    if(!validate_VK_FORMAT(pCreateInfo->depthStencilFormat))
     {
-        char const str[] = "xglCreateRenderPass parameter, XGL_FORMAT pCreateInfo->"\
+        char const str[] = "vkCreateRenderPass parameter, VK_FORMAT pCreateInfo->"\
             "depthStencilFormat, is unrecognized (precondition).";
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
         return;
     }
 
-    XGL_FORMAT_PROPERTIES properties;
+    VK_FORMAT_PROPERTIES properties;
     size_t size = sizeof(properties);
-    XGL_RESULT result = nextTable.GetFormatInfo(device, pCreateInfo->depthStencilFormat,
-        XGL_INFO_TYPE_FORMAT_PROPERTIES, &size, &properties);
-    if(result != XGL_SUCCESS)
+    VK_RESULT result = nextTable.GetFormatInfo(device, pCreateInfo->depthStencilFormat,
+        VK_INFO_TYPE_FORMAT_PROPERTIES, &size, &properties);
+    if(result != VK_SUCCESS)
     {
-        char const str[] = "xglCreateRenderPass parameter, XGL_FORMAT pCreateInfo->"\
+        char const str[] = "vkCreateRenderPass parameter, VK_FORMAT pCreateInfo->"\
             "depthStencilFormat, cannot be validated (precondition).";
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
         return;
     }
 
     if((properties.linearTilingFeatures) == 0 && (properties.optimalTilingFeatures == 0))
     {
-        char const str[] = "xglCreateRenderPass parameter, XGL_FORMAT pCreateInfo->"\
+        char const str[] = "vkCreateRenderPass parameter, VK_FORMAT pCreateInfo->"\
             "depthStencilFormat, contains unsupported format (precondition).";
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
         return;
     }
 
-    if(!validate_XGL_IMAGE_LAYOUT(pCreateInfo->depthStencilLayout))
+    if(!validate_VK_IMAGE_LAYOUT(pCreateInfo->depthStencilLayout))
     {
-        char const str[] = "xglCreateRenderPass parameter, XGL_IMAGE_LAYOUT pCreateInfo->"\
+        char const str[] = "vkCreateRenderPass parameter, VK_IMAGE_LAYOUT pCreateInfo->"\
             "depthStencilLayout, is unrecognized (precondition).";
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
         return;
     }
 
-    if(!validate_XGL_ATTACHMENT_LOAD_OP(pCreateInfo->depthLoadOp))
+    if(!validate_VK_ATTACHMENT_LOAD_OP(pCreateInfo->depthLoadOp))
     {
-        char const str[] = "xglCreateRenderPass parameter, XGL_ATTACHMENT_LOAD_OP pCreateInfo->"\
+        char const str[] = "vkCreateRenderPass parameter, VK_ATTACHMENT_LOAD_OP pCreateInfo->"\
             "depthLoadOp, is unrecognized (precondition).";
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
         return;
     }
 
-    if(!validate_XGL_ATTACHMENT_STORE_OP(pCreateInfo->depthStoreOp))
+    if(!validate_VK_ATTACHMENT_STORE_OP(pCreateInfo->depthStoreOp))
     {
-        char const str[] = "xglCreateRenderPass parameter, XGL_ATTACHMENT_STORE_OP pCreateInfo->"\
+        char const str[] = "vkCreateRenderPass parameter, VK_ATTACHMENT_STORE_OP pCreateInfo->"\
             "depthStoreOp, is unrecognized (precondition).";
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
         return;
     }
 
-    if(!validate_XGL_ATTACHMENT_LOAD_OP(pCreateInfo->stencilLoadOp))
+    if(!validate_VK_ATTACHMENT_LOAD_OP(pCreateInfo->stencilLoadOp))
     {
-        char const str[] = "xglCreateRenderPass parameter, XGL_ATTACHMENT_LOAD_OP pCreateInfo->"\
+        char const str[] = "vkCreateRenderPass parameter, VK_ATTACHMENT_LOAD_OP pCreateInfo->"\
             "stencilLoadOp, is unrecognized (precondition).";
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
         return;
     }
 
-    if(!validate_XGL_ATTACHMENT_STORE_OP(pCreateInfo->stencilStoreOp))
+    if(!validate_VK_ATTACHMENT_STORE_OP(pCreateInfo->stencilStoreOp))
     {
-        char const str[] = "xglCreateRenderPass parameter, XGL_ATTACHMENT_STORE_OP pCreateInfo->"\
+        char const str[] = "vkCreateRenderPass parameter, VK_ATTACHMENT_STORE_OP pCreateInfo->"\
             "stencilStoreOp, is unrecognized (precondition).";
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
         return;
     }
 }
 
-void PostCreateRenderPass(XGL_RESULT result, XGL_RENDER_PASS* pRenderPass)
+void PostCreateRenderPass(VK_RESULT result, VK_RENDER_PASS* pRenderPass)
 {
-    if(result != XGL_SUCCESS)
+    if(result != VK_SUCCESS)
     {
-        // TODO: Spit out XGL_RESULT value.
-        char const str[] = "xglCreateRenderPass failed (postcondition).";
-        layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        // TODO: Spit out VK_RESULT value.
+        char const str[] = "vkCreateRenderPass failed (postcondition).";
+        layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
         return;
     }
 
     if(pRenderPass == nullptr)
     {
-        char const str[] = "xglCreateRenderPass parameter, XGL_RENDER_PASS* pRenderPass, is nullptr (postcondition).";
-        layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        char const str[] = "vkCreateRenderPass parameter, VK_RENDER_PASS* pRenderPass, is nullptr (postcondition).";
+        layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
         return;
     }
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateRenderPass(XGL_DEVICE device, const XGL_RENDER_PASS_CREATE_INFO* pCreateInfo, XGL_RENDER_PASS* pRenderPass)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateRenderPass(VK_DEVICE device, const VK_RENDER_PASS_CREATE_INFO* pCreateInfo, VK_RENDER_PASS* pRenderPass)
 {
     PreCreateRenderPass(device, pCreateInfo);
-    XGL_RESULT result = nextTable.CreateRenderPass(device, pCreateInfo, pRenderPass);
+    VK_RESULT result = nextTable.CreateRenderPass(device, pCreateInfo, pRenderPass);
     PostCreateRenderPass(result, pRenderPass);
     return result;
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdBeginRenderPass(XGL_CMD_BUFFER cmdBuffer, const XGL_RENDER_PASS_BEGIN* pRenderPassBegin)
+VK_LAYER_EXPORT void VKAPI vkCmdBeginRenderPass(VK_CMD_BUFFER cmdBuffer, const VK_RENDER_PASS_BEGIN* pRenderPassBegin)
 {
     char str[1024];
     if (!pRenderPassBegin) {
         sprintf(str, "Struct ptr parameter pRenderPassBegin to function CmdBeginRenderPass is NULL.");
-        layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
     }
-    else if (!xgl_validate_xgl_render_pass_begin(pRenderPassBegin)) {
+    else if (!vk_validate_vk_render_pass_begin(pRenderPassBegin)) {
         sprintf(str, "Parameter pRenderPassBegin to function CmdBeginRenderPass contains an invalid value.");
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
     }
     nextTable.CmdBeginRenderPass(cmdBuffer, pRenderPassBegin);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdEndRenderPass(XGL_CMD_BUFFER cmdBuffer, XGL_RENDER_PASS renderPass)
+VK_LAYER_EXPORT void VKAPI vkCmdEndRenderPass(VK_CMD_BUFFER cmdBuffer, VK_RENDER_PASS renderPass)
 {
 
     nextTable.CmdEndRenderPass(cmdBuffer, renderPass);
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDbgSetValidationLevel(XGL_DEVICE device, XGL_VALIDATION_LEVEL validationLevel)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkDbgSetValidationLevel(VK_DEVICE device, VK_VALIDATION_LEVEL validationLevel)
 {
     char str[1024];
-    if (!validate_XGL_VALIDATION_LEVEL(validationLevel)) {
+    if (!validate_VK_VALIDATION_LEVEL(validationLevel)) {
         sprintf(str, "Parameter validationLevel to function DbgSetValidationLevel has invalid value of %i.", (int)validationLevel);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
     }
-    XGL_RESULT result = nextTable.DbgSetValidationLevel(device, validationLevel);
+    VK_RESULT result = nextTable.DbgSetValidationLevel(device, validationLevel);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDbgRegisterMsgCallback(XGL_INSTANCE instance, XGL_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback, void* pUserData)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkDbgRegisterMsgCallback(VK_INSTANCE instance, VK_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback, void* pUserData)
 {
     // This layer intercepts callbacks
-    XGL_LAYER_DBG_FUNCTION_NODE *pNewDbgFuncNode = (XGL_LAYER_DBG_FUNCTION_NODE*)malloc(sizeof(XGL_LAYER_DBG_FUNCTION_NODE));
+    VK_LAYER_DBG_FUNCTION_NODE *pNewDbgFuncNode = (VK_LAYER_DBG_FUNCTION_NODE*)malloc(sizeof(VK_LAYER_DBG_FUNCTION_NODE));
     if (!pNewDbgFuncNode)
-        return XGL_ERROR_OUT_OF_MEMORY;
+        return VK_ERROR_OUT_OF_MEMORY;
     pNewDbgFuncNode->pfnMsgCallback = pfnMsgCallback;
     pNewDbgFuncNode->pUserData = pUserData;
     pNewDbgFuncNode->pNext = g_pDbgFunctionHead;
     g_pDbgFunctionHead = pNewDbgFuncNode;
     // force callbacks if DebugAction hasn't been set already other than initial value
     if (g_actionIsDefault) {
-        g_debugAction = XGL_DBG_LAYER_ACTION_CALLBACK;
+        g_debugAction = VK_DBG_LAYER_ACTION_CALLBACK;
     }
-    XGL_RESULT result = nextTable.DbgRegisterMsgCallback(instance, pfnMsgCallback, pUserData);
+    VK_RESULT result = nextTable.DbgRegisterMsgCallback(instance, pfnMsgCallback, pUserData);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDbgUnregisterMsgCallback(XGL_INSTANCE instance, XGL_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkDbgUnregisterMsgCallback(VK_INSTANCE instance, VK_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback)
 {
-    XGL_LAYER_DBG_FUNCTION_NODE *pTrav = g_pDbgFunctionHead;
-    XGL_LAYER_DBG_FUNCTION_NODE *pPrev = pTrav;
+    VK_LAYER_DBG_FUNCTION_NODE *pTrav = g_pDbgFunctionHead;
+    VK_LAYER_DBG_FUNCTION_NODE *pPrev = pTrav;
     while (pTrav) {
         if (pTrav->pfnMsgCallback == pfnMsgCallback) {
             pPrev->pNext = pTrav->pNext;
@@ -1880,49 +1881,49 @@
     if (g_pDbgFunctionHead == NULL)
     {
         if (g_actionIsDefault)
-            g_debugAction = XGL_DBG_LAYER_ACTION_LOG_MSG;
+            g_debugAction = VK_DBG_LAYER_ACTION_LOG_MSG;
         else
-            g_debugAction = (XGL_LAYER_DBG_ACTION)(g_debugAction & ~((uint32_t)XGL_DBG_LAYER_ACTION_CALLBACK));
+            g_debugAction = (VK_LAYER_DBG_ACTION)(g_debugAction & ~((uint32_t)VK_DBG_LAYER_ACTION_CALLBACK));
     }
-    XGL_RESULT result = nextTable.DbgUnregisterMsgCallback(instance, pfnMsgCallback);
+    VK_RESULT result = nextTable.DbgUnregisterMsgCallback(instance, pfnMsgCallback);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDbgSetMessageFilter(XGL_DEVICE device, int32_t msgCode, XGL_DBG_MSG_FILTER filter)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkDbgSetMessageFilter(VK_DEVICE device, int32_t msgCode, VK_DBG_MSG_FILTER filter)
 {
 
-    XGL_RESULT result = nextTable.DbgSetMessageFilter(device, msgCode, filter);
+    VK_RESULT result = nextTable.DbgSetMessageFilter(device, msgCode, filter);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDbgSetObjectTag(XGL_BASE_OBJECT object, size_t tagSize, const void* pTag)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkDbgSetObjectTag(VK_BASE_OBJECT object, size_t tagSize, const void* pTag)
 {
 
-    XGL_RESULT result = nextTable.DbgSetObjectTag(object, tagSize, pTag);
+    VK_RESULT result = nextTable.DbgSetObjectTag(object, tagSize, pTag);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDbgSetGlobalOption(XGL_INSTANCE instance, XGL_DBG_GLOBAL_OPTION dbgOption, size_t dataSize, const void* pData)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkDbgSetGlobalOption(VK_INSTANCE instance, VK_DBG_GLOBAL_OPTION dbgOption, size_t dataSize, const void* pData)
 {
 
-    XGL_RESULT result = nextTable.DbgSetGlobalOption(instance, dbgOption, dataSize, pData);
+    VK_RESULT result = nextTable.DbgSetGlobalOption(instance, dbgOption, dataSize, pData);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDbgSetDeviceOption(XGL_DEVICE device, XGL_DBG_DEVICE_OPTION dbgOption, size_t dataSize, const void* pData)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkDbgSetDeviceOption(VK_DEVICE device, VK_DBG_DEVICE_OPTION dbgOption, size_t dataSize, const void* pData)
 {
 
-    XGL_RESULT result = nextTable.DbgSetDeviceOption(device, dbgOption, dataSize, pData);
+    VK_RESULT result = nextTable.DbgSetDeviceOption(device, dbgOption, dataSize, pData);
     return result;
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdDbgMarkerBegin(XGL_CMD_BUFFER cmdBuffer, const char* pMarker)
+VK_LAYER_EXPORT void VKAPI vkCmdDbgMarkerBegin(VK_CMD_BUFFER cmdBuffer, const char* pMarker)
 {
 
     nextTable.CmdDbgMarkerBegin(cmdBuffer, pMarker);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdDbgMarkerEnd(XGL_CMD_BUFFER cmdBuffer)
+VK_LAYER_EXPORT void VKAPI vkCmdDbgMarkerEnd(VK_CMD_BUFFER cmdBuffer)
 {
 
     nextTable.CmdDbgMarkerEnd(cmdBuffer);
@@ -1930,43 +1931,43 @@
 
 #if defined(__linux__) || defined(XCB_NVIDIA)
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglWsiX11AssociateConnection(XGL_PHYSICAL_GPU gpu, const XGL_WSI_X11_CONNECTION_INFO* pConnectionInfo)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkWsiX11AssociateConnection(VK_PHYSICAL_GPU gpu, const VK_WSI_X11_CONNECTION_INFO* pConnectionInfo)
 {
-    XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) gpu;
+    VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
     pCurObj = gpuw;
     loader_platform_thread_once(&tabOnce, initParamChecker);
 
-    XGL_RESULT result = nextTable.WsiX11AssociateConnection((XGL_PHYSICAL_GPU)gpuw->nextObject, pConnectionInfo);
+    VK_RESULT result = nextTable.WsiX11AssociateConnection((VK_PHYSICAL_GPU)gpuw->nextObject, pConnectionInfo);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglWsiX11GetMSC(XGL_DEVICE device, xcb_window_t window, xcb_randr_crtc_t crtc, uint64_t* pMsc)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkWsiX11GetMSC(VK_DEVICE device, xcb_window_t window, xcb_randr_crtc_t crtc, uint64_t* pMsc)
 {
 
-    XGL_RESULT result = nextTable.WsiX11GetMSC(device, window, crtc, pMsc);
+    VK_RESULT result = nextTable.WsiX11GetMSC(device, window, crtc, pMsc);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglWsiX11CreatePresentableImage(XGL_DEVICE device, const XGL_WSI_X11_PRESENTABLE_IMAGE_CREATE_INFO* pCreateInfo, XGL_IMAGE* pImage, XGL_GPU_MEMORY* pMem)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkWsiX11CreatePresentableImage(VK_DEVICE device, const VK_WSI_X11_PRESENTABLE_IMAGE_CREATE_INFO* pCreateInfo, VK_IMAGE* pImage, VK_GPU_MEMORY* pMem)
 {
 
-    XGL_RESULT result = nextTable.WsiX11CreatePresentableImage(device, pCreateInfo, pImage, pMem);
+    VK_RESULT result = nextTable.WsiX11CreatePresentableImage(device, pCreateInfo, pImage, pMem);
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglWsiX11QueuePresent(XGL_QUEUE queue, const XGL_WSI_X11_PRESENT_INFO* pPresentInfo, XGL_FENCE fence)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkWsiX11QueuePresent(VK_QUEUE queue, const VK_WSI_X11_PRESENT_INFO* pPresentInfo, VK_FENCE fence)
 {
 
-    XGL_RESULT result = nextTable.WsiX11QueuePresent(queue, pPresentInfo, fence);
+    VK_RESULT result = nextTable.WsiX11QueuePresent(queue, pPresentInfo, fence);
     return result;
 }
 
 #endif
 
-#include "xgl_generic_intercept_proc_helper.h"
-XGL_LAYER_EXPORT void* XGLAPI xglGetProcAddr(XGL_PHYSICAL_GPU gpu, const char* funcName)
+#include "vk_generic_intercept_proc_helper.h"
+VK_LAYER_EXPORT void* VKAPI vkGetProcAddr(VK_PHYSICAL_GPU gpu, const char* funcName)
 {
-    XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) gpu;
+    VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
     void* addr;
     if (gpu == NULL)
         return NULL;
@@ -1979,7 +1980,7 @@
     else {
         if (gpuw->pGPA == NULL)
             return NULL;
-        return gpuw->pGPA((XGL_PHYSICAL_GPU)gpuw->nextObject, funcName);
+        return gpuw->pGPA((VK_PHYSICAL_GPU)gpuw->nextObject, funcName);
     }
 }
 
diff --git a/loader/CMakeLists.txt b/loader/CMakeLists.txt
index 2319511..ef8907b 100644
--- a/loader/CMakeLists.txt
+++ b/loader/CMakeLists.txt
@@ -21,7 +21,7 @@
 set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -DDEBUG")
 
 if (WIN32)
-    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DXGL_PROTOTYPES -D_CRT_SECURE_NO_WARNINGS -DXCB_NVIDIA")
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DVK_PROTOTYPES -D_CRT_SECURE_NO_WARNINGS -DXCB_NVIDIA")
 
     add_library(XGL SHARED loader.c loader.h dirent_on_windows.c dispatch.c table_ops.h XGL.def)
     set_target_properties(XGL PROPERTIES LINK_FLAGS "/DEF:${PROJECT_SOURCE_DIR}/loader/XGL.def")
@@ -30,7 +30,7 @@
     target_link_libraries(XGL)
 endif()
 if (NOT WIN32)
-    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DXGL_PROTOTYPES -Wpointer-arith")
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DVK_PROTOTYPES -Wpointer-arith")
 
     add_library(XGL SHARED loader.c dispatch.c table_ops.h)
     set_target_properties(XGL PROPERTIES SOVERSION 0)
diff --git a/loader/README.md b/loader/README.md
index b3b9fdf..a647928 100644
--- a/loader/README.md
+++ b/loader/README.md
@@ -1,8 +1,8 @@
 # Loader Description 
 
 ## Overview
-The Loader implements the main XGL library (e.g. "XGL.dll" on Windows and
-"libXGL.so" on Linux).  It handles layer management and driver management.  The
+The Loader implements the main VK library (e.g. "VK.dll" on Windows and
+"libVK.so" on Linux).  It handles layer management and driver management.  The
 loader fully supports multi-gpu operation.  As part of this, it dispatches API
 calls to the correct driver, and to the correct layers, based on the GPU object
 selected by the application.
@@ -20,43 +20,43 @@
 loader supports layers that operate on multiple GPUs.
 
 ## Environment Variables
-**LIBXGL\_DRIVERS\_PATH**  directory for loader to search for ICD driver libraries to open
+**LIBVK\_DRIVERS\_PATH**  directory for loader to search for ICD driver libraries to open
 
-**LIBXGL\_LAYERS\_PATH**   directory for loader to search for layer libraries that may get activated  and used at xglCreateDevice() time.
+**LIBVK\_LAYERS\_PATH**   directory for loader to search for layer libraries that may get activated  and used at vkCreateDevice() time.
 
-**LIBXGL\_LAYER\_NAMES**   colon-separated list of layer names to be activated (e.g., LIBXGL\_LAYER\_NAMES=MemTracker:DrawState).
+**LIBVK\_LAYER\_NAMES**   colon-separated list of layer names to be activated (e.g., LIBVK\_LAYER\_NAMES=MemTracker:DrawState).
 
-Note: Both of the LIBXGL\_*\_PATH variables may contain more than one directory.  Each directory must be separated by one of the following characters, depending on your OS:
+Note: Both of the LIBVK\_*\_PATH variables may contain more than one directory.  Each directory must be separated by one of the following characters, depending on your OS:
 
 - ";" on Windows
 - ":" on Linux
 
 ## Interface to driver (ICD)
-- xglEnumerateGpus exported
-- xglCreateInstance exported
-- xglDestroyInstance exported
-- xglGetProcAddr exported and returns valid function pointers for all the XGL API entrypoints
-- all objects created by ICD can be cast to (XGL\_LAYER\_DISPATCH\_TABLE \*\*)
+- vkEnumerateGpus exported
+- vkCreateInstance exported
+- vkDestroyInstance exported
+- vkGetProcAddr exported and returns valid function pointers for all the VK API entrypoints
+- all objects created by ICD can be cast to (VK\_LAYER\_DISPATCH\_TABLE \*\*)
  where the loader will replace the first entry with a pointer to the dispatch table which is
  owned by the loader. This implies three things for ICD drivers:
   1. The ICD must return a pointer for the opaque object handle
   2. This pointer points to a regular C structure with the first entry being a pointer.
-  Note: for any C++ ICD's that implement XGL objects directly as C++ classes.
+  Note: for any C++ ICD's that implement VK objects directly as C++ classes.
   The C++ compiler may put a vtable at offset zero, if your class is virtual.
   In this case use a regular C structure (see below).
   3. The reservedForLoader.loaderMagic member must be initialized with ICD\_LOADER\_MAGIC, as follows:
 
 ```
-  #include "xglIcd.h"
+  #include "vkIcd.h"
 
   struct {
-        XGL_LOADER_DATA reservedForLoader; // Reserve space for pointer to loader's dispatch table
+        VK_LOADER_DATA reservedForLoader; // Reserve space for pointer to loader's dispatch table
         myObjectClass myObj;               // Your driver's C++ class
-  } xglObj;
+  } vkObj;
 
-  xglObj alloc_icd_obj()
+  vkObj alloc_icd_obj()
   {
-      xglObj *newObj = alloc_obj();
+      vkObj *newObj = alloc_obj();
       ...
       // Initialize pointer to loader's dispatch table with ICD_LOADER_MAGIC
       set_loader_magic_value(newObj);
@@ -68,5 +68,5 @@
 Additional Notes:
 
 - The ICD may or may not implement a dispatch table.
-- ICD entrypoints can be named anything including the offcial xgl name such as xglCreateDevice().  However, beware of interposing by dynamic OS library loaders if the offical names are used.  On Linux, if offical names are used, the ICD library must be linked with -Bsymbolic.
+- ICD entrypoints can be named anything including the offcial vk name such as vkCreateDevice().  However, beware of interposing by dynamic OS library loaders if the offical names are used.  On Linux, if offical names are used, the ICD library must be linked with -Bsymbolic.
 
diff --git a/loader/loader.c b/loader/loader.c
index 7ea486a..60c5f21 100644
--- a/loader/loader.c
+++ b/loader/loader.c
@@ -1,5 +1,5 @@
 /*
- * XGL
+ * Vulkan
  *
  * Copyright (C) 2014 LunarG, Inc.
  *
@@ -43,7 +43,7 @@
 #include "loader_platform.h"
 #include "table_ops.h"
 #include "loader.h"
-#include "xglIcd.h"
+#include "vkIcd.h"
 // The following is #included again to catch certain OS-specific functions
 // being used:
 #include "loader_platform.h"
@@ -66,12 +66,12 @@
 struct loader_icd {
     const struct loader_scanned_icds *scanned_icds;
 
-    XGL_LAYER_DISPATCH_TABLE *loader_dispatch;
-    uint32_t layer_count[XGL_MAX_PHYSICAL_GPUS];
-    struct loader_layers layer_libs[XGL_MAX_PHYSICAL_GPUS][MAX_LAYER_LIBRARIES];
-    XGL_BASE_LAYER_OBJECT *wrappedGpus[XGL_MAX_PHYSICAL_GPUS];
+    VK_LAYER_DISPATCH_TABLE *loader_dispatch;
+    uint32_t layer_count[VK_MAX_PHYSICAL_GPUS];
+    struct loader_layers layer_libs[VK_MAX_PHYSICAL_GPUS][MAX_LAYER_LIBRARIES];
+    VK_BASE_LAYER_OBJECT *wrappedGpus[VK_MAX_PHYSICAL_GPUS];
     uint32_t gpu_count;
-    XGL_BASE_LAYER_OBJECT *gpus;
+    VK_BASE_LAYER_OBJECT *gpus;
 
     struct loader_icd *next;
 };
@@ -79,12 +79,12 @@
 
 struct loader_scanned_icds {
     loader_platform_dl_handle handle;
-    xglGetProcAddrType GetProcAddr;
-    xglCreateInstanceType CreateInstance;
-    xglDestroyInstanceType DestroyInstance;
-    xglEnumerateGpusType EnumerateGpus;
-    xglGetExtensionSupportType GetExtensionSupport;
-    XGL_INSTANCE instance;
+    vkGetProcAddrType GetProcAddr;
+    vkCreateInstanceType CreateInstance;
+    vkDestroyInstanceType DestroyInstance;
+    vkEnumerateGpusType EnumerateGpus;
+    vkGetExtensionSupportType GetExtensionSupport;
+    VK_INSTANCE instance;
     struct loader_scanned_icds *next;
 };
 
@@ -166,7 +166,7 @@
     size_t rtn_len;
 
     registry_str = loader_get_registry_string(HKEY_LOCAL_MACHINE,
-                                              "Software\\XGL",
+                                              "Software\\VK",
                                               registry_value);
     registry_len = (registry_str) ? strlen(registry_str) : 0;
 
@@ -203,7 +203,7 @@
 #endif // WIN32
 
 
-static void loader_log(XGL_DBG_MSG_TYPE msg_type, int32_t msg_code,
+static void loader_log(VK_DBG_MSG_TYPE msg_type, int32_t msg_code,
                        const char *format, ...)
 {
     char msg[256];
@@ -269,14 +269,14 @@
     // Used to call: dlopen(filename, RTLD_LAZY);
     handle = loader_platform_open_library(filename);
     if (!handle) {
-        loader_log(XGL_DBG_MSG_WARNING, 0, loader_platform_open_library_error(filename));
+        loader_log(VK_DBG_MSG_WARNING, 0, loader_platform_open_library_error(filename));
         return;
     }
 
 #define LOOKUP(func_ptr, func) do {                            \
-    func_ptr = (xgl ##func## Type) loader_platform_get_proc_address(handle, "xgl" #func); \
+    func_ptr = (vk ##func## Type) loader_platform_get_proc_address(handle, "vk" #func); \
     if (!func_ptr) {                                           \
-        loader_log(XGL_DBG_MSG_WARNING, 0, loader_platform_get_proc_address_error("xgl" #func)); \
+        loader_log(VK_DBG_MSG_WARNING, 0, loader_platform_get_proc_address_error("vk" #func)); \
         return;                                                \
     }                                                          \
 } while (0)
@@ -290,7 +290,7 @@
 
     new_node = (struct loader_scanned_icds *) malloc(sizeof(struct loader_scanned_icds));
     if (!new_node) {
-        loader_log(XGL_DBG_MSG_WARNING, 0, "Out of memory can't add icd");
+        loader_log(VK_DBG_MSG_WARNING, 0, "Out of memory can't add icd");
         return;
     }
 
@@ -306,11 +306,11 @@
 
 
 /**
- * Try to \c loader_icd_scan XGL driver(s).
+ * Try to \c loader_icd_scan VK driver(s).
  *
  * This function scans the default system path or path
- * specified by the \c LIBXGL_DRIVERS_PATH environment variable in
- * order to find loadable XGL ICDs with the name of libXGL_*.
+ * specified by the \c LIBVK_DRIVERS_PATH environment variable in
+ * order to find loadable VK ICDs with the name of libVK_*.
  *
  * \returns
  * void; but side effect is to set loader_icd_scanned to true
@@ -332,7 +332,7 @@
         must_free_libPaths = true;
     } else {
         must_free_libPaths = false;
-        libPaths = DEFAULT_XGL_DRIVERS_PATH;
+        libPaths = DEFAULT_VK_DRIVERS_PATH;
     }
 #else  // WIN32
     if (geteuid() == getuid()) {
@@ -340,7 +340,7 @@
         libPaths = getenv(DRIVER_PATH_ENV);
     }
     if (libPaths == NULL) {
-        libPaths = DEFAULT_XGL_DRIVERS_PATH;
+        libPaths = DEFAULT_VK_DRIVERS_PATH;
     }
 #endif // WIN32
 
@@ -363,18 +363,18 @@
        if (sysdir) {
           dent = readdir(sysdir);
           while (dent) {
-             /* Look for ICDs starting with XGL_DRIVER_LIBRARY_PREFIX and
-              * ending with XGL_LIBRARY_SUFFIX
+             /* Look for ICDs starting with VK_DRIVER_LIBRARY_PREFIX and
+              * ending with VK_LIBRARY_SUFFIX
               */
               if (!strncmp(dent->d_name,
-                          XGL_DRIVER_LIBRARY_PREFIX,
-                          XGL_DRIVER_LIBRARY_PREFIX_LEN)) {
+                          VK_DRIVER_LIBRARY_PREFIX,
+                          VK_DRIVER_LIBRARY_PREFIX_LEN)) {
                  uint32_t nlen = (uint32_t) strlen(dent->d_name);
-                 const char *suf = dent->d_name + nlen - XGL_LIBRARY_SUFFIX_LEN;
-                 if ((nlen > XGL_LIBRARY_SUFFIX_LEN) &&
+                 const char *suf = dent->d_name + nlen - VK_LIBRARY_SUFFIX_LEN;
+                 if ((nlen > VK_LIBRARY_SUFFIX_LEN) &&
                      !strncmp(suf,
-                              XGL_LIBRARY_SUFFIX,
-                              XGL_LIBRARY_SUFFIX_LEN)) {
+                              VK_LIBRARY_SUFFIX,
+                              VK_LIBRARY_SUFFIX_LEN)) {
                     snprintf(icd_library, 1024, "%s" DIRECTORY_SYMBOL "%s", p,dent->d_name);
                     loader_scanned_icd_add(icd_library);
                  }
@@ -415,7 +415,7 @@
         must_free_libPaths = true;
     } else {
         must_free_libPaths = false;
-        libPaths = DEFAULT_XGL_LAYERS_PATH;
+        libPaths = DEFAULT_VK_LAYERS_PATH;
     }
 #else  // WIN32
     if (geteuid() == getuid()) {
@@ -423,7 +423,7 @@
         libPaths = getenv(LAYERS_PATH_ENV);
     }
     if (libPaths == NULL) {
-        libPaths = DEFAULT_XGL_LAYERS_PATH;
+        libPaths = DEFAULT_VK_LAYERS_PATH;
     }
 #endif // WIN32
 
@@ -473,18 +473,18 @@
        if (curdir) {
           dent = readdir(curdir);
           while (dent) {
-             /* Look for layers starting with XGL_LAYER_LIBRARY_PREFIX and
-              * ending with XGL_LIBRARY_SUFFIX
+             /* Look for layers starting with VK_LAYER_LIBRARY_PREFIX and
+              * ending with VK_LIBRARY_SUFFIX
               */
               if (!strncmp(dent->d_name,
-                          XGL_LAYER_LIBRARY_PREFIX,
-                          XGL_LAYER_LIBRARY_PREFIX_LEN)) {
+                          VK_LAYER_LIBRARY_PREFIX,
+                          VK_LAYER_LIBRARY_PREFIX_LEN)) {
                  uint32_t nlen = (uint32_t) strlen(dent->d_name);
-                 const char *suf = dent->d_name + nlen - XGL_LIBRARY_SUFFIX_LEN;
-                 if ((nlen > XGL_LIBRARY_SUFFIX_LEN) &&
+                 const char *suf = dent->d_name + nlen - VK_LIBRARY_SUFFIX_LEN;
+                 if ((nlen > VK_LIBRARY_SUFFIX_LEN) &&
                      !strncmp(suf,
-                              XGL_LIBRARY_SUFFIX,
-                              XGL_LIBRARY_SUFFIX_LEN)) {
+                              VK_LIBRARY_SUFFIX,
+                              VK_LIBRARY_SUFFIX_LEN)) {
                      loader_platform_dl_handle handle;
                      snprintf(temp_str, sizeof(temp_str), "%s" DIRECTORY_SYMBOL "%s",p,dent->d_name);
                      // Used to call: dlopen(temp_str, RTLD_LAZY)
@@ -493,11 +493,11 @@
                          continue;
                      }
                      if (loader.scanned_layer_count == MAX_LAYER_LIBRARIES) {
-                         loader_log(XGL_DBG_MSG_ERROR, 0, "%s ignored: max layer libraries exceed", temp_str);
+                         loader_log(VK_DBG_MSG_ERROR, 0, "%s ignored: max layer libraries exceed", temp_str);
                          break;
                      }
                      if ((loader.scanned_layer_names[loader.scanned_layer_count] = malloc(strlen(temp_str) + 1)) == NULL) {
-                         loader_log(XGL_DBG_MSG_ERROR, 0, "%s ignored: out of memory", temp_str);
+                         loader_log(VK_DBG_MSG_ERROR, 0, "%s ignored: out of memory", temp_str);
                          break;
                      }
                      strcpy(loader.scanned_layer_names[loader.scanned_layer_count], temp_str);
@@ -515,15 +515,15 @@
     loader.layer_scanned = true;
 }
 
-static void loader_init_dispatch_table(XGL_LAYER_DISPATCH_TABLE *tab, xglGetProcAddrType fpGPA, XGL_PHYSICAL_GPU gpu)
+static void loader_init_dispatch_table(VK_LAYER_DISPATCH_TABLE *tab, vkGetProcAddrType fpGPA, VK_PHYSICAL_GPU gpu)
 {
     loader_initialize_dispatch_table(tab, fpGPA, gpu);
 
     if (tab->EnumerateLayers == NULL)
-        tab->EnumerateLayers = xglEnumerateLayers;
+        tab->EnumerateLayers = vkEnumerateLayers;
 }
 
-static struct loader_icd * loader_get_icd(const XGL_BASE_LAYER_OBJECT *gpu, uint32_t *gpu_index)
+static struct loader_icd * loader_get_icd(const VK_BASE_LAYER_OBJECT *gpu, uint32_t *gpu_index)
 {
     for (struct loader_instance *inst = loader.instances; inst; inst = inst->next) {
         for (struct loader_icd *icd = inst->icds; icd; icd = icd->next) {
@@ -567,10 +567,10 @@
             obj->name[sizeof(obj->name) - 1] = '\0';
             // Used to call: dlopen(pLayerNames[i].lib_name, RTLD_LAZY | RTLD_DEEPBIND)
             if ((obj->lib_handle = loader_platform_open_library(pLayerNames[i].lib_name)) == NULL) {
-                loader_log(XGL_DBG_MSG_ERROR, 0, loader_platform_open_library_error(pLayerNames[i].lib_name));
+                loader_log(VK_DBG_MSG_ERROR, 0, loader_platform_open_library_error(pLayerNames[i].lib_name));
                 continue;
             } else {
-                loader_log(XGL_DBG_MSG_UNKNOWN, 0, "Inserting layer %s from library %s", pLayerNames[i].layer_name, pLayerNames[i].lib_name);
+                loader_log(VK_DBG_MSG_UNKNOWN, 0, "Inserting layer %s from library %s", pLayerNames[i].layer_name, pLayerNames[i].lib_name);
             }
             free(pLayerNames[i].layer_name);
             icd->layer_count[gpu_index]++;
@@ -578,30 +578,30 @@
     }
 }
 
-static XGL_RESULT find_layer_extension(struct loader_icd *icd, uint32_t gpu_index, const char *pExtName, const char **lib_name)
+static VK_RESULT find_layer_extension(struct loader_icd *icd, uint32_t gpu_index, const char *pExtName, const char **lib_name)
 {
-    XGL_RESULT err;
+    VK_RESULT err;
     char *search_name;
     loader_platform_dl_handle handle;
-    xglGetExtensionSupportType fpGetExtensionSupport;
+    vkGetExtensionSupportType fpGetExtensionSupport;
 
     /*
      * The loader provides the abstraction that make layers and extensions work via
      * the currently defined extension mechanism. That is, when app queries for an extension
-     * via xglGetExtensionSupport, the loader will call both the driver as well as any layers
+     * via vkGetExtensionSupport, the loader will call both the driver as well as any layers
      * to see who implements that extension. Then, if the app enables the extension during
-     * xglCreateDevice the loader will find and load any layers that implement that extension.
+     * vkCreateDevice the loader will find and load any layers that implement that extension.
      */
 
     // TODO: What if extension is in multiple places?
 
     // TODO: Who should we ask first? Driver or layers? Do driver for now.
-    err = icd->scanned_icds[gpu_index].GetExtensionSupport((XGL_PHYSICAL_GPU) (icd->gpus[gpu_index].nextObject), pExtName);
-    if (err == XGL_SUCCESS) {
+    err = icd->scanned_icds[gpu_index].GetExtensionSupport((VK_PHYSICAL_GPU) (icd->gpus[gpu_index].nextObject), pExtName);
+    if (err == VK_SUCCESS) {
         if (lib_name) {
             *lib_name = NULL;
         }
-        return XGL_SUCCESS;
+        return VK_SUCCESS;
     }
 
     for (unsigned int j = 0; j < loader.scanned_layer_count; j++) {
@@ -610,19 +610,19 @@
         if ((handle = loader_platform_open_library(search_name)) == NULL)
             continue;
 
-        fpGetExtensionSupport = loader_platform_get_proc_address(handle, "xglGetExtensionSupport");
+        fpGetExtensionSupport = loader_platform_get_proc_address(handle, "vkGetExtensionSupport");
 
         if (fpGetExtensionSupport != NULL) {
             // Found layer's GetExtensionSupport call
-            err = fpGetExtensionSupport((XGL_PHYSICAL_GPU) (icd->gpus + gpu_index), pExtName);
+            err = fpGetExtensionSupport((VK_PHYSICAL_GPU) (icd->gpus + gpu_index), pExtName);
 
             loader_platform_close_library(handle);
 
-            if (err == XGL_SUCCESS) {
+            if (err == VK_SUCCESS) {
                 if (lib_name) {
                     *lib_name = loader.scanned_layer_names[j];
                 }
-                return XGL_SUCCESS;
+                return VK_SUCCESS;
             }
         } else {
             loader_platform_close_library(handle);
@@ -630,12 +630,12 @@
 
         // No GetExtensionSupport or GetExtensionSupport returned invalid extension
         // for the layer, so test the layer name as if it is an extension name
-        // use default layer name based on library name XGL_LAYER_LIBRARY_PREFIX<name>.XGL_LIBRARY_SUFFIX
+        // use default layer name based on library name VK_LAYER_LIBRARY_PREFIX<name>.VK_LIBRARY_SUFFIX
         char *pEnd;
         size_t siz;
 
         search_name = basename(search_name);
-        search_name += strlen(XGL_LAYER_LIBRARY_PREFIX);
+        search_name += strlen(VK_LAYER_LIBRARY_PREFIX);
         pEnd = strrchr(search_name, '.');
         siz = (int) (pEnd - search_name);
         if (siz != strlen(pExtName))
@@ -645,10 +645,10 @@
             if (lib_name) {
                 *lib_name = loader.scanned_layer_names[j];
             }
-            return XGL_SUCCESS;
+            return VK_SUCCESS;
         }
     }
-    return XGL_ERROR_INVALID_EXTENSION;
+    return VK_ERROR_INVALID_EXTENSION;
 }
 
 static uint32_t loader_get_layer_env(struct loader_icd *icd, uint32_t gpu_index, struct layer_name_pair *pLayerNames)
@@ -691,7 +691,7 @@
             next++;
         }
         name = basename(p);
-        if (find_layer_extension(icd, gpu_index, name, &lib_name) != XGL_SUCCESS) {
+        if (find_layer_extension(icd, gpu_index, name, &lib_name) != VK_SUCCESS) {
             p = next;
             continue;
         }
@@ -714,7 +714,7 @@
     return count;
 }
 
-static uint32_t loader_get_layer_libs(struct loader_icd *icd, uint32_t gpu_index, const XGL_DEVICE_CREATE_INFO* pCreateInfo, struct layer_name_pair **ppLayerNames)
+static uint32_t loader_get_layer_libs(struct loader_icd *icd, uint32_t gpu_index, const VK_DEVICE_CREATE_INFO* pCreateInfo, struct layer_name_pair **ppLayerNames)
 {
     static struct layer_name_pair layerNames[MAX_LAYER_LIBRARIES];
     const char *lib_name = NULL;
@@ -727,7 +727,7 @@
     for (uint32_t i = 0; i < pCreateInfo->extensionCount; i++) {
         const char *pExtName = pCreateInfo->ppEnabledExtensionNames[i];
 
-        if (find_layer_extension(icd, gpu_index, pExtName, &lib_name) == XGL_SUCCESS) {
+        if (find_layer_extension(icd, gpu_index, pExtName, &lib_name) == VK_SUCCESS) {
             uint32_t len;
 
             /*
@@ -788,31 +788,31 @@
     }
 }
 
-extern uint32_t loader_activate_layers(XGL_PHYSICAL_GPU gpu, const XGL_DEVICE_CREATE_INFO* pCreateInfo)
+extern uint32_t loader_activate_layers(VK_PHYSICAL_GPU gpu, const VK_DEVICE_CREATE_INFO* pCreateInfo)
 {
     uint32_t gpu_index;
     uint32_t count;
     struct layer_name_pair *pLayerNames;
-    struct loader_icd *icd = loader_get_icd((const XGL_BASE_LAYER_OBJECT *) gpu, &gpu_index);
+    struct loader_icd *icd = loader_get_icd((const VK_BASE_LAYER_OBJECT *) gpu, &gpu_index);
 
     if (!icd)
         return 0;
-    assert(gpu_index < XGL_MAX_PHYSICAL_GPUS);
+    assert(gpu_index < VK_MAX_PHYSICAL_GPUS);
 
     /* activate any layer libraries */
     if (!loader_layers_activated(icd, gpu_index)) {
-        XGL_BASE_LAYER_OBJECT *gpuObj = (XGL_BASE_LAYER_OBJECT *) gpu;
-        XGL_BASE_LAYER_OBJECT *nextGpuObj, *baseObj = gpuObj->baseObject;
-        xglGetProcAddrType nextGPA = xglGetProcAddr;
+        VK_BASE_LAYER_OBJECT *gpuObj = (VK_BASE_LAYER_OBJECT *) gpu;
+        VK_BASE_LAYER_OBJECT *nextGpuObj, *baseObj = gpuObj->baseObject;
+        vkGetProcAddrType nextGPA = vkGetProcAddr;
 
         count = loader_get_layer_libs(icd, gpu_index, pCreateInfo, &pLayerNames);
         if (!count)
             return 0;
         loader_init_layer_libs(icd, gpu_index, pLayerNames, count);
 
-        icd->wrappedGpus[gpu_index] = malloc(sizeof(XGL_BASE_LAYER_OBJECT) * icd->layer_count[gpu_index]);
+        icd->wrappedGpus[gpu_index] = malloc(sizeof(VK_BASE_LAYER_OBJECT) * icd->layer_count[gpu_index]);
         if (! icd->wrappedGpus[gpu_index])
-                loader_log(XGL_DBG_MSG_ERROR, 0, "Failed to malloc Gpu objects for layer");
+                loader_log(VK_DBG_MSG_ERROR, 0, "Failed to malloc Gpu objects for layer");
         for (int32_t i = icd->layer_count[gpu_index] - 1; i >= 0; i--) {
             nextGpuObj = (icd->wrappedGpus[gpu_index] + i);
             nextGpuObj->pGPA = nextGPA;
@@ -822,18 +822,18 @@
 
             char funcStr[256];
             snprintf(funcStr, 256, "%sGetProcAddr",icd->layer_libs[gpu_index][i].name);
-            if ((nextGPA = (xglGetProcAddrType) loader_platform_get_proc_address(icd->layer_libs[gpu_index][i].lib_handle, funcStr)) == NULL)
-                nextGPA = (xglGetProcAddrType) loader_platform_get_proc_address(icd->layer_libs[gpu_index][i].lib_handle, "xglGetProcAddr");
+            if ((nextGPA = (vkGetProcAddrType) loader_platform_get_proc_address(icd->layer_libs[gpu_index][i].lib_handle, funcStr)) == NULL)
+                nextGPA = (vkGetProcAddrType) loader_platform_get_proc_address(icd->layer_libs[gpu_index][i].lib_handle, "vkGetProcAddr");
             if (!nextGPA) {
-                loader_log(XGL_DBG_MSG_ERROR, 0, "Failed to find xglGetProcAddr in layer %s", icd->layer_libs[gpu_index][i].name);
+                loader_log(VK_DBG_MSG_ERROR, 0, "Failed to find vkGetProcAddr in layer %s", icd->layer_libs[gpu_index][i].name);
                 continue;
             }
 
             if (i == 0) {
                 loader_init_dispatch_table(icd->loader_dispatch + gpu_index, nextGPA, gpuObj);
                 //Insert the new wrapped objects into the list with loader object at head
-                ((XGL_BASE_LAYER_OBJECT *) gpu)->nextObject = gpuObj;
-                ((XGL_BASE_LAYER_OBJECT *) gpu)->pGPA = nextGPA;
+                ((VK_BASE_LAYER_OBJECT *) gpu)->nextObject = gpuObj;
+                ((VK_BASE_LAYER_OBJECT *) gpu)->pGPA = nextGPA;
                 gpuObj = icd->wrappedGpus[gpu_index] + icd->layer_count[gpu_index] - 1;
                 gpuObj->nextObject = baseObj;
                 gpuObj->pGPA = icd->scanned_icds->GetProcAddr;
@@ -846,27 +846,27 @@
         count = loader_get_layer_libs(icd, gpu_index, pCreateInfo, &pLayerNames);
         for (uint32_t i = 0; i < count; i++) {
             if (strcmp(icd->layer_libs[gpu_index][i].name, pLayerNames[i].layer_name)) {
-                loader_log(XGL_DBG_MSG_ERROR, 0, "Layers activated != Layers requested");
+                loader_log(VK_DBG_MSG_ERROR, 0, "Layers activated != Layers requested");
                 break;
             }
         }
         if (count != icd->layer_count[gpu_index]) {
-            loader_log(XGL_DBG_MSG_ERROR, 0, "Number of Layers activated != number requested");
+            loader_log(VK_DBG_MSG_ERROR, 0, "Number of Layers activated != number requested");
         }
     }
     return icd->layer_count[gpu_index];
 }
 
-LOADER_EXPORT XGL_RESULT XGLAPI xglCreateInstance(
-        const XGL_INSTANCE_CREATE_INFO*         pCreateInfo,
-        XGL_INSTANCE*                           pInstance)
+LOADER_EXPORT VK_RESULT VKAPI vkCreateInstance(
+        const VK_INSTANCE_CREATE_INFO*         pCreateInfo,
+        VK_INSTANCE*                           pInstance)
 {
     static LOADER_PLATFORM_THREAD_ONCE_DECLARATION(once_icd);
     static LOADER_PLATFORM_THREAD_ONCE_DECLARATION(once_layer);
     struct loader_instance *ptr_instance = NULL;
     struct loader_scanned_icds *scanned_icds;
     struct loader_icd *icd;
-    XGL_RESULT res = XGL_ERROR_INITIALIZATION_FAILED;
+    VK_RESULT res = VK_ERROR_INITIALIZATION_FAILED;
 
     /* Scan/discover all ICD libraries in a single-threaded manner */
     loader_platform_thread_once(&once_icd, loader_icd_scan);
@@ -876,7 +876,7 @@
 
     ptr_instance = (struct loader_instance*) malloc(sizeof(struct loader_instance));
     if (ptr_instance == NULL) {
-        return XGL_ERROR_OUT_OF_MEMORY;
+        return VK_ERROR_OUT_OF_MEMORY;
     }
     memset(ptr_instance, 0, sizeof(struct loader_instance));
 
@@ -889,12 +889,12 @@
         if (icd) {
             res = scanned_icds->CreateInstance(pCreateInfo,
                                            &(scanned_icds->instance));
-            if (res != XGL_SUCCESS)
+            if (res != VK_SUCCESS)
             {
                 ptr_instance->icds = ptr_instance->icds->next;
                 loader_icd_destroy(icd);
                 scanned_icds->instance = NULL;
-                loader_log(XGL_DBG_MSG_WARNING, 0,
+                loader_log(VK_DBG_MSG_WARNING, 0,
                         "ICD ignored: failed to CreateInstance on device");
             }
         }
@@ -902,19 +902,19 @@
     }
 
     if (ptr_instance->icds == NULL) {
-        return XGL_ERROR_INCOMPATIBLE_DRIVER;
+        return VK_ERROR_INCOMPATIBLE_DRIVER;
     }
 
-    *pInstance = (XGL_INSTANCE) ptr_instance;
-    return XGL_SUCCESS;
+    *pInstance = (VK_INSTANCE) ptr_instance;
+    return VK_SUCCESS;
 }
 
-LOADER_EXPORT XGL_RESULT XGLAPI xglDestroyInstance(
-        XGL_INSTANCE                                instance)
+LOADER_EXPORT VK_RESULT VKAPI vkDestroyInstance(
+        VK_INSTANCE                                instance)
 {
     struct loader_instance *ptr_instance = (struct loader_instance *) instance;
     struct loader_scanned_icds *scanned_icds;
-    XGL_RESULT res;
+    VK_RESULT res;
 
     // Remove this instance from the list of instances:
     struct loader_instance *prev = NULL;
@@ -933,7 +933,7 @@
     }
     if (next  == NULL) {
         // This must be an invalid instance handle or empty list
-        return XGL_ERROR_INVALID_HANDLE;
+        return VK_ERROR_INVALID_HANDLE;
     }
 
     // cleanup any prior layer initializations
@@ -943,8 +943,8 @@
     while (scanned_icds) {
         if (scanned_icds->instance)
             res = scanned_icds->DestroyInstance(scanned_icds->instance);
-        if (res != XGL_SUCCESS)
-            loader_log(XGL_DBG_MSG_WARNING, 0,
+        if (res != VK_SUCCESS)
+            loader_log(VK_DBG_MSG_WARNING, 0,
                         "ICD ignored: failed to DestroyInstance on device");
         scanned_icds->instance = NULL;
         scanned_icds = scanned_icds->next;
@@ -952,43 +952,43 @@
 
     free(ptr_instance);
 
-    return XGL_SUCCESS;
+    return VK_SUCCESS;
 }
 
-LOADER_EXPORT XGL_RESULT XGLAPI xglEnumerateGpus(
+LOADER_EXPORT VK_RESULT VKAPI vkEnumerateGpus(
 
-        XGL_INSTANCE                                instance,
+        VK_INSTANCE                                instance,
         uint32_t                                    maxGpus,
         uint32_t*                                   pGpuCount,
-        XGL_PHYSICAL_GPU*                           pGpus)
+        VK_PHYSICAL_GPU*                           pGpus)
 {
     struct loader_instance *ptr_instance = (struct loader_instance *) instance;
     struct loader_icd *icd;
     uint32_t count = 0;
-    XGL_RESULT res;
+    VK_RESULT res;
 
-    //in spirit of XGL don't error check on the instance parameter
+    //in spirit of VK don't error check on the instance parameter
     icd = ptr_instance->icds;
     while (icd) {
-        XGL_PHYSICAL_GPU gpus[XGL_MAX_PHYSICAL_GPUS];
-        XGL_BASE_LAYER_OBJECT * wrapped_gpus;
-        xglGetProcAddrType get_proc_addr = icd->scanned_icds->GetProcAddr;
+        VK_PHYSICAL_GPU gpus[VK_MAX_PHYSICAL_GPUS];
+        VK_BASE_LAYER_OBJECT * wrapped_gpus;
+        vkGetProcAddrType get_proc_addr = icd->scanned_icds->GetProcAddr;
         uint32_t n, max = maxGpus - count;
 
-        if (max > XGL_MAX_PHYSICAL_GPUS) {
-            max = XGL_MAX_PHYSICAL_GPUS;
+        if (max > VK_MAX_PHYSICAL_GPUS) {
+            max = VK_MAX_PHYSICAL_GPUS;
         }
 
         res = icd->scanned_icds->EnumerateGpus(icd->scanned_icds->instance,
                                                max, &n,
                                                gpus);
-        if (res == XGL_SUCCESS && n) {
-            wrapped_gpus = (XGL_BASE_LAYER_OBJECT*) malloc(n *
-                                        sizeof(XGL_BASE_LAYER_OBJECT));
+        if (res == VK_SUCCESS && n) {
+            wrapped_gpus = (VK_BASE_LAYER_OBJECT*) malloc(n *
+                                        sizeof(VK_BASE_LAYER_OBJECT));
             icd->gpus = wrapped_gpus;
             icd->gpu_count = n;
-            icd->loader_dispatch = (XGL_LAYER_DISPATCH_TABLE *) malloc(n *
-                                        sizeof(XGL_LAYER_DISPATCH_TABLE));
+            icd->loader_dispatch = (VK_LAYER_DISPATCH_TABLE *) malloc(n *
+                                        sizeof(VK_LAYER_DISPATCH_TABLE));
             for (unsigned int i = 0; i < n; i++) {
                 (wrapped_gpus + i)->baseObject = gpus[i];
                 (wrapped_gpus + i)->pGPA = get_proc_addr;
@@ -999,13 +999,13 @@
 
                 /* Verify ICD compatibility */
                 if (!valid_loader_magic_value(gpus[i])) {
-                    loader_log(XGL_DBG_MSG_WARNING, 0,
+                    loader_log(VK_DBG_MSG_WARNING, 0,
                             "Loader: Incompatible ICD, first dword must be initialized to ICD_LOADER_MAGIC. See loader/README.md for details.\n");
                     assert(0);
                 }
 
-                const XGL_LAYER_DISPATCH_TABLE **disp;
-                disp = (const XGL_LAYER_DISPATCH_TABLE **) gpus[i];
+                const VK_LAYER_DISPATCH_TABLE **disp;
+                disp = (const VK_LAYER_DISPATCH_TABLE **) gpus[i];
                 *disp = icd->loader_dispatch + i;
             }
 
@@ -1021,16 +1021,16 @@
 
     *pGpuCount = count;
 
-    return (count > 0) ? XGL_SUCCESS : res;
+    return (count > 0) ? VK_SUCCESS : res;
 }
 
-LOADER_EXPORT void * XGLAPI xglGetProcAddr(XGL_PHYSICAL_GPU gpu, const char * pName)
+LOADER_EXPORT void * VKAPI vkGetProcAddr(VK_PHYSICAL_GPU gpu, const char * pName)
 {
     if (gpu == NULL) {
         return NULL;
     }
-    XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) gpu;
-    XGL_LAYER_DISPATCH_TABLE * disp_table = * (XGL_LAYER_DISPATCH_TABLE **) gpuw->baseObject;
+    VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
+    VK_LAYER_DISPATCH_TABLE * disp_table = * (VK_LAYER_DISPATCH_TABLE **) gpuw->baseObject;
     void *addr;
 
     if (disp_table == NULL)
@@ -1046,33 +1046,33 @@
     }
 }
 
-LOADER_EXPORT XGL_RESULT XGLAPI xglGetExtensionSupport(XGL_PHYSICAL_GPU gpu, const char *pExtName)
+LOADER_EXPORT VK_RESULT VKAPI vkGetExtensionSupport(VK_PHYSICAL_GPU gpu, const char *pExtName)
 {
     uint32_t gpu_index;
-    struct loader_icd *icd = loader_get_icd((const XGL_BASE_LAYER_OBJECT *) gpu, &gpu_index);
+    struct loader_icd *icd = loader_get_icd((const VK_BASE_LAYER_OBJECT *) gpu, &gpu_index);
 
     if (!icd)
-        return XGL_ERROR_UNAVAILABLE;
+        return VK_ERROR_UNAVAILABLE;
 
     return find_layer_extension(icd, gpu_index, pExtName, NULL);
 }
 
-LOADER_EXPORT XGL_RESULT XGLAPI xglEnumerateLayers(XGL_PHYSICAL_GPU gpu, size_t maxLayerCount, size_t maxStringSize, size_t* pOutLayerCount, char* const* pOutLayers, void* pReserved)
+LOADER_EXPORT VK_RESULT VKAPI vkEnumerateLayers(VK_PHYSICAL_GPU gpu, size_t maxLayerCount, size_t maxStringSize, size_t* pOutLayerCount, char* const* pOutLayers, void* pReserved)
 {
     uint32_t gpu_index;
     size_t count = 0;
     char *lib_name;
-    struct loader_icd *icd = loader_get_icd((const XGL_BASE_LAYER_OBJECT *) gpu, &gpu_index);
+    struct loader_icd *icd = loader_get_icd((const VK_BASE_LAYER_OBJECT *) gpu, &gpu_index);
     loader_platform_dl_handle handle;
-    xglEnumerateLayersType fpEnumerateLayers;
+    vkEnumerateLayersType fpEnumerateLayers;
     char layer_buf[16][256];
     char * layers[16];
 
     if (pOutLayerCount == NULL || pOutLayers == NULL)
-        return XGL_ERROR_INVALID_POINTER;
+        return VK_ERROR_INVALID_POINTER;
 
     if (!icd)
-        return XGL_ERROR_UNAVAILABLE;
+        return VK_ERROR_UNAVAILABLE;
 
     for (int i = 0; i < 16; i++)
          layers[i] = &layer_buf[i][0];
@@ -1082,14 +1082,14 @@
         // Used to call: dlopen(*lib_name, RTLD_LAZY)
         if ((handle = loader_platform_open_library(lib_name)) == NULL)
             continue;
-        if ((fpEnumerateLayers = loader_platform_get_proc_address(handle, "xglEnumerateLayers")) == NULL) {
-            //use default layer name based on library name XGL_LAYER_LIBRARY_PREFIX<name>.XGL_LIBRARY_SUFFIX
+        if ((fpEnumerateLayers = loader_platform_get_proc_address(handle, "vkEnumerateLayers")) == NULL) {
+            //use default layer name based on library name VK_LAYER_LIBRARY_PREFIX<name>.VK_LIBRARY_SUFFIX
             char *pEnd, *cpyStr;
             size_t siz;
             loader_platform_close_library(handle);
             lib_name = basename(lib_name);
             pEnd = strrchr(lib_name, '.');
-            siz = (int) (pEnd - lib_name - strlen(XGL_LAYER_LIBRARY_PREFIX) + 1);
+            siz = (int) (pEnd - lib_name - strlen(VK_LAYER_LIBRARY_PREFIX) + 1);
             if (pEnd == NULL || siz <= 0)
                 continue;
             cpyStr = malloc(siz);
@@ -1097,7 +1097,7 @@
                 free(cpyStr);
                 continue;
             }
-            strncpy(cpyStr, lib_name + strlen(XGL_LAYER_LIBRARY_PREFIX), siz);
+            strncpy(cpyStr, lib_name + strlen(VK_LAYER_LIBRARY_PREFIX), siz);
             cpyStr[siz - 1] = '\0';
             if (siz > maxStringSize)
                 siz = (int) maxStringSize;
@@ -1108,11 +1108,11 @@
         } else {
             size_t cnt;
             uint32_t n;
-            XGL_RESULT res;
+            VK_RESULT res;
             n = (uint32_t) ((maxStringSize < 256) ? maxStringSize : 256);
             res = fpEnumerateLayers(NULL, 16, n, &cnt, layers, (char *) icd->gpus + gpu_index);
             loader_platform_close_library(handle);
-            if (res != XGL_SUCCESS)
+            if (res != VK_SUCCESS)
                 continue;
             if (cnt + count > maxLayerCount)
                 cnt = maxLayerCount - count;
@@ -1127,18 +1127,18 @@
 
     *pOutLayerCount = count;
 
-    return XGL_SUCCESS;
+    return VK_SUCCESS;
 }
 
-LOADER_EXPORT XGL_RESULT XGLAPI xglDbgRegisterMsgCallback(XGL_INSTANCE instance, XGL_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback, void* pUserData)
+LOADER_EXPORT VK_RESULT VKAPI vkDbgRegisterMsgCallback(VK_INSTANCE instance, VK_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback, void* pUserData)
 {
     const struct loader_icd *icd;
     struct loader_instance *inst;
-    XGL_RESULT res;
+    VK_RESULT res;
     uint32_t gpu_idx;
 
-    if (instance == XGL_NULL_HANDLE)
-        return XGL_ERROR_INVALID_HANDLE;
+    if (instance == VK_NULL_HANDLE)
+        return VK_ERROR_INVALID_HANDLE;
 
     assert(loader.icds_scanned);
 
@@ -1147,19 +1147,19 @@
             break;
     }
 
-    if (inst == XGL_NULL_HANDLE)
-        return XGL_ERROR_INVALID_HANDLE;
+    if (inst == VK_NULL_HANDLE)
+        return VK_ERROR_INVALID_HANDLE;
 
     for (icd = inst->icds; icd; icd = icd->next) {
         for (uint32_t i = 0; i < icd->gpu_count; i++) {
             res = (icd->loader_dispatch + i)->DbgRegisterMsgCallback(icd->scanned_icds->instance,
                                                    pfnMsgCallback, pUserData);
-            if (res != XGL_SUCCESS) {
+            if (res != VK_SUCCESS) {
                 gpu_idx = i;
                 break;
             }
         }
-        if (res != XGL_SUCCESS)
+        if (res != VK_SUCCESS)
             break;
     }
 
@@ -1178,15 +1178,15 @@
         return res;
     }
 
-    return XGL_SUCCESS;
+    return VK_SUCCESS;
 }
 
-LOADER_EXPORT XGL_RESULT XGLAPI xglDbgUnregisterMsgCallback(XGL_INSTANCE instance, XGL_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback)
+LOADER_EXPORT VK_RESULT VKAPI vkDbgUnregisterMsgCallback(VK_INSTANCE instance, VK_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback)
 {
-    XGL_RESULT res = XGL_SUCCESS;
+    VK_RESULT res = VK_SUCCESS;
     struct loader_instance *inst;
-    if (instance == XGL_NULL_HANDLE)
-        return XGL_ERROR_INVALID_HANDLE;
+    if (instance == VK_NULL_HANDLE)
+        return VK_ERROR_INVALID_HANDLE;
 
     assert(loader.icds_scanned);
 
@@ -1195,14 +1195,14 @@
             break;
     }
 
-    if (inst == XGL_NULL_HANDLE)
-        return XGL_ERROR_INVALID_HANDLE;
+    if (inst == VK_NULL_HANDLE)
+        return VK_ERROR_INVALID_HANDLE;
 
     for (const struct loader_icd * icd = inst->icds; icd; icd = icd->next) {
         for (uint32_t i = 0; i < icd->gpu_count; i++) {
-            XGL_RESULT r;
+            VK_RESULT r;
             r = (icd->loader_dispatch + i)->DbgUnregisterMsgCallback(icd->scanned_icds->instance, pfnMsgCallback);
-            if (r != XGL_SUCCESS) {
+            if (r != VK_SUCCESS) {
                 res = r;
             }
         }
@@ -1210,12 +1210,12 @@
     return res;
 }
 
-LOADER_EXPORT XGL_RESULT XGLAPI xglDbgSetGlobalOption(XGL_INSTANCE instance, XGL_DBG_GLOBAL_OPTION dbgOption, size_t dataSize, const void* pData)
+LOADER_EXPORT VK_RESULT VKAPI vkDbgSetGlobalOption(VK_INSTANCE instance, VK_DBG_GLOBAL_OPTION dbgOption, size_t dataSize, const void* pData)
 {
-    XGL_RESULT res = XGL_SUCCESS;
+    VK_RESULT res = VK_SUCCESS;
     struct loader_instance *inst;
-    if (instance == XGL_NULL_HANDLE)
-        return XGL_ERROR_INVALID_HANDLE;
+    if (instance == VK_NULL_HANDLE)
+        return VK_ERROR_INVALID_HANDLE;
 
     assert(loader.icds_scanned);
 
@@ -1224,15 +1224,15 @@
             break;
     }
 
-    if (inst == XGL_NULL_HANDLE)
-        return XGL_ERROR_INVALID_HANDLE;
+    if (inst == VK_NULL_HANDLE)
+        return VK_ERROR_INVALID_HANDLE;
     for (const struct loader_icd * icd = inst->icds; icd; icd = icd->next) {
         for (uint32_t i = 0; i < icd->gpu_count; i++) {
-            XGL_RESULT r;
+            VK_RESULT r;
             r = (icd->loader_dispatch + i)->DbgSetGlobalOption(icd->scanned_icds->instance, dbgOption,
                                                            dataSize, pData);
             /* unfortunately we cannot roll back */
-            if (r != XGL_SUCCESS) {
+            if (r != VK_SUCCESS) {
                res = r;
             }
         }
diff --git a/loader/loader.h b/loader/loader.h
index d307c53..1817386 100644
--- a/loader/loader.h
+++ b/loader/loader.h
@@ -1,5 +1,5 @@
 /*
- * XGL
+ * Vulkan
  *
  * Copyright (C) 2014 LunarG, Inc.
  *
@@ -28,15 +28,15 @@
 #ifndef LOADER_H
 #define LOADER_H
 
-#include <xgl.h>
-#include <xglDbg.h>
+#include <vulkan.h>
+#include <vkDbg.h>
 #if defined(WIN32)
 // FIXME: NEED WINDOWS EQUIVALENT
 #else // WIN32
-#include <xglWsiX11Ext.h>
+#include <vkWsiX11Ext.h>
 #endif // WIN32
-#include <xglLayer.h>
-#include <xglIcd.h>
+#include <vkLayer.h>
+#include <vkIcd.h>
 #include <assert.h>
 
 #if defined(__GNUC__) && __GNUC__ >= 4
@@ -65,16 +65,16 @@
     loader_set_data(obj, data);
 }
 
-static inline void *loader_unwrap_gpu(XGL_PHYSICAL_GPU *gpu)
+static inline void *loader_unwrap_gpu(VK_PHYSICAL_GPU *gpu)
 {
-    const XGL_BASE_LAYER_OBJECT *wrap = (const XGL_BASE_LAYER_OBJECT *) *gpu;
+    const VK_BASE_LAYER_OBJECT *wrap = (const VK_BASE_LAYER_OBJECT *) *gpu;
 
-    *gpu = (XGL_PHYSICAL_GPU) wrap->nextObject;
+    *gpu = (VK_PHYSICAL_GPU) wrap->nextObject;
 
     return loader_get_data(wrap->baseObject);
 }
 
-extern uint32_t loader_activate_layers(XGL_PHYSICAL_GPU gpu, const XGL_DEVICE_CREATE_INFO* pCreateInfo);
+extern uint32_t loader_activate_layers(VK_PHYSICAL_GPU gpu, const VK_DEVICE_CREATE_INFO* pCreateInfo);
 #define MAX_LAYER_LIBRARIES 64
 
 #endif /* LOADER_H */
diff --git a/loader/loader_platform.h b/loader/loader_platform.h
index d2299e3..230ee5d 100644
--- a/loader/loader_platform.h
+++ b/loader/loader_platform.h
@@ -1,5 +1,5 @@
 /*
- * XGL
+ * Vulkan
  *
  * Copyright (C) 2015 LunarG, Inc.
  * Copyright 2014 Valve Software
@@ -42,26 +42,26 @@
 #include <pthread.h>
 #include <assert.h>
 
-// XGL Library Filenames, Paths, etc.:
+// VK Library Filenames, Paths, etc.:
 #define PATH_SEPERATOR ':'
 #define DIRECTORY_SYMBOL "/"
-#define DRIVER_PATH_ENV "LIBXGL_DRIVERS_PATH"
-#define LAYERS_PATH_ENV "LIBXGL_LAYERS_PATH"
-#define LAYER_NAMES_ENV "LIBXGL_LAYER_NAMES"
-#ifndef DEFAULT_XGL_DRIVERS_PATH
+#define DRIVER_PATH_ENV "LIBVK_DRIVERS_PATH"
+#define LAYERS_PATH_ENV "LIBVK_LAYERS_PATH"
+#define LAYER_NAMES_ENV "LIBVK_LAYER_NAMES"
+#ifndef DEFAULT_VK_DRIVERS_PATH
 // TODO: Is this a good default location?
 // Need to search for both 32bit and 64bit ICDs
-#define DEFAULT_XGL_DRIVERS_PATH "/usr/lib/i386-linux-gnu/xgl:/usr/lib/x86_64-linux-gnu/xgl"
-#define XGL_DRIVER_LIBRARY_PREFIX "libXGL_"
-#define XGL_DRIVER_LIBRARY_PREFIX_LEN 7
-#define XGL_LAYER_LIBRARY_PREFIX "libXGLLayer"
-#define XGL_LAYER_LIBRARY_PREFIX_LEN 11
-#define XGL_LIBRARY_SUFFIX ".so"
-#define XGL_LIBRARY_SUFFIX_LEN 3
-#endif //  DEFAULT_XGL_DRIVERS_PATH
-#ifndef DEFAULT_XGL_LAYERS_PATH
+#define DEFAULT_VK_DRIVERS_PATH "/usr/lib/i386-linux-gnu/vk:/usr/lib/x86_64-linux-gnu/vk"
+#define VK_DRIVER_LIBRARY_PREFIX "libVK_"
+#define VK_DRIVER_LIBRARY_PREFIX_LEN 6
+#define VK_LAYER_LIBRARY_PREFIX "libVKLayer"
+#define VK_LAYER_LIBRARY_PREFIX_LEN 10
+#define VK_LIBRARY_SUFFIX ".so"
+#define VK_LIBRARY_SUFFIX_LEN 3
+#endif //  DEFAULT_VK_DRIVERS_PATH
+#ifndef DEFAULT_VK_LAYERS_PATH
 // TODO: Are these good default locations?
-#define DEFAULT_XGL_LAYERS_PATH ".:/usr/lib/i386-linux-gnu/xgl:/usr/lib/x86_64-linux-gnu/xgl"
+#define DEFAULT_VK_LAYERS_PATH ".:/usr/lib/i386-linux-gnu/vk:/usr/lib/x86_64-linux-gnu/vk"
 #endif
 
 // C99:
@@ -144,32 +144,32 @@
 using namespace std;
 #endif // __cplusplus
 
-// XGL Library Filenames, Paths, etc.:
+// VK Library Filenames, Paths, etc.:
 #define PATH_SEPERATOR ';'
 #define DIRECTORY_SYMBOL "\\"
-#define DRIVER_PATH_REGISTRY_VALUE "XGL_DRIVERS_PATH"
-#define LAYERS_PATH_REGISTRY_VALUE "XGL_LAYERS_PATH"
-#define LAYER_NAMES_REGISTRY_VALUE "XGL_LAYER_NAMES"
-#define DRIVER_PATH_ENV "XGL_DRIVERS_PATH"
-#define LAYERS_PATH_ENV "XGL_LAYERS_PATH"
-#define LAYER_NAMES_ENV "XGL_LAYER_NAMES"
-#ifndef DEFAULT_XGL_DRIVERS_PATH
+#define DRIVER_PATH_REGISTRY_VALUE "VK_DRIVERS_PATH"
+#define LAYERS_PATH_REGISTRY_VALUE "VK_LAYERS_PATH"
+#define LAYER_NAMES_REGISTRY_VALUE "VK_LAYER_NAMES"
+#define DRIVER_PATH_ENV "VK_DRIVERS_PATH"
+#define LAYERS_PATH_ENV "VK_LAYERS_PATH"
+#define LAYER_NAMES_ENV "VK_LAYER_NAMES"
+#ifndef DEFAULT_VK_DRIVERS_PATH
 // TODO: Is this a good default location?
 // Need to search for both 32bit and 64bit ICDs
-#define DEFAULT_XGL_DRIVERS_PATH "C:\\Windows\\System32"
+#define DEFAULT_VK_DRIVERS_PATH "C:\\Windows\\System32"
 // TODO/TBD: Is this an appropriate prefix for Windows?
-#define XGL_DRIVER_LIBRARY_PREFIX "XGL_"
-#define XGL_DRIVER_LIBRARY_PREFIX_LEN 4
+#define VK_DRIVER_LIBRARY_PREFIX "VK_"
+#define VK_DRIVER_LIBRARY_PREFIX_LEN 4
 // TODO/TBD: Is this an appropriate suffix for Windows?
-#define XGL_LAYER_LIBRARY_PREFIX "XGLLayer"
-#define XGL_LAYER_LIBRARY_PREFIX_LEN 8
-#define XGL_LIBRARY_SUFFIX ".dll"
-#define XGL_LIBRARY_SUFFIX_LEN 4
-#endif //  DEFAULT_XGL_DRIVERS_PATH
-#ifndef DEFAULT_XGL_LAYERS_PATH
+#define VK_LAYER_LIBRARY_PREFIX "VKLayer"
+#define VK_LAYER_LIBRARY_PREFIX_LEN 8
+#define VK_LIBRARY_SUFFIX ".dll"
+#define VK_LIBRARY_SUFFIX_LEN 4
+#endif //  DEFAULT_VK_DRIVERS_PATH
+#ifndef DEFAULT_VK_LAYERS_PATH
 // TODO: Is this a good default location?
-#define DEFAULT_XGL_LAYERS_PATH "C:\\Windows\\System32"
-#endif //  DEFAULT_XGL_LAYERS_PATH
+#define DEFAULT_VK_LAYERS_PATH "C:\\Windows\\System32"
+#endif //  DEFAULT_VK_LAYERS_PATH
 
 // C99:
 // Microsoft didn't implement C99 in Visual Studio; but started adding it with
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index 5a40641..a6dce81 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -14,7 +14,7 @@
     message(FATAL_ERROR "Missing ImageMagick library: sudo apt-get install libmagickwand-dev")
 endif()
 
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DXGL_PROTOTYPES -Wno-sign-compare")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DVK_PROTOTYPES -Wno-sign-compare")
 
 SET(COMMON_CPP
     xglrenderframework.cpp
@@ -78,28 +78,28 @@
    COMPILE_DEFINITIONS "GTEST_LINKED_AS_SHARED_LIBRARY=1")
 target_link_libraries(xglbase XGL gtest gtest_main ${TEST_LIBRARIES})
 
-add_executable(xgl_image_tests image_tests.cpp ${COMMON_CPP})
-set_target_properties(xgl_image_tests
+add_executable(vk_image_tests image_tests.cpp ${COMMON_CPP})
+set_target_properties(vk_image_tests
    PROPERTIES
    COMPILE_DEFINITIONS "GTEST_LINKED_AS_SHARED_LIBRARY=1")
-target_link_libraries(xgl_image_tests XGL gtest gtest_main ${TEST_LIBRARIES})
+target_link_libraries(vk_image_tests XGL gtest gtest_main ${TEST_LIBRARIES})
 
-add_executable(xgl_render_tests render_tests.cpp ${COMMON_CPP})
-set_target_properties(xgl_render_tests
+add_executable(vk_render_tests render_tests.cpp ${COMMON_CPP})
+set_target_properties(vk_render_tests
    PROPERTIES
    COMPILE_DEFINITIONS "GTEST_LINKED_AS_SHARED_LIBRARY=1")
-target_link_libraries(xgl_render_tests XGL gtest gtest_main ${TEST_LIBRARIES})
+target_link_libraries(vk_render_tests XGL gtest gtest_main ${TEST_LIBRARIES})
 
-add_executable(xgl_blit_tests blit_tests.cpp ${COMMON_CPP})
-set_target_properties(xgl_blit_tests
+add_executable(vk_blit_tests blit_tests.cpp ${COMMON_CPP})
+set_target_properties(vk_blit_tests
    PROPERTIES
    COMPILE_DEFINITIONS "GTEST_LINKED_AS_SHARED_LIBRARY=1")
-target_link_libraries(xgl_blit_tests XGL gtest gtest_main ${TEST_LIBRARIES})
+target_link_libraries(vk_blit_tests XGL gtest gtest_main ${TEST_LIBRARIES})
 
-add_executable(xgl_layer_validation_tests layer_validation_tests.cpp ${COMMON_CPP})
-set_target_properties(xgl_layer_validation_tests
+add_executable(vk_layer_validation_tests layer_validation_tests.cpp ${COMMON_CPP})
+set_target_properties(vk_layer_validation_tests
    PROPERTIES
    COMPILE_DEFINITIONS "GTEST_LINKED_AS_SHARED_LIBRARY=1")
-target_link_libraries(xgl_layer_validation_tests XGL gtest gtest_main ${TEST_LIBRARIES})
+target_link_libraries(vk_layer_validation_tests XGL gtest gtest_main ${TEST_LIBRARIES})
 
 add_subdirectory(gtest-1.7.0)
diff --git a/tests/README-raster_tests b/tests/README-raster_tests
index 80f599f..019760d 100644
--- a/tests/README-raster_tests
+++ b/tests/README-raster_tests
@@ -1,4 +1,4 @@
-To run the raster tests and just look for XGL errors simply run them with no arguments or use the --gtest_filter=XglRasterTest.<testname> to run just one test. Running with --gtest_list_tests  will name all of the available tests.
+To run the raster tests and just look for VK errors simply run them with no arguments or use the --gtest_filter=XglRasterTest.<testname> to run just one test. Running with --gtest_list_tests  will name all of the available tests.
 
 The raster tests can be run and the pixel results compared to known good (golden) images generated from previous runs.  To generate golden images, make sure that the tests are rendering as expected, and then run with --save-images.  This will generate .ppm files for all of the tests.  Create a directory called "golden" and "mv *.ppm golden".  When new tests are added to render_tests additional golden images will need to be generated for the new tests.
 
diff --git a/tests/blit_tests.cpp b/tests/blit_tests.cpp
index 2cc50d7..6de1ddd 100644
--- a/tests/blit_tests.cpp
+++ b/tests/blit_tests.cpp
@@ -1,4 +1,4 @@
-// XGL tests
+// VK tests
 //
 // Copyright (C) 2014 LunarG, Inc.
 //
@@ -23,31 +23,31 @@
 // Blit (copy, clear, and resolve) tests
 
 #include "test_common.h"
-#include "xgltestbinding.h"
+#include "vktestbinding.h"
 #include "test_environment.h"
 
 #define ARRAY_SIZE(a) (sizeof(a) / sizeof(a[0]))
 
-namespace xgl_testing {
+namespace vk_testing {
 
-size_t get_format_size(XGL_FORMAT format);
+size_t get_format_size(VK_FORMAT format);
 
 class ImageChecker {
 public:
-    explicit ImageChecker(const XGL_IMAGE_CREATE_INFO &info, const std::vector<XGL_BUFFER_IMAGE_COPY> &regions)
+    explicit ImageChecker(const VK_IMAGE_CREATE_INFO &info, const std::vector<VK_BUFFER_IMAGE_COPY> &regions)
         : info_(info), regions_(regions), pattern_(HASH) {}
-    explicit ImageChecker(const XGL_IMAGE_CREATE_INFO &info, const std::vector<XGL_IMAGE_SUBRESOURCE_RANGE> &ranges);
-    explicit ImageChecker(const XGL_IMAGE_CREATE_INFO &info);
+    explicit ImageChecker(const VK_IMAGE_CREATE_INFO &info, const std::vector<VK_IMAGE_SUBRESOURCE_RANGE> &ranges);
+    explicit ImageChecker(const VK_IMAGE_CREATE_INFO &info);
 
     void set_solid_pattern(const std::vector<uint8_t> &solid);
 
-    XGL_GPU_SIZE buffer_size() const;
+    VK_GPU_SIZE buffer_size() const;
     bool fill(Buffer &buf) const { return walk(FILL, buf); }
     bool fill(Image &img) const { return walk(FILL, img); }
     bool check(Buffer &buf) const { return walk(CHECK, buf); }
     bool check(Image &img) const { return walk(CHECK, img); }
 
-    const std::vector<XGL_BUFFER_IMAGE_COPY> &regions() const { return regions_; }
+    const std::vector<VK_BUFFER_IMAGE_COPY> &regions() const { return regions_; }
 
     static void hash_salt_generate() { hash_salt_++; }
 
@@ -63,18 +63,18 @@
     };
 
     size_t buffer_cpp() const;
-    XGL_SUBRESOURCE_LAYOUT buffer_layout(const XGL_BUFFER_IMAGE_COPY &region) const;
+    VK_SUBRESOURCE_LAYOUT buffer_layout(const VK_BUFFER_IMAGE_COPY &region) const;
 
     bool walk(Action action, Buffer &buf) const;
     bool walk(Action action, Image &img) const;
-    bool walk_region(Action action, const XGL_BUFFER_IMAGE_COPY &region, const XGL_SUBRESOURCE_LAYOUT &layout, void *data) const;
+    bool walk_region(Action action, const VK_BUFFER_IMAGE_COPY &region, const VK_SUBRESOURCE_LAYOUT &layout, void *data) const;
 
-    std::vector<uint8_t> pattern_hash(const XGL_IMAGE_SUBRESOURCE &subres, const XGL_OFFSET3D &offset) const;
+    std::vector<uint8_t> pattern_hash(const VK_IMAGE_SUBRESOURCE &subres, const VK_OFFSET3D &offset) const;
 
     static uint32_t hash_salt_;
 
-    XGL_IMAGE_CREATE_INFO info_;
-    std::vector<XGL_BUFFER_IMAGE_COPY> regions_;
+    VK_IMAGE_CREATE_INFO info_;
+    std::vector<VK_BUFFER_IMAGE_COPY> regions_;
 
     Pattern pattern_;
     std::vector<uint8_t> pattern_solid_;
@@ -83,33 +83,33 @@
 
 uint32_t ImageChecker::hash_salt_;
 
-ImageChecker::ImageChecker(const XGL_IMAGE_CREATE_INFO &info)
+ImageChecker::ImageChecker(const VK_IMAGE_CREATE_INFO &info)
     : info_(info), regions_(), pattern_(HASH)
 {
     // create a region for every mip level in array slice 0
-    XGL_GPU_SIZE offset = 0;
+    VK_GPU_SIZE offset = 0;
     for (uint32_t lv = 0; lv < info_.mipLevels; lv++) {
-        XGL_BUFFER_IMAGE_COPY region = {};
+        VK_BUFFER_IMAGE_COPY region = {};
 
         region.bufferOffset = offset;
         region.imageSubresource.mipLevel = lv;
         region.imageSubresource.arraySlice = 0;
         region.imageExtent = Image::extent(info_.extent, lv);
 
-        if (info_.usage & XGL_IMAGE_USAGE_DEPTH_STENCIL_BIT) {
-            if (info_.format != XGL_FMT_S8_UINT) {
-                region.imageSubresource.aspect = XGL_IMAGE_ASPECT_DEPTH;
+        if (info_.usage & VK_IMAGE_USAGE_DEPTH_STENCIL_BIT) {
+            if (info_.format != VK_FMT_S8_UINT) {
+                region.imageSubresource.aspect = VK_IMAGE_ASPECT_DEPTH;
                 regions_.push_back(region);
             }
 
-            if (info_.format == XGL_FMT_D16_UNORM_S8_UINT ||
-                info_.format == XGL_FMT_D32_SFLOAT_S8_UINT ||
-                info_.format == XGL_FMT_S8_UINT) {
-                region.imageSubresource.aspect = XGL_IMAGE_ASPECT_STENCIL;
+            if (info_.format == VK_FMT_D16_UNORM_S8_UINT ||
+                info_.format == VK_FMT_D32_SFLOAT_S8_UINT ||
+                info_.format == VK_FMT_S8_UINT) {
+                region.imageSubresource.aspect = VK_IMAGE_ASPECT_STENCIL;
                 regions_.push_back(region);
             }
         } else {
-            region.imageSubresource.aspect = XGL_IMAGE_ASPECT_COLOR;
+            region.imageSubresource.aspect = VK_IMAGE_ASPECT_COLOR;
             regions_.push_back(region);
         }
 
@@ -119,14 +119,14 @@
     // arraySize should be limited in our tests.  If this proves to be an
     // issue, we can store only the regions for array slice 0 and be smart.
     if (info_.arraySize > 1) {
-        const XGL_GPU_SIZE slice_pitch = offset;
+        const VK_GPU_SIZE slice_pitch = offset;
         const uint32_t slice_region_count = regions_.size();
 
         regions_.reserve(slice_region_count * info_.arraySize);
 
         for (uint32_t slice = 1; slice < info_.arraySize; slice++) {
             for (uint32_t i = 0; i < slice_region_count; i++) {
-                XGL_BUFFER_IMAGE_COPY region = regions_[i];
+                VK_BUFFER_IMAGE_COPY region = regions_[i];
 
                 region.bufferOffset += slice_pitch * slice;
                 region.imageSubresource.arraySlice = slice;
@@ -136,15 +136,15 @@
     }
 }
 
-ImageChecker::ImageChecker(const XGL_IMAGE_CREATE_INFO &info, const std::vector<XGL_IMAGE_SUBRESOURCE_RANGE> &ranges)
+ImageChecker::ImageChecker(const VK_IMAGE_CREATE_INFO &info, const std::vector<VK_IMAGE_SUBRESOURCE_RANGE> &ranges)
     : info_(info), regions_(), pattern_(HASH)
 {
-    XGL_GPU_SIZE offset = 0;
-    for (std::vector<XGL_IMAGE_SUBRESOURCE_RANGE>::const_iterator it = ranges.begin();
+    VK_GPU_SIZE offset = 0;
+    for (std::vector<VK_IMAGE_SUBRESOURCE_RANGE>::const_iterator it = ranges.begin();
          it != ranges.end(); it++) {
         for (uint32_t lv = 0; lv < it->mipLevels; lv++) {
             for (uint32_t slice = 0; slice < it->arraySize; slice++) {
-                XGL_BUFFER_IMAGE_COPY region = {};
+                VK_BUFFER_IMAGE_COPY region = {};
                 region.bufferOffset = offset;
                 region.imageSubresource = Image::subresource(*it, lv, slice);
                 region.imageExtent = Image::extent(info_.extent, lv);
@@ -171,9 +171,9 @@
     return get_format_size(info_.format);
 }
 
-XGL_SUBRESOURCE_LAYOUT ImageChecker::buffer_layout(const XGL_BUFFER_IMAGE_COPY &region) const
+VK_SUBRESOURCE_LAYOUT ImageChecker::buffer_layout(const VK_BUFFER_IMAGE_COPY &region) const
 {
-    XGL_SUBRESOURCE_LAYOUT layout = {};
+    VK_SUBRESOURCE_LAYOUT layout = {};
     layout.offset = region.bufferOffset;
     layout.rowPitch = buffer_cpp() * region.imageExtent.width;
     layout.depthPitch = layout.rowPitch * region.imageExtent.height;
@@ -182,13 +182,13 @@
     return layout;
 }
 
-XGL_GPU_SIZE ImageChecker::buffer_size() const
+VK_GPU_SIZE ImageChecker::buffer_size() const
 {
-    XGL_GPU_SIZE size = 0;
+    VK_GPU_SIZE size = 0;
 
-    for (std::vector<XGL_BUFFER_IMAGE_COPY>::const_iterator it = regions_.begin();
+    for (std::vector<VK_BUFFER_IMAGE_COPY>::const_iterator it = regions_.begin();
          it != regions_.end(); it++) {
-        const XGL_SUBRESOURCE_LAYOUT layout = buffer_layout(*it);
+        const VK_SUBRESOURCE_LAYOUT layout = buffer_layout(*it);
         if (size < layout.offset + layout.size)
             size = layout.offset + layout.size;
     }
@@ -196,8 +196,8 @@
     return size;
 }
 
-bool ImageChecker::walk_region(Action action, const XGL_BUFFER_IMAGE_COPY &region,
-                               const XGL_SUBRESOURCE_LAYOUT &layout, void *data) const
+bool ImageChecker::walk_region(Action action, const VK_BUFFER_IMAGE_COPY &region,
+                               const VK_SUBRESOURCE_LAYOUT &layout, void *data) const
 {
     for (int32_t z = 0; z < region.imageExtent.depth; z++) {
         for (int32_t y = 0; y < region.imageExtent.height; y++) {
@@ -206,7 +206,7 @@
                 dst += layout.offset + layout.depthPitch * z +
                     layout.rowPitch * y + buffer_cpp() * x;
 
-                XGL_OFFSET3D offset = region.imageOffset;
+                VK_OFFSET3D offset = region.imageOffset;
                 offset.x += x;
                 offset.y += y;
                 offset.z += z;
@@ -239,7 +239,7 @@
     if (!data)
         return false;
 
-    std::vector<XGL_BUFFER_IMAGE_COPY>::const_iterator it;
+    std::vector<VK_BUFFER_IMAGE_COPY>::const_iterator it;
     for (it = regions_.begin(); it != regions_.end(); it++) {
         if (!walk_region(action, *it, buffer_layout(*it), data))
             break;
@@ -256,7 +256,7 @@
     if (!data)
         return false;
 
-    std::vector<XGL_BUFFER_IMAGE_COPY>::const_iterator it;
+    std::vector<VK_BUFFER_IMAGE_COPY>::const_iterator it;
     for (it = regions_.begin(); it != regions_.end(); it++) {
         if (!walk_region(action, *it, img.subresource_layout(it->imageSubresource), data))
             break;
@@ -267,7 +267,7 @@
     return (it == regions_.end());
 }
 
-std::vector<uint8_t> ImageChecker::pattern_hash(const XGL_IMAGE_SUBRESOURCE &subres, const XGL_OFFSET3D &offset) const
+std::vector<uint8_t> ImageChecker::pattern_hash(const VK_IMAGE_SUBRESOURCE &subres, const VK_OFFSET3D &offset) const
 {
 #define HASH_BYTE(val, b) static_cast<uint8_t>((static_cast<uint32_t>(val) >> (b * 8)) & 0xff)
 #define HASH_BYTES(val) HASH_BYTE(val, 0), HASH_BYTE(val, 1), HASH_BYTE(val, 2), HASH_BYTE(val, 3)
@@ -296,195 +296,195 @@
     return val;
 }
 
-size_t get_format_size(XGL_FORMAT format)
+size_t get_format_size(VK_FORMAT format)
 {
     static const struct format_info {
         size_t size;
         uint32_t channel_count;
-    } format_table[XGL_NUM_FMT] = {
-        [XGL_FMT_UNDEFINED]            = { 0,  0 },
-        [XGL_FMT_R4G4_UNORM]           = { 1,  2 },
-        [XGL_FMT_R4G4_USCALED]         = { 1,  2 },
-        [XGL_FMT_R4G4B4A4_UNORM]       = { 2,  4 },
-        [XGL_FMT_R4G4B4A4_USCALED]     = { 2,  4 },
-        [XGL_FMT_R5G6B5_UNORM]         = { 2,  3 },
-        [XGL_FMT_R5G6B5_USCALED]       = { 2,  3 },
-        [XGL_FMT_R5G5B5A1_UNORM]       = { 2,  4 },
-        [XGL_FMT_R5G5B5A1_USCALED]     = { 2,  4 },
-        [XGL_FMT_R8_UNORM]             = { 1,  1 },
-        [XGL_FMT_R8_SNORM]             = { 1,  1 },
-        [XGL_FMT_R8_USCALED]           = { 1,  1 },
-        [XGL_FMT_R8_SSCALED]           = { 1,  1 },
-        [XGL_FMT_R8_UINT]              = { 1,  1 },
-        [XGL_FMT_R8_SINT]              = { 1,  1 },
-        [XGL_FMT_R8_SRGB]              = { 1,  1 },
-        [XGL_FMT_R8G8_UNORM]           = { 2,  2 },
-        [XGL_FMT_R8G8_SNORM]           = { 2,  2 },
-        [XGL_FMT_R8G8_USCALED]         = { 2,  2 },
-        [XGL_FMT_R8G8_SSCALED]         = { 2,  2 },
-        [XGL_FMT_R8G8_UINT]            = { 2,  2 },
-        [XGL_FMT_R8G8_SINT]            = { 2,  2 },
-        [XGL_FMT_R8G8_SRGB]            = { 2,  2 },
-        [XGL_FMT_R8G8B8_UNORM]         = { 3,  3 },
-        [XGL_FMT_R8G8B8_SNORM]         = { 3,  3 },
-        [XGL_FMT_R8G8B8_USCALED]       = { 3,  3 },
-        [XGL_FMT_R8G8B8_SSCALED]       = { 3,  3 },
-        [XGL_FMT_R8G8B8_UINT]          = { 3,  3 },
-        [XGL_FMT_R8G8B8_SINT]          = { 3,  3 },
-        [XGL_FMT_R8G8B8_SRGB]          = { 3,  3 },
-        [XGL_FMT_R8G8B8A8_UNORM]       = { 4,  4 },
-        [XGL_FMT_R8G8B8A8_SNORM]       = { 4,  4 },
-        [XGL_FMT_R8G8B8A8_USCALED]     = { 4,  4 },
-        [XGL_FMT_R8G8B8A8_SSCALED]     = { 4,  4 },
-        [XGL_FMT_R8G8B8A8_UINT]        = { 4,  4 },
-        [XGL_FMT_R8G8B8A8_SINT]        = { 4,  4 },
-        [XGL_FMT_R8G8B8A8_SRGB]        = { 4,  4 },
-        [XGL_FMT_R10G10B10A2_UNORM]    = { 4,  4 },
-        [XGL_FMT_R10G10B10A2_SNORM]    = { 4,  4 },
-        [XGL_FMT_R10G10B10A2_USCALED]  = { 4,  4 },
-        [XGL_FMT_R10G10B10A2_SSCALED]  = { 4,  4 },
-        [XGL_FMT_R10G10B10A2_UINT]     = { 4,  4 },
-        [XGL_FMT_R10G10B10A2_SINT]     = { 4,  4 },
-        [XGL_FMT_R16_UNORM]            = { 2,  1 },
-        [XGL_FMT_R16_SNORM]            = { 2,  1 },
-        [XGL_FMT_R16_USCALED]          = { 2,  1 },
-        [XGL_FMT_R16_SSCALED]          = { 2,  1 },
-        [XGL_FMT_R16_UINT]             = { 2,  1 },
-        [XGL_FMT_R16_SINT]             = { 2,  1 },
-        [XGL_FMT_R16_SFLOAT]           = { 2,  1 },
-        [XGL_FMT_R16G16_UNORM]         = { 4,  2 },
-        [XGL_FMT_R16G16_SNORM]         = { 4,  2 },
-        [XGL_FMT_R16G16_USCALED]       = { 4,  2 },
-        [XGL_FMT_R16G16_SSCALED]       = { 4,  2 },
-        [XGL_FMT_R16G16_UINT]          = { 4,  2 },
-        [XGL_FMT_R16G16_SINT]          = { 4,  2 },
-        [XGL_FMT_R16G16_SFLOAT]        = { 4,  2 },
-        [XGL_FMT_R16G16B16_UNORM]      = { 6,  3 },
-        [XGL_FMT_R16G16B16_SNORM]      = { 6,  3 },
-        [XGL_FMT_R16G16B16_USCALED]    = { 6,  3 },
-        [XGL_FMT_R16G16B16_SSCALED]    = { 6,  3 },
-        [XGL_FMT_R16G16B16_UINT]       = { 6,  3 },
-        [XGL_FMT_R16G16B16_SINT]       = { 6,  3 },
-        [XGL_FMT_R16G16B16_SFLOAT]     = { 6,  3 },
-        [XGL_FMT_R16G16B16A16_UNORM]   = { 8,  4 },
-        [XGL_FMT_R16G16B16A16_SNORM]   = { 8,  4 },
-        [XGL_FMT_R16G16B16A16_USCALED] = { 8,  4 },
-        [XGL_FMT_R16G16B16A16_SSCALED] = { 8,  4 },
-        [XGL_FMT_R16G16B16A16_UINT]    = { 8,  4 },
-        [XGL_FMT_R16G16B16A16_SINT]    = { 8,  4 },
-        [XGL_FMT_R16G16B16A16_SFLOAT]  = { 8,  4 },
-        [XGL_FMT_R32_UINT]             = { 4,  1 },
-        [XGL_FMT_R32_SINT]             = { 4,  1 },
-        [XGL_FMT_R32_SFLOAT]           = { 4,  1 },
-        [XGL_FMT_R32G32_UINT]          = { 8,  2 },
-        [XGL_FMT_R32G32_SINT]          = { 8,  2 },
-        [XGL_FMT_R32G32_SFLOAT]        = { 8,  2 },
-        [XGL_FMT_R32G32B32_UINT]       = { 12, 3 },
-        [XGL_FMT_R32G32B32_SINT]       = { 12, 3 },
-        [XGL_FMT_R32G32B32_SFLOAT]     = { 12, 3 },
-        [XGL_FMT_R32G32B32A32_UINT]    = { 16, 4 },
-        [XGL_FMT_R32G32B32A32_SINT]    = { 16, 4 },
-        [XGL_FMT_R32G32B32A32_SFLOAT]  = { 16, 4 },
-        [XGL_FMT_R64_SFLOAT]           = { 8,  1 },
-        [XGL_FMT_R64G64_SFLOAT]        = { 16, 2 },
-        [XGL_FMT_R64G64B64_SFLOAT]     = { 24, 3 },
-        [XGL_FMT_R64G64B64A64_SFLOAT]  = { 32, 4 },
-        [XGL_FMT_R11G11B10_UFLOAT]     = { 4,  3 },
-        [XGL_FMT_R9G9B9E5_UFLOAT]      = { 4,  3 },
-        [XGL_FMT_D16_UNORM]            = { 2,  1 },
-        [XGL_FMT_D24_UNORM]            = { 3,  1 },
-        [XGL_FMT_D32_SFLOAT]           = { 4,  1 },
-        [XGL_FMT_S8_UINT]              = { 1,  1 },
-        [XGL_FMT_D16_UNORM_S8_UINT]    = { 3,  2 },
-        [XGL_FMT_D24_UNORM_S8_UINT]    = { 4,  2 },
-        [XGL_FMT_D32_SFLOAT_S8_UINT]   = { 4,  2 },
-        [XGL_FMT_BC1_RGB_UNORM]        = { 8,  4 },
-        [XGL_FMT_BC1_RGB_SRGB]         = { 8,  4 },
-        [XGL_FMT_BC1_RGBA_UNORM]       = { 8,  4 },
-        [XGL_FMT_BC1_RGBA_SRGB]        = { 8,  4 },
-        [XGL_FMT_BC2_UNORM]            = { 16, 4 },
-        [XGL_FMT_BC2_SRGB]             = { 16, 4 },
-        [XGL_FMT_BC3_UNORM]            = { 16, 4 },
-        [XGL_FMT_BC3_SRGB]             = { 16, 4 },
-        [XGL_FMT_BC4_UNORM]            = { 8,  4 },
-        [XGL_FMT_BC4_SNORM]            = { 8,  4 },
-        [XGL_FMT_BC5_UNORM]            = { 16, 4 },
-        [XGL_FMT_BC5_SNORM]            = { 16, 4 },
-        [XGL_FMT_BC6H_UFLOAT]          = { 16, 4 },
-        [XGL_FMT_BC6H_SFLOAT]          = { 16, 4 },
-        [XGL_FMT_BC7_UNORM]            = { 16, 4 },
-        [XGL_FMT_BC7_SRGB]             = { 16, 4 },
+    } format_table[VK_NUM_FMT] = {
+        [VK_FMT_UNDEFINED]            = { 0,  0 },
+        [VK_FMT_R4G4_UNORM]           = { 1,  2 },
+        [VK_FMT_R4G4_USCALED]         = { 1,  2 },
+        [VK_FMT_R4G4B4A4_UNORM]       = { 2,  4 },
+        [VK_FMT_R4G4B4A4_USCALED]     = { 2,  4 },
+        [VK_FMT_R5G6B5_UNORM]         = { 2,  3 },
+        [VK_FMT_R5G6B5_USCALED]       = { 2,  3 },
+        [VK_FMT_R5G5B5A1_UNORM]       = { 2,  4 },
+        [VK_FMT_R5G5B5A1_USCALED]     = { 2,  4 },
+        [VK_FMT_R8_UNORM]             = { 1,  1 },
+        [VK_FMT_R8_SNORM]             = { 1,  1 },
+        [VK_FMT_R8_USCALED]           = { 1,  1 },
+        [VK_FMT_R8_SSCALED]           = { 1,  1 },
+        [VK_FMT_R8_UINT]              = { 1,  1 },
+        [VK_FMT_R8_SINT]              = { 1,  1 },
+        [VK_FMT_R8_SRGB]              = { 1,  1 },
+        [VK_FMT_R8G8_UNORM]           = { 2,  2 },
+        [VK_FMT_R8G8_SNORM]           = { 2,  2 },
+        [VK_FMT_R8G8_USCALED]         = { 2,  2 },
+        [VK_FMT_R8G8_SSCALED]         = { 2,  2 },
+        [VK_FMT_R8G8_UINT]            = { 2,  2 },
+        [VK_FMT_R8G8_SINT]            = { 2,  2 },
+        [VK_FMT_R8G8_SRGB]            = { 2,  2 },
+        [VK_FMT_R8G8B8_UNORM]         = { 3,  3 },
+        [VK_FMT_R8G8B8_SNORM]         = { 3,  3 },
+        [VK_FMT_R8G8B8_USCALED]       = { 3,  3 },
+        [VK_FMT_R8G8B8_SSCALED]       = { 3,  3 },
+        [VK_FMT_R8G8B8_UINT]          = { 3,  3 },
+        [VK_FMT_R8G8B8_SINT]          = { 3,  3 },
+        [VK_FMT_R8G8B8_SRGB]          = { 3,  3 },
+        [VK_FMT_R8G8B8A8_UNORM]       = { 4,  4 },
+        [VK_FMT_R8G8B8A8_SNORM]       = { 4,  4 },
+        [VK_FMT_R8G8B8A8_USCALED]     = { 4,  4 },
+        [VK_FMT_R8G8B8A8_SSCALED]     = { 4,  4 },
+        [VK_FMT_R8G8B8A8_UINT]        = { 4,  4 },
+        [VK_FMT_R8G8B8A8_SINT]        = { 4,  4 },
+        [VK_FMT_R8G8B8A8_SRGB]        = { 4,  4 },
+        [VK_FMT_R10G10B10A2_UNORM]    = { 4,  4 },
+        [VK_FMT_R10G10B10A2_SNORM]    = { 4,  4 },
+        [VK_FMT_R10G10B10A2_USCALED]  = { 4,  4 },
+        [VK_FMT_R10G10B10A2_SSCALED]  = { 4,  4 },
+        [VK_FMT_R10G10B10A2_UINT]     = { 4,  4 },
+        [VK_FMT_R10G10B10A2_SINT]     = { 4,  4 },
+        [VK_FMT_R16_UNORM]            = { 2,  1 },
+        [VK_FMT_R16_SNORM]            = { 2,  1 },
+        [VK_FMT_R16_USCALED]          = { 2,  1 },
+        [VK_FMT_R16_SSCALED]          = { 2,  1 },
+        [VK_FMT_R16_UINT]             = { 2,  1 },
+        [VK_FMT_R16_SINT]             = { 2,  1 },
+        [VK_FMT_R16_SFLOAT]           = { 2,  1 },
+        [VK_FMT_R16G16_UNORM]         = { 4,  2 },
+        [VK_FMT_R16G16_SNORM]         = { 4,  2 },
+        [VK_FMT_R16G16_USCALED]       = { 4,  2 },
+        [VK_FMT_R16G16_SSCALED]       = { 4,  2 },
+        [VK_FMT_R16G16_UINT]          = { 4,  2 },
+        [VK_FMT_R16G16_SINT]          = { 4,  2 },
+        [VK_FMT_R16G16_SFLOAT]        = { 4,  2 },
+        [VK_FMT_R16G16B16_UNORM]      = { 6,  3 },
+        [VK_FMT_R16G16B16_SNORM]      = { 6,  3 },
+        [VK_FMT_R16G16B16_USCALED]    = { 6,  3 },
+        [VK_FMT_R16G16B16_SSCALED]    = { 6,  3 },
+        [VK_FMT_R16G16B16_UINT]       = { 6,  3 },
+        [VK_FMT_R16G16B16_SINT]       = { 6,  3 },
+        [VK_FMT_R16G16B16_SFLOAT]     = { 6,  3 },
+        [VK_FMT_R16G16B16A16_UNORM]   = { 8,  4 },
+        [VK_FMT_R16G16B16A16_SNORM]   = { 8,  4 },
+        [VK_FMT_R16G16B16A16_USCALED] = { 8,  4 },
+        [VK_FMT_R16G16B16A16_SSCALED] = { 8,  4 },
+        [VK_FMT_R16G16B16A16_UINT]    = { 8,  4 },
+        [VK_FMT_R16G16B16A16_SINT]    = { 8,  4 },
+        [VK_FMT_R16G16B16A16_SFLOAT]  = { 8,  4 },
+        [VK_FMT_R32_UINT]             = { 4,  1 },
+        [VK_FMT_R32_SINT]             = { 4,  1 },
+        [VK_FMT_R32_SFLOAT]           = { 4,  1 },
+        [VK_FMT_R32G32_UINT]          = { 8,  2 },
+        [VK_FMT_R32G32_SINT]          = { 8,  2 },
+        [VK_FMT_R32G32_SFLOAT]        = { 8,  2 },
+        [VK_FMT_R32G32B32_UINT]       = { 12, 3 },
+        [VK_FMT_R32G32B32_SINT]       = { 12, 3 },
+        [VK_FMT_R32G32B32_SFLOAT]     = { 12, 3 },
+        [VK_FMT_R32G32B32A32_UINT]    = { 16, 4 },
+        [VK_FMT_R32G32B32A32_SINT]    = { 16, 4 },
+        [VK_FMT_R32G32B32A32_SFLOAT]  = { 16, 4 },
+        [VK_FMT_R64_SFLOAT]           = { 8,  1 },
+        [VK_FMT_R64G64_SFLOAT]        = { 16, 2 },
+        [VK_FMT_R64G64B64_SFLOAT]     = { 24, 3 },
+        [VK_FMT_R64G64B64A64_SFLOAT]  = { 32, 4 },
+        [VK_FMT_R11G11B10_UFLOAT]     = { 4,  3 },
+        [VK_FMT_R9G9B9E5_UFLOAT]      = { 4,  3 },
+        [VK_FMT_D16_UNORM]            = { 2,  1 },
+        [VK_FMT_D24_UNORM]            = { 3,  1 },
+        [VK_FMT_D32_SFLOAT]           = { 4,  1 },
+        [VK_FMT_S8_UINT]              = { 1,  1 },
+        [VK_FMT_D16_UNORM_S8_UINT]    = { 3,  2 },
+        [VK_FMT_D24_UNORM_S8_UINT]    = { 4,  2 },
+        [VK_FMT_D32_SFLOAT_S8_UINT]   = { 4,  2 },
+        [VK_FMT_BC1_RGB_UNORM]        = { 8,  4 },
+        [VK_FMT_BC1_RGB_SRGB]         = { 8,  4 },
+        [VK_FMT_BC1_RGBA_UNORM]       = { 8,  4 },
+        [VK_FMT_BC1_RGBA_SRGB]        = { 8,  4 },
+        [VK_FMT_BC2_UNORM]            = { 16, 4 },
+        [VK_FMT_BC2_SRGB]             = { 16, 4 },
+        [VK_FMT_BC3_UNORM]            = { 16, 4 },
+        [VK_FMT_BC3_SRGB]             = { 16, 4 },
+        [VK_FMT_BC4_UNORM]            = { 8,  4 },
+        [VK_FMT_BC4_SNORM]            = { 8,  4 },
+        [VK_FMT_BC5_UNORM]            = { 16, 4 },
+        [VK_FMT_BC5_SNORM]            = { 16, 4 },
+        [VK_FMT_BC6H_UFLOAT]          = { 16, 4 },
+        [VK_FMT_BC6H_SFLOAT]          = { 16, 4 },
+        [VK_FMT_BC7_UNORM]            = { 16, 4 },
+        [VK_FMT_BC7_SRGB]             = { 16, 4 },
         // TODO: Initialize remaining compressed formats.
-        [XGL_FMT_ETC2_R8G8B8_UNORM]    = { 0, 0 },
-        [XGL_FMT_ETC2_R8G8B8_SRGB]     = { 0, 0 },
-        [XGL_FMT_ETC2_R8G8B8A1_UNORM]  = { 0, 0 },
-        [XGL_FMT_ETC2_R8G8B8A1_SRGB]   = { 0, 0 },
-        [XGL_FMT_ETC2_R8G8B8A8_UNORM]  = { 0, 0 },
-        [XGL_FMT_ETC2_R8G8B8A8_SRGB]   = { 0, 0 },
-        [XGL_FMT_EAC_R11_UNORM]        = { 0, 0 },
-        [XGL_FMT_EAC_R11_SNORM]        = { 0, 0 },
-        [XGL_FMT_EAC_R11G11_UNORM]     = { 0, 0 },
-        [XGL_FMT_EAC_R11G11_SNORM]     = { 0, 0 },
-        [XGL_FMT_ASTC_4x4_UNORM]       = { 0, 0 },
-        [XGL_FMT_ASTC_4x4_SRGB]        = { 0, 0 },
-        [XGL_FMT_ASTC_5x4_UNORM]       = { 0, 0 },
-        [XGL_FMT_ASTC_5x4_SRGB]        = { 0, 0 },
-        [XGL_FMT_ASTC_5x5_UNORM]       = { 0, 0 },
-        [XGL_FMT_ASTC_5x5_SRGB]        = { 0, 0 },
-        [XGL_FMT_ASTC_6x5_UNORM]       = { 0, 0 },
-        [XGL_FMT_ASTC_6x5_SRGB]        = { 0, 0 },
-        [XGL_FMT_ASTC_6x6_UNORM]       = { 0, 0 },
-        [XGL_FMT_ASTC_6x6_SRGB]        = { 0, 0 },
-        [XGL_FMT_ASTC_8x5_UNORM]       = { 0, 0 },
-        [XGL_FMT_ASTC_8x5_SRGB]        = { 0, 0 },
-        [XGL_FMT_ASTC_8x6_UNORM]       = { 0, 0 },
-        [XGL_FMT_ASTC_8x6_SRGB]        = { 0, 0 },
-        [XGL_FMT_ASTC_8x8_UNORM]       = { 0, 0 },
-        [XGL_FMT_ASTC_8x8_SRGB]        = { 0, 0 },
-        [XGL_FMT_ASTC_10x5_UNORM]      = { 0, 0 },
-        [XGL_FMT_ASTC_10x5_SRGB]       = { 0, 0 },
-        [XGL_FMT_ASTC_10x6_UNORM]      = { 0, 0 },
-        [XGL_FMT_ASTC_10x6_SRGB]       = { 0, 0 },
-        [XGL_FMT_ASTC_10x8_UNORM]      = { 0, 0 },
-        [XGL_FMT_ASTC_10x8_SRGB]       = { 0, 0 },
-        [XGL_FMT_ASTC_10x10_UNORM]     = { 0, 0 },
-        [XGL_FMT_ASTC_10x10_SRGB]      = { 0, 0 },
-        [XGL_FMT_ASTC_12x10_UNORM]     = { 0, 0 },
-        [XGL_FMT_ASTC_12x10_SRGB]      = { 0, 0 },
-        [XGL_FMT_ASTC_12x12_UNORM]     = { 0, 0 },
-        [XGL_FMT_ASTC_12x12_SRGB]      = { 0, 0 },
-        [XGL_FMT_B4G4R4A4_UNORM]       = { 2, 4 },
-        [XGL_FMT_B5G5R5A1_UNORM]       = { 2, 4 },
-        [XGL_FMT_B5G6R5_UNORM]         = { 2, 3 },
-        [XGL_FMT_B5G6R5_USCALED]       = { 2, 3 },
-        [XGL_FMT_B8G8R8_UNORM]         = { 3, 3 },
-        [XGL_FMT_B8G8R8_SNORM]         = { 3, 3 },
-        [XGL_FMT_B8G8R8_USCALED]       = { 3, 3 },
-        [XGL_FMT_B8G8R8_SSCALED]       = { 3, 3 },
-        [XGL_FMT_B8G8R8_UINT]          = { 3, 3 },
-        [XGL_FMT_B8G8R8_SINT]          = { 3, 3 },
-        [XGL_FMT_B8G8R8_SRGB]          = { 3, 3 },
-        [XGL_FMT_B8G8R8A8_UNORM]       = { 4, 4 },
-        [XGL_FMT_B8G8R8A8_SNORM]       = { 4, 4 },
-        [XGL_FMT_B8G8R8A8_USCALED]     = { 4, 4 },
-        [XGL_FMT_B8G8R8A8_SSCALED]     = { 4, 4 },
-        [XGL_FMT_B8G8R8A8_UINT]        = { 4, 4 },
-        [XGL_FMT_B8G8R8A8_SINT]        = { 4, 4 },
-        [XGL_FMT_B8G8R8A8_SRGB]        = { 4, 4 },
-        [XGL_FMT_B10G10R10A2_UNORM]    = { 4, 4 },
-        [XGL_FMT_B10G10R10A2_SNORM]    = { 4, 4 },
-        [XGL_FMT_B10G10R10A2_USCALED]  = { 4, 4 },
-        [XGL_FMT_B10G10R10A2_SSCALED]  = { 4, 4 },
-        [XGL_FMT_B10G10R10A2_UINT]     = { 4, 4 },
-        [XGL_FMT_B10G10R10A2_SINT]     = { 4, 4 },
+        [VK_FMT_ETC2_R8G8B8_UNORM]    = { 0, 0 },
+        [VK_FMT_ETC2_R8G8B8_SRGB]     = { 0, 0 },
+        [VK_FMT_ETC2_R8G8B8A1_UNORM]  = { 0, 0 },
+        [VK_FMT_ETC2_R8G8B8A1_SRGB]   = { 0, 0 },
+        [VK_FMT_ETC2_R8G8B8A8_UNORM]  = { 0, 0 },
+        [VK_FMT_ETC2_R8G8B8A8_SRGB]   = { 0, 0 },
+        [VK_FMT_EAC_R11_UNORM]        = { 0, 0 },
+        [VK_FMT_EAC_R11_SNORM]        = { 0, 0 },
+        [VK_FMT_EAC_R11G11_UNORM]     = { 0, 0 },
+        [VK_FMT_EAC_R11G11_SNORM]     = { 0, 0 },
+        [VK_FMT_ASTC_4x4_UNORM]       = { 0, 0 },
+        [VK_FMT_ASTC_4x4_SRGB]        = { 0, 0 },
+        [VK_FMT_ASTC_5x4_UNORM]       = { 0, 0 },
+        [VK_FMT_ASTC_5x4_SRGB]        = { 0, 0 },
+        [VK_FMT_ASTC_5x5_UNORM]       = { 0, 0 },
+        [VK_FMT_ASTC_5x5_SRGB]        = { 0, 0 },
+        [VK_FMT_ASTC_6x5_UNORM]       = { 0, 0 },
+        [VK_FMT_ASTC_6x5_SRGB]        = { 0, 0 },
+        [VK_FMT_ASTC_6x6_UNORM]       = { 0, 0 },
+        [VK_FMT_ASTC_6x6_SRGB]        = { 0, 0 },
+        [VK_FMT_ASTC_8x5_UNORM]       = { 0, 0 },
+        [VK_FMT_ASTC_8x5_SRGB]        = { 0, 0 },
+        [VK_FMT_ASTC_8x6_UNORM]       = { 0, 0 },
+        [VK_FMT_ASTC_8x6_SRGB]        = { 0, 0 },
+        [VK_FMT_ASTC_8x8_UNORM]       = { 0, 0 },
+        [VK_FMT_ASTC_8x8_SRGB]        = { 0, 0 },
+        [VK_FMT_ASTC_10x5_UNORM]      = { 0, 0 },
+        [VK_FMT_ASTC_10x5_SRGB]       = { 0, 0 },
+        [VK_FMT_ASTC_10x6_UNORM]      = { 0, 0 },
+        [VK_FMT_ASTC_10x6_SRGB]       = { 0, 0 },
+        [VK_FMT_ASTC_10x8_UNORM]      = { 0, 0 },
+        [VK_FMT_ASTC_10x8_SRGB]       = { 0, 0 },
+        [VK_FMT_ASTC_10x10_UNORM]     = { 0, 0 },
+        [VK_FMT_ASTC_10x10_SRGB]      = { 0, 0 },
+        [VK_FMT_ASTC_12x10_UNORM]     = { 0, 0 },
+        [VK_FMT_ASTC_12x10_SRGB]      = { 0, 0 },
+        [VK_FMT_ASTC_12x12_UNORM]     = { 0, 0 },
+        [VK_FMT_ASTC_12x12_SRGB]      = { 0, 0 },
+        [VK_FMT_B4G4R4A4_UNORM]       = { 2, 4 },
+        [VK_FMT_B5G5R5A1_UNORM]       = { 2, 4 },
+        [VK_FMT_B5G6R5_UNORM]         = { 2, 3 },
+        [VK_FMT_B5G6R5_USCALED]       = { 2, 3 },
+        [VK_FMT_B8G8R8_UNORM]         = { 3, 3 },
+        [VK_FMT_B8G8R8_SNORM]         = { 3, 3 },
+        [VK_FMT_B8G8R8_USCALED]       = { 3, 3 },
+        [VK_FMT_B8G8R8_SSCALED]       = { 3, 3 },
+        [VK_FMT_B8G8R8_UINT]          = { 3, 3 },
+        [VK_FMT_B8G8R8_SINT]          = { 3, 3 },
+        [VK_FMT_B8G8R8_SRGB]          = { 3, 3 },
+        [VK_FMT_B8G8R8A8_UNORM]       = { 4, 4 },
+        [VK_FMT_B8G8R8A8_SNORM]       = { 4, 4 },
+        [VK_FMT_B8G8R8A8_USCALED]     = { 4, 4 },
+        [VK_FMT_B8G8R8A8_SSCALED]     = { 4, 4 },
+        [VK_FMT_B8G8R8A8_UINT]        = { 4, 4 },
+        [VK_FMT_B8G8R8A8_SINT]        = { 4, 4 },
+        [VK_FMT_B8G8R8A8_SRGB]        = { 4, 4 },
+        [VK_FMT_B10G10R10A2_UNORM]    = { 4, 4 },
+        [VK_FMT_B10G10R10A2_SNORM]    = { 4, 4 },
+        [VK_FMT_B10G10R10A2_USCALED]  = { 4, 4 },
+        [VK_FMT_B10G10R10A2_SSCALED]  = { 4, 4 },
+        [VK_FMT_B10G10R10A2_UINT]     = { 4, 4 },
+        [VK_FMT_B10G10R10A2_SINT]     = { 4, 4 },
     };
 
     return format_table[format].size;
 }
 
-XGL_EXTENT3D get_mip_level_extent(const XGL_EXTENT3D &extent, uint32_t mip_level)
+VK_EXTENT3D get_mip_level_extent(const VK_EXTENT3D &extent, uint32_t mip_level)
 {
-    const XGL_EXTENT3D ext = {
+    const VK_EXTENT3D ext = {
         (extent.width  >> mip_level) ? extent.width  >> mip_level : 1,
         (extent.height >> mip_level) ? extent.height >> mip_level : 1,
         (extent.depth  >> mip_level) ? extent.depth  >> mip_level : 1,
@@ -493,23 +493,23 @@
     return ext;
 }
 
-}; // namespace xgl_testing
+}; // namespace vk_testing
 
 namespace {
 
 #define DO(action) ASSERT_EQ(true, action);
 
-static xgl_testing::Environment *environment;
+static vk_testing::Environment *environment;
 
 class XglCmdBlitTest : public ::testing::Test {
 protected:
     XglCmdBlitTest() :
         dev_(environment->default_device()),
         queue_(*dev_.graphics_queues()[0]),
-        cmd_(dev_, xgl_testing::CmdBuffer::create_info(dev_.graphics_queue_node_index_))
+        cmd_(dev_, vk_testing::CmdBuffer::create_info(dev_.graphics_queue_node_index_))
     {
         // make sure every test uses a different pattern
-        xgl_testing::ImageChecker::hash_salt_generate();
+        vk_testing::ImageChecker::hash_salt_generate();
     }
 
     bool submit_and_done()
@@ -520,11 +520,11 @@
         return true;
     }
 
-    void add_memory_ref(const xgl_testing::Object &obj)
+    void add_memory_ref(const vk_testing::Object &obj)
     {
-        const std::vector<XGL_GPU_MEMORY> mems = obj.memories();
-        for (std::vector<XGL_GPU_MEMORY>::const_iterator it = mems.begin(); it != mems.end(); it++) {
-            std::vector<XGL_GPU_MEMORY>::iterator ref;
+        const std::vector<VK_GPU_MEMORY> mems = obj.memories();
+        for (std::vector<VK_GPU_MEMORY>::const_iterator it = mems.begin(); it != mems.end(); it++) {
+            std::vector<VK_GPU_MEMORY>::iterator ref;
             for (ref = mem_refs_.begin(); ref != mem_refs_.end(); ref++) {
                 if (*ref == *it)
                     break;
@@ -536,25 +536,25 @@
         }
     }
 
-    xgl_testing::Device &dev_;
-    xgl_testing::Queue &queue_;
-    xgl_testing::CmdBuffer cmd_;
+    vk_testing::Device &dev_;
+    vk_testing::Queue &queue_;
+    vk_testing::CmdBuffer cmd_;
 
-    std::vector<XGL_GPU_MEMORY> mem_refs_;
+    std::vector<VK_GPU_MEMORY> mem_refs_;
 };
 
 typedef XglCmdBlitTest XglCmdFillBufferTest;
 
 TEST_F(XglCmdFillBufferTest, Basic)
 {
-    xgl_testing::Buffer buf;
+    vk_testing::Buffer buf;
 
     buf.init(dev_, 20);
     add_memory_ref(buf);
 
     cmd_.begin();
-    xglCmdFillBuffer(cmd_.obj(), buf.obj(), 0, 4, 0x11111111);
-    xglCmdFillBuffer(cmd_.obj(), buf.obj(), 4, 16, 0x22222222);
+    vkCmdFillBuffer(cmd_.obj(), buf.obj(), 0, 4, 0x11111111);
+    vkCmdFillBuffer(cmd_.obj(), buf.obj(), 4, 16, 0x22222222);
     cmd_.end();
 
     submit_and_done();
@@ -570,21 +570,21 @@
 
 TEST_F(XglCmdFillBufferTest, Large)
 {
-    const XGL_GPU_SIZE size = 32 * 1024 * 1024;
-    xgl_testing::Buffer buf;
+    const VK_GPU_SIZE size = 32 * 1024 * 1024;
+    vk_testing::Buffer buf;
 
     buf.init(dev_, size);
     add_memory_ref(buf);
 
     cmd_.begin();
-    xglCmdFillBuffer(cmd_.obj(), buf.obj(), 0, size / 2, 0x11111111);
-    xglCmdFillBuffer(cmd_.obj(), buf.obj(), size / 2, size / 2, 0x22222222);
+    vkCmdFillBuffer(cmd_.obj(), buf.obj(), 0, size / 2, 0x11111111);
+    vkCmdFillBuffer(cmd_.obj(), buf.obj(), size / 2, size / 2, 0x22222222);
     cmd_.end();
 
     submit_and_done();
 
     const uint32_t *data = static_cast<const uint32_t *>(buf.map());
-    XGL_GPU_SIZE offset;
+    VK_GPU_SIZE offset;
     for (offset = 0; offset < size / 2; offset += 4)
         EXPECT_EQ(0x11111111, data[offset / 4]) << "Offset is: " << offset;
     for (; offset < size; offset += 4)
@@ -594,20 +594,20 @@
 
 TEST_F(XglCmdFillBufferTest, Overlap)
 {
-    xgl_testing::Buffer buf;
+    vk_testing::Buffer buf;
 
     buf.init(dev_, 64);
     add_memory_ref(buf);
 
     cmd_.begin();
-    xglCmdFillBuffer(cmd_.obj(), buf.obj(), 0, 48, 0x11111111);
-    xglCmdFillBuffer(cmd_.obj(), buf.obj(), 32, 32, 0x22222222);
+    vkCmdFillBuffer(cmd_.obj(), buf.obj(), 0, 48, 0x11111111);
+    vkCmdFillBuffer(cmd_.obj(), buf.obj(), 32, 32, 0x22222222);
     cmd_.end();
 
     submit_and_done();
 
     const uint32_t *data = static_cast<const uint32_t *>(buf.map());
-    XGL_GPU_SIZE offset;
+    VK_GPU_SIZE offset;
     for (offset = 0; offset < 32; offset += 4)
         EXPECT_EQ(0x11111111, data[offset / 4]) << "Offset is: " << offset;
     for (; offset < 64; offset += 4)
@@ -617,14 +617,14 @@
 
 TEST_F(XglCmdFillBufferTest, MultiAlignments)
 {
-    xgl_testing::Buffer bufs[9];
-    XGL_GPU_SIZE size = 4;
+    vk_testing::Buffer bufs[9];
+    VK_GPU_SIZE size = 4;
 
     cmd_.begin();
     for (int i = 0; i < ARRAY_SIZE(bufs); i++) {
         bufs[i].init(dev_, size);
         add_memory_ref(bufs[i]);
-        xglCmdFillBuffer(cmd_.obj(), bufs[i].obj(), 0, size, 0x11111111);
+        vkCmdFillBuffer(cmd_.obj(), bufs[i].obj(), 0, size, 0x11111111);
         size <<= 1;
     }
     cmd_.end();
@@ -634,7 +634,7 @@
     size = 4;
     for (int i = 0; i < ARRAY_SIZE(bufs); i++) {
         const uint32_t *data = static_cast<const uint32_t *>(bufs[i].map());
-        XGL_GPU_SIZE offset;
+        VK_GPU_SIZE offset;
         for (offset = 0; offset < size; offset += 4)
             EXPECT_EQ(0x11111111, data[offset / 4]) << "Buffser is: " << i << "\n" <<
                                                        "Offset is: " << offset;
@@ -648,7 +648,7 @@
 
 TEST_F(XglCmdCopyBufferTest, Basic)
 {
-    xgl_testing::Buffer src, dst;
+    vk_testing::Buffer src, dst;
 
     src.init(dev_, 4);
     uint32_t *data = static_cast<uint32_t *>(src.map());
@@ -660,9 +660,9 @@
     add_memory_ref(dst);
 
     cmd_.begin();
-    XGL_BUFFER_COPY region = {};
+    VK_BUFFER_COPY region = {};
     region.copySize = 4;
-    xglCmdCopyBuffer(cmd_.obj(), src.obj(), dst.obj(), 1, &region);
+    vkCmdCopyBuffer(cmd_.obj(), src.obj(), dst.obj(), 1, &region);
     cmd_.end();
 
     submit_and_done();
@@ -674,12 +674,12 @@
 
 TEST_F(XglCmdCopyBufferTest, Large)
 {
-    const XGL_GPU_SIZE size = 32 * 1024 * 1024;
-    xgl_testing::Buffer src, dst;
+    const VK_GPU_SIZE size = 32 * 1024 * 1024;
+    vk_testing::Buffer src, dst;
 
     src.init(dev_, size);
     uint32_t *data = static_cast<uint32_t *>(src.map());
-    XGL_GPU_SIZE offset;
+    VK_GPU_SIZE offset;
     for (offset = 0; offset < size; offset += 4)
         data[offset / 4] = offset;
     src.unmap();
@@ -689,9 +689,9 @@
     add_memory_ref(dst);
 
     cmd_.begin();
-    XGL_BUFFER_COPY region = {};
+    VK_BUFFER_COPY region = {};
     region.copySize = size;
-    xglCmdCopyBuffer(cmd_.obj(), src.obj(), dst.obj(), 1, &region);
+    vkCmdCopyBuffer(cmd_.obj(), src.obj(), dst.obj(), 1, &region);
     cmd_.end();
 
     submit_and_done();
@@ -704,7 +704,7 @@
 
 TEST_F(XglCmdCopyBufferTest, MultiAlignments)
 {
-    const XGL_BUFFER_COPY regions[] = {
+    const VK_BUFFER_COPY regions[] = {
         /* well aligned */
         {  0,   0,  256 },
         {  0, 256,  128 },
@@ -720,7 +720,7 @@
         { 45, 570,   15 },
         { 50, 590,    1 },
     };
-    xgl_testing::Buffer src, dst;
+    vk_testing::Buffer src, dst;
 
     src.init(dev_, 256);
     uint8_t *data = static_cast<uint8_t *>(src.map());
@@ -733,14 +733,14 @@
     add_memory_ref(dst);
 
     cmd_.begin();
-    xglCmdCopyBuffer(cmd_.obj(), src.obj(), dst.obj(), ARRAY_SIZE(regions), regions);
+    vkCmdCopyBuffer(cmd_.obj(), src.obj(), dst.obj(), ARRAY_SIZE(regions), regions);
     cmd_.end();
 
     submit_and_done();
 
     data = static_cast<uint8_t *>(dst.map());
     for (int i = 0; i < ARRAY_SIZE(regions); i++) {
-        const XGL_BUFFER_COPY &r = regions[i];
+        const VK_BUFFER_COPY &r = regions[i];
 
         for (int j = 0; j < r.copySize; j++) {
             EXPECT_EQ(r.srcOffset + j, data[r.destOffset + j]) <<
@@ -753,52 +753,52 @@
 
 TEST_F(XglCmdCopyBufferTest, RAWHazard)
 {
-    xgl_testing::Buffer bufs[3];
-    XGL_EVENT_CREATE_INFO event_info;
-    XGL_EVENT event;
-    XGL_MEMORY_REQUIREMENTS mem_req;
+    vk_testing::Buffer bufs[3];
+    VK_EVENT_CREATE_INFO event_info;
+    VK_EVENT event;
+    VK_MEMORY_REQUIREMENTS mem_req;
     size_t data_size = sizeof(mem_req);
-    XGL_RESULT err;
+    VK_RESULT err;
 
-    //        typedef struct _XGL_EVENT_CREATE_INFO
+    //        typedef struct _VK_EVENT_CREATE_INFO
     //        {
-    //            XGL_STRUCTURE_TYPE                      sType;      // Must be XGL_STRUCTURE_TYPE_EVENT_CREATE_INFO
+    //            VK_STRUCTURE_TYPE                      sType;      // Must be VK_STRUCTURE_TYPE_EVENT_CREATE_INFO
     //            const void*                             pNext;      // Pointer to next structure
-    //            XGL_FLAGS                               flags;      // Reserved
-    //        } XGL_EVENT_CREATE_INFO;
+    //            VK_FLAGS                               flags;      // Reserved
+    //        } VK_EVENT_CREATE_INFO;
     memset(&event_info, 0, sizeof(event_info));
-    event_info.sType = XGL_STRUCTURE_TYPE_EVENT_CREATE_INFO;
+    event_info.sType = VK_STRUCTURE_TYPE_EVENT_CREATE_INFO;
 
-    err = xglCreateEvent(dev_.obj(), &event_info, &event);
-    ASSERT_XGL_SUCCESS(err);
+    err = vkCreateEvent(dev_.obj(), &event_info, &event);
+    ASSERT_VK_SUCCESS(err);
 
-    err = xglGetObjectInfo(event, XGL_INFO_TYPE_MEMORY_REQUIREMENTS,
+    err = vkGetObjectInfo(event, VK_INFO_TYPE_MEMORY_REQUIREMENTS,
                            &data_size, &mem_req);
-    ASSERT_XGL_SUCCESS(err);
+    ASSERT_VK_SUCCESS(err);
 
-    //        XGL_RESULT XGLAPI xglAllocMemory(
-    //            XGL_DEVICE                                  device,
-    //            const XGL_MEMORY_ALLOC_INFO*                pAllocInfo,
-    //            XGL_GPU_MEMORY*                             pMem);
-    XGL_MEMORY_ALLOC_INFO mem_info;
-    XGL_GPU_MEMORY event_mem;
+    //        VK_RESULT VKAPI vkAllocMemory(
+    //            VK_DEVICE                                  device,
+    //            const VK_MEMORY_ALLOC_INFO*                pAllocInfo,
+    //            VK_GPU_MEMORY*                             pMem);
+    VK_MEMORY_ALLOC_INFO mem_info;
+    VK_GPU_MEMORY event_mem;
 
-    ASSERT_NE(0, mem_req.size) << "xglGetObjectInfo (Event): Failed - expect events to require memory";
+    ASSERT_NE(0, mem_req.size) << "vkGetObjectInfo (Event): Failed - expect events to require memory";
 
     memset(&mem_info, 0, sizeof(mem_info));
-    mem_info.sType = XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO;
+    mem_info.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO;
     mem_info.allocationSize = mem_req.size;
     mem_info.memType = mem_req.memType;
-    mem_info.memPriority = XGL_MEMORY_PRIORITY_NORMAL;
-    mem_info.memProps = XGL_MEMORY_PROPERTY_SHAREABLE_BIT;
-    err = xglAllocMemory(dev_.obj(), &mem_info, &event_mem);
-    ASSERT_XGL_SUCCESS(err);
+    mem_info.memPriority = VK_MEMORY_PRIORITY_NORMAL;
+    mem_info.memProps = VK_MEMORY_PROPERTY_SHAREABLE_BIT;
+    err = vkAllocMemory(dev_.obj(), &mem_info, &event_mem);
+    ASSERT_VK_SUCCESS(err);
 
-    err = xglBindObjectMemory(event, 0, event_mem, 0);
-    ASSERT_XGL_SUCCESS(err);
+    err = vkBindObjectMemory(event, 0, event_mem, 0);
+    ASSERT_VK_SUCCESS(err);
 
-    err = xglResetEvent(event);
-    ASSERT_XGL_SUCCESS(err);
+    err = vkResetEvent(event);
+    ASSERT_VK_SUCCESS(err);
 
     for (int i = 0; i < ARRAY_SIZE(bufs); i++) {
         bufs[i].init(dev_, 4);
@@ -811,57 +811,57 @@
 
     cmd_.begin();
 
-    xglCmdFillBuffer(cmd_.obj(), bufs[0].obj(), 0, 4, 0x11111111);
+    vkCmdFillBuffer(cmd_.obj(), bufs[0].obj(), 0, 4, 0x11111111);
     // is this necessary?
-    XGL_BUFFER_MEMORY_BARRIER memory_barrier = bufs[0].buffer_memory_barrier(
-            XGL_MEMORY_OUTPUT_COPY_BIT, XGL_MEMORY_INPUT_COPY_BIT, 0, 4);
-    XGL_BUFFER_MEMORY_BARRIER *pmemory_barrier = &memory_barrier;
+    VK_BUFFER_MEMORY_BARRIER memory_barrier = bufs[0].buffer_memory_barrier(
+            VK_MEMORY_OUTPUT_COPY_BIT, VK_MEMORY_INPUT_COPY_BIT, 0, 4);
+    VK_BUFFER_MEMORY_BARRIER *pmemory_barrier = &memory_barrier;
 
-    XGL_PIPE_EVENT set_events[] = { XGL_PIPE_EVENT_TRANSFER_COMPLETE };
-    XGL_PIPELINE_BARRIER pipeline_barrier = {};
-    pipeline_barrier.sType = XGL_STRUCTURE_TYPE_PIPELINE_BARRIER;
+    VK_PIPE_EVENT set_events[] = { VK_PIPE_EVENT_TRANSFER_COMPLETE };
+    VK_PIPELINE_BARRIER pipeline_barrier = {};
+    pipeline_barrier.sType = VK_STRUCTURE_TYPE_PIPELINE_BARRIER;
     pipeline_barrier.eventCount = 1;
     pipeline_barrier.pEvents = set_events;
-    pipeline_barrier.waitEvent = XGL_WAIT_EVENT_TOP_OF_PIPE;
+    pipeline_barrier.waitEvent = VK_WAIT_EVENT_TOP_OF_PIPE;
     pipeline_barrier.memBarrierCount = 1;
     pipeline_barrier.ppMemBarriers = (const void **)&pmemory_barrier;
-    xglCmdPipelineBarrier(cmd_.obj(), &pipeline_barrier);
+    vkCmdPipelineBarrier(cmd_.obj(), &pipeline_barrier);
 
-    XGL_BUFFER_COPY region = {};
+    VK_BUFFER_COPY region = {};
     region.copySize = 4;
-    xglCmdCopyBuffer(cmd_.obj(), bufs[0].obj(), bufs[1].obj(), 1, &region);
+    vkCmdCopyBuffer(cmd_.obj(), bufs[0].obj(), bufs[1].obj(), 1, &region);
 
     memory_barrier = bufs[1].buffer_memory_barrier(
-            XGL_MEMORY_OUTPUT_COPY_BIT, XGL_MEMORY_INPUT_COPY_BIT, 0, 4);
+            VK_MEMORY_OUTPUT_COPY_BIT, VK_MEMORY_INPUT_COPY_BIT, 0, 4);
     pmemory_barrier = &memory_barrier;
-    pipeline_barrier.sType = XGL_STRUCTURE_TYPE_PIPELINE_BARRIER;
+    pipeline_barrier.sType = VK_STRUCTURE_TYPE_PIPELINE_BARRIER;
     pipeline_barrier.eventCount = 1;
     pipeline_barrier.pEvents = set_events;
-    pipeline_barrier.waitEvent = XGL_WAIT_EVENT_TOP_OF_PIPE;
+    pipeline_barrier.waitEvent = VK_WAIT_EVENT_TOP_OF_PIPE;
     pipeline_barrier.memBarrierCount = 1;
     pipeline_barrier.ppMemBarriers = (const void **)&pmemory_barrier;
-    xglCmdPipelineBarrier(cmd_.obj(), &pipeline_barrier);
+    vkCmdPipelineBarrier(cmd_.obj(), &pipeline_barrier);
 
-    xglCmdCopyBuffer(cmd_.obj(), bufs[1].obj(), bufs[2].obj(), 1, &region);
+    vkCmdCopyBuffer(cmd_.obj(), bufs[1].obj(), bufs[2].obj(), 1, &region);
 
-    /* Use xglCmdSetEvent and xglCmdWaitEvents to test them.
-     * This could be xglCmdPipelineBarrier.
+    /* Use vkCmdSetEvent and vkCmdWaitEvents to test them.
+     * This could be vkCmdPipelineBarrier.
      */
-    xglCmdSetEvent(cmd_.obj(), event, XGL_PIPE_EVENT_TRANSFER_COMPLETE);
+    vkCmdSetEvent(cmd_.obj(), event, VK_PIPE_EVENT_TRANSFER_COMPLETE);
 
     // Additional commands could go into the buffer here before the wait.
 
     memory_barrier = bufs[1].buffer_memory_barrier(
-            XGL_MEMORY_OUTPUT_COPY_BIT, XGL_MEMORY_INPUT_CPU_READ_BIT, 0, 4);
+            VK_MEMORY_OUTPUT_COPY_BIT, VK_MEMORY_INPUT_CPU_READ_BIT, 0, 4);
     pmemory_barrier = &memory_barrier;
-    XGL_EVENT_WAIT_INFO wait_info = {};
-    wait_info.sType = XGL_STRUCTURE_TYPE_EVENT_WAIT_INFO;
+    VK_EVENT_WAIT_INFO wait_info = {};
+    wait_info.sType = VK_STRUCTURE_TYPE_EVENT_WAIT_INFO;
     wait_info.eventCount = 1;
     wait_info.pEvents = &event;
-    wait_info.waitEvent = XGL_WAIT_EVENT_TOP_OF_PIPE;
+    wait_info.waitEvent = VK_WAIT_EVENT_TOP_OF_PIPE;
     wait_info.memBarrierCount = 1;
     wait_info.ppMemBarriers = (const void **)&pmemory_barrier;
-    xglCmdWaitEvents(cmd_.obj(), &wait_info);
+    vkCmdWaitEvents(cmd_.obj(), &wait_info);
 
     cmd_.end();
 
@@ -872,33 +872,33 @@
     bufs[2].unmap();
 
     // All done with event memory, clean up
-    err = xglBindObjectMemory(event, 0, XGL_NULL_HANDLE, 0);
-    ASSERT_XGL_SUCCESS(err);
+    err = vkBindObjectMemory(event, 0, VK_NULL_HANDLE, 0);
+    ASSERT_VK_SUCCESS(err);
 
-    err = xglDestroyObject(event);
-    ASSERT_XGL_SUCCESS(err);
+    err = vkDestroyObject(event);
+    ASSERT_VK_SUCCESS(err);
 
-    err = xglFreeMemory(event_mem);
-    ASSERT_XGL_SUCCESS(err);
+    err = vkFreeMemory(event_mem);
+    ASSERT_VK_SUCCESS(err);
 }
 
 class XglCmdBlitImageTest : public XglCmdBlitTest {
 protected:
-    void init_test_formats(XGL_FLAGS features)
+    void init_test_formats(VK_FLAGS features)
     {
-        first_linear_format_ = XGL_FMT_UNDEFINED;
-        first_optimal_format_ = XGL_FMT_UNDEFINED;
+        first_linear_format_ = VK_FMT_UNDEFINED;
+        first_optimal_format_ = VK_FMT_UNDEFINED;
 
-        for (std::vector<xgl_testing::Device::Format>::const_iterator it = dev_.formats().begin();
+        for (std::vector<vk_testing::Device::Format>::const_iterator it = dev_.formats().begin();
              it != dev_.formats().end(); it++) {
             if (it->features & features) {
                 test_formats_.push_back(*it);
 
-                if (it->tiling == XGL_LINEAR_TILING &&
-                    first_linear_format_ == XGL_FMT_UNDEFINED)
+                if (it->tiling == VK_LINEAR_TILING &&
+                    first_linear_format_ == VK_FMT_UNDEFINED)
                     first_linear_format_ = it->format;
-                if (it->tiling == XGL_OPTIMAL_TILING &&
-                    first_optimal_format_ == XGL_FMT_UNDEFINED)
+                if (it->tiling == VK_OPTIMAL_TILING &&
+                    first_optimal_format_ == VK_FMT_UNDEFINED)
                     first_optimal_format_ = it->format;
             }
         }
@@ -906,10 +906,10 @@
 
     void init_test_formats()
     {
-        init_test_formats(static_cast<XGL_FLAGS>(-1));
+        init_test_formats(static_cast<VK_FLAGS>(-1));
     }
 
-    void fill_src(xgl_testing::Image &img, const xgl_testing::ImageChecker &checker)
+    void fill_src(vk_testing::Image &img, const vk_testing::ImageChecker &checker)
     {
         if (img.transparent()) {
             checker.fill(img);
@@ -918,7 +918,7 @@
 
         ASSERT_EQ(true, img.copyable());
 
-        xgl_testing::Buffer in_buf;
+        vk_testing::Buffer in_buf;
         in_buf.init(dev_, checker.buffer_size());
         checker.fill(in_buf);
 
@@ -927,15 +927,15 @@
 
         // copy in and tile
         cmd_.begin();
-        xglCmdCopyBufferToImage(cmd_.obj(), in_buf.obj(),
-                img.obj(), XGL_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL,
+        vkCmdCopyBufferToImage(cmd_.obj(), in_buf.obj(),
+                img.obj(), VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL,
                 checker.regions().size(), &checker.regions()[0]);
         cmd_.end();
 
         submit_and_done();
     }
 
-    void check_dst(xgl_testing::Image &img, const xgl_testing::ImageChecker &checker)
+    void check_dst(vk_testing::Image &img, const vk_testing::ImageChecker &checker)
     {
         if (img.transparent()) {
             DO(checker.check(img));
@@ -944,7 +944,7 @@
 
         ASSERT_EQ(true, img.copyable());
 
-        xgl_testing::Buffer out_buf;
+        vk_testing::Buffer out_buf;
         out_buf.init(dev_, checker.buffer_size());
 
         add_memory_ref(img);
@@ -952,8 +952,8 @@
 
         // copy out and linearize
         cmd_.begin();
-        xglCmdCopyImageToBuffer(cmd_.obj(),
-                img.obj(), XGL_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL,
+        vkCmdCopyImageToBuffer(cmd_.obj(),
+                img.obj(), VK_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL,
                 out_buf.obj(),
                 checker.regions().size(), &checker.regions()[0]);
         cmd_.end();
@@ -963,9 +963,9 @@
         DO(checker.check(out_buf));
     }
 
-    std::vector<xgl_testing::Device::Format> test_formats_;
-    XGL_FORMAT first_linear_format_;
-    XGL_FORMAT first_optimal_format_;
+    std::vector<vk_testing::Device::Format> test_formats_;
+    VK_FORMAT first_linear_format_;
+    VK_FORMAT first_optimal_format_;
 };
 
 class XglCmdCopyBufferToImageTest : public XglCmdBlitImageTest {
@@ -973,14 +973,14 @@
     virtual void SetUp()
     {
         XglCmdBlitTest::SetUp();
-        init_test_formats(XGL_FORMAT_IMAGE_COPY_BIT);
+        init_test_formats(VK_FORMAT_IMAGE_COPY_BIT);
         ASSERT_NE(true, test_formats_.empty());
     }
 
-    void test_copy_memory_to_image(const XGL_IMAGE_CREATE_INFO &img_info, const xgl_testing::ImageChecker &checker)
+    void test_copy_memory_to_image(const VK_IMAGE_CREATE_INFO &img_info, const vk_testing::ImageChecker &checker)
     {
-        xgl_testing::Buffer buf;
-        xgl_testing::Image img;
+        vk_testing::Buffer buf;
+        vk_testing::Image img;
 
         buf.init(dev_, checker.buffer_size());
         checker.fill(buf);
@@ -990,9 +990,9 @@
         add_memory_ref(img);
 
         cmd_.begin();
-        xglCmdCopyBufferToImage(cmd_.obj(),
+        vkCmdCopyBufferToImage(cmd_.obj(),
                 buf.obj(),
-                img.obj(), XGL_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL,
+                img.obj(), VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL,
                 checker.regions().size(), &checker.regions()[0]);
         cmd_.end();
 
@@ -1001,32 +1001,32 @@
         check_dst(img, checker);
     }
 
-    void test_copy_memory_to_image(const XGL_IMAGE_CREATE_INFO &img_info, const std::vector<XGL_BUFFER_IMAGE_COPY> &regions)
+    void test_copy_memory_to_image(const VK_IMAGE_CREATE_INFO &img_info, const std::vector<VK_BUFFER_IMAGE_COPY> &regions)
     {
-        xgl_testing::ImageChecker checker(img_info, regions);
+        vk_testing::ImageChecker checker(img_info, regions);
         test_copy_memory_to_image(img_info, checker);
     }
 
-    void test_copy_memory_to_image(const XGL_IMAGE_CREATE_INFO &img_info)
+    void test_copy_memory_to_image(const VK_IMAGE_CREATE_INFO &img_info)
     {
-        xgl_testing::ImageChecker checker(img_info);
+        vk_testing::ImageChecker checker(img_info);
         test_copy_memory_to_image(img_info, checker);
     }
 };
 
 TEST_F(XglCmdCopyBufferToImageTest, Basic)
 {
-    for (std::vector<xgl_testing::Device::Format>::const_iterator it = test_formats_.begin();
+    for (std::vector<vk_testing::Device::Format>::const_iterator it = test_formats_.begin();
          it != test_formats_.end(); it++) {
 
         // not sure what to do here
-        if (it->format == XGL_FMT_UNDEFINED ||
-            (it->format >= XGL_FMT_B8G8R8_UNORM &&
-             it->format <= XGL_FMT_B8G8R8_SRGB))
+        if (it->format == VK_FMT_UNDEFINED ||
+            (it->format >= VK_FMT_B8G8R8_UNORM &&
+             it->format <= VK_FMT_B8G8R8_SRGB))
             continue;
 
-        XGL_IMAGE_CREATE_INFO img_info = xgl_testing::Image::create_info();
-        img_info.imageType = XGL_IMAGE_2D;
+        VK_IMAGE_CREATE_INFO img_info = vk_testing::Image::create_info();
+        img_info.imageType = VK_IMAGE_2D;
         img_info.format = it->format;
         img_info.extent.width = 64;
         img_info.extent.height = 64;
@@ -1041,14 +1041,14 @@
     virtual void SetUp()
     {
         XglCmdBlitTest::SetUp();
-        init_test_formats(XGL_FORMAT_IMAGE_COPY_BIT);
+        init_test_formats(VK_FORMAT_IMAGE_COPY_BIT);
         ASSERT_NE(true, test_formats_.empty());
     }
 
-    void test_copy_image_to_memory(const XGL_IMAGE_CREATE_INFO &img_info, const xgl_testing::ImageChecker &checker)
+    void test_copy_image_to_memory(const VK_IMAGE_CREATE_INFO &img_info, const vk_testing::ImageChecker &checker)
     {
-        xgl_testing::Image img;
-        xgl_testing::Buffer buf;
+        vk_testing::Image img;
+        vk_testing::Buffer buf;
 
         img.init(dev_, img_info);
         fill_src(img, checker);
@@ -1058,8 +1058,8 @@
         add_memory_ref(buf);
 
         cmd_.begin();
-        xglCmdCopyImageToBuffer(cmd_.obj(),
-                img.obj(), XGL_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL,
+        vkCmdCopyImageToBuffer(cmd_.obj(),
+                img.obj(), VK_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL,
                 buf.obj(),
                 checker.regions().size(), &checker.regions()[0]);
         cmd_.end();
@@ -1069,32 +1069,32 @@
         checker.check(buf);
     }
 
-    void test_copy_image_to_memory(const XGL_IMAGE_CREATE_INFO &img_info, const std::vector<XGL_BUFFER_IMAGE_COPY> &regions)
+    void test_copy_image_to_memory(const VK_IMAGE_CREATE_INFO &img_info, const std::vector<VK_BUFFER_IMAGE_COPY> &regions)
     {
-        xgl_testing::ImageChecker checker(img_info, regions);
+        vk_testing::ImageChecker checker(img_info, regions);
         test_copy_image_to_memory(img_info, checker);
     }
 
-    void test_copy_image_to_memory(const XGL_IMAGE_CREATE_INFO &img_info)
+    void test_copy_image_to_memory(const VK_IMAGE_CREATE_INFO &img_info)
     {
-        xgl_testing::ImageChecker checker(img_info);
+        vk_testing::ImageChecker checker(img_info);
         test_copy_image_to_memory(img_info, checker);
     }
 };
 
 TEST_F(XglCmdCopyImageToBufferTest, Basic)
 {
-    for (std::vector<xgl_testing::Device::Format>::const_iterator it = test_formats_.begin();
+    for (std::vector<vk_testing::Device::Format>::const_iterator it = test_formats_.begin();
          it != test_formats_.end(); it++) {
 
         // not sure what to do here
-        if (it->format == XGL_FMT_UNDEFINED ||
-            (it->format >= XGL_FMT_B8G8R8_UNORM &&
-             it->format <= XGL_FMT_B8G8R8_SRGB))
+        if (it->format == VK_FMT_UNDEFINED ||
+            (it->format >= VK_FMT_B8G8R8_UNORM &&
+             it->format <= VK_FMT_B8G8R8_SRGB))
             continue;
 
-        XGL_IMAGE_CREATE_INFO img_info = xgl_testing::Image::create_info();
-        img_info.imageType = XGL_IMAGE_2D;
+        VK_IMAGE_CREATE_INFO img_info = vk_testing::Image::create_info();
+        img_info.imageType = VK_IMAGE_2D;
         img_info.format = it->format;
         img_info.extent.width = 64;
         img_info.extent.height = 64;
@@ -1109,18 +1109,18 @@
     virtual void SetUp()
     {
         XglCmdBlitTest::SetUp();
-        init_test_formats(XGL_FORMAT_IMAGE_COPY_BIT);
+        init_test_formats(VK_FORMAT_IMAGE_COPY_BIT);
         ASSERT_NE(true, test_formats_.empty());
     }
 
-    void test_copy_image(const XGL_IMAGE_CREATE_INFO &src_info, const XGL_IMAGE_CREATE_INFO &dst_info,
-                         const std::vector<XGL_IMAGE_COPY> &copies)
+    void test_copy_image(const VK_IMAGE_CREATE_INFO &src_info, const VK_IMAGE_CREATE_INFO &dst_info,
+                         const std::vector<VK_IMAGE_COPY> &copies)
     {
-        // convert XGL_IMAGE_COPY to two sets of XGL_BUFFER_IMAGE_COPY
-        std::vector<XGL_BUFFER_IMAGE_COPY> src_regions, dst_regions;
-        XGL_GPU_SIZE src_offset = 0, dst_offset = 0;
-        for (std::vector<XGL_IMAGE_COPY>::const_iterator it = copies.begin(); it != copies.end(); it++) {
-            XGL_BUFFER_IMAGE_COPY src_region = {}, dst_region = {};
+        // convert VK_IMAGE_COPY to two sets of VK_BUFFER_IMAGE_COPY
+        std::vector<VK_BUFFER_IMAGE_COPY> src_regions, dst_regions;
+        VK_GPU_SIZE src_offset = 0, dst_offset = 0;
+        for (std::vector<VK_IMAGE_COPY>::const_iterator it = copies.begin(); it != copies.end(); it++) {
+            VK_BUFFER_IMAGE_COPY src_region = {}, dst_region = {};
 
             src_region.bufferOffset = src_offset;
             src_region.imageSubresource = it->srcSubresource;
@@ -1134,27 +1134,27 @@
             dst_region.imageExtent = it->extent;
             dst_regions.push_back(dst_region);
 
-            const XGL_GPU_SIZE size = it->extent.width * it->extent.height * it->extent.depth;
-            src_offset += xgl_testing::get_format_size(src_info.format) * size;
-            dst_offset += xgl_testing::get_format_size(dst_info.format) * size;
+            const VK_GPU_SIZE size = it->extent.width * it->extent.height * it->extent.depth;
+            src_offset += vk_testing::get_format_size(src_info.format) * size;
+            dst_offset += vk_testing::get_format_size(dst_info.format) * size;
         }
 
-        xgl_testing::ImageChecker src_checker(src_info, src_regions);
-        xgl_testing::ImageChecker dst_checker(dst_info, dst_regions);
+        vk_testing::ImageChecker src_checker(src_info, src_regions);
+        vk_testing::ImageChecker dst_checker(dst_info, dst_regions);
 
-        xgl_testing::Image src;
+        vk_testing::Image src;
         src.init(dev_, src_info);
         fill_src(src, src_checker);
         add_memory_ref(src);
 
-        xgl_testing::Image dst;
+        vk_testing::Image dst;
         dst.init(dev_, dst_info);
         add_memory_ref(dst);
 
         cmd_.begin();
-        xglCmdCopyImage(cmd_.obj(),
-                        src.obj(), XGL_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL,
-                        dst.obj(), XGL_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL,
+        vkCmdCopyImage(cmd_.obj(),
+                        src.obj(), VK_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL,
+                        dst.obj(), VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL,
                         copies.size(), &copies[0]);
         cmd_.end();
 
@@ -1166,28 +1166,28 @@
 
 TEST_F(XglCmdCopyImageTest, Basic)
 {
-    for (std::vector<xgl_testing::Device::Format>::const_iterator it = test_formats_.begin();
+    for (std::vector<vk_testing::Device::Format>::const_iterator it = test_formats_.begin();
          it != test_formats_.end(); it++) {
 
         // not sure what to do here
-        if (it->format == XGL_FMT_UNDEFINED ||
-            (it->format >= XGL_FMT_B8G8R8_UNORM &&
-             it->format <= XGL_FMT_B8G8R8_SRGB))
+        if (it->format == VK_FMT_UNDEFINED ||
+            (it->format >= VK_FMT_B8G8R8_UNORM &&
+             it->format <= VK_FMT_B8G8R8_SRGB))
             continue;
 
-        XGL_IMAGE_CREATE_INFO img_info = xgl_testing::Image::create_info();
-        img_info.imageType = XGL_IMAGE_2D;
+        VK_IMAGE_CREATE_INFO img_info = vk_testing::Image::create_info();
+        img_info.imageType = VK_IMAGE_2D;
         img_info.format = it->format;
         img_info.extent.width = 64;
         img_info.extent.height = 64;
         img_info.tiling = it->tiling;
 
-        XGL_IMAGE_COPY copy = {};
-        copy.srcSubresource = xgl_testing::Image::subresource(XGL_IMAGE_ASPECT_COLOR, 0, 0);
+        VK_IMAGE_COPY copy = {};
+        copy.srcSubresource = vk_testing::Image::subresource(VK_IMAGE_ASPECT_COLOR, 0, 0);
         copy.destSubresource = copy.srcSubresource;
         copy.extent = img_info.extent;
 
-        test_copy_image(img_info, img_info, std::vector<XGL_IMAGE_COPY>(&copy, &copy + 1));
+        test_copy_image(img_info, img_info, std::vector<VK_IMAGE_COPY>(&copy, &copy + 1));
     }
 }
 
@@ -1200,10 +1200,10 @@
         ASSERT_NE(true, test_formats_.empty());
     }
 
-    void test_clone_image_data(const XGL_IMAGE_CREATE_INFO &img_info)
+    void test_clone_image_data(const VK_IMAGE_CREATE_INFO &img_info)
     {
-        xgl_testing::ImageChecker checker(img_info);
-        xgl_testing::Image src, dst;
+        vk_testing::ImageChecker checker(img_info);
+        vk_testing::Image src, dst;
 
         src.init(dev_, img_info);
         if (src.transparent() || src.copyable())
@@ -1213,10 +1213,10 @@
         dst.init(dev_, img_info);
         add_memory_ref(dst);
 
-        const XGL_IMAGE_LAYOUT layout = XGL_IMAGE_LAYOUT_GENERAL;
+        const VK_IMAGE_LAYOUT layout = VK_IMAGE_LAYOUT_GENERAL;
 
         cmd_.begin();
-        xglCmdCloneImageData(cmd_.obj(), src.obj(), layout, dst.obj(), layout);
+        vkCmdCloneImageData(cmd_.obj(), src.obj(), layout, dst.obj(), layout);
         cmd_.end();
 
         submit_and_done();
@@ -1231,33 +1231,33 @@
 
 TEST_F(XglCmdCloneImageDataTest, Basic)
 {
-    for (std::vector<xgl_testing::Device::Format>::const_iterator it = test_formats_.begin();
+    for (std::vector<vk_testing::Device::Format>::const_iterator it = test_formats_.begin();
          it != test_formats_.end(); it++) {
         // not sure what to do here
-        if (it->format == XGL_FMT_UNDEFINED ||
-            (it->format >= XGL_FMT_R32G32B32_UINT &&
-             it->format <= XGL_FMT_R32G32B32_SFLOAT) ||
-            (it->format >= XGL_FMT_B8G8R8_UNORM &&
-             it->format <= XGL_FMT_B8G8R8_SRGB) ||
-            (it->format >= XGL_FMT_BC1_RGB_UNORM &&
-             it->format <= XGL_FMT_ASTC_12x12_SRGB) ||
-            (it->format >= XGL_FMT_D16_UNORM &&
-             it->format <= XGL_FMT_D32_SFLOAT_S8_UINT) ||
-            it->format == XGL_FMT_R64G64B64_SFLOAT ||
-            it->format == XGL_FMT_R64G64B64A64_SFLOAT)
+        if (it->format == VK_FMT_UNDEFINED ||
+            (it->format >= VK_FMT_R32G32B32_UINT &&
+             it->format <= VK_FMT_R32G32B32_SFLOAT) ||
+            (it->format >= VK_FMT_B8G8R8_UNORM &&
+             it->format <= VK_FMT_B8G8R8_SRGB) ||
+            (it->format >= VK_FMT_BC1_RGB_UNORM &&
+             it->format <= VK_FMT_ASTC_12x12_SRGB) ||
+            (it->format >= VK_FMT_D16_UNORM &&
+             it->format <= VK_FMT_D32_SFLOAT_S8_UINT) ||
+            it->format == VK_FMT_R64G64B64_SFLOAT ||
+            it->format == VK_FMT_R64G64B64A64_SFLOAT)
             continue;
 
-        XGL_IMAGE_CREATE_INFO img_info = xgl_testing::Image::create_info();
-        img_info.imageType = XGL_IMAGE_2D;
+        VK_IMAGE_CREATE_INFO img_info = vk_testing::Image::create_info();
+        img_info.imageType = VK_IMAGE_2D;
         img_info.format = it->format;
         img_info.extent.width = 64;
         img_info.extent.height = 64;
         img_info.tiling = it->tiling;
-        img_info.flags = XGL_IMAGE_CREATE_CLONEABLE_BIT;
+        img_info.flags = VK_IMAGE_CREATE_CLONEABLE_BIT;
 
-        const XGL_IMAGE_SUBRESOURCE_RANGE range =
-            xgl_testing::Image::subresource_range(img_info, XGL_IMAGE_ASPECT_COLOR);
-        std::vector<XGL_IMAGE_SUBRESOURCE_RANGE> ranges(&range, &range + 1);
+        const VK_IMAGE_SUBRESOURCE_RANGE range =
+            vk_testing::Image::subresource_range(img_info, VK_IMAGE_ASPECT_COLOR);
+        std::vector<VK_IMAGE_SUBRESOURCE_RANGE> ranges(&range, &range + 1);
 
         test_clone_image_data(img_info);
     }
@@ -1275,7 +1275,7 @@
         if (test_raw_)
             init_test_formats();
         else
-            init_test_formats(XGL_FORMAT_CONVERSION_BIT);
+            init_test_formats(VK_FORMAT_CONVERSION_BIT);
 
         ASSERT_NE(true, test_formats_.empty());
     }
@@ -1287,19 +1287,19 @@
 
     bool test_raw_;
 
-    std::vector<uint8_t> color_to_raw(XGL_FORMAT format, const float color[4])
+    std::vector<uint8_t> color_to_raw(VK_FORMAT format, const float color[4])
     {
         std::vector<uint8_t> raw;
 
         // TODO support all formats
         switch (format) {
-        case XGL_FMT_R8G8B8A8_UNORM:
+        case VK_FMT_R8G8B8A8_UNORM:
             raw.push_back(color[0] * 255.0f);
             raw.push_back(color[1] * 255.0f);
             raw.push_back(color[2] * 255.0f);
             raw.push_back(color[3] * 255.0f);
             break;
-        case XGL_FMT_B8G8R8A8_UNORM:
+        case VK_FMT_B8G8R8A8_UNORM:
             raw.push_back(color[2] * 255.0f);
             raw.push_back(color[1] * 255.0f);
             raw.push_back(color[0] * 255.0f);
@@ -1312,19 +1312,19 @@
         return raw;
     }
 
-    std::vector<uint8_t> color_to_raw(XGL_FORMAT format, const uint32_t color[4])
+    std::vector<uint8_t> color_to_raw(VK_FORMAT format, const uint32_t color[4])
     {
         std::vector<uint8_t> raw;
 
         // TODO support all formats
         switch (format) {
-        case XGL_FMT_R8G8B8A8_UNORM:
+        case VK_FMT_R8G8B8A8_UNORM:
             raw.push_back(static_cast<uint8_t>(color[0]));
             raw.push_back(static_cast<uint8_t>(color[1]));
             raw.push_back(static_cast<uint8_t>(color[2]));
             raw.push_back(static_cast<uint8_t>(color[3]));
             break;
-        case XGL_FMT_B8G8R8A8_UNORM:
+        case VK_FMT_B8G8R8A8_UNORM:
             raw.push_back(static_cast<uint8_t>(color[2]));
             raw.push_back(static_cast<uint8_t>(color[1]));
             raw.push_back(static_cast<uint8_t>(color[0]));
@@ -1337,7 +1337,7 @@
         return raw;
     }
 
-    std::vector<uint8_t> color_to_raw(XGL_FORMAT format, const XGL_CLEAR_COLOR &color)
+    std::vector<uint8_t> color_to_raw(VK_FORMAT format, const VK_CLEAR_COLOR &color)
     {
         if (color.useRawValue)
             return color_to_raw(format, color.color.rawColor);
@@ -1345,71 +1345,71 @@
             return color_to_raw(format, color.color.floatColor);
     }
 
-    void test_clear_color_image(const XGL_IMAGE_CREATE_INFO &img_info,
-                                const XGL_CLEAR_COLOR &clear_color,
-                                const std::vector<XGL_IMAGE_SUBRESOURCE_RANGE> &ranges)
+    void test_clear_color_image(const VK_IMAGE_CREATE_INFO &img_info,
+                                const VK_CLEAR_COLOR &clear_color,
+                                const std::vector<VK_IMAGE_SUBRESOURCE_RANGE> &ranges)
     {
-        xgl_testing::Image img;
+        vk_testing::Image img;
         img.init(dev_, img_info);
         add_memory_ref(img);
-        const XGL_FLAGS all_cache_outputs =
-                XGL_MEMORY_OUTPUT_CPU_WRITE_BIT |
-                XGL_MEMORY_OUTPUT_SHADER_WRITE_BIT |
-                XGL_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT |
-                XGL_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT |
-                XGL_MEMORY_OUTPUT_COPY_BIT;
-        const XGL_FLAGS all_cache_inputs =
-                XGL_MEMORY_INPUT_CPU_READ_BIT |
-                XGL_MEMORY_INPUT_INDIRECT_COMMAND_BIT |
-                XGL_MEMORY_INPUT_INDEX_FETCH_BIT |
-                XGL_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT |
-                XGL_MEMORY_INPUT_UNIFORM_READ_BIT |
-                XGL_MEMORY_INPUT_SHADER_READ_BIT |
-                XGL_MEMORY_INPUT_COLOR_ATTACHMENT_BIT |
-                XGL_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT |
-                XGL_MEMORY_INPUT_COPY_BIT;
+        const VK_FLAGS all_cache_outputs =
+                VK_MEMORY_OUTPUT_CPU_WRITE_BIT |
+                VK_MEMORY_OUTPUT_SHADER_WRITE_BIT |
+                VK_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT |
+                VK_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT |
+                VK_MEMORY_OUTPUT_COPY_BIT;
+        const VK_FLAGS all_cache_inputs =
+                VK_MEMORY_INPUT_CPU_READ_BIT |
+                VK_MEMORY_INPUT_INDIRECT_COMMAND_BIT |
+                VK_MEMORY_INPUT_INDEX_FETCH_BIT |
+                VK_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT |
+                VK_MEMORY_INPUT_UNIFORM_READ_BIT |
+                VK_MEMORY_INPUT_SHADER_READ_BIT |
+                VK_MEMORY_INPUT_COLOR_ATTACHMENT_BIT |
+                VK_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT |
+                VK_MEMORY_INPUT_COPY_BIT;
 
-        std::vector<XGL_IMAGE_MEMORY_BARRIER> to_clear;
-        std::vector<XGL_IMAGE_MEMORY_BARRIER *> p_to_clear;
-        std::vector<XGL_IMAGE_MEMORY_BARRIER> to_xfer;
-        std::vector<XGL_IMAGE_MEMORY_BARRIER *> p_to_xfer;
+        std::vector<VK_IMAGE_MEMORY_BARRIER> to_clear;
+        std::vector<VK_IMAGE_MEMORY_BARRIER *> p_to_clear;
+        std::vector<VK_IMAGE_MEMORY_BARRIER> to_xfer;
+        std::vector<VK_IMAGE_MEMORY_BARRIER *> p_to_xfer;
 
-        for (std::vector<XGL_IMAGE_SUBRESOURCE_RANGE>::const_iterator it = ranges.begin();
+        for (std::vector<VK_IMAGE_SUBRESOURCE_RANGE>::const_iterator it = ranges.begin();
              it != ranges.end(); it++) {
             to_clear.push_back(img.image_memory_barrier(all_cache_outputs, all_cache_inputs,
-                    XGL_IMAGE_LAYOUT_GENERAL,
-                    XGL_IMAGE_LAYOUT_CLEAR_OPTIMAL,
+                    VK_IMAGE_LAYOUT_GENERAL,
+                    VK_IMAGE_LAYOUT_CLEAR_OPTIMAL,
                     *it));
             p_to_clear.push_back(&to_clear.back());
             to_xfer.push_back(img.image_memory_barrier(all_cache_outputs, all_cache_inputs,
-                    XGL_IMAGE_LAYOUT_CLEAR_OPTIMAL,
-                    XGL_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL, *it));
+                    VK_IMAGE_LAYOUT_CLEAR_OPTIMAL,
+                    VK_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL, *it));
             p_to_xfer.push_back(&to_xfer.back());
         }
 
         cmd_.begin();
 
-        XGL_PIPE_EVENT set_events[] = { XGL_PIPE_EVENT_GPU_COMMANDS_COMPLETE };
-        XGL_PIPELINE_BARRIER pipeline_barrier = {};
-        pipeline_barrier.sType = XGL_STRUCTURE_TYPE_PIPELINE_BARRIER;
+        VK_PIPE_EVENT set_events[] = { VK_PIPE_EVENT_GPU_COMMANDS_COMPLETE };
+        VK_PIPELINE_BARRIER pipeline_barrier = {};
+        pipeline_barrier.sType = VK_STRUCTURE_TYPE_PIPELINE_BARRIER;
         pipeline_barrier.eventCount = 1;
         pipeline_barrier.pEvents = set_events;
-        pipeline_barrier.waitEvent = XGL_WAIT_EVENT_TOP_OF_PIPE;
+        pipeline_barrier.waitEvent = VK_WAIT_EVENT_TOP_OF_PIPE;
         pipeline_barrier.memBarrierCount = to_clear.size();
         pipeline_barrier.ppMemBarriers = (const void **)&p_to_clear[0];
-        xglCmdPipelineBarrier(cmd_.obj(), &pipeline_barrier);
+        vkCmdPipelineBarrier(cmd_.obj(), &pipeline_barrier);
 
-        xglCmdClearColorImage(cmd_.obj(),
-                              img.obj(), XGL_IMAGE_LAYOUT_CLEAR_OPTIMAL,
+        vkCmdClearColorImage(cmd_.obj(),
+                              img.obj(), VK_IMAGE_LAYOUT_CLEAR_OPTIMAL,
                               clear_color, ranges.size(), &ranges[0]);
 
-        pipeline_barrier.sType = XGL_STRUCTURE_TYPE_PIPELINE_BARRIER;
+        pipeline_barrier.sType = VK_STRUCTURE_TYPE_PIPELINE_BARRIER;
         pipeline_barrier.eventCount = 1;
         pipeline_barrier.pEvents = set_events;
-        pipeline_barrier.waitEvent = XGL_WAIT_EVENT_TOP_OF_PIPE;
+        pipeline_barrier.waitEvent = VK_WAIT_EVENT_TOP_OF_PIPE;
         pipeline_barrier.memBarrierCount = to_xfer.size();
         pipeline_barrier.ppMemBarriers = (const void **)&p_to_xfer[0];
-        xglCmdPipelineBarrier(cmd_.obj(), &pipeline_barrier);
+        vkCmdPipelineBarrier(cmd_.obj(), &pipeline_barrier);
 
         cmd_.end();
 
@@ -1419,7 +1419,7 @@
         if (!img.transparent() && !img.copyable())
             return;
 
-        xgl_testing::ImageChecker checker(img_info, ranges);
+        vk_testing::ImageChecker checker(img_info, ranges);
 
         const std::vector<uint8_t> solid_pattern = color_to_raw(img_info.format, clear_color);
         if (solid_pattern.empty())
@@ -1429,11 +1429,11 @@
         check_dst(img, checker);
     }
 
-    void test_clear_color_image(const XGL_IMAGE_CREATE_INFO &img_info,
+    void test_clear_color_image(const VK_IMAGE_CREATE_INFO &img_info,
                                 const float color[4],
-                                const std::vector<XGL_IMAGE_SUBRESOURCE_RANGE> &ranges)
+                                const std::vector<VK_IMAGE_SUBRESOURCE_RANGE> &ranges)
     {
-        XGL_CLEAR_COLOR c = {};
+        VK_CLEAR_COLOR c = {};
         memcpy(c.color.floatColor, color, sizeof(c.color.floatColor));
         test_clear_color_image(img_info, c, ranges);
     }
@@ -1441,20 +1441,20 @@
 
 TEST_F(XglCmdClearColorImageTest, Basic)
 {
-    for (std::vector<xgl_testing::Device::Format>::const_iterator it = test_formats_.begin();
+    for (std::vector<vk_testing::Device::Format>::const_iterator it = test_formats_.begin();
          it != test_formats_.end(); it++) {
         const float color[4] = { 0.0f, 1.0f, 0.0f, 1.0f };
 
-        XGL_IMAGE_CREATE_INFO img_info = xgl_testing::Image::create_info();
-        img_info.imageType = XGL_IMAGE_2D;
+        VK_IMAGE_CREATE_INFO img_info = vk_testing::Image::create_info();
+        img_info.imageType = VK_IMAGE_2D;
         img_info.format = it->format;
         img_info.extent.width = 64;
         img_info.extent.height = 64;
         img_info.tiling = it->tiling;
 
-        const XGL_IMAGE_SUBRESOURCE_RANGE range =
-            xgl_testing::Image::subresource_range(img_info, XGL_IMAGE_ASPECT_COLOR);
-        std::vector<XGL_IMAGE_SUBRESOURCE_RANGE> ranges(&range, &range + 1);
+        const VK_IMAGE_SUBRESOURCE_RANGE range =
+            vk_testing::Image::subresource_range(img_info, VK_IMAGE_ASPECT_COLOR);
+        std::vector<VK_IMAGE_SUBRESOURCE_RANGE> ranges(&range, &range + 1);
 
         test_clear_color_image(img_info, color, ranges);
     }
@@ -1464,11 +1464,11 @@
 protected:
     XglCmdClearColorImageRawTest() : XglCmdClearColorImageTest(true) {}
 
-    void test_clear_color_image_raw(const XGL_IMAGE_CREATE_INFO &img_info,
+    void test_clear_color_image_raw(const VK_IMAGE_CREATE_INFO &img_info,
                                     const uint32_t color[4],
-                                    const std::vector<XGL_IMAGE_SUBRESOURCE_RANGE> &ranges)
+                                    const std::vector<VK_IMAGE_SUBRESOURCE_RANGE> &ranges)
     {
-        XGL_CLEAR_COLOR c = {};
+        VK_CLEAR_COLOR c = {};
         c.useRawValue = true;
         memcpy(c.color.rawColor, color, sizeof(c.color.rawColor));
         test_clear_color_image(img_info, c, ranges);
@@ -1477,36 +1477,36 @@
 
 TEST_F(XglCmdClearColorImageRawTest, Basic)
 {
-    for (std::vector<xgl_testing::Device::Format>::const_iterator it = test_formats_.begin();
+    for (std::vector<vk_testing::Device::Format>::const_iterator it = test_formats_.begin();
          it != test_formats_.end(); it++) {
         const uint32_t color[4] = { 0x11111111, 0x22222222, 0x33333333, 0x44444444 };
 
         // not sure what to do here
-        if (it->format == XGL_FMT_UNDEFINED ||
-            (it->format >= XGL_FMT_R8G8B8_UNORM &&
-             it->format <= XGL_FMT_R8G8B8_SRGB) ||
-            (it->format >= XGL_FMT_B8G8R8_UNORM &&
-             it->format <= XGL_FMT_B8G8R8_SRGB) ||
-            (it->format >= XGL_FMT_R16G16B16_UNORM &&
-             it->format <= XGL_FMT_R16G16B16_SFLOAT) ||
-            (it->format >= XGL_FMT_R32G32B32_UINT &&
-             it->format <= XGL_FMT_R32G32B32_SFLOAT) ||
-            it->format == XGL_FMT_R64G64B64_SFLOAT ||
-            it->format == XGL_FMT_R64G64B64A64_SFLOAT ||
-            (it->format >= XGL_FMT_D16_UNORM &&
-             it->format <= XGL_FMT_D32_SFLOAT_S8_UINT))
+        if (it->format == VK_FMT_UNDEFINED ||
+            (it->format >= VK_FMT_R8G8B8_UNORM &&
+             it->format <= VK_FMT_R8G8B8_SRGB) ||
+            (it->format >= VK_FMT_B8G8R8_UNORM &&
+             it->format <= VK_FMT_B8G8R8_SRGB) ||
+            (it->format >= VK_FMT_R16G16B16_UNORM &&
+             it->format <= VK_FMT_R16G16B16_SFLOAT) ||
+            (it->format >= VK_FMT_R32G32B32_UINT &&
+             it->format <= VK_FMT_R32G32B32_SFLOAT) ||
+            it->format == VK_FMT_R64G64B64_SFLOAT ||
+            it->format == VK_FMT_R64G64B64A64_SFLOAT ||
+            (it->format >= VK_FMT_D16_UNORM &&
+             it->format <= VK_FMT_D32_SFLOAT_S8_UINT))
             continue;
 
-        XGL_IMAGE_CREATE_INFO img_info = xgl_testing::Image::create_info();
-        img_info.imageType = XGL_IMAGE_2D;
+        VK_IMAGE_CREATE_INFO img_info = vk_testing::Image::create_info();
+        img_info.imageType = VK_IMAGE_2D;
         img_info.format = it->format;
         img_info.extent.width = 64;
         img_info.extent.height = 64;
         img_info.tiling = it->tiling;
 
-        const XGL_IMAGE_SUBRESOURCE_RANGE range =
-            xgl_testing::Image::subresource_range(img_info, XGL_IMAGE_ASPECT_COLOR);
-        std::vector<XGL_IMAGE_SUBRESOURCE_RANGE> ranges(&range, &range + 1);
+        const VK_IMAGE_SUBRESOURCE_RANGE range =
+            vk_testing::Image::subresource_range(img_info, VK_IMAGE_ASPECT_COLOR);
+        std::vector<VK_IMAGE_SUBRESOURCE_RANGE> ranges(&range, &range + 1);
 
         test_clear_color_image_raw(img_info, color, ranges);
     }
@@ -1517,27 +1517,27 @@
     virtual void SetUp()
     {
         XglCmdBlitTest::SetUp();
-        init_test_formats(XGL_FORMAT_DEPTH_ATTACHMENT_BIT |
-                          XGL_FORMAT_STENCIL_ATTACHMENT_BIT);
+        init_test_formats(VK_FORMAT_DEPTH_ATTACHMENT_BIT |
+                          VK_FORMAT_STENCIL_ATTACHMENT_BIT);
         ASSERT_NE(true, test_formats_.empty());
     }
 
-    std::vector<uint8_t> ds_to_raw(XGL_FORMAT format, float depth, uint32_t stencil)
+    std::vector<uint8_t> ds_to_raw(VK_FORMAT format, float depth, uint32_t stencil)
     {
         std::vector<uint8_t> raw;
 
         // depth
         switch (format) {
-        case XGL_FMT_D16_UNORM:
-        case XGL_FMT_D16_UNORM_S8_UINT:
+        case VK_FMT_D16_UNORM:
+        case VK_FMT_D16_UNORM_S8_UINT:
             {
                 const uint16_t unorm = depth * 65535.0f;
                 raw.push_back(unorm & 0xff);
                 raw.push_back(unorm >> 8);
             }
             break;
-        case XGL_FMT_D32_SFLOAT:
-        case XGL_FMT_D32_SFLOAT_S8_UINT:
+        case VK_FMT_D32_SFLOAT:
+        case VK_FMT_D32_SFLOAT_S8_UINT:
             {
                 const union {
                     float depth;
@@ -1556,14 +1556,14 @@
 
         // stencil
         switch (format) {
-        case XGL_FMT_S8_UINT:
+        case VK_FMT_S8_UINT:
             raw.push_back(stencil);
             break;
-        case XGL_FMT_D16_UNORM_S8_UINT:
+        case VK_FMT_D16_UNORM_S8_UINT:
             raw.push_back(stencil);
             raw.push_back(0);
             break;
-        case XGL_FMT_D32_SFLOAT_S8_UINT:
+        case VK_FMT_D32_SFLOAT_S8_UINT:
             raw.push_back(stencil);
             raw.push_back(0);
             raw.push_back(0);
@@ -1576,72 +1576,72 @@
         return raw;
     }
 
-    void test_clear_depth_stencil(const XGL_IMAGE_CREATE_INFO &img_info,
+    void test_clear_depth_stencil(const VK_IMAGE_CREATE_INFO &img_info,
                                   float depth, uint32_t stencil,
-                                  const std::vector<XGL_IMAGE_SUBRESOURCE_RANGE> &ranges)
+                                  const std::vector<VK_IMAGE_SUBRESOURCE_RANGE> &ranges)
     {
-        xgl_testing::Image img;
+        vk_testing::Image img;
         img.init(dev_, img_info);
         add_memory_ref(img);
-        const XGL_FLAGS all_cache_outputs =
-                XGL_MEMORY_OUTPUT_CPU_WRITE_BIT |
-                XGL_MEMORY_OUTPUT_SHADER_WRITE_BIT |
-                XGL_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT |
-                XGL_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT |
-                XGL_MEMORY_OUTPUT_COPY_BIT;
-        const XGL_FLAGS all_cache_inputs =
-                XGL_MEMORY_INPUT_CPU_READ_BIT |
-                XGL_MEMORY_INPUT_INDIRECT_COMMAND_BIT |
-                XGL_MEMORY_INPUT_INDEX_FETCH_BIT |
-                XGL_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT |
-                XGL_MEMORY_INPUT_UNIFORM_READ_BIT |
-                XGL_MEMORY_INPUT_SHADER_READ_BIT |
-                XGL_MEMORY_INPUT_COLOR_ATTACHMENT_BIT |
-                XGL_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT |
-                XGL_MEMORY_INPUT_COPY_BIT;
+        const VK_FLAGS all_cache_outputs =
+                VK_MEMORY_OUTPUT_CPU_WRITE_BIT |
+                VK_MEMORY_OUTPUT_SHADER_WRITE_BIT |
+                VK_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT |
+                VK_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT |
+                VK_MEMORY_OUTPUT_COPY_BIT;
+        const VK_FLAGS all_cache_inputs =
+                VK_MEMORY_INPUT_CPU_READ_BIT |
+                VK_MEMORY_INPUT_INDIRECT_COMMAND_BIT |
+                VK_MEMORY_INPUT_INDEX_FETCH_BIT |
+                VK_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT |
+                VK_MEMORY_INPUT_UNIFORM_READ_BIT |
+                VK_MEMORY_INPUT_SHADER_READ_BIT |
+                VK_MEMORY_INPUT_COLOR_ATTACHMENT_BIT |
+                VK_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT |
+                VK_MEMORY_INPUT_COPY_BIT;
 
-        std::vector<XGL_IMAGE_MEMORY_BARRIER> to_clear;
-        std::vector<XGL_IMAGE_MEMORY_BARRIER *> p_to_clear;
-        std::vector<XGL_IMAGE_MEMORY_BARRIER> to_xfer;
-        std::vector<XGL_IMAGE_MEMORY_BARRIER *> p_to_xfer;
+        std::vector<VK_IMAGE_MEMORY_BARRIER> to_clear;
+        std::vector<VK_IMAGE_MEMORY_BARRIER *> p_to_clear;
+        std::vector<VK_IMAGE_MEMORY_BARRIER> to_xfer;
+        std::vector<VK_IMAGE_MEMORY_BARRIER *> p_to_xfer;
 
-        for (std::vector<XGL_IMAGE_SUBRESOURCE_RANGE>::const_iterator it = ranges.begin();
+        for (std::vector<VK_IMAGE_SUBRESOURCE_RANGE>::const_iterator it = ranges.begin();
              it != ranges.end(); it++) {
             to_clear.push_back(img.image_memory_barrier(all_cache_outputs, all_cache_inputs,
-                    XGL_IMAGE_LAYOUT_GENERAL,
-                    XGL_IMAGE_LAYOUT_CLEAR_OPTIMAL,
+                    VK_IMAGE_LAYOUT_GENERAL,
+                    VK_IMAGE_LAYOUT_CLEAR_OPTIMAL,
                     *it));
             p_to_clear.push_back(&to_clear.back());
             to_xfer.push_back(img.image_memory_barrier(all_cache_outputs, all_cache_inputs,
-                    XGL_IMAGE_LAYOUT_CLEAR_OPTIMAL,
-                    XGL_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL, *it));
+                    VK_IMAGE_LAYOUT_CLEAR_OPTIMAL,
+                    VK_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL, *it));
             p_to_xfer.push_back(&to_xfer.back());
         }
 
         cmd_.begin();
 
-        XGL_PIPE_EVENT set_events[] = { XGL_PIPE_EVENT_GPU_COMMANDS_COMPLETE };
-        XGL_PIPELINE_BARRIER pipeline_barrier = {};
-        pipeline_barrier.sType = XGL_STRUCTURE_TYPE_PIPELINE_BARRIER;
+        VK_PIPE_EVENT set_events[] = { VK_PIPE_EVENT_GPU_COMMANDS_COMPLETE };
+        VK_PIPELINE_BARRIER pipeline_barrier = {};
+        pipeline_barrier.sType = VK_STRUCTURE_TYPE_PIPELINE_BARRIER;
         pipeline_barrier.eventCount = 1;
         pipeline_barrier.pEvents = set_events;
-        pipeline_barrier.waitEvent = XGL_WAIT_EVENT_TOP_OF_PIPE;
+        pipeline_barrier.waitEvent = VK_WAIT_EVENT_TOP_OF_PIPE;
         pipeline_barrier.memBarrierCount = to_clear.size();
         pipeline_barrier.ppMemBarriers = (const void **)&p_to_clear[0];
-        xglCmdPipelineBarrier(cmd_.obj(), &pipeline_barrier);
+        vkCmdPipelineBarrier(cmd_.obj(), &pipeline_barrier);
 
-        xglCmdClearDepthStencil(cmd_.obj(),
-                                img.obj(), XGL_IMAGE_LAYOUT_CLEAR_OPTIMAL,
+        vkCmdClearDepthStencil(cmd_.obj(),
+                                img.obj(), VK_IMAGE_LAYOUT_CLEAR_OPTIMAL,
                                 depth, stencil,
                                 ranges.size(), &ranges[0]);
 
-        pipeline_barrier.sType = XGL_STRUCTURE_TYPE_PIPELINE_BARRIER;
+        pipeline_barrier.sType = VK_STRUCTURE_TYPE_PIPELINE_BARRIER;
         pipeline_barrier.eventCount = 1;
         pipeline_barrier.pEvents = set_events;
-        pipeline_barrier.waitEvent = XGL_WAIT_EVENT_TOP_OF_PIPE;
+        pipeline_barrier.waitEvent = VK_WAIT_EVENT_TOP_OF_PIPE;
         pipeline_barrier.memBarrierCount = to_xfer.size();
         pipeline_barrier.ppMemBarriers = (const void **)&p_to_xfer[0];
-        xglCmdPipelineBarrier(cmd_.obj(), &pipeline_barrier);
+        vkCmdPipelineBarrier(cmd_.obj(), &pipeline_barrier);
 
         cmd_.end();
 
@@ -1651,7 +1651,7 @@
         if (!img.transparent() && !img.copyable())
             return;
 
-        xgl_testing::ImageChecker checker(img_info, ranges);
+        vk_testing::ImageChecker checker(img_info, ranges);
 
         checker.set_solid_pattern(ds_to_raw(img_info.format, depth, stencil));
         check_dst(img, checker);
@@ -1660,26 +1660,26 @@
 
 TEST_F(XglCmdClearDepthStencilTest, Basic)
 {
-    for (std::vector<xgl_testing::Device::Format>::const_iterator it = test_formats_.begin();
+    for (std::vector<vk_testing::Device::Format>::const_iterator it = test_formats_.begin();
          it != test_formats_.end(); it++) {
         // known driver issues
-        if (it->format == XGL_FMT_S8_UINT ||
-            it->format == XGL_FMT_D24_UNORM ||
-            it->format == XGL_FMT_D16_UNORM_S8_UINT ||
-            it->format == XGL_FMT_D24_UNORM_S8_UINT)
+        if (it->format == VK_FMT_S8_UINT ||
+            it->format == VK_FMT_D24_UNORM ||
+            it->format == VK_FMT_D16_UNORM_S8_UINT ||
+            it->format == VK_FMT_D24_UNORM_S8_UINT)
             continue;
 
-        XGL_IMAGE_CREATE_INFO img_info = xgl_testing::Image::create_info();
-        img_info.imageType = XGL_IMAGE_2D;
+        VK_IMAGE_CREATE_INFO img_info = vk_testing::Image::create_info();
+        img_info.imageType = VK_IMAGE_2D;
         img_info.format = it->format;
         img_info.extent.width = 64;
         img_info.extent.height = 64;
         img_info.tiling = it->tiling;
-        img_info.usage = XGL_IMAGE_USAGE_DEPTH_STENCIL_BIT;
+        img_info.usage = VK_IMAGE_USAGE_DEPTH_STENCIL_BIT;
 
-        const XGL_IMAGE_SUBRESOURCE_RANGE range =
-            xgl_testing::Image::subresource_range(img_info, XGL_IMAGE_ASPECT_DEPTH);
-        std::vector<XGL_IMAGE_SUBRESOURCE_RANGE> ranges(&range, &range + 1);
+        const VK_IMAGE_SUBRESOURCE_RANGE range =
+            vk_testing::Image::subresource_range(img_info, VK_IMAGE_ASPECT_DEPTH);
+        std::vector<VK_IMAGE_SUBRESOURCE_RANGE> ranges(&range, &range + 1);
 
         test_clear_depth_stencil(img_info, 0.25f, 63, ranges);
     }
@@ -1691,9 +1691,9 @@
 {
     ::testing::InitGoogleTest(&argc, argv);
 
-    xgl_testing::set_error_callback(test_error_callback);
+    vk_testing::set_error_callback(test_error_callback);
 
-    environment = new xgl_testing::Environment();
+    environment = new vk_testing::Environment();
 
     if (!environment->parse_args(argc, argv))
         return -1;
diff --git a/tests/golden/SPV_VKTriangle-2.ppm b/tests/golden/SPV_VKTriangle-2.ppm
new file mode 100644
index 0000000..8fb7dc8
--- /dev/null
+++ b/tests/golden/SPV_VKTriangle-2.ppm
Binary files differ
diff --git a/tests/golden/SPV_VKTriangle-3.ppm b/tests/golden/SPV_VKTriangle-3.ppm
new file mode 100644
index 0000000..5fff708
--- /dev/null
+++ b/tests/golden/SPV_VKTriangle-3.ppm
Binary files differ
diff --git a/tests/golden/SPV_VKTriangle-4.ppm b/tests/golden/SPV_VKTriangle-4.ppm
new file mode 100644
index 0000000..75855bc
--- /dev/null
+++ b/tests/golden/SPV_VKTriangle-4.ppm
Binary files differ
diff --git a/tests/golden/SPV_VKTriangle-5.ppm b/tests/golden/SPV_VKTriangle-5.ppm
new file mode 100644
index 0000000..eb59515
--- /dev/null
+++ b/tests/golden/SPV_VKTriangle-5.ppm
@@ -0,0 +1,5 @@
+P6
+256
+256
+255
+@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
\ No newline at end of file
diff --git a/tests/golden/SPV_VKTriangle-6.ppm b/tests/golden/SPV_VKTriangle-6.ppm
new file mode 100644
index 0000000..1368dfb
--- /dev/null
+++ b/tests/golden/SPV_VKTriangle-6.ppm
Binary files differ
diff --git a/tests/golden/SPV_VKTriangle-7.ppm b/tests/golden/SPV_VKTriangle-7.ppm
new file mode 100644
index 0000000..2196f0a
--- /dev/null
+++ b/tests/golden/SPV_VKTriangle-7.ppm
Binary files differ
diff --git a/tests/golden/SPV_VKTriangle-8.ppm b/tests/golden/SPV_VKTriangle-8.ppm
new file mode 100644
index 0000000..d7f2ee7
--- /dev/null
+++ b/tests/golden/SPV_VKTriangle-8.ppm
Binary files differ
diff --git a/tests/golden/SPV_VKTriangle-9.ppm b/tests/golden/SPV_VKTriangle-9.ppm
new file mode 100644
index 0000000..8334d05
--- /dev/null
+++ b/tests/golden/SPV_VKTriangle-9.ppm
Binary files differ
diff --git a/tests/golden/SPV_VKTriangle.ppm b/tests/golden/SPV_VKTriangle.ppm
new file mode 100644
index 0000000..56faaac
--- /dev/null
+++ b/tests/golden/SPV_VKTriangle.ppm
Binary files differ
diff --git a/tests/golden/VKTriangle_FragColor-2.ppm b/tests/golden/VKTriangle_FragColor-2.ppm
new file mode 100644
index 0000000..8fb7dc8
--- /dev/null
+++ b/tests/golden/VKTriangle_FragColor-2.ppm
Binary files differ
diff --git a/tests/golden/VKTriangle_FragColor-3.ppm b/tests/golden/VKTriangle_FragColor-3.ppm
new file mode 100644
index 0000000..5fff708
--- /dev/null
+++ b/tests/golden/VKTriangle_FragColor-3.ppm
Binary files differ
diff --git a/tests/golden/VKTriangle_FragColor-4.ppm b/tests/golden/VKTriangle_FragColor-4.ppm
new file mode 100644
index 0000000..75855bc
--- /dev/null
+++ b/tests/golden/VKTriangle_FragColor-4.ppm
Binary files differ
diff --git a/tests/golden/VKTriangle_FragColor-5.ppm b/tests/golden/VKTriangle_FragColor-5.ppm
new file mode 100644
index 0000000..eb59515
--- /dev/null
+++ b/tests/golden/VKTriangle_FragColor-5.ppm
@@ -0,0 +1,5 @@
+P6
+256
+256
+255
+@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
\ No newline at end of file
diff --git a/tests/golden/VKTriangle_FragColor-6.ppm b/tests/golden/VKTriangle_FragColor-6.ppm
new file mode 100644
index 0000000..1368dfb
--- /dev/null
+++ b/tests/golden/VKTriangle_FragColor-6.ppm
Binary files differ
diff --git a/tests/golden/VKTriangle_FragColor-7.ppm b/tests/golden/VKTriangle_FragColor-7.ppm
new file mode 100644
index 0000000..2196f0a
--- /dev/null
+++ b/tests/golden/VKTriangle_FragColor-7.ppm
Binary files differ
diff --git a/tests/golden/VKTriangle_FragColor-8.ppm b/tests/golden/VKTriangle_FragColor-8.ppm
new file mode 100644
index 0000000..d7f2ee7
--- /dev/null
+++ b/tests/golden/VKTriangle_FragColor-8.ppm
Binary files differ
diff --git a/tests/golden/VKTriangle_FragColor-9.ppm b/tests/golden/VKTriangle_FragColor-9.ppm
new file mode 100644
index 0000000..8334d05
--- /dev/null
+++ b/tests/golden/VKTriangle_FragColor-9.ppm
Binary files differ
diff --git a/tests/golden/VKTriangle_FragColor.ppm b/tests/golden/VKTriangle_FragColor.ppm
new file mode 100644
index 0000000..56faaac
--- /dev/null
+++ b/tests/golden/VKTriangle_FragColor.ppm
Binary files differ
diff --git a/tests/golden/VKTriangle_OutputLocation-2.ppm b/tests/golden/VKTriangle_OutputLocation-2.ppm
new file mode 100644
index 0000000..8fb7dc8
--- /dev/null
+++ b/tests/golden/VKTriangle_OutputLocation-2.ppm
Binary files differ
diff --git a/tests/golden/VKTriangle_OutputLocation-3.ppm b/tests/golden/VKTriangle_OutputLocation-3.ppm
new file mode 100644
index 0000000..5fff708
--- /dev/null
+++ b/tests/golden/VKTriangle_OutputLocation-3.ppm
Binary files differ
diff --git a/tests/golden/VKTriangle_OutputLocation-4.ppm b/tests/golden/VKTriangle_OutputLocation-4.ppm
new file mode 100644
index 0000000..75855bc
--- /dev/null
+++ b/tests/golden/VKTriangle_OutputLocation-4.ppm
Binary files differ
diff --git a/tests/golden/VKTriangle_OutputLocation-5.ppm b/tests/golden/VKTriangle_OutputLocation-5.ppm
new file mode 100644
index 0000000..eb59515
--- /dev/null
+++ b/tests/golden/VKTriangle_OutputLocation-5.ppm
@@ -0,0 +1,5 @@
+P6
+256
+256
+255
+@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
\ No newline at end of file
diff --git a/tests/golden/VKTriangle_OutputLocation-6.ppm b/tests/golden/VKTriangle_OutputLocation-6.ppm
new file mode 100644
index 0000000..1368dfb
--- /dev/null
+++ b/tests/golden/VKTriangle_OutputLocation-6.ppm
Binary files differ
diff --git a/tests/golden/VKTriangle_OutputLocation-7.ppm b/tests/golden/VKTriangle_OutputLocation-7.ppm
new file mode 100644
index 0000000..2196f0a
--- /dev/null
+++ b/tests/golden/VKTriangle_OutputLocation-7.ppm
Binary files differ
diff --git a/tests/golden/VKTriangle_OutputLocation-8.ppm b/tests/golden/VKTriangle_OutputLocation-8.ppm
new file mode 100644
index 0000000..d7f2ee7
--- /dev/null
+++ b/tests/golden/VKTriangle_OutputLocation-8.ppm
Binary files differ
diff --git a/tests/golden/VKTriangle_OutputLocation-9.ppm b/tests/golden/VKTriangle_OutputLocation-9.ppm
new file mode 100644
index 0000000..8334d05
--- /dev/null
+++ b/tests/golden/VKTriangle_OutputLocation-9.ppm
Binary files differ
diff --git a/tests/golden/VKTriangle_OutputLocation.ppm b/tests/golden/VKTriangle_OutputLocation.ppm
new file mode 100644
index 0000000..56faaac
--- /dev/null
+++ b/tests/golden/VKTriangle_OutputLocation.ppm
Binary files differ
diff --git a/tests/image_tests.cpp b/tests/image_tests.cpp
index c4cc58e..a843a4a 100644
--- a/tests/image_tests.cpp
+++ b/tests/image_tests.cpp
@@ -28,7 +28,7 @@
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 
-//  XGL tests
+//  VK tests
 //
 //  Copyright (C) 2014 LunarG, Inc.
 //
@@ -51,16 +51,16 @@
 //  DEALINGS IN THE SOFTWARE.
 
 
-// Verify XGL driver initialization
+// Verify VK driver initialization
 
 #include <stdlib.h>
 #include <stdio.h>
 #include <stdbool.h>
 #include <string.h>
 
-#include <xgl.h>
+#include <vulkan.h>
 #include "gtest-1.7.0/include/gtest/gtest.h"
-#include "xgltestbinding.h"
+#include "vktestbinding.h"
 #include "test_common.h"
 
 class XglImageTest : public ::testing::Test {
@@ -68,62 +68,62 @@
     void CreateImage(uint32_t w, uint32_t h);
     void DestroyImage();
 
-    void CreateImageView(XGL_IMAGE_VIEW_CREATE_INFO* pCreateInfo,
-                         XGL_IMAGE_VIEW* pView);
-    void DestroyImageView(XGL_IMAGE_VIEW imageView);
-    XGL_DEVICE device() {return m_device->obj();}
+    void CreateImageView(VK_IMAGE_VIEW_CREATE_INFO* pCreateInfo,
+                         VK_IMAGE_VIEW* pView);
+    void DestroyImageView(VK_IMAGE_VIEW imageView);
+    VK_DEVICE device() {return m_device->obj();}
 
 protected:
-    xgl_testing::Device *m_device;
-    XGL_APPLICATION_INFO app_info;
-    XGL_PHYSICAL_GPU objs[XGL_MAX_PHYSICAL_GPUS];
+    vk_testing::Device *m_device;
+    VK_APPLICATION_INFO app_info;
+    VK_PHYSICAL_GPU objs[VK_MAX_PHYSICAL_GPUS];
     uint32_t gpu_count;
-    XGL_INSTANCE inst;
-    XGL_IMAGE m_image;
-    XGL_GPU_MEMORY *m_image_mem;
+    VK_INSTANCE inst;
+    VK_IMAGE m_image;
+    VK_GPU_MEMORY *m_image_mem;
     uint32_t m_num_mem;
 
     virtual void SetUp() {
-        XGL_RESULT err;
+        VK_RESULT err;
 
-        this->app_info.sType = XGL_STRUCTURE_TYPE_APPLICATION_INFO;
+        this->app_info.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
         this->app_info.pNext = NULL;
         this->app_info.pAppName = "base";
         this->app_info.appVersion = 1;
         this->app_info.pEngineName = "unittest";
         this->app_info.engineVersion = 1;
-        this->app_info.apiVersion = XGL_API_VERSION;
-        XGL_INSTANCE_CREATE_INFO inst_info = {};
-        inst_info.sType = XGL_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
+        this->app_info.apiVersion = VK_API_VERSION;
+        VK_INSTANCE_CREATE_INFO inst_info = {};
+        inst_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
         inst_info.pNext = NULL;
         inst_info.pAppInfo = &app_info;
         inst_info.pAllocCb = NULL;
         inst_info.extensionCount = 0;
         inst_info.ppEnabledExtensionNames = NULL;
-        err = xglCreateInstance(&inst_info, &this->inst);
-        ASSERT_XGL_SUCCESS(err);
-        err = xglEnumerateGpus(this->inst, XGL_MAX_PHYSICAL_GPUS,
+        err = vkCreateInstance(&inst_info, &this->inst);
+        ASSERT_VK_SUCCESS(err);
+        err = vkEnumerateGpus(this->inst, VK_MAX_PHYSICAL_GPUS,
                                &this->gpu_count, objs);
-        ASSERT_XGL_SUCCESS(err);
+        ASSERT_VK_SUCCESS(err);
         ASSERT_GE(this->gpu_count, 1) << "No GPU available";
 
-        this->m_device = new xgl_testing::Device(objs[0]);
+        this->m_device = new vk_testing::Device(objs[0]);
         this->m_device->init();
     }
 
     virtual void TearDown() {
-        xglDestroyInstance(this->inst);
+        vkDestroyInstance(this->inst);
     }
 };
 
 
 void XglImageTest::CreateImage(uint32_t w, uint32_t h)
 {
-    XGL_RESULT err;
+    VK_RESULT err;
     uint32_t mipCount;
     size_t size;
-    XGL_FORMAT fmt;
-    XGL_FORMAT_PROPERTIES image_fmt;
+    VK_FORMAT fmt;
+    VK_FORMAT_PROPERTIES image_fmt;
 
     mipCount = 0;
 
@@ -136,41 +136,41 @@
         mipCount++;
     }
 
-    fmt = XGL_FMT_R8G8B8A8_UINT;
+    fmt = VK_FMT_R8G8B8A8_UINT;
     // TODO: Pick known good format rather than just expect common format
     /*
      * XXX: What should happen if given NULL HANDLE for the pData argument?
-     * We're not requesting XGL_INFO_TYPE_MEMORY_REQUIREMENTS so there is
+     * We're not requesting VK_INFO_TYPE_MEMORY_REQUIREMENTS so there is
      * an expectation that pData is a valid pointer.
      * However, why include a returned size value? That implies that the
      * amount of data may vary and that doesn't work well for using a
      * fixed structure.
      */
     size = sizeof(image_fmt);
-    err = xglGetFormatInfo(this->device(), fmt,
-                           XGL_INFO_TYPE_FORMAT_PROPERTIES,
+    err = vkGetFormatInfo(this->device(), fmt,
+                           VK_INFO_TYPE_FORMAT_PROPERTIES,
                            &size, &image_fmt);
-    ASSERT_XGL_SUCCESS(err);
+    ASSERT_VK_SUCCESS(err);
 
-    //    typedef struct _XGL_IMAGE_CREATE_INFO
+    //    typedef struct _VK_IMAGE_CREATE_INFO
     //    {
-    //        XGL_STRUCTURE_TYPE                      sType;                      // Must be XGL_STRUCTURE_TYPE_IMAGE_CREATE_INFO
+    //        VK_STRUCTURE_TYPE                      sType;                      // Must be VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO
     //        const void*                             pNext;                      // Pointer to next structure.
-    //        XGL_IMAGE_TYPE                          imageType;
-    //        XGL_FORMAT                              format;
-    //        XGL_EXTENT3D                            extent;
+    //        VK_IMAGE_TYPE                          imageType;
+    //        VK_FORMAT                              format;
+    //        VK_EXTENT3D                            extent;
     //        uint32_t                                mipLevels;
     //        uint32_t                                arraySize;
     //        uint32_t                                samples;
-    //        XGL_IMAGE_TILING                        tiling;
-    //        XGL_FLAGS                               usage;                      // XGL_IMAGE_USAGE_FLAGS
-    //        XGL_FLAGS                               flags;                      // XGL_IMAGE_CREATE_FLAGS
-    //    } XGL_IMAGE_CREATE_INFO;
+    //        VK_IMAGE_TILING                        tiling;
+    //        VK_FLAGS                               usage;                      // VK_IMAGE_USAGE_FLAGS
+    //        VK_FLAGS                               flags;                      // VK_IMAGE_CREATE_FLAGS
+    //    } VK_IMAGE_CREATE_INFO;
 
 
-    XGL_IMAGE_CREATE_INFO imageCreateInfo = {};
-    imageCreateInfo.sType = XGL_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
-    imageCreateInfo.imageType = XGL_IMAGE_2D;
+    VK_IMAGE_CREATE_INFO imageCreateInfo = {};
+    imageCreateInfo.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
+    imageCreateInfo.imageType = VK_IMAGE_2D;
     imageCreateInfo.format = fmt;
     imageCreateInfo.arraySize = 1;
     imageCreateInfo.extent.width = w;
@@ -178,151 +178,151 @@
     imageCreateInfo.extent.depth = 1;
     imageCreateInfo.mipLevels = mipCount;
     imageCreateInfo.samples = 1;
-    if (image_fmt.linearTilingFeatures & XGL_FORMAT_IMAGE_SHADER_READ_BIT) {
-        imageCreateInfo.tiling = XGL_LINEAR_TILING;
+    if (image_fmt.linearTilingFeatures & VK_FORMAT_IMAGE_SHADER_READ_BIT) {
+        imageCreateInfo.tiling = VK_LINEAR_TILING;
     }
-    else if (image_fmt.optimalTilingFeatures & XGL_FORMAT_IMAGE_SHADER_READ_BIT) {
-        imageCreateInfo.tiling = XGL_OPTIMAL_TILING;
+    else if (image_fmt.optimalTilingFeatures & VK_FORMAT_IMAGE_SHADER_READ_BIT) {
+        imageCreateInfo.tiling = VK_OPTIMAL_TILING;
     }
     else {
         ASSERT_TRUE(false) << "Cannot find supported tiling format - Exiting";
     }
 
     // Image usage flags
-    //    typedef enum _XGL_IMAGE_USAGE_FLAGS
+    //    typedef enum _VK_IMAGE_USAGE_FLAGS
     //    {
-    //        XGL_IMAGE_USAGE_SHADER_ACCESS_READ_BIT                  = 0x00000001,
-    //        XGL_IMAGE_USAGE_SHADER_ACCESS_WRITE_BIT                 = 0x00000002,
-    //        XGL_IMAGE_USAGE_COLOR_ATTACHMENT_BIT                    = 0x00000004,
-    //        XGL_IMAGE_USAGE_DEPTH_STENCIL_BIT                       = 0x00000008,
-    //    } XGL_IMAGE_USAGE_FLAGS;
-    imageCreateInfo.usage = XGL_IMAGE_USAGE_SHADER_ACCESS_WRITE_BIT | XGL_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
+    //        VK_IMAGE_USAGE_SHADER_ACCESS_READ_BIT                  = 0x00000001,
+    //        VK_IMAGE_USAGE_SHADER_ACCESS_WRITE_BIT                 = 0x00000002,
+    //        VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT                    = 0x00000004,
+    //        VK_IMAGE_USAGE_DEPTH_STENCIL_BIT                       = 0x00000008,
+    //    } VK_IMAGE_USAGE_FLAGS;
+    imageCreateInfo.usage = VK_IMAGE_USAGE_SHADER_ACCESS_WRITE_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
 
-    //    XGL_RESULT XGLAPI xglCreateImage(
-    //        XGL_DEVICE                                  device,
-    //        const XGL_IMAGE_CREATE_INFO*                pCreateInfo,
-    //        XGL_IMAGE*                                  pImage);
-    err = xglCreateImage(device(), &imageCreateInfo, &m_image);
-    ASSERT_XGL_SUCCESS(err);
+    //    VK_RESULT VKAPI vkCreateImage(
+    //        VK_DEVICE                                  device,
+    //        const VK_IMAGE_CREATE_INFO*                pCreateInfo,
+    //        VK_IMAGE*                                  pImage);
+    err = vkCreateImage(device(), &imageCreateInfo, &m_image);
+    ASSERT_VK_SUCCESS(err);
 
-    XGL_MEMORY_REQUIREMENTS *mem_req;
-    size_t mem_reqs_size = sizeof(XGL_MEMORY_REQUIREMENTS);
-    XGL_IMAGE_MEMORY_REQUIREMENTS img_reqs;
-    size_t img_reqs_size = sizeof(XGL_IMAGE_MEMORY_REQUIREMENTS);
+    VK_MEMORY_REQUIREMENTS *mem_req;
+    size_t mem_reqs_size = sizeof(VK_MEMORY_REQUIREMENTS);
+    VK_IMAGE_MEMORY_REQUIREMENTS img_reqs;
+    size_t img_reqs_size = sizeof(VK_IMAGE_MEMORY_REQUIREMENTS);
     uint32_t num_allocations = 0;
     size_t num_alloc_size = sizeof(num_allocations);
-    XGL_MEMORY_ALLOC_IMAGE_INFO img_alloc = {};
-    img_alloc.sType = XGL_STRUCTURE_TYPE_MEMORY_ALLOC_IMAGE_INFO;
+    VK_MEMORY_ALLOC_IMAGE_INFO img_alloc = {};
+    img_alloc.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOC_IMAGE_INFO;
     img_alloc.pNext = NULL;
 
-    XGL_MEMORY_ALLOC_INFO mem_info = {};
-    mem_info.sType = XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO;
+    VK_MEMORY_ALLOC_INFO mem_info = {};
+    mem_info.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO;
     mem_info.pNext = &img_alloc;
 
-    err = xglGetObjectInfo(m_image, XGL_INFO_TYPE_MEMORY_ALLOCATION_COUNT,
+    err = vkGetObjectInfo(m_image, VK_INFO_TYPE_MEMORY_ALLOCATION_COUNT,
                     &num_alloc_size, &num_allocations);
-    ASSERT_XGL_SUCCESS(err);
+    ASSERT_VK_SUCCESS(err);
     ASSERT_EQ(num_alloc_size,sizeof(num_allocations));
-    mem_req = (XGL_MEMORY_REQUIREMENTS *) malloc(num_allocations * sizeof(XGL_MEMORY_REQUIREMENTS));
-    m_image_mem = (XGL_GPU_MEMORY *) malloc(num_allocations * sizeof(XGL_GPU_MEMORY));
+    mem_req = (VK_MEMORY_REQUIREMENTS *) malloc(num_allocations * sizeof(VK_MEMORY_REQUIREMENTS));
+    m_image_mem = (VK_GPU_MEMORY *) malloc(num_allocations * sizeof(VK_GPU_MEMORY));
     m_num_mem = num_allocations;
-    err = xglGetObjectInfo(m_image,
-                    XGL_INFO_TYPE_MEMORY_REQUIREMENTS,
+    err = vkGetObjectInfo(m_image,
+                    VK_INFO_TYPE_MEMORY_REQUIREMENTS,
                     &mem_reqs_size, mem_req);
-    ASSERT_XGL_SUCCESS(err);
-    ASSERT_EQ(mem_reqs_size, num_allocations * sizeof(XGL_MEMORY_REQUIREMENTS));
-    err = xglGetObjectInfo(m_image,
-                        XGL_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS,
+    ASSERT_VK_SUCCESS(err);
+    ASSERT_EQ(mem_reqs_size, num_allocations * sizeof(VK_MEMORY_REQUIREMENTS));
+    err = vkGetObjectInfo(m_image,
+                        VK_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS,
                         &img_reqs_size, &img_reqs);
-    ASSERT_XGL_SUCCESS(err);
-    ASSERT_EQ(img_reqs_size, sizeof(XGL_IMAGE_MEMORY_REQUIREMENTS));
+    ASSERT_VK_SUCCESS(err);
+    ASSERT_EQ(img_reqs_size, sizeof(VK_IMAGE_MEMORY_REQUIREMENTS));
     img_alloc.usage = img_reqs.usage;
     img_alloc.formatClass = img_reqs.formatClass;
     img_alloc.samples = img_reqs.samples;
 
     for (uint32_t i = 0; i < num_allocations; i ++) {
-        ASSERT_NE(0, mem_req[i].size) << "xglGetObjectInfo (Image): Failed - expect images to require memory";
+        ASSERT_NE(0, mem_req[i].size) << "vkGetObjectInfo (Image): Failed - expect images to require memory";
         mem_info.allocationSize = mem_req[i].size;
-        mem_info.memProps = XGL_MEMORY_PROPERTY_SHAREABLE_BIT;
-        mem_info.memType = XGL_MEMORY_TYPE_IMAGE;
-        mem_info.memPriority = XGL_MEMORY_PRIORITY_NORMAL;
+        mem_info.memProps = VK_MEMORY_PROPERTY_SHAREABLE_BIT;
+        mem_info.memType = VK_MEMORY_TYPE_IMAGE;
+        mem_info.memPriority = VK_MEMORY_PRIORITY_NORMAL;
 
         /* allocate memory */
-        err = xglAllocMemory(device(), &mem_info, &m_image_mem[i]);
-        ASSERT_XGL_SUCCESS(err);
+        err = vkAllocMemory(device(), &mem_info, &m_image_mem[i]);
+        ASSERT_VK_SUCCESS(err);
 
         /* bind memory */
-        err = xglBindObjectMemory(m_image, i, m_image_mem[i], 0);
-        ASSERT_XGL_SUCCESS(err);
+        err = vkBindObjectMemory(m_image, i, m_image_mem[i], 0);
+        ASSERT_VK_SUCCESS(err);
     }
 }
 
 void XglImageTest::DestroyImage()
 {
-    XGL_RESULT err;
+    VK_RESULT err;
     // All done with image memory, clean up
-    ASSERT_XGL_SUCCESS(xglBindObjectMemory(m_image, 0, XGL_NULL_HANDLE, 0));
+    ASSERT_VK_SUCCESS(vkBindObjectMemory(m_image, 0, VK_NULL_HANDLE, 0));
 
     for (uint32_t i = 0 ; i < m_num_mem; i++) {
-        err = xglFreeMemory(m_image_mem[i]);
-        ASSERT_XGL_SUCCESS(err);
+        err = vkFreeMemory(m_image_mem[i]);
+        ASSERT_VK_SUCCESS(err);
     }
 
 
-    ASSERT_XGL_SUCCESS(xglDestroyObject(m_image));
+    ASSERT_VK_SUCCESS(vkDestroyObject(m_image));
 }
 
-void XglImageTest::CreateImageView(XGL_IMAGE_VIEW_CREATE_INFO *pCreateInfo,
-                                   XGL_IMAGE_VIEW *pView)
+void XglImageTest::CreateImageView(VK_IMAGE_VIEW_CREATE_INFO *pCreateInfo,
+                                   VK_IMAGE_VIEW *pView)
 {
     pCreateInfo->image = this->m_image;
-    ASSERT_XGL_SUCCESS(xglCreateImageView(device(), pCreateInfo, pView));
+    ASSERT_VK_SUCCESS(vkCreateImageView(device(), pCreateInfo, pView));
 }
 
-void XglImageTest::DestroyImageView(XGL_IMAGE_VIEW imageView)
+void XglImageTest::DestroyImageView(VK_IMAGE_VIEW imageView)
 {
-    ASSERT_XGL_SUCCESS(xglDestroyObject(imageView));
+    ASSERT_VK_SUCCESS(vkDestroyObject(imageView));
 }
 
 TEST_F(XglImageTest, CreateImageViewTest) {
-    XGL_FORMAT fmt;
-    XGL_IMAGE_VIEW imageView;
+    VK_FORMAT fmt;
+    VK_IMAGE_VIEW imageView;
 
-    fmt = XGL_FMT_R8G8B8A8_UINT;
+    fmt = VK_FMT_R8G8B8A8_UINT;
 
     CreateImage(512, 256);
 
-    //    typedef struct _XGL_IMAGE_VIEW_CREATE_INFO
+    //    typedef struct _VK_IMAGE_VIEW_CREATE_INFO
     //    {
-    //        XGL_STRUCTURE_TYPE                      sType;                  // Must be XGL_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO
+    //        VK_STRUCTURE_TYPE                      sType;                  // Must be VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO
     //        const void*                             pNext;                  // Pointer to next structure
-    //        XGL_IMAGE                               image;
-    //        XGL_IMAGE_VIEW_TYPE                     viewType;
-    //        XGL_FORMAT                              format;
-    //        XGL_CHANNEL_MAPPING                     channels;
-    //        XGL_IMAGE_SUBRESOURCE_RANGE             subresourceRange;
+    //        VK_IMAGE                               image;
+    //        VK_IMAGE_VIEW_TYPE                     viewType;
+    //        VK_FORMAT                              format;
+    //        VK_CHANNEL_MAPPING                     channels;
+    //        VK_IMAGE_SUBRESOURCE_RANGE             subresourceRange;
     //        float                                   minLod;
-    //    } XGL_IMAGE_VIEW_CREATE_INFO;
-    XGL_IMAGE_VIEW_CREATE_INFO viewInfo = {};
-    viewInfo.sType = XGL_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
-    viewInfo.viewType = XGL_IMAGE_VIEW_2D;
+    //    } VK_IMAGE_VIEW_CREATE_INFO;
+    VK_IMAGE_VIEW_CREATE_INFO viewInfo = {};
+    viewInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
+    viewInfo.viewType = VK_IMAGE_VIEW_2D;
     viewInfo.format = fmt;
 
-    viewInfo.channels.r = XGL_CHANNEL_SWIZZLE_R;
-    viewInfo.channels.g = XGL_CHANNEL_SWIZZLE_G;
-    viewInfo.channels.b = XGL_CHANNEL_SWIZZLE_B;
-    viewInfo.channels.a = XGL_CHANNEL_SWIZZLE_A;
+    viewInfo.channels.r = VK_CHANNEL_SWIZZLE_R;
+    viewInfo.channels.g = VK_CHANNEL_SWIZZLE_G;
+    viewInfo.channels.b = VK_CHANNEL_SWIZZLE_B;
+    viewInfo.channels.a = VK_CHANNEL_SWIZZLE_A;
 
     viewInfo.subresourceRange.baseArraySlice = 0;
     viewInfo.subresourceRange.arraySize = 1;
     viewInfo.subresourceRange.baseMipLevel = 0;
     viewInfo.subresourceRange.mipLevels = 1;
-    viewInfo.subresourceRange.aspect = XGL_IMAGE_ASPECT_COLOR;
+    viewInfo.subresourceRange.aspect = VK_IMAGE_ASPECT_COLOR;
 
-    //    XGL_RESULT XGLAPI xglCreateImageView(
-    //        XGL_DEVICE                                  device,
-    //        const XGL_IMAGE_VIEW_CREATE_INFO*           pCreateInfo,
-    //        XGL_IMAGE_VIEW*                             pView);
+    //    VK_RESULT VKAPI vkCreateImageView(
+    //        VK_DEVICE                                  device,
+    //        const VK_IMAGE_VIEW_CREATE_INFO*           pCreateInfo,
+    //        VK_IMAGE_VIEW*                             pView);
 
     CreateImageView(&viewInfo, &imageView);
 
@@ -331,6 +331,6 @@
 
 int main(int argc, char **argv) {
     ::testing::InitGoogleTest(&argc, argv);
-    xgl_testing::set_error_callback(test_error_callback);
+    vk_testing::set_error_callback(test_error_callback);
     return RUN_ALL_TESTS();
 }
diff --git a/tests/init.cpp b/tests/init.cpp
index 72779af..9de9dfc 100644
--- a/tests/init.cpp
+++ b/tests/init.cpp
@@ -28,7 +28,7 @@
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 
-//  XGL tests
+//  VK tests
 //
 //  Copyright (C) 2014 LunarG, Inc.
 //
@@ -51,17 +51,17 @@
 //  DEALINGS IN THE SOFTWARE.
 
 
-// Verify XGL driver initialization
+// Verify VK driver initialization
 
 #include <stdlib.h>
 #include <stdio.h>
 #include <stdbool.h>
 #include <string.h>
 
-#include <xgl.h>
+#include <vulkan.h>
 #include "gtest-1.7.0/include/gtest/gtest.h"
 
-#include "xgltestbinding.h"
+#include "vktestbinding.h"
 #include "test_common.h"
 #include "icd-spv.h"
 
@@ -71,56 +71,56 @@
     void CreateCommandBufferTest();
     void CreatePipelineTest();
     void CreateShaderTest();
-    void CreateShader(XGL_SHADER *pshader);
+    void CreateShader(VK_SHADER *pshader);
 
-    XGL_DEVICE device() {return m_device->obj();}
+    VK_DEVICE device() {return m_device->obj();}
 
 protected:
-    XGL_APPLICATION_INFO app_info;
-    XGL_INSTANCE inst;
-    XGL_PHYSICAL_GPU objs[XGL_MAX_PHYSICAL_GPUS];
+    VK_APPLICATION_INFO app_info;
+    VK_INSTANCE inst;
+    VK_PHYSICAL_GPU objs[VK_MAX_PHYSICAL_GPUS];
     uint32_t gpu_count;
 
     uint32_t m_device_id;
-    xgl_testing::Device *m_device;
-    XGL_PHYSICAL_GPU_PROPERTIES props;
-    std::vector<XGL_PHYSICAL_GPU_QUEUE_PROPERTIES> queue_props;
+    vk_testing::Device *m_device;
+    VK_PHYSICAL_GPU_PROPERTIES props;
+    std::vector<VK_PHYSICAL_GPU_QUEUE_PROPERTIES> queue_props;
     uint32_t graphics_queue_node_index;
 
     virtual void SetUp() {
-        XGL_RESULT err;
+        VK_RESULT err;
         int i;
 
-        this->app_info.sType = XGL_STRUCTURE_TYPE_APPLICATION_INFO;
+        this->app_info.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
         this->app_info.pNext = NULL;
         this->app_info.pAppName = "base";
         this->app_info.appVersion = 1;
         this->app_info.pEngineName = "unittest";
         this->app_info.engineVersion = 1;
-        this->app_info.apiVersion = XGL_API_VERSION;
-        XGL_INSTANCE_CREATE_INFO inst_info = {};
-        inst_info.sType = XGL_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
+        this->app_info.apiVersion = VK_API_VERSION;
+        VK_INSTANCE_CREATE_INFO inst_info = {};
+        inst_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
         inst_info.pNext = NULL;
         inst_info.pAppInfo = &app_info;
         inst_info.pAllocCb = NULL;
         inst_info.extensionCount = 0;
         inst_info.ppEnabledExtensionNames = NULL;
-        err = xglCreateInstance(&inst_info, &inst);
-        ASSERT_XGL_SUCCESS(err);
-        err = xglEnumerateGpus(inst, XGL_MAX_PHYSICAL_GPUS, &this->gpu_count,
+        err = vkCreateInstance(&inst_info, &inst);
+        ASSERT_VK_SUCCESS(err);
+        err = vkEnumerateGpus(inst, VK_MAX_PHYSICAL_GPUS, &this->gpu_count,
                                objs);
-        ASSERT_XGL_SUCCESS(err);
+        ASSERT_VK_SUCCESS(err);
         ASSERT_GE(this->gpu_count, 1) << "No GPU available";
 
         m_device_id = 0;
-        this->m_device = new xgl_testing::Device(objs[m_device_id]);
+        this->m_device = new vk_testing::Device(objs[m_device_id]);
         this->m_device->init();
 
         props = m_device->gpu().properties();
 
         queue_props = this->m_device->gpu().queue_properties();
         for (i = 0; i < queue_props.size(); i++) {
-            if (queue_props[i].queueFlags & XGL_QUEUE_GRAPHICS_BIT) {
+            if (queue_props[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) {
                 graphics_queue_node_index = i;
                 break;
             }
@@ -129,331 +129,331 @@
     }
 
     virtual void TearDown() {
-        xglDestroyInstance(inst);
+        vkDestroyInstance(inst);
     }
 };
 
-TEST(Initialization, xglEnumerateGpus) {
-    XGL_APPLICATION_INFO app_info = {};
-    XGL_INSTANCE inst;
-    XGL_PHYSICAL_GPU objs[XGL_MAX_PHYSICAL_GPUS];
+TEST(Initialization, vkEnumerateGpus) {
+    VK_APPLICATION_INFO app_info = {};
+    VK_INSTANCE inst;
+    VK_PHYSICAL_GPU objs[VK_MAX_PHYSICAL_GPUS];
     uint32_t gpu_count;
-    XGL_RESULT err;
-    xgl_testing::PhysicalGpu *gpu;
+    VK_RESULT err;
+    vk_testing::PhysicalGpu *gpu;
     char *layers[16];
     size_t layer_count;
     char layer_buf[16][256];
-    XGL_INSTANCE_CREATE_INFO inst_info = {};
-    inst_info.sType = XGL_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
+    VK_INSTANCE_CREATE_INFO inst_info = {};
+    inst_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
     inst_info.pNext = NULL;
     inst_info.pAppInfo = &app_info;
     inst_info.pAllocCb = NULL;
     inst_info.extensionCount = 0;
     inst_info.ppEnabledExtensionNames = NULL;
-    app_info.sType = XGL_STRUCTURE_TYPE_APPLICATION_INFO;
+    app_info.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
     app_info.pNext = NULL;
     app_info.pAppName = "base";
     app_info.appVersion = 1;
     app_info.pEngineName = "unittest";
     app_info.engineVersion = 1;
-    app_info.apiVersion = XGL_API_VERSION;
+    app_info.apiVersion = VK_API_VERSION;
 
-    err = xglCreateInstance(&inst_info, &inst);
-    ASSERT_XGL_SUCCESS(err);
-    err = xglEnumerateGpus(inst, XGL_MAX_PHYSICAL_GPUS, &gpu_count, objs);
-    ASSERT_XGL_SUCCESS(err);
+    err = vkCreateInstance(&inst_info, &inst);
+    ASSERT_VK_SUCCESS(err);
+    err = vkEnumerateGpus(inst, VK_MAX_PHYSICAL_GPUS, &gpu_count, objs);
+    ASSERT_VK_SUCCESS(err);
     ASSERT_GE(gpu_count, 1) << "No GPU available";
 
     for (int i = 0; i < 16; i++)
         layers[i] = &layer_buf[i][0];
-    err = xglEnumerateLayers(objs[0], 16, 256, &layer_count, (char * const *) layers, NULL);
-    ASSERT_XGL_SUCCESS(err);
+    err = vkEnumerateLayers(objs[0], 16, 256, &layer_count, (char * const *) layers, NULL);
+    ASSERT_VK_SUCCESS(err);
     for (int i = 0; i < layer_count; i++) {
         printf("Enumerated layers: %s ", layers[i]);
     }
     printf("\n");
 
     // TODO: Iterate over all GPUs
-    gpu = new xgl_testing::PhysicalGpu(objs[0]);
+    gpu = new vk_testing::PhysicalGpu(objs[0]);
     delete gpu;
 
     // TODO: Verify destroy functions
-    err = xglDestroyInstance(inst);
-    ASSERT_XGL_SUCCESS(err);
+    err = vkDestroyInstance(inst);
+    ASSERT_VK_SUCCESS(err);
 }
 
 TEST_F(XglTest, AllocMemory) {
-    XGL_RESULT err;
-    XGL_MEMORY_ALLOC_INFO alloc_info = {};
-    XGL_GPU_MEMORY gpu_mem;
+    VK_RESULT err;
+    VK_MEMORY_ALLOC_INFO alloc_info = {};
+    VK_GPU_MEMORY gpu_mem;
     uint8_t *pData;
 
-    alloc_info.sType = XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO;
+    alloc_info.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO;
     alloc_info.allocationSize = 1024 * 1024; // 1MB
-    alloc_info.memProps = XGL_MEMORY_PROPERTY_SHAREABLE_BIT |
-                          XGL_MEMORY_PROPERTY_CPU_VISIBLE_BIT;
-    alloc_info.memType = XGL_MEMORY_TYPE_OTHER;
+    alloc_info.memProps = VK_MEMORY_PROPERTY_SHAREABLE_BIT |
+                          VK_MEMORY_PROPERTY_CPU_VISIBLE_BIT;
+    alloc_info.memType = VK_MEMORY_TYPE_OTHER;
 
 
     // TODO: Try variety of memory priorities
-    alloc_info.memPriority = XGL_MEMORY_PRIORITY_NORMAL;
+    alloc_info.memPriority = VK_MEMORY_PRIORITY_NORMAL;
 
-    err = xglAllocMemory(device(), &alloc_info, &gpu_mem);
-    ASSERT_XGL_SUCCESS(err);
+    err = vkAllocMemory(device(), &alloc_info, &gpu_mem);
+    ASSERT_VK_SUCCESS(err);
 
-    err = xglMapMemory(gpu_mem, 0, (void **) &pData);
-    ASSERT_XGL_SUCCESS(err);
+    err = vkMapMemory(gpu_mem, 0, (void **) &pData);
+    ASSERT_VK_SUCCESS(err);
 
     memset(pData, 0x55, alloc_info.allocationSize);
     EXPECT_EQ(0x55, pData[0]) << "Memory read not same a write";
 
-    err = xglUnmapMemory(gpu_mem);
-    ASSERT_XGL_SUCCESS(err);
+    err = vkUnmapMemory(gpu_mem);
+    ASSERT_VK_SUCCESS(err);
 
-    err = xglFreeMemory(gpu_mem);
-    ASSERT_XGL_SUCCESS(err);
+    err = vkFreeMemory(gpu_mem);
+    ASSERT_VK_SUCCESS(err);
 }
 
 TEST_F(XglTest, Event) {
-    XGL_EVENT_CREATE_INFO event_info;
-    XGL_EVENT event;
-    XGL_MEMORY_REQUIREMENTS mem_req;
+    VK_EVENT_CREATE_INFO event_info;
+    VK_EVENT event;
+    VK_MEMORY_REQUIREMENTS mem_req;
     size_t data_size = sizeof(mem_req);
-    XGL_RESULT err;
+    VK_RESULT err;
 
-    //        typedef struct _XGL_EVENT_CREATE_INFO
+    //        typedef struct _VK_EVENT_CREATE_INFO
     //        {
-    //            XGL_STRUCTURE_TYPE                      sType;      // Must be XGL_STRUCTURE_TYPE_EVENT_CREATE_INFO
+    //            VK_STRUCTURE_TYPE                      sType;      // Must be VK_STRUCTURE_TYPE_EVENT_CREATE_INFO
     //            const void*                             pNext;      // Pointer to next structure
-    //            XGL_FLAGS                               flags;      // Reserved
-    //        } XGL_EVENT_CREATE_INFO;
+    //            VK_FLAGS                               flags;      // Reserved
+    //        } VK_EVENT_CREATE_INFO;
     memset(&event_info, 0, sizeof(event_info));
-    event_info.sType = XGL_STRUCTURE_TYPE_EVENT_CREATE_INFO;
+    event_info.sType = VK_STRUCTURE_TYPE_EVENT_CREATE_INFO;
 
-    err = xglCreateEvent(device(), &event_info, &event);
-    ASSERT_XGL_SUCCESS(err);
+    err = vkCreateEvent(device(), &event_info, &event);
+    ASSERT_VK_SUCCESS(err);
 
-    err = xglGetObjectInfo(event, XGL_INFO_TYPE_MEMORY_REQUIREMENTS,
+    err = vkGetObjectInfo(event, VK_INFO_TYPE_MEMORY_REQUIREMENTS,
                            &data_size, &mem_req);
-    ASSERT_XGL_SUCCESS(err);
+    ASSERT_VK_SUCCESS(err);
 
-    //        XGL_RESULT XGLAPI xglAllocMemory(
-    //            XGL_DEVICE                                  device,
-    //            const XGL_MEMORY_ALLOC_INFO*                pAllocInfo,
-    //            XGL_GPU_MEMORY*                             pMem);
-    XGL_MEMORY_ALLOC_INFO mem_info;
-    XGL_GPU_MEMORY event_mem;
+    //        VK_RESULT VKAPI vkAllocMemory(
+    //            VK_DEVICE                                  device,
+    //            const VK_MEMORY_ALLOC_INFO*                pAllocInfo,
+    //            VK_GPU_MEMORY*                             pMem);
+    VK_MEMORY_ALLOC_INFO mem_info;
+    VK_GPU_MEMORY event_mem;
 
-    ASSERT_NE(0, mem_req.size) << "xglGetObjectInfo (Event): Failed - expect events to require memory";
+    ASSERT_NE(0, mem_req.size) << "vkGetObjectInfo (Event): Failed - expect events to require memory";
 
     memset(&mem_info, 0, sizeof(mem_info));
-    mem_info.sType = XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO;
+    mem_info.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO;
     mem_info.allocationSize = mem_req.size;
-    mem_info.memProps = XGL_MEMORY_PROPERTY_SHAREABLE_BIT;
-    mem_info.memPriority = XGL_MEMORY_PRIORITY_NORMAL;
-    mem_info.memType = XGL_MEMORY_TYPE_OTHER;
-    err = xglAllocMemory(device(), &mem_info, &event_mem);
-    ASSERT_XGL_SUCCESS(err);
+    mem_info.memProps = VK_MEMORY_PROPERTY_SHAREABLE_BIT;
+    mem_info.memPriority = VK_MEMORY_PRIORITY_NORMAL;
+    mem_info.memType = VK_MEMORY_TYPE_OTHER;
+    err = vkAllocMemory(device(), &mem_info, &event_mem);
+    ASSERT_VK_SUCCESS(err);
 
-    err = xglBindObjectMemory(event, 0, event_mem, 0);
-    ASSERT_XGL_SUCCESS(err);
+    err = vkBindObjectMemory(event, 0, event_mem, 0);
+    ASSERT_VK_SUCCESS(err);
 
-    err = xglResetEvent(event);
-    ASSERT_XGL_SUCCESS(err);
+    err = vkResetEvent(event);
+    ASSERT_VK_SUCCESS(err);
 
-    err = xglGetEventStatus(event);
-    ASSERT_EQ(XGL_EVENT_RESET, err);
+    err = vkGetEventStatus(event);
+    ASSERT_EQ(VK_EVENT_RESET, err);
 
-    err = xglSetEvent(event);
-    ASSERT_XGL_SUCCESS(err);
+    err = vkSetEvent(event);
+    ASSERT_VK_SUCCESS(err);
 
-    err = xglGetEventStatus(event);
-    ASSERT_EQ(XGL_EVENT_SET, err);
+    err = vkGetEventStatus(event);
+    ASSERT_EQ(VK_EVENT_SET, err);
 
     // TODO: Test actual synchronization with command buffer event.
 
     // All done with event memory, clean up
-    err = xglBindObjectMemory(event, 0, XGL_NULL_HANDLE, 0);
-    ASSERT_XGL_SUCCESS(err);
+    err = vkBindObjectMemory(event, 0, VK_NULL_HANDLE, 0);
+    ASSERT_VK_SUCCESS(err);
 
-    err = xglDestroyObject(event);
-    ASSERT_XGL_SUCCESS(err);
+    err = vkDestroyObject(event);
+    ASSERT_VK_SUCCESS(err);
 }
 
 TEST_F(XglTest, Fence) {
-    XGL_RESULT err;
-    XGL_FENCE_CREATE_INFO fence_info;
-    XGL_FENCE fence;
+    VK_RESULT err;
+    VK_FENCE_CREATE_INFO fence_info;
+    VK_FENCE fence;
 
     memset(&fence_info, 0, sizeof(fence_info));
 
-    //            typedef struct _XGL_FENCE_CREATE_INFO
+    //            typedef struct _VK_FENCE_CREATE_INFO
     //            {
-    //                XGL_STRUCTURE_TYPE                      sType;      // Must be XGL_STRUCTURE_TYPE_FENCE_CREATE_INFO
+    //                VK_STRUCTURE_TYPE                      sType;      // Must be VK_STRUCTURE_TYPE_FENCE_CREATE_INFO
     //                const void*                             pNext;      // Pointer to next structure
-    //                XGL_FLAGS                               flags;      // Reserved
-    fence_info.sType = XGL_STRUCTURE_TYPE_FENCE_CREATE_INFO;
+    //                VK_FLAGS                               flags;      // Reserved
+    fence_info.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
 
-    err = xglCreateFence(device(), &fence_info, &fence);
-    ASSERT_XGL_SUCCESS(err);
+    err = vkCreateFence(device(), &fence_info, &fence);
+    ASSERT_VK_SUCCESS(err);
 
-    err = xglGetFenceStatus(fence);
+    err = vkGetFenceStatus(fence);
     // We've not submitted this fence on a command buffer so should get
-    // XGL_ERROR_UNAVAILABLE
-    EXPECT_EQ(XGL_ERROR_UNAVAILABLE, err);
+    // VK_ERROR_UNAVAILABLE
+    EXPECT_EQ(VK_ERROR_UNAVAILABLE, err);
 
     // Test glxWaitForFences
-    //        XGL_RESULT XGLAPI xglWaitForFences(
-    //            XGL_DEVICE                                  device,
+    //        VK_RESULT VKAPI vkWaitForFences(
+    //            VK_DEVICE                                  device,
     //            uint32_t                                    fenceCount,
-    //            const XGL_FENCE*                            pFences,
+    //            const VK_FENCE*                            pFences,
     //            bool32_t                                    waitAll,
     //            uint64_t                                    timeout);
-    err = xglWaitForFences(device(), 1, &fence, XGL_TRUE, 0);
-    EXPECT_EQ(XGL_ERROR_UNAVAILABLE, err);
+    err = vkWaitForFences(device(), 1, &fence, VK_TRUE, 0);
+    EXPECT_EQ(VK_ERROR_UNAVAILABLE, err);
 
     // TODO: Attached to command buffer and test GetFenceStatus
     // TODO: Add some commands and submit the command buffer
 
-    err = xglDestroyObject(fence);
-    ASSERT_XGL_SUCCESS(err);
+    err = vkDestroyObject(fence);
+    ASSERT_VK_SUCCESS(err);
 
 }
 
 #define MAX_QUERY_SLOTS 10
 
 TEST_F(XglTest, Query) {
-    XGL_QUERY_POOL_CREATE_INFO query_info;
-    XGL_QUERY_POOL query_pool;
+    VK_QUERY_POOL_CREATE_INFO query_info;
+    VK_QUERY_POOL query_pool;
     size_t data_size;
-    XGL_MEMORY_REQUIREMENTS mem_req;
+    VK_MEMORY_REQUIREMENTS mem_req;
     size_t query_result_size;
     uint32_t *query_result_data;
-    XGL_RESULT err;
+    VK_RESULT err;
 
-    //        typedef enum _XGL_QUERY_TYPE
+    //        typedef enum _VK_QUERY_TYPE
     //        {
-    //            XGL_QUERY_OCCLUSION                                     = 0x00000000,
-    //            XGL_QUERY_PIPELINE_STATISTICS                           = 0x00000001,
+    //            VK_QUERY_OCCLUSION                                     = 0x00000000,
+    //            VK_QUERY_PIPELINE_STATISTICS                           = 0x00000001,
 
-    //            XGL_QUERY_TYPE_BEGIN_RANGE                              = XGL_QUERY_OCCLUSION,
-    //            XGL_QUERY_TYPE_END_RANGE                                = XGL_QUERY_PIPELINE_STATISTICS,
-    //            XGL_NUM_QUERY_TYPE                                      = (XGL_QUERY_TYPE_END_RANGE - XGL_QUERY_TYPE_BEGIN_RANGE + 1),
-    //            XGL_MAX_ENUM(_XGL_QUERY_TYPE)
-    //        } XGL_QUERY_TYPE;
+    //            VK_QUERY_TYPE_BEGIN_RANGE                              = VK_QUERY_OCCLUSION,
+    //            VK_QUERY_TYPE_END_RANGE                                = VK_QUERY_PIPELINE_STATISTICS,
+    //            VK_NUM_QUERY_TYPE                                      = (VK_QUERY_TYPE_END_RANGE - VK_QUERY_TYPE_BEGIN_RANGE + 1),
+    //            VK_MAX_ENUM(_VK_QUERY_TYPE)
+    //        } VK_QUERY_TYPE;
 
-    //        typedef struct _XGL_QUERY_POOL_CREATE_INFO
+    //        typedef struct _VK_QUERY_POOL_CREATE_INFO
     //        {
-    //            XGL_STRUCTURE_TYPE                      sType;      // Must be XGL_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO
+    //            VK_STRUCTURE_TYPE                      sType;      // Must be VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO
     //            const void*                             pNext;      // Pointer to next structure
-    //            XGL_QUERY_TYPE                          queryType;
+    //            VK_QUERY_TYPE                          queryType;
     //            uint32_t                                slots;
-    //        } XGL_QUERY_POOL_CREATE_INFO;
+    //        } VK_QUERY_POOL_CREATE_INFO;
 
     memset(&query_info, 0, sizeof(query_info));
-    query_info.sType = XGL_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO;
-    query_info.queryType = XGL_QUERY_OCCLUSION;
+    query_info.sType = VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO;
+    query_info.queryType = VK_QUERY_OCCLUSION;
     query_info.slots = MAX_QUERY_SLOTS;
 
-    //        XGL_RESULT XGLAPI xglCreateQueryPool(
-    //            XGL_DEVICE                                  device,
-    //            const XGL_QUERY_POOL_CREATE_INFO*           pCreateInfo,
-    //            XGL_QUERY_POOL*                             pQueryPool);
+    //        VK_RESULT VKAPI vkCreateQueryPool(
+    //            VK_DEVICE                                  device,
+    //            const VK_QUERY_POOL_CREATE_INFO*           pCreateInfo,
+    //            VK_QUERY_POOL*                             pQueryPool);
 
-    err = xglCreateQueryPool(device(), &query_info, &query_pool);
-    ASSERT_XGL_SUCCESS(err);
+    err = vkCreateQueryPool(device(), &query_info, &query_pool);
+    ASSERT_VK_SUCCESS(err);
 
     data_size = sizeof(mem_req);
-    err = xglGetObjectInfo(query_pool, XGL_INFO_TYPE_MEMORY_REQUIREMENTS,
+    err = vkGetObjectInfo(query_pool, VK_INFO_TYPE_MEMORY_REQUIREMENTS,
                            &data_size, &mem_req);
-    ASSERT_XGL_SUCCESS(err);
+    ASSERT_VK_SUCCESS(err);
     ASSERT_NE(0, data_size) << "Invalid data_size";
 
-    //        XGL_RESULT XGLAPI xglAllocMemory(
-    //            XGL_DEVICE                                  device,
-    //            const XGL_MEMORY_ALLOC_INFO*                pAllocInfo,
-    //            XGL_GPU_MEMORY*                             pMem);
-    XGL_MEMORY_ALLOC_INFO mem_info;
-    XGL_GPU_MEMORY query_mem;
+    //        VK_RESULT VKAPI vkAllocMemory(
+    //            VK_DEVICE                                  device,
+    //            const VK_MEMORY_ALLOC_INFO*                pAllocInfo,
+    //            VK_GPU_MEMORY*                             pMem);
+    VK_MEMORY_ALLOC_INFO mem_info;
+    VK_GPU_MEMORY query_mem;
 
     memset(&mem_info, 0, sizeof(mem_info));
-    mem_info.sType = XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO;
+    mem_info.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO;
     // TODO: Is a simple multiple all that's needed here?
     mem_info.allocationSize = mem_req.size * MAX_QUERY_SLOTS;
-    mem_info.memProps = XGL_MEMORY_PROPERTY_SHAREABLE_BIT;
-    mem_info.memType = XGL_MEMORY_TYPE_OTHER;
-    mem_info.memPriority = XGL_MEMORY_PRIORITY_NORMAL;
+    mem_info.memProps = VK_MEMORY_PROPERTY_SHAREABLE_BIT;
+    mem_info.memType = VK_MEMORY_TYPE_OTHER;
+    mem_info.memPriority = VK_MEMORY_PRIORITY_NORMAL;
     // TODO: Should this be pinned? Or maybe a separate test with pinned.
-    err = xglAllocMemory(device(), &mem_info, &query_mem);
-    ASSERT_XGL_SUCCESS(err);
+    err = vkAllocMemory(device(), &mem_info, &query_mem);
+    ASSERT_VK_SUCCESS(err);
 
-    err = xglBindObjectMemory(query_pool, 0, query_mem, 0);
-    ASSERT_XGL_SUCCESS(err);
+    err = vkBindObjectMemory(query_pool, 0, query_mem, 0);
+    ASSERT_VK_SUCCESS(err);
 
     // TODO: Test actual synchronization with command buffer event.
     // TODO: Create command buffer
-    // TODO: xglCmdResetQueryPool
-    // TODO: xglCmdBeginQuery
+    // TODO: vkCmdResetQueryPool
+    // TODO: vkCmdBeginQuery
     // TODO: commands
-    // TOOD: xglCmdEndQuery
+    // TOOD: vkCmdEndQuery
 
-    err = xglGetQueryPoolResults(query_pool, 0, MAX_QUERY_SLOTS,
-                                 &query_result_size, XGL_NULL_HANDLE);
-    ASSERT_XGL_SUCCESS(err);
+    err = vkGetQueryPoolResults(query_pool, 0, MAX_QUERY_SLOTS,
+                                 &query_result_size, VK_NULL_HANDLE);
+    ASSERT_VK_SUCCESS(err);
 
     if (query_result_size > 0) {
         query_result_data = new uint32_t [query_result_size];
-        err = xglGetQueryPoolResults(query_pool, 0, MAX_QUERY_SLOTS,
+        err = vkGetQueryPoolResults(query_pool, 0, MAX_QUERY_SLOTS,
                                      &query_result_size, query_result_data);
-        ASSERT_XGL_SUCCESS(err);
+        ASSERT_VK_SUCCESS(err);
 
         // TODO: Test Query result data.
 
     }
 
     // All done with QueryPool memory, clean up
-    err = xglBindObjectMemory(query_pool, 0, XGL_NULL_HANDLE, 0);
-    ASSERT_XGL_SUCCESS(err);
+    err = vkBindObjectMemory(query_pool, 0, VK_NULL_HANDLE, 0);
+    ASSERT_VK_SUCCESS(err);
 
-    err = xglDestroyObject(query_pool);
-    ASSERT_XGL_SUCCESS(err);
+    err = vkDestroyObject(query_pool);
+    ASSERT_VK_SUCCESS(err);
 }
 
-void getQueue(xgl_testing::Device *device, uint32_t queue_node_index, const char *qname)
+void getQueue(vk_testing::Device *device, uint32_t queue_node_index, const char *qname)
 {
     int que_idx;
-    XGL_RESULT err;
-    XGL_QUEUE queue;
+    VK_RESULT err;
+    VK_QUEUE queue;
 
-    const XGL_PHYSICAL_GPU_QUEUE_PROPERTIES props = device->gpu().queue_properties()[queue_node_index];
+    const VK_PHYSICAL_GPU_QUEUE_PROPERTIES props = device->gpu().queue_properties()[queue_node_index];
     for (que_idx = 0; que_idx < props.queueCount; que_idx++) {
-        err = xglGetDeviceQueue(device->obj(), queue_node_index, que_idx, &queue);
-        ASSERT_EQ(XGL_SUCCESS, err) << "xglGetDeviceQueue: " << qname << " queue #" << que_idx << ": Failed with error: " << xgl_result_string(err);
+        err = vkGetDeviceQueue(device->obj(), queue_node_index, que_idx, &queue);
+        ASSERT_EQ(VK_SUCCESS, err) << "vkGetDeviceQueue: " << qname << " queue #" << que_idx << ": Failed with error: " << vk_result_string(err);
     }
 }
 
 
-void print_queue_info(xgl_testing::Device *device, uint32_t queue_node_index)
+void print_queue_info(vk_testing::Device *device, uint32_t queue_node_index)
 {
     uint32_t que_idx;
-    XGL_PHYSICAL_GPU_QUEUE_PROPERTIES queue_props;
-    XGL_PHYSICAL_GPU_PROPERTIES props;
+    VK_PHYSICAL_GPU_QUEUE_PROPERTIES queue_props;
+    VK_PHYSICAL_GPU_PROPERTIES props;
 
     props = device->gpu().properties();
     queue_props = device->gpu().queue_properties()[queue_node_index];
     ASSERT_NE(0, queue_props.queueCount) << "No Queues available at Node Index #" << queue_node_index << " GPU: " << props.gpuName;
 
-//            XGL_RESULT XGLAPI xglGetDeviceQueue(
-//                XGL_DEVICE                                  device,
+//            VK_RESULT VKAPI vkGetDeviceQueue(
+//                VK_DEVICE                                  device,
 //                uint32_t                                    queueNodeIndex,
 //                uint32_t                                    queueIndex,
-//                XGL_QUEUE*                                  pQueue);
+//                VK_QUEUE*                                  pQueue);
     /*
      * queue handles are retrieved from the device by calling
-     * xglGetDeviceQueue() with a queue node index and a requested logical
+     * vkGetDeviceQueue() with a queue node index and a requested logical
      * queue ID. The queue node index is the index into the array of
-     * XGL_PHYSICAL_GPU_QUEUE_PROPERTIES returned by GetGpuInfo. Each
-     * queue node index has different attributes specified by the XGL_QUEUE_FLAGS property.
+     * VK_PHYSICAL_GPU_QUEUE_PROPERTIES returned by GetGpuInfo. Each
+     * queue node index has different attributes specified by the VK_QUEUE_FLAGS property.
      * The logical queue ID is a sequential number starting from zero
      * and referencing up to the number of queues supported of that node index
      * at device creation.
@@ -461,23 +461,23 @@
 
     for (que_idx = 0; que_idx < queue_props.queueCount; que_idx++) {
 
-//                typedef enum _XGL_QUEUE_FLAGS
+//                typedef enum _VK_QUEUE_FLAGS
 //                {
-//                    XGL_QUEUE_GRAPHICS_BIT                                  = 0x00000001,   // Queue supports graphics operations
-//                    XGL_QUEUE_COMPUTE_BIT                                   = 0x00000002,   // Queue supports compute operations
-//                    XGL_QUEUE_DMA_BIT                                       = 0x00000004,   // Queue supports DMA operations
-//                    XGL_QUEUE_EXTENDED_BIT                                  = 0x80000000    // Extended queue
-//                } XGL_QUEUE_FLAGS;
+//                    VK_QUEUE_GRAPHICS_BIT                                  = 0x00000001,   // Queue supports graphics operations
+//                    VK_QUEUE_COMPUTE_BIT                                   = 0x00000002,   // Queue supports compute operations
+//                    VK_QUEUE_DMA_BIT                                       = 0x00000004,   // Queue supports DMA operations
+//                    VK_QUEUE_EXTENDED_BIT                                  = 0x80000000    // Extended queue
+//                } VK_QUEUE_FLAGS;
 
-        if (queue_props.queueFlags & XGL_QUEUE_GRAPHICS_BIT) {
+        if (queue_props.queueFlags & VK_QUEUE_GRAPHICS_BIT) {
             getQueue(device, queue_node_index, "Graphics");
         }
 
-        if (queue_props.queueFlags & XGL_QUEUE_COMPUTE_BIT) {
+        if (queue_props.queueFlags & VK_QUEUE_COMPUTE_BIT) {
             getQueue(device, queue_node_index, "Compute");
         }
 
-        if (queue_props.queueFlags & XGL_QUEUE_DMA_BIT) {
+        if (queue_props.queueFlags & VK_QUEUE_DMA_BIT) {
             getQueue(device, queue_node_index, "DMA");
         }
 
@@ -504,12 +504,12 @@
 
 void XglTest::CreateImageTest()
 {
-    XGL_RESULT err;
-    XGL_IMAGE image;
+    VK_RESULT err;
+    VK_IMAGE image;
     uint32_t w, h, mipCount;
     size_t size;
-    XGL_FORMAT fmt;
-    XGL_FORMAT_PROPERTIES image_fmt;
+    VK_FORMAT fmt;
+    VK_FORMAT_PROPERTIES image_fmt;
     size_t data_size;
 
     w =512;
@@ -525,11 +525,11 @@
         mipCount++;
     }
 
-    fmt = XGL_FMT_R8G8B8A8_UINT;
+    fmt = VK_FMT_R8G8B8A8_UINT;
     // TODO: Pick known good format rather than just expect common format
     /*
      * XXX: What should happen if given NULL HANDLE for the pData argument?
-     * We're not requesting XGL_INFO_TYPE_MEMORY_REQUIREMENTS so there is
+     * We're not requesting VK_INFO_TYPE_MEMORY_REQUIREMENTS so there is
      * an expectation that pData is a valid pointer.
      * However, why include a returned size value? That implies that the
      * amount of data may vary and that doesn't work well for using a
@@ -537,30 +537,30 @@
      */
 
     size = sizeof(image_fmt);
-    err = xglGetFormatInfo(device(), fmt,
-                           XGL_INFO_TYPE_FORMAT_PROPERTIES,
+    err = vkGetFormatInfo(device(), fmt,
+                           VK_INFO_TYPE_FORMAT_PROPERTIES,
                            &size, &image_fmt);
-    ASSERT_XGL_SUCCESS(err);
+    ASSERT_VK_SUCCESS(err);
 
-//    typedef struct _XGL_IMAGE_CREATE_INFO
+//    typedef struct _VK_IMAGE_CREATE_INFO
 //    {
-//        XGL_STRUCTURE_TYPE                      sType;                      // Must be XGL_STRUCTURE_TYPE_IMAGE_CREATE_INFO
+//        VK_STRUCTURE_TYPE                      sType;                      // Must be VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO
 //        const void*                             pNext;                      // Pointer to next structure.
-//        XGL_IMAGE_TYPE                          imageType;
-//        XGL_FORMAT                              format;
-//        XGL_EXTENT3D                            extent;
+//        VK_IMAGE_TYPE                          imageType;
+//        VK_FORMAT                              format;
+//        VK_EXTENT3D                            extent;
 //        uint32_t                                mipLevels;
 //        uint32_t                                arraySize;
 //        uint32_t                                samples;
-//        XGL_IMAGE_TILING                        tiling;
-//        XGL_FLAGS                               usage;                      // XGL_IMAGE_USAGE_FLAGS
-//        XGL_FLAGS                               flags;                      // XGL_IMAGE_CREATE_FLAGS
-//    } XGL_IMAGE_CREATE_INFO;
+//        VK_IMAGE_TILING                        tiling;
+//        VK_FLAGS                               usage;                      // VK_IMAGE_USAGE_FLAGS
+//        VK_FLAGS                               flags;                      // VK_IMAGE_CREATE_FLAGS
+//    } VK_IMAGE_CREATE_INFO;
 
 
-    XGL_IMAGE_CREATE_INFO imageCreateInfo = {};
-    imageCreateInfo.sType = XGL_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
-    imageCreateInfo.imageType = XGL_IMAGE_2D;
+    VK_IMAGE_CREATE_INFO imageCreateInfo = {};
+    imageCreateInfo.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
+    imageCreateInfo.imageType = VK_IMAGE_2D;
     imageCreateInfo.format = fmt;
     imageCreateInfo.arraySize = 1;
     imageCreateInfo.extent.width = w;
@@ -568,67 +568,67 @@
     imageCreateInfo.extent.depth = 1;
     imageCreateInfo.mipLevels = mipCount;
     imageCreateInfo.samples = 1;
-    imageCreateInfo.tiling = XGL_LINEAR_TILING;
+    imageCreateInfo.tiling = VK_LINEAR_TILING;
 
 // Image usage flags
-//    typedef enum _XGL_IMAGE_USAGE_FLAGS
+//    typedef enum _VK_IMAGE_USAGE_FLAGS
 //    {
-//        XGL_IMAGE_USAGE_SHADER_ACCESS_READ_BIT                  = 0x00000001,
-//        XGL_IMAGE_USAGE_SHADER_ACCESS_WRITE_BIT                 = 0x00000002,
-//        XGL_IMAGE_USAGE_COLOR_ATTACHMENT_BIT                    = 0x00000004,
-//        XGL_IMAGE_USAGE_DEPTH_STENCIL_BIT                       = 0x00000008,
-//    } XGL_IMAGE_USAGE_FLAGS;
-    imageCreateInfo.usage = XGL_IMAGE_USAGE_SHADER_ACCESS_WRITE_BIT | XGL_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
+//        VK_IMAGE_USAGE_SHADER_ACCESS_READ_BIT                  = 0x00000001,
+//        VK_IMAGE_USAGE_SHADER_ACCESS_WRITE_BIT                 = 0x00000002,
+//        VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT                    = 0x00000004,
+//        VK_IMAGE_USAGE_DEPTH_STENCIL_BIT                       = 0x00000008,
+//    } VK_IMAGE_USAGE_FLAGS;
+    imageCreateInfo.usage = VK_IMAGE_USAGE_SHADER_ACCESS_WRITE_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
 
-//    XGL_RESULT XGLAPI xglCreateImage(
-//        XGL_DEVICE                                  device,
-//        const XGL_IMAGE_CREATE_INFO*                pCreateInfo,
-//        XGL_IMAGE*                                  pImage);
-    err = xglCreateImage(device(), &imageCreateInfo, &image);
-    ASSERT_XGL_SUCCESS(err);
+//    VK_RESULT VKAPI vkCreateImage(
+//        VK_DEVICE                                  device,
+//        const VK_IMAGE_CREATE_INFO*                pCreateInfo,
+//        VK_IMAGE*                                  pImage);
+    err = vkCreateImage(device(), &imageCreateInfo, &image);
+    ASSERT_VK_SUCCESS(err);
 
     // Verify image resources
-//    XGL_RESULT XGLAPI xglGetImageSubresourceInfo(
-//        XGL_IMAGE                                   image,
-//        const XGL_IMAGE_SUBRESOURCE*                pSubresource,
-//        XGL_SUBRESOURCE_INFO_TYPE                   infoType,
+//    VK_RESULT VKAPI vkGetImageSubresourceInfo(
+//        VK_IMAGE                                   image,
+//        const VK_IMAGE_SUBRESOURCE*                pSubresource,
+//        VK_SUBRESOURCE_INFO_TYPE                   infoType,
 //        size_t*                                     pDataSize,
 //        void*                                       pData);
-//    typedef struct _XGL_SUBRESOURCE_LAYOUT
+//    typedef struct _VK_SUBRESOURCE_LAYOUT
 //    {
-//        XGL_GPU_SIZE                            offset;                 // Specified in bytes
-//        XGL_GPU_SIZE                            size;                   // Specified in bytes
-//        XGL_GPU_SIZE                            rowPitch;               // Specified in bytes
-//        XGL_GPU_SIZE                            depthPitch;             // Specified in bytes
-//    } XGL_SUBRESOURCE_LAYOUT;
+//        VK_GPU_SIZE                            offset;                 // Specified in bytes
+//        VK_GPU_SIZE                            size;                   // Specified in bytes
+//        VK_GPU_SIZE                            rowPitch;               // Specified in bytes
+//        VK_GPU_SIZE                            depthPitch;             // Specified in bytes
+//    } VK_SUBRESOURCE_LAYOUT;
 
-//    typedef struct _XGL_IMAGE_SUBRESOURCE
+//    typedef struct _VK_IMAGE_SUBRESOURCE
 //    {
-//        XGL_IMAGE_ASPECT                        aspect;
+//        VK_IMAGE_ASPECT                        aspect;
 //        uint32_t                                mipLevel;
 //        uint32_t                                arraySlice;
-//    } XGL_IMAGE_SUBRESOURCE;
-//    typedef enum _XGL_SUBRESOURCE_INFO_TYPE
+//    } VK_IMAGE_SUBRESOURCE;
+//    typedef enum _VK_SUBRESOURCE_INFO_TYPE
 //    {
-//        // Info type for xglGetImageSubresourceInfo()
-//        XGL_INFO_TYPE_SUBRESOURCE_LAYOUT                        = 0x00000000,
+//        // Info type for vkGetImageSubresourceInfo()
+//        VK_INFO_TYPE_SUBRESOURCE_LAYOUT                        = 0x00000000,
 
-//        XGL_MAX_ENUM(_XGL_SUBRESOURCE_INFO_TYPE)
-//    } XGL_SUBRESOURCE_INFO_TYPE;
-    XGL_IMAGE_SUBRESOURCE subresource = {};
-    subresource.aspect = XGL_IMAGE_ASPECT_COLOR;
+//        VK_MAX_ENUM(_VK_SUBRESOURCE_INFO_TYPE)
+//    } VK_SUBRESOURCE_INFO_TYPE;
+    VK_IMAGE_SUBRESOURCE subresource = {};
+    subresource.aspect = VK_IMAGE_ASPECT_COLOR;
     subresource.arraySlice = 0;
 
     _w = w;
     _h = h;
     while( ( _w > 0 ) || ( _h > 0 ) )
     {
-        XGL_SUBRESOURCE_LAYOUT layout = {};
+        VK_SUBRESOURCE_LAYOUT layout = {};
         data_size = sizeof(layout);
-        err = xglGetImageSubresourceInfo(image, &subresource, XGL_INFO_TYPE_SUBRESOURCE_LAYOUT,
+        err = vkGetImageSubresourceInfo(image, &subresource, VK_INFO_TYPE_SUBRESOURCE_LAYOUT,
                                          &data_size, &layout);
-        ASSERT_XGL_SUCCESS(err);
-        ASSERT_EQ(sizeof(XGL_SUBRESOURCE_LAYOUT), data_size) << "Invalid structure (XGL_SUBRESOURCE_LAYOUT) size";
+        ASSERT_VK_SUCCESS(err);
+        ASSERT_EQ(sizeof(VK_SUBRESOURCE_LAYOUT), data_size) << "Invalid structure (VK_SUBRESOURCE_LAYOUT) size";
 
         // TODO: 4 should be replaced with pixel size for given format
         EXPECT_LE(_w * 4, layout.rowPitch) << "Pitch does not match expected image pitch";
@@ -638,91 +638,91 @@
         subresource.mipLevel++;
     }
 
-    XGL_MEMORY_ALLOC_IMAGE_INFO img_alloc = {
-        .sType = XGL_STRUCTURE_TYPE_MEMORY_ALLOC_IMAGE_INFO,
+    VK_MEMORY_ALLOC_IMAGE_INFO img_alloc = {
+        .sType = VK_STRUCTURE_TYPE_MEMORY_ALLOC_IMAGE_INFO,
         .pNext = NULL,
 
     };
-    XGL_MEMORY_REQUIREMENTS mem_req;
-    XGL_IMAGE_MEMORY_REQUIREMENTS img_reqs;
-    size_t img_reqs_size = sizeof(XGL_IMAGE_MEMORY_REQUIREMENTS);
+    VK_MEMORY_REQUIREMENTS mem_req;
+    VK_IMAGE_MEMORY_REQUIREMENTS img_reqs;
+    size_t img_reqs_size = sizeof(VK_IMAGE_MEMORY_REQUIREMENTS);
     data_size = sizeof(mem_req);
-    err = xglGetObjectInfo(image, XGL_INFO_TYPE_MEMORY_REQUIREMENTS,
+    err = vkGetObjectInfo(image, VK_INFO_TYPE_MEMORY_REQUIREMENTS,
                            &data_size, &mem_req);
-    ASSERT_XGL_SUCCESS(err);
+    ASSERT_VK_SUCCESS(err);
     ASSERT_EQ(data_size, sizeof(mem_req));
-    ASSERT_NE(0, mem_req.size) << "xglGetObjectInfo (Event): Failed - expect images to require memory";
-    err = xglGetObjectInfo(image, XGL_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS,
+    ASSERT_NE(0, mem_req.size) << "vkGetObjectInfo (Event): Failed - expect images to require memory";
+    err = vkGetObjectInfo(image, VK_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS,
                            &img_reqs_size, &img_reqs);
-    ASSERT_XGL_SUCCESS(err);
-    ASSERT_EQ(img_reqs_size, sizeof(XGL_IMAGE_MEMORY_REQUIREMENTS));
+    ASSERT_VK_SUCCESS(err);
+    ASSERT_EQ(img_reqs_size, sizeof(VK_IMAGE_MEMORY_REQUIREMENTS));
     img_alloc.usage = img_reqs.usage;
     img_alloc.formatClass = img_reqs.formatClass;
     img_alloc.samples = img_reqs.samples;
-    //        XGL_RESULT XGLAPI xglAllocMemory(
-    //            XGL_DEVICE                                  device,
-    //            const XGL_MEMORY_ALLOC_INFO*                pAllocInfo,
-    //            XGL_GPU_MEMORY*                             pMem);
-    XGL_MEMORY_ALLOC_INFO mem_info = {};
-    XGL_GPU_MEMORY image_mem;
+    //        VK_RESULT VKAPI vkAllocMemory(
+    //            VK_DEVICE                                  device,
+    //            const VK_MEMORY_ALLOC_INFO*                pAllocInfo,
+    //            VK_GPU_MEMORY*                             pMem);
+    VK_MEMORY_ALLOC_INFO mem_info = {};
+    VK_GPU_MEMORY image_mem;
 
-    mem_info.sType = XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO;
+    mem_info.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO;
     mem_info.pNext = &img_alloc;
     mem_info.allocationSize = mem_req.size;
-    mem_info.memProps = XGL_MEMORY_PROPERTY_SHAREABLE_BIT;
-    mem_info.memType = XGL_MEMORY_TYPE_IMAGE;
-    mem_info.memPriority = XGL_MEMORY_PRIORITY_NORMAL;
-    err = xglAllocMemory(device(), &mem_info, &image_mem);
-    ASSERT_XGL_SUCCESS(err);
+    mem_info.memProps = VK_MEMORY_PROPERTY_SHAREABLE_BIT;
+    mem_info.memType = VK_MEMORY_TYPE_IMAGE;
+    mem_info.memPriority = VK_MEMORY_PRIORITY_NORMAL;
+    err = vkAllocMemory(device(), &mem_info, &image_mem);
+    ASSERT_VK_SUCCESS(err);
 
-    err = xglBindObjectMemory(image, 0, image_mem, 0);
-    ASSERT_XGL_SUCCESS(err);
+    err = vkBindObjectMemory(image, 0, image_mem, 0);
+    ASSERT_VK_SUCCESS(err);
 
-//    typedef struct _XGL_IMAGE_VIEW_CREATE_INFO
+//    typedef struct _VK_IMAGE_VIEW_CREATE_INFO
 //    {
-//        XGL_STRUCTURE_TYPE                      sType;                  // Must be XGL_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO
+//        VK_STRUCTURE_TYPE                      sType;                  // Must be VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO
 //        const void*                             pNext;                  // Pointer to next structure
-//        XGL_IMAGE                               image;
-//        XGL_IMAGE_VIEW_TYPE                     viewType;
-//        XGL_FORMAT                              format;
-//        XGL_CHANNEL_MAPPING                     channels;
-//        XGL_IMAGE_SUBRESOURCE_RANGE             subresourceRange;
+//        VK_IMAGE                               image;
+//        VK_IMAGE_VIEW_TYPE                     viewType;
+//        VK_FORMAT                              format;
+//        VK_CHANNEL_MAPPING                     channels;
+//        VK_IMAGE_SUBRESOURCE_RANGE             subresourceRange;
 //        float                                   minLod;
-//    } XGL_IMAGE_VIEW_CREATE_INFO;
-    XGL_IMAGE_VIEW_CREATE_INFO viewInfo = {};
-    XGL_IMAGE_VIEW view;
-    viewInfo.sType = XGL_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
+//    } VK_IMAGE_VIEW_CREATE_INFO;
+    VK_IMAGE_VIEW_CREATE_INFO viewInfo = {};
+    VK_IMAGE_VIEW view;
+    viewInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
     viewInfo.image = image;
-    viewInfo.viewType = XGL_IMAGE_VIEW_2D;
+    viewInfo.viewType = VK_IMAGE_VIEW_2D;
     viewInfo.format = fmt;
 
-    viewInfo.channels.r = XGL_CHANNEL_SWIZZLE_R;
-    viewInfo.channels.g = XGL_CHANNEL_SWIZZLE_G;
-    viewInfo.channels.b = XGL_CHANNEL_SWIZZLE_B;
-    viewInfo.channels.a = XGL_CHANNEL_SWIZZLE_A;
+    viewInfo.channels.r = VK_CHANNEL_SWIZZLE_R;
+    viewInfo.channels.g = VK_CHANNEL_SWIZZLE_G;
+    viewInfo.channels.b = VK_CHANNEL_SWIZZLE_B;
+    viewInfo.channels.a = VK_CHANNEL_SWIZZLE_A;
 
     viewInfo.subresourceRange.baseArraySlice = 0;
     viewInfo.subresourceRange.arraySize = 1;
     viewInfo.subresourceRange.baseMipLevel = 0;
     viewInfo.subresourceRange.mipLevels = 1;
-    viewInfo.subresourceRange.aspect = XGL_IMAGE_ASPECT_COLOR;
+    viewInfo.subresourceRange.aspect = VK_IMAGE_ASPECT_COLOR;
 
-//    XGL_RESULT XGLAPI xglCreateImageView(
-//        XGL_DEVICE                                  device,
-//        const XGL_IMAGE_VIEW_CREATE_INFO*           pCreateInfo,
-//        XGL_IMAGE_VIEW*                             pView);
+//    VK_RESULT VKAPI vkCreateImageView(
+//        VK_DEVICE                                  device,
+//        const VK_IMAGE_VIEW_CREATE_INFO*           pCreateInfo,
+//        VK_IMAGE_VIEW*                             pView);
 
-    err = xglCreateImageView(device(), &viewInfo, &view);
-    ASSERT_XGL_SUCCESS(err) << "xglCreateImageView failed";
+    err = vkCreateImageView(device(), &viewInfo, &view);
+    ASSERT_VK_SUCCESS(err) << "vkCreateImageView failed";
 
     // TODO: Test image memory.
 
     // All done with image memory, clean up
-    ASSERT_XGL_SUCCESS(xglBindObjectMemory(image, 0, XGL_NULL_HANDLE, 0));
+    ASSERT_VK_SUCCESS(vkBindObjectMemory(image, 0, VK_NULL_HANDLE, 0));
 
-    ASSERT_XGL_SUCCESS(xglFreeMemory(image_mem));
+    ASSERT_VK_SUCCESS(vkFreeMemory(image_mem));
 
-    ASSERT_XGL_SUCCESS(xglDestroyObject(image));
+    ASSERT_VK_SUCCESS(vkDestroyObject(image));
 }
 
 TEST_F(XglTest, CreateImage) {
@@ -731,36 +731,36 @@
 
 void XglTest::CreateCommandBufferTest()
 {
-    XGL_RESULT err;
-    XGL_CMD_BUFFER_CREATE_INFO info = {};
-    XGL_CMD_BUFFER cmdBuffer;
+    VK_RESULT err;
+    VK_CMD_BUFFER_CREATE_INFO info = {};
+    VK_CMD_BUFFER cmdBuffer;
 
-//    typedef struct _XGL_CMD_BUFFER_CREATE_INFO
+//    typedef struct _VK_CMD_BUFFER_CREATE_INFO
 //    {
-//        XGL_STRUCTURE_TYPE                      sType;      // Must be XGL_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO
+//        VK_STRUCTURE_TYPE                      sType;      // Must be VK_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO
 //        const void*                             pNext;
-//        XGL_QUEUE_TYPE                          queueType;
-//        XGL_FLAGS                               flags;
-//    } XGL_CMD_BUFFER_CREATE_INFO;
+//        VK_QUEUE_TYPE                          queueType;
+//        VK_FLAGS                               flags;
+//    } VK_CMD_BUFFER_CREATE_INFO;
 
-    info.sType = XGL_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO;
+    info.sType = VK_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO;
     info.queueNodeIndex = graphics_queue_node_index;
-    err = xglCreateCommandBuffer(device(), &info, &cmdBuffer);
-    ASSERT_XGL_SUCCESS(err) << "xglCreateCommandBuffer failed";
+    err = vkCreateCommandBuffer(device(), &info, &cmdBuffer);
+    ASSERT_VK_SUCCESS(err) << "vkCreateCommandBuffer failed";
 
-    ASSERT_XGL_SUCCESS(xglDestroyObject(cmdBuffer));
+    ASSERT_VK_SUCCESS(vkDestroyObject(cmdBuffer));
 }
 
 TEST_F(XglTest, TestComandBuffer) {
     CreateCommandBufferTest();
 }
 
-void XglTest::CreateShader(XGL_SHADER *pshader)
+void XglTest::CreateShader(VK_SHADER *pshader)
 {
     void *code;
     uint32_t codeSize;
     struct icd_spv_header *pSPV;
-    XGL_RESULT err;
+    VK_RESULT err;
 
     codeSize = sizeof(struct icd_spv_header) + 100;
     code = malloc(codeSize);
@@ -773,31 +773,31 @@
     pSPV->magic = ICD_SPV_MAGIC;
     pSPV->version = ICD_SPV_VERSION;
 
-//    typedef struct _XGL_SHADER_CREATE_INFO
+//    typedef struct _VK_SHADER_CREATE_INFO
 //    {
-//        XGL_STRUCTURE_TYPE                      sType;              // Must be XGL_STRUCTURE_TYPE_SHADER_CREATE_INFO
+//        VK_STRUCTURE_TYPE                      sType;              // Must be VK_STRUCTURE_TYPE_SHADER_CREATE_INFO
 //        const void*                             pNext;              // Pointer to next structure
 //        size_t                                  codeSize;           // Specified in bytes
 //        const void*                             pCode;
-//        XGL_FLAGS                               flags;              // Reserved
-//    } XGL_SHADER_CREATE_INFO;
+//        VK_FLAGS                               flags;              // Reserved
+//    } VK_SHADER_CREATE_INFO;
 
-    XGL_SHADER_CREATE_INFO createInfo;
-    XGL_SHADER shader;
+    VK_SHADER_CREATE_INFO createInfo;
+    VK_SHADER shader;
 
-    createInfo.sType = XGL_STRUCTURE_TYPE_SHADER_CREATE_INFO;
+    createInfo.sType = VK_STRUCTURE_TYPE_SHADER_CREATE_INFO;
     createInfo.pNext = NULL;
     createInfo.pCode = code;
     createInfo.codeSize = codeSize;
     createInfo.flags = 0;
-    err = xglCreateShader(device(), &createInfo, &shader);
-    ASSERT_XGL_SUCCESS(err);
+    err = vkCreateShader(device(), &createInfo, &shader);
+    ASSERT_VK_SUCCESS(err);
 
     *pshader = shader;
 }
 
 int main(int argc, char **argv) {
     ::testing::InitGoogleTest(&argc, argv);
-    xgl_testing::set_error_callback(test_error_callback);
+    vk_testing::set_error_callback(test_error_callback);
     return RUN_ALL_TESTS();
 }
diff --git a/tests/layer_test_suite.py b/tests/layer_test_suite.py
index 25e46b5..7a1e678 100755
--- a/tests/layer_test_suite.py
+++ b/tests/layer_test_suite.py
@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 #
-# XGL
+# VK
 #
 # Copyright (C) 2014 LunarG, Inc.
 #
@@ -49,7 +49,7 @@
                                                                           '{OBJTRACK}ERROR : OBJ ERROR : GPU_MEMORY',
                                                                           '{OBJTRACK}ERROR : OBJ ERROR : IMAGE'],
                    'XglTest.Fence' : ['{OBJTRACK}ERROR : OBJECT VALIDATION WARNING: FENCE'],
-                   #'XglRenderTest.XGLTriangle_OutputLocation' : ['{OBJTRACK}ERROR : xglQueueSubmit Memory reference count'],
+                   #'XglRenderTest.VKTriangle_OutputLocation' : ['{OBJTRACK}ERROR : vkQueueSubmit Memory reference count'],
                    'XglRenderTest.TriangleWithVertexFetch' : ['{OBJTRACK}ERROR : OBJ ERROR : CMD_BUFFER'],
                    'XglRenderTest.TriangleMRT' : ['{OBJTRACK}ERROR : OBJ ERROR : CMD_BUFFER'],
                    'XglRenderTest.QuadWithIndexedVertexFetch' : ['{OBJTRACK}ERROR : OBJ ERROR : CMD_BUFFER', '{OBJTRACK}ERROR : OBJ ERROR : CMD_BUFFER'],
diff --git a/tests/layer_validation_tests.cpp b/tests/layer_validation_tests.cpp
index 3915b25..21292a0 100644
--- a/tests/layer_validation_tests.cpp
+++ b/tests/layer_validation_tests.cpp
@@ -1,12 +1,12 @@
-#include <xgl.h>
-#include <xglDbg.h>
+#include <vulkan.h>
+#include <vkDbg.h>
 #include "gtest-1.7.0/include/gtest/gtest.h"
-#include "xglrenderframework.h"
+#include "vkrenderframework.h"
 
-void XGLAPI myDbgFunc(
-    XGL_DBG_MSG_TYPE     msgType,
-    XGL_VALIDATION_LEVEL validationLevel,
-    XGL_BASE_OBJECT      srcObject,
+void VKAPI myDbgFunc(
+    VK_DBG_MSG_TYPE     msgType,
+    VK_VALIDATION_LEVEL validationLevel,
+    VK_BASE_OBJECT      srcObject,
     size_t               location,
     int32_t              msgCode,
     const char*          pMsg,
@@ -14,36 +14,36 @@
 
 class ErrorMonitor {
 public:
-    ErrorMonitor(XGL_INSTANCE inst)
+    ErrorMonitor(VK_INSTANCE inst)
     {
-        xglDbgRegisterMsgCallback(inst, myDbgFunc, this);
-        m_msgType = XGL_DBG_MSG_UNKNOWN;
+        vkDbgRegisterMsgCallback(inst, myDbgFunc, this);
+        m_msgType = VK_DBG_MSG_UNKNOWN;
     }
     void ClearState()
     {
-        m_msgType = XGL_DBG_MSG_UNKNOWN;
+        m_msgType = VK_DBG_MSG_UNKNOWN;
         m_msgString.clear();
     }
-    XGL_DBG_MSG_TYPE GetState(std::string *msgString)
+    VK_DBG_MSG_TYPE GetState(std::string *msgString)
     {
         *msgString = m_msgString;
         return m_msgType;
     }
-    void SetState(XGL_DBG_MSG_TYPE msgType, const char *msgString)
+    void SetState(VK_DBG_MSG_TYPE msgType, const char *msgString)
     {
         m_msgType = msgType;
         m_msgString = *msgString;
     }
 
 private:
-    XGL_DBG_MSG_TYPE        m_msgType;
+    VK_DBG_MSG_TYPE        m_msgType;
     std::string             m_msgString;
 
 };
-void XGLAPI myDbgFunc(
-    XGL_DBG_MSG_TYPE     msgType,
-    XGL_VALIDATION_LEVEL validationLevel,
-    XGL_BASE_OBJECT      srcObject,
+void VKAPI myDbgFunc(
+    VK_DBG_MSG_TYPE     msgType,
+    VK_VALIDATION_LEVEL validationLevel,
+    VK_BASE_OBJECT      srcObject,
     size_t               location,
     int32_t              msgCode,
     const char*          pMsg,
@@ -55,8 +55,8 @@
 class XglLayerTest : public XglRenderFramework
 {
 public:
-    XGL_RESULT BeginCommandBuffer(XglCommandBufferObj &cmdBuffer);
-    XGL_RESULT EndCommandBuffer(XglCommandBufferObj &cmdBuffer);
+    VK_RESULT BeginCommandBuffer(XglCommandBufferObj &cmdBuffer);
+    VK_RESULT EndCommandBuffer(XglCommandBufferObj &cmdBuffer);
 
 protected:
         XglMemoryRefManager         m_memoryRefManager;
@@ -64,13 +64,13 @@
 
     virtual void SetUp() {
 
-        this->app_info.sType = XGL_STRUCTURE_TYPE_APPLICATION_INFO;
+        this->app_info.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
         this->app_info.pNext = NULL;
         this->app_info.pAppName = "layer_tests";
         this->app_info.appVersion = 1;
         this->app_info.pEngineName = "unittest";
         this->app_info.engineVersion = 1;
-        this->app_info.apiVersion = XGL_API_VERSION;
+        this->app_info.apiVersion = VK_API_VERSION;
 
         InitFramework();
         m_errorMonitor = new ErrorMonitor(inst);
@@ -82,9 +82,9 @@
         ShutdownFramework();
     }
 };
-XGL_RESULT XglLayerTest::BeginCommandBuffer(XglCommandBufferObj &cmdBuffer)
+VK_RESULT XglLayerTest::BeginCommandBuffer(XglCommandBufferObj &cmdBuffer)
 {
-    XGL_RESULT result;
+    VK_RESULT result;
 
     result = cmdBuffer.BeginCommandBuffer();
 
@@ -92,16 +92,16 @@
      * For render test all drawing happens in a single render pass
      * on a single command buffer.
      */
-    if (XGL_SUCCESS == result) {
+    if (VK_SUCCESS == result) {
         cmdBuffer.BeginRenderPass(renderPass(), framebuffer());
     }
 
     return result;
 }
 
-XGL_RESULT XglLayerTest::EndCommandBuffer(XglCommandBufferObj &cmdBuffer)
+VK_RESULT XglLayerTest::EndCommandBuffer(XglCommandBufferObj &cmdBuffer)
 {
-    XGL_RESULT result;
+    VK_RESULT result;
 
     cmdBuffer.EndRenderPass(renderPass());
 
@@ -112,13 +112,13 @@
 
 TEST_F(XglLayerTest, UseSignaledFence)
 {
-    xgl_testing::Fence testFence;
-    XGL_DBG_MSG_TYPE msgType;
+    vk_testing::Fence testFence;
+    VK_DBG_MSG_TYPE msgType;
     std::string msgString;
-    const XGL_FENCE_CREATE_INFO fenceInfo = {
-        .sType = XGL_STRUCTURE_TYPE_FENCE_CREATE_INFO,
+    const VK_FENCE_CREATE_INFO fenceInfo = {
+        .sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,
         .pNext = NULL,
-        .flags = XGL_FENCE_CREATE_SIGNALED_BIT,
+        .flags = VK_FENCE_CREATE_SIGNALED_BIT,
     };
 
     // Register error callback to catch errors and record parameters
diff --git a/tests/render_tests.cpp b/tests/render_tests.cpp
index f50520a..882f14f 100644
--- a/tests/render_tests.cpp
+++ b/tests/render_tests.cpp
@@ -28,7 +28,7 @@
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 
-//  XGL tests
+//  VK tests
 //
 //  Copyright (C) 2014 LunarG, Inc.
 //
@@ -60,7 +60,7 @@
 #include <fstream>
 using namespace std;
 
-#include <xgl.h>
+#include <vulkan.h>
 #ifdef DUMP_STATE_DOT
 #include "../layers/draw_state.h"
 #endif
@@ -68,7 +68,7 @@
 #include "../layers/object_track.h"
 #endif
 #ifdef DEBUG_CALLBACK
-#include <xglDbg.h>
+#include <vkDbg.h>
 #endif
 #include "gtest-1.7.0/include/gtest/gtest.h"
 
@@ -78,12 +78,12 @@
 #include "glm/glm.hpp"
 #include <glm/gtc/matrix_transform.hpp>
 
-#include "xglrenderframework.h"
+#include "vkrenderframework.h"
 #ifdef DEBUG_CALLBACK
-void XGLAPI myDbgFunc(
-    XGL_DBG_MSG_TYPE     msgType,
-    XGL_VALIDATION_LEVEL validationLevel,
-    XGL_BASE_OBJECT      srcObject,
+void VKAPI myDbgFunc(
+    VK_DBG_MSG_TYPE     msgType,
+    VK_VALIDATION_LEVEL validationLevel,
+    VK_BASE_OBJECT      srcObject,
     size_t               location,
     int32_t              msgCode,
     const char*          pMsg,
@@ -91,10 +91,10 @@
 {
     switch (msgType)
     {
-        case XGL_DBG_MSG_WARNING:
+        case VK_DBG_MSG_WARNING:
             printf("CALLBACK WARNING : %s\n", pMsg);
             break;
-        case XGL_DBG_MSG_ERROR:
+        case VK_DBG_MSG_ERROR:
             printf("CALLBACK ERROR : %s\n", pMsg);
             break;
         default:
@@ -217,32 +217,32 @@
                                  XglConstantBufferObj *constantBuffer, XglCommandBufferObj *cmdBuffer);
     void GenericDrawPreparation(XglCommandBufferObj *cmdBuffer, XglPipelineObj &pipelineobj, XglDescriptorSetObj &descriptorSet);
     void InitDepthStencil();
-    void XGLTriangleTest(const char *vertShaderText, const char *fragShaderText, const bool rotate);
+    void VKTriangleTest(const char *vertShaderText, const char *fragShaderText, const bool rotate);
 
-    XGL_RESULT BeginCommandBuffer(XglCommandBufferObj &cmdBuffer);
-    XGL_RESULT EndCommandBuffer(XglCommandBufferObj &cmdBuffer);
+    VK_RESULT BeginCommandBuffer(XglCommandBufferObj &cmdBuffer);
+    VK_RESULT EndCommandBuffer(XglCommandBufferObj &cmdBuffer);
 
 protected:
-    XGL_IMAGE m_texture;
-    XGL_IMAGE_VIEW m_textureView;
-    XGL_IMAGE_VIEW_ATTACH_INFO m_textureViewInfo;
-    XGL_GPU_MEMORY m_textureMem;
+    VK_IMAGE m_texture;
+    VK_IMAGE_VIEW m_textureView;
+    VK_IMAGE_VIEW_ATTACH_INFO m_textureViewInfo;
+    VK_GPU_MEMORY m_textureMem;
 
-    XGL_SAMPLER m_sampler;
+    VK_SAMPLER m_sampler;
 
 
     virtual void SetUp() {
 
-        this->app_info.sType = XGL_STRUCTURE_TYPE_APPLICATION_INFO;
+        this->app_info.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
         this->app_info.pNext = NULL;
         this->app_info.pAppName = "render_tests";
         this->app_info.appVersion = 1;
         this->app_info.pEngineName = "unittest";
         this->app_info.engineVersion = 1;
-        this->app_info.apiVersion = XGL_API_VERSION;
+        this->app_info.apiVersion = VK_API_VERSION;
 
         memset(&m_textureViewInfo, 0, sizeof(m_textureViewInfo));
-        m_textureViewInfo.sType = XGL_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO;
+        m_textureViewInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO;
 
         InitFramework();
     }
@@ -253,9 +253,9 @@
     }
 };
 
-XGL_RESULT XglRenderTest::BeginCommandBuffer(XglCommandBufferObj &cmdBuffer)
+VK_RESULT XglRenderTest::BeginCommandBuffer(XglCommandBufferObj &cmdBuffer)
 {
-    XGL_RESULT result;
+    VK_RESULT result;
 
     result = cmdBuffer.BeginCommandBuffer();
 
@@ -263,16 +263,16 @@
      * For render test all drawing happens in a single render pass
      * on a single command buffer.
      */
-    if (XGL_SUCCESS == result) {
+    if (VK_SUCCESS == result) {
         cmdBuffer.BeginRenderPass(renderPass(), framebuffer());
     }
 
     return result;
 }
 
-XGL_RESULT XglRenderTest::EndCommandBuffer(XglCommandBufferObj &cmdBuffer)
+VK_RESULT XglRenderTest::EndCommandBuffer(XglCommandBufferObj &cmdBuffer)
 {
-    XGL_RESULT result;
+    VK_RESULT result;
 
     cmdBuffer.EndRenderPass(renderPass());
 
@@ -291,12 +291,12 @@
     }
 
     cmdBuffer->PrepareAttachments();
-    cmdBuffer->BindStateObject(XGL_STATE_BIND_RASTER, m_stateRaster);
-    cmdBuffer->BindStateObject(XGL_STATE_BIND_VIEWPORT, m_stateViewport);
-    cmdBuffer->BindStateObject(XGL_STATE_BIND_COLOR_BLEND, m_colorBlend);
-    cmdBuffer->BindStateObject(XGL_STATE_BIND_DEPTH_STENCIL, m_stateDepthStencil);
-    descriptorSet.CreateXGLDescriptorSet(cmdBuffer);
-    pipelineobj.CreateXGLPipeline(descriptorSet);
+    cmdBuffer->BindStateObject(VK_STATE_BIND_RASTER, m_stateRaster);
+    cmdBuffer->BindStateObject(VK_STATE_BIND_VIEWPORT, m_stateViewport);
+    cmdBuffer->BindStateObject(VK_STATE_BIND_COLOR_BLEND, m_colorBlend);
+    cmdBuffer->BindStateObject(VK_STATE_BIND_DEPTH_STENCIL, m_stateDepthStencil);
+    descriptorSet.CreateVKDescriptorSet(cmdBuffer);
+    pipelineobj.CreateVKPipeline(descriptorSet);
     cmdBuffer->BindPipeline(pipelineobj);
     cmdBuffer->BindDescriptorSet(descriptorSet);
 }
@@ -307,7 +307,7 @@
     int i;
     glm::mat4 MVP;
     int matrixSize = sizeof(MVP);
-    XGL_RESULT err;
+    VK_RESULT err;
 
     for (i = 0; i < 8; i++) {
         void *pData = constantBuffer->map();
@@ -321,11 +321,11 @@
         // submit the command buffer to the universal queue
         cmdBuffer->QueueCommandBuffer();
 
-        err = xglQueueWaitIdle( m_device->m_queue );
-        ASSERT_XGL_SUCCESS( err );
+        err = vkQueueWaitIdle( m_device->m_queue );
+        ASSERT_VK_SUCCESS( err );
 
         // Wait for work to finish before cleaning up.
-        xglDeviceWaitIdle(m_device->device());
+        vkDeviceWaitIdle(m_device->device());
 
         assert(m_renderTargets.size() == 1);
         RecordImage(m_renderTargets[0]);
@@ -352,28 +352,28 @@
     fflush(stdout);
 }
 
-struct xgltriangle_vs_uniform {
+struct vktriangle_vs_uniform {
     // Must start with MVP
     float   mvp[4][4];
     float   position[3][4];
     float   color[3][4];
 };
 
-void XglRenderTest::XGLTriangleTest(const char *vertShaderText, const char *fragShaderText, const bool rotate)
+void XglRenderTest::VKTriangleTest(const char *vertShaderText, const char *fragShaderText, const bool rotate)
 {
 #ifdef DEBUG_CALLBACK
-    xglDbgRegisterMsgCallback(inst, myDbgFunc, NULL);
+    vkDbgRegisterMsgCallback(inst, myDbgFunc, NULL);
 #endif
     // Create identity matrix
     int i;
-    struct xgltriangle_vs_uniform data;
+    struct vktriangle_vs_uniform data;
 
     glm::mat4 Projection      = glm::mat4(1.0f);
     glm::mat4 View      = glm::mat4(1.0f);
     glm::mat4 Model      = glm::mat4(1.0f);
     glm::mat4 MVP = Projection * View * Model;
     const int matrixSize = sizeof(MVP);
-    const int bufSize = sizeof(xgltriangle_vs_uniform) / sizeof(float);
+    const int bufSize = sizeof(vktriangle_vs_uniform) / sizeof(float);
     memcpy(&data.mvp, &MVP[0][0], matrixSize);
 
     static const Vertex tri_data[] =
@@ -399,25 +399,25 @@
 
     XglConstantBufferObj constantBuffer(m_device, bufSize*2, sizeof(float), (const void*) &data);
 
-    XglShaderObj vs(m_device,vertShaderText,XGL_SHADER_STAGE_VERTEX, this);
-    XglShaderObj ps(m_device,fragShaderText, XGL_SHADER_STAGE_FRAGMENT, this);
+    XglShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX, this);
+    XglShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT, this);
 
     XglPipelineObj pipelineobj(m_device);
     pipelineobj.AddShader(&vs);
     pipelineobj.AddShader(&ps);
 
     XglDescriptorSetObj descriptorSet(m_device);
-    descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, constantBuffer);
+    descriptorSet.AppendBuffer(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, constantBuffer);
 
     ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
     XglCommandBufferObj cmdBuffer(m_device);
     cmdBuffer.AddRenderTarget(m_renderTargets[0]);
 
-    ASSERT_XGL_SUCCESS(BeginCommandBuffer(cmdBuffer));
+    ASSERT_VK_SUCCESS(BeginCommandBuffer(cmdBuffer));
 
     GenericDrawPreparation(&cmdBuffer, pipelineobj, descriptorSet);
 #ifdef DUMP_STATE_DOT
-    DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)xglGetProcAddr(gpu(), (char*)"drawStateDumpDotFile");
+    DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)vkGetProcAddr(gpu(), (char*)"drawStateDumpDotFile");
     pDSDumpDot((char*)"triTest2.dot");
 #endif
 
@@ -435,23 +435,23 @@
         RotateTriangleVSUniform(Projection, View, Model, &constantBuffer, &cmdBuffer);
 
 #ifdef PRINT_OBJECTS
-    //uint64_t objTrackGetObjectCount(XGL_OBJECT_TYPE type)
-    OBJ_TRACK_GET_OBJECT_COUNT pObjTrackGetObjectCount = (OBJ_TRACK_GET_OBJECT_COUNT)xglGetProcAddr(gpu(), (char*)"objTrackGetObjectCount");
-    uint64_t numObjects = pObjTrackGetObjectCount(XGL_OBJECT_TYPE_ANY);
-    //OBJ_TRACK_GET_OBJECTS pGetObjsFunc = xglGetProcAddr(gpu(), (char*)"objTrackGetObjects");
+    //uint64_t objTrackGetObjectCount(VK_OBJECT_TYPE type)
+    OBJ_TRACK_GET_OBJECT_COUNT pObjTrackGetObjectCount = (OBJ_TRACK_GET_OBJECT_COUNT)vkGetProcAddr(gpu(), (char*)"objTrackGetObjectCount");
+    uint64_t numObjects = pObjTrackGetObjectCount(VK_OBJECT_TYPE_ANY);
+    //OBJ_TRACK_GET_OBJECTS pGetObjsFunc = vkGetProcAddr(gpu(), (char*)"objTrackGetObjects");
     printf("DEBUG : Number of Objects : %lu\n", numObjects);
-    OBJ_TRACK_GET_OBJECTS pObjTrackGetObjs = (OBJ_TRACK_GET_OBJECTS)xglGetProcAddr(gpu(), (char*)"objTrackGetObjects");
+    OBJ_TRACK_GET_OBJECTS pObjTrackGetObjs = (OBJ_TRACK_GET_OBJECTS)vkGetProcAddr(gpu(), (char*)"objTrackGetObjects");
     OBJTRACK_NODE* pObjNodeArray = (OBJTRACK_NODE*)malloc(sizeof(OBJTRACK_NODE)*numObjects);
-    pObjTrackGetObjs(XGL_OBJECT_TYPE_ANY, numObjects, pObjNodeArray);
+    pObjTrackGetObjs(VK_OBJECT_TYPE_ANY, numObjects, pObjNodeArray);
     for (i=0; i < numObjects; i++) {
-        printf("Object %i of type %s has objID (%p) and %lu uses\n", i, string_XGL_OBJECT_TYPE(pObjNodeArray[i].objType), pObjNodeArray[i].pObj, pObjNodeArray[i].numUses);
+        printf("Object %i of type %s has objID (%p) and %lu uses\n", i, string_VK_OBJECT_TYPE(pObjNodeArray[i].objType), pObjNodeArray[i].pObj, pObjNodeArray[i].numUses);
     }
     free(pObjNodeArray);
 #endif
 
 }
 
-TEST_F(XglRenderTest, XGLTriangle_FragColor)
+TEST_F(XglRenderTest, VKTriangle_FragColor)
 {
     static const char *vertShaderText =
         "#version 140\n"
@@ -484,11 +484,11 @@
         "   gl_FragColor = inColor;\n"
         "}\n";
 
-    TEST_DESCRIPTION("XGL-style shaders where fragment shader outputs to GLSL built-in gl_FragColor");
-    XGLTriangleTest(vertShaderText, fragShaderText, true);
+    TEST_DESCRIPTION("VK-style shaders where fragment shader outputs to GLSL built-in gl_FragColor");
+    VKTriangleTest(vertShaderText, fragShaderText, true);
 }
 
-TEST_F(XglRenderTest, XGLTriangle_OutputLocation)
+TEST_F(XglRenderTest, VKTriangle_OutputLocation)
 {
     static const char *vertShaderText =
         "#version 140\n"
@@ -522,12 +522,12 @@
         "   outColor = inColor;\n"
         "}\n";
 
-    TEST_DESCRIPTION("XGL-style shaders where fragment shader outputs to output location 0, which should be the same as gl_FragColor");
+    TEST_DESCRIPTION("VK-style shaders where fragment shader outputs to output location 0, which should be the same as gl_FragColor");
 
-    XGLTriangleTest(vertShaderText, fragShaderText, true);
+    VKTriangleTest(vertShaderText, fragShaderText, true);
 }
 #ifndef _WIN32 // Implicit (for now at least) in WIN32 is that we are using the Nvidia driver and it won't consume SPIRV yet
-TEST_F(XglRenderTest, SPV_XGLTriangle)
+TEST_F(XglRenderTest, SPV_VKTriangle)
 {
     bool saved_use_spv = XglTestFramework::m_use_spv;
 
@@ -562,11 +562,11 @@
         "   gl_FragColor = inColor;\n"
         "}\n";
 
-    TEST_DESCRIPTION("XGL-style shaders, but force test framework to compile shader to SPV and pass SPV to driver.");
+    TEST_DESCRIPTION("VK-style shaders, but force test framework to compile shader to SPV and pass SPV to driver.");
 
     XglTestFramework::m_use_spv = true;
 
-    XGLTriangleTest(vertShaderText, fragShaderText, true);
+    VKTriangleTest(vertShaderText, fragShaderText, true);
 
     XglTestFramework::m_use_spv = saved_use_spv;
 }
@@ -591,7 +591,7 @@
 
     TEST_DESCRIPTION("Basic shader that renders a fixed Green triangle coded as part of the vertex shader.");
 
-    XGLTriangleTest(vertShaderText, fragShaderText, false);
+    VKTriangleTest(vertShaderText, fragShaderText, false);
 }
 #ifndef _WIN32 // Implicit (for now at least) in WIN32 is that we are using the Nvidia driver and it won't consume SPIRV yet
 TEST_F(XglRenderTest, SPV_GreenTriangle)
@@ -617,7 +617,7 @@
     TEST_DESCRIPTION("Same shader as GreenTriangle, but compiles shader to SPV and gives SPV to driver.");
 
     XglTestFramework::m_use_spv = true;
-    XGLTriangleTest(vertShaderText, fragShaderText, false);
+    VKTriangleTest(vertShaderText, fragShaderText, false);
     XglTestFramework::m_use_spv = saved_use_spv;
 }
 #endif
@@ -643,7 +643,7 @@
             "  gl_FragColor = vec4(1.0, 1.0, 0.0, 1.0);\n"
             "}\n";
 
-    XGLTriangleTest(vertShaderText, fragShaderText, false);
+    VKTriangleTest(vertShaderText, fragShaderText, false);
 }
 
 TEST_F(XglRenderTest, QuadWithVertexFetch)
@@ -681,31 +681,31 @@
     XglConstantBufferObj meshBuffer(m_device,sizeof(g_vbData)/sizeof(g_vbData[0]),sizeof(g_vbData[0]), g_vbData);
     meshBuffer.BufferMemoryBarrier();
 
-    XglShaderObj vs(m_device,vertShaderText,XGL_SHADER_STAGE_VERTEX, this);
-    XglShaderObj ps(m_device,fragShaderText, XGL_SHADER_STAGE_FRAGMENT, this);
+    XglShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX, this);
+    XglShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT, this);
 
     XglPipelineObj pipelineobj(m_device);
     pipelineobj.AddShader(&vs);
     pipelineobj.AddShader(&ps);
 
     XglDescriptorSetObj descriptorSet(m_device);
-    descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, meshBuffer);
+    descriptorSet.AppendBuffer(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, meshBuffer);
 
 #define MESH_BIND_ID 0
-    XGL_VERTEX_INPUT_BINDING_DESCRIPTION vi_binding = {
+    VK_VERTEX_INPUT_BINDING_DESCRIPTION vi_binding = {
         MESH_BIND_ID,                      // binding ID
          sizeof(g_vbData[0]),              // strideInBytes;  Distance between vertices in bytes (0 = no advancement)
-         XGL_VERTEX_INPUT_STEP_RATE_VERTEX // stepRate;       // Rate at which binding is incremented
+         VK_VERTEX_INPUT_STEP_RATE_VERTEX // stepRate;       // Rate at which binding is incremented
     };
 
-    XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION vi_attribs[2];
+    VK_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION vi_attribs[2];
     vi_attribs[0].binding = MESH_BIND_ID;               // Binding ID
     vi_attribs[0].location = 0;                         // location, position
-    vi_attribs[0].format = XGL_FMT_R32G32B32A32_SFLOAT; // format of source data
+    vi_attribs[0].format = VK_FMT_R32G32B32A32_SFLOAT; // format of source data
     vi_attribs[0].offsetInBytes = 0;                    // Offset of first element in bytes from base of vertex
     vi_attribs[1].binding = MESH_BIND_ID;               // Binding ID
     vi_attribs[1].location = 1;                         // location, color
-    vi_attribs[1].format = XGL_FMT_R32G32B32A32_SFLOAT; // format of source data
+    vi_attribs[1].format = VK_FMT_R32G32B32A32_SFLOAT; // format of source data
     vi_attribs[1].offsetInBytes = 1*sizeof(float)*4;     // Offset of first element in bytes from base of vertex
 
     pipelineobj.AddVertexInputAttribs(vi_attribs,2);
@@ -716,7 +716,7 @@
     XglCommandBufferObj cmdBuffer(m_device);
     cmdBuffer.AddRenderTarget(m_renderTargets[0]);
 
-    ASSERT_XGL_SUCCESS(BeginCommandBuffer(cmdBuffer));
+    ASSERT_VK_SUCCESS(BeginCommandBuffer(cmdBuffer));
 
     GenericDrawPreparation(&cmdBuffer, pipelineobj, descriptorSet);
 
@@ -762,24 +762,24 @@
     XglConstantBufferObj meshBuffer(m_device, sizeof(vb_data) / sizeof(vb_data[0]), sizeof(vb_data[0]), vb_data);
     meshBuffer.BufferMemoryBarrier();
 
-    XglShaderObj vs(m_device,vertShaderText,XGL_SHADER_STAGE_VERTEX, this);
-    XglShaderObj ps(m_device,fragShaderText, XGL_SHADER_STAGE_FRAGMENT, this);
+    XglShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX, this);
+    XglShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT, this);
 
     XglPipelineObj pipelineobj(m_device);
     pipelineobj.AddShader(&vs);
     pipelineobj.AddShader(&ps);
 
 #define MESH_BUF_ID 0
-    XGL_VERTEX_INPUT_BINDING_DESCRIPTION vi_binding = {
+    VK_VERTEX_INPUT_BINDING_DESCRIPTION vi_binding = {
         MESH_BUF_ID,                            // Binding ID
         sizeof(vb_data[0]),                     // strideInBytes;  Distance between vertices in bytes (0 = no advancement)
-        XGL_VERTEX_INPUT_STEP_RATE_VERTEX       // stepRate;       // Rate at which binding is incremented
+        VK_VERTEX_INPUT_STEP_RATE_VERTEX       // stepRate;       // Rate at which binding is incremented
     };
 
-    XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION vi_attrib;
+    VK_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION vi_attrib;
     vi_attrib.binding = MESH_BUF_ID;            // index into vertexBindingDescriptions
     vi_attrib.location = 0;
-    vi_attrib.format = XGL_FMT_R32G32_SFLOAT;   // format of source data
+    vi_attrib.format = VK_FMT_R32G32_SFLOAT;   // format of source data
     vi_attrib.offsetInBytes = 0;                // Offset of first element in bytes from base of vertex
 
     pipelineobj.AddVertexInputAttribs(&vi_attrib, 1);
@@ -787,12 +787,12 @@
     pipelineobj.AddVertexDataBuffer(&meshBuffer, MESH_BUF_ID);
 
     XglDescriptorSetObj descriptorSet(m_device);
-    descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, meshBuffer);
+    descriptorSet.AppendBuffer(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, meshBuffer);
 
     ASSERT_NO_FATAL_FAILURE(InitRenderTarget(2));
 
-    XGL_PIPELINE_CB_ATTACHMENT_STATE att = {};
-    att.blendEnable = XGL_FALSE;
+    VK_PIPELINE_CB_ATTACHMENT_STATE att = {};
+    att.blendEnable = VK_FALSE;
     att.format = m_render_target_fmt;
     att.channelWriteMask = 0xf;
     pipelineobj.AddColorAttachment(1, &att);
@@ -802,13 +802,13 @@
     cmdBuffer.AddRenderTarget(m_renderTargets[0]);
     cmdBuffer.AddRenderTarget(m_renderTargets[1]);
 
-    ASSERT_XGL_SUCCESS(BeginCommandBuffer(cmdBuffer));
+    ASSERT_VK_SUCCESS(BeginCommandBuffer(cmdBuffer));
 
     GenericDrawPreparation(&cmdBuffer, pipelineobj, descriptorSet);
 
     cmdBuffer.BindVertexBuffer(&meshBuffer, 0, 0);
 #ifdef DUMP_STATE_DOT
-    DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)xglGetProcAddr(gpu(), (char*)"drawStateDumpDotFile");
+    DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)vkGetProcAddr(gpu(), (char*)"drawStateDumpDotFile");
     pDSDumpDot((char*)"triTest2.dot");
 #endif
 
@@ -871,36 +871,36 @@
     meshBuffer.BufferMemoryBarrier();
 
     XglIndexBufferObj indexBuffer(m_device);
-    indexBuffer.CreateAndInitBuffer(sizeof(g_idxData)/sizeof(g_idxData[0]), XGL_INDEX_16, g_idxData);
+    indexBuffer.CreateAndInitBuffer(sizeof(g_idxData)/sizeof(g_idxData[0]), VK_INDEX_16, g_idxData);
     indexBuffer.BufferMemoryBarrier();
 
-    XglShaderObj vs(m_device,vertShaderText,XGL_SHADER_STAGE_VERTEX, this);
-    XglShaderObj ps(m_device,fragShaderText, XGL_SHADER_STAGE_FRAGMENT, this);
+    XglShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX, this);
+    XglShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT, this);
 
     XglPipelineObj pipelineobj(m_device);
     pipelineobj.AddShader(&vs);
     pipelineobj.AddShader(&ps);
 
     XglDescriptorSetObj descriptorSet(m_device);
-    descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, meshBuffer);
-    descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, indexBuffer);
+    descriptorSet.AppendBuffer(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, meshBuffer);
+    descriptorSet.AppendBuffer(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, indexBuffer);
 
 
 #define MESH_BIND_ID 0
-    XGL_VERTEX_INPUT_BINDING_DESCRIPTION vi_binding = {
+    VK_VERTEX_INPUT_BINDING_DESCRIPTION vi_binding = {
         MESH_BIND_ID,                           // binding ID
         sizeof(g_vbData[0]),                    // strideInBytes;  Distance between vertices in bytes (0 = no advancement)
-        XGL_VERTEX_INPUT_STEP_RATE_VERTEX       // stepRate;       // Rate at which binding is incremented
+        VK_VERTEX_INPUT_STEP_RATE_VERTEX       // stepRate;       // Rate at which binding is incremented
     };
 
-    XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION vi_attribs[2];
+    VK_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION vi_attribs[2];
     vi_attribs[0].binding = MESH_BIND_ID;               // binding ID from BINDING_DESCRIPTION array to use for this attribute
     vi_attribs[0].location = 0;                         // layout location of vertex attribute
-    vi_attribs[0].format = XGL_FMT_R32G32B32A32_SFLOAT; // format of source data
+    vi_attribs[0].format = VK_FMT_R32G32B32A32_SFLOAT; // format of source data
     vi_attribs[0].offsetInBytes = 0;                    // Offset of first element in bytes from base of vertex
     vi_attribs[1].binding = MESH_BIND_ID;               // binding ID from BINDING_DESCRIPTION array to use for this attribute
     vi_attribs[1].location = 1;                         // layout location of vertex attribute
-    vi_attribs[1].format = XGL_FMT_R32G32B32A32_SFLOAT; // format of source data
+    vi_attribs[1].format = VK_FMT_R32G32B32A32_SFLOAT; // format of source data
     vi_attribs[1].offsetInBytes = 16;                   // Offset of first element in bytes from base of vertex
 
     pipelineobj.AddVertexInputAttribs(vi_attribs,2);
@@ -909,12 +909,12 @@
     ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
     XglCommandBufferObj cmdBuffer(m_device);
     cmdBuffer.AddRenderTarget(m_renderTargets[0]);
-    ASSERT_XGL_SUCCESS(BeginCommandBuffer(cmdBuffer));
+    ASSERT_VK_SUCCESS(BeginCommandBuffer(cmdBuffer));
 
     GenericDrawPreparation(&cmdBuffer, pipelineobj, descriptorSet);
 
 #ifdef DUMP_STATE_DOT
-    DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)xglGetProcAddr(gpu(), (char*)"drawStateDumpDotFile");
+    DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)vkGetProcAddr(gpu(), (char*)"drawStateDumpDotFile");
     pDSDumpDot((char*)"triTest2.dot");
 #endif
 
@@ -970,27 +970,27 @@
     XglConstantBufferObj meshBuffer(m_device,sizeof(g_vbData)/sizeof(g_vbData[0]),sizeof(g_vbData[0]), g_vbData);
     meshBuffer.BufferMemoryBarrier();
 
-    XglShaderObj vs(m_device,vertShaderText,XGL_SHADER_STAGE_VERTEX, this);
-    XglShaderObj ps(m_device,fragShaderText, XGL_SHADER_STAGE_FRAGMENT, this);
+    XglShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX, this);
+    XglShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT, this);
 
     XglPipelineObj pipelineobj(m_device);
     pipelineobj.AddShader(&vs);
     pipelineobj.AddShader(&ps);
 
     XglDescriptorSetObj descriptorSet(m_device);
-    descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, meshBuffer);
+    descriptorSet.AppendBuffer(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, meshBuffer);
 
 #define MESH_BIND_ID 0
-    XGL_VERTEX_INPUT_BINDING_DESCRIPTION vi_binding = {
+    VK_VERTEX_INPUT_BINDING_DESCRIPTION vi_binding = {
         MESH_BIND_ID,                           // binding ID
         sizeof(g_vbData[0]),                    // strideInBytes;  Distance between vertices in bytes (0 = no advancement)
-        XGL_VERTEX_INPUT_STEP_RATE_VERTEX       // stepRate;       // Rate at which binding is incremented
+        VK_VERTEX_INPUT_STEP_RATE_VERTEX       // stepRate;       // Rate at which binding is incremented
     };
 
-    XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION vi_attribs[1];
+    VK_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION vi_attribs[1];
     vi_attribs[0].binding = MESH_BIND_ID;               // binding ID
     vi_attribs[0].location = 0;
-    vi_attribs[0].format = XGL_FMT_R32G32B32A32_SFLOAT; // format of source data
+    vi_attribs[0].format = VK_FMT_R32G32B32A32_SFLOAT; // format of source data
     vi_attribs[0].offsetInBytes = 0;                    // Offset of first element in bytes from base of vertex
 
     pipelineobj.AddVertexInputAttribs(vi_attribs,1);
@@ -1001,13 +1001,13 @@
     XglCommandBufferObj cmdBuffer(m_device);
     cmdBuffer.AddRenderTarget(m_renderTargets[0]);
 
-    ASSERT_XGL_SUCCESS(BeginCommandBuffer(cmdBuffer));
+    ASSERT_VK_SUCCESS(BeginCommandBuffer(cmdBuffer));
 
     GenericDrawPreparation(&cmdBuffer, pipelineobj, descriptorSet);
 
     cmdBuffer.BindVertexBuffer(&meshBuffer, 0, 0);
 #ifdef DUMP_STATE_DOT
-    DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)xglGetProcAddr(gpu(), (char*)"drawStateDumpDotFile");
+    DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)vkGetProcAddr(gpu(), (char*)"drawStateDumpDotFile");
     pDSDumpDot((char*)"triTest2.dot");
 #endif
 
@@ -1060,27 +1060,27 @@
     XglConstantBufferObj meshBuffer(m_device,sizeof(g_vbData)/sizeof(g_vbData[0]),sizeof(g_vbData[0]), g_vbData);
     meshBuffer.BufferMemoryBarrier();
 
-    XglShaderObj vs(m_device,vertShaderText,XGL_SHADER_STAGE_VERTEX, this);
-    XglShaderObj ps(m_device,fragShaderText, XGL_SHADER_STAGE_FRAGMENT, this);
+    XglShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX, this);
+    XglShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT, this);
 
     XglPipelineObj pipelineobj(m_device);
     pipelineobj.AddShader(&vs);
     pipelineobj.AddShader(&ps);
 
     XglDescriptorSetObj descriptorSet(m_device);
-    descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, meshBuffer);
+    descriptorSet.AppendBuffer(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, meshBuffer);
 
 #define MESH_BIND_ID 0
-    XGL_VERTEX_INPUT_BINDING_DESCRIPTION vi_binding = {
+    VK_VERTEX_INPUT_BINDING_DESCRIPTION vi_binding = {
         MESH_BIND_ID,                           // binding ID
         sizeof(g_vbData[0]),                    // strideInBytes;  Distance between vertices in bytes (0 = no advancement)
-        XGL_VERTEX_INPUT_STEP_RATE_VERTEX       // stepRate;       // Rate at which binding is incremented
+        VK_VERTEX_INPUT_STEP_RATE_VERTEX       // stepRate;       // Rate at which binding is incremented
     };
 
-    XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION vi_attribs[1];
+    VK_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION vi_attribs[1];
     vi_attribs[0].binding = MESH_BIND_ID;               // binding ID
     vi_attribs[0].location = 0;
-    vi_attribs[0].format = XGL_FMT_R32G32B32A32_SFLOAT; // format of source data
+    vi_attribs[0].format = VK_FMT_R32G32B32A32_SFLOAT; // format of source data
     vi_attribs[0].offsetInBytes = 0;                    // Offset of first element in bytes from base of vertex
 
     pipelineobj.AddVertexInputAttribs(vi_attribs,1);
@@ -1091,13 +1091,13 @@
     XglCommandBufferObj cmdBuffer(m_device);
     cmdBuffer.AddRenderTarget(m_renderTargets[0]);
 
-    ASSERT_XGL_SUCCESS(BeginCommandBuffer(cmdBuffer));
+    ASSERT_VK_SUCCESS(BeginCommandBuffer(cmdBuffer));
 
     GenericDrawPreparation(&cmdBuffer, pipelineobj, descriptorSet);
 
     cmdBuffer.BindVertexBuffer(&meshBuffer, 0, 0);
 #ifdef DUMP_STATE_DOT
-    DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)xglGetProcAddr(gpu(), (char*)"drawStateDumpDotFile");
+    DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)vkGetProcAddr(gpu(), (char*)"drawStateDumpDotFile");
     pDSDumpDot((char*)"triTest2.dot");
 #endif
     // render two triangles
@@ -1160,27 +1160,27 @@
     XglConstantBufferObj meshBuffer(m_device,sizeof(g_vbData)/sizeof(g_vbData[0]),sizeof(g_vbData[0]), g_vbData);
     meshBuffer.BufferMemoryBarrier();
 
-    XglShaderObj vs(m_device,vertShaderText,XGL_SHADER_STAGE_VERTEX, this);
-    XglShaderObj ps(m_device,fragShaderText, XGL_SHADER_STAGE_FRAGMENT, this);
+    XglShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX, this);
+    XglShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT, this);
 
     XglPipelineObj pipelineobj(m_device);
     pipelineobj.AddShader(&vs);
     pipelineobj.AddShader(&ps);
 
     XglDescriptorSetObj descriptorSet(m_device);
-    descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, meshBuffer);
+    descriptorSet.AppendBuffer(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, meshBuffer);
 
 #define MESH_BIND_ID 0
-    XGL_VERTEX_INPUT_BINDING_DESCRIPTION vi_binding = {
+    VK_VERTEX_INPUT_BINDING_DESCRIPTION vi_binding = {
         MESH_BIND_ID,                           // binding ID
         sizeof(g_vbData[0]),                    // strideInBytes;  Distance between vertices in bytes (0 = no advancement)
-        XGL_VERTEX_INPUT_STEP_RATE_VERTEX       // stepRate;       // Rate at which binding is incremented
+        VK_VERTEX_INPUT_STEP_RATE_VERTEX       // stepRate;       // Rate at which binding is incremented
     };
 
-    XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION vi_attribs[1];
+    VK_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION vi_attribs[1];
     vi_attribs[0].binding = MESH_BIND_ID;               // binding ID
     vi_attribs[0].location = 0;
-    vi_attribs[0].format = XGL_FMT_R32G32B32A32_SFLOAT; // format of source data
+    vi_attribs[0].format = VK_FMT_R32G32B32A32_SFLOAT; // format of source data
     vi_attribs[0].offsetInBytes = 0;                    // Offset of first element in bytes from base of vertex
 
     pipelineobj.AddVertexInputAttribs(vi_attribs,1);
@@ -1191,13 +1191,13 @@
     XglCommandBufferObj cmdBuffer(m_device);
     cmdBuffer.AddRenderTarget(m_renderTargets[0]);
 
-    ASSERT_XGL_SUCCESS(BeginCommandBuffer(cmdBuffer));
+    ASSERT_VK_SUCCESS(BeginCommandBuffer(cmdBuffer));
 
     GenericDrawPreparation(&cmdBuffer, pipelineobj, descriptorSet);
 
     cmdBuffer.BindVertexBuffer(&meshBuffer, 0, 0);
 #ifdef DUMP_STATE_DOT
-    DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)xglGetProcAddr(gpu(), (char*)"drawStateDumpDotFile");
+    DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)vkGetProcAddr(gpu(), (char*)"drawStateDumpDotFile");
     pDSDumpDot((char*)"triTest2.dot");
 #endif
 
@@ -1251,27 +1251,27 @@
     XglConstantBufferObj meshBuffer(m_device,sizeof(g_vbData)/sizeof(g_vbData[0]),sizeof(g_vbData[0]), g_vbData);
     meshBuffer.BufferMemoryBarrier();
 
-    XglShaderObj vs(m_device,vertShaderText,XGL_SHADER_STAGE_VERTEX, this);
-    XglShaderObj ps(m_device,fragShaderText, XGL_SHADER_STAGE_FRAGMENT, this);
+    XglShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX, this);
+    XglShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT, this);
 
     XglPipelineObj pipelineobj(m_device);
     pipelineobj.AddShader(&vs);
     pipelineobj.AddShader(&ps);
 
     XglDescriptorSetObj descriptorSet(m_device);
-    descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, meshBuffer);
+    descriptorSet.AppendBuffer(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, meshBuffer);
 
 #define MESH_BIND_ID 0
-    XGL_VERTEX_INPUT_BINDING_DESCRIPTION vi_binding = {
+    VK_VERTEX_INPUT_BINDING_DESCRIPTION vi_binding = {
         MESH_BIND_ID,                           // binding ID
         sizeof(g_vbData[0]),                    // strideInBytes;  Distance between vertices in bytes (0 = no advancement)
-        XGL_VERTEX_INPUT_STEP_RATE_VERTEX       // stepRate;       // Rate at which binding is incremented
+        VK_VERTEX_INPUT_STEP_RATE_VERTEX       // stepRate;       // Rate at which binding is incremented
     };
 
-    XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION vi_attribs[1];
+    VK_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION vi_attribs[1];
     vi_attribs[0].binding = MESH_BIND_ID;               // binding ID
     vi_attribs[0].location = 0;
-    vi_attribs[0].format = XGL_FMT_R32G32B32A32_SFLOAT; // format of source data
+    vi_attribs[0].format = VK_FMT_R32G32B32A32_SFLOAT; // format of source data
     vi_attribs[0].offsetInBytes = 0;                    // Offset of first element in bytes from base of vertex
 
     pipelineobj.AddVertexInputAttribs(vi_attribs,1);
@@ -1282,13 +1282,13 @@
     XglCommandBufferObj cmdBuffer(m_device);
     cmdBuffer.AddRenderTarget(m_renderTargets[0]);
 
-    ASSERT_XGL_SUCCESS(BeginCommandBuffer(cmdBuffer));
+    ASSERT_VK_SUCCESS(BeginCommandBuffer(cmdBuffer));
 
     GenericDrawPreparation(&cmdBuffer, pipelineobj, descriptorSet);
 
     cmdBuffer.BindVertexBuffer(&meshBuffer, 0, 0);
 #ifdef DUMP_STATE_DOT
-    DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)xglGetProcAddr(gpu(), (char*)"drawStateDumpDotFile");
+    DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)vkGetProcAddr(gpu(), (char*)"drawStateDumpDotFile");
     pDSDumpDot((char*)"triTest2.dot");
 #endif
 
@@ -1338,8 +1338,8 @@
     const int matrixSize = sizeof(MVP) / sizeof(MVP[0]);
 
     XglConstantBufferObj MVPBuffer(m_device, matrixSize, sizeof(MVP[0]), (const void*) &MVP[0][0]);
-    XglShaderObj vs(m_device,vertShaderText,XGL_SHADER_STAGE_VERTEX, this);
-    XglShaderObj ps(m_device,fragShaderText, XGL_SHADER_STAGE_FRAGMENT, this);
+    XglShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX, this);
+    XglShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT, this);
 
     XglPipelineObj pipelineobj(m_device);
     pipelineobj.AddShader(&vs);
@@ -1347,19 +1347,19 @@
 
     // Create descriptor set and attach the constant buffer to it
     XglDescriptorSetObj descriptorSet(m_device);
-    descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, MVPBuffer);
+    descriptorSet.AppendBuffer(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, MVPBuffer);
 
     ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
     XglCommandBufferObj cmdBuffer(m_device);
     cmdBuffer.AddRenderTarget(m_renderTargets[0]);
 
-    ASSERT_XGL_SUCCESS(BeginCommandBuffer(cmdBuffer));
+    ASSERT_VK_SUCCESS(BeginCommandBuffer(cmdBuffer));
 
     GenericDrawPreparation(&cmdBuffer, pipelineobj, descriptorSet);
 
     // cmdBuffer.BindVertexBuffer(&meshBuffer, 0, 0);
 #ifdef DUMP_STATE_DOT
-    DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)xglGetProcAddr(gpu(), (char*)"drawStateDumpDotFile");
+    DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)vkGetProcAddr(gpu(), (char*)"drawStateDumpDotFile");
     pDSDumpDot((char*)"triTest2.dot");
 #endif
 
@@ -1416,8 +1416,8 @@
     ASSERT_NO_FATAL_FAILURE(InitState());
     ASSERT_NO_FATAL_FAILURE(InitViewport());
 
-    XglShaderObj vs(m_device,vertShaderText,XGL_SHADER_STAGE_VERTEX, this);
-    XglShaderObj ps(m_device,fragShaderText, XGL_SHADER_STAGE_FRAGMENT, this);
+    XglShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX, this);
+    XglShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT, this);
 
     XglPipelineObj pipelineobj(m_device);
     pipelineobj.AddShader(&vs);
@@ -1430,12 +1430,12 @@
     XglCommandBufferObj cmdBuffer(m_device);
     cmdBuffer.AddRenderTarget(m_renderTargets[0]);
 
-    ASSERT_XGL_SUCCESS(BeginCommandBuffer(cmdBuffer));
+    ASSERT_VK_SUCCESS(BeginCommandBuffer(cmdBuffer));
 
     GenericDrawPreparation(&cmdBuffer, pipelineobj, descriptorSet);
 
 #ifdef DUMP_STATE_DOT
-    DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)xglGetProcAddr(gpu(), (char*)"drawStateDumpDotFile");
+    DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)vkGetProcAddr(gpu(), (char*)"drawStateDumpDotFile");
     pDSDumpDot((char*)"triTest2.dot");
 #endif
 
@@ -1485,31 +1485,31 @@
     XglConstantBufferObj meshBuffer(m_device,sizeof(g_vbData)/sizeof(g_vbData[0]),sizeof(g_vbData[0]), g_vbData);
     meshBuffer.BufferMemoryBarrier();
 
-    XglShaderObj vs(m_device,vertShaderText,XGL_SHADER_STAGE_VERTEX, this);
-    XglShaderObj ps(m_device,fragShaderText, XGL_SHADER_STAGE_FRAGMENT, this);
+    XglShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX, this);
+    XglShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT, this);
 
     XglPipelineObj pipelineobj(m_device);
     pipelineobj.AddShader(&vs);
     pipelineobj.AddShader(&ps);
 
     XglDescriptorSetObj descriptorSet(m_device);
-    descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, meshBuffer);
+    descriptorSet.AppendBuffer(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, meshBuffer);
 
 #define MESH_BUF_ID 0
-    XGL_VERTEX_INPUT_BINDING_DESCRIPTION vi_binding = {
+    VK_VERTEX_INPUT_BINDING_DESCRIPTION vi_binding = {
         MESH_BUF_ID,                            // Binding ID
         sizeof(g_vbData[0]),                    // strideInBytes;  Distance between vertices in bytes (0 = no advancement)
-        XGL_VERTEX_INPUT_STEP_RATE_VERTEX       // stepRate;       // Rate at which binding is incremented
+        VK_VERTEX_INPUT_STEP_RATE_VERTEX       // stepRate;       // Rate at which binding is incremented
     };
 
-    XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION vi_attribs[2];
+    VK_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION vi_attribs[2];
     vi_attribs[0].binding = MESH_BUF_ID;            // binding ID
     vi_attribs[0].location = 0;
-    vi_attribs[0].format = XGL_FMT_R32G32_SFLOAT;   // format of source data
+    vi_attribs[0].format = VK_FMT_R32G32_SFLOAT;   // format of source data
     vi_attribs[0].offsetInBytes = 0;                // Offset of first element in bytes from base of vertex
     vi_attribs[1].binding = MESH_BUF_ID;            // binding ID
     vi_attribs[1].location = 1;
-    vi_attribs[1].format = XGL_FMT_R32G32_SFLOAT;   // format of source data
+    vi_attribs[1].format = VK_FMT_R32G32_SFLOAT;   // format of source data
     vi_attribs[1].offsetInBytes = 16;                // Offset of first element in bytes from base of vertex
 
     pipelineobj.AddVertexInputAttribs(vi_attribs, 2);
@@ -1520,13 +1520,13 @@
     XglCommandBufferObj cmdBuffer(m_device);
     cmdBuffer.AddRenderTarget(m_renderTargets[0]);
 
-    ASSERT_XGL_SUCCESS(BeginCommandBuffer(cmdBuffer));
+    ASSERT_VK_SUCCESS(BeginCommandBuffer(cmdBuffer));
 
     GenericDrawPreparation(&cmdBuffer, pipelineobj, descriptorSet);
 
     cmdBuffer.BindVertexBuffer(&meshBuffer, 0, 0);
 #ifdef DUMP_STATE_DOT
-    DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)xglGetProcAddr(gpu(), (char*)"drawStateDumpDotFile");
+    DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)vkGetProcAddr(gpu(), (char*)"drawStateDumpDotFile");
     pDSDumpDot((char*)"triTest2.dot");
 #endif
 
@@ -1590,31 +1590,31 @@
     XglConstantBufferObj meshBuffer(m_device,sizeof(vData)/sizeof(vData[0]),sizeof(vData[0]), vData);
     meshBuffer.BufferMemoryBarrier();
 
-    XglShaderObj vs(m_device,vertShaderText,XGL_SHADER_STAGE_VERTEX, this);
-    XglShaderObj ps(m_device,fragShaderText, XGL_SHADER_STAGE_FRAGMENT, this);
+    XglShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX, this);
+    XglShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT, this);
 
     XglPipelineObj pipelineobj(m_device);
     pipelineobj.AddShader(&vs);
     pipelineobj.AddShader(&ps);
 
     XglDescriptorSetObj descriptorSet(m_device);
-    descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, meshBuffer);
+    descriptorSet.AppendBuffer(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, meshBuffer);
 
 #define MESH_BUF_ID 0
-    XGL_VERTEX_INPUT_BINDING_DESCRIPTION vi_binding = {
+    VK_VERTEX_INPUT_BINDING_DESCRIPTION vi_binding = {
         MESH_BUF_ID,                            // Binding ID
         sizeof(vData[0]),                       // strideInBytes;  Distance between vertices in bytes (0 = no advancement)
-        XGL_VERTEX_INPUT_STEP_RATE_VERTEX       // stepRate;       // Rate at which binding is incremented
+        VK_VERTEX_INPUT_STEP_RATE_VERTEX       // stepRate;       // Rate at which binding is incremented
     };
 
-    XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION vi_attribs[2];
+    VK_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION vi_attribs[2];
     vi_attribs[0].binding = MESH_BUF_ID;                                        // binding ID
     vi_attribs[0].location = 4;
-    vi_attribs[0].format = XGL_FMT_R32G32B32A32_SFLOAT;                         // format of source data
+    vi_attribs[0].format = VK_FMT_R32G32B32A32_SFLOAT;                         // format of source data
     vi_attribs[0].offsetInBytes = sizeof(float) * 4 * 2;   // Offset of first element in bytes from base of vertex
     vi_attribs[1].binding = MESH_BUF_ID;                                        // binding ID
     vi_attribs[1].location = 1;
-    vi_attribs[1].format = XGL_FMT_R32G32B32A32_SFLOAT;                         // format of source data
+    vi_attribs[1].format = VK_FMT_R32G32B32A32_SFLOAT;                         // format of source data
     vi_attribs[1].offsetInBytes = sizeof(float) * 4 * 1;   // Offset of first element in bytes from base of vertex
 
     pipelineobj.AddVertexInputAttribs(vi_attribs, 2);
@@ -1625,13 +1625,13 @@
     XglCommandBufferObj cmdBuffer(m_device);
     cmdBuffer.AddRenderTarget(m_renderTargets[0]);
 
-    ASSERT_XGL_SUCCESS(BeginCommandBuffer(cmdBuffer));
+    ASSERT_VK_SUCCESS(BeginCommandBuffer(cmdBuffer));
 
     GenericDrawPreparation(&cmdBuffer, pipelineobj, descriptorSet);
 
     cmdBuffer.BindVertexBuffer(&meshBuffer, 0, MESH_BUF_ID);
 #ifdef DUMP_STATE_DOT
-    DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)xglGetProcAddr(gpu(), (char*)"drawStateDumpDotFile");
+    DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)vkGetProcAddr(gpu(), (char*)"drawStateDumpDotFile");
     pDSDumpDot((char*)"triTest2.dot");
 #endif
 
@@ -1685,31 +1685,31 @@
     XglConstantBufferObj meshBuffer(m_device,sizeof(g_vbData)/sizeof(g_vbData[0]),sizeof(g_vbData[0]), g_vbData);
     meshBuffer.BufferMemoryBarrier();
 
-    XglShaderObj vs(m_device,vertShaderText,XGL_SHADER_STAGE_VERTEX, this);
-    XglShaderObj ps(m_device,fragShaderText, XGL_SHADER_STAGE_FRAGMENT, this);
+    XglShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX, this);
+    XglShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT, this);
 
     XglPipelineObj pipelineobj(m_device);
     pipelineobj.AddShader(&vs);
     pipelineobj.AddShader(&ps);
 
     XglDescriptorSetObj descriptorSet(m_device);
-    descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, meshBuffer);
+    descriptorSet.AppendBuffer(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, meshBuffer);
 
 #define MESH_BUF_ID 0
-    XGL_VERTEX_INPUT_BINDING_DESCRIPTION vi_binding = {
+    VK_VERTEX_INPUT_BINDING_DESCRIPTION vi_binding = {
         MESH_BUF_ID,                            // Binding ID
         sizeof(g_vbData[0]),                    // strideInBytes;  Distance between vertices in bytes (0 = no advancement)
-        XGL_VERTEX_INPUT_STEP_RATE_VERTEX       // stepRate;       // Rate at which binding is incremented
+        VK_VERTEX_INPUT_STEP_RATE_VERTEX       // stepRate;       // Rate at which binding is incremented
     };
 
-    XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION vi_attribs[2];
+    VK_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION vi_attribs[2];
     vi_attribs[0].binding = MESH_BUF_ID;            // binding ID
     vi_attribs[0].location = 0;
-    vi_attribs[0].format = XGL_FMT_R32G32B32A32_SFLOAT;            // format of source data
+    vi_attribs[0].format = VK_FMT_R32G32B32A32_SFLOAT;            // format of source data
     vi_attribs[0].offsetInBytes = 0;                // Offset of first element in bytes from base of vertex
     vi_attribs[1].binding = MESH_BUF_ID;            // binding ID
     vi_attribs[1].location = 1;
-    vi_attribs[1].format = XGL_FMT_R32G32B32A32_SFLOAT;            // format of source data
+    vi_attribs[1].format = VK_FMT_R32G32B32A32_SFLOAT;            // format of source data
     vi_attribs[1].offsetInBytes = 16;                // Offset of first element in bytes from base of vertex
 
     pipelineobj.AddVertexInputAttribs(vi_attribs, 2);
@@ -1720,13 +1720,13 @@
     XglCommandBufferObj cmdBuffer(m_device);
     cmdBuffer.AddRenderTarget(m_renderTargets[0]);
 
-    ASSERT_XGL_SUCCESS(BeginCommandBuffer(cmdBuffer));
+    ASSERT_VK_SUCCESS(BeginCommandBuffer(cmdBuffer));
 
     GenericDrawPreparation(&cmdBuffer, pipelineobj, descriptorSet);
 
     cmdBuffer.BindVertexBuffer(&meshBuffer, 0, 0);
 #ifdef DUMP_STATE_DOT
-    DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)xglGetProcAddr(gpu(), (char*)"drawStateDumpDotFile");
+    DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)vkGetProcAddr(gpu(), (char*)"drawStateDumpDotFile");
     pDSDumpDot((char*)"triTest2.dot");
 #endif
 
@@ -1785,45 +1785,45 @@
     const int buf_size = sizeof(MVP) / sizeof(float);
 
     XglConstantBufferObj MVPBuffer(m_device, buf_size, sizeof(MVP[0]), (const void*) &MVP[0][0]);
-    XglShaderObj vs(m_device,vertShaderText,XGL_SHADER_STAGE_VERTEX, this);
-    XglShaderObj ps(m_device,fragShaderText, XGL_SHADER_STAGE_FRAGMENT, this);
+    XglShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX, this);
+    XglShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT, this);
 
     XglPipelineObj pipelineobj(m_device);
     pipelineobj.AddShader(&vs);
     pipelineobj.AddShader(&ps);
 
-    XGL_PIPELINE_DS_STATE_CREATE_INFO ds_state;
-    ds_state.depthTestEnable = XGL_TRUE;
-    ds_state.depthWriteEnable = XGL_TRUE;
-    ds_state.depthFunc = XGL_COMPARE_LESS_EQUAL;
-    ds_state.depthBoundsEnable = XGL_FALSE;
-    ds_state.stencilTestEnable = XGL_FALSE;
-    ds_state.back.stencilDepthFailOp = XGL_STENCIL_OP_KEEP;
-    ds_state.back.stencilFailOp = XGL_STENCIL_OP_KEEP;
-    ds_state.back.stencilPassOp = XGL_STENCIL_OP_KEEP;
-    ds_state.back.stencilFunc = XGL_COMPARE_ALWAYS;
-    ds_state.format = XGL_FMT_D32_SFLOAT;
+    VK_PIPELINE_DS_STATE_CREATE_INFO ds_state;
+    ds_state.depthTestEnable = VK_TRUE;
+    ds_state.depthWriteEnable = VK_TRUE;
+    ds_state.depthFunc = VK_COMPARE_LESS_EQUAL;
+    ds_state.depthBoundsEnable = VK_FALSE;
+    ds_state.stencilTestEnable = VK_FALSE;
+    ds_state.back.stencilDepthFailOp = VK_STENCIL_OP_KEEP;
+    ds_state.back.stencilFailOp = VK_STENCIL_OP_KEEP;
+    ds_state.back.stencilPassOp = VK_STENCIL_OP_KEEP;
+    ds_state.back.stencilFunc = VK_COMPARE_ALWAYS;
+    ds_state.format = VK_FMT_D32_SFLOAT;
     ds_state.front = ds_state.back;
     pipelineobj.SetDepthStencil(&ds_state);
 
     XglDescriptorSetObj descriptorSet(m_device);
-    descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, MVPBuffer);
+    descriptorSet.AppendBuffer(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, MVPBuffer);
 
 #define MESH_BUF_ID 0
-    XGL_VERTEX_INPUT_BINDING_DESCRIPTION vi_binding = {
+    VK_VERTEX_INPUT_BINDING_DESCRIPTION vi_binding = {
         MESH_BUF_ID,                            // Binding ID
         sizeof(g_vbData[0]),                     // strideInBytes;  Distance between vertices in bytes (0 = no advancement)
-        XGL_VERTEX_INPUT_STEP_RATE_VERTEX       // stepRate;       // Rate at which binding is incremented
+        VK_VERTEX_INPUT_STEP_RATE_VERTEX       // stepRate;       // Rate at which binding is incremented
     };
 
-    XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION vi_attribs[2];
+    VK_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION vi_attribs[2];
     vi_attribs[0].binding = MESH_BUF_ID;            // binding ID
     vi_attribs[0].location = 0;
-    vi_attribs[0].format = XGL_FMT_R32G32B32A32_SFLOAT;            // format of source data
+    vi_attribs[0].format = VK_FMT_R32G32B32A32_SFLOAT;            // format of source data
     vi_attribs[0].offsetInBytes = 0;                // Offset of first element in bytes from base of vertex
     vi_attribs[1].binding = MESH_BUF_ID;            // binding ID
     vi_attribs[1].location = 1;
-    vi_attribs[1].format = XGL_FMT_R32G32B32A32_SFLOAT;            // format of source data
+    vi_attribs[1].format = VK_FMT_R32G32B32A32_SFLOAT;            // format of source data
     vi_attribs[1].offsetInBytes = 16;                // Offset of first element in bytes from base of vertex
 
     pipelineobj.AddVertexInputAttribs(vi_attribs, 2);
@@ -1835,12 +1835,12 @@
     XglCommandBufferObj cmdBuffer(m_device);
     cmdBuffer.AddRenderTarget(m_renderTargets[0]);
 
-    ASSERT_XGL_SUCCESS(BeginCommandBuffer(cmdBuffer));
+    ASSERT_VK_SUCCESS(BeginCommandBuffer(cmdBuffer));
     GenericDrawPreparation(&cmdBuffer, pipelineobj, descriptorSet);
 
     cmdBuffer.BindVertexBuffer(&meshBuffer, 0, 0);
 #ifdef DUMP_STATE_DOT
-    DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)xglGetProcAddr(gpu(), (char*)"drawStateDumpDotFile");
+    DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)vkGetProcAddr(gpu(), (char*)"drawStateDumpDotFile");
     pDSDumpDot((char*)"triTest2.dot");
 #endif
 
@@ -1887,8 +1887,8 @@
     ASSERT_NO_FATAL_FAILURE(InitState());
     ASSERT_NO_FATAL_FAILURE(InitViewport());
 
-    XglShaderObj vs(m_device,vertShaderText,XGL_SHADER_STAGE_VERTEX, this);
-    XglShaderObj ps(m_device,fragShaderText, XGL_SHADER_STAGE_FRAGMENT, this);
+    XglShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX, this);
+    XglShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT, this);
     XglSamplerObj sampler(m_device);
     XglTextureObj texture(m_device);
 
@@ -1903,12 +1903,12 @@
     XglCommandBufferObj cmdBuffer(m_device);
     cmdBuffer.AddRenderTarget(m_renderTargets[0]);
 
-    ASSERT_XGL_SUCCESS(BeginCommandBuffer(cmdBuffer));
+    ASSERT_VK_SUCCESS(BeginCommandBuffer(cmdBuffer));
 
     GenericDrawPreparation(&cmdBuffer, pipelineobj, descriptorSet);
 
 #ifdef DUMP_STATE_DOT
-    DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)xglGetProcAddr(gpu(), (char*)"drawStateDumpDotFile");
+    DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)vkGetProcAddr(gpu(), (char*)"drawStateDumpDotFile");
     pDSDumpDot((char*)"triTest2.dot");
 #endif
 
@@ -1957,8 +1957,8 @@
     ASSERT_NO_FATAL_FAILURE(InitState());
     ASSERT_NO_FATAL_FAILURE(InitViewport());
 
-    XglShaderObj vs(m_device,vertShaderText,XGL_SHADER_STAGE_VERTEX, this);
-    XglShaderObj ps(m_device,fragShaderText, XGL_SHADER_STAGE_FRAGMENT, this);
+    XglShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX, this);
+    XglShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT, this);
     XglSamplerObj sampler(m_device);
     XglTextureObj texture(m_device);
 
@@ -1973,12 +1973,12 @@
     XglCommandBufferObj cmdBuffer(m_device);
     cmdBuffer.AddRenderTarget(m_renderTargets[0]);
 
-    ASSERT_XGL_SUCCESS(BeginCommandBuffer(cmdBuffer));
+    ASSERT_VK_SUCCESS(BeginCommandBuffer(cmdBuffer));
 
     GenericDrawPreparation(&cmdBuffer, pipelineobj, descriptorSet);
 
 #ifdef DUMP_STATE_DOT
-    DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)xglGetProcAddr(gpu(), (char*)"drawStateDumpDotFile");
+    DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)vkGetProcAddr(gpu(), (char*)"drawStateDumpDotFile");
     pDSDumpDot((char*)"triTest2.dot");
 #endif
     // render triangle
@@ -2037,8 +2037,8 @@
     ASSERT_NO_FATAL_FAILURE(InitState());
     ASSERT_NO_FATAL_FAILURE(InitViewport());
 
-    XglShaderObj vs(m_device,vertShaderText,XGL_SHADER_STAGE_VERTEX, this);
-    XglShaderObj ps(m_device,fragShaderText, XGL_SHADER_STAGE_FRAGMENT, this);
+    XglShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX, this);
+    XglShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT, this);
     XglSamplerObj sampler(m_device);
     XglTextureObj texture(m_device);
 
@@ -2053,12 +2053,12 @@
     XglCommandBufferObj cmdBuffer(m_device);
     cmdBuffer.AddRenderTarget(m_renderTargets[0]);
 
-    ASSERT_XGL_SUCCESS(BeginCommandBuffer(cmdBuffer));
+    ASSERT_VK_SUCCESS(BeginCommandBuffer(cmdBuffer));
 
     GenericDrawPreparation(&cmdBuffer, pipelineobj, descriptorSet);
 
 #ifdef DUMP_STATE_DOT
-    DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)xglGetProcAddr(gpu(), (char*)"drawStateDumpDotFile");
+    DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)vkGetProcAddr(gpu(), (char*)"drawStateDumpDotFile");
     pDSDumpDot((char*)"triTest2.dot");
 #endif
     // render triangle
@@ -2106,8 +2106,8 @@
     ASSERT_NO_FATAL_FAILURE(InitState());
     ASSERT_NO_FATAL_FAILURE(InitViewport());
 
-    XglShaderObj vs(m_device,vertShaderText,XGL_SHADER_STAGE_VERTEX, this);
-    XglShaderObj ps(m_device,fragShaderText, XGL_SHADER_STAGE_FRAGMENT, this);
+    XglShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX, this);
+    XglShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT, this);
     XglSamplerObj sampler(m_device);
     XglTextureObj texture(m_device);
 
@@ -2122,12 +2122,12 @@
     XglCommandBufferObj cmdBuffer(m_device);
     cmdBuffer.AddRenderTarget(m_renderTargets[0]);
 
-    ASSERT_XGL_SUCCESS(BeginCommandBuffer(cmdBuffer));
+    ASSERT_VK_SUCCESS(BeginCommandBuffer(cmdBuffer));
 
     GenericDrawPreparation(&cmdBuffer, pipelineobj, descriptorSet);
 
 #ifdef DUMP_STATE_DOT
-    DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)xglGetProcAddr(gpu(), (char*)"drawStateDumpDotFile");
+    DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)vkGetProcAddr(gpu(), (char*)"drawStateDumpDotFile");
     pDSDumpDot((char*)"triTest2.dot");
 #endif
     // render triangle
@@ -2181,8 +2181,8 @@
     ASSERT_NO_FATAL_FAILURE(InitState());
     ASSERT_NO_FATAL_FAILURE(InitViewport());
 
-    XglShaderObj vs(m_device,vertShaderText,XGL_SHADER_STAGE_VERTEX, this);
-    XglShaderObj ps(m_device,fragShaderText, XGL_SHADER_STAGE_FRAGMENT, this);
+    XglShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX, this);
+    XglShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT, this);
 
     XglSamplerObj sampler1(m_device);
     XglSamplerObj sampler2(m_device);
@@ -2210,12 +2210,12 @@
     XglCommandBufferObj cmdBuffer(m_device);
     cmdBuffer.AddRenderTarget(m_renderTargets[0]);
 
-    ASSERT_XGL_SUCCESS(BeginCommandBuffer(cmdBuffer));
+    ASSERT_VK_SUCCESS(BeginCommandBuffer(cmdBuffer));
 
     GenericDrawPreparation(&cmdBuffer, pipelineobj, descriptorSet);
 
 #ifdef DUMP_STATE_DOT
-    DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)xglGetProcAddr(gpu(), (char*)"drawStateDumpDotFile");
+    DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)vkGetProcAddr(gpu(), (char*)"drawStateDumpDotFile");
     pDSDumpDot((char*)"triTest2.dot");
 #endif
     // render triangle
@@ -2264,8 +2264,8 @@
     ASSERT_NO_FATAL_FAILURE(InitState());
     ASSERT_NO_FATAL_FAILURE(InitViewport());
 
-    XglShaderObj vs(m_device,vertShaderText,XGL_SHADER_STAGE_VERTEX, this);
-    XglShaderObj ps(m_device,fragShaderText, XGL_SHADER_STAGE_FRAGMENT, this);
+    XglShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX, this);
+    XglShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT, this);
 
     // Let's populate our buffer with the following:
     //     vec4 red;
@@ -2285,18 +2285,18 @@
     pipelineobj.AddShader(&ps);
 
     XglDescriptorSetObj descriptorSet(m_device);
-    descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, colorBuffer);
+    descriptorSet.AppendBuffer(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, colorBuffer);
 
     ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
     XglCommandBufferObj cmdBuffer(m_device);
     cmdBuffer.AddRenderTarget(m_renderTargets[0]);
 
-    ASSERT_XGL_SUCCESS(BeginCommandBuffer(cmdBuffer));
+    ASSERT_VK_SUCCESS(BeginCommandBuffer(cmdBuffer));
 
     GenericDrawPreparation(&cmdBuffer, pipelineobj, descriptorSet);
 
 #ifdef DUMP_STATE_DOT
-    DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)xglGetProcAddr(gpu(), (char*)"drawStateDumpDotFile");
+    DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)vkGetProcAddr(gpu(), (char*)"drawStateDumpDotFile");
     pDSDumpDot((char*)"triTest2.dot");
 #endif
     // render triangle
@@ -2347,8 +2347,8 @@
     ASSERT_NO_FATAL_FAILURE(InitState());
     ASSERT_NO_FATAL_FAILURE(InitViewport());
 
-    XglShaderObj vs(m_device,vertShaderText,XGL_SHADER_STAGE_VERTEX, this);
-    XglShaderObj ps(m_device,fragShaderText, XGL_SHADER_STAGE_FRAGMENT, this);
+    XglShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX, this);
+    XglShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT, this);
 
     // We're going to create a number of uniform buffers, and then allow
     // the shader to select which it wants to read from with a binding
@@ -2382,21 +2382,21 @@
     pipelineobj.AddShader(&ps);
 
     XglDescriptorSetObj descriptorSet(m_device);
-    descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, redBuffer);
-    descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, greenBuffer);
-    descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, blueBuffer);
-    descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, whiteBuffer);
+    descriptorSet.AppendBuffer(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, redBuffer);
+    descriptorSet.AppendBuffer(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, greenBuffer);
+    descriptorSet.AppendBuffer(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, blueBuffer);
+    descriptorSet.AppendBuffer(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, whiteBuffer);
 
     ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
     XglCommandBufferObj cmdBuffer(m_device);
     cmdBuffer.AddRenderTarget(m_renderTargets[0]);
 
-    ASSERT_XGL_SUCCESS(BeginCommandBuffer(cmdBuffer));
+    ASSERT_VK_SUCCESS(BeginCommandBuffer(cmdBuffer));
 
     GenericDrawPreparation(&cmdBuffer, pipelineobj, descriptorSet);
 
 #ifdef DUMP_STATE_DOT
-    DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)xglGetProcAddr(gpu(), (char*)"drawStateDumpDotFile");
+    DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)vkGetProcAddr(gpu(), (char*)"drawStateDumpDotFile");
     pDSDumpDot((char*)"triTest2.dot");
 #endif
     // render triangle
@@ -2443,8 +2443,8 @@
     ASSERT_NO_FATAL_FAILURE(InitState());
     ASSERT_NO_FATAL_FAILURE(InitViewport());
 
-    XglShaderObj vs(m_device,vertShaderText,XGL_SHADER_STAGE_VERTEX, this);
-    XglShaderObj ps(m_device,fragShaderText, XGL_SHADER_STAGE_FRAGMENT, this);
+    XglShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX, this);
+    XglShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT, this);
 
     // We're going to create a number of uniform buffers, and then allow
     // the shader to select which it wants to read from with a binding
@@ -2478,21 +2478,21 @@
     pipelineobj.AddShader(&ps);
 
     XglDescriptorSetObj descriptorSet(m_device);
-    descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, redBuffer);
-    descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, greenBuffer);
-    descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, blueBuffer);
-    descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, whiteBuffer);
+    descriptorSet.AppendBuffer(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, redBuffer);
+    descriptorSet.AppendBuffer(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, greenBuffer);
+    descriptorSet.AppendBuffer(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, blueBuffer);
+    descriptorSet.AppendBuffer(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, whiteBuffer);
 
     ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
     XglCommandBufferObj cmdBuffer(m_device);
     cmdBuffer.AddRenderTarget(m_renderTargets[0]);
 
-    ASSERT_XGL_SUCCESS(BeginCommandBuffer(cmdBuffer));
+    ASSERT_VK_SUCCESS(BeginCommandBuffer(cmdBuffer));
 
     GenericDrawPreparation(&cmdBuffer, pipelineobj, descriptorSet);
 
 #ifdef DUMP_STATE_DOT
-    DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)xglGetProcAddr(gpu(), (char*)"drawStateDumpDotFile");
+    DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)vkGetProcAddr(gpu(), (char*)"drawStateDumpDotFile");
     pDSDumpDot((char*)"triTest2.dot");
 #endif
     // render triangle
@@ -2559,8 +2559,8 @@
     const int buf_size = sizeof(MVP) / sizeof(float);
 
     XglConstantBufferObj mvpBuffer(m_device, buf_size, sizeof(MVP[0]), (const void*) &MVP[0][0]);
-    XglShaderObj vs(m_device,vertShaderText,XGL_SHADER_STAGE_VERTEX, this);
-    XglShaderObj ps(m_device,fragShaderText, XGL_SHADER_STAGE_FRAGMENT, this);
+    XglShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX, this);
+    XglShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT, this);
     XglSamplerObj sampler(m_device);
     XglTextureObj texture(m_device);
 
@@ -2569,41 +2569,41 @@
     pipelineobj.AddShader(&ps);
 
     XglDescriptorSetObj descriptorSet(m_device);
-    descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, mvpBuffer);
+    descriptorSet.AppendBuffer(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, mvpBuffer);
     descriptorSet.AppendSamplerTexture(&sampler, &texture);
 
 #define MESH_BIND_ID 0
-    XGL_VERTEX_INPUT_BINDING_DESCRIPTION vi_binding = {
+    VK_VERTEX_INPUT_BINDING_DESCRIPTION vi_binding = {
         MESH_BIND_ID,                      // binding ID
         sizeof(g_vbData[0]),               // strideInBytes;  Distance between vertices in bytes (0 = no advancement)
-        XGL_VERTEX_INPUT_STEP_RATE_VERTEX  // stepRate;       // Rate at which binding is incremented
+        VK_VERTEX_INPUT_STEP_RATE_VERTEX  // stepRate;       // Rate at which binding is incremented
     };
 
-    XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION vi_attribs[2];
+    VK_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION vi_attribs[2];
     vi_attribs[0].binding = MESH_BIND_ID;               // Binding ID
     vi_attribs[0].location = 0;                         // location
-    vi_attribs[0].format = XGL_FMT_R32G32B32A32_SFLOAT; // format of source data
+    vi_attribs[0].format = VK_FMT_R32G32B32A32_SFLOAT; // format of source data
     vi_attribs[0].offsetInBytes = 0;                    // Offset of first element in bytes from base of vertex
     vi_attribs[1].binding = MESH_BIND_ID;               // Binding ID
     vi_attribs[1].location = 1;                         // location
-    vi_attribs[1].format = XGL_FMT_R32G32B32A32_SFLOAT; // format of source data
+    vi_attribs[1].format = VK_FMT_R32G32B32A32_SFLOAT; // format of source data
     vi_attribs[1].offsetInBytes = 16;                   // Offset of first element in bytes from base of vertex
 
     pipelineobj.AddVertexInputAttribs(vi_attribs,2);
     pipelineobj.AddVertexInputBindings(&vi_binding,1);
     pipelineobj.AddVertexDataBuffer(&meshBuffer, MESH_BIND_ID);
 
-    XGL_PIPELINE_DS_STATE_CREATE_INFO ds_state;
-    ds_state.depthTestEnable = XGL_TRUE;
-    ds_state.depthWriteEnable = XGL_TRUE;
-    ds_state.depthFunc = XGL_COMPARE_LESS_EQUAL;
-    ds_state.depthBoundsEnable = XGL_FALSE;
-    ds_state.stencilTestEnable = XGL_FALSE;
-    ds_state.back.stencilDepthFailOp = XGL_STENCIL_OP_KEEP;
-    ds_state.back.stencilFailOp = XGL_STENCIL_OP_KEEP;
-    ds_state.back.stencilPassOp = XGL_STENCIL_OP_KEEP;
-    ds_state.back.stencilFunc = XGL_COMPARE_ALWAYS;
-    ds_state.format = XGL_FMT_D32_SFLOAT;
+    VK_PIPELINE_DS_STATE_CREATE_INFO ds_state;
+    ds_state.depthTestEnable = VK_TRUE;
+    ds_state.depthWriteEnable = VK_TRUE;
+    ds_state.depthFunc = VK_COMPARE_LESS_EQUAL;
+    ds_state.depthBoundsEnable = VK_FALSE;
+    ds_state.stencilTestEnable = VK_FALSE;
+    ds_state.back.stencilDepthFailOp = VK_STENCIL_OP_KEEP;
+    ds_state.back.stencilFailOp = VK_STENCIL_OP_KEEP;
+    ds_state.back.stencilPassOp = VK_STENCIL_OP_KEEP;
+    ds_state.back.stencilFunc = VK_COMPARE_ALWAYS;
+    ds_state.format = VK_FMT_D32_SFLOAT;
     ds_state.front = ds_state.back;
     pipelineobj.SetDepthStencil(&ds_state);
 
@@ -2611,13 +2611,13 @@
     XglCommandBufferObj cmdBuffer(m_device);
     cmdBuffer.AddRenderTarget(m_renderTargets[0]);
 
-    ASSERT_XGL_SUCCESS(BeginCommandBuffer(cmdBuffer));
+    ASSERT_VK_SUCCESS(BeginCommandBuffer(cmdBuffer));
 
     GenericDrawPreparation(&cmdBuffer, pipelineobj, descriptorSet);
 
     cmdBuffer.BindVertexBuffer(&meshBuffer, 0, 0);
 #ifdef DUMP_STATE_DOT
-    DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)xglGetProcAddr(gpu(), (char*)"drawStateDumpDotFile");
+    DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)vkGetProcAddr(gpu(), (char*)"drawStateDumpDotFile");
     pDSDumpDot((char*)"triTest2.dot");
 #endif
     // render triangle
@@ -2673,8 +2673,8 @@
     ASSERT_NO_FATAL_FAILURE(InitState());
     ASSERT_NO_FATAL_FAILURE(InitViewport());
 
-    XglShaderObj vs(m_device,vertShaderText,XGL_SHADER_STAGE_VERTEX, this);
-    XglShaderObj ps(m_device,fragShaderText, XGL_SHADER_STAGE_FRAGMENT, this);
+    XglShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX, this);
+    XglShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT, this);
 
     const float redVals[4]   = { 1.0, 0.0, 0.0, 1.0 };
     const float greenVals[4] = { 0.0, 1.0, 0.0, 1.0 };
@@ -2716,22 +2716,22 @@
     descriptorSet.AppendSamplerTexture(&sampler2, &texture2);
     descriptorSet.AppendSamplerTexture(&sampler4, &texture4);
     descriptorSet.AppendSamplerTexture(&sampler7, &texture7);
-    descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, redBuffer);
+    descriptorSet.AppendBuffer(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, redBuffer);
     // swap blue and green
-    descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, blueBuffer);
-    descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, greenBuffer);
-    descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, whiteBuffer);
+    descriptorSet.AppendBuffer(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, blueBuffer);
+    descriptorSet.AppendBuffer(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, greenBuffer);
+    descriptorSet.AppendBuffer(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, whiteBuffer);
 
     ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
     XglCommandBufferObj cmdBuffer(m_device);
     cmdBuffer.AddRenderTarget(m_renderTargets[0]);
 
-    ASSERT_XGL_SUCCESS(BeginCommandBuffer(cmdBuffer));
+    ASSERT_VK_SUCCESS(BeginCommandBuffer(cmdBuffer));
 
     GenericDrawPreparation(&cmdBuffer, pipelineobj, descriptorSet);
 
 #ifdef DUMP_STATE_DOT
-    DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)xglGetProcAddr(gpu(), (char*)"drawStateDumpDotFile");
+    DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)vkGetProcAddr(gpu(), (char*)"drawStateDumpDotFile");
     pDSDumpDot((char*)"triTest2.dot");
 #endif
     // render triangle
@@ -2785,8 +2785,8 @@
     ASSERT_NO_FATAL_FAILURE(InitState());
     ASSERT_NO_FATAL_FAILURE(InitViewport());
 
-    XglShaderObj vs(m_device,vertShaderText,XGL_SHADER_STAGE_VERTEX, this);
-    XglShaderObj ps(m_device,fragShaderText, XGL_SHADER_STAGE_FRAGMENT, this);
+    XglShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX, this);
+    XglShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT, this);
 
     const float redVals[4]   = { 1.0, 0.0, 0.0, 1.0 };
     const float greenVals[4] = { 0.0, 1.0, 0.0, 1.0 };
@@ -2825,21 +2825,21 @@
     descriptorSet.AppendSamplerTexture(&sampler2, &texture2);
     descriptorSet.AppendSamplerTexture(&sampler4, &texture4);
     descriptorSet.AppendSamplerTexture(&sampler7, &texture7);
-    descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, redBuffer);
-    descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, greenBuffer);
-    descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, blueBuffer);
-    descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, whiteBuffer);
+    descriptorSet.AppendBuffer(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, redBuffer);
+    descriptorSet.AppendBuffer(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, greenBuffer);
+    descriptorSet.AppendBuffer(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, blueBuffer);
+    descriptorSet.AppendBuffer(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, whiteBuffer);
 
     ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
     XglCommandBufferObj cmdBuffer(m_device);
     cmdBuffer.AddRenderTarget(m_renderTargets[0]);
 
-    ASSERT_XGL_SUCCESS(BeginCommandBuffer(cmdBuffer));
+    ASSERT_VK_SUCCESS(BeginCommandBuffer(cmdBuffer));
 
     GenericDrawPreparation(&cmdBuffer, pipelineobj, descriptorSet);
 
 #ifdef DUMP_STATE_DOT
-    DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)xglGetProcAddr(gpu(), (char*)"drawStateDumpDotFile");
+    DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)vkGetProcAddr(gpu(), (char*)"drawStateDumpDotFile");
     pDSDumpDot((char*)"triTest2.dot");
 #endif
     // render triangle
@@ -3068,8 +3068,8 @@
 
     const int constCount   = sizeof(mixedVals)   / sizeof(float);
 
-    XglShaderObj vs(m_device,vertShaderText,XGL_SHADER_STAGE_VERTEX, this);
-    XglShaderObj ps(m_device,fragShaderText, XGL_SHADER_STAGE_FRAGMENT, this);
+    XglShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX, this);
+    XglShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT, this);
 
     XglConstantBufferObj mixedBuffer(m_device, constCount, sizeof(mixedVals[0]), (const void*) mixedVals);
 
@@ -3078,18 +3078,18 @@
     pipelineobj.AddShader(&ps);
 
     XglDescriptorSetObj descriptorSet(m_device);
-    descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, mixedBuffer);
+    descriptorSet.AppendBuffer(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, mixedBuffer);
 
     ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
     XglCommandBufferObj cmdBuffer(m_device);
     cmdBuffer.AddRenderTarget(m_renderTargets[0]);
 
-    ASSERT_XGL_SUCCESS(BeginCommandBuffer(cmdBuffer));
+    ASSERT_VK_SUCCESS(BeginCommandBuffer(cmdBuffer));
 
     GenericDrawPreparation(&cmdBuffer, pipelineobj, descriptorSet);
 
 #ifdef DUMP_STATE_DOT
-    DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)xglGetProcAddr(gpu(), (char*)"drawStateDumpDotFile");
+    DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)vkGetProcAddr(gpu(), (char*)"drawStateDumpDotFile");
     pDSDumpDot((char*)"triTest2.dot");
 #endif
     // render triangle
diff --git a/tests/run_all_tests.sh b/tests/run_all_tests.sh
index fcd0412..aa8ef48 100755
--- a/tests/run_all_tests.sh
+++ b/tests/run_all_tests.sh
@@ -2,16 +2,16 @@
 #
 # Run all the regression tests
 
-# xglbase tests that basic XGL calls are working (don't return an error).
-./xglbase
+# vkbase tests that basic VK calls are working (don't return an error).
+./vkbase
 
-# xgl_blit_tests test Fill/Copy Memory, Clears, CopyMemoryToImage
-./xgl_blit_tests
+# vk_blit_tests test Fill/Copy Memory, Clears, CopyMemoryToImage
+./vk_blit_tests
 
-# xgl_image_tests check that image can be allocated and bound.
-./xgl_image_tests
+# vk_image_tests check that image can be allocated and bound.
+./vk_image_tests
 
-#xgl_render_tests tests a variety of features using rendered images
+#vk_render_tests tests a variety of features using rendered images
 # --compare-images will cause the test to check the resulting image against
 # a saved "golden" image and will report an error if there is any difference
-./xgl_render_tests --compare-images
+./vk_render_tests --compare-images
diff --git a/tests/run_all_tests_with_layers.sh b/tests/run_all_tests_with_layers.sh
index db836b0..7a585d6 100755
--- a/tests/run_all_tests_with_layers.sh
+++ b/tests/run_all_tests_with_layers.sh
@@ -3,12 +3,12 @@
 # Run all the regression tests with validation layers enabled
 
 # enable layers
-export LIBXGL_LAYER_NAMES=DrawState:MemTracker:ParamChecker:ObjectTracker
+export LIBVK_LAYER_NAMES=DrawState:MemTracker:ParamChecker:ObjectTracker
 # Save any existing settings file
 RESTORE_SETTINGS="false"
-SETTINGS_NAME="xgl_layer_settings.txt"
+SETTINGS_NAME="vk_layer_settings.txt"
 TMP_SETTINGS_NAME="xls.txt"
-OUTPUT_LEVEL="XGL_DBG_LAYER_LEVEL_ERROR"
+OUTPUT_LEVEL="VK_DBG_LAYER_LEVEL_ERROR"
 if [ -f $SETTINGS_NAME ]; then
     echo Saving $SETTINGS_NAME to $TMP_SETTINGS_NAME
     RESTORE_SETTINGS="true"
@@ -22,19 +22,19 @@
 echo "ObjectTrackerReportLevel = $OUTPUT_LEVEL" >> $SETTINGS_NAME
 echo "ParamCheckerReportLevel = $OUTPUT_LEVEL" >> $SETTINGS_NAME
 
-# xglbase tests that basic XGL calls are working (don't return an error).
-./xglbase
+# vkbase tests that basic VK calls are working (don't return an error).
+./vkbase
 
-# xgl_blit_tests test Fill/Copy Memory, Clears, CopyMemoryToImage
-./xgl_blit_tests
+# vk_blit_tests test Fill/Copy Memory, Clears, CopyMemoryToImage
+./vk_blit_tests
 
-# xgl_image_tests check that image can be allocated and bound.
-./xgl_image_tests
+# vk_image_tests check that image can be allocated and bound.
+./vk_image_tests
 
-#xgl_render_tests tests a variety of features using rendered images
+#vk_render_tests tests a variety of features using rendered images
 # --compare-images will cause the test to check the resulting image against
 # a saved "golden" image and will report an error if there is any difference
-./xgl_render_tests --compare-images
+./vk_render_tests --compare-images
 
 if [ "$RESTORE_SETTINGS" = "true" ]; then
     echo Restore $SETTINGS_NAME from $TMP_SETTINGS_NAME
diff --git a/tests/test_common.h b/tests/test_common.h
index 52082a6..48cf177 100644
--- a/tests/test_common.h
+++ b/tests/test_common.h
@@ -7,58 +7,58 @@
 #include <string.h>
 #include <assert.h>
 
-#include <xgl.h>
+#include <vulkan.h>
 
 #include "gtest/gtest.h"
 #include "gtest-1.7.0/include/gtest/gtest.h"
-#include "xgltestbinding.h"
+#include "vktestbinding.h"
 
-#define ASSERT_XGL_SUCCESS(err) ASSERT_EQ(XGL_SUCCESS, err) << xgl_result_string(err)
+#define ASSERT_VK_SUCCESS(err) ASSERT_EQ(VK_SUCCESS, err) << vk_result_string(err)
 
-static inline const char *xgl_result_string(XGL_RESULT err)
+static inline const char *vk_result_string(VK_RESULT err)
 {
     switch (err) {
 #define STR(r) case r: return #r
-    STR(XGL_SUCCESS);
-    STR(XGL_UNSUPPORTED);
-    STR(XGL_NOT_READY);
-    STR(XGL_TIMEOUT);
-    STR(XGL_EVENT_SET);
-    STR(XGL_EVENT_RESET);
-    STR(XGL_ERROR_UNKNOWN);
-    STR(XGL_ERROR_UNAVAILABLE);
-    STR(XGL_ERROR_INITIALIZATION_FAILED);
-    STR(XGL_ERROR_OUT_OF_MEMORY);
-    STR(XGL_ERROR_OUT_OF_GPU_MEMORY);
-    STR(XGL_ERROR_DEVICE_ALREADY_CREATED);
-    STR(XGL_ERROR_DEVICE_LOST);
-    STR(XGL_ERROR_INVALID_POINTER);
-    STR(XGL_ERROR_INVALID_VALUE);
-    STR(XGL_ERROR_INVALID_HANDLE);
-    STR(XGL_ERROR_INVALID_ORDINAL);
-    STR(XGL_ERROR_INVALID_MEMORY_SIZE);
-    STR(XGL_ERROR_INVALID_EXTENSION);
-    STR(XGL_ERROR_INVALID_FLAGS);
-    STR(XGL_ERROR_INVALID_ALIGNMENT);
-    STR(XGL_ERROR_INVALID_FORMAT);
-    STR(XGL_ERROR_INVALID_IMAGE);
-    STR(XGL_ERROR_INVALID_DESCRIPTOR_SET_DATA);
-    STR(XGL_ERROR_INVALID_QUEUE_TYPE);
-    STR(XGL_ERROR_INVALID_OBJECT_TYPE);
-    STR(XGL_ERROR_UNSUPPORTED_SHADER_IL_VERSION);
-    STR(XGL_ERROR_BAD_SHADER_CODE);
-    STR(XGL_ERROR_BAD_PIPELINE_DATA);
-    STR(XGL_ERROR_TOO_MANY_MEMORY_REFERENCES);
-    STR(XGL_ERROR_NOT_MAPPABLE);
-    STR(XGL_ERROR_MEMORY_MAP_FAILED);
-    STR(XGL_ERROR_MEMORY_UNMAP_FAILED);
-    STR(XGL_ERROR_INCOMPATIBLE_DEVICE);
-    STR(XGL_ERROR_INCOMPATIBLE_DRIVER);
-    STR(XGL_ERROR_INCOMPLETE_COMMAND_BUFFER);
-    STR(XGL_ERROR_BUILDING_COMMAND_BUFFER);
-    STR(XGL_ERROR_MEMORY_NOT_BOUND);
-    STR(XGL_ERROR_INCOMPATIBLE_QUEUE);
-    STR(XGL_ERROR_NOT_SHAREABLE);
+    STR(VK_SUCCESS);
+    STR(VK_UNSUPPORTED);
+    STR(VK_NOT_READY);
+    STR(VK_TIMEOUT);
+    STR(VK_EVENT_SET);
+    STR(VK_EVENT_RESET);
+    STR(VK_ERROR_UNKNOWN);
+    STR(VK_ERROR_UNAVAILABLE);
+    STR(VK_ERROR_INITIALIZATION_FAILED);
+    STR(VK_ERROR_OUT_OF_MEMORY);
+    STR(VK_ERROR_OUT_OF_GPU_MEMORY);
+    STR(VK_ERROR_DEVICE_ALREADY_CREATED);
+    STR(VK_ERROR_DEVICE_LOST);
+    STR(VK_ERROR_INVALID_POINTER);
+    STR(VK_ERROR_INVALID_VALUE);
+    STR(VK_ERROR_INVALID_HANDLE);
+    STR(VK_ERROR_INVALID_ORDINAL);
+    STR(VK_ERROR_INVALID_MEMORY_SIZE);
+    STR(VK_ERROR_INVALID_EXTENSION);
+    STR(VK_ERROR_INVALID_FLAGS);
+    STR(VK_ERROR_INVALID_ALIGNMENT);
+    STR(VK_ERROR_INVALID_FORMAT);
+    STR(VK_ERROR_INVALID_IMAGE);
+    STR(VK_ERROR_INVALID_DESCRIPTOR_SET_DATA);
+    STR(VK_ERROR_INVALID_QUEUE_TYPE);
+    STR(VK_ERROR_INVALID_OBJECT_TYPE);
+    STR(VK_ERROR_UNSUPPORTED_SHADER_IL_VERSION);
+    STR(VK_ERROR_BAD_SHADER_CODE);
+    STR(VK_ERROR_BAD_PIPELINE_DATA);
+    STR(VK_ERROR_TOO_MANY_MEMORY_REFERENCES);
+    STR(VK_ERROR_NOT_MAPPABLE);
+    STR(VK_ERROR_MEMORY_MAP_FAILED);
+    STR(VK_ERROR_MEMORY_UNMAP_FAILED);
+    STR(VK_ERROR_INCOMPATIBLE_DEVICE);
+    STR(VK_ERROR_INCOMPATIBLE_DRIVER);
+    STR(VK_ERROR_INCOMPLETE_COMMAND_BUFFER);
+    STR(VK_ERROR_BUILDING_COMMAND_BUFFER);
+    STR(VK_ERROR_MEMORY_NOT_BOUND);
+    STR(VK_ERROR_INCOMPATIBLE_QUEUE);
+    STR(VK_ERROR_NOT_SHAREABLE);
 #undef STR
     default: return "UNKNOWN_RESULT";
     }
diff --git a/tests/test_environment.cpp b/tests/test_environment.cpp
index 812a050..5d3a580 100644
--- a/tests/test_environment.cpp
+++ b/tests/test_environment.cpp
@@ -1,20 +1,20 @@
 #include "test_common.h"
-#include "xgltestbinding.h"
+#include "vktestbinding.h"
 #include "test_environment.h"
 
 #define ARRAY_SIZE(a) (sizeof(a) / sizeof(a[0]))
 
-namespace xgl_testing {
+namespace vk_testing {
 
 Environment::Environment() :
     m_connection(NULL), default_dev_(0)
 {
-    app_.sType = XGL_STRUCTURE_TYPE_APPLICATION_INFO;
-    app_.pAppName = "xgl_testing";
+    app_.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
+    app_.pAppName = "vk_testing";
     app_.appVersion = 1;
-    app_.pEngineName = "xgl_testing";
+    app_.pEngineName = "vk_testing";
     app_.engineVersion = 1;
-    app_.apiVersion = XGL_API_VERSION;
+    app_.apiVersion = VK_API_VERSION;
 }
 
 bool Environment::parse_args(int argc, char **argv)
@@ -50,18 +50,18 @@
 {
 
     uint32_t count;
-    XGL_RESULT err;
-    XGL_INSTANCE_CREATE_INFO inst_info = {};
-    inst_info.sType = XGL_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
+    VK_RESULT err;
+    VK_INSTANCE_CREATE_INFO inst_info = {};
+    inst_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
     inst_info.pNext = NULL;
     inst_info.pAppInfo = &app_;
     inst_info.pAllocCb = NULL;
     inst_info.extensionCount = 0;
     inst_info.ppEnabledExtensionNames = NULL;
-    err = xglCreateInstance(&inst_info, &inst);
-    ASSERT_EQ(XGL_SUCCESS, err);
-    err = xglEnumerateGpus(inst, ARRAY_SIZE(gpus), &count, gpus);
-    ASSERT_EQ(XGL_SUCCESS, err);
+    err = vkCreateInstance(&inst_info, &inst);
+    ASSERT_EQ(VK_SUCCESS, err);
+    err = vkEnumerateGpus(inst, ARRAY_SIZE(gpus), &count, gpus);
+    ASSERT_EQ(VK_SUCCESS, err);
     ASSERT_GT(count, default_dev_);
 
     devs_.reserve(count);
@@ -78,22 +78,22 @@
 {
 
     uint32_t count;
-    XGL_RESULT err;
+    VK_RESULT err;
     const xcb_setup_t *setup;
     xcb_screen_iterator_t iter;
     int scr;
-    XGL_INSTANCE_CREATE_INFO instInfo = {};
-    instInfo.sType = XGL_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
+    VK_INSTANCE_CREATE_INFO instInfo = {};
+    instInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
     instInfo.pNext = NULL;
     instInfo.pAppInfo = &app_;
     instInfo.pAllocCb = NULL;
     instInfo.extensionCount = 0;
     instInfo.ppEnabledExtensionNames = NULL;
 
-    err = xglCreateInstance(&instInfo, &inst);
-    ASSERT_EQ(XGL_SUCCESS, err);
-    err = xglEnumerateGpus(inst, ARRAY_SIZE(gpus), &count, gpus);
-    ASSERT_EQ(XGL_SUCCESS, err);
+    err = vkCreateInstance(&instInfo, &inst);
+    ASSERT_EQ(VK_SUCCESS, err);
+    err = vkEnumerateGpus(inst, ARRAY_SIZE(gpus), &count, gpus);
+    ASSERT_EQ(VK_SUCCESS, err);
     ASSERT_GT(count, default_dev_);
 
     m_connection = xcb_connect(NULL, &scr);
@@ -105,12 +105,12 @@
 
     m_screen = iter.data;
 
-    XGL_WSI_X11_CONNECTION_INFO connection_info = {};
+    VK_WSI_X11_CONNECTION_INFO connection_info = {};
     connection_info.pConnection = m_connection;
     connection_info.root = m_screen->root;
     connection_info.provider = 0;
 
-    err = xglWsiX11AssociateConnection(gpus[0], &connection_info);
+    err = vkWsiX11AssociateConnection(gpus[0], &connection_info);
     assert(!err);
 
 
@@ -134,6 +134,6 @@
         delete *it;
     devs_.clear();
 
-    xglDestroyInstance(inst);
+    vkDestroyInstance(inst);
 }
-} // xgl_testing namespace
+} // vk_testing namespace
diff --git a/tests/test_environment.h b/tests/test_environment.h
index 69d574e..4338ec4 100644
--- a/tests/test_environment.h
+++ b/tests/test_environment.h
@@ -1,9 +1,9 @@
 #ifndef TEST_ENVIRONMENT_H
 #define TEST_ENVIRONMENT_H
-#include "xgltestbinding.h"
-#include <xglWsiX11Ext.h>
+#include "vktestbinding.h"
+#include <vkWsiX11Ext.h>
 
-namespace xgl_testing {
+namespace vk_testing {
 class Environment : public ::testing::Environment {
 public:
     Environment();
@@ -18,12 +18,12 @@
 
     const std::vector<Device *> &devices() { return devs_; }
     Device &default_device() { return *(devs_[default_dev_]); }
-    XGL_PHYSICAL_GPU gpus[XGL_MAX_PHYSICAL_GPUS];
+    VK_PHYSICAL_GPU gpus[VK_MAX_PHYSICAL_GPUS];
 
 private:
-    XGL_APPLICATION_INFO app_;
+    VK_APPLICATION_INFO app_;
     int default_dev_;
-    XGL_INSTANCE inst;
+    VK_INSTANCE inst;
 
     std::vector<Device *> devs_;
 };
diff --git a/tests/vkrenderframework.h b/tests/vkrenderframework.h
new file mode 100644
index 0000000..4c7ba01
--- /dev/null
+++ b/tests/vkrenderframework.h
@@ -0,0 +1,417 @@
+/*
+ * Vulkan Tests
+ *
+ * Copyright (C) 2014 LunarG, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ * Authors:
+ *   Courtney Goeltzenleuchter <courtney@lunarg.com>
+ */
+
+#ifndef VKRENDERFRAMEWORK_H
+#define VKRENDERFRAMEWORK_H
+
+#include "vktestframework.h"
+
+
+class XglDevice : public vk_testing::Device
+{
+public:
+    XglDevice(uint32_t id, VK_PHYSICAL_GPU obj);
+
+    VK_DEVICE device() { return obj(); }
+    void get_device_queue();
+
+    uint32_t id;
+    VK_PHYSICAL_GPU_PROPERTIES props;
+    const VK_PHYSICAL_GPU_QUEUE_PROPERTIES *queue_props;
+
+    VK_QUEUE m_queue;
+};
+
+class XglMemoryRefManager
+{
+public:
+    void AddMemoryRefs(vk_testing::Object &vkObject);
+    void AddMemoryRefs(vector<VK_GPU_MEMORY> mem);
+    void EmitAddMemoryRefs(VK_QUEUE queue);
+    void EmitRemoveMemoryRefs(VK_QUEUE queue);
+    vector<VK_GPU_MEMORY> mem_refs() const;
+
+protected:
+    vector<VK_GPU_MEMORY>      mem_refs_;
+
+};
+
+class XglDepthStencilObj : public vk_testing::Image
+{
+public:
+    XglDepthStencilObj();
+    void Init(XglDevice *device, int32_t width, int32_t height);
+    bool Initialized();
+    VK_DEPTH_STENCIL_BIND_INFO* BindInfo();
+
+protected:
+    XglDevice                         *m_device;
+    bool                               m_initialized;
+    vk_testing::DepthStencilView      m_depthStencilView;
+    VK_FORMAT                         m_depth_stencil_fmt;
+    VK_DEPTH_STENCIL_BIND_INFO        m_depthStencilBindInfo;
+};
+
+class XglRenderFramework : public XglTestFramework
+{
+public:
+    XglRenderFramework();
+    ~XglRenderFramework();
+
+    VK_DEVICE device() {return m_device->device();}
+    VK_PHYSICAL_GPU gpu() {return objs[0];}
+    VK_RENDER_PASS renderPass() {return m_renderPass;}
+    VK_FRAMEBUFFER framebuffer() {return m_framebuffer;}
+    void InitViewport(float width, float height);
+    void InitViewport();
+    void InitRenderTarget();
+    void InitRenderTarget(uint32_t targets);
+    void InitRenderTarget(VK_DEPTH_STENCIL_BIND_INFO *dsBinding);
+    void InitRenderTarget(uint32_t targets, VK_DEPTH_STENCIL_BIND_INFO *dsBinding);
+    void InitFramework();
+    void ShutdownFramework();
+    void InitState();
+
+
+protected:
+    VK_APPLICATION_INFO                    app_info;
+    VK_INSTANCE                            inst;
+    VK_PHYSICAL_GPU                        objs[VK_MAX_PHYSICAL_GPUS];
+    uint32_t                                gpu_count;
+    XglDevice                              *m_device;
+    VK_CMD_BUFFER                          m_cmdBuffer;
+    VK_RENDER_PASS                         m_renderPass;
+    VK_FRAMEBUFFER                         m_framebuffer;
+    VK_DYNAMIC_RS_STATE_OBJECT             m_stateRaster;
+    VK_DYNAMIC_CB_STATE_OBJECT             m_colorBlend;
+    VK_DYNAMIC_VP_STATE_OBJECT             m_stateViewport;
+    VK_DYNAMIC_DS_STATE_OBJECT             m_stateDepthStencil;
+    vector<XglImage*>                       m_renderTargets;
+    float                                   m_width, m_height;
+    VK_FORMAT                              m_render_target_fmt;
+    VK_FORMAT                              m_depth_stencil_fmt;
+    VK_COLOR_ATTACHMENT_BIND_INFO          m_colorBindings[8];
+    VK_CLEAR_COLOR                         m_clear_color;
+    float                                   m_depth_clear_color;
+    uint32_t                                m_stencil_clear_color;
+    XglDepthStencilObj                     *m_depthStencil;
+    XglMemoryRefManager                     m_mem_ref_mgr;
+
+    /*
+     * SetUp and TearDown are called by the Google Test framework
+     * to initialize a test framework based on this class.
+     */
+    virtual void SetUp() {
+        this->app_info.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
+        this->app_info.pNext = NULL;
+        this->app_info.pAppName = "base";
+        this->app_info.appVersion = 1;
+        this->app_info.pEngineName = "unittest";
+        this->app_info.engineVersion = 1;
+        this->app_info.apiVersion = VK_API_VERSION;
+
+        InitFramework();
+    }
+
+    virtual void TearDown() {
+        ShutdownFramework();
+    }
+};
+
+class XglDescriptorSetObj;
+class XglIndexBufferObj;
+class XglConstantBufferObj;
+class XglPipelineObj;
+class XglDescriptorSetObj;
+
+class XglCommandBufferObj : public vk_testing::CmdBuffer
+{
+public:
+    XglCommandBufferObj(XglDevice *device);
+    VK_CMD_BUFFER GetBufferHandle();
+    VK_RESULT BeginCommandBuffer();
+    VK_RESULT BeginCommandBuffer(VK_CMD_BUFFER_BEGIN_INFO *pInfo);
+    VK_RESULT BeginCommandBuffer(VK_RENDER_PASS renderpass_obj, VK_FRAMEBUFFER framebuffer_obj);
+    VK_RESULT EndCommandBuffer();
+    void PipelineBarrier(VK_PIPELINE_BARRIER *barrierPtr);
+    void AddRenderTarget(XglImage *renderTarget);
+    void AddDepthStencil();
+    void ClearAllBuffers(VK_CLEAR_COLOR clear_color, float depth_clear_color, uint32_t stencil_clear_color, XglDepthStencilObj *depthStencilObj);
+    void PrepareAttachments();
+    void AddMemoryRefs(vk_testing::Object &vkObject);
+    void AddMemoryRefs(uint32_t ref_count, const VK_GPU_MEMORY *mem);
+    void AddMemoryRefs(vector<vk_testing::Object *> images);
+    void BindPipeline(XglPipelineObj &pipeline);
+    void BindDescriptorSet(XglDescriptorSetObj &descriptorSet);
+    void BindVertexBuffer(XglConstantBufferObj *vertexBuffer, uint32_t offset, uint32_t binding);
+    void BindIndexBuffer(XglIndexBufferObj *indexBuffer, uint32_t offset);
+    void BindStateObject(VK_STATE_BIND_POINT stateBindPoint, VK_DYNAMIC_STATE_OBJECT stateObject);
+    void BeginRenderPass(VK_RENDER_PASS renderpass, VK_FRAMEBUFFER framebuffer);
+    void EndRenderPass(VK_RENDER_PASS renderpass);
+    void Draw(uint32_t firstVertex, uint32_t vertexCount, uint32_t firstInstance, uint32_t instanceCount);
+    void DrawIndexed(uint32_t firstIndex, uint32_t indexCount, int32_t vertexOffset, uint32_t firstInstance, uint32_t instanceCount);
+    void QueueCommandBuffer();
+    void QueueCommandBuffer(VK_FENCE fence);
+
+    XglMemoryRefManager             mem_ref_mgr;
+
+protected:
+    XglDevice                      *m_device;
+    vector<XglImage*>               m_renderTargets;
+};
+
+class XglConstantBufferObj : public vk_testing::Buffer
+{
+public:
+    XglConstantBufferObj(XglDevice *device);
+    XglConstantBufferObj(XglDevice *device, int constantCount, int constantSize, const void* data);
+    ~XglConstantBufferObj();
+    void BufferMemoryBarrier(
+        VK_FLAGS outputMask =
+            VK_MEMORY_OUTPUT_CPU_WRITE_BIT |
+            VK_MEMORY_OUTPUT_SHADER_WRITE_BIT |
+            VK_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT |
+            VK_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT |
+            VK_MEMORY_OUTPUT_COPY_BIT,
+        VK_FLAGS inputMask =
+            VK_MEMORY_INPUT_CPU_READ_BIT |
+            VK_MEMORY_INPUT_INDIRECT_COMMAND_BIT |
+            VK_MEMORY_INPUT_INDEX_FETCH_BIT |
+            VK_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT |
+            VK_MEMORY_INPUT_UNIFORM_READ_BIT |
+            VK_MEMORY_INPUT_SHADER_READ_BIT |
+            VK_MEMORY_INPUT_COLOR_ATTACHMENT_BIT |
+            VK_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT |
+            VK_MEMORY_INPUT_COPY_BIT);
+
+    void Bind(VK_CMD_BUFFER cmdBuffer, VK_GPU_SIZE offset, uint32_t binding);
+
+    VK_BUFFER_VIEW_ATTACH_INFO     m_bufferViewInfo;
+
+protected:
+    XglDevice                      *m_device;
+    vk_testing::BufferView         m_bufferView;
+    int                             m_numVertices;
+    int                             m_stride;
+    XglCommandBufferObj             *m_commandBuffer;
+    vk_testing::Fence              m_fence;
+};
+
+class XglIndexBufferObj : public XglConstantBufferObj
+{
+public:
+    XglIndexBufferObj(XglDevice *device);
+    void CreateAndInitBuffer(int numIndexes, VK_INDEX_TYPE dataFormat, const void* data);
+    void Bind(VK_CMD_BUFFER cmdBuffer, VK_GPU_SIZE offset);
+    VK_INDEX_TYPE GetIndexType();
+
+protected:
+    VK_INDEX_TYPE  m_indexType;
+};
+
+class XglImage : public vk_testing::Image
+{
+public:
+    XglImage(XglDevice *dev);
+    bool IsCompatible(VK_FLAGS usage, VK_FLAGS features);
+
+public:
+    void init(uint32_t w, uint32_t h,
+              VK_FORMAT fmt, VK_FLAGS usage,
+              VK_IMAGE_TILING tiling=VK_LINEAR_TILING);
+
+    //    void clear( CommandBuffer*, uint32_t[4] );
+
+    void layout( VK_IMAGE_LAYOUT layout )
+    {
+        m_imageInfo.layout = layout;
+    }
+
+    VK_GPU_MEMORY memory() const
+    {
+        const std::vector<VK_GPU_MEMORY> mems = memories();
+        return mems.empty() ? VK_NULL_HANDLE : mems[0];
+    }
+
+    void ImageMemoryBarrier(XglCommandBufferObj *cmd,
+                            VK_IMAGE_ASPECT aspect,
+                            VK_FLAGS output_mask,
+                            VK_FLAGS input_mask,
+                            VK_IMAGE_LAYOUT image_layout);
+
+    VK_RESULT CopyImage(XglImage &src_image);
+
+    VK_IMAGE image() const
+    {
+        return obj();
+    }
+
+    VK_COLOR_ATTACHMENT_VIEW targetView()
+    {
+        if (!m_targetView.initialized())
+        {
+            VK_COLOR_ATTACHMENT_VIEW_CREATE_INFO createView = {
+                VK_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO,
+                VK_NULL_HANDLE,
+                obj(),
+                VK_FMT_B8G8R8A8_UNORM,
+                0,
+                0,
+                1
+            };
+            m_targetView.init(*m_device, createView);
+        }
+        return m_targetView.obj();
+    }
+
+    void SetLayout(XglCommandBufferObj *cmd_buf, VK_IMAGE_ASPECT aspect, VK_IMAGE_LAYOUT image_layout);
+    void SetLayout(VK_IMAGE_ASPECT aspect, VK_IMAGE_LAYOUT image_layout);
+
+    VK_IMAGE_LAYOUT layout() const
+    {
+        return ( VK_IMAGE_LAYOUT )m_imageInfo.layout;
+    }
+    uint32_t width() const
+    {
+        return extent().width;
+    }
+    uint32_t height() const
+    {
+        return extent().height;
+    }
+    XglDevice* device() const
+    {
+        return m_device;
+    }
+
+    VK_RESULT MapMemory(void** ptr);
+    VK_RESULT UnmapMemory();
+
+protected:
+    XglDevice *m_device;
+
+    vk_testing::ColorAttachmentView m_targetView;
+    VK_IMAGE_VIEW_ATTACH_INFO   m_imageInfo;
+};
+
+class XglTextureObj : public XglImage
+{
+public:
+    XglTextureObj(XglDevice *device, uint32_t *colors = NULL);
+    VK_IMAGE_VIEW_ATTACH_INFO m_textureViewInfo;
+
+
+protected:
+    XglDevice                 *m_device;
+    vk_testing::ImageView     m_textureView;
+    VK_GPU_SIZE               m_rowPitch;
+};
+
+class XglSamplerObj : public vk_testing::Sampler
+{
+public:
+    XglSamplerObj(XglDevice *device);
+
+protected:
+     XglDevice *m_device;
+
+};
+
+class XglDescriptorSetObj : public vk_testing::DescriptorPool
+{
+public:
+    XglDescriptorSetObj(XglDevice *device);
+    ~XglDescriptorSetObj();
+
+    int AppendDummy();
+    int AppendBuffer(VK_DESCRIPTOR_TYPE type, XglConstantBufferObj &constantBuffer);
+    int AppendSamplerTexture(XglSamplerObj* sampler, XglTextureObj* texture);
+    void CreateVKDescriptorSet(XglCommandBufferObj *cmdBuffer);
+
+    VK_DESCRIPTOR_SET GetDescriptorSetHandle() const;
+    VK_DESCRIPTOR_SET_LAYOUT_CHAIN GetLayoutChain() const;
+
+    XglMemoryRefManager                  mem_ref_mgr;
+
+protected:
+    XglDevice                           *m_device;
+    vector<VK_DESCRIPTOR_TYPE_COUNT>    m_type_counts;
+    int                                  m_nextSlot;
+
+    vector<VK_UPDATE_BUFFERS>           m_updateBuffers;
+
+    vector<VK_SAMPLER_IMAGE_VIEW_INFO>  m_samplerTextureInfo;
+    vector<VK_UPDATE_SAMPLER_TEXTURES>  m_updateSamplerTextures;
+
+    vk_testing::DescriptorSetLayout     m_layout;
+    vk_testing::DescriptorSetLayoutChain m_layout_chain;
+    vk_testing::DescriptorSet          *m_set;
+};
+
+
+class XglShaderObj : public vk_testing::Shader
+{
+public:
+    XglShaderObj(XglDevice *device, const char * shaderText, VK_PIPELINE_SHADER_STAGE stage, XglRenderFramework *framework);
+    VK_PIPELINE_SHADER_STAGE_CREATE_INFO* GetStageCreateInfo();
+
+protected:
+    VK_PIPELINE_SHADER_STAGE_CREATE_INFO stage_info;
+    VK_PIPELINE_SHADER_STAGE m_stage;
+    XglDevice *m_device;
+
+};
+
+class XglPipelineObj : public vk_testing::Pipeline
+{
+public:
+    XglPipelineObj(XglDevice *device);
+    void AddShader(XglShaderObj* shaderObj);
+    void AddVertexInputAttribs(VK_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* vi_attrib, int count);
+    void AddVertexInputBindings(VK_VERTEX_INPUT_BINDING_DESCRIPTION* vi_binding, int count);
+    void AddVertexDataBuffer(XglConstantBufferObj* vertexDataBuffer, int binding);
+    void AddColorAttachment(uint32_t binding, const VK_PIPELINE_CB_ATTACHMENT_STATE *att);
+    void SetDepthStencil(VK_PIPELINE_DS_STATE_CREATE_INFO *);
+    void CreateVKPipeline(XglDescriptorSetObj &descriptorSet);
+
+protected:
+    VK_PIPELINE_VERTEX_INPUT_CREATE_INFO m_vi_state;
+    VK_PIPELINE_IA_STATE_CREATE_INFO m_ia_state;
+    VK_PIPELINE_RS_STATE_CREATE_INFO m_rs_state;
+    VK_PIPELINE_CB_STATE_CREATE_INFO m_cb_state;
+    VK_PIPELINE_DS_STATE_CREATE_INFO m_ds_state;
+    VK_PIPELINE_MS_STATE_CREATE_INFO m_ms_state;
+    XglDevice *m_device;
+    vector<XglShaderObj*> m_shaderObjs;
+    vector<XglConstantBufferObj*> m_vertexBufferObjs;
+    vector<int> m_vertexBufferBindings;
+    vector<VK_PIPELINE_CB_ATTACHMENT_STATE> m_colorAttachments;
+    int m_vertexBufferCount;
+
+};
+
+#endif // VKRENDERFRAMEWORK_H
diff --git a/tests/vktestbinding.h b/tests/vktestbinding.h
new file mode 100644
index 0000000..4068e75
--- /dev/null
+++ b/tests/vktestbinding.h
@@ -0,0 +1,891 @@
+// VK tests
+//
+// Copyright (C) 2014 LunarG, Inc.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the "Software"),
+// to deal in the Software without restriction, including without limitation
+// the rights to use, copy, modify, merge, publish, distribute, sublicense,
+// and/or sell copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+// DEALINGS IN THE SOFTWARE.
+
+#ifndef VKTESTBINDING_H
+#define VKTESTBINDING_H
+
+#include <vector>
+
+#include "vulkan.h"
+
+namespace vk_testing {
+
+typedef void (*ErrorCallback)(const char *expr, const char *file, unsigned int line, const char *function);
+void set_error_callback(ErrorCallback callback);
+
+class PhysicalGpu;
+class BaseObject;
+class Object;
+class DynamicStateObject;
+class Device;
+class Queue;
+class GpuMemory;
+class Fence;
+class Semaphore;
+class Event;
+class QueryPool;
+class Buffer;
+class BufferView;
+class Image;
+class ImageView;
+class ColorAttachmentView;
+class DepthStencilView;
+class Shader;
+class Pipeline;
+class PipelineDelta;
+class Sampler;
+class DescriptorSetLayout;
+class DescriptorSetLayoutChain;
+class DescriptorSetPool;
+class DescriptorSet;
+class DynamicVpStateObject;
+class DynamicRsStateObject;
+class DynamicMsaaStateObject;
+class DynamicCbStateObject;
+class DynamicDsStateObject;
+class CmdBuffer;
+
+class PhysicalGpu {
+public:
+    explicit PhysicalGpu(VK_PHYSICAL_GPU gpu) : gpu_(gpu) {}
+
+    const VK_PHYSICAL_GPU &obj() const { return gpu_; }
+
+    // vkGetGpuInfo()
+    VK_PHYSICAL_GPU_PROPERTIES properties() const;
+    VK_PHYSICAL_GPU_PERFORMANCE performance() const;
+    VK_PHYSICAL_GPU_MEMORY_PROPERTIES memory_properties() const;
+    std::vector<VK_PHYSICAL_GPU_QUEUE_PROPERTIES> queue_properties() const;
+
+    // vkGetProcAddr()
+    void *get_proc(const char *name) const { return vkGetProcAddr(gpu_, name); }
+
+    // vkGetExtensionSupport()
+    bool has_extension(const char *ext) const { return (vkGetExtensionSupport(gpu_, ext) == VK_SUCCESS); }
+    std::vector<const char *> extensions() const;
+
+    // vkEnumerateLayers()
+    std::vector<const char *> layers(std::vector<char> &buf) const;
+
+    // vkGetMultiGpuCompatibility()
+    VK_GPU_COMPATIBILITY_INFO compatibility(const PhysicalGpu &other) const;
+
+private:
+    VK_PHYSICAL_GPU gpu_;
+};
+
+class BaseObject {
+public:
+    const VK_BASE_OBJECT &obj() const { return obj_; }
+    bool initialized() const { return (obj_ != VK_NULL_HANDLE); }
+
+    // vkGetObjectInfo()
+    uint32_t memory_allocation_count() const;
+    std::vector<VK_MEMORY_REQUIREMENTS> memory_requirements() const;
+
+protected:
+    explicit BaseObject() : obj_(VK_NULL_HANDLE), own_obj_(false) {}
+    explicit BaseObject(VK_BASE_OBJECT obj) : obj_(VK_NULL_HANDLE), own_obj_(false) { init(obj); }
+
+    void init(VK_BASE_OBJECT obj, bool own);
+    void init(VK_BASE_OBJECT obj) { init(obj, true); }
+
+    void reinit(VK_BASE_OBJECT obj, bool own);
+    void reinit(VK_BASE_OBJECT obj) { reinit(obj, true); }
+
+    bool own() const { return own_obj_; }
+
+private:
+    // base objects are non-copyable
+    BaseObject(const BaseObject &);
+    BaseObject &operator=(const BaseObject &);
+
+    VK_BASE_OBJECT obj_;
+    bool own_obj_;
+};
+
+class Object : public BaseObject {
+public:
+    const VK_OBJECT &obj() const { return reinterpret_cast<const VK_OBJECT &>(BaseObject::obj()); }
+
+    // vkBindObjectMemory()
+    void bind_memory(uint32_t alloc_idx, const GpuMemory &mem, VK_GPU_SIZE mem_offset);
+    void unbind_memory(uint32_t alloc_idx);
+    void unbind_memory();
+
+    // vkBindObjectMemoryRange()
+    void bind_memory(uint32_t alloc_idx, VK_GPU_SIZE offset, VK_GPU_SIZE size,
+                     const GpuMemory &mem, VK_GPU_SIZE mem_offset);
+
+    // Unless an object is initialized with init_no_mem(), memories are
+    // automatically allocated and bound.  These methods can be used to get
+    // the memories (for vkQueueAddMemReference), or to map/unmap the primary memory.
+    std::vector<VK_GPU_MEMORY> memories() const;
+
+    const void *map(VK_FLAGS flags) const;
+          void *map(VK_FLAGS flags);
+    const void *map() const { return map(0); }
+          void *map()       { return map(0); }
+
+    void unmap() const;
+
+protected:
+    explicit Object() : mem_alloc_count_(0), internal_mems_(NULL), primary_mem_(NULL) {}
+    explicit Object(VK_OBJECT obj) : mem_alloc_count_(0), internal_mems_(NULL), primary_mem_(NULL) { init(obj); }
+    ~Object() { cleanup(); }
+
+    void init(VK_OBJECT obj, bool own);
+    void init(VK_OBJECT obj) { init(obj, true); }
+
+    void reinit(VK_OBJECT obj, bool own);
+    void reinit(VK_OBJECT obj) { init(obj, true); }
+
+    // allocate and bind internal memories
+    void alloc_memory(const Device &dev, bool for_linear_img, bool for_img);
+    void alloc_memory(const Device &dev) { alloc_memory(dev, false, false); }
+    void alloc_memory(const std::vector<VK_GPU_MEMORY> &mems);
+
+private:
+    void cleanup();
+
+    uint32_t mem_alloc_count_;
+    GpuMemory *internal_mems_;
+    GpuMemory *primary_mem_;
+};
+
+class DynamicStateObject : public Object {
+public:
+    const VK_DYNAMIC_STATE_OBJECT &obj() const { return reinterpret_cast<const VK_DYNAMIC_STATE_OBJECT &>(Object::obj()); }
+
+protected:
+    explicit DynamicStateObject() {}
+    explicit DynamicStateObject(VK_DYNAMIC_STATE_OBJECT obj) : Object(obj) {}
+};
+
+template<typename T, class C>
+class DerivedObject : public C {
+public:
+    const T &obj() const { return reinterpret_cast<const T &>(C::obj()); }
+
+protected:
+    typedef T obj_type;
+    typedef C base_type;
+
+    explicit DerivedObject() {}
+    explicit DerivedObject(T obj) : C(obj) {}
+};
+
+class Device : public DerivedObject<VK_DEVICE, BaseObject> {
+public:
+    explicit Device(VK_PHYSICAL_GPU gpu) : gpu_(gpu) {}
+    ~Device();
+
+    // vkCreateDevice()
+    void init(const VK_DEVICE_CREATE_INFO &info);
+    void init(bool enable_layers); // all queues, all extensions, etc
+    void init() { init(false); };
+
+    const PhysicalGpu &gpu() const { return gpu_; }
+
+    // vkGetDeviceQueue()
+    const std::vector<Queue *> &graphics_queues() { return queues_[GRAPHICS]; }
+    const std::vector<Queue *> &compute_queues() { return queues_[COMPUTE]; }
+    const std::vector<Queue *> &dma_queues() { return queues_[DMA]; }
+    uint32_t graphics_queue_node_index_;
+
+    struct Format {
+        VK_FORMAT format;
+        VK_IMAGE_TILING tiling;
+        VK_FLAGS features;
+    };
+    // vkGetFormatInfo()
+    VK_FORMAT_PROPERTIES format_properties(VK_FORMAT format);
+    const std::vector<Format> &formats() const { return formats_; }
+
+    // vkDeviceWaitIdle()
+    void wait();
+
+    // vkWaitForFences()
+    VK_RESULT wait(const std::vector<const Fence *> &fences, bool wait_all, uint64_t timeout);
+    VK_RESULT wait(const Fence &fence) { return wait(std::vector<const Fence *>(1, &fence), true, (uint64_t) -1); }
+
+    // vkBeginDescriptorPoolUpdate()
+    // vkEndDescriptorPoolUpdate()
+    void begin_descriptor_pool_update(VK_DESCRIPTOR_UPDATE_MODE mode);
+    void end_descriptor_pool_update(CmdBuffer &cmd);
+
+private:
+    enum QueueIndex {
+        GRAPHICS,
+        COMPUTE,
+        DMA,
+        QUEUE_COUNT,
+    };
+
+    void init_queues();
+    void init_formats();
+
+    PhysicalGpu gpu_;
+
+    std::vector<Queue *> queues_[QUEUE_COUNT];
+    std::vector<Format> formats_;
+};
+
+class Queue : public DerivedObject<VK_QUEUE, BaseObject> {
+public:
+    explicit Queue(VK_QUEUE queue) : DerivedObject(queue) {}
+
+    // vkQueueSubmit()
+    void submit(const std::vector<const CmdBuffer *> &cmds, Fence &fence);
+    void submit(const CmdBuffer &cmd, Fence &fence);
+    void submit(const CmdBuffer &cmd);
+
+    // vkQueueAddMemReference()
+    // vkQueueRemoveMemReference()
+    void add_mem_references(const std::vector<VK_GPU_MEMORY> &mem_refs);
+    void remove_mem_references(const std::vector<VK_GPU_MEMORY> &mem_refs);
+
+    // vkQueueWaitIdle()
+    void wait();
+
+    // vkQueueSignalSemaphore()
+    // vkQueueWaitSemaphore()
+    void signal_semaphore(Semaphore &sem);
+    void wait_semaphore(Semaphore &sem);
+};
+
+class GpuMemory : public DerivedObject<VK_GPU_MEMORY, BaseObject> {
+public:
+    ~GpuMemory();
+
+    // vkAllocMemory()
+    void init(const Device &dev, const VK_MEMORY_ALLOC_INFO &info);
+    // vkPinSystemMemory()
+    void init(const Device &dev, size_t size, const void *data);
+    // vkOpenSharedMemory()
+    void init(const Device &dev, const VK_MEMORY_OPEN_INFO &info);
+    // vkOpenPeerMemory()
+    void init(const Device &dev, const VK_PEER_MEMORY_OPEN_INFO &info);
+
+    void init(VK_GPU_MEMORY mem) { BaseObject::init(mem, false); }
+
+    // vkSetMemoryPriority()
+    void set_priority(VK_MEMORY_PRIORITY priority);
+
+    // vkMapMemory()
+    const void *map(VK_FLAGS flags) const;
+          void *map(VK_FLAGS flags);
+    const void *map() const { return map(0); }
+          void *map()       { return map(0); }
+
+    // vkUnmapMemory()
+    void unmap() const;
+
+    static VK_MEMORY_ALLOC_INFO alloc_info(const VK_MEMORY_REQUIREMENTS &reqs,
+                  const VK_MEMORY_ALLOC_INFO *next_info);
+};
+
+class Fence : public DerivedObject<VK_FENCE, Object> {
+public:
+    // vkCreateFence()
+    void init(const Device &dev, const VK_FENCE_CREATE_INFO &info);
+
+    // vkGetFenceStatus()
+    VK_RESULT status() const { return vkGetFenceStatus(obj()); }
+
+    static VK_FENCE_CREATE_INFO create_info(VK_FENCE_CREATE_FLAGS flags);
+    static VK_FENCE_CREATE_INFO create_info();
+};
+
+class Semaphore : public DerivedObject<VK_SEMAPHORE, Object> {
+public:
+    // vkCreateSemaphore()
+    void init(const Device &dev, const VK_SEMAPHORE_CREATE_INFO &info);
+    // vkOpenSharedSemaphore()
+    void init(const Device &dev, const VK_SEMAPHORE_OPEN_INFO &info);
+
+    static VK_SEMAPHORE_CREATE_INFO create_info(uint32_t init_count, VK_FLAGS flags);
+};
+
+class Event : public DerivedObject<VK_EVENT, Object> {
+public:
+    // vkCreateEvent()
+    void init(const Device &dev, const VK_EVENT_CREATE_INFO &info);
+
+    // vkGetEventStatus()
+    // vkSetEvent()
+    // vkResetEvent()
+    VK_RESULT status() const { return vkGetEventStatus(obj()); }
+    void set();
+    void reset();
+
+    static VK_EVENT_CREATE_INFO create_info(VK_FLAGS flags);
+};
+
+class QueryPool : public DerivedObject<VK_QUERY_POOL, Object> {
+public:
+    // vkCreateQueryPool()
+    void init(const Device &dev, const VK_QUERY_POOL_CREATE_INFO &info);
+
+    // vkGetQueryPoolResults()
+    VK_RESULT results(uint32_t start, uint32_t count, size_t size, void *data);
+
+    static VK_QUERY_POOL_CREATE_INFO create_info(VK_QUERY_TYPE type, uint32_t slot_count);
+};
+
+class Buffer : public DerivedObject<VK_BUFFER, Object> {
+public:
+    explicit Buffer() {}
+    explicit Buffer(const Device &dev, const VK_BUFFER_CREATE_INFO &info) { init(dev, info); }
+    explicit Buffer(const Device &dev, VK_GPU_SIZE size) { init(dev, size); }
+
+    // vkCreateBuffer()
+    void init(const Device &dev, const VK_BUFFER_CREATE_INFO &info);
+    void init(const Device &dev, VK_GPU_SIZE size) { init(dev, create_info(size, 0)); }
+    void init_no_mem(const Device &dev, const VK_BUFFER_CREATE_INFO &info);
+
+    static VK_BUFFER_CREATE_INFO create_info(VK_GPU_SIZE size, VK_FLAGS usage);
+
+    VK_BUFFER_MEMORY_BARRIER buffer_memory_barrier(VK_FLAGS output_mask, VK_FLAGS input_mask,
+                                                 VK_GPU_SIZE offset, VK_GPU_SIZE size) const
+    {
+        VK_BUFFER_MEMORY_BARRIER barrier = {};
+        barrier.sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER;
+        barrier.buffer = obj();
+        barrier.outputMask = output_mask;
+        barrier.inputMask = input_mask;
+        barrier.offset = offset;
+        barrier.size = size;
+        return barrier;
+    }
+private:
+    VK_BUFFER_CREATE_INFO create_info_;
+};
+
+class BufferView : public DerivedObject<VK_BUFFER_VIEW, Object> {
+public:
+    // vkCreateBufferView()
+    void init(const Device &dev, const VK_BUFFER_VIEW_CREATE_INFO &info);
+};
+
+class Image : public DerivedObject<VK_IMAGE, Object> {
+public:
+    explicit Image() : format_features_(0) {}
+    explicit Image(const Device &dev, const VK_IMAGE_CREATE_INFO &info) : format_features_(0) { init(dev, info); }
+
+    // vkCreateImage()
+    void init(const Device &dev, const VK_IMAGE_CREATE_INFO &info);
+    void init_no_mem(const Device &dev, const VK_IMAGE_CREATE_INFO &info);
+    // vkOpenPeerImage()
+    void init(const Device &dev, const VK_PEER_IMAGE_OPEN_INFO &info, const VK_IMAGE_CREATE_INFO &original_info);
+
+    // vkBindImageMemoryRange()
+    void bind_memory(uint32_t alloc_idx, const VK_IMAGE_MEMORY_BIND_INFO &info,
+                     const GpuMemory &mem, VK_GPU_SIZE mem_offset);
+
+    // vkGetImageSubresourceInfo()
+    VK_SUBRESOURCE_LAYOUT subresource_layout(const VK_IMAGE_SUBRESOURCE &subres) const;
+
+    bool transparent() const;
+    bool copyable() const { return (format_features_ & VK_FORMAT_IMAGE_COPY_BIT); }
+
+    VK_IMAGE_SUBRESOURCE_RANGE subresource_range(VK_IMAGE_ASPECT aspect) const { return subresource_range(create_info_, aspect); }
+    VK_EXTENT3D extent() const { return create_info_.extent; }
+    VK_EXTENT3D extent(uint32_t mip_level) const { return extent(create_info_.extent, mip_level); }
+    VK_FORMAT format() const {return create_info_.format;}
+
+    VK_IMAGE_MEMORY_BARRIER image_memory_barrier(VK_FLAGS output_mask, VK_FLAGS input_mask,
+                                                  VK_IMAGE_LAYOUT old_layout,
+                                                  VK_IMAGE_LAYOUT new_layout,
+                                                  const VK_IMAGE_SUBRESOURCE_RANGE &range) const
+    {
+        VK_IMAGE_MEMORY_BARRIER barrier = {};
+        barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
+        barrier.outputMask = output_mask;
+        barrier.inputMask = input_mask;
+        barrier.oldLayout = old_layout;
+        barrier.newLayout = new_layout;
+        barrier.image = obj();
+        barrier.subresourceRange = range;
+        return barrier;
+    }
+
+    static VK_IMAGE_CREATE_INFO create_info();
+    static VK_IMAGE_SUBRESOURCE subresource(VK_IMAGE_ASPECT aspect, uint32_t mip_level, uint32_t array_slice);
+    static VK_IMAGE_SUBRESOURCE subresource(const VK_IMAGE_SUBRESOURCE_RANGE &range, uint32_t mip_level, uint32_t array_slice);
+    static VK_IMAGE_SUBRESOURCE_RANGE subresource_range(VK_IMAGE_ASPECT aspect, uint32_t base_mip_level, uint32_t mip_levels,
+                                                                                  uint32_t base_array_slice, uint32_t array_size);
+    static VK_IMAGE_SUBRESOURCE_RANGE subresource_range(const VK_IMAGE_CREATE_INFO &info, VK_IMAGE_ASPECT aspect);
+    static VK_IMAGE_SUBRESOURCE_RANGE subresource_range(const VK_IMAGE_SUBRESOURCE &subres);
+
+    static VK_EXTENT2D extent(int32_t width, int32_t height);
+    static VK_EXTENT2D extent(const VK_EXTENT2D &extent, uint32_t mip_level);
+    static VK_EXTENT2D extent(const VK_EXTENT3D &extent);
+
+    static VK_EXTENT3D extent(int32_t width, int32_t height, int32_t depth);
+    static VK_EXTENT3D extent(const VK_EXTENT3D &extent, uint32_t mip_level);
+
+private:
+    void init_info(const Device &dev, const VK_IMAGE_CREATE_INFO &info);
+
+    VK_IMAGE_CREATE_INFO create_info_;
+    VK_FLAGS format_features_;
+};
+
+class ImageView : public DerivedObject<VK_IMAGE_VIEW, Object> {
+public:
+    // vkCreateImageView()
+    void init(const Device &dev, const VK_IMAGE_VIEW_CREATE_INFO &info);
+};
+
+class ColorAttachmentView : public DerivedObject<VK_COLOR_ATTACHMENT_VIEW, Object> {
+public:
+    // vkCreateColorAttachmentView()
+    void init(const Device &dev, const VK_COLOR_ATTACHMENT_VIEW_CREATE_INFO &info);
+};
+
+class DepthStencilView : public DerivedObject<VK_DEPTH_STENCIL_VIEW, Object> {
+public:
+    // vkCreateDepthStencilView()
+    void init(const Device &dev, const VK_DEPTH_STENCIL_VIEW_CREATE_INFO &info);
+};
+
+class Shader : public DerivedObject<VK_SHADER, Object> {
+public:
+    // vkCreateShader()
+    void init(const Device &dev, const VK_SHADER_CREATE_INFO &info);
+    VK_RESULT init_try(const Device &dev, const VK_SHADER_CREATE_INFO &info);
+
+    static VK_SHADER_CREATE_INFO create_info(size_t code_size, const void *code, VK_FLAGS flags);
+};
+
+class Pipeline : public DerivedObject<VK_PIPELINE, Object> {
+public:
+    // vkCreateGraphicsPipeline()
+    void init(const Device &dev, const VK_GRAPHICS_PIPELINE_CREATE_INFO &info);
+    // vkCreateGraphicsPipelineDerivative()
+    void init(const Device &dev, const VK_GRAPHICS_PIPELINE_CREATE_INFO &info, const VK_PIPELINE basePipeline);
+    // vkCreateComputePipeline()
+    void init(const Device &dev, const VK_COMPUTE_PIPELINE_CREATE_INFO &info);
+    // vkLoadPipeline()
+    void init(const Device&dev, size_t size, const void *data);
+    // vkLoadPipelineDerivative()
+    void init(const Device&dev, size_t size, const void *data, VK_PIPELINE basePipeline);
+
+    // vkStorePipeline()
+    size_t store(size_t size, void *data);
+};
+
+class Sampler : public DerivedObject<VK_SAMPLER, Object> {
+public:
+    // vkCreateSampler()
+    void init(const Device &dev, const VK_SAMPLER_CREATE_INFO &info);
+};
+
+class DescriptorSetLayout : public DerivedObject<VK_DESCRIPTOR_SET_LAYOUT, Object> {
+public:
+    // vkCreateDescriptorSetLayout()
+    void init(const Device &dev, const VK_DESCRIPTOR_SET_LAYOUT_CREATE_INFO &info);
+};
+
+class DescriptorSetLayoutChain : public DerivedObject<VK_DESCRIPTOR_SET_LAYOUT_CHAIN, Object> {
+public:
+    // vkCreateDescriptorSetLayoutChain()
+    void init(const Device &dev, const std::vector<const DescriptorSetLayout *> &layouts);
+};
+
+class DescriptorPool : public DerivedObject<VK_DESCRIPTOR_POOL, Object> {
+public:
+    // vkCreateDescriptorPool()
+    void init(const Device &dev, VK_DESCRIPTOR_POOL_USAGE usage,
+              uint32_t max_sets, const VK_DESCRIPTOR_POOL_CREATE_INFO &info);
+
+    // vkResetDescriptorPool()
+    void reset();
+
+    // vkAllocDescriptorSets()
+    std::vector<DescriptorSet *> alloc_sets(VK_DESCRIPTOR_SET_USAGE usage, const std::vector<const DescriptorSetLayout *> &layouts);
+    std::vector<DescriptorSet *> alloc_sets(VK_DESCRIPTOR_SET_USAGE usage, const DescriptorSetLayout &layout, uint32_t count);
+    DescriptorSet *alloc_sets(VK_DESCRIPTOR_SET_USAGE usage, const DescriptorSetLayout &layout);
+
+    // vkClearDescriptorSets()
+    void clear_sets(const std::vector<DescriptorSet *> &sets);
+    void clear_sets(DescriptorSet &set) { clear_sets(std::vector<DescriptorSet *>(1, &set)); }
+};
+
+class DescriptorSet : public DerivedObject<VK_DESCRIPTOR_SET, Object> {
+public:
+    explicit DescriptorSet(VK_DESCRIPTOR_SET set) : DerivedObject(set) {}
+
+    // vkUpdateDescriptors()
+    void update(const std::vector<const void *> &update_array);
+
+    static VK_UPDATE_SAMPLERS update(uint32_t binding, uint32_t index, uint32_t count, const VK_SAMPLER *samplers);
+    static VK_UPDATE_SAMPLERS update(uint32_t binding, uint32_t index, const std::vector<VK_SAMPLER> &samplers);
+
+    static VK_UPDATE_SAMPLER_TEXTURES update(uint32_t binding, uint32_t index, uint32_t count, const VK_SAMPLER_IMAGE_VIEW_INFO *textures);
+    static VK_UPDATE_SAMPLER_TEXTURES update(uint32_t binding, uint32_t index, const std::vector<VK_SAMPLER_IMAGE_VIEW_INFO> &textures);
+
+    static VK_UPDATE_IMAGES update(VK_DESCRIPTOR_TYPE type, uint32_t binding, uint32_t index, uint32_t count, const VK_IMAGE_VIEW_ATTACH_INFO *views);
+    static VK_UPDATE_IMAGES update(VK_DESCRIPTOR_TYPE type, uint32_t binding, uint32_t index, const std::vector<VK_IMAGE_VIEW_ATTACH_INFO> &views);
+
+    static VK_UPDATE_BUFFERS update(VK_DESCRIPTOR_TYPE type, uint32_t binding, uint32_t index, uint32_t count, const VK_BUFFER_VIEW_ATTACH_INFO *views);
+    static VK_UPDATE_BUFFERS update(VK_DESCRIPTOR_TYPE type, uint32_t binding, uint32_t index, const std::vector<VK_BUFFER_VIEW_ATTACH_INFO> &views);
+
+    static VK_UPDATE_AS_COPY update(VK_DESCRIPTOR_TYPE type, uint32_t binding, uint32_t index, uint32_t count, const DescriptorSet &set);
+
+    static VK_BUFFER_VIEW_ATTACH_INFO attach_info(const BufferView &view);
+    static VK_IMAGE_VIEW_ATTACH_INFO attach_info(const ImageView &view, VK_IMAGE_LAYOUT layout);
+};
+
+class DynamicVpStateObject : public DerivedObject<VK_DYNAMIC_VP_STATE_OBJECT, DynamicStateObject> {
+public:
+    // vkCreateDynamicViewportState()
+    void init(const Device &dev, const VK_DYNAMIC_VP_STATE_CREATE_INFO &info);
+};
+
+class DynamicRsStateObject : public DerivedObject<VK_DYNAMIC_RS_STATE_OBJECT, DynamicStateObject> {
+public:
+    // vkCreateDynamicRasterState()
+    void init(const Device &dev, const VK_DYNAMIC_RS_STATE_CREATE_INFO &info);
+};
+
+class DynamicCbStateObject : public DerivedObject<VK_DYNAMIC_CB_STATE_OBJECT, DynamicStateObject> {
+public:
+    // vkCreateDynamicColorBlendState()
+    void init(const Device &dev, const VK_DYNAMIC_CB_STATE_CREATE_INFO &info);
+};
+
+class DynamicDsStateObject : public DerivedObject<VK_DYNAMIC_DS_STATE_OBJECT, DynamicStateObject> {
+public:
+    // vkCreateDynamicDepthStencilState()
+    void init(const Device &dev, const VK_DYNAMIC_DS_STATE_CREATE_INFO &info);
+};
+
+class CmdBuffer : public DerivedObject<VK_CMD_BUFFER, Object> {
+public:
+    explicit CmdBuffer() {}
+    explicit CmdBuffer(const Device &dev, const VK_CMD_BUFFER_CREATE_INFO &info) { init(dev, info); }
+
+    // vkCreateCommandBuffer()
+    void init(const Device &dev, const VK_CMD_BUFFER_CREATE_INFO &info);
+
+    // vkBeginCommandBuffer()
+    void begin(const VK_CMD_BUFFER_BEGIN_INFO *info);
+    void begin(VK_RENDER_PASS renderpass_obj, VK_FRAMEBUFFER framebuffer_obj);
+    void begin();
+
+    // vkEndCommandBuffer()
+    // vkResetCommandBuffer()
+    void end();
+    void reset();
+
+    static VK_CMD_BUFFER_CREATE_INFO create_info(uint32_t queueNodeIndex);
+};
+
+inline const void *Object::map(VK_FLAGS flags) const
+{
+    return (primary_mem_) ? primary_mem_->map(flags) : NULL;
+}
+
+inline void *Object::map(VK_FLAGS flags)
+{
+    return (primary_mem_) ? primary_mem_->map(flags) : NULL;
+}
+
+inline void Object::unmap() const
+{
+    if (primary_mem_)
+        primary_mem_->unmap();
+}
+
+inline VK_MEMORY_ALLOC_INFO GpuMemory::alloc_info(const VK_MEMORY_REQUIREMENTS &reqs,
+                                const VK_MEMORY_ALLOC_INFO *next_info)
+{
+    VK_MEMORY_ALLOC_INFO info = {};
+    info.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO;
+    if (next_info != NULL)
+        info.pNext = (void *) next_info;
+
+    info.allocationSize = reqs.size;
+    info.memProps = reqs.memProps;
+    info.memType = reqs.memType;
+    info.memPriority = VK_MEMORY_PRIORITY_NORMAL;
+    return info;
+}
+
+inline VK_BUFFER_CREATE_INFO Buffer::create_info(VK_GPU_SIZE size, VK_FLAGS usage)
+{
+    VK_BUFFER_CREATE_INFO info = {};
+    info.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
+    info.size = size;
+    info.usage = usage;
+    return info;
+}
+
+inline VK_FENCE_CREATE_INFO Fence::create_info(VK_FENCE_CREATE_FLAGS flags)
+{
+    VK_FENCE_CREATE_INFO info = {};
+    info.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
+    info.flags = flags;
+    return info;
+}
+
+inline VK_FENCE_CREATE_INFO Fence::create_info()
+{
+    VK_FENCE_CREATE_INFO info = {};
+    info.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
+    return info;
+}
+
+inline VK_SEMAPHORE_CREATE_INFO Semaphore::create_info(uint32_t init_count, VK_FLAGS flags)
+{
+    VK_SEMAPHORE_CREATE_INFO info = {};
+    info.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
+    info.initialCount = init_count;
+    info.flags = flags;
+    return info;
+}
+
+inline VK_EVENT_CREATE_INFO Event::create_info(VK_FLAGS flags)
+{
+    VK_EVENT_CREATE_INFO info = {};
+    info.sType = VK_STRUCTURE_TYPE_EVENT_CREATE_INFO;
+    info.flags = flags;
+    return info;
+}
+
+inline VK_QUERY_POOL_CREATE_INFO QueryPool::create_info(VK_QUERY_TYPE type, uint32_t slot_count)
+{
+    VK_QUERY_POOL_CREATE_INFO info = {};
+    info.sType = VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO;
+    info.queryType = type;
+    info.slots = slot_count;
+    return info;
+}
+
+inline VK_IMAGE_CREATE_INFO Image::create_info()
+{
+    VK_IMAGE_CREATE_INFO info = {};
+    info.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
+    info.extent.width = 1;
+    info.extent.height = 1;
+    info.extent.depth = 1;
+    info.mipLevels = 1;
+    info.arraySize = 1;
+    info.samples = 1;
+    return info;
+}
+
+inline VK_IMAGE_SUBRESOURCE Image::subresource(VK_IMAGE_ASPECT aspect, uint32_t mip_level, uint32_t array_slice)
+{
+    VK_IMAGE_SUBRESOURCE subres = {};
+    subres.aspect = aspect;
+    subres.mipLevel = mip_level;
+    subres.arraySlice = array_slice;
+    return subres;
+}
+
+inline VK_IMAGE_SUBRESOURCE Image::subresource(const VK_IMAGE_SUBRESOURCE_RANGE &range, uint32_t mip_level, uint32_t array_slice)
+{
+    return subresource(range.aspect, range.baseMipLevel + mip_level, range.baseArraySlice + array_slice);
+}
+
+inline VK_IMAGE_SUBRESOURCE_RANGE Image::subresource_range(VK_IMAGE_ASPECT aspect, uint32_t base_mip_level, uint32_t mip_levels,
+                                                                                     uint32_t base_array_slice, uint32_t array_size)
+{
+    VK_IMAGE_SUBRESOURCE_RANGE range = {};
+    range.aspect = aspect;
+    range.baseMipLevel = base_mip_level;
+    range.mipLevels = mip_levels;
+    range.baseArraySlice = base_array_slice;
+    range.arraySize = array_size;
+    return range;
+}
+
+inline VK_IMAGE_SUBRESOURCE_RANGE Image::subresource_range(const VK_IMAGE_CREATE_INFO &info, VK_IMAGE_ASPECT aspect)
+{
+    return subresource_range(aspect, 0, info.mipLevels, 0, info.arraySize);
+}
+
+inline VK_IMAGE_SUBRESOURCE_RANGE Image::subresource_range(const VK_IMAGE_SUBRESOURCE &subres)
+{
+    return subresource_range(subres.aspect, subres.mipLevel, 1, subres.arraySlice, 1);
+}
+
+inline VK_EXTENT2D Image::extent(int32_t width, int32_t height)
+{
+    VK_EXTENT2D extent = {};
+    extent.width = width;
+    extent.height = height;
+    return extent;
+}
+
+inline VK_EXTENT2D Image::extent(const VK_EXTENT2D &extent, uint32_t mip_level)
+{
+    const int32_t width  = (extent.width  >> mip_level) ? extent.width  >> mip_level : 1;
+    const int32_t height = (extent.height >> mip_level) ? extent.height >> mip_level : 1;
+    return Image::extent(width, height);
+}
+
+inline VK_EXTENT2D Image::extent(const VK_EXTENT3D &extent)
+{
+    return Image::extent(extent.width, extent.height);
+}
+
+inline VK_EXTENT3D Image::extent(int32_t width, int32_t height, int32_t depth)
+{
+    VK_EXTENT3D extent = {};
+    extent.width = width;
+    extent.height = height;
+    extent.depth = depth;
+    return extent;
+}
+
+inline VK_EXTENT3D Image::extent(const VK_EXTENT3D &extent, uint32_t mip_level)
+{
+    const int32_t width  = (extent.width  >> mip_level) ? extent.width  >> mip_level : 1;
+    const int32_t height = (extent.height >> mip_level) ? extent.height >> mip_level : 1;
+    const int32_t depth  = (extent.depth  >> mip_level) ? extent.depth  >> mip_level : 1;
+    return Image::extent(width, height, depth);
+}
+
+inline VK_SHADER_CREATE_INFO Shader::create_info(size_t code_size, const void *code, VK_FLAGS flags)
+{
+    VK_SHADER_CREATE_INFO info = {};
+    info.sType = VK_STRUCTURE_TYPE_SHADER_CREATE_INFO;
+    info.codeSize = code_size;
+    info.pCode = code;
+    info.flags = flags;
+    return info;
+}
+
+inline VK_BUFFER_VIEW_ATTACH_INFO DescriptorSet::attach_info(const BufferView &view)
+{
+    VK_BUFFER_VIEW_ATTACH_INFO info = {};
+    info.sType = VK_STRUCTURE_TYPE_BUFFER_VIEW_ATTACH_INFO;
+    info.view = view.obj();
+    return info;
+}
+
+inline VK_IMAGE_VIEW_ATTACH_INFO DescriptorSet::attach_info(const ImageView &view, VK_IMAGE_LAYOUT layout)
+{
+    VK_IMAGE_VIEW_ATTACH_INFO info = {};
+    info.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO;
+    info.view = view.obj();
+    info.layout = layout;
+    return info;
+}
+
+inline VK_UPDATE_SAMPLERS DescriptorSet::update(uint32_t binding, uint32_t index, uint32_t count, const VK_SAMPLER *samplers)
+{
+    VK_UPDATE_SAMPLERS info = {};
+    info.sType = VK_STRUCTURE_TYPE_UPDATE_SAMPLERS;
+    info.binding = binding;
+    info.arrayIndex = index;
+    info.count = count;
+    info.pSamplers = samplers;
+    return info;
+}
+
+inline VK_UPDATE_SAMPLERS DescriptorSet::update(uint32_t binding, uint32_t index, const std::vector<VK_SAMPLER> &samplers)
+{
+    return update(binding, index, samplers.size(), &samplers[0]);
+}
+
+inline VK_UPDATE_SAMPLER_TEXTURES DescriptorSet::update(uint32_t binding, uint32_t index, uint32_t count, const VK_SAMPLER_IMAGE_VIEW_INFO *textures)
+{
+    VK_UPDATE_SAMPLER_TEXTURES info = {};
+    info.sType = VK_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES;
+    info.binding = binding;
+    info.arrayIndex = index;
+    info.count = count;
+    info.pSamplerImageViews = textures;
+    return info;
+}
+
+inline VK_UPDATE_SAMPLER_TEXTURES DescriptorSet::update(uint32_t binding, uint32_t index, const std::vector<VK_SAMPLER_IMAGE_VIEW_INFO> &textures)
+{
+    return update(binding, index, textures.size(), &textures[0]);
+}
+
+inline VK_UPDATE_IMAGES DescriptorSet::update(VK_DESCRIPTOR_TYPE type, uint32_t binding, uint32_t index, uint32_t count,
+                                               const VK_IMAGE_VIEW_ATTACH_INFO *views)
+{
+    VK_UPDATE_IMAGES info = {};
+    info.sType = VK_STRUCTURE_TYPE_UPDATE_IMAGES;
+    info.descriptorType = type;
+    info.binding = binding;
+    info.arrayIndex = index;
+    info.count = count;
+    info.pImageViews = views;
+    return info;
+}
+
+inline VK_UPDATE_IMAGES DescriptorSet::update(VK_DESCRIPTOR_TYPE type, uint32_t binding, uint32_t index,
+                                               const std::vector<VK_IMAGE_VIEW_ATTACH_INFO> &views)
+{
+    return update(type, binding, index, views.size(), &views[0]);
+}
+
+inline VK_UPDATE_BUFFERS DescriptorSet::update(VK_DESCRIPTOR_TYPE type, uint32_t binding, uint32_t index, uint32_t count,
+                                                const VK_BUFFER_VIEW_ATTACH_INFO *views)
+{
+    VK_UPDATE_BUFFERS info = {};
+    info.sType = VK_STRUCTURE_TYPE_UPDATE_BUFFERS;
+    info.descriptorType = type;
+    info.binding = binding;
+    info.arrayIndex = index;
+    info.count = count;
+    info.pBufferViews = views;
+    return info;
+}
+
+inline VK_UPDATE_BUFFERS DescriptorSet::update(VK_DESCRIPTOR_TYPE type, uint32_t binding, uint32_t index,
+                                                const std::vector<VK_BUFFER_VIEW_ATTACH_INFO> &views)
+{
+    return update(type, binding, index, views.size(), &views[0]);
+}
+
+inline VK_UPDATE_AS_COPY DescriptorSet::update(VK_DESCRIPTOR_TYPE type, uint32_t binding, uint32_t index, uint32_t count, const DescriptorSet &set)
+{
+    VK_UPDATE_AS_COPY info = {};
+    info.sType = VK_STRUCTURE_TYPE_UPDATE_AS_COPY;
+    info.descriptorType = type;
+    info.binding = binding;
+    info.arrayElement = index;
+    info.count = count;
+    info.descriptorSet = set.obj();
+    return info;
+}
+
+inline VK_CMD_BUFFER_CREATE_INFO CmdBuffer::create_info(uint32_t queueNodeIndex)
+{
+    VK_CMD_BUFFER_CREATE_INFO info = {};
+    info.sType = VK_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO;
+    info.queueNodeIndex = queueNodeIndex;
+    return info;
+}
+
+}; // namespace vk_testing
+
+#endif // VKTESTBINDING_H
diff --git a/tests/xgltestframework.h b/tests/vktestframework.h
similarity index 89%
rename from tests/xgltestframework.h
rename to tests/vktestframework.h
index 981dc0e..9648009 100644
--- a/tests/xgltestframework.h
+++ b/tests/vktestframework.h
@@ -1,4 +1,4 @@
-//  XGL tests
+//  VK tests
 //
 //  Copyright (C) 2014 LunarG, Inc.
 //
@@ -20,15 +20,15 @@
 //  FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 //  DEALINGS IN THE SOFTWARE.
 
-#ifndef XGLTESTFRAMEWORK_H
-#define XGLTESTFRAMEWORK_H
+#ifndef VKTESTFRAMEWORK_H
+#define VKTESTFRAMEWORK_H
 
 #include "gtest-1.7.0/include/gtest/gtest.h"
 #include "ShaderLang.h"
 #include "GLSL450Lib.h"
 #include "icd-spv.h"
 #include "test_common.h"
-#include "xgltestbinding.h"
+#include "vktestbinding.h"
 #include "test_environment.h"
 
 #include <stdlib.h>
@@ -38,7 +38,7 @@
 #include <iostream>
 #include <fstream>
 #include <list>
-#include <xglWsiX11Ext.h>
+#include <vkWsiX11Ext.h>
 
 // Can be used by tests to record additional details / description of test
 #define TEST_DESCRIPTION(desc) RecordProperty("description", desc)
@@ -62,8 +62,8 @@
     int                       m_width;
     int                       m_height;
     void                     *m_data;
-    XGL_IMAGE                 m_presentableImage;
-    XGL_GPU_MEMORY            m_presentableMemory;
+    VK_IMAGE                 m_presentableImage;
+    VK_GPU_MEMORY            m_presentableMemory;
     unsigned                  m_data_size;
 };
 
@@ -81,7 +81,7 @@
     void Compare(const char *comment, XglImage *image);
     void RecordImage(XglImage * image);
     void RecordImages(vector<XglImage *> image);
-    bool GLSLtoSPV(const XGL_PIPELINE_SHADER_STAGE shader_type,
+    bool GLSLtoSPV(const VK_PIPELINE_SHADER_STAGE shader_type,
                    const char *pshader,
                    std::vector<unsigned int> &spv);
     static bool         m_use_spv;
@@ -96,7 +96,7 @@
     void SetMessageOptions(EShMessages& messages);
     void ProcessConfigFile();
     EShLanguage FindLanguage(const std::string& name);
-    EShLanguage FindLanguage(const XGL_PIPELINE_SHADER_STAGE shader_type);
+    EShLanguage FindLanguage(const VK_PIPELINE_SHADER_STAGE shader_type);
     std::string ConfigFile;
     bool SetConfigFile(const std::string& name);
 
@@ -129,9 +129,9 @@
     void TearDown();
 
 protected:
-    xgl_testing::Device                    &m_device;
-    xgl_testing::Queue                     &m_queue;
-    xgl_testing::CmdBuffer                  m_cmdbuf;
+    vk_testing::Device                    &m_device;
+    vk_testing::Queue                     &m_queue;
+    vk_testing::CmdBuffer                  m_cmdbuf;
 
 private:
     xcb_window_t                            m_window;
@@ -158,4 +158,4 @@
   void TearDown();
 };
 
-#endif // XGLTESTFRAMEWORK_H
+#endif // VKTESTFRAMEWORK_H
diff --git a/tests/xglrenderframework.cpp b/tests/xglrenderframework.cpp
index 620b229..bec384e 100644
--- a/tests/xglrenderframework.cpp
+++ b/tests/xglrenderframework.cpp
@@ -1,5 +1,5 @@
 /*
- * XGL Tests
+ * Vulkan Tests
  *
  * Copyright (C) 2014 LunarG, Inc.
  *
@@ -25,18 +25,18 @@
  *   Courtney Goeltzenleuchter <courtney@lunarg.com>
  */
 
-#include "xglrenderframework.h"
+#include "vkrenderframework.h"
 
 XglRenderFramework::XglRenderFramework() :
-    m_cmdBuffer( XGL_NULL_HANDLE ),
-    m_stateRaster( XGL_NULL_HANDLE ),
-    m_colorBlend( XGL_NULL_HANDLE ),
-    m_stateViewport( XGL_NULL_HANDLE ),
-    m_stateDepthStencil( XGL_NULL_HANDLE ),
+    m_cmdBuffer( VK_NULL_HANDLE ),
+    m_stateRaster( VK_NULL_HANDLE ),
+    m_colorBlend( VK_NULL_HANDLE ),
+    m_stateViewport( VK_NULL_HANDLE ),
+    m_stateDepthStencil( VK_NULL_HANDLE ),
     m_width( 256.0 ),                   // default window width
     m_height( 256.0 ),                  // default window height
-    m_render_target_fmt( XGL_FMT_R8G8B8A8_UNORM ),
-    m_depth_stencil_fmt( XGL_FMT_UNDEFINED ),
+    m_render_target_fmt( VK_FMT_R8G8B8A8_UNORM ),
+    m_depth_stencil_fmt( VK_FMT_UNDEFINED ),
     m_depth_clear_color( 1.0 ),
     m_stencil_clear_color( 0 )
 {
@@ -56,19 +56,19 @@
 
 void XglRenderFramework::InitFramework()
 {
-    XGL_RESULT err;
-    XGL_INSTANCE_CREATE_INFO instInfo = {};
-    instInfo.sType = XGL_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
+    VK_RESULT err;
+    VK_INSTANCE_CREATE_INFO instInfo = {};
+    instInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
     instInfo.pNext = NULL;
     instInfo.pAppInfo = &app_info;
     instInfo.pAllocCb = NULL;
     instInfo.extensionCount = 0;
     instInfo.ppEnabledExtensionNames = NULL;
-    err = xglCreateInstance(&instInfo, &this->inst);
-    ASSERT_XGL_SUCCESS(err);
-    err = xglEnumerateGpus(inst, XGL_MAX_PHYSICAL_GPUS, &this->gpu_count,
+    err = vkCreateInstance(&instInfo, &this->inst);
+    ASSERT_VK_SUCCESS(err);
+    err = vkEnumerateGpus(inst, VK_MAX_PHYSICAL_GPUS, &this->gpu_count,
                            objs);
-    ASSERT_XGL_SUCCESS(err);
+    ASSERT_VK_SUCCESS(err);
     ASSERT_GE(this->gpu_count, 1) << "No GPU available";
 
     m_device = new XglDevice(0, objs[0]);
@@ -79,21 +79,21 @@
 
 void XglRenderFramework::ShutdownFramework()
 {
-    if (m_colorBlend) xglDestroyObject(m_colorBlend);
-    if (m_stateDepthStencil) xglDestroyObject(m_stateDepthStencil);
-    if (m_stateRaster) xglDestroyObject(m_stateRaster);
-    if (m_cmdBuffer) xglDestroyObject(m_cmdBuffer);
-    if (m_framebuffer) xglDestroyObject(m_framebuffer);
-    if (m_renderPass) xglDestroyObject(m_renderPass);
+    if (m_colorBlend) vkDestroyObject(m_colorBlend);
+    if (m_stateDepthStencil) vkDestroyObject(m_stateDepthStencil);
+    if (m_stateRaster) vkDestroyObject(m_stateRaster);
+    if (m_cmdBuffer) vkDestroyObject(m_cmdBuffer);
+    if (m_framebuffer) vkDestroyObject(m_framebuffer);
+    if (m_renderPass) vkDestroyObject(m_renderPass);
 
     if (m_stateViewport) {
-        xglDestroyObject(m_stateViewport);
+        vkDestroyObject(m_stateViewport);
     }
     while (!m_renderTargets.empty()) {
-        xglDestroyObject(m_renderTargets.back()->targetView());
-        xglBindObjectMemory(m_renderTargets.back()->image(), 0, XGL_NULL_HANDLE, 0);
-        xglDestroyObject(m_renderTargets.back()->image());
-        xglFreeMemory(m_renderTargets.back()->memory());
+        vkDestroyObject(m_renderTargets.back()->targetView());
+        vkBindObjectMemory(m_renderTargets.back()->image(), 0, VK_NULL_HANDLE, 0);
+        vkDestroyObject(m_renderTargets.back()->image());
+        vkFreeMemory(m_renderTargets.back()->memory());
         m_renderTargets.pop_back();
     }
 
@@ -101,56 +101,56 @@
 
     // reset the driver
     delete m_device;
-    xglDestroyInstance(this->inst);
+    vkDestroyInstance(this->inst);
 }
 
 void XglRenderFramework::InitState()
 {
-    XGL_RESULT err;
+    VK_RESULT err;
 
-    m_render_target_fmt = XGL_FMT_B8G8R8A8_UNORM;
+    m_render_target_fmt = VK_FMT_B8G8R8A8_UNORM;
 
     // create a raster state (solid, back-face culling)
-    XGL_DYNAMIC_RS_STATE_CREATE_INFO raster = {};
-    raster.sType = XGL_STRUCTURE_TYPE_DYNAMIC_RS_STATE_CREATE_INFO;
+    VK_DYNAMIC_RS_STATE_CREATE_INFO raster = {};
+    raster.sType = VK_STRUCTURE_TYPE_DYNAMIC_RS_STATE_CREATE_INFO;
     raster.pointSize = 1.0;
 
-    err = xglCreateDynamicRasterState( device(), &raster, &m_stateRaster );
-    ASSERT_XGL_SUCCESS(err);
+    err = vkCreateDynamicRasterState( device(), &raster, &m_stateRaster );
+    ASSERT_VK_SUCCESS(err);
 
-    XGL_DYNAMIC_CB_STATE_CREATE_INFO blend = {};
-    blend.sType = XGL_STRUCTURE_TYPE_DYNAMIC_CB_STATE_CREATE_INFO;
-    err = xglCreateDynamicColorBlendState(device(), &blend, &m_colorBlend);
-    ASSERT_XGL_SUCCESS( err );
+    VK_DYNAMIC_CB_STATE_CREATE_INFO blend = {};
+    blend.sType = VK_STRUCTURE_TYPE_DYNAMIC_CB_STATE_CREATE_INFO;
+    err = vkCreateDynamicColorBlendState(device(), &blend, &m_colorBlend);
+    ASSERT_VK_SUCCESS( err );
 
-    XGL_DYNAMIC_DS_STATE_CREATE_INFO depthStencil = {};
-    depthStencil.sType = XGL_STRUCTURE_TYPE_DYNAMIC_DS_STATE_CREATE_INFO;
+    VK_DYNAMIC_DS_STATE_CREATE_INFO depthStencil = {};
+    depthStencil.sType = VK_STRUCTURE_TYPE_DYNAMIC_DS_STATE_CREATE_INFO;
     depthStencil.minDepth = 0.f;
     depthStencil.maxDepth = 1.f;
     depthStencil.stencilFrontRef = 0;
     depthStencil.stencilBackRef = 0;
 
-    err = xglCreateDynamicDepthStencilState( device(), &depthStencil, &m_stateDepthStencil );
-    ASSERT_XGL_SUCCESS( err );
+    err = vkCreateDynamicDepthStencilState( device(), &depthStencil, &m_stateDepthStencil );
+    ASSERT_VK_SUCCESS( err );
 
-    XGL_CMD_BUFFER_CREATE_INFO cmdInfo = {};
+    VK_CMD_BUFFER_CREATE_INFO cmdInfo = {};
 
-    cmdInfo.sType = XGL_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO;
+    cmdInfo.sType = VK_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO;
     cmdInfo.queueNodeIndex = m_device->graphics_queue_node_index_;
 
-    err = xglCreateCommandBuffer(device(), &cmdInfo, &m_cmdBuffer);
-    ASSERT_XGL_SUCCESS(err) << "xglCreateCommandBuffer failed";
+    err = vkCreateCommandBuffer(device(), &cmdInfo, &m_cmdBuffer);
+    ASSERT_VK_SUCCESS(err) << "vkCreateCommandBuffer failed";
 }
 
 void XglRenderFramework::InitViewport(float width, float height)
 {
-    XGL_RESULT err;
+    VK_RESULT err;
 
-    XGL_VIEWPORT viewport;
-    XGL_RECT scissor;
+    VK_VIEWPORT viewport;
+    VK_RECT scissor;
 
-    XGL_DYNAMIC_VP_STATE_CREATE_INFO viewportCreate = {};
-    viewportCreate.sType = XGL_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO;
+    VK_DYNAMIC_VP_STATE_CREATE_INFO viewportCreate = {};
+    viewportCreate.sType = VK_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO;
     viewportCreate.viewportAndScissorCount         = 1;
     viewport.originX  = 0;
     viewport.originY  = 0;
@@ -165,8 +165,8 @@
     viewportCreate.pViewports = &viewport;
     viewportCreate.pScissors = &scissor;
 
-    err = xglCreateDynamicViewportState( device(), &viewportCreate, &m_stateViewport );
-    ASSERT_XGL_SUCCESS( err );
+    err = vkCreateDynamicViewportState( device(), &viewportCreate, &m_stateViewport );
+    ASSERT_VK_SUCCESS( err );
     m_width = width;
     m_height = height;
 }
@@ -185,35 +185,35 @@
     InitRenderTarget(targets, NULL);
 }
 
-void XglRenderFramework::InitRenderTarget(XGL_DEPTH_STENCIL_BIND_INFO *dsBinding)
+void XglRenderFramework::InitRenderTarget(VK_DEPTH_STENCIL_BIND_INFO *dsBinding)
 {
     InitRenderTarget(1, dsBinding);
 }
 
-void XglRenderFramework::InitRenderTarget(uint32_t targets, XGL_DEPTH_STENCIL_BIND_INFO *dsBinding)
+void XglRenderFramework::InitRenderTarget(uint32_t targets, VK_DEPTH_STENCIL_BIND_INFO *dsBinding)
 {
-    std::vector<XGL_ATTACHMENT_LOAD_OP> load_ops;
-    std::vector<XGL_ATTACHMENT_STORE_OP> store_ops;
-    std::vector<XGL_CLEAR_COLOR> clear_colors;
+    std::vector<VK_ATTACHMENT_LOAD_OP> load_ops;
+    std::vector<VK_ATTACHMENT_STORE_OP> store_ops;
+    std::vector<VK_CLEAR_COLOR> clear_colors;
 
     uint32_t i;
 
     for (i = 0; i < targets; i++) {
         XglImage *img = new XglImage(m_device);
         img->init(m_width, m_height, m_render_target_fmt,
-                XGL_IMAGE_USAGE_SHADER_ACCESS_WRITE_BIT |
-                XGL_IMAGE_USAGE_COLOR_ATTACHMENT_BIT);
+                VK_IMAGE_USAGE_SHADER_ACCESS_WRITE_BIT |
+                VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT);
         m_colorBindings[i].view  = img->targetView();
-        m_colorBindings[i].layout = XGL_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
+        m_colorBindings[i].layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
         m_renderTargets.push_back(img);
-        load_ops.push_back(XGL_ATTACHMENT_LOAD_OP_LOAD);
-        store_ops.push_back(XGL_ATTACHMENT_STORE_OP_STORE);
+        load_ops.push_back(VK_ATTACHMENT_LOAD_OP_LOAD);
+        store_ops.push_back(VK_ATTACHMENT_STORE_OP_STORE);
         clear_colors.push_back(m_clear_color);
 //        m_mem_ref_mgr.AddMemoryRefs(*img);
     }
       // Create Framebuffer and RenderPass with color attachments and any depth/stencil attachment
-    XGL_FRAMEBUFFER_CREATE_INFO fb_info = {};
-    fb_info.sType = XGL_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
+    VK_FRAMEBUFFER_CREATE_INFO fb_info = {};
+    fb_info.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
     fb_info.pNext = NULL;
     fb_info.colorAttachmentCount = m_renderTargets.size();
     fb_info.pColorAttachments = m_colorBindings;
@@ -223,10 +223,10 @@
     fb_info.height = (uint32_t)m_height;
     fb_info.layers = 1;
 
-    xglCreateFramebuffer(device(), &fb_info, &m_framebuffer);
+    vkCreateFramebuffer(device(), &fb_info, &m_framebuffer);
 
-    XGL_RENDER_PASS_CREATE_INFO rp_info = {};
-    rp_info.sType = XGL_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
+    VK_RENDER_PASS_CREATE_INFO rp_info = {};
+    rp_info.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
     rp_info.renderArea.extent.width = m_width;
     rp_info.renderArea.extent.height = m_height;
 
@@ -240,19 +240,19 @@
     if (dsBinding) {
         rp_info.depthStencilLayout = dsBinding->layout;
     }
-    rp_info.depthLoadOp = XGL_ATTACHMENT_LOAD_OP_LOAD;
+    rp_info.depthLoadOp = VK_ATTACHMENT_LOAD_OP_LOAD;
     rp_info.depthLoadClearValue = m_depth_clear_color;
-    rp_info.depthStoreOp = XGL_ATTACHMENT_STORE_OP_STORE;
-    rp_info.stencilLoadOp = XGL_ATTACHMENT_LOAD_OP_LOAD;
+    rp_info.depthStoreOp = VK_ATTACHMENT_STORE_OP_STORE;
+    rp_info.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_LOAD;
     rp_info.stencilLoadClearValue = m_stencil_clear_color;
-    rp_info.stencilStoreOp = XGL_ATTACHMENT_STORE_OP_STORE;
-    xglCreateRenderPass(device(), &rp_info, &m_renderPass);
+    rp_info.stencilStoreOp = VK_ATTACHMENT_STORE_OP_STORE;
+    vkCreateRenderPass(device(), &rp_info, &m_renderPass);
 }
 
 
 
-XglDevice::XglDevice(uint32_t id, XGL_PHYSICAL_GPU obj) :
-    xgl_testing::Device(obj), id(id)
+XglDevice::XglDevice(uint32_t id, VK_PHYSICAL_GPU obj) :
+    vk_testing::Device(obj), id(id)
 {
     init();
 
@@ -281,22 +281,22 @@
 int XglDescriptorSetObj::AppendDummy()
 {
     /* request a descriptor but do not update it */
-    XGL_DESCRIPTOR_TYPE_COUNT tc = {};
-    tc.type = XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER;
+    VK_DESCRIPTOR_TYPE_COUNT tc = {};
+    tc.type = VK_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER;
     tc.count = 1;
     m_type_counts.push_back(tc);
 
     return m_nextSlot++;
 }
 
-int XglDescriptorSetObj::AppendBuffer(XGL_DESCRIPTOR_TYPE type, XglConstantBufferObj &constantBuffer)
+int XglDescriptorSetObj::AppendBuffer(VK_DESCRIPTOR_TYPE type, XglConstantBufferObj &constantBuffer)
 {
-    XGL_DESCRIPTOR_TYPE_COUNT tc = {};
+    VK_DESCRIPTOR_TYPE_COUNT tc = {};
     tc.type = type;
     tc.count = 1;
     m_type_counts.push_back(tc);
 
-    m_updateBuffers.push_back(xgl_testing::DescriptorSet::update(type,
+    m_updateBuffers.push_back(vk_testing::DescriptorSet::update(type,
                 m_nextSlot, 0, 1, &constantBuffer.m_bufferViewInfo));
 
     // Track mem references for this descriptor set object
@@ -307,18 +307,18 @@
 
 int XglDescriptorSetObj::AppendSamplerTexture( XglSamplerObj* sampler, XglTextureObj* texture)
 {
-    XGL_DESCRIPTOR_TYPE_COUNT tc = {};
-    tc.type = XGL_DESCRIPTOR_TYPE_SAMPLER_TEXTURE;
+    VK_DESCRIPTOR_TYPE_COUNT tc = {};
+    tc.type = VK_DESCRIPTOR_TYPE_SAMPLER_TEXTURE;
     tc.count = 1;
     m_type_counts.push_back(tc);
 
-    XGL_SAMPLER_IMAGE_VIEW_INFO tmp = {};
+    VK_SAMPLER_IMAGE_VIEW_INFO tmp = {};
     tmp.sampler = sampler->obj();
     tmp.pImageView = &texture->m_textureViewInfo;
     m_samplerTextureInfo.push_back(tmp);
 
-    m_updateSamplerTextures.push_back(xgl_testing::DescriptorSet::update(m_nextSlot, 0, 1,
-                (const XGL_SAMPLER_IMAGE_VIEW_INFO *) NULL));
+    m_updateSamplerTextures.push_back(vk_testing::DescriptorSet::update(m_nextSlot, 0, 1,
+                (const VK_SAMPLER_IMAGE_VIEW_INFO *) NULL));
 
     // Track mem references for the texture referenced here
     mem_ref_mgr.AddMemoryRefs(*texture);
@@ -326,49 +326,49 @@
     return m_nextSlot++;
 }
 
-XGL_DESCRIPTOR_SET_LAYOUT_CHAIN XglDescriptorSetObj::GetLayoutChain() const
+VK_DESCRIPTOR_SET_LAYOUT_CHAIN XglDescriptorSetObj::GetLayoutChain() const
 {
     return m_layout_chain.obj();
 }
 
-XGL_DESCRIPTOR_SET XglDescriptorSetObj::GetDescriptorSetHandle() const
+VK_DESCRIPTOR_SET XglDescriptorSetObj::GetDescriptorSetHandle() const
 {
     return m_set->obj();
 }
 
-void XglDescriptorSetObj::CreateXGLDescriptorSet(XglCommandBufferObj *cmdBuffer)
+void XglDescriptorSetObj::CreateVKDescriptorSet(XglCommandBufferObj *cmdBuffer)
 {
-    // create XGL_DESCRIPTOR_POOL
-    XGL_DESCRIPTOR_POOL_CREATE_INFO pool = {};
-    pool.sType = XGL_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
+    // create VK_DESCRIPTOR_POOL
+    VK_DESCRIPTOR_POOL_CREATE_INFO pool = {};
+    pool.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
     pool.count = m_type_counts.size();
     pool.pTypeCount = &m_type_counts[0];
-    init(*m_device, XGL_DESCRIPTOR_POOL_USAGE_ONE_SHOT, 1, pool);
+    init(*m_device, VK_DESCRIPTOR_POOL_USAGE_ONE_SHOT, 1, pool);
 
-    // create XGL_DESCRIPTOR_SET_LAYOUT
-    vector<XGL_DESCRIPTOR_SET_LAYOUT_BINDING> bindings;
+    // create VK_DESCRIPTOR_SET_LAYOUT
+    vector<VK_DESCRIPTOR_SET_LAYOUT_BINDING> bindings;
     bindings.resize(m_type_counts.size());
     for (int i = 0; i < m_type_counts.size(); i++) {
         bindings[i].descriptorType = m_type_counts[i].type;
         bindings[i].count = m_type_counts[i].count;
-        bindings[i].stageFlags = XGL_SHADER_STAGE_FLAGS_ALL;
+        bindings[i].stageFlags = VK_SHADER_STAGE_FLAGS_ALL;
         bindings[i].pImmutableSamplers = NULL;
     }
 
-    // create XGL_DESCRIPTOR_SET_LAYOUT
-    XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO layout = {};
-    layout.sType = XGL_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
+    // create VK_DESCRIPTOR_SET_LAYOUT
+    VK_DESCRIPTOR_SET_LAYOUT_CREATE_INFO layout = {};
+    layout.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
     layout.count = bindings.size();
     layout.pBinding = &bindings[0];
 
     m_layout.init(*m_device, layout);
 
-    vector<const xgl_testing::DescriptorSetLayout *> layouts;
+    vector<const vk_testing::DescriptorSetLayout *> layouts;
     layouts.push_back(&m_layout);
     m_layout_chain.init(*m_device, layouts);
 
-    // create XGL_DESCRIPTOR_SET
-    m_set = alloc_sets(XGL_DESCRIPTOR_SET_USAGE_STATIC, m_layout);
+    // create VK_DESCRIPTOR_SET
+    m_set = alloc_sets(VK_DESCRIPTOR_SET_USAGE_STATIC, m_layout);
 
     // build the update array
     vector<const void *> update_array;
@@ -382,7 +382,7 @@
     }
 
     // do the updates
-    m_device->begin_descriptor_pool_update(XGL_DESCRIPTOR_UPDATE_MODE_FASTEST);
+    m_device->begin_descriptor_pool_update(VK_DESCRIPTOR_UPDATE_MODE_FASTEST);
     clear_sets(*m_set);
     m_set->update(update_array);
     m_device->end_descriptor_pool_update(*cmdBuffer);
@@ -391,95 +391,95 @@
 XglImage::XglImage(XglDevice *dev)
 {
     m_device = dev;
-    m_imageInfo.view = XGL_NULL_HANDLE;
-    m_imageInfo.layout = XGL_IMAGE_LAYOUT_GENERAL;
+    m_imageInfo.view = VK_NULL_HANDLE;
+    m_imageInfo.layout = VK_IMAGE_LAYOUT_GENERAL;
 }
 
 void XglImage::ImageMemoryBarrier(
         XglCommandBufferObj *cmd_buf,
-        XGL_IMAGE_ASPECT aspect,
-        XGL_FLAGS output_mask /*=
-            XGL_MEMORY_OUTPUT_CPU_WRITE_BIT |
-            XGL_MEMORY_OUTPUT_SHADER_WRITE_BIT |
-            XGL_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT |
-            XGL_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT |
-            XGL_MEMORY_OUTPUT_COPY_BIT*/,
-        XGL_FLAGS input_mask /*=
-            XGL_MEMORY_INPUT_CPU_READ_BIT |
-            XGL_MEMORY_INPUT_INDIRECT_COMMAND_BIT |
-            XGL_MEMORY_INPUT_INDEX_FETCH_BIT |
-            XGL_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT |
-            XGL_MEMORY_INPUT_UNIFORM_READ_BIT |
-            XGL_MEMORY_INPUT_SHADER_READ_BIT |
-            XGL_MEMORY_INPUT_COLOR_ATTACHMENT_BIT |
-            XGL_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT |
-            XGL_MEMORY_INPUT_COPY_BIT*/,
-        XGL_IMAGE_LAYOUT image_layout)
+        VK_IMAGE_ASPECT aspect,
+        VK_FLAGS output_mask /*=
+            VK_MEMORY_OUTPUT_CPU_WRITE_BIT |
+            VK_MEMORY_OUTPUT_SHADER_WRITE_BIT |
+            VK_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT |
+            VK_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT |
+            VK_MEMORY_OUTPUT_COPY_BIT*/,
+        VK_FLAGS input_mask /*=
+            VK_MEMORY_INPUT_CPU_READ_BIT |
+            VK_MEMORY_INPUT_INDIRECT_COMMAND_BIT |
+            VK_MEMORY_INPUT_INDEX_FETCH_BIT |
+            VK_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT |
+            VK_MEMORY_INPUT_UNIFORM_READ_BIT |
+            VK_MEMORY_INPUT_SHADER_READ_BIT |
+            VK_MEMORY_INPUT_COLOR_ATTACHMENT_BIT |
+            VK_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT |
+            VK_MEMORY_INPUT_COPY_BIT*/,
+        VK_IMAGE_LAYOUT image_layout)
 {
-    const XGL_IMAGE_SUBRESOURCE_RANGE subresourceRange = subresource_range(aspect, 0, 1, 0, 1);
-    XGL_IMAGE_MEMORY_BARRIER barrier;
+    const VK_IMAGE_SUBRESOURCE_RANGE subresourceRange = subresource_range(aspect, 0, 1, 0, 1);
+    VK_IMAGE_MEMORY_BARRIER barrier;
     barrier = image_memory_barrier(output_mask, input_mask, layout(), image_layout,
                                    subresourceRange);
 
-    XGL_IMAGE_MEMORY_BARRIER *pmemory_barrier = &barrier;
+    VK_IMAGE_MEMORY_BARRIER *pmemory_barrier = &barrier;
 
-    XGL_PIPE_EVENT pipe_events[] = { XGL_PIPE_EVENT_GPU_COMMANDS_COMPLETE };
-    XGL_PIPELINE_BARRIER pipeline_barrier = {};
-    pipeline_barrier.sType = XGL_STRUCTURE_TYPE_PIPELINE_BARRIER;
+    VK_PIPE_EVENT pipe_events[] = { VK_PIPE_EVENT_GPU_COMMANDS_COMPLETE };
+    VK_PIPELINE_BARRIER pipeline_barrier = {};
+    pipeline_barrier.sType = VK_STRUCTURE_TYPE_PIPELINE_BARRIER;
     pipeline_barrier.pNext = NULL;
     pipeline_barrier.eventCount = 1;
     pipeline_barrier.pEvents = pipe_events;
-    pipeline_barrier.waitEvent = XGL_WAIT_EVENT_TOP_OF_PIPE;
+    pipeline_barrier.waitEvent = VK_WAIT_EVENT_TOP_OF_PIPE;
     pipeline_barrier.memBarrierCount = 1;
     pipeline_barrier.ppMemBarriers = (const void **)&pmemory_barrier;
 
     // write barrier to the command buffer
-    xglCmdPipelineBarrier(cmd_buf->obj(), &pipeline_barrier);
+    vkCmdPipelineBarrier(cmd_buf->obj(), &pipeline_barrier);
 }
 
 void XglImage::SetLayout(XglCommandBufferObj *cmd_buf,
-                         XGL_IMAGE_ASPECT aspect,
-                         XGL_IMAGE_LAYOUT image_layout)
+                         VK_IMAGE_ASPECT aspect,
+                         VK_IMAGE_LAYOUT image_layout)
 {
-    XGL_FLAGS output_mask, input_mask;
-    const XGL_FLAGS all_cache_outputs =
-            XGL_MEMORY_OUTPUT_CPU_WRITE_BIT |
-            XGL_MEMORY_OUTPUT_SHADER_WRITE_BIT |
-            XGL_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT |
-            XGL_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT |
-            XGL_MEMORY_OUTPUT_COPY_BIT;
-    const XGL_FLAGS all_cache_inputs =
-            XGL_MEMORY_INPUT_CPU_READ_BIT |
-            XGL_MEMORY_INPUT_INDIRECT_COMMAND_BIT |
-            XGL_MEMORY_INPUT_INDEX_FETCH_BIT |
-            XGL_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT |
-            XGL_MEMORY_INPUT_UNIFORM_READ_BIT |
-            XGL_MEMORY_INPUT_SHADER_READ_BIT |
-            XGL_MEMORY_INPUT_COLOR_ATTACHMENT_BIT |
-            XGL_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT |
-            XGL_MEMORY_INPUT_COPY_BIT;
+    VK_FLAGS output_mask, input_mask;
+    const VK_FLAGS all_cache_outputs =
+            VK_MEMORY_OUTPUT_CPU_WRITE_BIT |
+            VK_MEMORY_OUTPUT_SHADER_WRITE_BIT |
+            VK_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT |
+            VK_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT |
+            VK_MEMORY_OUTPUT_COPY_BIT;
+    const VK_FLAGS all_cache_inputs =
+            VK_MEMORY_INPUT_CPU_READ_BIT |
+            VK_MEMORY_INPUT_INDIRECT_COMMAND_BIT |
+            VK_MEMORY_INPUT_INDEX_FETCH_BIT |
+            VK_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT |
+            VK_MEMORY_INPUT_UNIFORM_READ_BIT |
+            VK_MEMORY_INPUT_SHADER_READ_BIT |
+            VK_MEMORY_INPUT_COLOR_ATTACHMENT_BIT |
+            VK_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT |
+            VK_MEMORY_INPUT_COPY_BIT;
 
     if (image_layout == m_imageInfo.layout) {
         return;
     }
 
     switch (image_layout) {
-    case XGL_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL:
-        output_mask = XGL_MEMORY_OUTPUT_COPY_BIT;
-        input_mask = XGL_MEMORY_INPUT_SHADER_READ_BIT | XGL_MEMORY_INPUT_COPY_BIT;
+    case VK_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL:
+        output_mask = VK_MEMORY_OUTPUT_COPY_BIT;
+        input_mask = VK_MEMORY_INPUT_SHADER_READ_BIT | VK_MEMORY_INPUT_COPY_BIT;
         break;
 
-    case XGL_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL:
-        output_mask = XGL_MEMORY_OUTPUT_COPY_BIT;
-        input_mask = XGL_MEMORY_INPUT_SHADER_READ_BIT | XGL_MEMORY_INPUT_COPY_BIT;
+    case VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL:
+        output_mask = VK_MEMORY_OUTPUT_COPY_BIT;
+        input_mask = VK_MEMORY_INPUT_SHADER_READ_BIT | VK_MEMORY_INPUT_COPY_BIT;
         break;
 
-    case XGL_IMAGE_LAYOUT_CLEAR_OPTIMAL:
+    case VK_IMAGE_LAYOUT_CLEAR_OPTIMAL:
         break;
 
-    case XGL_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL:
-        output_mask = XGL_MEMORY_OUTPUT_COPY_BIT;
-        input_mask = XGL_MEMORY_INPUT_SHADER_READ_BIT | XGL_MEMORY_INPUT_COPY_BIT;
+    case VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL:
+        output_mask = VK_MEMORY_OUTPUT_COPY_BIT;
+        input_mask = VK_MEMORY_INPUT_SHADER_READ_BIT | VK_MEMORY_INPUT_COPY_BIT;
         break;
 
     default:
@@ -492,10 +492,10 @@
     m_imageInfo.layout = image_layout;
 }
 
-void XglImage::SetLayout(XGL_IMAGE_ASPECT aspect,
-                         XGL_IMAGE_LAYOUT image_layout)
+void XglImage::SetLayout(VK_IMAGE_ASPECT aspect,
+                         VK_IMAGE_LAYOUT image_layout)
 {
-    XGL_RESULT err;
+    VK_RESULT err;
     XglCommandBufferObj cmd_buf(m_device);
 
     /* Build command buffer to set image layout in the driver */
@@ -510,27 +510,27 @@
     cmd_buf.QueueCommandBuffer();
 }
 
-bool XglImage::IsCompatible(XGL_FLAGS usage, XGL_FLAGS features)
+bool XglImage::IsCompatible(VK_FLAGS usage, VK_FLAGS features)
 {
-    if ((usage & XGL_IMAGE_USAGE_SHADER_ACCESS_READ_BIT) &&
-            !(features & XGL_FORMAT_IMAGE_SHADER_READ_BIT))
+    if ((usage & VK_IMAGE_USAGE_SHADER_ACCESS_READ_BIT) &&
+            !(features & VK_FORMAT_IMAGE_SHADER_READ_BIT))
         return false;
 
-    if ((usage & XGL_IMAGE_USAGE_SHADER_ACCESS_WRITE_BIT) &&
-            !(features & XGL_FORMAT_IMAGE_SHADER_WRITE_BIT))
+    if ((usage & VK_IMAGE_USAGE_SHADER_ACCESS_WRITE_BIT) &&
+            !(features & VK_FORMAT_IMAGE_SHADER_WRITE_BIT))
         return false;
 
     return true;
 }
 
 void XglImage::init(uint32_t w, uint32_t h,
-               XGL_FORMAT fmt, XGL_FLAGS usage,
-               XGL_IMAGE_TILING requested_tiling)
+               VK_FORMAT fmt, VK_FLAGS usage,
+               VK_IMAGE_TILING requested_tiling)
 {
     uint32_t mipCount;
-    XGL_FORMAT_PROPERTIES image_fmt;
-    XGL_IMAGE_TILING tiling;
-    XGL_RESULT err;
+    VK_FORMAT_PROPERTIES image_fmt;
+    VK_IMAGE_TILING tiling;
+    VK_RESULT err;
     size_t size;
 
     mipCount = 0;
@@ -545,29 +545,29 @@
     }
 
     size = sizeof(image_fmt);
-    err = xglGetFormatInfo(m_device->obj(), fmt,
-        XGL_INFO_TYPE_FORMAT_PROPERTIES,
+    err = vkGetFormatInfo(m_device->obj(), fmt,
+        VK_INFO_TYPE_FORMAT_PROPERTIES,
         &size, &image_fmt);
-    ASSERT_XGL_SUCCESS(err);
+    ASSERT_VK_SUCCESS(err);
 
-    if (requested_tiling == XGL_LINEAR_TILING) {
+    if (requested_tiling == VK_LINEAR_TILING) {
         if (IsCompatible(usage, image_fmt.linearTilingFeatures)) {
-            tiling = XGL_LINEAR_TILING;
+            tiling = VK_LINEAR_TILING;
         } else if (IsCompatible(usage, image_fmt.optimalTilingFeatures)) {
-            tiling = XGL_OPTIMAL_TILING;
+            tiling = VK_OPTIMAL_TILING;
         } else {
             ASSERT_TRUE(false) << "Error: Cannot find requested tiling configuration";
         }
     } else if (IsCompatible(usage, image_fmt.optimalTilingFeatures)) {
-        tiling = XGL_OPTIMAL_TILING;
+        tiling = VK_OPTIMAL_TILING;
     } else if (IsCompatible(usage, image_fmt.linearTilingFeatures)) {
-        tiling = XGL_LINEAR_TILING;
+        tiling = VK_LINEAR_TILING;
     } else {
          ASSERT_TRUE(false) << "Error: Cannot find requested tiling configuration";
     }
 
-    XGL_IMAGE_CREATE_INFO imageCreateInfo = xgl_testing::Image::create_info();
-    imageCreateInfo.imageType = XGL_IMAGE_2D;
+    VK_IMAGE_CREATE_INFO imageCreateInfo = vk_testing::Image::create_info();
+    imageCreateInfo.imageType = VK_IMAGE_2D;
     imageCreateInfo.format = fmt;
     imageCreateInfo.extent.width = w;
     imageCreateInfo.extent.height = h;
@@ -576,32 +576,32 @@
 
     imageCreateInfo.usage = usage;
 
-    xgl_testing::Image::init(*m_device, imageCreateInfo);
+    vk_testing::Image::init(*m_device, imageCreateInfo);
 
-    if (usage & XGL_IMAGE_USAGE_SHADER_ACCESS_READ_BIT) {
-        SetLayout(XGL_IMAGE_ASPECT_COLOR, XGL_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
+    if (usage & VK_IMAGE_USAGE_SHADER_ACCESS_READ_BIT) {
+        SetLayout(VK_IMAGE_ASPECT_COLOR, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
     } else {
-        SetLayout(XGL_IMAGE_ASPECT_COLOR, XGL_IMAGE_LAYOUT_GENERAL);
+        SetLayout(VK_IMAGE_ASPECT_COLOR, VK_IMAGE_LAYOUT_GENERAL);
     }
 }
 
-XGL_RESULT XglImage::MapMemory(void** ptr)
+VK_RESULT XglImage::MapMemory(void** ptr)
 {
     *ptr = map();
-    return (*ptr) ? XGL_SUCCESS : XGL_ERROR_UNKNOWN;
+    return (*ptr) ? VK_SUCCESS : VK_ERROR_UNKNOWN;
 }
 
-XGL_RESULT XglImage::UnmapMemory()
+VK_RESULT XglImage::UnmapMemory()
 {
     unmap();
-    return XGL_SUCCESS;
+    return VK_SUCCESS;
 }
 
-XGL_RESULT XglImage::CopyImage(XglImage &src_image)
+VK_RESULT XglImage::CopyImage(XglImage &src_image)
 {
-    XGL_RESULT err;
+    VK_RESULT err;
     XglCommandBufferObj cmd_buf(m_device);
-    XGL_IMAGE_LAYOUT src_image_layout, dest_image_layout;
+    VK_IMAGE_LAYOUT src_image_layout, dest_image_layout;
 
     /* Build command buffer to copy staging texture to usable texture */
     err = cmd_buf.BeginCommandBuffer();
@@ -609,19 +609,19 @@
 
     /* TODO: Can we determine image aspect from image object? */
     src_image_layout = src_image.layout();
-    src_image.SetLayout(&cmd_buf, XGL_IMAGE_ASPECT_COLOR, XGL_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL);
+    src_image.SetLayout(&cmd_buf, VK_IMAGE_ASPECT_COLOR, VK_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL);
 
     dest_image_layout = this->layout();
-    this->SetLayout(&cmd_buf, XGL_IMAGE_ASPECT_COLOR, XGL_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL);
+    this->SetLayout(&cmd_buf, VK_IMAGE_ASPECT_COLOR, VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL);
 
-    XGL_IMAGE_COPY copy_region = {};
-    copy_region.srcSubresource.aspect = XGL_IMAGE_ASPECT_COLOR;
+    VK_IMAGE_COPY copy_region = {};
+    copy_region.srcSubresource.aspect = VK_IMAGE_ASPECT_COLOR;
     copy_region.srcSubresource.arraySlice = 0;
     copy_region.srcSubresource.mipLevel = 0;
     copy_region.srcOffset.x = 0;
     copy_region.srcOffset.y = 0;
     copy_region.srcOffset.z = 0;
-    copy_region.destSubresource.aspect = XGL_IMAGE_ASPECT_COLOR;
+    copy_region.destSubresource.aspect = VK_IMAGE_ASPECT_COLOR;
     copy_region.destSubresource.arraySlice = 0;
     copy_region.destSubresource.mipLevel = 0;
     copy_region.destOffset.x = 0;
@@ -629,56 +629,56 @@
     copy_region.destOffset.z = 0;
     copy_region.extent = src_image.extent();
 
-    xglCmdCopyImage(cmd_buf.obj(),
+    vkCmdCopyImage(cmd_buf.obj(),
                     src_image.obj(), src_image.layout(),
                     obj(), layout(),
                     1, &copy_region);
     cmd_buf.mem_ref_mgr.AddMemoryRefs(src_image);
     cmd_buf.mem_ref_mgr.AddMemoryRefs(*this);
 
-    src_image.SetLayout(&cmd_buf, XGL_IMAGE_ASPECT_COLOR, src_image_layout);
+    src_image.SetLayout(&cmd_buf, VK_IMAGE_ASPECT_COLOR, src_image_layout);
 
-    this->SetLayout(&cmd_buf, XGL_IMAGE_ASPECT_COLOR, dest_image_layout);
+    this->SetLayout(&cmd_buf, VK_IMAGE_ASPECT_COLOR, dest_image_layout);
 
     err = cmd_buf.EndCommandBuffer();
     assert(!err);
 
     cmd_buf.QueueCommandBuffer();
 
-    return XGL_SUCCESS;
+    return VK_SUCCESS;
 }
 
 XglTextureObj::XglTextureObj(XglDevice *device, uint32_t *colors)
     :XglImage(device)
 {
     m_device = device;
-    const XGL_FORMAT tex_format = XGL_FMT_B8G8R8A8_UNORM;
+    const VK_FORMAT tex_format = VK_FMT_B8G8R8A8_UNORM;
     uint32_t tex_colors[2] = { 0xffff0000, 0xff00ff00 };
     void *data;
     int32_t x, y;
     XglImage stagingImage(device);
 
-    stagingImage.init(16, 16, tex_format, 0, XGL_LINEAR_TILING);
-    XGL_SUBRESOURCE_LAYOUT layout = stagingImage.subresource_layout(subresource(XGL_IMAGE_ASPECT_COLOR, 0, 0));
+    stagingImage.init(16, 16, tex_format, 0, VK_LINEAR_TILING);
+    VK_SUBRESOURCE_LAYOUT layout = stagingImage.subresource_layout(subresource(VK_IMAGE_ASPECT_COLOR, 0, 0));
 
     if (colors == NULL)
         colors = tex_colors;
 
     memset(&m_textureViewInfo,0,sizeof(m_textureViewInfo));
 
-    m_textureViewInfo.sType = XGL_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO;
+    m_textureViewInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO;
 
-    XGL_IMAGE_VIEW_CREATE_INFO view = {};
-    view.sType = XGL_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
+    VK_IMAGE_VIEW_CREATE_INFO view = {};
+    view.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
     view.pNext = NULL;
-    view.image = XGL_NULL_HANDLE;
-    view.viewType = XGL_IMAGE_VIEW_2D;
+    view.image = VK_NULL_HANDLE;
+    view.viewType = VK_IMAGE_VIEW_2D;
     view.format = tex_format;
-    view.channels.r = XGL_CHANNEL_SWIZZLE_R;
-    view.channels.g = XGL_CHANNEL_SWIZZLE_G;
-    view.channels.b = XGL_CHANNEL_SWIZZLE_B;
-    view.channels.a = XGL_CHANNEL_SWIZZLE_A;
-    view.subresourceRange.aspect = XGL_IMAGE_ASPECT_COLOR;
+    view.channels.r = VK_CHANNEL_SWIZZLE_R;
+    view.channels.g = VK_CHANNEL_SWIZZLE_G;
+    view.channels.b = VK_CHANNEL_SWIZZLE_B;
+    view.channels.a = VK_CHANNEL_SWIZZLE_A;
+    view.subresourceRange.aspect = VK_IMAGE_ASPECT_COLOR;
     view.subresourceRange.baseMipLevel = 0;
     view.subresourceRange.mipLevels = 1;
     view.subresourceRange.baseArraySlice = 0;
@@ -686,7 +686,7 @@
     view.minLod = 0.0f;
 
     /* create image */
-    init(16, 16, tex_format, XGL_IMAGE_USAGE_SHADER_ACCESS_READ_BIT, XGL_OPTIMAL_TILING);
+    init(16, 16, tex_format, VK_IMAGE_USAGE_SHADER_ACCESS_READ_BIT, VK_OPTIMAL_TILING);
 
     /* create image view */
     view.image = obj();
@@ -708,21 +708,21 @@
 {
     m_device = device;
 
-    XGL_SAMPLER_CREATE_INFO samplerCreateInfo;
+    VK_SAMPLER_CREATE_INFO samplerCreateInfo;
     memset(&samplerCreateInfo,0,sizeof(samplerCreateInfo));
-    samplerCreateInfo.sType = XGL_STRUCTURE_TYPE_SAMPLER_CREATE_INFO;
-    samplerCreateInfo.magFilter = XGL_TEX_FILTER_NEAREST;
-    samplerCreateInfo.minFilter = XGL_TEX_FILTER_NEAREST;
-    samplerCreateInfo.mipMode = XGL_TEX_MIPMAP_BASE;
-    samplerCreateInfo.addressU = XGL_TEX_ADDRESS_WRAP;
-    samplerCreateInfo.addressV = XGL_TEX_ADDRESS_WRAP;
-    samplerCreateInfo.addressW = XGL_TEX_ADDRESS_WRAP;
+    samplerCreateInfo.sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO;
+    samplerCreateInfo.magFilter = VK_TEX_FILTER_NEAREST;
+    samplerCreateInfo.minFilter = VK_TEX_FILTER_NEAREST;
+    samplerCreateInfo.mipMode = VK_TEX_MIPMAP_BASE;
+    samplerCreateInfo.addressU = VK_TEX_ADDRESS_WRAP;
+    samplerCreateInfo.addressV = VK_TEX_ADDRESS_WRAP;
+    samplerCreateInfo.addressW = VK_TEX_ADDRESS_WRAP;
     samplerCreateInfo.mipLodBias = 0.0;
     samplerCreateInfo.maxAnisotropy = 0.0;
-    samplerCreateInfo.compareFunc = XGL_COMPARE_NEVER;
+    samplerCreateInfo.compareFunc = VK_COMPARE_NEVER;
     samplerCreateInfo.minLod = 0.0;
     samplerCreateInfo.maxLod = 0.0;
-    samplerCreateInfo.borderColorType = XGL_BORDER_COLOR_OPAQUE_WHITE;
+    samplerCreateInfo.borderColorType = VK_BORDER_COLOR_OPAQUE_WHITE;
 
     init(*m_device, samplerCreateInfo);
 }
@@ -763,47 +763,47 @@
     unmap();
 
     // set up the buffer view for the constant buffer
-    XGL_BUFFER_VIEW_CREATE_INFO view_info = {};
-    view_info.sType = XGL_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO;
+    VK_BUFFER_VIEW_CREATE_INFO view_info = {};
+    view_info.sType = VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO;
     view_info.buffer = obj();
-    view_info.viewType = XGL_BUFFER_VIEW_RAW;
+    view_info.viewType = VK_BUFFER_VIEW_RAW;
     view_info.offset = 0;
     view_info.range  = allocationSize;
     m_bufferView.init(*m_device, view_info);
 
-    this->m_bufferViewInfo.sType = XGL_STRUCTURE_TYPE_BUFFER_VIEW_ATTACH_INFO;
+    this->m_bufferViewInfo.sType = VK_STRUCTURE_TYPE_BUFFER_VIEW_ATTACH_INFO;
     this->m_bufferViewInfo.view = m_bufferView.obj();
 }
 
-void XglConstantBufferObj::Bind(XGL_CMD_BUFFER cmdBuffer, XGL_GPU_SIZE offset, uint32_t binding)
+void XglConstantBufferObj::Bind(VK_CMD_BUFFER cmdBuffer, VK_GPU_SIZE offset, uint32_t binding)
 {
-    xglCmdBindVertexBuffer(cmdBuffer, obj(), offset, binding);
+    vkCmdBindVertexBuffer(cmdBuffer, obj(), offset, binding);
 }
 
 
 void XglConstantBufferObj::BufferMemoryBarrier(
-        XGL_FLAGS outputMask /*=
-            XGL_MEMORY_OUTPUT_CPU_WRITE_BIT |
-            XGL_MEMORY_OUTPUT_SHADER_WRITE_BIT |
-            XGL_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT |
-            XGL_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT |
-            XGL_MEMORY_OUTPUT_COPY_BIT*/,
-        XGL_FLAGS inputMask /*=
-            XGL_MEMORY_INPUT_CPU_READ_BIT |
-            XGL_MEMORY_INPUT_INDIRECT_COMMAND_BIT |
-            XGL_MEMORY_INPUT_INDEX_FETCH_BIT |
-            XGL_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT |
-            XGL_MEMORY_INPUT_UNIFORM_READ_BIT |
-            XGL_MEMORY_INPUT_SHADER_READ_BIT |
-            XGL_MEMORY_INPUT_COLOR_ATTACHMENT_BIT |
-            XGL_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT |
-            XGL_MEMORY_INPUT_COPY_BIT*/)
+        VK_FLAGS outputMask /*=
+            VK_MEMORY_OUTPUT_CPU_WRITE_BIT |
+            VK_MEMORY_OUTPUT_SHADER_WRITE_BIT |
+            VK_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT |
+            VK_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT |
+            VK_MEMORY_OUTPUT_COPY_BIT*/,
+        VK_FLAGS inputMask /*=
+            VK_MEMORY_INPUT_CPU_READ_BIT |
+            VK_MEMORY_INPUT_INDIRECT_COMMAND_BIT |
+            VK_MEMORY_INPUT_INDEX_FETCH_BIT |
+            VK_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT |
+            VK_MEMORY_INPUT_UNIFORM_READ_BIT |
+            VK_MEMORY_INPUT_SHADER_READ_BIT |
+            VK_MEMORY_INPUT_COLOR_ATTACHMENT_BIT |
+            VK_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT |
+            VK_MEMORY_INPUT_COPY_BIT*/)
 {
-    XGL_RESULT err = XGL_SUCCESS;
+    VK_RESULT err = VK_SUCCESS;
 
     if (!m_commandBuffer)
     {
-        m_fence.init(*m_device, xgl_testing::Fence::create_info());
+        m_fence.init(*m_device, vk_testing::Fence::create_info());
 
         m_commandBuffer = new XglCommandBufferObj(m_device);
     }
@@ -814,24 +814,24 @@
     }
 
     // open the command buffer
-    XGL_CMD_BUFFER_BEGIN_INFO cmd_buf_info = {};
-    cmd_buf_info.sType = XGL_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO;
+    VK_CMD_BUFFER_BEGIN_INFO cmd_buf_info = {};
+    cmd_buf_info.sType = VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO;
     cmd_buf_info.pNext = NULL;
     cmd_buf_info.flags = 0;
 
     err = m_commandBuffer->BeginCommandBuffer(&cmd_buf_info);
-    ASSERT_XGL_SUCCESS(err);
+    ASSERT_VK_SUCCESS(err);
 
-    XGL_BUFFER_MEMORY_BARRIER memory_barrier =
+    VK_BUFFER_MEMORY_BARRIER memory_barrier =
         buffer_memory_barrier(outputMask, inputMask, 0, m_numVertices * m_stride);
-    XGL_BUFFER_MEMORY_BARRIER *pmemory_barrier = &memory_barrier;
+    VK_BUFFER_MEMORY_BARRIER *pmemory_barrier = &memory_barrier;
 
-    XGL_PIPE_EVENT set_events[] = { XGL_PIPE_EVENT_GPU_COMMANDS_COMPLETE };
-    XGL_PIPELINE_BARRIER pipeline_barrier = {};
-    pipeline_barrier.sType = XGL_STRUCTURE_TYPE_PIPELINE_BARRIER;
+    VK_PIPE_EVENT set_events[] = { VK_PIPE_EVENT_GPU_COMMANDS_COMPLETE };
+    VK_PIPELINE_BARRIER pipeline_barrier = {};
+    pipeline_barrier.sType = VK_STRUCTURE_TYPE_PIPELINE_BARRIER;
     pipeline_barrier.eventCount = 1;
     pipeline_barrier.pEvents = set_events;
-    pipeline_barrier.waitEvent = XGL_WAIT_EVENT_TOP_OF_PIPE;
+    pipeline_barrier.waitEvent = VK_WAIT_EVENT_TOP_OF_PIPE;
     pipeline_barrier.memBarrierCount = 1;
     pipeline_barrier.ppMemBarriers = (const void **)&pmemory_barrier;
 
@@ -840,7 +840,7 @@
 
     // finish recording the command buffer
     err = m_commandBuffer->EndCommandBuffer();
-    ASSERT_XGL_SUCCESS(err);
+    ASSERT_VK_SUCCESS(err);
 
     /*
      * Tell driver about memory references made in this command buffer
@@ -850,10 +850,10 @@
     m_commandBuffer->mem_ref_mgr.EmitAddMemoryRefs(m_device->m_queue);
 
     // submit the command buffer to the universal queue
-    XGL_CMD_BUFFER bufferArray[1];
+    VK_CMD_BUFFER bufferArray[1];
     bufferArray[0] = m_commandBuffer->GetBufferHandle();
-    err = xglQueueSubmit( m_device->m_queue, 1, bufferArray, m_fence.obj() );
-    ASSERT_XGL_SUCCESS(err);
+    err = vkQueueSubmit( m_device->m_queue, 1, bufferArray, m_fence.obj() );
+    ASSERT_VK_SUCCESS(err);
 }
 
 XglIndexBufferObj::XglIndexBufferObj(XglDevice *device)
@@ -862,24 +862,24 @@
 
 }
 
-void XglIndexBufferObj::CreateAndInitBuffer(int numIndexes, XGL_INDEX_TYPE indexType, const void* data)
+void XglIndexBufferObj::CreateAndInitBuffer(int numIndexes, VK_INDEX_TYPE indexType, const void* data)
 {
-    XGL_FORMAT viewFormat;
+    VK_FORMAT viewFormat;
 
     m_numVertices = numIndexes;
     m_indexType = indexType;
     switch (indexType) {
-    case XGL_INDEX_8:
+    case VK_INDEX_8:
         m_stride = 1;
-        viewFormat = XGL_FMT_R8_UINT;
+        viewFormat = VK_FMT_R8_UINT;
         break;
-    case XGL_INDEX_16:
+    case VK_INDEX_16:
         m_stride = 2;
-        viewFormat = XGL_FMT_R16_UINT;
+        viewFormat = VK_FMT_R16_UINT;
         break;
-    case XGL_INDEX_32:
+    case VK_INDEX_32:
         m_stride = 4;
-        viewFormat = XGL_FMT_R32_UINT;
+        viewFormat = VK_FMT_R32_UINT;
         break;
     default:
         assert(!"unknown index type");
@@ -894,52 +894,52 @@
     unmap();
 
     // set up the buffer view for the constant buffer
-    XGL_BUFFER_VIEW_CREATE_INFO view_info = {};
-    view_info.sType = XGL_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO;
+    VK_BUFFER_VIEW_CREATE_INFO view_info = {};
+    view_info.sType = VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO;
     view_info.buffer = obj();
-    view_info.viewType = XGL_BUFFER_VIEW_TYPED;
+    view_info.viewType = VK_BUFFER_VIEW_TYPED;
     view_info.format = viewFormat;
     view_info.offset = 0;
     view_info.range  = allocationSize;
     m_bufferView.init(*m_device, view_info);
 
-    this->m_bufferViewInfo.sType = XGL_STRUCTURE_TYPE_BUFFER_VIEW_ATTACH_INFO;
+    this->m_bufferViewInfo.sType = VK_STRUCTURE_TYPE_BUFFER_VIEW_ATTACH_INFO;
     this->m_bufferViewInfo.view = m_bufferView.obj();
 }
 
-void XglIndexBufferObj::Bind(XGL_CMD_BUFFER cmdBuffer, XGL_GPU_SIZE offset)
+void XglIndexBufferObj::Bind(VK_CMD_BUFFER cmdBuffer, VK_GPU_SIZE offset)
 {
-    xglCmdBindIndexBuffer(cmdBuffer, obj(), offset, m_indexType);
+    vkCmdBindIndexBuffer(cmdBuffer, obj(), offset, m_indexType);
 }
 
-XGL_INDEX_TYPE XglIndexBufferObj::GetIndexType()
+VK_INDEX_TYPE XglIndexBufferObj::GetIndexType()
 {
     return m_indexType;
 }
 
-XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* XglShaderObj::GetStageCreateInfo()
+VK_PIPELINE_SHADER_STAGE_CREATE_INFO* XglShaderObj::GetStageCreateInfo()
 {
-    XGL_PIPELINE_SHADER_STAGE_CREATE_INFO *stageInfo = (XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*) calloc( 1,sizeof(XGL_PIPELINE_SHADER_STAGE_CREATE_INFO) );
-    stageInfo->sType = XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
+    VK_PIPELINE_SHADER_STAGE_CREATE_INFO *stageInfo = (VK_PIPELINE_SHADER_STAGE_CREATE_INFO*) calloc( 1,sizeof(VK_PIPELINE_SHADER_STAGE_CREATE_INFO) );
+    stageInfo->sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
     stageInfo->shader.stage = m_stage;
     stageInfo->shader.shader = obj();
     stageInfo->shader.linkConstBufferCount = 0;
-    stageInfo->shader.pLinkConstBufferInfo = XGL_NULL_HANDLE;
+    stageInfo->shader.pLinkConstBufferInfo = VK_NULL_HANDLE;
 
     return stageInfo;
 }
 
-XglShaderObj::XglShaderObj(XglDevice *device, const char * shader_code, XGL_PIPELINE_SHADER_STAGE stage, XglRenderFramework *framework)
+XglShaderObj::XglShaderObj(XglDevice *device, const char * shader_code, VK_PIPELINE_SHADER_STAGE stage, XglRenderFramework *framework)
 {
-    XGL_RESULT err = XGL_SUCCESS;
+    VK_RESULT err = VK_SUCCESS;
     std::vector<unsigned int> spv;
-    XGL_SHADER_CREATE_INFO createInfo;
+    VK_SHADER_CREATE_INFO createInfo;
     size_t shader_len;
 
     m_stage = stage;
     m_device = device;
 
-    createInfo.sType = XGL_STRUCTURE_TYPE_SHADER_CREATE_INFO;
+    createInfo.sType = VK_STRUCTURE_TYPE_SHADER_CREATE_INFO;
     createInfo.pNext = NULL;
 
     if (!framework->m_use_spv) {
@@ -949,7 +949,7 @@
         createInfo.pCode = malloc(createInfo.codeSize);
         createInfo.flags = 0;
 
-        /* try version 0 first: XGL_PIPELINE_SHADER_STAGE followed by GLSL */
+        /* try version 0 first: VK_PIPELINE_SHADER_STAGE followed by GLSL */
         ((uint32_t *) createInfo.pCode)[0] = ICD_SPV_MAGIC;
         ((uint32_t *) createInfo.pCode)[1] = 0;
         ((uint32_t *) createInfo.pCode)[2] = stage;
@@ -960,7 +960,7 @@
 
     if (framework->m_use_spv || err) {
         std::vector<unsigned int> spv;
-        err = XGL_SUCCESS;
+        err = VK_SUCCESS;
 
         // Use Reference GLSL to SPV compiler
         framework->GLSLtoSPV(stage, shader_code, spv);
@@ -978,55 +978,55 @@
     m_vi_state.attributeCount = m_vi_state.bindingCount = 0;
     m_vertexBufferCount = 0;
 
-    m_ia_state.sType = XGL_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO;
-    m_ia_state.pNext = XGL_NULL_HANDLE;
-    m_ia_state.topology = XGL_TOPOLOGY_TRIANGLE_LIST;
-    m_ia_state.disableVertexReuse = XGL_FALSE;
-    m_ia_state.primitiveRestartEnable = XGL_FALSE;
+    m_ia_state.sType = VK_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO;
+    m_ia_state.pNext = VK_NULL_HANDLE;
+    m_ia_state.topology = VK_TOPOLOGY_TRIANGLE_LIST;
+    m_ia_state.disableVertexReuse = VK_FALSE;
+    m_ia_state.primitiveRestartEnable = VK_FALSE;
     m_ia_state.primitiveRestartIndex = 0;
 
-    m_rs_state.sType = XGL_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO;
+    m_rs_state.sType = VK_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO;
     m_rs_state.pNext = &m_ia_state;
-    m_rs_state.depthClipEnable = XGL_FALSE;
-    m_rs_state.rasterizerDiscardEnable = XGL_FALSE;
-    m_rs_state.programPointSize = XGL_FALSE;
-    m_rs_state.pointOrigin = XGL_COORDINATE_ORIGIN_UPPER_LEFT;
-    m_rs_state.provokingVertex = XGL_PROVOKING_VERTEX_LAST;
-    m_rs_state.fillMode = XGL_FILL_SOLID;
-    m_rs_state.cullMode = XGL_CULL_NONE;
-    m_rs_state.frontFace = XGL_FRONT_FACE_CCW;
+    m_rs_state.depthClipEnable = VK_FALSE;
+    m_rs_state.rasterizerDiscardEnable = VK_FALSE;
+    m_rs_state.programPointSize = VK_FALSE;
+    m_rs_state.pointOrigin = VK_COORDINATE_ORIGIN_UPPER_LEFT;
+    m_rs_state.provokingVertex = VK_PROVOKING_VERTEX_LAST;
+    m_rs_state.fillMode = VK_FILL_SOLID;
+    m_rs_state.cullMode = VK_CULL_NONE;
+    m_rs_state.frontFace = VK_FRONT_FACE_CCW;
 
     memset(&m_cb_state,0,sizeof(m_cb_state));
-    m_cb_state.sType = XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO;
+    m_cb_state.sType = VK_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO;
     m_cb_state.pNext = &m_rs_state;
-    m_cb_state.alphaToCoverageEnable = XGL_FALSE;
-    m_cb_state.logicOp = XGL_LOGIC_OP_COPY;
+    m_cb_state.alphaToCoverageEnable = VK_FALSE;
+    m_cb_state.logicOp = VK_LOGIC_OP_COPY;
 
     m_ms_state.pNext = &m_cb_state;
-    m_ms_state.sType = XGL_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO;
-    m_ms_state.multisampleEnable = XGL_FALSE;
+    m_ms_state.sType = VK_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO;
+    m_ms_state.multisampleEnable = VK_FALSE;
     m_ms_state.sampleMask = 1;                // Do we have to specify MSAA even just to disable it?
     m_ms_state.samples = 1;
     m_ms_state.minSampleShading = 0;
     m_ms_state.sampleShadingEnable = 0;
 
-    m_ds_state.sType = XGL_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO;
+    m_ds_state.sType = VK_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO;
     m_ds_state.pNext = &m_ms_state,
-    m_ds_state.format = XGL_FMT_D32_SFLOAT;
-    m_ds_state.depthTestEnable      = XGL_FALSE;
-    m_ds_state.depthWriteEnable     = XGL_FALSE;
-    m_ds_state.depthBoundsEnable    = XGL_FALSE;
-    m_ds_state.depthFunc = XGL_COMPARE_LESS_EQUAL;
-    m_ds_state.back.stencilDepthFailOp = XGL_STENCIL_OP_KEEP;
-    m_ds_state.back.stencilFailOp = XGL_STENCIL_OP_KEEP;
-    m_ds_state.back.stencilPassOp = XGL_STENCIL_OP_KEEP;
-    m_ds_state.back.stencilFunc = XGL_COMPARE_ALWAYS;
-    m_ds_state.stencilTestEnable = XGL_FALSE;
+    m_ds_state.format = VK_FMT_D32_SFLOAT;
+    m_ds_state.depthTestEnable      = VK_FALSE;
+    m_ds_state.depthWriteEnable     = VK_FALSE;
+    m_ds_state.depthBoundsEnable    = VK_FALSE;
+    m_ds_state.depthFunc = VK_COMPARE_LESS_EQUAL;
+    m_ds_state.back.stencilDepthFailOp = VK_STENCIL_OP_KEEP;
+    m_ds_state.back.stencilFailOp = VK_STENCIL_OP_KEEP;
+    m_ds_state.back.stencilPassOp = VK_STENCIL_OP_KEEP;
+    m_ds_state.back.stencilFunc = VK_COMPARE_ALWAYS;
+    m_ds_state.stencilTestEnable = VK_FALSE;
     m_ds_state.front = m_ds_state.back;
 
-    XGL_PIPELINE_CB_ATTACHMENT_STATE att = {};
-    att.blendEnable = XGL_FALSE;
-    att.format = XGL_FMT_B8G8R8A8_UNORM;
+    VK_PIPELINE_CB_ATTACHMENT_STATE att = {};
+    att.blendEnable = VK_FALSE;
+    att.format = VK_FMT_B8G8R8A8_UNORM;
     att.channelWriteMask = 0xf;
     AddColorAttachment(0, &att);
 
@@ -1037,13 +1037,13 @@
     m_shaderObjs.push_back(shader);
 }
 
-void XglPipelineObj::AddVertexInputAttribs(XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* vi_attrib, int count)
+void XglPipelineObj::AddVertexInputAttribs(VK_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* vi_attrib, int count)
 {
     m_vi_state.pVertexAttributeDescriptions = vi_attrib;
     m_vi_state.attributeCount = count;
 }
 
-void XglPipelineObj::AddVertexInputBindings(XGL_VERTEX_INPUT_BINDING_DESCRIPTION* vi_binding, int count)
+void XglPipelineObj::AddVertexInputBindings(VK_VERTEX_INPUT_BINDING_DESCRIPTION* vi_binding, int count)
 {
     m_vi_state.pVertexBindingDescriptions = vi_binding;
     m_vi_state.bindingCount = count;
@@ -1056,7 +1056,7 @@
     m_vertexBufferCount++;
 }
 
-void XglPipelineObj::AddColorAttachment(uint32_t binding, const XGL_PIPELINE_CB_ATTACHMENT_STATE *att)
+void XglPipelineObj::AddColorAttachment(uint32_t binding, const VK_PIPELINE_CB_ATTACHMENT_STATE *att)
 {
     if (binding+1 > m_colorAttachments.size())
     {
@@ -1065,7 +1065,7 @@
     m_colorAttachments[binding] = *att;
 }
 
-void XglPipelineObj::SetDepthStencil(XGL_PIPELINE_DS_STATE_CREATE_INFO *ds_state)
+void XglPipelineObj::SetDepthStencil(VK_PIPELINE_DS_STATE_CREATE_INFO *ds_state)
 {
     m_ds_state.format = ds_state->format;
     m_ds_state.depthTestEnable = ds_state->depthTestEnable;
@@ -1077,12 +1077,12 @@
     m_ds_state.front = ds_state->front;
 }
 
-void XglPipelineObj::CreateXGLPipeline(XglDescriptorSetObj &descriptorSet)
+void XglPipelineObj::CreateVKPipeline(XglDescriptorSetObj &descriptorSet)
 {
     void* head_ptr = &m_ds_state;
-    XGL_GRAPHICS_PIPELINE_CREATE_INFO info = {};
+    VK_GRAPHICS_PIPELINE_CREATE_INFO info = {};
 
-    XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* shaderCreateInfo;
+    VK_PIPELINE_SHADER_STAGE_CREATE_INFO* shaderCreateInfo;
 
     for (int i=0; i<m_shaderObjs.size(); i++)
     {
@@ -1093,12 +1093,12 @@
 
     if (m_vi_state.attributeCount && m_vi_state.bindingCount)
     {
-        m_vi_state.sType = XGL_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO;
+        m_vi_state.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO;
         m_vi_state.pNext = head_ptr;
         head_ptr = &m_vi_state;
     }
 
-    info.sType = XGL_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
+    info.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
     info.pNext = head_ptr;
     info.flags = 0;
     info.pSetLayoutChain = descriptorSet.GetLayoutChain();
@@ -1109,9 +1109,9 @@
     init(*m_device, info);
 }
 
-vector<XGL_GPU_MEMORY> XglMemoryRefManager::mem_refs() const
+vector<VK_GPU_MEMORY> XglMemoryRefManager::mem_refs() const
 {
-    std::vector<XGL_GPU_MEMORY> mems;
+    std::vector<VK_GPU_MEMORY> mems;
     if (this->mem_refs_.size()) {
         mems.reserve(this->mem_refs_.size());
         for (uint32_t i = 0; i < this->mem_refs_.size(); i++)
@@ -1121,13 +1121,13 @@
     return mems;
 }
 
-void XglMemoryRefManager::AddMemoryRefs(xgl_testing::Object &xglObject)
+void XglMemoryRefManager::AddMemoryRefs(vk_testing::Object &vkObject)
 {
-    const std::vector<XGL_GPU_MEMORY> mems = xglObject.memories();
+    const std::vector<VK_GPU_MEMORY> mems = vkObject.memories();
     AddMemoryRefs(mems);
 }
 
-void XglMemoryRefManager::AddMemoryRefs(vector<XGL_GPU_MEMORY> mem)
+void XglMemoryRefManager::AddMemoryRefs(vector<VK_GPU_MEMORY> mem)
 {
     for (size_t i = 0; i < mem.size(); i++) {
         if (mem[i] != NULL) {
@@ -1136,105 +1136,105 @@
     }
 }
 
-void XglMemoryRefManager::EmitAddMemoryRefs(XGL_QUEUE queue)
+void XglMemoryRefManager::EmitAddMemoryRefs(VK_QUEUE queue)
 {
     for (uint32_t i = 0; i < mem_refs_.size(); i++) {
-        xglQueueAddMemReference(queue, mem_refs_[i]);
+        vkQueueAddMemReference(queue, mem_refs_[i]);
     }
 }
 
-void XglMemoryRefManager::EmitRemoveMemoryRefs(XGL_QUEUE queue)
+void XglMemoryRefManager::EmitRemoveMemoryRefs(VK_QUEUE queue)
 {
     for (uint32_t i = 0; i < mem_refs_.size(); i++) {
-        xglQueueRemoveMemReference(queue, mem_refs_[i]);
+        vkQueueRemoveMemReference(queue, mem_refs_[i]);
     }
 }
 
 XglCommandBufferObj::XglCommandBufferObj(XglDevice *device)
-    : xgl_testing::CmdBuffer(*device, xgl_testing::CmdBuffer::create_info(device->graphics_queue_node_index_))
+    : vk_testing::CmdBuffer(*device, vk_testing::CmdBuffer::create_info(device->graphics_queue_node_index_))
 {
     m_device = device;
 }
 
-XGL_CMD_BUFFER XglCommandBufferObj::GetBufferHandle()
+VK_CMD_BUFFER XglCommandBufferObj::GetBufferHandle()
 {
     return obj();
 }
 
-XGL_RESULT XglCommandBufferObj::BeginCommandBuffer(XGL_CMD_BUFFER_BEGIN_INFO *pInfo)
+VK_RESULT XglCommandBufferObj::BeginCommandBuffer(VK_CMD_BUFFER_BEGIN_INFO *pInfo)
 {
     begin(pInfo);
-    return XGL_SUCCESS;
+    return VK_SUCCESS;
 }
 
-XGL_RESULT XglCommandBufferObj::BeginCommandBuffer(XGL_RENDER_PASS renderpass_obj, XGL_FRAMEBUFFER framebuffer_obj)
+VK_RESULT XglCommandBufferObj::BeginCommandBuffer(VK_RENDER_PASS renderpass_obj, VK_FRAMEBUFFER framebuffer_obj)
 {
     begin(renderpass_obj, framebuffer_obj);
-    return XGL_SUCCESS;
+    return VK_SUCCESS;
 }
 
-XGL_RESULT XglCommandBufferObj::BeginCommandBuffer()
+VK_RESULT XglCommandBufferObj::BeginCommandBuffer()
 {
     begin();
-    return XGL_SUCCESS;
+    return VK_SUCCESS;
 }
 
-XGL_RESULT XglCommandBufferObj::EndCommandBuffer()
+VK_RESULT XglCommandBufferObj::EndCommandBuffer()
 {
     end();
-    return XGL_SUCCESS;
+    return VK_SUCCESS;
 }
 
-void XglCommandBufferObj::PipelineBarrier(XGL_PIPELINE_BARRIER *barrierPtr)
+void XglCommandBufferObj::PipelineBarrier(VK_PIPELINE_BARRIER *barrierPtr)
 {
-    xglCmdPipelineBarrier(obj(), barrierPtr);
+    vkCmdPipelineBarrier(obj(), barrierPtr);
 }
 
-void XglCommandBufferObj::ClearAllBuffers(XGL_CLEAR_COLOR clear_color, float depth_clear_color, uint32_t stencil_clear_color,
+void XglCommandBufferObj::ClearAllBuffers(VK_CLEAR_COLOR clear_color, float depth_clear_color, uint32_t stencil_clear_color,
                                           XglDepthStencilObj *depthStencilObj)
 {
     uint32_t i;
-    const XGL_FLAGS output_mask =
-        XGL_MEMORY_OUTPUT_CPU_WRITE_BIT |
-        XGL_MEMORY_OUTPUT_SHADER_WRITE_BIT |
-        XGL_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT |
-        XGL_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT |
-        XGL_MEMORY_OUTPUT_COPY_BIT;
-    const XGL_FLAGS input_mask = 0;
+    const VK_FLAGS output_mask =
+        VK_MEMORY_OUTPUT_CPU_WRITE_BIT |
+        VK_MEMORY_OUTPUT_SHADER_WRITE_BIT |
+        VK_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT |
+        VK_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT |
+        VK_MEMORY_OUTPUT_COPY_BIT;
+    const VK_FLAGS input_mask = 0;
 
     // whatever we want to do, we do it to the whole buffer
-    XGL_IMAGE_SUBRESOURCE_RANGE srRange = {};
-    srRange.aspect = XGL_IMAGE_ASPECT_COLOR;
+    VK_IMAGE_SUBRESOURCE_RANGE srRange = {};
+    srRange.aspect = VK_IMAGE_ASPECT_COLOR;
     srRange.baseMipLevel = 0;
-    srRange.mipLevels = XGL_LAST_MIP_OR_SLICE;
+    srRange.mipLevels = VK_LAST_MIP_OR_SLICE;
     srRange.baseArraySlice = 0;
-    srRange.arraySize = XGL_LAST_MIP_OR_SLICE;
+    srRange.arraySize = VK_LAST_MIP_OR_SLICE;
 
-    XGL_IMAGE_MEMORY_BARRIER memory_barrier = {};
-    memory_barrier.sType = XGL_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
+    VK_IMAGE_MEMORY_BARRIER memory_barrier = {};
+    memory_barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
     memory_barrier.outputMask = output_mask;
     memory_barrier.inputMask = input_mask;
-    memory_barrier.newLayout = XGL_IMAGE_LAYOUT_CLEAR_OPTIMAL;
+    memory_barrier.newLayout = VK_IMAGE_LAYOUT_CLEAR_OPTIMAL;
     memory_barrier.subresourceRange = srRange;
-    XGL_IMAGE_MEMORY_BARRIER *pmemory_barrier = &memory_barrier;
+    VK_IMAGE_MEMORY_BARRIER *pmemory_barrier = &memory_barrier;
 
-    XGL_PIPE_EVENT set_events[] = { XGL_PIPE_EVENT_GPU_COMMANDS_COMPLETE };
-    XGL_PIPELINE_BARRIER pipeline_barrier = {};
-    pipeline_barrier.sType = XGL_STRUCTURE_TYPE_PIPELINE_BARRIER;
+    VK_PIPE_EVENT set_events[] = { VK_PIPE_EVENT_GPU_COMMANDS_COMPLETE };
+    VK_PIPELINE_BARRIER pipeline_barrier = {};
+    pipeline_barrier.sType = VK_STRUCTURE_TYPE_PIPELINE_BARRIER;
     pipeline_barrier.eventCount = 1;
     pipeline_barrier.pEvents = set_events;
-    pipeline_barrier.waitEvent = XGL_WAIT_EVENT_TOP_OF_PIPE;
+    pipeline_barrier.waitEvent = VK_WAIT_EVENT_TOP_OF_PIPE;
     pipeline_barrier.memBarrierCount = 1;
     pipeline_barrier.ppMemBarriers = (const void **)&pmemory_barrier;
 
     for (i = 0; i < m_renderTargets.size(); i++) {
         memory_barrier.image = m_renderTargets[i]->image();
         memory_barrier.oldLayout = m_renderTargets[i]->layout();
-        xglCmdPipelineBarrier( obj(), &pipeline_barrier);
+        vkCmdPipelineBarrier( obj(), &pipeline_barrier);
         m_renderTargets[i]->layout(memory_barrier.newLayout);
 
-        xglCmdClearColorImage(obj(),
-               m_renderTargets[i]->image(), XGL_IMAGE_LAYOUT_CLEAR_OPTIMAL,
+        vkCmdClearColorImage(obj(),
+               m_renderTargets[i]->image(), VK_IMAGE_LAYOUT_CLEAR_OPTIMAL,
                clear_color, 1, &srRange );
 
         mem_ref_mgr.AddMemoryRefs(*m_renderTargets[i]);
@@ -1242,78 +1242,78 @@
 
     if (depthStencilObj)
     {
-        XGL_IMAGE_SUBRESOURCE_RANGE dsRange = {};
-        dsRange.aspect = XGL_IMAGE_ASPECT_DEPTH;
+        VK_IMAGE_SUBRESOURCE_RANGE dsRange = {};
+        dsRange.aspect = VK_IMAGE_ASPECT_DEPTH;
         dsRange.baseMipLevel = 0;
-        dsRange.mipLevels = XGL_LAST_MIP_OR_SLICE;
+        dsRange.mipLevels = VK_LAST_MIP_OR_SLICE;
         dsRange.baseArraySlice = 0;
-        dsRange.arraySize = XGL_LAST_MIP_OR_SLICE;
+        dsRange.arraySize = VK_LAST_MIP_OR_SLICE;
 
         // prepare the depth buffer for clear
 
         memory_barrier.oldLayout = depthStencilObj->BindInfo()->layout;
-        memory_barrier.newLayout = XGL_IMAGE_LAYOUT_CLEAR_OPTIMAL;
+        memory_barrier.newLayout = VK_IMAGE_LAYOUT_CLEAR_OPTIMAL;
         memory_barrier.image = depthStencilObj->obj();
         memory_barrier.subresourceRange = dsRange;
 
-        xglCmdPipelineBarrier( obj(), &pipeline_barrier);
+        vkCmdPipelineBarrier( obj(), &pipeline_barrier);
 
-        xglCmdClearDepthStencil(obj(),
-                                depthStencilObj->obj(), XGL_IMAGE_LAYOUT_CLEAR_OPTIMAL,
+        vkCmdClearDepthStencil(obj(),
+                                depthStencilObj->obj(), VK_IMAGE_LAYOUT_CLEAR_OPTIMAL,
                                 depth_clear_color,  stencil_clear_color,
                                 1, &dsRange);
         mem_ref_mgr.AddMemoryRefs(*depthStencilObj);
 
         // prepare depth buffer for rendering
         memory_barrier.image = depthStencilObj->obj();
-        memory_barrier.oldLayout = XGL_IMAGE_LAYOUT_CLEAR_OPTIMAL;
+        memory_barrier.oldLayout = VK_IMAGE_LAYOUT_CLEAR_OPTIMAL;
         memory_barrier.newLayout = depthStencilObj->BindInfo()->layout;
         memory_barrier.subresourceRange = dsRange;
-        xglCmdPipelineBarrier( obj(), &pipeline_barrier);
+        vkCmdPipelineBarrier( obj(), &pipeline_barrier);
     }
 }
 
 void XglCommandBufferObj::PrepareAttachments()
 {
     uint32_t i;
-    const XGL_FLAGS output_mask =
-        XGL_MEMORY_OUTPUT_CPU_WRITE_BIT |
-        XGL_MEMORY_OUTPUT_SHADER_WRITE_BIT |
-        XGL_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT |
-        XGL_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT |
-        XGL_MEMORY_OUTPUT_COPY_BIT;
-    const XGL_FLAGS input_mask =
-        XGL_MEMORY_INPUT_CPU_READ_BIT |
-        XGL_MEMORY_INPUT_INDIRECT_COMMAND_BIT |
-        XGL_MEMORY_INPUT_INDEX_FETCH_BIT |
-        XGL_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT |
-        XGL_MEMORY_INPUT_UNIFORM_READ_BIT |
-        XGL_MEMORY_INPUT_SHADER_READ_BIT |
-        XGL_MEMORY_INPUT_COLOR_ATTACHMENT_BIT |
-        XGL_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT |
-        XGL_MEMORY_INPUT_COPY_BIT;
+    const VK_FLAGS output_mask =
+        VK_MEMORY_OUTPUT_CPU_WRITE_BIT |
+        VK_MEMORY_OUTPUT_SHADER_WRITE_BIT |
+        VK_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT |
+        VK_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT |
+        VK_MEMORY_OUTPUT_COPY_BIT;
+    const VK_FLAGS input_mask =
+        VK_MEMORY_INPUT_CPU_READ_BIT |
+        VK_MEMORY_INPUT_INDIRECT_COMMAND_BIT |
+        VK_MEMORY_INPUT_INDEX_FETCH_BIT |
+        VK_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT |
+        VK_MEMORY_INPUT_UNIFORM_READ_BIT |
+        VK_MEMORY_INPUT_SHADER_READ_BIT |
+        VK_MEMORY_INPUT_COLOR_ATTACHMENT_BIT |
+        VK_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT |
+        VK_MEMORY_INPUT_COPY_BIT;
 
-    XGL_IMAGE_SUBRESOURCE_RANGE srRange = {};
-    srRange.aspect = XGL_IMAGE_ASPECT_COLOR;
+    VK_IMAGE_SUBRESOURCE_RANGE srRange = {};
+    srRange.aspect = VK_IMAGE_ASPECT_COLOR;
     srRange.baseMipLevel = 0;
-    srRange.mipLevels = XGL_LAST_MIP_OR_SLICE;
+    srRange.mipLevels = VK_LAST_MIP_OR_SLICE;
     srRange.baseArraySlice = 0;
-    srRange.arraySize = XGL_LAST_MIP_OR_SLICE;
+    srRange.arraySize = VK_LAST_MIP_OR_SLICE;
 
-    XGL_IMAGE_MEMORY_BARRIER memory_barrier = {};
-    memory_barrier.sType = XGL_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
+    VK_IMAGE_MEMORY_BARRIER memory_barrier = {};
+    memory_barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
     memory_barrier.outputMask = output_mask;
     memory_barrier.inputMask = input_mask;
-    memory_barrier.newLayout = XGL_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
+    memory_barrier.newLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
     memory_barrier.subresourceRange = srRange;
-    XGL_IMAGE_MEMORY_BARRIER *pmemory_barrier = &memory_barrier;
+    VK_IMAGE_MEMORY_BARRIER *pmemory_barrier = &memory_barrier;
 
-    XGL_PIPE_EVENT set_events[] = { XGL_PIPE_EVENT_GPU_COMMANDS_COMPLETE };
-    XGL_PIPELINE_BARRIER pipeline_barrier = {};
-    pipeline_barrier.sType = XGL_STRUCTURE_TYPE_PIPELINE_BARRIER;
+    VK_PIPE_EVENT set_events[] = { VK_PIPE_EVENT_GPU_COMMANDS_COMPLETE };
+    VK_PIPELINE_BARRIER pipeline_barrier = {};
+    pipeline_barrier.sType = VK_STRUCTURE_TYPE_PIPELINE_BARRIER;
     pipeline_barrier.eventCount = 1;
     pipeline_barrier.pEvents = set_events;
-    pipeline_barrier.waitEvent = XGL_WAIT_EVENT_TOP_OF_PIPE;
+    pipeline_barrier.waitEvent = VK_WAIT_EVENT_TOP_OF_PIPE;
     pipeline_barrier.memBarrierCount = 1;
     pipeline_barrier.ppMemBarriers = (const void **)&pmemory_barrier;
 
@@ -1321,29 +1321,29 @@
     {
         memory_barrier.image = m_renderTargets[i]->image();
         memory_barrier.oldLayout = m_renderTargets[i]->layout();
-        xglCmdPipelineBarrier( obj(), &pipeline_barrier);
+        vkCmdPipelineBarrier( obj(), &pipeline_barrier);
         m_renderTargets[i]->layout(memory_barrier.newLayout);
     }
 }
 
-void XglCommandBufferObj::BeginRenderPass(XGL_RENDER_PASS renderpass, XGL_FRAMEBUFFER framebuffer)
+void XglCommandBufferObj::BeginRenderPass(VK_RENDER_PASS renderpass, VK_FRAMEBUFFER framebuffer)
 {
-    XGL_RENDER_PASS_BEGIN rp_begin = {
+    VK_RENDER_PASS_BEGIN rp_begin = {
         renderpass,
         framebuffer,
     };
 
-    xglCmdBeginRenderPass( obj(), &rp_begin);
+    vkCmdBeginRenderPass( obj(), &rp_begin);
 }
 
-void XglCommandBufferObj::EndRenderPass(XGL_RENDER_PASS renderpass)
+void XglCommandBufferObj::EndRenderPass(VK_RENDER_PASS renderpass)
 {
-    xglCmdEndRenderPass( obj(), renderpass);
+    vkCmdEndRenderPass( obj(), renderpass);
 }
 
-void XglCommandBufferObj::BindStateObject(XGL_STATE_BIND_POINT stateBindPoint, XGL_DYNAMIC_STATE_OBJECT stateObject)
+void XglCommandBufferObj::BindStateObject(VK_STATE_BIND_POINT stateBindPoint, VK_DYNAMIC_STATE_OBJECT stateObject)
 {
-    xglCmdBindDynamicStateObject( obj(), stateBindPoint, stateObject);
+    vkCmdBindDynamicStateObject( obj(), stateBindPoint, stateObject);
 }
 
 void XglCommandBufferObj::AddRenderTarget(XglImage *renderTarget)
@@ -1353,12 +1353,12 @@
 
 void XglCommandBufferObj::DrawIndexed(uint32_t firstIndex, uint32_t indexCount, int32_t vertexOffset, uint32_t firstInstance, uint32_t instanceCount)
 {
-    xglCmdDrawIndexed(obj(), firstIndex, indexCount, vertexOffset, firstInstance, instanceCount);
+    vkCmdDrawIndexed(obj(), firstIndex, indexCount, vertexOffset, firstInstance, instanceCount);
 }
 
 void XglCommandBufferObj::Draw(uint32_t firstVertex, uint32_t vertexCount, uint32_t firstInstance, uint32_t instanceCount)
 {
-    xglCmdDraw(obj(), firstVertex, vertexCount, firstInstance, instanceCount);
+    vkCmdDraw(obj(), firstVertex, vertexCount, firstInstance, instanceCount);
 }
 
 void XglCommandBufferObj::QueueCommandBuffer()
@@ -1366,21 +1366,21 @@
     QueueCommandBuffer(NULL);
 }
 
-void XglCommandBufferObj::QueueCommandBuffer(XGL_FENCE fence)
+void XglCommandBufferObj::QueueCommandBuffer(VK_FENCE fence)
 {
-    XGL_RESULT err = XGL_SUCCESS;
+    VK_RESULT err = VK_SUCCESS;
 
     mem_ref_mgr.EmitAddMemoryRefs(m_device->m_queue);
 
     // submit the command buffer to the universal queue
-    err = xglQueueSubmit( m_device->m_queue, 1, &obj(), fence );
-    ASSERT_XGL_SUCCESS( err );
+    err = vkQueueSubmit( m_device->m_queue, 1, &obj(), fence );
+    ASSERT_VK_SUCCESS( err );
 
-    err = xglQueueWaitIdle( m_device->m_queue );
-    ASSERT_XGL_SUCCESS( err );
+    err = vkQueueWaitIdle( m_device->m_queue );
+    ASSERT_VK_SUCCESS( err );
 
     // Wait for work to finish before cleaning up.
-    xglDeviceWaitIdle(m_device->device());
+    vkDeviceWaitIdle(m_device->device());
 
     /*
      * Now that processing on this command buffer is complete
@@ -1391,16 +1391,16 @@
 
 void XglCommandBufferObj::BindPipeline(XglPipelineObj &pipeline)
 {
-    xglCmdBindPipeline( obj(), XGL_PIPELINE_BIND_POINT_GRAPHICS, pipeline.obj() );
+    vkCmdBindPipeline( obj(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline.obj() );
     mem_ref_mgr.AddMemoryRefs(pipeline);
 }
 
 void XglCommandBufferObj::BindDescriptorSet(XglDescriptorSetObj &descriptorSet)
 {
-    XGL_DESCRIPTOR_SET set_obj = descriptorSet.GetDescriptorSetHandle();
+    VK_DESCRIPTOR_SET set_obj = descriptorSet.GetDescriptorSetHandle();
 
     // bind pipeline, vertex buffer (descriptor set) and WVP (dynamic buffer view)
-    xglCmdBindDescriptorSets(obj(), XGL_PIPELINE_BIND_POINT_GRAPHICS,
+    vkCmdBindDescriptorSets(obj(), VK_PIPELINE_BIND_POINT_GRAPHICS,
            descriptorSet.GetLayoutChain(), 0, 1, &set_obj, NULL );
 
     // Add descriptor set mem refs to command buffer's list
@@ -1410,13 +1410,13 @@
 
 void XglCommandBufferObj::BindIndexBuffer(XglIndexBufferObj *indexBuffer, uint32_t offset)
 {
-    xglCmdBindIndexBuffer(obj(), indexBuffer->obj(), offset, indexBuffer->GetIndexType());
+    vkCmdBindIndexBuffer(obj(), indexBuffer->obj(), offset, indexBuffer->GetIndexType());
     mem_ref_mgr.AddMemoryRefs(*indexBuffer);
 }
 
 void XglCommandBufferObj::BindVertexBuffer(XglConstantBufferObj *vertexBuffer, uint32_t offset, uint32_t binding)
 {
-    xglCmdBindVertexBuffer(obj(), vertexBuffer->obj(), offset, binding);
+    vkCmdBindVertexBuffer(obj(), vertexBuffer->obj(), offset, binding);
     mem_ref_mgr.AddMemoryRefs(*vertexBuffer);
 }
 
@@ -1429,23 +1429,23 @@
     return m_initialized;
 }
 
-XGL_DEPTH_STENCIL_BIND_INFO* XglDepthStencilObj::BindInfo()
+VK_DEPTH_STENCIL_BIND_INFO* XglDepthStencilObj::BindInfo()
 {
     return &m_depthStencilBindInfo;
 }
 
 void XglDepthStencilObj::Init(XglDevice *device, int32_t width, int32_t height)
 {
-    XGL_IMAGE_CREATE_INFO image_info;
-    XGL_DEPTH_STENCIL_VIEW_CREATE_INFO view_info;
+    VK_IMAGE_CREATE_INFO image_info;
+    VK_DEPTH_STENCIL_VIEW_CREATE_INFO view_info;
 
     m_device = device;
     m_initialized = true;
-    m_depth_stencil_fmt = XGL_FMT_D16_UNORM;
+    m_depth_stencil_fmt = VK_FMT_D16_UNORM;
 
-    image_info.sType = XGL_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
+    image_info.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
     image_info.pNext = NULL;
-    image_info.imageType = XGL_IMAGE_2D;
+    image_info.imageType = VK_IMAGE_2D;
     image_info.format = m_depth_stencil_fmt;
     image_info.extent.width = width;
     image_info.extent.height = height;
@@ -1453,14 +1453,14 @@
     image_info.mipLevels = 1;
     image_info.arraySize = 1;
     image_info.samples = 1;
-    image_info.tiling = XGL_OPTIMAL_TILING;
-    image_info.usage = XGL_IMAGE_USAGE_DEPTH_STENCIL_BIT;
+    image_info.tiling = VK_OPTIMAL_TILING;
+    image_info.usage = VK_IMAGE_USAGE_DEPTH_STENCIL_BIT;
     image_info.flags = 0;
     init(*m_device, image_info);
 
-    view_info.sType = XGL_STRUCTURE_TYPE_DEPTH_STENCIL_VIEW_CREATE_INFO;
+    view_info.sType = VK_STRUCTURE_TYPE_DEPTH_STENCIL_VIEW_CREATE_INFO;
     view_info.pNext = NULL;
-    view_info.image = XGL_NULL_HANDLE;
+    view_info.image = VK_NULL_HANDLE;
     view_info.mipLevel = 0;
     view_info.baseArraySlice = 0;
     view_info.arraySize = 1;
@@ -1469,5 +1469,5 @@
     m_depthStencilView.init(*m_device, view_info);
 
     m_depthStencilBindInfo.view = m_depthStencilView.obj();
-    m_depthStencilBindInfo.layout = XGL_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
+    m_depthStencilBindInfo.layout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
 }
diff --git a/tests/xglrenderframework.h b/tests/xglrenderframework.h
deleted file mode 100644
index 9241eaa..0000000
--- a/tests/xglrenderframework.h
+++ /dev/null
@@ -1,417 +0,0 @@
-/*
- * XGL Tests
- *
- * Copyright (C) 2014 LunarG, Inc.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- *
- * Authors:
- *   Courtney Goeltzenleuchter <courtney@lunarg.com>
- */
-
-#ifndef XGLRENDERFRAMEWORK_H
-#define XGLRENDERFRAMEWORK_H
-
-#include "xgltestframework.h"
-
-
-class XglDevice : public xgl_testing::Device
-{
-public:
-    XglDevice(uint32_t id, XGL_PHYSICAL_GPU obj);
-
-    XGL_DEVICE device() { return obj(); }
-    void get_device_queue();
-
-    uint32_t id;
-    XGL_PHYSICAL_GPU_PROPERTIES props;
-    const XGL_PHYSICAL_GPU_QUEUE_PROPERTIES *queue_props;
-
-    XGL_QUEUE m_queue;
-};
-
-class XglMemoryRefManager
-{
-public:
-    void AddMemoryRefs(xgl_testing::Object &xglObject);
-    void AddMemoryRefs(vector<XGL_GPU_MEMORY> mem);
-    void EmitAddMemoryRefs(XGL_QUEUE queue);
-    void EmitRemoveMemoryRefs(XGL_QUEUE queue);
-    vector<XGL_GPU_MEMORY> mem_refs() const;
-
-protected:
-    vector<XGL_GPU_MEMORY>      mem_refs_;
-
-};
-
-class XglDepthStencilObj : public xgl_testing::Image
-{
-public:
-    XglDepthStencilObj();
-    void Init(XglDevice *device, int32_t width, int32_t height);
-    bool Initialized();
-    XGL_DEPTH_STENCIL_BIND_INFO* BindInfo();
-
-protected:
-    XglDevice                         *m_device;
-    bool                               m_initialized;
-    xgl_testing::DepthStencilView      m_depthStencilView;
-    XGL_FORMAT                         m_depth_stencil_fmt;
-    XGL_DEPTH_STENCIL_BIND_INFO        m_depthStencilBindInfo;
-};
-
-class XglRenderFramework : public XglTestFramework
-{
-public:
-    XglRenderFramework();
-    ~XglRenderFramework();
-
-    XGL_DEVICE device() {return m_device->device();}
-    XGL_PHYSICAL_GPU gpu() {return objs[0];}
-    XGL_RENDER_PASS renderPass() {return m_renderPass;}
-    XGL_FRAMEBUFFER framebuffer() {return m_framebuffer;}
-    void InitViewport(float width, float height);
-    void InitViewport();
-    void InitRenderTarget();
-    void InitRenderTarget(uint32_t targets);
-    void InitRenderTarget(XGL_DEPTH_STENCIL_BIND_INFO *dsBinding);
-    void InitRenderTarget(uint32_t targets, XGL_DEPTH_STENCIL_BIND_INFO *dsBinding);
-    void InitFramework();
-    void ShutdownFramework();
-    void InitState();
-
-
-protected:
-    XGL_APPLICATION_INFO                    app_info;
-    XGL_INSTANCE                            inst;
-    XGL_PHYSICAL_GPU                        objs[XGL_MAX_PHYSICAL_GPUS];
-    uint32_t                                gpu_count;
-    XglDevice                              *m_device;
-    XGL_CMD_BUFFER                          m_cmdBuffer;
-    XGL_RENDER_PASS                         m_renderPass;
-    XGL_FRAMEBUFFER                         m_framebuffer;
-    XGL_DYNAMIC_RS_STATE_OBJECT             m_stateRaster;
-    XGL_DYNAMIC_CB_STATE_OBJECT             m_colorBlend;
-    XGL_DYNAMIC_VP_STATE_OBJECT             m_stateViewport;
-    XGL_DYNAMIC_DS_STATE_OBJECT             m_stateDepthStencil;
-    vector<XglImage*>                       m_renderTargets;
-    float                                   m_width, m_height;
-    XGL_FORMAT                              m_render_target_fmt;
-    XGL_FORMAT                              m_depth_stencil_fmt;
-    XGL_COLOR_ATTACHMENT_BIND_INFO          m_colorBindings[8];
-    XGL_CLEAR_COLOR                         m_clear_color;
-    float                                   m_depth_clear_color;
-    uint32_t                                m_stencil_clear_color;
-    XglDepthStencilObj                     *m_depthStencil;
-    XglMemoryRefManager                     m_mem_ref_mgr;
-
-    /*
-     * SetUp and TearDown are called by the Google Test framework
-     * to initialize a test framework based on this class.
-     */
-    virtual void SetUp() {
-        this->app_info.sType = XGL_STRUCTURE_TYPE_APPLICATION_INFO;
-        this->app_info.pNext = NULL;
-        this->app_info.pAppName = "base";
-        this->app_info.appVersion = 1;
-        this->app_info.pEngineName = "unittest";
-        this->app_info.engineVersion = 1;
-        this->app_info.apiVersion = XGL_API_VERSION;
-
-        InitFramework();
-    }
-
-    virtual void TearDown() {
-        ShutdownFramework();
-    }
-};
-
-class XglDescriptorSetObj;
-class XglIndexBufferObj;
-class XglConstantBufferObj;
-class XglPipelineObj;
-class XglDescriptorSetObj;
-
-class XglCommandBufferObj : public xgl_testing::CmdBuffer
-{
-public:
-    XglCommandBufferObj(XglDevice *device);
-    XGL_CMD_BUFFER GetBufferHandle();
-    XGL_RESULT BeginCommandBuffer();
-    XGL_RESULT BeginCommandBuffer(XGL_CMD_BUFFER_BEGIN_INFO *pInfo);
-    XGL_RESULT BeginCommandBuffer(XGL_RENDER_PASS renderpass_obj, XGL_FRAMEBUFFER framebuffer_obj);
-    XGL_RESULT EndCommandBuffer();
-    void PipelineBarrier(XGL_PIPELINE_BARRIER *barrierPtr);
-    void AddRenderTarget(XglImage *renderTarget);
-    void AddDepthStencil();
-    void ClearAllBuffers(XGL_CLEAR_COLOR clear_color, float depth_clear_color, uint32_t stencil_clear_color, XglDepthStencilObj *depthStencilObj);
-    void PrepareAttachments();
-    void AddMemoryRefs(xgl_testing::Object &xglObject);
-    void AddMemoryRefs(uint32_t ref_count, const XGL_GPU_MEMORY *mem);
-    void AddMemoryRefs(vector<xgl_testing::Object *> images);
-    void BindPipeline(XglPipelineObj &pipeline);
-    void BindDescriptorSet(XglDescriptorSetObj &descriptorSet);
-    void BindVertexBuffer(XglConstantBufferObj *vertexBuffer, uint32_t offset, uint32_t binding);
-    void BindIndexBuffer(XglIndexBufferObj *indexBuffer, uint32_t offset);
-    void BindStateObject(XGL_STATE_BIND_POINT stateBindPoint, XGL_DYNAMIC_STATE_OBJECT stateObject);
-    void BeginRenderPass(XGL_RENDER_PASS renderpass, XGL_FRAMEBUFFER framebuffer);
-    void EndRenderPass(XGL_RENDER_PASS renderpass);
-    void Draw(uint32_t firstVertex, uint32_t vertexCount, uint32_t firstInstance, uint32_t instanceCount);
-    void DrawIndexed(uint32_t firstIndex, uint32_t indexCount, int32_t vertexOffset, uint32_t firstInstance, uint32_t instanceCount);
-    void QueueCommandBuffer();
-    void QueueCommandBuffer(XGL_FENCE fence);
-
-    XglMemoryRefManager             mem_ref_mgr;
-
-protected:
-    XglDevice                      *m_device;
-    vector<XglImage*>               m_renderTargets;
-};
-
-class XglConstantBufferObj : public xgl_testing::Buffer
-{
-public:
-    XglConstantBufferObj(XglDevice *device);
-    XglConstantBufferObj(XglDevice *device, int constantCount, int constantSize, const void* data);
-    ~XglConstantBufferObj();
-    void BufferMemoryBarrier(
-        XGL_FLAGS outputMask =
-            XGL_MEMORY_OUTPUT_CPU_WRITE_BIT |
-            XGL_MEMORY_OUTPUT_SHADER_WRITE_BIT |
-            XGL_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT |
-            XGL_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT |
-            XGL_MEMORY_OUTPUT_COPY_BIT,
-        XGL_FLAGS inputMask =
-            XGL_MEMORY_INPUT_CPU_READ_BIT |
-            XGL_MEMORY_INPUT_INDIRECT_COMMAND_BIT |
-            XGL_MEMORY_INPUT_INDEX_FETCH_BIT |
-            XGL_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT |
-            XGL_MEMORY_INPUT_UNIFORM_READ_BIT |
-            XGL_MEMORY_INPUT_SHADER_READ_BIT |
-            XGL_MEMORY_INPUT_COLOR_ATTACHMENT_BIT |
-            XGL_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT |
-            XGL_MEMORY_INPUT_COPY_BIT);
-
-    void Bind(XGL_CMD_BUFFER cmdBuffer, XGL_GPU_SIZE offset, uint32_t binding);
-
-    XGL_BUFFER_VIEW_ATTACH_INFO     m_bufferViewInfo;
-
-protected:
-    XglDevice                      *m_device;
-    xgl_testing::BufferView         m_bufferView;
-    int                             m_numVertices;
-    int                             m_stride;
-    XglCommandBufferObj             *m_commandBuffer;
-    xgl_testing::Fence              m_fence;
-};
-
-class XglIndexBufferObj : public XglConstantBufferObj
-{
-public:
-    XglIndexBufferObj(XglDevice *device);
-    void CreateAndInitBuffer(int numIndexes, XGL_INDEX_TYPE dataFormat, const void* data);
-    void Bind(XGL_CMD_BUFFER cmdBuffer, XGL_GPU_SIZE offset);
-    XGL_INDEX_TYPE GetIndexType();
-
-protected:
-    XGL_INDEX_TYPE  m_indexType;
-};
-
-class XglImage : public xgl_testing::Image
-{
-public:
-    XglImage(XglDevice *dev);
-    bool IsCompatible(XGL_FLAGS usage, XGL_FLAGS features);
-
-public:
-    void init(uint32_t w, uint32_t h,
-              XGL_FORMAT fmt, XGL_FLAGS usage,
-              XGL_IMAGE_TILING tiling=XGL_LINEAR_TILING);
-
-    //    void clear( CommandBuffer*, uint32_t[4] );
-
-    void layout( XGL_IMAGE_LAYOUT layout )
-    {
-        m_imageInfo.layout = layout;
-    }
-
-    XGL_GPU_MEMORY memory() const
-    {
-        const std::vector<XGL_GPU_MEMORY> mems = memories();
-        return mems.empty() ? XGL_NULL_HANDLE : mems[0];
-    }
-
-    void ImageMemoryBarrier(XglCommandBufferObj *cmd,
-                            XGL_IMAGE_ASPECT aspect,
-                            XGL_FLAGS output_mask,
-                            XGL_FLAGS input_mask,
-                            XGL_IMAGE_LAYOUT image_layout);
-
-    XGL_RESULT CopyImage(XglImage &src_image);
-
-    XGL_IMAGE image() const
-    {
-        return obj();
-    }
-
-    XGL_COLOR_ATTACHMENT_VIEW targetView()
-    {
-        if (!m_targetView.initialized())
-        {
-            XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO createView = {
-                XGL_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO,
-                XGL_NULL_HANDLE,
-                obj(),
-                XGL_FMT_B8G8R8A8_UNORM,
-                0,
-                0,
-                1
-            };
-            m_targetView.init(*m_device, createView);
-        }
-        return m_targetView.obj();
-    }
-
-    void SetLayout(XglCommandBufferObj *cmd_buf, XGL_IMAGE_ASPECT aspect, XGL_IMAGE_LAYOUT image_layout);
-    void SetLayout(XGL_IMAGE_ASPECT aspect, XGL_IMAGE_LAYOUT image_layout);
-
-    XGL_IMAGE_LAYOUT layout() const
-    {
-        return ( XGL_IMAGE_LAYOUT )m_imageInfo.layout;
-    }
-    uint32_t width() const
-    {
-        return extent().width;
-    }
-    uint32_t height() const
-    {
-        return extent().height;
-    }
-    XglDevice* device() const
-    {
-        return m_device;
-    }
-
-    XGL_RESULT MapMemory(void** ptr);
-    XGL_RESULT UnmapMemory();
-
-protected:
-    XglDevice *m_device;
-
-    xgl_testing::ColorAttachmentView m_targetView;
-    XGL_IMAGE_VIEW_ATTACH_INFO   m_imageInfo;
-};
-
-class XglTextureObj : public XglImage
-{
-public:
-    XglTextureObj(XglDevice *device, uint32_t *colors = NULL);
-    XGL_IMAGE_VIEW_ATTACH_INFO m_textureViewInfo;
-
-
-protected:
-    XglDevice                 *m_device;
-    xgl_testing::ImageView     m_textureView;
-    XGL_GPU_SIZE               m_rowPitch;
-};
-
-class XglSamplerObj : public xgl_testing::Sampler
-{
-public:
-    XglSamplerObj(XglDevice *device);
-
-protected:
-     XglDevice *m_device;
-
-};
-
-class XglDescriptorSetObj : public xgl_testing::DescriptorPool
-{
-public:
-    XglDescriptorSetObj(XglDevice *device);
-    ~XglDescriptorSetObj();
-
-    int AppendDummy();
-    int AppendBuffer(XGL_DESCRIPTOR_TYPE type, XglConstantBufferObj &constantBuffer);
-    int AppendSamplerTexture(XglSamplerObj* sampler, XglTextureObj* texture);
-    void CreateXGLDescriptorSet(XglCommandBufferObj *cmdBuffer);
-
-    XGL_DESCRIPTOR_SET GetDescriptorSetHandle() const;
-    XGL_DESCRIPTOR_SET_LAYOUT_CHAIN GetLayoutChain() const;
-
-    XglMemoryRefManager                  mem_ref_mgr;
-
-protected:
-    XglDevice                           *m_device;
-    vector<XGL_DESCRIPTOR_TYPE_COUNT>    m_type_counts;
-    int                                  m_nextSlot;
-
-    vector<XGL_UPDATE_BUFFERS>           m_updateBuffers;
-
-    vector<XGL_SAMPLER_IMAGE_VIEW_INFO>  m_samplerTextureInfo;
-    vector<XGL_UPDATE_SAMPLER_TEXTURES>  m_updateSamplerTextures;
-
-    xgl_testing::DescriptorSetLayout     m_layout;
-    xgl_testing::DescriptorSetLayoutChain m_layout_chain;
-    xgl_testing::DescriptorSet          *m_set;
-};
-
-
-class XglShaderObj : public xgl_testing::Shader
-{
-public:
-    XglShaderObj(XglDevice *device, const char * shaderText, XGL_PIPELINE_SHADER_STAGE stage, XglRenderFramework *framework);
-    XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* GetStageCreateInfo();
-
-protected:
-    XGL_PIPELINE_SHADER_STAGE_CREATE_INFO stage_info;
-    XGL_PIPELINE_SHADER_STAGE m_stage;
-    XglDevice *m_device;
-
-};
-
-class XglPipelineObj : public xgl_testing::Pipeline
-{
-public:
-    XglPipelineObj(XglDevice *device);
-    void AddShader(XglShaderObj* shaderObj);
-    void AddVertexInputAttribs(XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* vi_attrib, int count);
-    void AddVertexInputBindings(XGL_VERTEX_INPUT_BINDING_DESCRIPTION* vi_binding, int count);
-    void AddVertexDataBuffer(XglConstantBufferObj* vertexDataBuffer, int binding);
-    void AddColorAttachment(uint32_t binding, const XGL_PIPELINE_CB_ATTACHMENT_STATE *att);
-    void SetDepthStencil(XGL_PIPELINE_DS_STATE_CREATE_INFO *);
-    void CreateXGLPipeline(XglDescriptorSetObj &descriptorSet);
-
-protected:
-    XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO m_vi_state;
-    XGL_PIPELINE_IA_STATE_CREATE_INFO m_ia_state;
-    XGL_PIPELINE_RS_STATE_CREATE_INFO m_rs_state;
-    XGL_PIPELINE_CB_STATE_CREATE_INFO m_cb_state;
-    XGL_PIPELINE_DS_STATE_CREATE_INFO m_ds_state;
-    XGL_PIPELINE_MS_STATE_CREATE_INFO m_ms_state;
-    XglDevice *m_device;
-    vector<XglShaderObj*> m_shaderObjs;
-    vector<XglConstantBufferObj*> m_vertexBufferObjs;
-    vector<int> m_vertexBufferBindings;
-    vector<XGL_PIPELINE_CB_ATTACHMENT_STATE> m_colorAttachments;
-    int m_vertexBufferCount;
-
-};
-
-#endif // XGLRENDERFRAMEWORK_H
diff --git a/tests/xgltestbinding.cpp b/tests/xgltestbinding.cpp
index 92ca983..fcadfd9 100644
--- a/tests/xgltestbinding.cpp
+++ b/tests/xgltestbinding.cpp
@@ -1,4 +1,4 @@
-// XGL tests
+// VK tests
 //
 // Copyright (C) 2014 LunarG, Inc.
 //
@@ -22,21 +22,21 @@
 
 #include <iostream>
 #include <string.h> // memset(), memcmp()
-#include "xgltestbinding.h"
+#include "vktestbinding.h"
 
 namespace {
 
 #define DERIVED_OBJECT_INIT(create_func, ...)                       \
     do {                                                            \
         obj_type obj;                                               \
-        if (EXPECT(create_func(__VA_ARGS__, &obj) == XGL_SUCCESS))  \
+        if (EXPECT(create_func(__VA_ARGS__, &obj) == VK_SUCCESS))  \
             base_type::init(obj);                                   \
     } while (0)
 
 #define STRINGIFY(x) #x
 #define EXPECT(expr) ((expr) ? true : expect_failure(STRINGIFY(expr), __FILE__, __LINE__, __FUNCTION__))
 
-xgl_testing::ErrorCallback error_callback;
+vk_testing::ErrorCallback error_callback;
 
 bool expect_failure(const char *expr, const char *file, unsigned int line, const char *function)
 {
@@ -61,13 +61,13 @@
 }
 
 template<typename T>
-std::vector<T> get_info(XGL_PHYSICAL_GPU gpu, XGL_PHYSICAL_GPU_INFO_TYPE type, size_t min_elems)
+std::vector<T> get_info(VK_PHYSICAL_GPU gpu, VK_PHYSICAL_GPU_INFO_TYPE type, size_t min_elems)
 {
     std::vector<T> info;
     size_t size;
-    if (EXPECT(xglGetGpuInfo(gpu, type, &size, NULL) == XGL_SUCCESS && size % sizeof(T) == 0)) {
+    if (EXPECT(vkGetGpuInfo(gpu, type, &size, NULL) == VK_SUCCESS && size % sizeof(T) == 0)) {
         info.resize(size / sizeof(T));
-        if (!EXPECT(xglGetGpuInfo(gpu, type, &size, &info[0]) == XGL_SUCCESS && size == info.size() * sizeof(T)))
+        if (!EXPECT(vkGetGpuInfo(gpu, type, &size, &info[0]) == VK_SUCCESS && size == info.size() * sizeof(T)))
             info.clear();
     }
 
@@ -78,13 +78,13 @@
 }
 
 template<typename T>
-std::vector<T> get_info(XGL_BASE_OBJECT obj, XGL_OBJECT_INFO_TYPE type, size_t min_elems)
+std::vector<T> get_info(VK_BASE_OBJECT obj, VK_OBJECT_INFO_TYPE type, size_t min_elems)
 {
     std::vector<T> info;
     size_t size;
-    if (EXPECT(xglGetObjectInfo(obj, type, &size, NULL) == XGL_SUCCESS && size % sizeof(T) == 0)) {
+    if (EXPECT(vkGetObjectInfo(obj, type, &size, NULL) == VK_SUCCESS && size % sizeof(T) == 0)) {
         info.resize(size / sizeof(T));
-        if (!EXPECT(xglGetObjectInfo(obj, type, &size, &info[0]) == XGL_SUCCESS && size == info.size() * sizeof(T)))
+        if (!EXPECT(vkGetObjectInfo(obj, type, &size, &info[0]) == VK_SUCCESS && size == info.size() * sizeof(T)))
             info.clear();
     }
 
@@ -96,31 +96,31 @@
 
 } // namespace
 
-namespace xgl_testing {
+namespace vk_testing {
 
 void set_error_callback(ErrorCallback callback)
 {
     error_callback = callback;
 }
 
-XGL_PHYSICAL_GPU_PROPERTIES PhysicalGpu::properties() const
+VK_PHYSICAL_GPU_PROPERTIES PhysicalGpu::properties() const
 {
-    return get_info<XGL_PHYSICAL_GPU_PROPERTIES>(gpu_, XGL_INFO_TYPE_PHYSICAL_GPU_PROPERTIES, 1)[0];
+    return get_info<VK_PHYSICAL_GPU_PROPERTIES>(gpu_, VK_INFO_TYPE_PHYSICAL_GPU_PROPERTIES, 1)[0];
 }
 
-XGL_PHYSICAL_GPU_PERFORMANCE PhysicalGpu::performance() const
+VK_PHYSICAL_GPU_PERFORMANCE PhysicalGpu::performance() const
 {
-    return get_info<XGL_PHYSICAL_GPU_PERFORMANCE>(gpu_, XGL_INFO_TYPE_PHYSICAL_GPU_PERFORMANCE, 1)[0];
+    return get_info<VK_PHYSICAL_GPU_PERFORMANCE>(gpu_, VK_INFO_TYPE_PHYSICAL_GPU_PERFORMANCE, 1)[0];
 }
 
-std::vector<XGL_PHYSICAL_GPU_QUEUE_PROPERTIES> PhysicalGpu::queue_properties() const
+std::vector<VK_PHYSICAL_GPU_QUEUE_PROPERTIES> PhysicalGpu::queue_properties() const
 {
-    return get_info<XGL_PHYSICAL_GPU_QUEUE_PROPERTIES>(gpu_, XGL_INFO_TYPE_PHYSICAL_GPU_QUEUE_PROPERTIES, 0);
+    return get_info<VK_PHYSICAL_GPU_QUEUE_PROPERTIES>(gpu_, VK_INFO_TYPE_PHYSICAL_GPU_QUEUE_PROPERTIES, 0);
 }
 
-XGL_PHYSICAL_GPU_MEMORY_PROPERTIES PhysicalGpu::memory_properties() const
+VK_PHYSICAL_GPU_MEMORY_PROPERTIES PhysicalGpu::memory_properties() const
 {
-    return get_info<XGL_PHYSICAL_GPU_MEMORY_PROPERTIES>(gpu_, XGL_INFO_TYPE_PHYSICAL_GPU_MEMORY_PROPERTIES, 1)[0];
+    return get_info<VK_PHYSICAL_GPU_MEMORY_PROPERTIES>(gpu_, VK_INFO_TYPE_PHYSICAL_GPU_MEMORY_PROPERTIES, 1)[0];
 }
 
 std::vector<const char *> PhysicalGpu::layers(std::vector<char> &buf) const
@@ -137,7 +137,7 @@
 
     char * const *out = const_cast<char * const *>(&layers[0]);
     size_t count;
-    if (!EXPECT(xglEnumerateLayers(gpu_, max_layer_count, max_string_size, &count, out, NULL) == XGL_SUCCESS))
+    if (!EXPECT(vkEnumerateLayers(gpu_, max_layer_count, max_string_size, &count, out, NULL) == VK_SUCCESS))
         count = 0;
     layers.resize(count);
 
@@ -147,35 +147,35 @@
 std::vector<const char *> PhysicalGpu::extensions() const
 {
     static const char *known_exts[] = {
-        "XGL_WSI_X11",
+        "VK_WSI_X11",
     };
 
     std::vector<const char *> exts;
     for (int i = 0; i < sizeof(known_exts) / sizeof(known_exts[0]); i++) {
-        XGL_RESULT err = xglGetExtensionSupport(gpu_, known_exts[i]);
-        if (err == XGL_SUCCESS)
+        VK_RESULT err = vkGetExtensionSupport(gpu_, known_exts[i]);
+        if (err == VK_SUCCESS)
             exts.push_back(known_exts[i]);
     }
 
     return exts;
 }
 
-XGL_GPU_COMPATIBILITY_INFO PhysicalGpu::compatibility(const PhysicalGpu &other) const
+VK_GPU_COMPATIBILITY_INFO PhysicalGpu::compatibility(const PhysicalGpu &other) const
 {
-    XGL_GPU_COMPATIBILITY_INFO data;
-    if (!EXPECT(xglGetMultiGpuCompatibility(gpu_, other.gpu_, &data) == XGL_SUCCESS))
+    VK_GPU_COMPATIBILITY_INFO data;
+    if (!EXPECT(vkGetMultiGpuCompatibility(gpu_, other.gpu_, &data) == VK_SUCCESS))
         memset(&data, 0, sizeof(data));
 
     return data;
 }
 
-void BaseObject::init(XGL_BASE_OBJECT obj, bool own)
+void BaseObject::init(VK_BASE_OBJECT obj, bool own)
 {
     EXPECT(!initialized());
     reinit(obj, own);
 }
 
-void BaseObject::reinit(XGL_BASE_OBJECT obj, bool own)
+void BaseObject::reinit(VK_BASE_OBJECT obj, bool own)
 {
     obj_ = obj;
     own_obj_ = own;
@@ -183,19 +183,19 @@
 
 uint32_t BaseObject::memory_allocation_count() const
 {
-    return get_info<uint32_t>(obj_, XGL_INFO_TYPE_MEMORY_ALLOCATION_COUNT, 1)[0];
+    return get_info<uint32_t>(obj_, VK_INFO_TYPE_MEMORY_ALLOCATION_COUNT, 1)[0];
 }
 
-std::vector<XGL_MEMORY_REQUIREMENTS> BaseObject::memory_requirements() const
+std::vector<VK_MEMORY_REQUIREMENTS> BaseObject::memory_requirements() const
 {
-    XGL_RESULT err;
+    VK_RESULT err;
     uint32_t num_allocations = 0;
     size_t num_alloc_size = sizeof(num_allocations);
-    err = xglGetObjectInfo(obj_, XGL_INFO_TYPE_MEMORY_ALLOCATION_COUNT,
+    err = vkGetObjectInfo(obj_, VK_INFO_TYPE_MEMORY_ALLOCATION_COUNT,
                            &num_alloc_size, &num_allocations);
-    EXPECT(err == XGL_SUCCESS && num_alloc_size == sizeof(num_allocations));
-    std::vector<XGL_MEMORY_REQUIREMENTS> info =
-        get_info<XGL_MEMORY_REQUIREMENTS>(obj_, XGL_INFO_TYPE_MEMORY_REQUIREMENTS, 0);
+    EXPECT(err == VK_SUCCESS && num_alloc_size == sizeof(num_allocations));
+    std::vector<VK_MEMORY_REQUIREMENTS> info =
+        get_info<VK_MEMORY_REQUIREMENTS>(obj_, VK_INFO_TYPE_MEMORY_REQUIREMENTS, 0);
     EXPECT(info.size() == num_allocations);
     if (info.size() == 1 && !info[0].size)
         info.clear();
@@ -203,13 +203,13 @@
     return info;
 }
 
-void Object::init(XGL_OBJECT obj, bool own)
+void Object::init(VK_OBJECT obj, bool own)
 {
     BaseObject::init(obj, own);
     mem_alloc_count_ = memory_allocation_count();
 }
 
-void Object::reinit(XGL_OBJECT obj, bool own)
+void Object::reinit(VK_OBJECT obj, bool own)
 {
     cleanup();
     BaseObject::reinit(obj, own);
@@ -232,23 +232,23 @@
     mem_alloc_count_ = 0;
 
     if (own())
-        EXPECT(xglDestroyObject(obj()) == XGL_SUCCESS);
+        EXPECT(vkDestroyObject(obj()) == VK_SUCCESS);
 }
 
-void Object::bind_memory(uint32_t alloc_idx, const GpuMemory &mem, XGL_GPU_SIZE mem_offset)
+void Object::bind_memory(uint32_t alloc_idx, const GpuMemory &mem, VK_GPU_SIZE mem_offset)
 {
-    EXPECT(xglBindObjectMemory(obj(), alloc_idx, mem.obj(), mem_offset) == XGL_SUCCESS);
+    EXPECT(vkBindObjectMemory(obj(), alloc_idx, mem.obj(), mem_offset) == VK_SUCCESS);
 }
 
-void Object::bind_memory(uint32_t alloc_idx, XGL_GPU_SIZE offset, XGL_GPU_SIZE size,
-                         const GpuMemory &mem, XGL_GPU_SIZE mem_offset)
+void Object::bind_memory(uint32_t alloc_idx, VK_GPU_SIZE offset, VK_GPU_SIZE size,
+                         const GpuMemory &mem, VK_GPU_SIZE mem_offset)
 {
-    EXPECT(!alloc_idx && xglBindObjectMemoryRange(obj(), 0, offset, size, mem.obj(), mem_offset) == XGL_SUCCESS);
+    EXPECT(!alloc_idx && vkBindObjectMemoryRange(obj(), 0, offset, size, mem.obj(), mem_offset) == VK_SUCCESS);
 }
 
 void Object::unbind_memory(uint32_t alloc_idx)
 {
-    EXPECT(xglBindObjectMemory(obj(), alloc_idx, XGL_NULL_HANDLE, 0) == XGL_SUCCESS);
+    EXPECT(vkBindObjectMemory(obj(), alloc_idx, VK_NULL_HANDLE, 0) == VK_SUCCESS);
 }
 
 void Object::unbind_memory()
@@ -264,20 +264,20 @@
 
     internal_mems_ = new GpuMemory[mem_alloc_count_];
 
-    const std::vector<XGL_MEMORY_REQUIREMENTS> mem_reqs = memory_requirements();
-    std::vector<XGL_IMAGE_MEMORY_REQUIREMENTS> img_reqs;
-    std::vector<XGL_BUFFER_MEMORY_REQUIREMENTS> buf_reqs;
-    XGL_MEMORY_ALLOC_IMAGE_INFO img_info;
-    XGL_MEMORY_ALLOC_BUFFER_INFO buf_info;
-    XGL_MEMORY_ALLOC_INFO info, *next_info = NULL;
+    const std::vector<VK_MEMORY_REQUIREMENTS> mem_reqs = memory_requirements();
+    std::vector<VK_IMAGE_MEMORY_REQUIREMENTS> img_reqs;
+    std::vector<VK_BUFFER_MEMORY_REQUIREMENTS> buf_reqs;
+    VK_MEMORY_ALLOC_IMAGE_INFO img_info;
+    VK_MEMORY_ALLOC_BUFFER_INFO buf_info;
+    VK_MEMORY_ALLOC_INFO info, *next_info = NULL;
 
     if (for_img) {
-        img_reqs = get_info<XGL_IMAGE_MEMORY_REQUIREMENTS>(obj(),
-                        XGL_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS, 0);
+        img_reqs = get_info<VK_IMAGE_MEMORY_REQUIREMENTS>(obj(),
+                        VK_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS, 0);
         EXPECT(img_reqs.size() == 1);
-        next_info = (XGL_MEMORY_ALLOC_INFO *) &img_info;
+        next_info = (VK_MEMORY_ALLOC_INFO *) &img_info;
         img_info.pNext = NULL;
-        img_info.sType = XGL_STRUCTURE_TYPE_MEMORY_ALLOC_IMAGE_INFO;
+        img_info.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOC_IMAGE_INFO;
         img_info.usage = img_reqs[0].usage;
         img_info.formatClass = img_reqs[0].formatClass;
         img_info.samples = img_reqs[0].samples;
@@ -285,14 +285,14 @@
 
 
     if (for_buf) {
-        buf_reqs = get_info<XGL_BUFFER_MEMORY_REQUIREMENTS>(obj(),
-                        XGL_INFO_TYPE_BUFFER_MEMORY_REQUIREMENTS, 0);
+        buf_reqs = get_info<VK_BUFFER_MEMORY_REQUIREMENTS>(obj(),
+                        VK_INFO_TYPE_BUFFER_MEMORY_REQUIREMENTS, 0);
         if (for_img)
             img_info.pNext = &buf_info;
         else
-            next_info = (XGL_MEMORY_ALLOC_INFO *) &buf_info;
+            next_info = (VK_MEMORY_ALLOC_INFO *) &buf_info;
         buf_info.pNext = NULL;
-        buf_info.sType = XGL_STRUCTURE_TYPE_MEMORY_ALLOC_BUFFER_INFO;
+        buf_info.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOC_BUFFER_INFO;
         buf_info.usage = buf_reqs[0].usage;
     }
 
@@ -301,12 +301,12 @@
         info = GpuMemory::alloc_info(mem_reqs[i], next_info);
 
         switch (info.memType) {
-        case XGL_MEMORY_TYPE_BUFFER:
+        case VK_MEMORY_TYPE_BUFFER:
             EXPECT(for_buf);
-            info.memProps |= XGL_MEMORY_PROPERTY_CPU_VISIBLE_BIT;
+            info.memProps |= VK_MEMORY_PROPERTY_CPU_VISIBLE_BIT;
             primary_mem_ = &internal_mems_[i];
             break;
-        case XGL_MEMORY_TYPE_IMAGE:
+        case VK_MEMORY_TYPE_IMAGE:
             EXPECT(for_img);
             primary_mem_ = &internal_mems_[i];
             break;
@@ -319,14 +319,14 @@
     }
 }
 
-void Object::alloc_memory(const std::vector<XGL_GPU_MEMORY> &mems)
+void Object::alloc_memory(const std::vector<VK_GPU_MEMORY> &mems)
 {
     if (!EXPECT(!internal_mems_) || !mem_alloc_count_)
         return;
 
     internal_mems_ = new GpuMemory[mem_alloc_count_];
 
-    const std::vector<XGL_MEMORY_REQUIREMENTS> mem_reqs = memory_requirements();
+    const std::vector<VK_MEMORY_REQUIREMENTS> mem_reqs = memory_requirements();
     if (!EXPECT(mem_reqs.size() == mems.size()))
         return;
 
@@ -338,9 +338,9 @@
     }
 }
 
-std::vector<XGL_GPU_MEMORY> Object::memories() const
+std::vector<VK_GPU_MEMORY> Object::memories() const
 {
-    std::vector<XGL_GPU_MEMORY> mems;
+    std::vector<VK_GPU_MEMORY> mems;
     if (internal_mems_) {
         mems.reserve(mem_alloc_count_);
         for (uint32_t i = 0; i < mem_alloc_count_; i++)
@@ -361,27 +361,27 @@
         queues_[i].clear();
     }
 
-    EXPECT(xglDestroyDevice(obj()) == XGL_SUCCESS);
+    EXPECT(vkDestroyDevice(obj()) == VK_SUCCESS);
 }
 
 void Device::init(bool enable_layers)
 {
     // request all queues
-    const std::vector<XGL_PHYSICAL_GPU_QUEUE_PROPERTIES> queue_props = gpu_.queue_properties();
-    std::vector<XGL_DEVICE_QUEUE_CREATE_INFO> queue_info;
+    const std::vector<VK_PHYSICAL_GPU_QUEUE_PROPERTIES> queue_props = gpu_.queue_properties();
+    std::vector<VK_DEVICE_QUEUE_CREATE_INFO> queue_info;
     queue_info.reserve(queue_props.size());
     for (int i = 0; i < queue_props.size(); i++) {
-        XGL_DEVICE_QUEUE_CREATE_INFO qi = {};
+        VK_DEVICE_QUEUE_CREATE_INFO qi = {};
         qi.queueNodeIndex = i;
         qi.queueCount = queue_props[i].queueCount;
-        if (queue_props[i].queueFlags & XGL_QUEUE_GRAPHICS_BIT) {
+        if (queue_props[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) {
             graphics_queue_node_index_ = i;
         }
         queue_info.push_back(qi);
     }
 
-    XGL_LAYER_CREATE_INFO layer_info = {};
-    layer_info.sType = XGL_STRUCTURE_TYPE_LAYER_CREATE_INFO;
+    VK_LAYER_CREATE_INFO layer_info = {};
+    layer_info.sType = VK_STRUCTURE_TYPE_LAYER_CREATE_INFO;
 
     std::vector<const char *> layers;
     std::vector<char> layer_buf;
@@ -394,22 +394,22 @@
 
     const std::vector<const char *> exts = gpu_.extensions();
 
-    XGL_DEVICE_CREATE_INFO dev_info = {};
-    dev_info.sType = XGL_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
+    VK_DEVICE_CREATE_INFO dev_info = {};
+    dev_info.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
     dev_info.pNext = (enable_layers) ? static_cast<void *>(&layer_info) : NULL;
     dev_info.queueRecordCount = queue_info.size();
     dev_info.pRequestedQueues = &queue_info[0];
     dev_info.extensionCount = exts.size();
     dev_info.ppEnabledExtensionNames = &exts[0];
-    dev_info.maxValidationLevel = XGL_VALIDATION_LEVEL_END_RANGE;
-    dev_info.flags = XGL_DEVICE_CREATE_VALIDATION_BIT;
+    dev_info.maxValidationLevel = VK_VALIDATION_LEVEL_END_RANGE;
+    dev_info.flags = VK_DEVICE_CREATE_VALIDATION_BIT;
 
     init(dev_info);
 }
 
-void Device::init(const XGL_DEVICE_CREATE_INFO &info)
+void Device::init(const VK_DEVICE_CREATE_INFO &info)
 {
-    DERIVED_OBJECT_INIT(xglCreateDevice, gpu_.obj(), &info);
+    DERIVED_OBJECT_INIT(vkCreateDevice, gpu_.obj(), &info);
 
     init_queues();
     init_formats();
@@ -417,39 +417,39 @@
 
 void Device::init_queues()
 {
-    XGL_RESULT err;
+    VK_RESULT err;
     size_t data_size;
     uint32_t queue_node_count;
 
-    err = xglGetGpuInfo(gpu_.obj(), XGL_INFO_TYPE_PHYSICAL_GPU_QUEUE_PROPERTIES,
+    err = vkGetGpuInfo(gpu_.obj(), VK_INFO_TYPE_PHYSICAL_GPU_QUEUE_PROPERTIES,
                         &data_size, NULL);
-    EXPECT(err == XGL_SUCCESS);
+    EXPECT(err == VK_SUCCESS);
 
-    queue_node_count = data_size / sizeof(XGL_PHYSICAL_GPU_QUEUE_PROPERTIES);
+    queue_node_count = data_size / sizeof(VK_PHYSICAL_GPU_QUEUE_PROPERTIES);
     EXPECT(queue_node_count >= 1);
 
-    XGL_PHYSICAL_GPU_QUEUE_PROPERTIES queue_props[queue_node_count];
+    VK_PHYSICAL_GPU_QUEUE_PROPERTIES queue_props[queue_node_count];
 
-    err = xglGetGpuInfo(gpu_.obj(), XGL_INFO_TYPE_PHYSICAL_GPU_QUEUE_PROPERTIES,
+    err = vkGetGpuInfo(gpu_.obj(), VK_INFO_TYPE_PHYSICAL_GPU_QUEUE_PROPERTIES,
                         &data_size, queue_props);
-    EXPECT(err == XGL_SUCCESS);
+    EXPECT(err == VK_SUCCESS);
 
     for (int i = 0; i < queue_node_count; i++) {
-        XGL_QUEUE queue;
+        VK_QUEUE queue;
 
         for (int j = 0; j < queue_props[i].queueCount; j++) {
-            err = xglGetDeviceQueue(obj(), i, j, &queue);
-            EXPECT(err == XGL_SUCCESS);
+            err = vkGetDeviceQueue(obj(), i, j, &queue);
+            EXPECT(err == VK_SUCCESS);
 
-            if (queue_props[i].queueFlags & XGL_QUEUE_GRAPHICS_BIT) {
+            if (queue_props[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) {
                 queues_[GRAPHICS].push_back(new Queue(queue));
             }
 
-            if (queue_props[i].queueFlags & XGL_QUEUE_COMPUTE_BIT) {
+            if (queue_props[i].queueFlags & VK_QUEUE_COMPUTE_BIT) {
                 queues_[COMPUTE].push_back(new Queue(queue));
             }
 
-            if (queue_props[i].queueFlags & XGL_QUEUE_DMA_BIT) {
+            if (queue_props[i].queueFlags & VK_QUEUE_DMA_BIT) {
                 queues_[DMA].push_back(new Queue(queue));
             }
         }
@@ -460,17 +460,17 @@
 
 void Device::init_formats()
 {
-    for (int f = XGL_FMT_BEGIN_RANGE; f <= XGL_FMT_END_RANGE; f++) {
-        const XGL_FORMAT fmt = static_cast<XGL_FORMAT>(f);
-        const XGL_FORMAT_PROPERTIES props = format_properties(fmt);
+    for (int f = VK_FMT_BEGIN_RANGE; f <= VK_FMT_END_RANGE; f++) {
+        const VK_FORMAT fmt = static_cast<VK_FORMAT>(f);
+        const VK_FORMAT_PROPERTIES props = format_properties(fmt);
 
         if (props.linearTilingFeatures) {
-            const Format tmp = { fmt, XGL_LINEAR_TILING, props.linearTilingFeatures };
+            const Format tmp = { fmt, VK_LINEAR_TILING, props.linearTilingFeatures };
             formats_.push_back(tmp);
         }
 
         if (props.optimalTilingFeatures) {
-            const Format tmp = { fmt, XGL_OPTIMAL_TILING, props.optimalTilingFeatures };
+            const Format tmp = { fmt, VK_OPTIMAL_TILING, props.optimalTilingFeatures };
             formats_.push_back(tmp);
         }
     }
@@ -478,12 +478,12 @@
     EXPECT(!formats_.empty());
 }
 
-XGL_FORMAT_PROPERTIES Device::format_properties(XGL_FORMAT format)
+VK_FORMAT_PROPERTIES Device::format_properties(VK_FORMAT format)
 {
-    const XGL_FORMAT_INFO_TYPE type = XGL_INFO_TYPE_FORMAT_PROPERTIES;
-    XGL_FORMAT_PROPERTIES data;
+    const VK_FORMAT_INFO_TYPE type = VK_INFO_TYPE_FORMAT_PROPERTIES;
+    VK_FORMAT_PROPERTIES data;
     size_t size = sizeof(data);
-    if (!EXPECT(xglGetFormatInfo(obj(), format, type, &size, &data) == XGL_SUCCESS && size == sizeof(data)))
+    if (!EXPECT(vkGetFormatInfo(obj(), format, type, &size, &data) == VK_SUCCESS && size == sizeof(data)))
         memset(&data, 0, sizeof(data));
 
     return data;
@@ -491,32 +491,32 @@
 
 void Device::wait()
 {
-    EXPECT(xglDeviceWaitIdle(obj()) == XGL_SUCCESS);
+    EXPECT(vkDeviceWaitIdle(obj()) == VK_SUCCESS);
 }
 
-XGL_RESULT Device::wait(const std::vector<const Fence *> &fences, bool wait_all, uint64_t timeout)
+VK_RESULT Device::wait(const std::vector<const Fence *> &fences, bool wait_all, uint64_t timeout)
 {
-    const std::vector<XGL_FENCE> fence_objs = make_objects<XGL_FENCE>(fences);
-    XGL_RESULT err = xglWaitForFences(obj(), fence_objs.size(), &fence_objs[0], wait_all, timeout);
-    EXPECT(err == XGL_SUCCESS || err == XGL_TIMEOUT);
+    const std::vector<VK_FENCE> fence_objs = make_objects<VK_FENCE>(fences);
+    VK_RESULT err = vkWaitForFences(obj(), fence_objs.size(), &fence_objs[0], wait_all, timeout);
+    EXPECT(err == VK_SUCCESS || err == VK_TIMEOUT);
 
     return err;
 }
 
-void Device::begin_descriptor_pool_update(XGL_DESCRIPTOR_UPDATE_MODE mode)
+void Device::begin_descriptor_pool_update(VK_DESCRIPTOR_UPDATE_MODE mode)
 {
-    EXPECT(xglBeginDescriptorPoolUpdate(obj(), mode) == XGL_SUCCESS);
+    EXPECT(vkBeginDescriptorPoolUpdate(obj(), mode) == VK_SUCCESS);
 }
 
 void Device::end_descriptor_pool_update(CmdBuffer &cmd)
 {
-    EXPECT(xglEndDescriptorPoolUpdate(obj(), cmd.obj()) == XGL_SUCCESS);
+    EXPECT(vkEndDescriptorPoolUpdate(obj(), cmd.obj()) == VK_SUCCESS);
 }
 
 void Queue::submit(const std::vector<const CmdBuffer *> &cmds, Fence &fence)
 {
-    const std::vector<XGL_CMD_BUFFER> cmd_objs = make_objects<XGL_CMD_BUFFER>(cmds);
-    EXPECT(xglQueueSubmit(obj(), cmd_objs.size(), &cmd_objs[0], fence.obj()) == XGL_SUCCESS);
+    const std::vector<VK_CMD_BUFFER> cmd_objs = make_objects<VK_CMD_BUFFER>(cmds);
+    EXPECT(vkQueueSubmit(obj(), cmd_objs.size(), &cmd_objs[0], fence.obj()) == VK_SUCCESS);
 }
 
 void Queue::submit(const CmdBuffer &cmd, Fence &fence)
@@ -530,79 +530,79 @@
     submit(cmd, fence);
 }
 
-void Queue::add_mem_references(const std::vector<XGL_GPU_MEMORY> &mem_refs)
+void Queue::add_mem_references(const std::vector<VK_GPU_MEMORY> &mem_refs)
 {
     for (int i = 0; i < mem_refs.size(); i++) {
-        EXPECT(xglQueueAddMemReference(obj(), mem_refs[i]) == XGL_SUCCESS);
+        EXPECT(vkQueueAddMemReference(obj(), mem_refs[i]) == VK_SUCCESS);
     }
 }
 
-void Queue::remove_mem_references(const std::vector<XGL_GPU_MEMORY> &mem_refs)
+void Queue::remove_mem_references(const std::vector<VK_GPU_MEMORY> &mem_refs)
 {
     for (int i = 0; i < mem_refs.size(); i++) {
-        EXPECT(xglQueueRemoveMemReference(obj(), mem_refs[i]) == XGL_SUCCESS);
+        EXPECT(vkQueueRemoveMemReference(obj(), mem_refs[i]) == VK_SUCCESS);
     }
 }
 
 void Queue::wait()
 {
-    EXPECT(xglQueueWaitIdle(obj()) == XGL_SUCCESS);
+    EXPECT(vkQueueWaitIdle(obj()) == VK_SUCCESS);
 }
 
 void Queue::signal_semaphore(Semaphore &sem)
 {
-    EXPECT(xglQueueSignalSemaphore(obj(), sem.obj()) == XGL_SUCCESS);
+    EXPECT(vkQueueSignalSemaphore(obj(), sem.obj()) == VK_SUCCESS);
 }
 
 void Queue::wait_semaphore(Semaphore &sem)
 {
-    EXPECT(xglQueueWaitSemaphore(obj(), sem.obj()) == XGL_SUCCESS);
+    EXPECT(vkQueueWaitSemaphore(obj(), sem.obj()) == VK_SUCCESS);
 }
 
 GpuMemory::~GpuMemory()
 {
     if (initialized() && own())
-        EXPECT(xglFreeMemory(obj()) == XGL_SUCCESS);
+        EXPECT(vkFreeMemory(obj()) == VK_SUCCESS);
 }
 
-void GpuMemory::init(const Device &dev, const XGL_MEMORY_ALLOC_INFO &info)
+void GpuMemory::init(const Device &dev, const VK_MEMORY_ALLOC_INFO &info)
 {
-    DERIVED_OBJECT_INIT(xglAllocMemory, dev.obj(), &info);
+    DERIVED_OBJECT_INIT(vkAllocMemory, dev.obj(), &info);
 }
 
 void GpuMemory::init(const Device &dev, size_t size, const void *data)
 {
-    DERIVED_OBJECT_INIT(xglPinSystemMemory, dev.obj(), data, size);
+    DERIVED_OBJECT_INIT(vkPinSystemMemory, dev.obj(), data, size);
 }
 
-void GpuMemory::init(const Device &dev, const XGL_MEMORY_OPEN_INFO &info)
+void GpuMemory::init(const Device &dev, const VK_MEMORY_OPEN_INFO &info)
 {
-    DERIVED_OBJECT_INIT(xglOpenSharedMemory, dev.obj(), &info);
+    DERIVED_OBJECT_INIT(vkOpenSharedMemory, dev.obj(), &info);
 }
 
-void GpuMemory::init(const Device &dev, const XGL_PEER_MEMORY_OPEN_INFO &info)
+void GpuMemory::init(const Device &dev, const VK_PEER_MEMORY_OPEN_INFO &info)
 {
-    DERIVED_OBJECT_INIT(xglOpenPeerMemory, dev.obj(), &info);
+    DERIVED_OBJECT_INIT(vkOpenPeerMemory, dev.obj(), &info);
 }
 
-void GpuMemory::set_priority(XGL_MEMORY_PRIORITY priority)
+void GpuMemory::set_priority(VK_MEMORY_PRIORITY priority)
 {
-    EXPECT(xglSetMemoryPriority(obj(), priority) == XGL_SUCCESS);
+    EXPECT(vkSetMemoryPriority(obj(), priority) == VK_SUCCESS);
 }
 
-const void *GpuMemory::map(XGL_FLAGS flags) const
+const void *GpuMemory::map(VK_FLAGS flags) const
 {
     void *data;
-    if (!EXPECT(xglMapMemory(obj(), flags, &data) == XGL_SUCCESS))
+    if (!EXPECT(vkMapMemory(obj(), flags, &data) == VK_SUCCESS))
         data = NULL;
 
     return data;
 }
 
-void *GpuMemory::map(XGL_FLAGS flags)
+void *GpuMemory::map(VK_FLAGS flags)
 {
     void *data;
-    if (!EXPECT(xglMapMemory(obj(), flags, &data) == XGL_SUCCESS))
+    if (!EXPECT(vkMapMemory(obj(), flags, &data) == VK_SUCCESS))
         data = NULL;
 
     return data;
@@ -610,104 +610,104 @@
 
 void GpuMemory::unmap() const
 {
-    EXPECT(xglUnmapMemory(obj()) == XGL_SUCCESS);
+    EXPECT(vkUnmapMemory(obj()) == VK_SUCCESS);
 }
 
-void Fence::init(const Device &dev, const XGL_FENCE_CREATE_INFO &info)
+void Fence::init(const Device &dev, const VK_FENCE_CREATE_INFO &info)
 {
-    DERIVED_OBJECT_INIT(xglCreateFence, dev.obj(), &info);
+    DERIVED_OBJECT_INIT(vkCreateFence, dev.obj(), &info);
     alloc_memory(dev);
 }
 
-void Semaphore::init(const Device &dev, const XGL_SEMAPHORE_CREATE_INFO &info)
+void Semaphore::init(const Device &dev, const VK_SEMAPHORE_CREATE_INFO &info)
 {
-    DERIVED_OBJECT_INIT(xglCreateSemaphore, dev.obj(), &info);
+    DERIVED_OBJECT_INIT(vkCreateSemaphore, dev.obj(), &info);
     alloc_memory(dev);
 }
 
-void Semaphore::init(const Device &dev, const XGL_SEMAPHORE_OPEN_INFO &info)
+void Semaphore::init(const Device &dev, const VK_SEMAPHORE_OPEN_INFO &info)
 {
-    DERIVED_OBJECT_INIT(xglOpenSharedSemaphore, dev.obj(), &info);
+    DERIVED_OBJECT_INIT(vkOpenSharedSemaphore, dev.obj(), &info);
 }
 
-void Event::init(const Device &dev, const XGL_EVENT_CREATE_INFO &info)
+void Event::init(const Device &dev, const VK_EVENT_CREATE_INFO &info)
 {
-    DERIVED_OBJECT_INIT(xglCreateEvent, dev.obj(), &info);
+    DERIVED_OBJECT_INIT(vkCreateEvent, dev.obj(), &info);
     alloc_memory(dev);
 }
 
 void Event::set()
 {
-    EXPECT(xglSetEvent(obj()) == XGL_SUCCESS);
+    EXPECT(vkSetEvent(obj()) == VK_SUCCESS);
 }
 
 void Event::reset()
 {
-    EXPECT(xglResetEvent(obj()) == XGL_SUCCESS);
+    EXPECT(vkResetEvent(obj()) == VK_SUCCESS);
 }
 
-void QueryPool::init(const Device &dev, const XGL_QUERY_POOL_CREATE_INFO &info)
+void QueryPool::init(const Device &dev, const VK_QUERY_POOL_CREATE_INFO &info)
 {
-    DERIVED_OBJECT_INIT(xglCreateQueryPool, dev.obj(), &info);
+    DERIVED_OBJECT_INIT(vkCreateQueryPool, dev.obj(), &info);
     alloc_memory(dev);
 }
 
-XGL_RESULT QueryPool::results(uint32_t start, uint32_t count, size_t size, void *data)
+VK_RESULT QueryPool::results(uint32_t start, uint32_t count, size_t size, void *data)
 {
     size_t tmp = size;
-    XGL_RESULT err = xglGetQueryPoolResults(obj(), start, count, &tmp, data);
-    if (err == XGL_SUCCESS) {
+    VK_RESULT err = vkGetQueryPoolResults(obj(), start, count, &tmp, data);
+    if (err == VK_SUCCESS) {
         if (!EXPECT(tmp == size))
             memset(data, 0, size);
     } else {
-        EXPECT(err == XGL_NOT_READY);
+        EXPECT(err == VK_NOT_READY);
     }
 
     return err;
 }
 
-void Buffer::init(const Device &dev, const XGL_BUFFER_CREATE_INFO &info)
+void Buffer::init(const Device &dev, const VK_BUFFER_CREATE_INFO &info)
 {
     init_no_mem(dev, info);
     alloc_memory(dev, true, false);
 }
 
-void Buffer::init_no_mem(const Device &dev, const XGL_BUFFER_CREATE_INFO &info)
+void Buffer::init_no_mem(const Device &dev, const VK_BUFFER_CREATE_INFO &info)
 {
-    DERIVED_OBJECT_INIT(xglCreateBuffer, dev.obj(), &info);
+    DERIVED_OBJECT_INIT(vkCreateBuffer, dev.obj(), &info);
     create_info_ = info;
 }
 
-void BufferView::init(const Device &dev, const XGL_BUFFER_VIEW_CREATE_INFO &info)
+void BufferView::init(const Device &dev, const VK_BUFFER_VIEW_CREATE_INFO &info)
 {
-    DERIVED_OBJECT_INIT(xglCreateBufferView, dev.obj(), &info);
+    DERIVED_OBJECT_INIT(vkCreateBufferView, dev.obj(), &info);
     alloc_memory(dev);
 }
 
-void Image::init(const Device &dev, const XGL_IMAGE_CREATE_INFO &info)
+void Image::init(const Device &dev, const VK_IMAGE_CREATE_INFO &info)
 {
     init_no_mem(dev, info);
-    alloc_memory(dev, info.tiling == XGL_LINEAR_TILING, true);
+    alloc_memory(dev, info.tiling == VK_LINEAR_TILING, true);
 }
 
-void Image::init_no_mem(const Device &dev, const XGL_IMAGE_CREATE_INFO &info)
+void Image::init_no_mem(const Device &dev, const VK_IMAGE_CREATE_INFO &info)
 {
-    DERIVED_OBJECT_INIT(xglCreateImage, dev.obj(), &info);
+    DERIVED_OBJECT_INIT(vkCreateImage, dev.obj(), &info);
     init_info(dev, info);
 }
 
-void Image::init(const Device &dev, const XGL_PEER_IMAGE_OPEN_INFO &info, const XGL_IMAGE_CREATE_INFO &original_info)
+void Image::init(const Device &dev, const VK_PEER_IMAGE_OPEN_INFO &info, const VK_IMAGE_CREATE_INFO &original_info)
 {
-    XGL_IMAGE img;
-    XGL_GPU_MEMORY mem;
-    EXPECT(xglOpenPeerImage(dev.obj(), &info, &img, &mem) == XGL_SUCCESS);
+    VK_IMAGE img;
+    VK_GPU_MEMORY mem;
+    EXPECT(vkOpenPeerImage(dev.obj(), &info, &img, &mem) == VK_SUCCESS);
     Object::init(img);
 
     init_info(dev, original_info);
-    alloc_memory(std::vector<XGL_GPU_MEMORY>(1, mem));
+    alloc_memory(std::vector<VK_GPU_MEMORY>(1, mem));
 }
 
-void Image::init_info(const Device &dev, const XGL_IMAGE_CREATE_INFO &info)
+void Image::init_info(const Device &dev, const VK_IMAGE_CREATE_INFO &info)
 {
     create_info_ = info;
 
@@ -719,18 +719,18 @@
     }
 }
 
-void Image::bind_memory(uint32_t alloc_idx, const XGL_IMAGE_MEMORY_BIND_INFO &info,
-                        const GpuMemory &mem, XGL_GPU_SIZE mem_offset)
+void Image::bind_memory(uint32_t alloc_idx, const VK_IMAGE_MEMORY_BIND_INFO &info,
+                        const GpuMemory &mem, VK_GPU_SIZE mem_offset)
 {
-    EXPECT(!alloc_idx && xglBindImageMemoryRange(obj(), 0, &info, mem.obj(), mem_offset) == XGL_SUCCESS);
+    EXPECT(!alloc_idx && vkBindImageMemoryRange(obj(), 0, &info, mem.obj(), mem_offset) == VK_SUCCESS);
 }
 
-XGL_SUBRESOURCE_LAYOUT Image::subresource_layout(const XGL_IMAGE_SUBRESOURCE &subres) const
+VK_SUBRESOURCE_LAYOUT Image::subresource_layout(const VK_IMAGE_SUBRESOURCE &subres) const
 {
-    const XGL_SUBRESOURCE_INFO_TYPE type = XGL_INFO_TYPE_SUBRESOURCE_LAYOUT;
-    XGL_SUBRESOURCE_LAYOUT data;
+    const VK_SUBRESOURCE_INFO_TYPE type = VK_INFO_TYPE_SUBRESOURCE_LAYOUT;
+    VK_SUBRESOURCE_LAYOUT data;
     size_t size = sizeof(data);
-    if (!EXPECT(xglGetImageSubresourceInfo(obj(), &subres, type, &size, &data) == XGL_SUCCESS && size == sizeof(data)))
+    if (!EXPECT(vkGetImageSubresourceInfo(obj(), &subres, type, &size, &data) == VK_SUCCESS && size == sizeof(data)))
         memset(&data, 0, sizeof(data));
 
     return data;
@@ -738,69 +738,69 @@
 
 bool Image::transparent() const
 {
-    return (create_info_.tiling == XGL_LINEAR_TILING &&
+    return (create_info_.tiling == VK_LINEAR_TILING &&
             create_info_.samples == 1 &&
-            !(create_info_.usage & (XGL_IMAGE_USAGE_COLOR_ATTACHMENT_BIT |
-                                    XGL_IMAGE_USAGE_DEPTH_STENCIL_BIT)));
+            !(create_info_.usage & (VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT |
+                                    VK_IMAGE_USAGE_DEPTH_STENCIL_BIT)));
 }
 
-void ImageView::init(const Device &dev, const XGL_IMAGE_VIEW_CREATE_INFO &info)
+void ImageView::init(const Device &dev, const VK_IMAGE_VIEW_CREATE_INFO &info)
 {
-    DERIVED_OBJECT_INIT(xglCreateImageView, dev.obj(), &info);
+    DERIVED_OBJECT_INIT(vkCreateImageView, dev.obj(), &info);
     alloc_memory(dev);
 }
 
-void ColorAttachmentView::init(const Device &dev, const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO &info)
+void ColorAttachmentView::init(const Device &dev, const VK_COLOR_ATTACHMENT_VIEW_CREATE_INFO &info)
 {
-    DERIVED_OBJECT_INIT(xglCreateColorAttachmentView, dev.obj(), &info);
+    DERIVED_OBJECT_INIT(vkCreateColorAttachmentView, dev.obj(), &info);
     alloc_memory(dev);
 }
 
-void DepthStencilView::init(const Device &dev, const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO &info)
+void DepthStencilView::init(const Device &dev, const VK_DEPTH_STENCIL_VIEW_CREATE_INFO &info)
 {
-    DERIVED_OBJECT_INIT(xglCreateDepthStencilView, dev.obj(), &info);
+    DERIVED_OBJECT_INIT(vkCreateDepthStencilView, dev.obj(), &info);
     alloc_memory(dev);
 }
 
-void Shader::init(const Device &dev, const XGL_SHADER_CREATE_INFO &info)
+void Shader::init(const Device &dev, const VK_SHADER_CREATE_INFO &info)
 {
-    DERIVED_OBJECT_INIT(xglCreateShader, dev.obj(), &info);
+    DERIVED_OBJECT_INIT(vkCreateShader, dev.obj(), &info);
 }
 
-XGL_RESULT Shader::init_try(const Device &dev, const XGL_SHADER_CREATE_INFO &info)
+VK_RESULT Shader::init_try(const Device &dev, const VK_SHADER_CREATE_INFO &info)
 {
-    XGL_SHADER sh;
-    XGL_RESULT err = xglCreateShader(dev.obj(), &info, &sh);
-    if (err == XGL_SUCCESS)
+    VK_SHADER sh;
+    VK_RESULT err = vkCreateShader(dev.obj(), &info, &sh);
+    if (err == VK_SUCCESS)
         Object::init(sh);
 
     return err;
 }
 
-void Pipeline::init(const Device &dev, const XGL_GRAPHICS_PIPELINE_CREATE_INFO &info)
+void Pipeline::init(const Device &dev, const VK_GRAPHICS_PIPELINE_CREATE_INFO &info)
 {
-    DERIVED_OBJECT_INIT(xglCreateGraphicsPipeline, dev.obj(), &info);
+    DERIVED_OBJECT_INIT(vkCreateGraphicsPipeline, dev.obj(), &info);
     alloc_memory(dev);
 }
 
 void Pipeline::init(
         const Device &dev,
-        const XGL_GRAPHICS_PIPELINE_CREATE_INFO &info,
-        const XGL_PIPELINE basePipeline)
+        const VK_GRAPHICS_PIPELINE_CREATE_INFO &info,
+        const VK_PIPELINE basePipeline)
 {
-    DERIVED_OBJECT_INIT(xglCreateGraphicsPipelineDerivative, dev.obj(), &info, basePipeline);
+    DERIVED_OBJECT_INIT(vkCreateGraphicsPipelineDerivative, dev.obj(), &info, basePipeline);
     alloc_memory(dev);
 }
 
-void Pipeline::init(const Device &dev, const XGL_COMPUTE_PIPELINE_CREATE_INFO &info)
+void Pipeline::init(const Device &dev, const VK_COMPUTE_PIPELINE_CREATE_INFO &info)
 {
-    DERIVED_OBJECT_INIT(xglCreateComputePipeline, dev.obj(), &info);
+    DERIVED_OBJECT_INIT(vkCreateComputePipeline, dev.obj(), &info);
     alloc_memory(dev);
 }
 
 void Pipeline::init(const Device&dev, size_t size, const void *data)
 {
-    DERIVED_OBJECT_INIT(xglLoadPipeline, dev.obj(), size, data);
+    DERIVED_OBJECT_INIT(vkLoadPipeline, dev.obj(), size, data);
     alloc_memory(dev);
 }
 
@@ -808,68 +808,68 @@
         const Device&dev,
         size_t size,
         const void *data,
-        const XGL_PIPELINE basePipeline)
+        const VK_PIPELINE basePipeline)
 {
-    DERIVED_OBJECT_INIT(xglLoadPipelineDerivative, dev.obj(), size, data, basePipeline);
+    DERIVED_OBJECT_INIT(vkLoadPipelineDerivative, dev.obj(), size, data, basePipeline);
     alloc_memory(dev);
 }
 
 size_t Pipeline::store(size_t size, void *data)
 {
-    if (!EXPECT(xglStorePipeline(obj(), &size, data) == XGL_SUCCESS))
+    if (!EXPECT(vkStorePipeline(obj(), &size, data) == VK_SUCCESS))
         size = 0;
 
     return size;
 }
 
-void Sampler::init(const Device &dev, const XGL_SAMPLER_CREATE_INFO &info)
+void Sampler::init(const Device &dev, const VK_SAMPLER_CREATE_INFO &info)
 {
-    DERIVED_OBJECT_INIT(xglCreateSampler, dev.obj(), &info);
+    DERIVED_OBJECT_INIT(vkCreateSampler, dev.obj(), &info);
     alloc_memory(dev);
 }
 
-void DescriptorSetLayout::init(const Device &dev, const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO &info)
+void DescriptorSetLayout::init(const Device &dev, const VK_DESCRIPTOR_SET_LAYOUT_CREATE_INFO &info)
 {
-    DERIVED_OBJECT_INIT(xglCreateDescriptorSetLayout, dev.obj(), &info);
+    DERIVED_OBJECT_INIT(vkCreateDescriptorSetLayout, dev.obj(), &info);
     alloc_memory(dev);
 }
 
 void DescriptorSetLayoutChain::init(const Device &dev, const std::vector<const DescriptorSetLayout *> &layouts)
 {
-    const std::vector<XGL_DESCRIPTOR_SET_LAYOUT> layout_objs = make_objects<XGL_DESCRIPTOR_SET_LAYOUT>(layouts);
+    const std::vector<VK_DESCRIPTOR_SET_LAYOUT> layout_objs = make_objects<VK_DESCRIPTOR_SET_LAYOUT>(layouts);
 
-    DERIVED_OBJECT_INIT(xglCreateDescriptorSetLayoutChain, dev.obj(), layout_objs.size(), &layout_objs[0]);
+    DERIVED_OBJECT_INIT(vkCreateDescriptorSetLayoutChain, dev.obj(), layout_objs.size(), &layout_objs[0]);
     alloc_memory(dev);
 }
 
-void DescriptorPool::init(const Device &dev, XGL_DESCRIPTOR_POOL_USAGE usage,
-                          uint32_t max_sets, const XGL_DESCRIPTOR_POOL_CREATE_INFO &info)
+void DescriptorPool::init(const Device &dev, VK_DESCRIPTOR_POOL_USAGE usage,
+                          uint32_t max_sets, const VK_DESCRIPTOR_POOL_CREATE_INFO &info)
 {
-    DERIVED_OBJECT_INIT(xglCreateDescriptorPool, dev.obj(), usage, max_sets, &info);
+    DERIVED_OBJECT_INIT(vkCreateDescriptorPool, dev.obj(), usage, max_sets, &info);
     alloc_memory(dev);
 }
 
 void DescriptorPool::reset()
 {
-    EXPECT(xglResetDescriptorPool(obj()) == XGL_SUCCESS);
+    EXPECT(vkResetDescriptorPool(obj()) == VK_SUCCESS);
 }
 
-std::vector<DescriptorSet *> DescriptorPool::alloc_sets(XGL_DESCRIPTOR_SET_USAGE usage, const std::vector<const DescriptorSetLayout *> &layouts)
+std::vector<DescriptorSet *> DescriptorPool::alloc_sets(VK_DESCRIPTOR_SET_USAGE usage, const std::vector<const DescriptorSetLayout *> &layouts)
 {
-    const std::vector<XGL_DESCRIPTOR_SET_LAYOUT> layout_objs = make_objects<XGL_DESCRIPTOR_SET_LAYOUT>(layouts);
+    const std::vector<VK_DESCRIPTOR_SET_LAYOUT> layout_objs = make_objects<VK_DESCRIPTOR_SET_LAYOUT>(layouts);
 
-    std::vector<XGL_DESCRIPTOR_SET> set_objs;
+    std::vector<VK_DESCRIPTOR_SET> set_objs;
     set_objs.resize(layout_objs.size());
 
     uint32_t set_count;
-    XGL_RESULT err = xglAllocDescriptorSets(obj(), usage, layout_objs.size(), &layout_objs[0], &set_objs[0], &set_count);
-    if (err == XGL_SUCCESS)
+    VK_RESULT err = vkAllocDescriptorSets(obj(), usage, layout_objs.size(), &layout_objs[0], &set_objs[0], &set_count);
+    if (err == VK_SUCCESS)
         EXPECT(set_count == set_objs.size());
     set_objs.resize(set_count);
 
     std::vector<DescriptorSet *> sets;
     sets.reserve(set_count);
-    for (std::vector<XGL_DESCRIPTOR_SET>::const_iterator it = set_objs.begin(); it != set_objs.end(); it++) {
+    for (std::vector<VK_DESCRIPTOR_SET>::const_iterator it = set_objs.begin(); it != set_objs.end(); it++) {
         // do descriptor sets need memories bound?
         sets.push_back(new DescriptorSet(*it));
     }
@@ -877,12 +877,12 @@
     return sets;
 }
 
-std::vector<DescriptorSet *> DescriptorPool::alloc_sets(XGL_DESCRIPTOR_SET_USAGE usage, const DescriptorSetLayout &layout, uint32_t count)
+std::vector<DescriptorSet *> DescriptorPool::alloc_sets(VK_DESCRIPTOR_SET_USAGE usage, const DescriptorSetLayout &layout, uint32_t count)
 {
     return alloc_sets(usage, std::vector<const DescriptorSetLayout *>(count, &layout));
 }
 
-DescriptorSet *DescriptorPool::alloc_sets(XGL_DESCRIPTOR_SET_USAGE usage, const DescriptorSetLayout &layout)
+DescriptorSet *DescriptorPool::alloc_sets(VK_DESCRIPTOR_SET_USAGE usage, const DescriptorSetLayout &layout)
 {
     std::vector<DescriptorSet *> set = alloc_sets(usage, layout, 1);
     return (set.empty()) ? NULL : set[0];
@@ -890,61 +890,61 @@
 
 void DescriptorPool::clear_sets(const std::vector<DescriptorSet *> &sets)
 {
-    const std::vector<XGL_DESCRIPTOR_SET> set_objs = make_objects<XGL_DESCRIPTOR_SET>(sets);
-    xglClearDescriptorSets(obj(), set_objs.size(), &set_objs[0]);
+    const std::vector<VK_DESCRIPTOR_SET> set_objs = make_objects<VK_DESCRIPTOR_SET>(sets);
+    vkClearDescriptorSets(obj(), set_objs.size(), &set_objs[0]);
 }
 
 void DescriptorSet::update(const std::vector<const void *> &update_array)
 {
-    xglUpdateDescriptors(obj(), update_array.size(), const_cast<const void **>(&update_array[0]));
+    vkUpdateDescriptors(obj(), update_array.size(), const_cast<const void **>(&update_array[0]));
 }
 
-void DynamicVpStateObject::init(const Device &dev, const XGL_DYNAMIC_VP_STATE_CREATE_INFO &info)
+void DynamicVpStateObject::init(const Device &dev, const VK_DYNAMIC_VP_STATE_CREATE_INFO &info)
 {
-    DERIVED_OBJECT_INIT(xglCreateDynamicViewportState, dev.obj(), &info);
+    DERIVED_OBJECT_INIT(vkCreateDynamicViewportState, dev.obj(), &info);
     alloc_memory(dev);
 }
 
-void DynamicRsStateObject::init(const Device &dev, const XGL_DYNAMIC_RS_STATE_CREATE_INFO &info)
+void DynamicRsStateObject::init(const Device &dev, const VK_DYNAMIC_RS_STATE_CREATE_INFO &info)
 {
-    DERIVED_OBJECT_INIT(xglCreateDynamicRasterState, dev.obj(), &info);
+    DERIVED_OBJECT_INIT(vkCreateDynamicRasterState, dev.obj(), &info);
     alloc_memory(dev);
 }
 
-void DynamicCbStateObject::init(const Device &dev, const XGL_DYNAMIC_CB_STATE_CREATE_INFO &info)
+void DynamicCbStateObject::init(const Device &dev, const VK_DYNAMIC_CB_STATE_CREATE_INFO &info)
 {
-    DERIVED_OBJECT_INIT(xglCreateDynamicColorBlendState, dev.obj(), &info);
+    DERIVED_OBJECT_INIT(vkCreateDynamicColorBlendState, dev.obj(), &info);
     alloc_memory(dev);
 }
 
-void DynamicDsStateObject::init(const Device &dev, const XGL_DYNAMIC_DS_STATE_CREATE_INFO &info)
+void DynamicDsStateObject::init(const Device &dev, const VK_DYNAMIC_DS_STATE_CREATE_INFO &info)
 {
-    DERIVED_OBJECT_INIT(xglCreateDynamicDepthStencilState, dev.obj(), &info);
+    DERIVED_OBJECT_INIT(vkCreateDynamicDepthStencilState, dev.obj(), &info);
     alloc_memory(dev);
 }
 
-void CmdBuffer::init(const Device &dev, const XGL_CMD_BUFFER_CREATE_INFO &info)
+void CmdBuffer::init(const Device &dev, const VK_CMD_BUFFER_CREATE_INFO &info)
 {
-    DERIVED_OBJECT_INIT(xglCreateCommandBuffer, dev.obj(), &info);
+    DERIVED_OBJECT_INIT(vkCreateCommandBuffer, dev.obj(), &info);
 }
 
-void CmdBuffer::begin(const XGL_CMD_BUFFER_BEGIN_INFO *info)
+void CmdBuffer::begin(const VK_CMD_BUFFER_BEGIN_INFO *info)
 {
-    EXPECT(xglBeginCommandBuffer(obj(), info) == XGL_SUCCESS);
+    EXPECT(vkBeginCommandBuffer(obj(), info) == VK_SUCCESS);
 }
 
-void CmdBuffer::begin(XGL_RENDER_PASS renderpass_obj, XGL_FRAMEBUFFER framebuffer_obj)
+void CmdBuffer::begin(VK_RENDER_PASS renderpass_obj, VK_FRAMEBUFFER framebuffer_obj)
 {
-    XGL_CMD_BUFFER_BEGIN_INFO info = {};
-    XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO graphics_cmd_buf_info = {};
-    graphics_cmd_buf_info.sType = XGL_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO;
+    VK_CMD_BUFFER_BEGIN_INFO info = {};
+    VK_CMD_BUFFER_GRAPHICS_BEGIN_INFO graphics_cmd_buf_info = {};
+    graphics_cmd_buf_info.sType = VK_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO;
     graphics_cmd_buf_info.pNext = NULL;
     graphics_cmd_buf_info.renderPassContinue.renderPass = renderpass_obj;
     graphics_cmd_buf_info.renderPassContinue.framebuffer = framebuffer_obj;
 
-    info.flags = XGL_CMD_BUFFER_OPTIMIZE_GPU_SMALL_BATCH_BIT |
-          XGL_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT;
-    info.sType = XGL_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO;
+    info.flags = VK_CMD_BUFFER_OPTIMIZE_GPU_SMALL_BATCH_BIT |
+          VK_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT;
+    info.sType = VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO;
     info.pNext = &graphics_cmd_buf_info;
 
     begin(&info);
@@ -952,22 +952,22 @@
 
 void CmdBuffer::begin()
 {
-    XGL_CMD_BUFFER_BEGIN_INFO info = {};
-    info.flags = XGL_CMD_BUFFER_OPTIMIZE_GPU_SMALL_BATCH_BIT |
-          XGL_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT;
-    info.sType = XGL_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO;
+    VK_CMD_BUFFER_BEGIN_INFO info = {};
+    info.flags = VK_CMD_BUFFER_OPTIMIZE_GPU_SMALL_BATCH_BIT |
+          VK_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT;
+    info.sType = VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO;
 
     begin(&info);
 }
 
 void CmdBuffer::end()
 {
-    EXPECT(xglEndCommandBuffer(obj()) == XGL_SUCCESS);
+    EXPECT(vkEndCommandBuffer(obj()) == VK_SUCCESS);
 }
 
 void CmdBuffer::reset()
 {
-    EXPECT(xglResetCommandBuffer(obj()) == XGL_SUCCESS);
+    EXPECT(vkResetCommandBuffer(obj()) == VK_SUCCESS);
 }
 
-}; // namespace xgl_testing
+}; // namespace vk_testing
diff --git a/tests/xgltestbinding.h b/tests/xgltestbinding.h
deleted file mode 100644
index 387bde3..0000000
--- a/tests/xgltestbinding.h
+++ /dev/null
@@ -1,891 +0,0 @@
-// XGL tests
-//
-// Copyright (C) 2014 LunarG, Inc.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the "Software"),
-// to deal in the Software without restriction, including without limitation
-// the rights to use, copy, modify, merge, publish, distribute, sublicense,
-// and/or sell copies of the Software, and to permit persons to whom the
-// Software is furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
-// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-// DEALINGS IN THE SOFTWARE.
-
-#ifndef XGLTESTBINDING_H
-#define XGLTESTBINDING_H
-
-#include <vector>
-
-#include "xgl.h"
-
-namespace xgl_testing {
-
-typedef void (*ErrorCallback)(const char *expr, const char *file, unsigned int line, const char *function);
-void set_error_callback(ErrorCallback callback);
-
-class PhysicalGpu;
-class BaseObject;
-class Object;
-class DynamicStateObject;
-class Device;
-class Queue;
-class GpuMemory;
-class Fence;
-class Semaphore;
-class Event;
-class QueryPool;
-class Buffer;
-class BufferView;
-class Image;
-class ImageView;
-class ColorAttachmentView;
-class DepthStencilView;
-class Shader;
-class Pipeline;
-class PipelineDelta;
-class Sampler;
-class DescriptorSetLayout;
-class DescriptorSetLayoutChain;
-class DescriptorSetPool;
-class DescriptorSet;
-class DynamicVpStateObject;
-class DynamicRsStateObject;
-class DynamicMsaaStateObject;
-class DynamicCbStateObject;
-class DynamicDsStateObject;
-class CmdBuffer;
-
-class PhysicalGpu {
-public:
-    explicit PhysicalGpu(XGL_PHYSICAL_GPU gpu) : gpu_(gpu) {}
-
-    const XGL_PHYSICAL_GPU &obj() const { return gpu_; }
-
-    // xglGetGpuInfo()
-    XGL_PHYSICAL_GPU_PROPERTIES properties() const;
-    XGL_PHYSICAL_GPU_PERFORMANCE performance() const;
-    XGL_PHYSICAL_GPU_MEMORY_PROPERTIES memory_properties() const;
-    std::vector<XGL_PHYSICAL_GPU_QUEUE_PROPERTIES> queue_properties() const;
-
-    // xglGetProcAddr()
-    void *get_proc(const char *name) const { return xglGetProcAddr(gpu_, name); }
-
-    // xglGetExtensionSupport()
-    bool has_extension(const char *ext) const { return (xglGetExtensionSupport(gpu_, ext) == XGL_SUCCESS); }
-    std::vector<const char *> extensions() const;
-
-    // xglEnumerateLayers()
-    std::vector<const char *> layers(std::vector<char> &buf) const;
-
-    // xglGetMultiGpuCompatibility()
-    XGL_GPU_COMPATIBILITY_INFO compatibility(const PhysicalGpu &other) const;
-
-private:
-    XGL_PHYSICAL_GPU gpu_;
-};
-
-class BaseObject {
-public:
-    const XGL_BASE_OBJECT &obj() const { return obj_; }
-    bool initialized() const { return (obj_ != XGL_NULL_HANDLE); }
-
-    // xglGetObjectInfo()
-    uint32_t memory_allocation_count() const;
-    std::vector<XGL_MEMORY_REQUIREMENTS> memory_requirements() const;
-
-protected:
-    explicit BaseObject() : obj_(XGL_NULL_HANDLE), own_obj_(false) {}
-    explicit BaseObject(XGL_BASE_OBJECT obj) : obj_(XGL_NULL_HANDLE), own_obj_(false) { init(obj); }
-
-    void init(XGL_BASE_OBJECT obj, bool own);
-    void init(XGL_BASE_OBJECT obj) { init(obj, true); }
-
-    void reinit(XGL_BASE_OBJECT obj, bool own);
-    void reinit(XGL_BASE_OBJECT obj) { reinit(obj, true); }
-
-    bool own() const { return own_obj_; }
-
-private:
-    // base objects are non-copyable
-    BaseObject(const BaseObject &);
-    BaseObject &operator=(const BaseObject &);
-
-    XGL_BASE_OBJECT obj_;
-    bool own_obj_;
-};
-
-class Object : public BaseObject {
-public:
-    const XGL_OBJECT &obj() const { return reinterpret_cast<const XGL_OBJECT &>(BaseObject::obj()); }
-
-    // xglBindObjectMemory()
-    void bind_memory(uint32_t alloc_idx, const GpuMemory &mem, XGL_GPU_SIZE mem_offset);
-    void unbind_memory(uint32_t alloc_idx);
-    void unbind_memory();
-
-    // xglBindObjectMemoryRange()
-    void bind_memory(uint32_t alloc_idx, XGL_GPU_SIZE offset, XGL_GPU_SIZE size,
-                     const GpuMemory &mem, XGL_GPU_SIZE mem_offset);
-
-    // Unless an object is initialized with init_no_mem(), memories are
-    // automatically allocated and bound.  These methods can be used to get
-    // the memories (for xglQueueAddMemReference), or to map/unmap the primary memory.
-    std::vector<XGL_GPU_MEMORY> memories() const;
-
-    const void *map(XGL_FLAGS flags) const;
-          void *map(XGL_FLAGS flags);
-    const void *map() const { return map(0); }
-          void *map()       { return map(0); }
-
-    void unmap() const;
-
-protected:
-    explicit Object() : mem_alloc_count_(0), internal_mems_(NULL), primary_mem_(NULL) {}
-    explicit Object(XGL_OBJECT obj) : mem_alloc_count_(0), internal_mems_(NULL), primary_mem_(NULL) { init(obj); }
-    ~Object() { cleanup(); }
-
-    void init(XGL_OBJECT obj, bool own);
-    void init(XGL_OBJECT obj) { init(obj, true); }
-
-    void reinit(XGL_OBJECT obj, bool own);
-    void reinit(XGL_OBJECT obj) { init(obj, true); }
-
-    // allocate and bind internal memories
-    void alloc_memory(const Device &dev, bool for_linear_img, bool for_img);
-    void alloc_memory(const Device &dev) { alloc_memory(dev, false, false); }
-    void alloc_memory(const std::vector<XGL_GPU_MEMORY> &mems);
-
-private:
-    void cleanup();
-
-    uint32_t mem_alloc_count_;
-    GpuMemory *internal_mems_;
-    GpuMemory *primary_mem_;
-};
-
-class DynamicStateObject : public Object {
-public:
-    const XGL_DYNAMIC_STATE_OBJECT &obj() const { return reinterpret_cast<const XGL_DYNAMIC_STATE_OBJECT &>(Object::obj()); }
-
-protected:
-    explicit DynamicStateObject() {}
-    explicit DynamicStateObject(XGL_DYNAMIC_STATE_OBJECT obj) : Object(obj) {}
-};
-
-template<typename T, class C>
-class DerivedObject : public C {
-public:
-    const T &obj() const { return reinterpret_cast<const T &>(C::obj()); }
-
-protected:
-    typedef T obj_type;
-    typedef C base_type;
-
-    explicit DerivedObject() {}
-    explicit DerivedObject(T obj) : C(obj) {}
-};
-
-class Device : public DerivedObject<XGL_DEVICE, BaseObject> {
-public:
-    explicit Device(XGL_PHYSICAL_GPU gpu) : gpu_(gpu) {}
-    ~Device();
-
-    // xglCreateDevice()
-    void init(const XGL_DEVICE_CREATE_INFO &info);
-    void init(bool enable_layers); // all queues, all extensions, etc
-    void init() { init(false); };
-
-    const PhysicalGpu &gpu() const { return gpu_; }
-
-    // xglGetDeviceQueue()
-    const std::vector<Queue *> &graphics_queues() { return queues_[GRAPHICS]; }
-    const std::vector<Queue *> &compute_queues() { return queues_[COMPUTE]; }
-    const std::vector<Queue *> &dma_queues() { return queues_[DMA]; }
-    uint32_t graphics_queue_node_index_;
-
-    struct Format {
-        XGL_FORMAT format;
-        XGL_IMAGE_TILING tiling;
-        XGL_FLAGS features;
-    };
-    // xglGetFormatInfo()
-    XGL_FORMAT_PROPERTIES format_properties(XGL_FORMAT format);
-    const std::vector<Format> &formats() const { return formats_; }
-
-    // xglDeviceWaitIdle()
-    void wait();
-
-    // xglWaitForFences()
-    XGL_RESULT wait(const std::vector<const Fence *> &fences, bool wait_all, uint64_t timeout);
-    XGL_RESULT wait(const Fence &fence) { return wait(std::vector<const Fence *>(1, &fence), true, (uint64_t) -1); }
-
-    // xglBeginDescriptorPoolUpdate()
-    // xglEndDescriptorPoolUpdate()
-    void begin_descriptor_pool_update(XGL_DESCRIPTOR_UPDATE_MODE mode);
-    void end_descriptor_pool_update(CmdBuffer &cmd);
-
-private:
-    enum QueueIndex {
-        GRAPHICS,
-        COMPUTE,
-        DMA,
-        QUEUE_COUNT,
-    };
-
-    void init_queues();
-    void init_formats();
-
-    PhysicalGpu gpu_;
-
-    std::vector<Queue *> queues_[QUEUE_COUNT];
-    std::vector<Format> formats_;
-};
-
-class Queue : public DerivedObject<XGL_QUEUE, BaseObject> {
-public:
-    explicit Queue(XGL_QUEUE queue) : DerivedObject(queue) {}
-
-    // xglQueueSubmit()
-    void submit(const std::vector<const CmdBuffer *> &cmds, Fence &fence);
-    void submit(const CmdBuffer &cmd, Fence &fence);
-    void submit(const CmdBuffer &cmd);
-
-    // xglQueueAddMemReference()
-    // xglQueueRemoveMemReference()
-    void add_mem_references(const std::vector<XGL_GPU_MEMORY> &mem_refs);
-    void remove_mem_references(const std::vector<XGL_GPU_MEMORY> &mem_refs);
-
-    // xglQueueWaitIdle()
-    void wait();
-
-    // xglQueueSignalSemaphore()
-    // xglQueueWaitSemaphore()
-    void signal_semaphore(Semaphore &sem);
-    void wait_semaphore(Semaphore &sem);
-};
-
-class GpuMemory : public DerivedObject<XGL_GPU_MEMORY, BaseObject> {
-public:
-    ~GpuMemory();
-
-    // xglAllocMemory()
-    void init(const Device &dev, const XGL_MEMORY_ALLOC_INFO &info);
-    // xglPinSystemMemory()
-    void init(const Device &dev, size_t size, const void *data);
-    // xglOpenSharedMemory()
-    void init(const Device &dev, const XGL_MEMORY_OPEN_INFO &info);
-    // xglOpenPeerMemory()
-    void init(const Device &dev, const XGL_PEER_MEMORY_OPEN_INFO &info);
-
-    void init(XGL_GPU_MEMORY mem) { BaseObject::init(mem, false); }
-
-    // xglSetMemoryPriority()
-    void set_priority(XGL_MEMORY_PRIORITY priority);
-
-    // xglMapMemory()
-    const void *map(XGL_FLAGS flags) const;
-          void *map(XGL_FLAGS flags);
-    const void *map() const { return map(0); }
-          void *map()       { return map(0); }
-
-    // xglUnmapMemory()
-    void unmap() const;
-
-    static XGL_MEMORY_ALLOC_INFO alloc_info(const XGL_MEMORY_REQUIREMENTS &reqs,
-                  const XGL_MEMORY_ALLOC_INFO *next_info);
-};
-
-class Fence : public DerivedObject<XGL_FENCE, Object> {
-public:
-    // xglCreateFence()
-    void init(const Device &dev, const XGL_FENCE_CREATE_INFO &info);
-
-    // xglGetFenceStatus()
-    XGL_RESULT status() const { return xglGetFenceStatus(obj()); }
-
-    static XGL_FENCE_CREATE_INFO create_info(XGL_FENCE_CREATE_FLAGS flags);
-    static XGL_FENCE_CREATE_INFO create_info();
-};
-
-class Semaphore : public DerivedObject<XGL_SEMAPHORE, Object> {
-public:
-    // xglCreateSemaphore()
-    void init(const Device &dev, const XGL_SEMAPHORE_CREATE_INFO &info);
-    // xglOpenSharedSemaphore()
-    void init(const Device &dev, const XGL_SEMAPHORE_OPEN_INFO &info);
-
-    static XGL_SEMAPHORE_CREATE_INFO create_info(uint32_t init_count, XGL_FLAGS flags);
-};
-
-class Event : public DerivedObject<XGL_EVENT, Object> {
-public:
-    // xglCreateEvent()
-    void init(const Device &dev, const XGL_EVENT_CREATE_INFO &info);
-
-    // xglGetEventStatus()
-    // xglSetEvent()
-    // xglResetEvent()
-    XGL_RESULT status() const { return xglGetEventStatus(obj()); }
-    void set();
-    void reset();
-
-    static XGL_EVENT_CREATE_INFO create_info(XGL_FLAGS flags);
-};
-
-class QueryPool : public DerivedObject<XGL_QUERY_POOL, Object> {
-public:
-    // xglCreateQueryPool()
-    void init(const Device &dev, const XGL_QUERY_POOL_CREATE_INFO &info);
-
-    // xglGetQueryPoolResults()
-    XGL_RESULT results(uint32_t start, uint32_t count, size_t size, void *data);
-
-    static XGL_QUERY_POOL_CREATE_INFO create_info(XGL_QUERY_TYPE type, uint32_t slot_count);
-};
-
-class Buffer : public DerivedObject<XGL_BUFFER, Object> {
-public:
-    explicit Buffer() {}
-    explicit Buffer(const Device &dev, const XGL_BUFFER_CREATE_INFO &info) { init(dev, info); }
-    explicit Buffer(const Device &dev, XGL_GPU_SIZE size) { init(dev, size); }
-
-    // xglCreateBuffer()
-    void init(const Device &dev, const XGL_BUFFER_CREATE_INFO &info);
-    void init(const Device &dev, XGL_GPU_SIZE size) { init(dev, create_info(size, 0)); }
-    void init_no_mem(const Device &dev, const XGL_BUFFER_CREATE_INFO &info);
-
-    static XGL_BUFFER_CREATE_INFO create_info(XGL_GPU_SIZE size, XGL_FLAGS usage);
-
-    XGL_BUFFER_MEMORY_BARRIER buffer_memory_barrier(XGL_FLAGS output_mask, XGL_FLAGS input_mask,
-                                                 XGL_GPU_SIZE offset, XGL_GPU_SIZE size) const
-    {
-        XGL_BUFFER_MEMORY_BARRIER barrier = {};
-        barrier.sType = XGL_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER;
-        barrier.buffer = obj();
-        barrier.outputMask = output_mask;
-        barrier.inputMask = input_mask;
-        barrier.offset = offset;
-        barrier.size = size;
-        return barrier;
-    }
-private:
-    XGL_BUFFER_CREATE_INFO create_info_;
-};
-
-class BufferView : public DerivedObject<XGL_BUFFER_VIEW, Object> {
-public:
-    // xglCreateBufferView()
-    void init(const Device &dev, const XGL_BUFFER_VIEW_CREATE_INFO &info);
-};
-
-class Image : public DerivedObject<XGL_IMAGE, Object> {
-public:
-    explicit Image() : format_features_(0) {}
-    explicit Image(const Device &dev, const XGL_IMAGE_CREATE_INFO &info) : format_features_(0) { init(dev, info); }
-
-    // xglCreateImage()
-    void init(const Device &dev, const XGL_IMAGE_CREATE_INFO &info);
-    void init_no_mem(const Device &dev, const XGL_IMAGE_CREATE_INFO &info);
-    // xglOpenPeerImage()
-    void init(const Device &dev, const XGL_PEER_IMAGE_OPEN_INFO &info, const XGL_IMAGE_CREATE_INFO &original_info);
-
-    // xglBindImageMemoryRange()
-    void bind_memory(uint32_t alloc_idx, const XGL_IMAGE_MEMORY_BIND_INFO &info,
-                     const GpuMemory &mem, XGL_GPU_SIZE mem_offset);
-
-    // xglGetImageSubresourceInfo()
-    XGL_SUBRESOURCE_LAYOUT subresource_layout(const XGL_IMAGE_SUBRESOURCE &subres) const;
-
-    bool transparent() const;
-    bool copyable() const { return (format_features_ & XGL_FORMAT_IMAGE_COPY_BIT); }
-
-    XGL_IMAGE_SUBRESOURCE_RANGE subresource_range(XGL_IMAGE_ASPECT aspect) const { return subresource_range(create_info_, aspect); }
-    XGL_EXTENT3D extent() const { return create_info_.extent; }
-    XGL_EXTENT3D extent(uint32_t mip_level) const { return extent(create_info_.extent, mip_level); }
-    XGL_FORMAT format() const {return create_info_.format;}
-
-    XGL_IMAGE_MEMORY_BARRIER image_memory_barrier(XGL_FLAGS output_mask, XGL_FLAGS input_mask,
-                                                  XGL_IMAGE_LAYOUT old_layout,
-                                                  XGL_IMAGE_LAYOUT new_layout,
-                                                  const XGL_IMAGE_SUBRESOURCE_RANGE &range) const
-    {
-        XGL_IMAGE_MEMORY_BARRIER barrier = {};
-        barrier.sType = XGL_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
-        barrier.outputMask = output_mask;
-        barrier.inputMask = input_mask;
-        barrier.oldLayout = old_layout;
-        barrier.newLayout = new_layout;
-        barrier.image = obj();
-        barrier.subresourceRange = range;
-        return barrier;
-    }
-
-    static XGL_IMAGE_CREATE_INFO create_info();
-    static XGL_IMAGE_SUBRESOURCE subresource(XGL_IMAGE_ASPECT aspect, uint32_t mip_level, uint32_t array_slice);
-    static XGL_IMAGE_SUBRESOURCE subresource(const XGL_IMAGE_SUBRESOURCE_RANGE &range, uint32_t mip_level, uint32_t array_slice);
-    static XGL_IMAGE_SUBRESOURCE_RANGE subresource_range(XGL_IMAGE_ASPECT aspect, uint32_t base_mip_level, uint32_t mip_levels,
-                                                                                  uint32_t base_array_slice, uint32_t array_size);
-    static XGL_IMAGE_SUBRESOURCE_RANGE subresource_range(const XGL_IMAGE_CREATE_INFO &info, XGL_IMAGE_ASPECT aspect);
-    static XGL_IMAGE_SUBRESOURCE_RANGE subresource_range(const XGL_IMAGE_SUBRESOURCE &subres);
-
-    static XGL_EXTENT2D extent(int32_t width, int32_t height);
-    static XGL_EXTENT2D extent(const XGL_EXTENT2D &extent, uint32_t mip_level);
-    static XGL_EXTENT2D extent(const XGL_EXTENT3D &extent);
-
-    static XGL_EXTENT3D extent(int32_t width, int32_t height, int32_t depth);
-    static XGL_EXTENT3D extent(const XGL_EXTENT3D &extent, uint32_t mip_level);
-
-private:
-    void init_info(const Device &dev, const XGL_IMAGE_CREATE_INFO &info);
-
-    XGL_IMAGE_CREATE_INFO create_info_;
-    XGL_FLAGS format_features_;
-};
-
-class ImageView : public DerivedObject<XGL_IMAGE_VIEW, Object> {
-public:
-    // xglCreateImageView()
-    void init(const Device &dev, const XGL_IMAGE_VIEW_CREATE_INFO &info);
-};
-
-class ColorAttachmentView : public DerivedObject<XGL_COLOR_ATTACHMENT_VIEW, Object> {
-public:
-    // xglCreateColorAttachmentView()
-    void init(const Device &dev, const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO &info);
-};
-
-class DepthStencilView : public DerivedObject<XGL_DEPTH_STENCIL_VIEW, Object> {
-public:
-    // xglCreateDepthStencilView()
-    void init(const Device &dev, const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO &info);
-};
-
-class Shader : public DerivedObject<XGL_SHADER, Object> {
-public:
-    // xglCreateShader()
-    void init(const Device &dev, const XGL_SHADER_CREATE_INFO &info);
-    XGL_RESULT init_try(const Device &dev, const XGL_SHADER_CREATE_INFO &info);
-
-    static XGL_SHADER_CREATE_INFO create_info(size_t code_size, const void *code, XGL_FLAGS flags);
-};
-
-class Pipeline : public DerivedObject<XGL_PIPELINE, Object> {
-public:
-    // xglCreateGraphicsPipeline()
-    void init(const Device &dev, const XGL_GRAPHICS_PIPELINE_CREATE_INFO &info);
-    // xglCreateGraphicsPipelineDerivative()
-    void init(const Device &dev, const XGL_GRAPHICS_PIPELINE_CREATE_INFO &info, const XGL_PIPELINE basePipeline);
-    // xglCreateComputePipeline()
-    void init(const Device &dev, const XGL_COMPUTE_PIPELINE_CREATE_INFO &info);
-    // xglLoadPipeline()
-    void init(const Device&dev, size_t size, const void *data);
-    // xglLoadPipelineDerivative()
-    void init(const Device&dev, size_t size, const void *data, XGL_PIPELINE basePipeline);
-
-    // xglStorePipeline()
-    size_t store(size_t size, void *data);
-};
-
-class Sampler : public DerivedObject<XGL_SAMPLER, Object> {
-public:
-    // xglCreateSampler()
-    void init(const Device &dev, const XGL_SAMPLER_CREATE_INFO &info);
-};
-
-class DescriptorSetLayout : public DerivedObject<XGL_DESCRIPTOR_SET_LAYOUT, Object> {
-public:
-    // xglCreateDescriptorSetLayout()
-    void init(const Device &dev, const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO &info);
-};
-
-class DescriptorSetLayoutChain : public DerivedObject<XGL_DESCRIPTOR_SET_LAYOUT_CHAIN, Object> {
-public:
-    // xglCreateDescriptorSetLayoutChain()
-    void init(const Device &dev, const std::vector<const DescriptorSetLayout *> &layouts);
-};
-
-class DescriptorPool : public DerivedObject<XGL_DESCRIPTOR_POOL, Object> {
-public:
-    // xglCreateDescriptorPool()
-    void init(const Device &dev, XGL_DESCRIPTOR_POOL_USAGE usage,
-              uint32_t max_sets, const XGL_DESCRIPTOR_POOL_CREATE_INFO &info);
-
-    // xglResetDescriptorPool()
-    void reset();
-
-    // xglAllocDescriptorSets()
-    std::vector<DescriptorSet *> alloc_sets(XGL_DESCRIPTOR_SET_USAGE usage, const std::vector<const DescriptorSetLayout *> &layouts);
-    std::vector<DescriptorSet *> alloc_sets(XGL_DESCRIPTOR_SET_USAGE usage, const DescriptorSetLayout &layout, uint32_t count);
-    DescriptorSet *alloc_sets(XGL_DESCRIPTOR_SET_USAGE usage, const DescriptorSetLayout &layout);
-
-    // xglClearDescriptorSets()
-    void clear_sets(const std::vector<DescriptorSet *> &sets);
-    void clear_sets(DescriptorSet &set) { clear_sets(std::vector<DescriptorSet *>(1, &set)); }
-};
-
-class DescriptorSet : public DerivedObject<XGL_DESCRIPTOR_SET, Object> {
-public:
-    explicit DescriptorSet(XGL_DESCRIPTOR_SET set) : DerivedObject(set) {}
-
-    // xglUpdateDescriptors()
-    void update(const std::vector<const void *> &update_array);
-
-    static XGL_UPDATE_SAMPLERS update(uint32_t binding, uint32_t index, uint32_t count, const XGL_SAMPLER *samplers);
-    static XGL_UPDATE_SAMPLERS update(uint32_t binding, uint32_t index, const std::vector<XGL_SAMPLER> &samplers);
-
-    static XGL_UPDATE_SAMPLER_TEXTURES update(uint32_t binding, uint32_t index, uint32_t count, const XGL_SAMPLER_IMAGE_VIEW_INFO *textures);
-    static XGL_UPDATE_SAMPLER_TEXTURES update(uint32_t binding, uint32_t index, const std::vector<XGL_SAMPLER_IMAGE_VIEW_INFO> &textures);
-
-    static XGL_UPDATE_IMAGES update(XGL_DESCRIPTOR_TYPE type, uint32_t binding, uint32_t index, uint32_t count, const XGL_IMAGE_VIEW_ATTACH_INFO *views);
-    static XGL_UPDATE_IMAGES update(XGL_DESCRIPTOR_TYPE type, uint32_t binding, uint32_t index, const std::vector<XGL_IMAGE_VIEW_ATTACH_INFO> &views);
-
-    static XGL_UPDATE_BUFFERS update(XGL_DESCRIPTOR_TYPE type, uint32_t binding, uint32_t index, uint32_t count, const XGL_BUFFER_VIEW_ATTACH_INFO *views);
-    static XGL_UPDATE_BUFFERS update(XGL_DESCRIPTOR_TYPE type, uint32_t binding, uint32_t index, const std::vector<XGL_BUFFER_VIEW_ATTACH_INFO> &views);
-
-    static XGL_UPDATE_AS_COPY update(XGL_DESCRIPTOR_TYPE type, uint32_t binding, uint32_t index, uint32_t count, const DescriptorSet &set);
-
-    static XGL_BUFFER_VIEW_ATTACH_INFO attach_info(const BufferView &view);
-    static XGL_IMAGE_VIEW_ATTACH_INFO attach_info(const ImageView &view, XGL_IMAGE_LAYOUT layout);
-};
-
-class DynamicVpStateObject : public DerivedObject<XGL_DYNAMIC_VP_STATE_OBJECT, DynamicStateObject> {
-public:
-    // xglCreateDynamicViewportState()
-    void init(const Device &dev, const XGL_DYNAMIC_VP_STATE_CREATE_INFO &info);
-};
-
-class DynamicRsStateObject : public DerivedObject<XGL_DYNAMIC_RS_STATE_OBJECT, DynamicStateObject> {
-public:
-    // xglCreateDynamicRasterState()
-    void init(const Device &dev, const XGL_DYNAMIC_RS_STATE_CREATE_INFO &info);
-};
-
-class DynamicCbStateObject : public DerivedObject<XGL_DYNAMIC_CB_STATE_OBJECT, DynamicStateObject> {
-public:
-    // xglCreateDynamicColorBlendState()
-    void init(const Device &dev, const XGL_DYNAMIC_CB_STATE_CREATE_INFO &info);
-};
-
-class DynamicDsStateObject : public DerivedObject<XGL_DYNAMIC_DS_STATE_OBJECT, DynamicStateObject> {
-public:
-    // xglCreateDynamicDepthStencilState()
-    void init(const Device &dev, const XGL_DYNAMIC_DS_STATE_CREATE_INFO &info);
-};
-
-class CmdBuffer : public DerivedObject<XGL_CMD_BUFFER, Object> {
-public:
-    explicit CmdBuffer() {}
-    explicit CmdBuffer(const Device &dev, const XGL_CMD_BUFFER_CREATE_INFO &info) { init(dev, info); }
-
-    // xglCreateCommandBuffer()
-    void init(const Device &dev, const XGL_CMD_BUFFER_CREATE_INFO &info);
-
-    // xglBeginCommandBuffer()
-    void begin(const XGL_CMD_BUFFER_BEGIN_INFO *info);
-    void begin(XGL_RENDER_PASS renderpass_obj, XGL_FRAMEBUFFER framebuffer_obj);
-    void begin();
-
-    // xglEndCommandBuffer()
-    // xglResetCommandBuffer()
-    void end();
-    void reset();
-
-    static XGL_CMD_BUFFER_CREATE_INFO create_info(uint32_t queueNodeIndex);
-};
-
-inline const void *Object::map(XGL_FLAGS flags) const
-{
-    return (primary_mem_) ? primary_mem_->map(flags) : NULL;
-}
-
-inline void *Object::map(XGL_FLAGS flags)
-{
-    return (primary_mem_) ? primary_mem_->map(flags) : NULL;
-}
-
-inline void Object::unmap() const
-{
-    if (primary_mem_)
-        primary_mem_->unmap();
-}
-
-inline XGL_MEMORY_ALLOC_INFO GpuMemory::alloc_info(const XGL_MEMORY_REQUIREMENTS &reqs,
-                                const XGL_MEMORY_ALLOC_INFO *next_info)
-{
-    XGL_MEMORY_ALLOC_INFO info = {};
-    info.sType = XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO;
-    if (next_info != NULL)
-        info.pNext = (void *) next_info;
-
-    info.allocationSize = reqs.size;
-    info.memProps = reqs.memProps;
-    info.memType = reqs.memType;
-    info.memPriority = XGL_MEMORY_PRIORITY_NORMAL;
-    return info;
-}
-
-inline XGL_BUFFER_CREATE_INFO Buffer::create_info(XGL_GPU_SIZE size, XGL_FLAGS usage)
-{
-    XGL_BUFFER_CREATE_INFO info = {};
-    info.sType = XGL_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
-    info.size = size;
-    info.usage = usage;
-    return info;
-}
-
-inline XGL_FENCE_CREATE_INFO Fence::create_info(XGL_FENCE_CREATE_FLAGS flags)
-{
-    XGL_FENCE_CREATE_INFO info = {};
-    info.sType = XGL_STRUCTURE_TYPE_FENCE_CREATE_INFO;
-    info.flags = flags;
-    return info;
-}
-
-inline XGL_FENCE_CREATE_INFO Fence::create_info()
-{
-    XGL_FENCE_CREATE_INFO info = {};
-    info.sType = XGL_STRUCTURE_TYPE_FENCE_CREATE_INFO;
-    return info;
-}
-
-inline XGL_SEMAPHORE_CREATE_INFO Semaphore::create_info(uint32_t init_count, XGL_FLAGS flags)
-{
-    XGL_SEMAPHORE_CREATE_INFO info = {};
-    info.sType = XGL_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
-    info.initialCount = init_count;
-    info.flags = flags;
-    return info;
-}
-
-inline XGL_EVENT_CREATE_INFO Event::create_info(XGL_FLAGS flags)
-{
-    XGL_EVENT_CREATE_INFO info = {};
-    info.sType = XGL_STRUCTURE_TYPE_EVENT_CREATE_INFO;
-    info.flags = flags;
-    return info;
-}
-
-inline XGL_QUERY_POOL_CREATE_INFO QueryPool::create_info(XGL_QUERY_TYPE type, uint32_t slot_count)
-{
-    XGL_QUERY_POOL_CREATE_INFO info = {};
-    info.sType = XGL_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO;
-    info.queryType = type;
-    info.slots = slot_count;
-    return info;
-}
-
-inline XGL_IMAGE_CREATE_INFO Image::create_info()
-{
-    XGL_IMAGE_CREATE_INFO info = {};
-    info.sType = XGL_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
-    info.extent.width = 1;
-    info.extent.height = 1;
-    info.extent.depth = 1;
-    info.mipLevels = 1;
-    info.arraySize = 1;
-    info.samples = 1;
-    return info;
-}
-
-inline XGL_IMAGE_SUBRESOURCE Image::subresource(XGL_IMAGE_ASPECT aspect, uint32_t mip_level, uint32_t array_slice)
-{
-    XGL_IMAGE_SUBRESOURCE subres = {};
-    subres.aspect = aspect;
-    subres.mipLevel = mip_level;
-    subres.arraySlice = array_slice;
-    return subres;
-}
-
-inline XGL_IMAGE_SUBRESOURCE Image::subresource(const XGL_IMAGE_SUBRESOURCE_RANGE &range, uint32_t mip_level, uint32_t array_slice)
-{
-    return subresource(range.aspect, range.baseMipLevel + mip_level, range.baseArraySlice + array_slice);
-}
-
-inline XGL_IMAGE_SUBRESOURCE_RANGE Image::subresource_range(XGL_IMAGE_ASPECT aspect, uint32_t base_mip_level, uint32_t mip_levels,
-                                                                                     uint32_t base_array_slice, uint32_t array_size)
-{
-    XGL_IMAGE_SUBRESOURCE_RANGE range = {};
-    range.aspect = aspect;
-    range.baseMipLevel = base_mip_level;
-    range.mipLevels = mip_levels;
-    range.baseArraySlice = base_array_slice;
-    range.arraySize = array_size;
-    return range;
-}
-
-inline XGL_IMAGE_SUBRESOURCE_RANGE Image::subresource_range(const XGL_IMAGE_CREATE_INFO &info, XGL_IMAGE_ASPECT aspect)
-{
-    return subresource_range(aspect, 0, info.mipLevels, 0, info.arraySize);
-}
-
-inline XGL_IMAGE_SUBRESOURCE_RANGE Image::subresource_range(const XGL_IMAGE_SUBRESOURCE &subres)
-{
-    return subresource_range(subres.aspect, subres.mipLevel, 1, subres.arraySlice, 1);
-}
-
-inline XGL_EXTENT2D Image::extent(int32_t width, int32_t height)
-{
-    XGL_EXTENT2D extent = {};
-    extent.width = width;
-    extent.height = height;
-    return extent;
-}
-
-inline XGL_EXTENT2D Image::extent(const XGL_EXTENT2D &extent, uint32_t mip_level)
-{
-    const int32_t width  = (extent.width  >> mip_level) ? extent.width  >> mip_level : 1;
-    const int32_t height = (extent.height >> mip_level) ? extent.height >> mip_level : 1;
-    return Image::extent(width, height);
-}
-
-inline XGL_EXTENT2D Image::extent(const XGL_EXTENT3D &extent)
-{
-    return Image::extent(extent.width, extent.height);
-}
-
-inline XGL_EXTENT3D Image::extent(int32_t width, int32_t height, int32_t depth)
-{
-    XGL_EXTENT3D extent = {};
-    extent.width = width;
-    extent.height = height;
-    extent.depth = depth;
-    return extent;
-}
-
-inline XGL_EXTENT3D Image::extent(const XGL_EXTENT3D &extent, uint32_t mip_level)
-{
-    const int32_t width  = (extent.width  >> mip_level) ? extent.width  >> mip_level : 1;
-    const int32_t height = (extent.height >> mip_level) ? extent.height >> mip_level : 1;
-    const int32_t depth  = (extent.depth  >> mip_level) ? extent.depth  >> mip_level : 1;
-    return Image::extent(width, height, depth);
-}
-
-inline XGL_SHADER_CREATE_INFO Shader::create_info(size_t code_size, const void *code, XGL_FLAGS flags)
-{
-    XGL_SHADER_CREATE_INFO info = {};
-    info.sType = XGL_STRUCTURE_TYPE_SHADER_CREATE_INFO;
-    info.codeSize = code_size;
-    info.pCode = code;
-    info.flags = flags;
-    return info;
-}
-
-inline XGL_BUFFER_VIEW_ATTACH_INFO DescriptorSet::attach_info(const BufferView &view)
-{
-    XGL_BUFFER_VIEW_ATTACH_INFO info = {};
-    info.sType = XGL_STRUCTURE_TYPE_BUFFER_VIEW_ATTACH_INFO;
-    info.view = view.obj();
-    return info;
-}
-
-inline XGL_IMAGE_VIEW_ATTACH_INFO DescriptorSet::attach_info(const ImageView &view, XGL_IMAGE_LAYOUT layout)
-{
-    XGL_IMAGE_VIEW_ATTACH_INFO info = {};
-    info.sType = XGL_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO;
-    info.view = view.obj();
-    info.layout = layout;
-    return info;
-}
-
-inline XGL_UPDATE_SAMPLERS DescriptorSet::update(uint32_t binding, uint32_t index, uint32_t count, const XGL_SAMPLER *samplers)
-{
-    XGL_UPDATE_SAMPLERS info = {};
-    info.sType = XGL_STRUCTURE_TYPE_UPDATE_SAMPLERS;
-    info.binding = binding;
-    info.arrayIndex = index;
-    info.count = count;
-    info.pSamplers = samplers;
-    return info;
-}
-
-inline XGL_UPDATE_SAMPLERS DescriptorSet::update(uint32_t binding, uint32_t index, const std::vector<XGL_SAMPLER> &samplers)
-{
-    return update(binding, index, samplers.size(), &samplers[0]);
-}
-
-inline XGL_UPDATE_SAMPLER_TEXTURES DescriptorSet::update(uint32_t binding, uint32_t index, uint32_t count, const XGL_SAMPLER_IMAGE_VIEW_INFO *textures)
-{
-    XGL_UPDATE_SAMPLER_TEXTURES info = {};
-    info.sType = XGL_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES;
-    info.binding = binding;
-    info.arrayIndex = index;
-    info.count = count;
-    info.pSamplerImageViews = textures;
-    return info;
-}
-
-inline XGL_UPDATE_SAMPLER_TEXTURES DescriptorSet::update(uint32_t binding, uint32_t index, const std::vector<XGL_SAMPLER_IMAGE_VIEW_INFO> &textures)
-{
-    return update(binding, index, textures.size(), &textures[0]);
-}
-
-inline XGL_UPDATE_IMAGES DescriptorSet::update(XGL_DESCRIPTOR_TYPE type, uint32_t binding, uint32_t index, uint32_t count,
-                                               const XGL_IMAGE_VIEW_ATTACH_INFO *views)
-{
-    XGL_UPDATE_IMAGES info = {};
-    info.sType = XGL_STRUCTURE_TYPE_UPDATE_IMAGES;
-    info.descriptorType = type;
-    info.binding = binding;
-    info.arrayIndex = index;
-    info.count = count;
-    info.pImageViews = views;
-    return info;
-}
-
-inline XGL_UPDATE_IMAGES DescriptorSet::update(XGL_DESCRIPTOR_TYPE type, uint32_t binding, uint32_t index,
-                                               const std::vector<XGL_IMAGE_VIEW_ATTACH_INFO> &views)
-{
-    return update(type, binding, index, views.size(), &views[0]);
-}
-
-inline XGL_UPDATE_BUFFERS DescriptorSet::update(XGL_DESCRIPTOR_TYPE type, uint32_t binding, uint32_t index, uint32_t count,
-                                                const XGL_BUFFER_VIEW_ATTACH_INFO *views)
-{
-    XGL_UPDATE_BUFFERS info = {};
-    info.sType = XGL_STRUCTURE_TYPE_UPDATE_BUFFERS;
-    info.descriptorType = type;
-    info.binding = binding;
-    info.arrayIndex = index;
-    info.count = count;
-    info.pBufferViews = views;
-    return info;
-}
-
-inline XGL_UPDATE_BUFFERS DescriptorSet::update(XGL_DESCRIPTOR_TYPE type, uint32_t binding, uint32_t index,
-                                                const std::vector<XGL_BUFFER_VIEW_ATTACH_INFO> &views)
-{
-    return update(type, binding, index, views.size(), &views[0]);
-}
-
-inline XGL_UPDATE_AS_COPY DescriptorSet::update(XGL_DESCRIPTOR_TYPE type, uint32_t binding, uint32_t index, uint32_t count, const DescriptorSet &set)
-{
-    XGL_UPDATE_AS_COPY info = {};
-    info.sType = XGL_STRUCTURE_TYPE_UPDATE_AS_COPY;
-    info.descriptorType = type;
-    info.binding = binding;
-    info.arrayElement = index;
-    info.count = count;
-    info.descriptorSet = set.obj();
-    return info;
-}
-
-inline XGL_CMD_BUFFER_CREATE_INFO CmdBuffer::create_info(uint32_t queueNodeIndex)
-{
-    XGL_CMD_BUFFER_CREATE_INFO info = {};
-    info.sType = XGL_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO;
-    info.queueNodeIndex = queueNodeIndex;
-    return info;
-}
-
-}; // namespace xgl_testing
-
-#endif // XGLTESTBINDING_H
diff --git a/tests/xgltestframework.cpp b/tests/xgltestframework.cpp
index 55c6081..9f13c8a 100644
--- a/tests/xgltestframework.cpp
+++ b/tests/xgltestframework.cpp
@@ -1,4 +1,4 @@
-//  XGL tests
+//  VK tests
 //
 //  Copyright (C) 2014 LunarG, Inc.
 //
@@ -20,8 +20,8 @@
 //  FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 //  DEALINGS IN THE SOFTWARE.
 
-#include "xgltestframework.h"
-#include "xglrenderframework.h"
+#include "vktestframework.h"
+#include "vkrenderframework.h"
 #include "GL/freeglut_std.h"
 //#include "ShaderLang.h"
 #include "GlslangToSpv.h"
@@ -83,7 +83,7 @@
     // Initialize GLSL to SPV compiler utility
     glslang::InitializeProcess();
 
-    xgl_testing::set_error_callback(test_error_callback);
+    vk_testing::set_error_callback(test_error_callback);
 }
 
 void TestEnvironment::TearDown()
@@ -180,26 +180,26 @@
 void XglTestFramework::WritePPM( const char *basename, XglImage *image )
 {
     string filename;
-    XGL_RESULT err;
+    VK_RESULT err;
     int x, y;
     XglImage displayImage(image->device());
 
-    displayImage.init(image->extent().width, image->extent().height, image->format(), 0, XGL_LINEAR_TILING);
+    displayImage.init(image->extent().width, image->extent().height, image->format(), 0, VK_LINEAR_TILING);
     displayImage.CopyImage(*image);
 
     filename.append(basename);
     filename.append(".ppm");
 
-    const XGL_IMAGE_SUBRESOURCE sr = {
-        XGL_IMAGE_ASPECT_COLOR, 0, 0
+    const VK_IMAGE_SUBRESOURCE sr = {
+        VK_IMAGE_ASPECT_COLOR, 0, 0
     };
-    XGL_SUBRESOURCE_LAYOUT sr_layout;
+    VK_SUBRESOURCE_LAYOUT sr_layout;
     size_t data_size = sizeof(sr_layout);
 
-    err = xglGetImageSubresourceInfo( image->image(), &sr,
-                                      XGL_INFO_TYPE_SUBRESOURCE_LAYOUT,
+    err = vkGetImageSubresourceInfo( image->image(), &sr,
+                                      VK_INFO_TYPE_SUBRESOURCE_LAYOUT,
                                       &data_size, &sr_layout);
-    ASSERT_XGL_SUCCESS( err );
+    ASSERT_VK_SUCCESS( err );
     ASSERT_EQ(data_size, sizeof(sr_layout));
 
     char *ptr;
@@ -218,7 +218,7 @@
         const int *row = (const int *) ptr;
         int swapped;
 
-        if (displayImage.format() == XGL_FMT_B8G8R8A8_UNORM)
+        if (displayImage.format() == VK_FMT_B8G8R8A8_UNORM)
         {
             for (x = 0; x < displayImage.width(); x++) {
                 swapped = (*row & 0xff00ff00) | (*row & 0x000000ff) << 16 | (*row & 0x00ff0000) >> 16;
@@ -226,7 +226,7 @@
                 row++;
             }
         }
-        else if (displayImage.format() == XGL_FMT_R8G8B8A8_UNORM)
+        else if (displayImage.format() == VK_FMT_R8G8B8A8_UNORM)
         {
             for (x = 0; x < displayImage.width(); x++) {
                 file.write((char *) row, 3);
@@ -300,26 +300,26 @@
 
 void XglTestFramework::Show(const char *comment, XglImage *image)
 {
-    XGL_RESULT err;
+    VK_RESULT err;
 
-    const XGL_IMAGE_SUBRESOURCE sr = {
-        XGL_IMAGE_ASPECT_COLOR, 0, 0
+    const VK_IMAGE_SUBRESOURCE sr = {
+        VK_IMAGE_ASPECT_COLOR, 0, 0
     };
-    XGL_SUBRESOURCE_LAYOUT sr_layout;
+    VK_SUBRESOURCE_LAYOUT sr_layout;
     size_t data_size = sizeof(sr_layout);
     XglTestImageRecord record;
 
     if (!m_show_images) return;
 
-    err = xglGetImageSubresourceInfo( image->image(), &sr, XGL_INFO_TYPE_SUBRESOURCE_LAYOUT,
+    err = vkGetImageSubresourceInfo( image->image(), &sr, VK_INFO_TYPE_SUBRESOURCE_LAYOUT,
                                       &data_size, &sr_layout);
-    ASSERT_XGL_SUCCESS( err );
+    ASSERT_VK_SUCCESS( err );
     ASSERT_EQ(data_size, sizeof(sr_layout));
 
     char *ptr;
 
     err = image->MapMemory( (void **) &ptr );
-    ASSERT_XGL_SUCCESS( err );
+    ASSERT_VK_SUCCESS( err );
 
     ptr += sr_layout.offset;
 
@@ -334,7 +334,7 @@
     m_display_image = --m_images.end();
 
     err = image->UnmapMemory();
-    ASSERT_XGL_SUCCESS( err );
+    ASSERT_VK_SUCCESS( err );
 
 }
 
@@ -380,12 +380,12 @@
     }
 }
 
-static xgl_testing::Environment *environment;
+static vk_testing::Environment *environment;
 
 TestFrameworkXglPresent::TestFrameworkXglPresent() :
    m_device(environment->default_device()),
    m_queue(*m_device.graphics_queues()[0]),
-   m_cmdbuf(m_device, xgl_testing::CmdBuffer::create_info(m_device.graphics_queue_node_index_))
+   m_cmdbuf(m_device, vk_testing::CmdBuffer::create_info(m_device.graphics_queue_node_index_))
 {
     m_quit = false;
     m_pause = false;
@@ -395,9 +395,9 @@
 
 void  TestFrameworkXglPresent::Display()
 {
-    XGL_RESULT err;
+    VK_RESULT err;
 
-    XGL_WSI_X11_PRESENT_INFO present = {};
+    VK_WSI_X11_PRESENT_INFO present = {};
     present.destWindow = m_window;
     present.srcImage = m_display_image->m_presentableImage;
 
@@ -410,7 +410,7 @@
                          m_display_image->m_title.size(),
                          m_display_image->m_title.c_str());
 
-    err = xglWsiX11QueuePresent(m_queue.obj(), &present, NULL);
+    err = vkWsiX11QueuePresent(m_queue.obj(), &present, NULL);
     assert(!err);
 
     m_queue.wait();
@@ -485,55 +485,55 @@
 
 void TestFrameworkXglPresent::CreatePresentableImages()
 {
-    XGL_RESULT err;
+    VK_RESULT err;
 
     m_display_image = m_images.begin();
 
     for (int x=0; x < m_images.size(); x++)
     {
-        XGL_WSI_X11_PRESENTABLE_IMAGE_CREATE_INFO presentable_image_info = {};
-        presentable_image_info.format = XGL_FMT_B8G8R8A8_UNORM;
-        presentable_image_info.usage = XGL_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
+        VK_WSI_X11_PRESENTABLE_IMAGE_CREATE_INFO presentable_image_info = {};
+        presentable_image_info.format = VK_FMT_B8G8R8A8_UNORM;
+        presentable_image_info.usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
         presentable_image_info.extent.width = m_display_image->m_width;
         presentable_image_info.extent.height = m_display_image->m_height;
         presentable_image_info.flags = 0;
 
         void *dest_ptr;
 
-        err = xglWsiX11CreatePresentableImage(m_device.obj(), &presentable_image_info,
+        err = vkWsiX11CreatePresentableImage(m_device.obj(), &presentable_image_info,
                         &m_display_image->m_presentableImage, &m_display_image->m_presentableMemory);
         assert(!err);
 
-        xgl_testing::Buffer buf;
-        buf.init(m_device, (XGL_GPU_SIZE) m_display_image->m_data_size);
+        vk_testing::Buffer buf;
+        buf.init(m_device, (VK_GPU_SIZE) m_display_image->m_data_size);
         dest_ptr = buf.map();
         memcpy(dest_ptr,m_display_image->m_data, m_display_image->m_data_size);
         buf.unmap();
 
         m_cmdbuf.begin();
 
-        XGL_BUFFER_IMAGE_COPY region = {};
+        VK_BUFFER_IMAGE_COPY region = {};
         region.imageExtent.height = m_display_image->m_height;
         region.imageExtent.width = m_display_image->m_width;
         region.imageExtent.depth = 1;
 
-        xglCmdCopyBufferToImage(m_cmdbuf.obj(),
+        vkCmdCopyBufferToImage(m_cmdbuf.obj(),
                 buf.obj(),
-                m_display_image->m_presentableImage, XGL_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL,
+                m_display_image->m_presentableImage, VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL,
                 1, &region);
         m_cmdbuf.end();
 
-        xglQueueAddMemReference(m_queue.obj(), m_display_image->m_presentableMemory);
-        xglQueueAddMemReference(m_queue.obj(), buf.memories()[0]);
+        vkQueueAddMemReference(m_queue.obj(), m_display_image->m_presentableMemory);
+        vkQueueAddMemReference(m_queue.obj(), buf.memories()[0]);
 
-        XGL_CMD_BUFFER cmdBufs[1];
+        VK_CMD_BUFFER cmdBufs[1];
         cmdBufs[0] = m_cmdbuf.obj();
 
-        xglQueueSubmit(m_queue.obj(), 1, cmdBufs, NULL);
+        vkQueueSubmit(m_queue.obj(), 1, cmdBufs, NULL);
         m_queue.wait();
 
-        xglQueueRemoveMemReference(m_queue.obj(), m_display_image->m_presentableMemory);
-        xglQueueRemoveMemReference(m_queue.obj(), buf.memories()[0]);
+        vkQueueRemoveMemReference(m_queue.obj(), m_display_image->m_presentableMemory);
+        vkQueueRemoveMemReference(m_queue.obj(), buf.memories()[0]);
 
         if (m_display_image->m_width > m_width)
             m_width = m_display_image->m_width;
@@ -594,7 +594,7 @@
 {
     std::list<XglTestImageRecord>::const_iterator iterator;
     for (iterator = m_images.begin(); iterator != m_images.end(); ++iterator) {
-        xglDestroyObject(iterator->m_presentableImage);
+        vkDestroyObject(iterator->m_presentableImage);
     }
     xcb_destroy_window(environment->m_connection, m_window);
 }
@@ -603,18 +603,18 @@
 {
     if (m_images.size() == 0) return;
 
-    environment = new xgl_testing::Environment();
+    environment = new vk_testing::Environment();
     ::testing::AddGlobalTestEnvironment(environment);
     environment->X11SetUp();
 
     {
-        TestFrameworkXglPresent xglPresent;
+        TestFrameworkXglPresent vkPresent;
 
-        xglPresent.InitPresentFramework(m_images);
-        xglPresent.CreatePresentableImages();
-        xglPresent.CreateMyWindow();
-        xglPresent.Run();
-        xglPresent.TearDown();
+        vkPresent.InitPresentFramework(m_images);
+        vkPresent.CreatePresentableImages();
+        vkPresent.CreateMyWindow();
+        vkPresent.Run();
+        vkPresent.TearDown();
     }
     environment->TearDown();
 }
@@ -1079,27 +1079,27 @@
 }
 
 //
-// Convert XGL shader type to compiler's
+// Convert VK shader type to compiler's
 //
-EShLanguage XglTestFramework::FindLanguage(const XGL_PIPELINE_SHADER_STAGE shader_type)
+EShLanguage XglTestFramework::FindLanguage(const VK_PIPELINE_SHADER_STAGE shader_type)
 {
     switch (shader_type) {
-    case XGL_SHADER_STAGE_VERTEX:
+    case VK_SHADER_STAGE_VERTEX:
         return EShLangVertex;
 
-    case XGL_SHADER_STAGE_TESS_CONTROL:
+    case VK_SHADER_STAGE_TESS_CONTROL:
         return EShLangTessControl;
 
-    case XGL_SHADER_STAGE_TESS_EVALUATION:
+    case VK_SHADER_STAGE_TESS_EVALUATION:
         return EShLangTessEvaluation;
 
-    case XGL_SHADER_STAGE_GEOMETRY:
+    case VK_SHADER_STAGE_GEOMETRY:
         return EShLangGeometry;
 
-    case XGL_SHADER_STAGE_FRAGMENT:
+    case VK_SHADER_STAGE_FRAGMENT:
         return EShLangFragment;
 
-    case XGL_SHADER_STAGE_COMPUTE:
+    case VK_SHADER_STAGE_COMPUTE:
         return EShLangCompute;
 
     default:
@@ -1109,10 +1109,10 @@
 
 
 //
-// Compile a given string containing GLSL into SPV for use by XGL
+// Compile a given string containing GLSL into SPV for use by VK
 // Return value of false means an error was encountered.
 //
-bool XglTestFramework::GLSLtoSPV(const XGL_PIPELINE_SHADER_STAGE shader_type,
+bool XglTestFramework::GLSLtoSPV(const VK_PIPELINE_SHADER_STAGE shader_type,
                                  const char *pshader,
                                  std::vector<unsigned int> &spv)
 {
diff --git a/xgl_helper.py b/vk_helper.py
similarity index 95%
rename from xgl_helper.py
rename to vk_helper.py
index 701d9b4..cee0470 100755
--- a/xgl_helper.py
+++ b/vk_helper.py
@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 #
-# XGL
+# VK
 #
 # Copyright (C) 2014 LunarG, Inc.
 #
@@ -27,7 +27,7 @@
 
 # code_gen.py overview
 # This script generates code based on input headers
-# Initially it's intended to support Mantle and XGL headers and
+# Initially it's intended to support Mantle and VK headers and
 #  generate wrappers functions that can be used to display
 #  structs in a human-readable txt format, as well as utility functions
 #  to print enum values as strings
@@ -161,8 +161,8 @@
                         self.typedef_fwd_dict[base_type] = targ_type.strip(';')
                         self.typedef_rev_dict[targ_type.strip(';')] = base_type
                 elif parse_enum:
-                    #if 'XGL_MAX_ENUM' not in line and '{' not in line:
-                    if True not in [ens in line for ens in ['{', 'XGL_MAX_ENUM', '_RANGE']]:
+                    #if 'VK_MAX_ENUM' not in line and '{' not in line:
+                    if True not in [ens in line for ens in ['{', 'VK_MAX_ENUM', '_RANGE']]:
                         self._add_enum(line, base_type, default_enum_val)
                         default_enum_val += 1
                 elif parse_struct:
@@ -342,21 +342,25 @@
         self.struct_dict = in_struct_dict
         self.include_headers = []
         self.api = prefix
-        self.header_filename = os.path.join(out_dir, self.api+"_struct_wrappers.h")
-        self.class_filename = os.path.join(out_dir, self.api+"_struct_wrappers.cpp")
-        self.string_helper_filename = os.path.join(out_dir, self.api+"_struct_string_helper.h")
-        self.string_helper_no_addr_filename = os.path.join(out_dir, self.api+"_struct_string_helper_no_addr.h")
-        self.string_helper_cpp_filename = os.path.join(out_dir, self.api+"_struct_string_helper_cpp.h")
-        self.string_helper_no_addr_cpp_filename = os.path.join(out_dir, self.api+"_struct_string_helper_no_addr_cpp.h")
-        self.validate_helper_filename = os.path.join(out_dir, self.api+"_struct_validate_helper.h")
+        if prefix == "vulkan":
+            self.api_prefix = "vk"
+        else:
+            self.api_prefix = prefix
+        self.header_filename = os.path.join(out_dir, self.api_prefix+"_struct_wrappers.h")
+        self.class_filename = os.path.join(out_dir, self.api_prefix+"_struct_wrappers.cpp")
+        self.string_helper_filename = os.path.join(out_dir, self.api_prefix+"_struct_string_helper.h")
+        self.string_helper_no_addr_filename = os.path.join(out_dir, self.api_prefix+"_struct_string_helper_no_addr.h")
+        self.string_helper_cpp_filename = os.path.join(out_dir, self.api_prefix+"_struct_string_helper_cpp.h")
+        self.string_helper_no_addr_cpp_filename = os.path.join(out_dir, self.api_prefix+"_struct_string_helper_no_addr_cpp.h")
+        self.validate_helper_filename = os.path.join(out_dir, self.api_prefix+"_struct_validate_helper.h")
         self.no_addr = False
         self.hfg = CommonFileGen(self.header_filename)
         self.cfg = CommonFileGen(self.class_filename)
         self.shg = CommonFileGen(self.string_helper_filename)
         self.shcppg = CommonFileGen(self.string_helper_cpp_filename)
         self.vhg = CommonFileGen(self.validate_helper_filename)
-        self.size_helper_filename = os.path.join(out_dir, self.api+"_struct_size_helper.h")
-        self.size_helper_c_filename = os.path.join(out_dir, self.api+"_struct_size_helper.c")
+        self.size_helper_filename = os.path.join(out_dir, self.api_prefix+"_struct_size_helper.h")
+        self.size_helper_c_filename = os.path.join(out_dir, self.api_prefix+"_struct_size_helper.c")
         self.size_helper_gen = CommonFileGen(self.size_helper_filename)
         self.size_helper_c_gen = CommonFileGen(self.size_helper_c_filename)
         #print(self.header_filename)
@@ -470,12 +474,12 @@
     def _generateCppHeader(self):
         header = []
         header.append("//#includes, #defines, globals and such...\n")
-        header.append("#include <stdio.h>\n#include <%s>\n#include <%s_enum_string_helper.h>\n" % (os.path.basename(self.header_filename), self.api))
+        header.append("#include <stdio.h>\n#include <%s>\n#include <%s_enum_string_helper.h>\n" % (os.path.basename(self.header_filename), self.api_prefix))
         return "".join(header)
         
     def _generateClassDefinition(self):
         class_def = []
-        if 'xgl' == self.api: # Mantle doesn't have pNext to worry about
+        if 'vk' == self.api: # Mantle doesn't have pNext to worry about
             class_def.append(self._generateDynamicPrintFunctions())
         for s in sorted(self.struct_dict):
             class_def.append("\n// %s class definition" % self.get_class_name(s))
@@ -498,7 +502,7 @@
     def _generateDynamicPrintFunctions(self):
         dp_funcs = []
         dp_funcs.append("\nvoid dynamic_display_full_txt(const void* pStruct, uint32_t indent)\n{\n    // Cast to APP_INFO ptr initially just to pull sType off struct")
-        dp_funcs.append("    XGL_STRUCTURE_TYPE sType = ((XGL_APPLICATION_INFO*)pStruct)->sType;\n")
+        dp_funcs.append("    VK_STRUCTURE_TYPE sType = ((VK_APPLICATION_INFO*)pStruct)->sType;\n")
         dp_funcs.append("    switch (sType)\n    {")
         for e in enum_type_dict:
             class_num = 0
@@ -519,7 +523,7 @@
         return "\n".join(dp_funcs)
 
     def _get_func_name(self, struct, mid_str):
-        return "%s_%s_%s" % (self.api, mid_str, struct.lower().strip("_"))
+        return "%s_%s_%s" % (self.api_prefix, mid_str, struct.lower().strip("_"))
 
     def _get_sh_func_name(self, struct):
         return self._get_func_name(struct, 'print')
@@ -695,7 +699,7 @@
         sh_funcs.append("    if (pStruct == NULL) {")
         sh_funcs.append("        return NULL;")
         sh_funcs.append("    }")
-        sh_funcs.append("    XGL_STRUCTURE_TYPE sType = ((XGL_APPLICATION_INFO*)pStruct)->sType;")
+        sh_funcs.append("    VK_STRUCTURE_TYPE sType = ((VK_APPLICATION_INFO*)pStruct)->sType;")
         sh_funcs.append('    char indent[100];\n    strcpy(indent, "    ");\n    strcat(indent, prefix);')
         sh_funcs.append("    switch (sType)\n    {")
         for e in enum_type_dict:
@@ -852,7 +856,7 @@
         sh_funcs.append("    if (pStruct == NULL) {\n")
         sh_funcs.append("        return NULL;")
         sh_funcs.append("    }\n")
-        sh_funcs.append("    XGL_STRUCTURE_TYPE sType = ((XGL_APPLICATION_INFO*)pStruct)->sType;")
+        sh_funcs.append("    VK_STRUCTURE_TYPE sType = ((VK_APPLICATION_INFO*)pStruct)->sType;")
         sh_funcs.append('    string indent = "    ";')
         sh_funcs.append('    indent += prefix;')
         sh_funcs.append("    switch (sType)\n    {")
@@ -967,9 +971,9 @@
         header = []
         header.append("//#includes, #defines, globals and such...\n")
         for f in self.include_headers:
-            if 'xgl_enum_string_helper' not in f:
+            if 'vk_enum_string_helper' not in f:
                 header.append("#include <%s>\n" % f)
-        header.append('#include "xgl_enum_string_helper.h"\n\n// Function Prototypes\n')
+        header.append('#include "vk_enum_string_helper.h"\n\n// Function Prototypes\n')
         header.append("char* dynamic_display(const void* pStruct, const char* prefix);\n")
         return "".join(header)
 
@@ -977,9 +981,9 @@
         header = []
         header.append("//#includes, #defines, globals and such...\n")
         for f in self.include_headers:
-            if 'xgl_enum_string_helper' not in f:
+            if 'vk_enum_string_helper' not in f:
                 header.append("#include <%s>\n" % f)
-        header.append('#include "xgl_enum_string_helper.h"\n')
+        header.append('#include "vk_enum_string_helper.h"\n')
         header.append('using namespace std;\n\n// Function Prototypes\n')
         header.append("string dynamic_display(const void* pStruct, const string prefix);\n")
         return "".join(header)
@@ -993,7 +997,7 @@
         for s in sorted(self.struct_dict):
             sh_funcs.append('uint32_t %s(const %s* pStruct)\n{' % (self._get_vh_func_name(s), typedef_fwd_dict[s]))
             for m in sorted(self.struct_dict[s]):
-                # TODO : Need to handle arrays of enums like in XGL_RENDER_PASS_CREATE_INFO struct
+                # TODO : Need to handle arrays of enums like in VK_RENDER_PASS_CREATE_INFO struct
                 if is_type(self.struct_dict[s][m]['type'], 'enum') and not self.struct_dict[s][m]['ptr']:
                     sh_funcs.append('    if (!validate_%s(pStruct->%s))\n        return 0;' % (self.struct_dict[s][m]['type'], self.struct_dict[s][m]['name']))
                 # TODO : Need a little refinement to this code to make sure type of struct matches expected input (ptr, const...)
@@ -1010,9 +1014,9 @@
         header = []
         header.append("//#includes, #defines, globals and such...\n")
         for f in self.include_headers:
-            if 'xgl_enum_validate_helper' not in f:
+            if 'vk_enum_validate_helper' not in f:
                 header.append("#include <%s>\n" % f)
-        header.append('#include "xgl_enum_validate_helper.h"\n\n// Function Prototypes\n')
+        header.append('#include "vk_enum_validate_helper.h"\n\n// Function Prototypes\n')
         #header.append("char* dynamic_display(const void* pStruct, const char* prefix);\n")
         return "".join(header)
 
@@ -1044,7 +1048,7 @@
                         if not is_type(self.struct_dict[s][m]['type'], 'struct') and not 'char' in self.struct_dict[s][m]['type'].lower():
                             if 'ppMemBarriers' == self.struct_dict[s][m]['name']:
                                 # TODO : For now be conservative and consider all memBarrier ptrs as largest possible struct
-                                sh_funcs.append('%sstructSize += pStruct->%s*(sizeof(%s*) + sizeof(XGL_IMAGE_MEMORY_BARRIER));' % (indent, self.struct_dict[s][m]['array_size'], self.struct_dict[s][m]['type']))
+                                sh_funcs.append('%sstructSize += pStruct->%s*(sizeof(%s*) + sizeof(VK_IMAGE_MEMORY_BARRIER));' % (indent, self.struct_dict[s][m]['array_size'], self.struct_dict[s][m]['type']))
                             else:
                                 sh_funcs.append('%sstructSize += pStruct->%s*(sizeof(%s*) + sizeof(%s));' % (indent, self.struct_dict[s][m]['array_size'], self.struct_dict[s][m]['type'], self.struct_dict[s][m]['type']))
                         else: # This is an array of char* or array of struct ptrs
@@ -1091,8 +1095,8 @@
             else:
                 sh_funcs.append('size_t get_dynamic_struct_size(const void* pStruct)\n{')
             indent = '    '
-            sh_funcs.append('%s// Just use XGL_APPLICATION_INFO as struct until actual type is resolved' % (indent))
-            sh_funcs.append('%sXGL_APPLICATION_INFO* pNext = (XGL_APPLICATION_INFO*)pStruct;' % (indent))
+            sh_funcs.append('%s// Just use VK_APPLICATION_INFO as struct until actual type is resolved' % (indent))
+            sh_funcs.append('%sVK_APPLICATION_INFO* pNext = (VK_APPLICATION_INFO*)pStruct;' % (indent))
             sh_funcs.append('%ssize_t structSize = 0;' % (indent))
             if follow_chain:
                 sh_funcs.append('%swhile (pNext) {' % (indent))
@@ -1118,7 +1122,7 @@
             indent = indent[:-4]
             sh_funcs.append('%s}' % (indent))
             if follow_chain:
-                sh_funcs.append('%spNext = (XGL_APPLICATION_INFO*)pNext->pNext;' % (indent))
+                sh_funcs.append('%spNext = (VK_APPLICATION_INFO*)pNext->pNext;' % (indent))
                 indent = indent[:-4]
                 sh_funcs.append('%s}' % (indent))
             sh_funcs.append('%sreturn structSize;\n}' % indent)
@@ -1282,7 +1286,11 @@
     def __init__(self, struct_dict, prefix, out_dir):
         self.struct_dict = struct_dict
         self.api = prefix
-        self.out_file = os.path.join(out_dir, self.api+"_struct_graphviz_helper.h")
+        if prefix == "vulkan":
+            self.api_prefix = "vk"
+        else:
+            self.api_prefix = prefix
+        self.out_file = os.path.join(out_dir, self.api_prefix+"_struct_graphviz_helper.h")
         self.gvg = CommonFileGen(self.out_file)
 
     def generate(self):
@@ -1299,14 +1307,14 @@
         header = []
         header.append("//#includes, #defines, globals and such...\n")
         for f in self.include_headers:
-            if 'xgl_enum_string_helper' not in f:
+            if 'vk_enum_string_helper' not in f:
                 header.append("#include <%s>\n" % f)
-        #header.append('#include "xgl_enum_string_helper.h"\n\n// Function Prototypes\n')
+        #header.append('#include "vk_enum_string_helper.h"\n\n// Function Prototypes\n')
         header.append("\nchar* dynamic_gv_display(const void* pStruct, const char* prefix);\n")
         return "".join(header)
 
     def _get_gv_func_name(self, struct):
-        return "%s_gv_print_%s" % (self.api, struct.lower().strip("_"))
+        return "%s_gv_print_%s" % (self.api_prefix, struct.lower().strip("_"))
 
     # Return elements to create formatted string for given struct member
     def _get_struct_gv_print_formatted(self, struct_member, pre_var_name="", postfix = "\\n", struct_var_name="pStruct", struct_ptr=True, print_array=False, port_label=""):
@@ -1368,15 +1376,15 @@
     def _generateBody(self):
         gv_funcs = []
         array_func_list = [] # structs for which we'll generate an array version of their print function
-        array_func_list.append('xgl_buffer_view_attach_info')
-        array_func_list.append('xgl_image_view_attach_info')
-        array_func_list.append('xgl_sampler_image_view_info')
-        array_func_list.append('xgl_descriptor_type_count')
+        array_func_list.append('vk_buffer_view_attach_info')
+        array_func_list.append('vk_image_view_attach_info')
+        array_func_list.append('vk_sampler_image_view_info')
+        array_func_list.append('vk_descriptor_type_count')
         # For first pass, generate prototype
         for s in sorted(self.struct_dict):
             gv_funcs.append('char* %s(const %s* pStruct, const char* myNodeName);\n' % (self._get_gv_func_name(s), typedef_fwd_dict[s]))
             if s.lower().strip("_") in array_func_list:
-                if s.lower().strip("_") in ['xgl_buffer_view_attach_info', 'xgl_image_view_attach_info']:
+                if s.lower().strip("_") in ['vk_buffer_view_attach_info', 'vk_image_view_attach_info']:
                     gv_funcs.append('char* %s_array(uint32_t count, const %s* const* pStruct, const char* myNodeName);\n' % (self._get_gv_func_name(s), typedef_fwd_dict[s]))
                 else:
                     gv_funcs.append('char* %s_array(uint32_t count, const %s* pStruct, const char* myNodeName);\n' % (self._get_gv_func_name(s), typedef_fwd_dict[s]))
@@ -1461,7 +1469,7 @@
             gv_funcs.append("    return str;\n}\n")
             if s.lower().strip("_") in array_func_list:
                 ptr_array = False
-                if s.lower().strip("_") in ['xgl_buffer_view_attach_info', 'xgl_image_view_attach_info']:
+                if s.lower().strip("_") in ['vk_buffer_view_attach_info', 'vk_image_view_attach_info']:
                     ptr_array = True
                     gv_funcs.append('char* %s_array(uint32_t count, const %s* const* pStruct, const char* myNodeName)\n{\n    char* str;\n    char tmpStr[1024];\n' % (self._get_gv_func_name(s), typedef_fwd_dict[s]))
                 else:
@@ -1495,7 +1503,7 @@
         # Add function to dynamically print out unknown struct
         gv_funcs.append("char* dynamic_gv_display(const void* pStruct, const char* nodeName)\n{\n")
         gv_funcs.append("    // Cast to APP_INFO ptr initially just to pull sType off struct\n")
-        gv_funcs.append("    XGL_STRUCTURE_TYPE sType = ((XGL_APPLICATION_INFO*)pStruct)->sType;\n")
+        gv_funcs.append("    VK_STRUCTURE_TYPE sType = ((VK_APPLICATION_INFO*)pStruct)->sType;\n")
         gv_funcs.append("    switch (sType)\n    {\n")
         for e in enum_type_dict:
             if "_STRUCTURE_TYPE" in e:
@@ -1503,13 +1511,13 @@
                     struct_name = v.replace("_STRUCTURE_TYPE", "")
                     print_func_name = self._get_gv_func_name(struct_name)
                     # TODO : Hand-coded fixes for some exceptions
-                    #if 'XGL_PIPELINE_CB_STATE_CREATE_INFO' in struct_name:
-                    #    struct_name = 'XGL_PIPELINE_CB_STATE'
-                    if 'XGL_SEMAPHORE_CREATE_INFO' in struct_name:
-                        struct_name = 'XGL_SEMAPHORE_CREATE_INFO'
+                    #if 'VK_PIPELINE_CB_STATE_CREATE_INFO' in struct_name:
+                    #    struct_name = 'VK_PIPELINE_CB_STATE'
+                    if 'VK_SEMAPHORE_CREATE_INFO' in struct_name:
+                        struct_name = 'VK_SEMAPHORE_CREATE_INFO'
                         print_func_name = self._get_gv_func_name(struct_name)
-                    elif 'XGL_SEMAPHORE_OPEN_INFO' in struct_name:
-                        struct_name = 'XGL_SEMAPHORE_OPEN_INFO'
+                    elif 'VK_SEMAPHORE_OPEN_INFO' in struct_name:
+                        struct_name = 'VK_SEMAPHORE_OPEN_INFO'
                         print_func_name = self._get_gv_func_name(struct_name)
                     gv_funcs.append('        case %s:\n' % (v))
                     gv_funcs.append('            return %s((%s*)pStruct, nodeName);\n' % (print_func_name, struct_name))
@@ -1565,17 +1573,20 @@
     #print(enum_val_dict)
     #print(typedef_dict)
     #print(struct_dict)
+    prefix = os.path.basename(opts.input_file).strip(".h")
+    if prefix == "vulkan":
+        prefix = "vk"
     if (opts.abs_out_dir is not None):
-        enum_sh_filename = os.path.join(opts.abs_out_dir, os.path.basename(opts.input_file).strip(".h")+"_enum_string_helper.h")
+        enum_sh_filename = os.path.join(opts.abs_out_dir, prefix+"_enum_string_helper.h")
     else:
-        enum_sh_filename = os.path.join(os.getcwd(), opts.rel_out_dir, os.path.basename(opts.input_file).strip(".h")+"_enum_string_helper.h")
+        enum_sh_filename = os.path.join(os.getcwd(), opts.rel_out_dir, prefix+"_enum_string_helper.h")
     enum_sh_filename = os.path.abspath(enum_sh_filename)
     if not os.path.exists(os.path.dirname(enum_sh_filename)):
         print("Creating output dir %s" % os.path.dirname(enum_sh_filename))
         os.mkdir(os.path.dirname(enum_sh_filename))
     if opts.gen_enum_string_helper:
         print("Generating enum string helper to %s" % enum_sh_filename)
-        enum_vh_filename = os.path.join(os.path.dirname(enum_sh_filename), os.path.basename(opts.input_file).strip(".h")+"_enum_validate_helper.h")
+        enum_vh_filename = os.path.join(os.path.dirname(enum_sh_filename), prefix+"_enum_validate_helper.h")
         print("Generating enum validate helper to %s" % enum_vh_filename)
         eg = EnumCodeGen(enum_type_dict, enum_val_dict, typedef_fwd_dict, os.path.basename(opts.input_file), enum_sh_filename, enum_vh_filename)
         eg.generateStringHelper()
diff --git a/xgl-generate.py b/xgl-generate.py
index e76b165..1a03d53 100755
--- a/xgl-generate.py
+++ b/xgl-generate.py
@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 #
-# XGL
+# VK
 #
 # Copyright (C) 2014 LunarG, Inc.
 #
@@ -30,8 +30,8 @@
 import xgl
 
 def generate_get_proc_addr_check(name):
-    return "    if (!%s || %s[0] != 'x' || %s[1] != 'g' || %s[2] != 'l')\n" \
-           "        return NULL;" % ((name,) * 4)
+    return "    if (!%s || %s[0] != 'v' || %s[1] != 'k')\n" \
+           "        return NULL;" % ((name,) * 3)
 
 class Subcommand(object):
     def __init__(self, argv):
@@ -64,7 +64,7 @@
         return """/* THIS FILE IS GENERATED.  DO NOT EDIT. */
 
 /*
- * XGL
+ * Vulkan
  *
  * Copyright (C) 2014 LunarG, Inc.
  *
@@ -111,7 +111,7 @@
 
     def _generate_object_setup(self, proto):
         method = "loader_init_data"
-        cond = "res == XGL_SUCCESS"
+        cond = "res == VK_SUCCESS"
 
         if "Get" in proto.name:
             method = "loader_set_data"
@@ -146,18 +146,17 @@
         for proto in self.protos:
             if not self._is_dispatchable(proto):
                 continue
-
             func = []
 
             obj_setup = self._generate_object_setup(proto)
 
-            func.append(qual + proto.c_func(prefix="xgl", attr="XGLAPI"))
+            func.append(qual + proto.c_func(prefix="vk", attr="VKAPI"))
             func.append("{")
 
             # declare local variables
-            func.append("    const XGL_LAYER_DISPATCH_TABLE *disp;")
+            func.append("    const VK_LAYER_DISPATCH_TABLE *disp;")
             if proto.ret != 'void' and obj_setup:
-                func.append("    XGL_RESULT res;")
+                func.append("    VK_RESULT res;")
             func.append("")
 
             # active layers before dispatching CreateDevice
@@ -169,7 +168,7 @@
             # get dispatch table and unwrap GPUs
             for param in proto.params:
                 stmt = ""
-                if param.ty == "XGL_PHYSICAL_GPU":
+                if param.ty == "VK_PHYSICAL_GPU":
                     stmt = "loader_unwrap_gpu(&%s);" % param.name
                     if param == proto.params[0]:
                         stmt = "disp = " + stmt
@@ -217,8 +216,8 @@
         super().run()
 
     def generate_header(self):
-        return "\n".join(["#include <xgl.h>",
-                          "#include <xglLayer.h>",
+        return "\n".join(["#include <vulkan.h>",
+                          "#include <vkLayer.h>",
                           "#include <string.h>",
                           "#include \"loader_platform.h\""])
 
@@ -231,16 +230,16 @@
                 stmts.append("table->%s = gpa; /* direct assignment */" %
                         proto.name)
             else:
-                stmts.append("table->%s = (xgl%sType) gpa(gpu, \"xgl%s\");" %
+                stmts.append("table->%s = (vk%sType) gpa(gpu, \"vk%s\");" %
                         (proto.name, proto.name, proto.name))
         stmts.append("#endif")
 
         func = []
-        func.append("static inline void %s_initialize_dispatch_table(XGL_LAYER_DISPATCH_TABLE *table,"
+        func.append("static inline void %s_initialize_dispatch_table(VK_LAYER_DISPATCH_TABLE *table,"
                 % self.prefix)
-        func.append("%s                                              xglGetProcAddrType gpa,"
+        func.append("%s                                              vkGetProcAddrType gpa,"
                 % (" " * len(self.prefix)))
-        func.append("%s                                              XGL_PHYSICAL_GPU gpu)"
+        func.append("%s                                              VK_PHYSICAL_GPU gpu)"
                 % (" " * len(self.prefix)))
         func.append("{")
         func.append("    %s" % "\n    ".join(stmts))
@@ -259,14 +258,14 @@
         lookups.append("#endif")
 
         func = []
-        func.append("static inline void *%s_lookup_dispatch_table(const XGL_LAYER_DISPATCH_TABLE *table,"
+        func.append("static inline void *%s_lookup_dispatch_table(const VK_LAYER_DISPATCH_TABLE *table,"
                 % self.prefix)
         func.append("%s                                           const char *name)"
                 % (" " * len(self.prefix)))
         func.append("{")
         func.append(generate_get_proc_addr_check("name"))
         func.append("")
-        func.append("    name += 3;")
+        func.append("    name += 2;")
         func.append("    %s" % "\n    ".join(lookups))
         func.append("")
         func.append("    return NULL;")
@@ -286,7 +285,7 @@
             self.prefix = self.argv[0]
             self.qual = "static"
         else:
-            self.prefix = "xgl"
+            self.prefix = "vk"
             self.qual = "ICD_EXPORT"
 
         super().run()
@@ -295,14 +294,14 @@
         return "#include \"icd.h\""
 
     def _generate_stub_decl(self, proto):
-        return proto.c_pretty_decl(self.prefix + proto.name, attr="XGLAPI")
+        return proto.c_pretty_decl(self.prefix + proto.name, attr="VKAPI")
 
     def _generate_stubs(self):
         stubs = []
         for proto in self.protos:
             decl = self._generate_stub_decl(proto)
             if proto.ret != "void":
-                stmt = "    return XGL_ERROR_UNKNOWN;\n"
+                stmt = "    return VK_ERROR_UNKNOWN;\n"
             else:
                 stmt = ""
 
@@ -340,7 +339,7 @@
         body.append("{")
         body.append(generate_get_proc_addr_check(gpa_pname))
         body.append("")
-        body.append("    %s += 3;" % gpa_pname)
+        body.append("    %s += 2;" % gpa_pname)
         body.append("    %s" % "\n    ".join(lookups))
         body.append("")
         body.append("    return NULL;")
@@ -350,7 +349,7 @@
 
 class LayerInterceptProcSubcommand(Subcommand):
     def run(self):
-        self.prefix = "xgl"
+        self.prefix = "vk"
 
         # we could get the list from argv if wanted
         self.intercepted = [proto.name for proto in self.protos
@@ -363,7 +362,7 @@
         super().run()
 
     def generate_header(self):
-        return "\n".join(["#include <string.h>", "#include \"xglLayer.h\""])
+        return "\n".join(["#include <string.h>", "#include \"vkLayer.h\""])
 
     def generate_body(self):
         lookups = []
@@ -385,7 +384,7 @@
         body.append("{")
         body.append(generate_get_proc_addr_check("name"))
         body.append("")
-        body.append("    name += 3;")
+        body.append("    name += 2;")
         body.append("    %s" % "\n    ".join(lookups))
         body.append("")
         body.append("    return NULL;")
@@ -423,7 +422,7 @@
         return """; THIS FILE IS GENERATED.  DO NOT EDIT.
 
 ;;;; Begin Copyright Notice ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-; XGL
+; Vulkan
 ;
 ; Copyright (C) 2015 LunarG, Inc.
 ;
@@ -458,7 +457,7 @@
         for proto in self.protos:
             if self.exports and proto.name not in self.exports:
                 continue
-            body.append("   xgl" + proto.name)
+            body.append("   vk" + proto.name)
 
         return "\n".join(body)
 
diff --git a/xgl-layer-generate.py b/xgl-layer-generate.py
index 38a0889..bf82d18 100755
--- a/xgl-layer-generate.py
+++ b/xgl-layer-generate.py
@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 #
-# XGL
+# VK
 #
 # Copyright (C) 2014 LunarG, Inc.
 #
@@ -29,11 +29,11 @@
 import os
 
 import xgl
-import xgl_helper
+import vk_helper
 
 def generate_get_proc_addr_check(name):
-    return "    if (!%s || %s[0] != 'x' || %s[1] != 'g' || %s[2] != 'l')\n" \
-           "        return NULL;" % ((name,) * 4)
+    return "    if (!%s || %s[0] != 'v' || %s[1] != 'k')\n" \
+           "        return NULL;" % ((name,) * 3)
 
 class Subcommand(object):
     def __init__(self, argv):
@@ -68,7 +68,7 @@
         return """/* THIS FILE IS GENERATED.  DO NOT EDIT. */
 
 /*
- * XGL
+ * Vulkan
  *
  * Copyright (C) 2014 LunarG, Inc.
  *
@@ -101,76 +101,76 @@
         pass
 
     # Return set of printf '%' qualifier and input to that qualifier
-    def _get_printf_params(self, xgl_type, name, output_param, cpp=False):
+    def _get_printf_params(self, vk_type, name, output_param, cpp=False):
         # TODO : Need ENUM and STRUCT checks here
-        if xgl_helper.is_type(xgl_type, 'enum'):#"_TYPE" in xgl_type: # TODO : This should be generic ENUM check
-            return ("%s", "string_%s(%s)" % (xgl_type.strip('const ').strip('*'), name))
-        if "char*" == xgl_type:
+        if vk_helper.is_type(vk_type, 'enum'):#"_TYPE" in vk_type: # TODO : This should be generic ENUM check
+            return ("%s", "string_%s(%s)" % (vk_type.strip('const ').strip('*'), name))
+        if "char*" == vk_type:
             return ("%s", name)
-        if "uint64" in xgl_type:
-            if '*' in xgl_type:
+        if "uint64" in vk_type:
+            if '*' in vk_type:
                 return ("%lu", "*%s" % name)
             return ("%lu", name)
-        if "size" in xgl_type:
-            if '*' in xgl_type:
+        if "size" in vk_type:
+            if '*' in vk_type:
                 return ("%zu", "*%s" % name)
             return ("%zu", name)
-        if "float" in xgl_type:
-            if '[' in xgl_type: # handle array, current hard-coded to 4 (TODO: Make this dynamic)
+        if "float" in vk_type:
+            if '[' in vk_type: # handle array, current hard-coded to 4 (TODO: Make this dynamic)
                 if cpp:
                     return ("[%i, %i, %i, %i]", '"[" << %s[0] << "," << %s[1] << "," << %s[2] << "," << %s[3] << "]"' % (name, name, name, name))
                 return ("[%f, %f, %f, %f]", "%s[0], %s[1], %s[2], %s[3]" % (name, name, name, name))
             return ("%f", name)
-        if "bool" in xgl_type or 'xcb_randr_crtc_t' in xgl_type:
+        if "bool" in vk_type or 'xcb_randr_crtc_t' in vk_type:
             return ("%u", name)
-        if True in [t in xgl_type for t in ["int", "FLAGS", "MASK", "xcb_window_t"]]:
-            if '[' in xgl_type: # handle array, current hard-coded to 4 (TODO: Make this dynamic)
+        if True in [t in vk_type for t in ["int", "FLAGS", "MASK", "xcb_window_t"]]:
+            if '[' in vk_type: # handle array, current hard-coded to 4 (TODO: Make this dynamic)
                 if cpp:
                     return ("[%i, %i, %i, %i]", "%s[0] << %s[1] << %s[2] << %s[3]" % (name, name, name, name))
                 return ("[%i, %i, %i, %i]", "%s[0], %s[1], %s[2], %s[3]" % (name, name, name, name))
-            if '*' in xgl_type:
+            if '*' in vk_type:
                 if 'pUserData' == name:
                     return ("%i", "((pUserData == 0) ? 0 : *(pUserData))")
                 return ("%i", "*(%s)" % name)
             return ("%i", name)
         # TODO : This is special-cased as there's only one "format" param currently and it's nice to expand it
-        if "XGL_FORMAT" == xgl_type:
+        if "VK_FORMAT" == vk_type:
             if cpp:
                 return ("%p", "&%s" % name)
-            return ("{%s.channelFormat = %%s, %s.numericFormat = %%s}" % (name, name), "string_XGL_CHANNEL_FORMAT(%s.channelFormat), string_XGL_NUM_FORMAT(%s.numericFormat)" % (name, name))
+            return ("{%s.channelFormat = %%s, %s.numericFormat = %%s}" % (name, name), "string_VK_CHANNEL_FORMAT(%s.channelFormat), string_VK_NUM_FORMAT(%s.numericFormat)" % (name, name))
         if output_param:
             return ("%p", "(void*)*%s" % name)
-        if xgl_helper.is_type(xgl_type, 'struct') and '*' not in xgl_type:
+        if vk_helper.is_type(vk_type, 'struct') and '*' not in vk_type:
             return ("%p", "(void*)(&%s)" % name)
         return ("%p", "(void*)(%s)" % name)
 
     def _gen_layer_dbg_callback_register(self):
         r_body = []
-        r_body.append('XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDbgRegisterMsgCallback(XGL_INSTANCE instance, XGL_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback, void* pUserData)')
+        r_body.append('VK_LAYER_EXPORT VK_RESULT VKAPI vkDbgRegisterMsgCallback(VK_INSTANCE instance, VK_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback, void* pUserData)')
         r_body.append('{')
         r_body.append('    // This layer intercepts callbacks')
-        r_body.append('    XGL_LAYER_DBG_FUNCTION_NODE *pNewDbgFuncNode = (XGL_LAYER_DBG_FUNCTION_NODE*)malloc(sizeof(XGL_LAYER_DBG_FUNCTION_NODE));')
+        r_body.append('    VK_LAYER_DBG_FUNCTION_NODE *pNewDbgFuncNode = (VK_LAYER_DBG_FUNCTION_NODE*)malloc(sizeof(VK_LAYER_DBG_FUNCTION_NODE));')
         r_body.append('    if (!pNewDbgFuncNode)')
-        r_body.append('        return XGL_ERROR_OUT_OF_MEMORY;')
+        r_body.append('        return VK_ERROR_OUT_OF_MEMORY;')
         r_body.append('    pNewDbgFuncNode->pfnMsgCallback = pfnMsgCallback;')
         r_body.append('    pNewDbgFuncNode->pUserData = pUserData;')
         r_body.append('    pNewDbgFuncNode->pNext = g_pDbgFunctionHead;')
         r_body.append('    g_pDbgFunctionHead = pNewDbgFuncNode;')
         r_body.append('    // force callbacks if DebugAction hasn\'t been set already other than initial value')
         r_body.append('    if (g_actionIsDefault) {')
-        r_body.append('        g_debugAction = XGL_DBG_LAYER_ACTION_CALLBACK;')
+        r_body.append('        g_debugAction = VK_DBG_LAYER_ACTION_CALLBACK;')
         r_body.append('    }')
-        r_body.append('    XGL_RESULT result = nextTable.DbgRegisterMsgCallback(instance, pfnMsgCallback, pUserData);')
+        r_body.append('    VK_RESULT result = nextTable.DbgRegisterMsgCallback(instance, pfnMsgCallback, pUserData);')
         r_body.append('    return result;')
         r_body.append('}')
         return "\n".join(r_body)
 
     def _gen_layer_dbg_callback_unregister(self):
         ur_body = []
-        ur_body.append('XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDbgUnregisterMsgCallback(XGL_INSTANCE instance, XGL_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback)')
+        ur_body.append('VK_LAYER_EXPORT VK_RESULT VKAPI vkDbgUnregisterMsgCallback(VK_INSTANCE instance, VK_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback)')
         ur_body.append('{')
-        ur_body.append('    XGL_LAYER_DBG_FUNCTION_NODE *pTrav = g_pDbgFunctionHead;')
-        ur_body.append('    XGL_LAYER_DBG_FUNCTION_NODE *pPrev = pTrav;')
+        ur_body.append('    VK_LAYER_DBG_FUNCTION_NODE *pTrav = g_pDbgFunctionHead;')
+        ur_body.append('    VK_LAYER_DBG_FUNCTION_NODE *pPrev = pTrav;')
         ur_body.append('    while (pTrav) {')
         ur_body.append('        if (pTrav->pfnMsgCallback == pfnMsgCallback) {')
         ur_body.append('            pPrev->pNext = pTrav->pNext;')
@@ -185,32 +185,32 @@
         ur_body.append('    if (g_pDbgFunctionHead == NULL)')
         ur_body.append('    {')
         ur_body.append('        if (g_actionIsDefault)')
-        ur_body.append('            g_debugAction = XGL_DBG_LAYER_ACTION_LOG_MSG;')
+        ur_body.append('            g_debugAction = VK_DBG_LAYER_ACTION_LOG_MSG;')
         ur_body.append('        else')
-        ur_body.append('            g_debugAction &= ~XGL_DBG_LAYER_ACTION_CALLBACK;')
+        ur_body.append('            g_debugAction &= ~VK_DBG_LAYER_ACTION_CALLBACK;')
         ur_body.append('    }')
-        ur_body.append('    XGL_RESULT result = nextTable.DbgUnregisterMsgCallback(instance, pfnMsgCallback);')
+        ur_body.append('    VK_RESULT result = nextTable.DbgUnregisterMsgCallback(instance, pfnMsgCallback);')
         ur_body.append('    return result;')
         ur_body.append('}')
         return "\n".join(ur_body)
 
     def _gen_layer_get_extension_support(self, layer="Generic"):
         ges_body = []
-        ges_body.append('XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglGetExtensionSupport(XGL_PHYSICAL_GPU gpu, const char* pExtName)')
+        ges_body.append('VK_LAYER_EXPORT VK_RESULT VKAPI vkGetExtensionSupport(VK_PHYSICAL_GPU gpu, const char* pExtName)')
         ges_body.append('{')
-        ges_body.append('    XGL_RESULT result;')
-        ges_body.append('    XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) gpu;')
+        ges_body.append('    VK_RESULT result;')
+        ges_body.append('    VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;')
         ges_body.append('')
         ges_body.append('    /* This entrypoint is NOT going to init its own dispatch table since loader calls here early */')
         ges_body.append('    if (!strncmp(pExtName, "%s", strlen("%s")))' % (layer, layer))
         ges_body.append('    {')
-        ges_body.append('        result = XGL_SUCCESS;')
+        ges_body.append('        result = VK_SUCCESS;')
         ges_body.append('    } else if (nextTable.GetExtensionSupport != NULL)')
         ges_body.append('    {')
-        ges_body.append('        result = nextTable.GetExtensionSupport((XGL_PHYSICAL_GPU)gpuw->nextObject, pExtName);')
+        ges_body.append('        result = nextTable.GetExtensionSupport((VK_PHYSICAL_GPU)gpuw->nextObject, pExtName);')
         ges_body.append('    } else')
         ges_body.append('    {')
-        ges_body.append('        result = XGL_ERROR_INVALID_EXTENSION;')
+        ges_body.append('        result = VK_ERROR_INVALID_EXTENSION;')
         ges_body.append('    }')
         ges_body.append('    return result;')
         ges_body.append('}')
@@ -237,7 +237,7 @@
                     funcs.append(intercept)
                     intercepted.append(proto)
 
-        prefix="xgl"
+        prefix="vk"
         lookups = []
         for proto in intercepted:
             if 'WsiX11' in proto.name:
@@ -254,7 +254,7 @@
         body.append("{")
         body.append(generate_get_proc_addr_check("name"))
         body.append("")
-        body.append("    name += 3;")
+        body.append("    name += 2;")
         body.append("    %s" % "\n    ".join(lookups))
         body.append("")
         body.append("    return NULL;")
@@ -265,44 +265,44 @@
 
     def _generate_extensions(self):
         exts = []
-        exts.append('uint64_t objTrackGetObjectCount(XGL_OBJECT_TYPE type)')
+        exts.append('uint64_t objTrackGetObjectCount(VK_OBJECT_TYPE type)')
         exts.append('{')
-        exts.append('    return (type == XGL_OBJECT_TYPE_ANY) ? numTotalObjs : numObjs[type];')
+        exts.append('    return (type == VK_OBJECT_TYPE_ANY) ? numTotalObjs : numObjs[type];')
         exts.append('}')
         exts.append('')
-        exts.append('XGL_RESULT objTrackGetObjects(XGL_OBJECT_TYPE type, uint64_t objCount, OBJTRACK_NODE* pObjNodeArray)')
+        exts.append('VK_RESULT objTrackGetObjects(VK_OBJECT_TYPE type, uint64_t objCount, OBJTRACK_NODE* pObjNodeArray)')
         exts.append('{')
         exts.append("    // This bool flags if we're pulling all objs or just a single class of objs")
-        exts.append('    bool32_t bAllObjs = (type == XGL_OBJECT_TYPE_ANY);')
+        exts.append('    bool32_t bAllObjs = (type == VK_OBJECT_TYPE_ANY);')
         exts.append('    // Check the count first thing')
         exts.append('    uint64_t maxObjCount = (bAllObjs) ? numTotalObjs : numObjs[type];')
         exts.append('    if (objCount > maxObjCount) {')
         exts.append('        char str[1024];')
-        exts.append('        sprintf(str, "OBJ ERROR : Received objTrackGetObjects() request for %lu objs, but there are only %lu objs of type %s", objCount, maxObjCount, string_XGL_OBJECT_TYPE(type));')
-        exts.append('        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, 0, 0, OBJTRACK_OBJCOUNT_MAX_EXCEEDED, "OBJTRACK", str);')
-        exts.append('        return XGL_ERROR_INVALID_VALUE;')
+        exts.append('        sprintf(str, "OBJ ERROR : Received objTrackGetObjects() request for %lu objs, but there are only %lu objs of type %s", objCount, maxObjCount, string_VK_OBJECT_TYPE(type));')
+        exts.append('        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, 0, 0, OBJTRACK_OBJCOUNT_MAX_EXCEEDED, "OBJTRACK", str);')
+        exts.append('        return VK_ERROR_INVALID_VALUE;')
         exts.append('    }')
         exts.append('    objNode* pTrav = (bAllObjs) ? pGlobalHead : pObjectHead[type];')
         exts.append('    for (uint64_t i = 0; i < objCount; i++) {')
         exts.append('        if (!pTrav) {')
         exts.append('            char str[1024];')
-        exts.append('            sprintf(str, "OBJ INTERNAL ERROR : Ran out of %s objs! Should have %lu, but only copied %lu and not the requested %lu.", string_XGL_OBJECT_TYPE(type), maxObjCount, i, objCount);')
-        exts.append('            layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, 0, 0, OBJTRACK_INTERNAL_ERROR, "OBJTRACK", str);')
-        exts.append('            return XGL_ERROR_UNKNOWN;')
+        exts.append('            sprintf(str, "OBJ INTERNAL ERROR : Ran out of %s objs! Should have %lu, but only copied %lu and not the requested %lu.", string_VK_OBJECT_TYPE(type), maxObjCount, i, objCount);')
+        exts.append('            layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, 0, 0, OBJTRACK_INTERNAL_ERROR, "OBJTRACK", str);')
+        exts.append('            return VK_ERROR_UNKNOWN;')
         exts.append('        }')
         exts.append('        memcpy(&pObjNodeArray[i], pTrav, sizeof(OBJTRACK_NODE));')
         exts.append('        pTrav = (bAllObjs) ? pTrav->pNextGlobal : pTrav->pNextObj;')
         exts.append('    }')
-        exts.append('    return XGL_SUCCESS;')
+        exts.append('    return VK_SUCCESS;')
         exts.append('}')
 
         return "\n".join(exts)
 
     def _generate_layer_gpa_function(self, extensions=[]):
         func_body = []
-        func_body.append("XGL_LAYER_EXPORT void* XGLAPI xglGetProcAddr(XGL_PHYSICAL_GPU gpu, const char* funcName)\n"
+        func_body.append("VK_LAYER_EXPORT void* VKAPI vkGetProcAddr(VK_PHYSICAL_GPU gpu, const char* funcName)\n"
                          "{\n"
-                         "    XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) gpu;\n"
+                         "    VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;\n"
                          "    void* addr;\n"
                          "    if (gpu == NULL)\n"
                          "        return NULL;\n"
@@ -319,13 +319,13 @@
         func_body.append("    else {\n"
                          "        if (gpuw->pGPA == NULL)\n"
                          "            return NULL;\n"
-                         "        return gpuw->pGPA((XGL_PHYSICAL_GPU)gpuw->nextObject, funcName);\n"
+                         "        return gpuw->pGPA((VK_PHYSICAL_GPU)gpuw->nextObject, funcName);\n"
                          "    }\n"
                          "}\n")
         return "\n".join(func_body)
 
-    def _generate_layer_initialization(self, init_opts=False, prefix='xgl', lockname=None):
-        func_body = ["#include \"xgl_dispatch_table_helper.h\""]
+    def _generate_layer_initialization(self, init_opts=False, prefix='vk', lockname=None):
+        func_body = ["#include \"vk_dispatch_table_helper.h\""]
         func_body.append('static void init%s(void)\n'
                          '{\n' % self.layer_name)
         if init_opts:
@@ -334,7 +334,7 @@
             func_body.append('    getLayerOptionEnum("%sReportLevel", (uint32_t *) &g_reportingLevel);' % self.layer_name)
             func_body.append('    g_actionIsDefault = getLayerOptionEnum("%sDebugAction", (uint32_t *) &g_debugAction);' % self.layer_name)
             func_body.append('')
-            func_body.append('    if (g_debugAction & XGL_DBG_LAYER_ACTION_LOG_MSG)')
+            func_body.append('    if (g_debugAction & VK_DBG_LAYER_ACTION_LOG_MSG)')
             func_body.append('    {')
             func_body.append('        strOpt = getLayerOption("%sLogFilename");' % self.layer_name)
             func_body.append('        if (strOpt)')
@@ -345,11 +345,11 @@
             func_body.append('            g_logFile = stdout;')
             func_body.append('    }')
             func_body.append('')
-        func_body.append('    xglGetProcAddrType fpNextGPA;\n'
+        func_body.append('    vkGetProcAddrType fpNextGPA;\n'
                          '    fpNextGPA = pCurObj->pGPA;\n'
                          '    assert(fpNextGPA);\n')
 
-        func_body.append("    layer_initialize_dispatch_table(&nextTable, fpNextGPA, (XGL_PHYSICAL_GPU) pCurObj->nextObject);")
+        func_body.append("    layer_initialize_dispatch_table(&nextTable, fpNextGPA, (VK_PHYSICAL_GPU) pCurObj->nextObject);")
         if lockname is not None:
             func_body.append("    if (!%sLockInitialized)" % lockname)
             func_body.append("    {")
@@ -360,15 +360,15 @@
         func_body.append("}\n")
         return "\n".join(func_body)
 
-    def _generate_layer_initialization_with_lock(self, prefix='xgl'):
-        func_body = ["#include \"xgl_dispatch_table_helper.h\""]
+    def _generate_layer_initialization_with_lock(self, prefix='vk'):
+        func_body = ["#include \"vk_dispatch_table_helper.h\""]
         func_body.append('static void init%s(void)\n'
                          '{\n'
-                         '    xglGetProcAddrType fpNextGPA;\n'
+                         '    vkGetProcAddrType fpNextGPA;\n'
                          '    fpNextGPA = pCurObj->pGPA;\n'
                          '    assert(fpNextGPA);\n' % self.layer_name);
 
-        func_body.append("    layer_initialize_dispatch_table(&nextTable, fpNextGPA, (XGL_PHYSICAL_GPU) pCurObj->nextObject);\n")
+        func_body.append("    layer_initialize_dispatch_table(&nextTable, fpNextGPA, (VK_PHYSICAL_GPU) pCurObj->nextObject);\n")
         func_body.append("    if (!printLockInitialized)")
         func_body.append("    {")
         func_body.append("        // TODO/TBD: Need to delete this mutex sometime.  How???")
@@ -380,7 +380,7 @@
 
 class LayerFuncsSubcommand(Subcommand):
     def generate_header(self):
-        return '#include <xglLayer.h>\n#include "loader.h"'
+        return '#include <vkLayer.h>\n#include "loader.h"'
 
     def generate_body(self):
         return self._generate_dispatch_entrypoints("static")
@@ -394,66 +394,66 @@
 
 class GenericLayerSubcommand(Subcommand):
     def generate_header(self):
-        return '#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n#include "loader_platform.h"\n#include "xglLayer.h"\n//The following is #included again to catch certain OS-specific functions being used:\n#include "loader_platform.h"\n\n#include "layers_config.h"\n#include "layers_msg.h"\n\nstatic XGL_LAYER_DISPATCH_TABLE nextTable;\nstatic XGL_BASE_LAYER_OBJECT *pCurObj;\n\nstatic LOADER_PLATFORM_THREAD_ONCE_DECLARATION(tabOnce);'
+        return '#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n#include "loader_platform.h"\n#include "vkLayer.h"\n//The following is #included again to catch certain OS-specific functions being used:\n#include "loader_platform.h"\n\n#include "layers_config.h"\n#include "layers_msg.h"\n\nstatic VK_LAYER_DISPATCH_TABLE nextTable;\nstatic VK_BASE_LAYER_OBJECT *pCurObj;\n\nstatic LOADER_PLATFORM_THREAD_ONCE_DECLARATION(tabOnce);'
 
     def generate_intercept(self, proto, qual):
         if proto.name in [ 'DbgRegisterMsgCallback', 'DbgUnregisterMsgCallback' , 'GetExtensionSupport']:
             # use default version
             return None
-        decl = proto.c_func(prefix="xgl", attr="XGLAPI")
+        decl = proto.c_func(prefix="vk", attr="VKAPI")
         param0_name = proto.params[0].name
         ret_val = ''
         stmt = ''
         funcs = []
         if proto.ret != "void":
-            ret_val = "XGL_RESULT result = "
+            ret_val = "VK_RESULT result = "
             stmt = "    return result;\n"
         if 'WsiX11AssociateConnection' == proto.name:
             funcs.append("#if defined(__linux__) || defined(XCB_NVIDIA)")
         if proto.name == "EnumerateLayers":
-            c_call = proto.c_call().replace("(" + proto.params[0].name, "((XGL_PHYSICAL_GPU)gpuw->nextObject", 1)
+            c_call = proto.c_call().replace("(" + proto.params[0].name, "((VK_PHYSICAL_GPU)gpuw->nextObject", 1)
             funcs.append('%s%s\n'
                      '{\n'
                      '    char str[1024];\n'
                      '    if (gpu != NULL) {\n'
-                     '        XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) %s;\n'
+                     '        VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) %s;\n'
                      '        sprintf(str, "At start of layered %s\\n");\n'
-                     '        layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, gpu, 0, 0, (char *) "GENERIC", (char *) str);\n'
+                     '        layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, gpu, 0, 0, (char *) "GENERIC", (char *) str);\n'
                      '        pCurObj = gpuw;\n'
                      '        loader_platform_thread_once(&tabOnce, init%s);\n'
                      '        %snextTable.%s;\n'
                      '        sprintf(str, "Completed layered %s\\n");\n'
-                     '        layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, gpu, 0, 0, (char *) "GENERIC", (char *) str);\n'
+                     '        layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, gpu, 0, 0, (char *) "GENERIC", (char *) str);\n'
                      '        fflush(stdout);\n'
                      '    %s'
                      '    } else {\n'
                      '        if (pOutLayerCount == NULL || pOutLayers == NULL || pOutLayers[0] == NULL)\n'
-                     '            return XGL_ERROR_INVALID_POINTER;\n'
+                     '            return VK_ERROR_INVALID_POINTER;\n'
                      '        // This layer compatible with all GPUs\n'
                      '        *pOutLayerCount = 1;\n'
                      '        strncpy((char *) pOutLayers[0], "%s", maxStringSize);\n'
-                     '        return XGL_SUCCESS;\n'
+                     '        return VK_SUCCESS;\n'
                      '    }\n'
                          '}' % (qual, decl, proto.params[0].name, proto.name, self.layer_name, ret_val, c_call, proto.name, stmt, self.layer_name))
-        elif proto.params[0].ty != "XGL_PHYSICAL_GPU":
+        elif proto.params[0].ty != "VK_PHYSICAL_GPU":
             funcs.append('%s%s\n'
                      '{\n'
                      '    %snextTable.%s;\n'
                      '%s'
                      '}' % (qual, decl, ret_val, proto.c_call(), stmt))
         else:
-            c_call = proto.c_call().replace("(" + proto.params[0].name, "((XGL_PHYSICAL_GPU)gpuw->nextObject", 1)
+            c_call = proto.c_call().replace("(" + proto.params[0].name, "((VK_PHYSICAL_GPU)gpuw->nextObject", 1)
             funcs.append('%s%s\n'
                      '{\n'
                      '    char str[1024];'
-                     '    XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) %s;\n'
+                     '    VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) %s;\n'
                      '    sprintf(str, "At start of layered %s\\n");\n'
-                     '    layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, gpuw, 0, 0, (char *) "GENERIC", (char *) str);\n'
+                     '    layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, gpuw, 0, 0, (char *) "GENERIC", (char *) str);\n'
                      '    pCurObj = gpuw;\n'
                      '    loader_platform_thread_once(&tabOnce, init%s);\n'
                      '    %snextTable.%s;\n'
                      '    sprintf(str, "Completed layered %s\\n");\n'
-                     '    layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, gpuw, 0, 0, (char *) "GENERIC", (char *) str);\n'
+                     '    layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, gpuw, 0, 0, (char *) "GENERIC", (char *) str);\n'
                      '    fflush(stdout);\n'
                      '%s'
                      '}' % (qual, decl, proto.params[0].name, proto.name, self.layer_name, ret_val, c_call, proto.name, stmt))
@@ -464,7 +464,7 @@
     def generate_body(self):
         self.layer_name = "Generic"
         body = [self._generate_layer_initialization(True),
-                self._generate_dispatch_entrypoints("XGL_LAYER_EXPORT"),
+                self._generate_dispatch_entrypoints("VK_LAYER_EXPORT"),
                 self._generate_layer_gpa_function()]
 
         return "\n\n".join(body)
@@ -474,11 +474,11 @@
         header_txt = []
         header_txt.append('#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>')
         header_txt.append('#include "loader_platform.h"')
-        header_txt.append('#include "xglLayer.h"\n#include "xgl_struct_string_helper.h"\n')
+        header_txt.append('#include "vkLayer.h"\n#include "vk_struct_string_helper.h"\n')
         header_txt.append('// The following is #included again to catch certain OS-specific functions being used:')
         header_txt.append('#include "loader_platform.h"')
-        header_txt.append('static XGL_LAYER_DISPATCH_TABLE nextTable;')
-        header_txt.append('static XGL_BASE_LAYER_OBJECT *pCurObj;\n')
+        header_txt.append('static VK_LAYER_DISPATCH_TABLE nextTable;')
+        header_txt.append('static VK_BASE_LAYER_OBJECT *pCurObj;\n')
         header_txt.append('static LOADER_PLATFORM_THREAD_ONCE_DECLARATION(tabOnce);')
         header_txt.append('static int printLockInitialized = 0;')
         header_txt.append('static loader_platform_thread_mutex printLock;\n')
@@ -502,7 +502,7 @@
         return "\n".join(header_txt)
 
     def generate_intercept(self, proto, qual):
-        decl = proto.c_func(prefix="xgl", attr="XGLAPI")
+        decl = proto.c_func(prefix="vk", attr="VKAPI")
         param0_name = proto.params[0].name
         ret_val = ''
         stmt = ''
@@ -514,7 +514,7 @@
         elif 'Create' in proto.name or 'Alloc' in proto.name or 'MapMemory' in proto.name:
             create_params = -1
         if proto.ret != "void":
-            ret_val = "XGL_RESULT result = "
+            ret_val = "VK_RESULT result = "
             stmt = "    return result;\n"
         f_open = ''
         f_close = ''
@@ -523,11 +523,11 @@
             if 'CreateDevice' in proto.name:
                 file_mode = "w"
             f_open = 'loader_platform_thread_lock_mutex(&printLock);\n    pOutFile = fopen(outFileName, "%s");\n    ' % (file_mode)
-            log_func = 'fprintf(pOutFile, "t{%%u} xgl%s(' % proto.name
+            log_func = 'fprintf(pOutFile, "t{%%u} vk%s(' % proto.name
             f_close = '\n    fclose(pOutFile);\n    loader_platform_thread_unlock_mutex(&printLock);'
         else:
             f_open = 'loader_platform_thread_lock_mutex(&printLock);\n    '
-            log_func = 'printf("t{%%u} xgl%s(' % proto.name
+            log_func = 'printf("t{%%u} vk%s(' % proto.name
             f_close = '\n    loader_platform_thread_unlock_mutex(&printLock);'
         print_vals = ', getTIDIndex()'
         pindex = 0
@@ -549,7 +549,7 @@
                 sp_param_dict[pindex] = prev_count_name
             elif 'pDescriptorSets' == p.name and proto.params[-1].name == 'pCount':
                 sp_param_dict[pindex] = '*pCount'
-            elif 'Wsi' not in proto.name and xgl_helper.is_type(p.ty.strip('*').strip('const '), 'struct'):
+            elif 'Wsi' not in proto.name and vk_helper.is_type(p.ty.strip('*').strip('const '), 'struct'):
                 sp_param_dict[pindex] = 'index'
             pindex += 1
             if p.name.endswith('Count'):
@@ -562,7 +562,7 @@
         log_func = log_func.strip(', ')
         if proto.ret != "void":
             log_func += ') = %s\\n"'
-            print_vals += ', string_XGL_RESULT(result)'
+            print_vals += ', string_VK_RESULT(result)'
         else:
             log_func += ')\\n"'
         log_func = '%s%s);' % (log_func, print_vals)
@@ -572,7 +572,7 @@
             for sp_index in sorted(sp_param_dict):
                 # TODO : Clean this if/else block up, too much duplicated code
                 if 'index' == sp_param_dict[sp_index]:
-                    cis_print_func = 'xgl_print_%s' % (proto.params[sp_index].ty.strip('const ').strip('*').lower())
+                    cis_print_func = 'vk_print_%s' % (proto.params[sp_index].ty.strip('const ').strip('*').lower())
                     var_name = proto.params[sp_index].name
                     if proto.params[sp_index].name != 'color':
                         log_func += '\n    if (%s) {' % (proto.params[sp_index].name)
@@ -594,8 +594,8 @@
                     if proto.params[sp_index].name != 'color':
                         log_func += '\n    }'
                 else: # should have a count value stored to iterate over array
-                    if xgl_helper.is_type(proto.params[sp_index].ty.strip('*').strip('const '), 'struct'):
-                        cis_print_func = 'pTmpStr = xgl_print_%s(&%s[i], "    ");' % (proto.params[sp_index].ty.strip('const ').strip('*').lower(), proto.params[sp_index].name)
+                    if vk_helper.is_type(proto.params[sp_index].ty.strip('*').strip('const '), 'struct'):
+                        cis_print_func = 'pTmpStr = vk_print_%s(&%s[i], "    ");' % (proto.params[sp_index].ty.strip('const ').strip('*').lower(), proto.params[sp_index].name)
                     else:
                         cis_print_func = 'pTmpStr = (char*)malloc(32);\n        sprintf(pTmpStr, "    %%p", %s[i]);' % proto.params[sp_index].name
                     if not i_decl:
@@ -618,11 +618,11 @@
         if 'WsiX11AssociateConnection' == proto.name:
             funcs.append("#if defined(__linux__) || defined(XCB_NVIDIA)")
         if proto.name == "EnumerateLayers":
-            c_call = proto.c_call().replace("(" + proto.params[0].name, "((XGL_PHYSICAL_GPU)gpuw->nextObject", 1)
+            c_call = proto.c_call().replace("(" + proto.params[0].name, "((VK_PHYSICAL_GPU)gpuw->nextObject", 1)
             funcs.append('%s%s\n'
                      '{\n'
                      '    if (gpu != NULL) {\n'
-                     '        XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) %s;\n'
+                     '        VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) %s;\n'
                      '        pCurObj = gpuw;\n'
                      '        loader_platform_thread_once(&tabOnce, init%s);\n'
                      '        %snextTable.%s;\n'
@@ -630,34 +630,34 @@
                      '    %s'
                      '    } else {\n'
                      '        if (pOutLayerCount == NULL || pOutLayers == NULL || pOutLayers[0] == NULL)\n'
-                     '            return XGL_ERROR_INVALID_POINTER;\n'
+                     '            return VK_ERROR_INVALID_POINTER;\n'
                      '        // This layer compatible with all GPUs\n'
                      '        *pOutLayerCount = 1;\n'
                      '        strncpy((char *) pOutLayers[0], "%s", maxStringSize);\n'
-                     '        return XGL_SUCCESS;\n'
+                     '        return VK_SUCCESS;\n'
                      '    }\n'
                          '}' % (qual, decl, proto.params[0].name, self.layer_name, ret_val, c_call,f_open, log_func, f_close, stmt, self.layer_name))
         elif 'GetExtensionSupport' == proto.name:
-            c_call = proto.c_call().replace("(" + proto.params[0].name, "((XGL_PHYSICAL_GPU)gpuw->nextObject", 1)
+            c_call = proto.c_call().replace("(" + proto.params[0].name, "((VK_PHYSICAL_GPU)gpuw->nextObject", 1)
             funcs.append('%s%s\n'
                          '{\n'
-                         '    XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) %s;\n'
-                         '    XGL_RESULT result;\n'
+                         '    VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) %s;\n'
+                         '    VK_RESULT result;\n'
                          '    /* This entrypoint is NOT going to init its own dispatch table since loader calls here early */\n'
                          '    if (!strncmp(pExtName, "%s", strlen("%s")))\n'
                          '    {\n'
-                         '        result = XGL_SUCCESS;\n'
+                         '        result = VK_SUCCESS;\n'
                          '    } else if (nextTable.GetExtensionSupport != NULL)\n'
                          '    {\n'
                          '        result = nextTable.%s;\n'
                          '        %s    %s        %s\n'
                          '    } else\n'
                          '    {\n'
-                         '        result = XGL_ERROR_INVALID_EXTENSION;\n'
+                         '        result = VK_ERROR_INVALID_EXTENSION;\n'
                          '    }\n'
                          '%s'
                          '}' % (qual, decl, proto.params[0].name, self.layer_name, self.layer_name, c_call, f_open, log_func, f_close, stmt))
-        elif proto.params[0].ty != "XGL_PHYSICAL_GPU":
+        elif proto.params[0].ty != "VK_PHYSICAL_GPU":
             funcs.append('%s%s\n'
                      '{\n'
                      '    %snextTable.%s;\n'
@@ -665,10 +665,10 @@
                      '%s'
                      '}' % (qual, decl, ret_val, proto.c_call(), f_open, log_func, f_close, stmt))
         else:
-            c_call = proto.c_call().replace("(" + proto.params[0].name, "((XGL_PHYSICAL_GPU)gpuw->nextObject", 1)
+            c_call = proto.c_call().replace("(" + proto.params[0].name, "((VK_PHYSICAL_GPU)gpuw->nextObject", 1)
             funcs.append('%s%s\n'
                      '{\n'
-                     '    XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) %s;\n'
+                     '    VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) %s;\n'
                      '    pCurObj = gpuw;\n'
                      '    loader_platform_thread_once(&tabOnce, init%s);\n'
                      '    %snextTable.%s;\n'
@@ -682,7 +682,7 @@
     def generate_body(self):
         self.layer_name = "APIDump"
         body = [self._generate_layer_initialization_with_lock(),
-                self._generate_dispatch_entrypoints("XGL_LAYER_EXPORT"),
+                self._generate_dispatch_entrypoints("VK_LAYER_EXPORT"),
                 self._generate_layer_gpa_function()]
 
         return "\n\n".join(body)
@@ -692,11 +692,11 @@
         header_txt = []
         header_txt.append('#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>')
         header_txt.append('#include "loader_platform.h"')
-        header_txt.append('#include "xglLayer.h"\n#include "xgl_struct_string_helper_cpp.h"\n')
+        header_txt.append('#include "vkLayer.h"\n#include "vk_struct_string_helper_cpp.h"\n')
         header_txt.append('// The following is #included again to catch certain OS-specific functions being used:')
         header_txt.append('#include "loader_platform.h"')
-        header_txt.append('static XGL_LAYER_DISPATCH_TABLE nextTable;')
-        header_txt.append('static XGL_BASE_LAYER_OBJECT *pCurObj;\n')
+        header_txt.append('static VK_LAYER_DISPATCH_TABLE nextTable;')
+        header_txt.append('static VK_BASE_LAYER_OBJECT *pCurObj;\n')
         header_txt.append('static LOADER_PLATFORM_THREAD_ONCE_DECLARATION(tabOnce);')
         header_txt.append('static int printLockInitialized = 0;')
         header_txt.append('static loader_platform_thread_mutex printLock;\n')
@@ -720,7 +720,7 @@
         return "\n".join(header_txt)
 
     def generate_intercept(self, proto, qual):
-        decl = proto.c_func(prefix="xgl", attr="XGLAPI")
+        decl = proto.c_func(prefix="vk", attr="VKAPI")
         param0_name = proto.params[0].name
         ret_val = ''
         stmt = ''
@@ -732,7 +732,7 @@
         elif 'Create' in proto.name or 'Alloc' in proto.name or 'MapMemory' in proto.name:
             create_params = -1
         if proto.ret != "void":
-            ret_val = "XGL_RESULT result = "
+            ret_val = "VK_RESULT result = "
             stmt = "    return result;\n"
         f_open = ''
         f_close = ''
@@ -741,11 +741,11 @@
             if 'CreateDevice' in proto.name:
                 file_mode = "w"
             f_open = 'loader_platform_thread_lock_mutex(&printLock);\n    pOutFile = fopen(outFileName, "%s");\n    ' % (file_mode)
-            log_func = 'fprintf(pOutFile, "t{%%u} xgl%s(' % proto.name
+            log_func = 'fprintf(pOutFile, "t{%%u} vk%s(' % proto.name
             f_close = '\n    fclose(pOutFile);\n    loader_platform_thread_unlock_mutex(&printLock);'
         else:
             f_open = 'loader_platform_thread_lock_mutex(&printLock);\n    '
-            log_func = 'cout << "t{" << getTIDIndex() << "} xgl%s(' % proto.name
+            log_func = 'cout << "t{" << getTIDIndex() << "} vk%s(' % proto.name
             f_close = '\n    loader_platform_thread_unlock_mutex(&printLock);'
         pindex = 0
         prev_count_name = ''
@@ -765,7 +765,7 @@
                 sp_param_dict[pindex] = prev_count_name
             elif 'pDescriptorSets' == p.name and proto.params[-1].name == 'pCount':
                 sp_param_dict[pindex] = '*pCount'
-            elif 'Wsi' not in proto.name and xgl_helper.is_type(p.ty.strip('*').strip('const '), 'struct'):
+            elif 'Wsi' not in proto.name and vk_helper.is_type(p.ty.strip('*').strip('const '), 'struct'):
                 sp_param_dict[pindex] = 'index'
             pindex += 1
             if p.name.endswith('Count'):
@@ -777,8 +777,8 @@
                 prev_count_name = ''
         log_func = log_func.strip(', ')
         if proto.ret != "void":
-            log_func += ') = " << string_XGL_RESULT((XGL_RESULT)result) << endl'
-            #print_vals += ', string_XGL_RESULT_CODE(result)'
+            log_func += ') = " << string_VK_RESULT((VK_RESULT)result) << endl'
+            #print_vals += ', string_VK_RESULT_CODE(result)'
         else:
             log_func += ')\\n"'
         log_func += ';'
@@ -787,7 +787,7 @@
             log_func += '\n    string tmp_str;'
             for sp_index in sp_param_dict:
                 if 'index' == sp_param_dict[sp_index]:
-                    cis_print_func = 'xgl_print_%s' % (proto.params[sp_index].ty.strip('const ').strip('*').lower())
+                    cis_print_func = 'vk_print_%s' % (proto.params[sp_index].ty.strip('const ').strip('*').lower())
                     var_name = proto.params[sp_index].name
                     if proto.params[sp_index].name != 'color':
                         log_func += '\n    if (%s) {' % (proto.params[sp_index].name)
@@ -812,10 +812,10 @@
                 else: # We have a count value stored to iterate over an array
                     print_cast = ''
                     print_func = ''
-                    if xgl_helper.is_type(proto.params[sp_index].ty.strip('*').strip('const '), 'struct'):
+                    if vk_helper.is_type(proto.params[sp_index].ty.strip('*').strip('const '), 'struct'):
                         print_cast = '&'
-                        print_func = 'xgl_print_%s' % proto.params[sp_index].ty.strip('const ').strip('*').lower()
-                        #cis_print_func = 'tmp_str = xgl_print_%s(&%s[i], "    ");' % (proto.params[sp_index].ty.strip('const ').strip('*').lower(), proto.params[sp_index].name)
+                        print_func = 'vk_print_%s' % proto.params[sp_index].ty.strip('const ').strip('*').lower()
+                        #cis_print_func = 'tmp_str = vk_print_%s(&%s[i], "    ");' % (proto.params[sp_index].ty.strip('const ').strip('*').lower(), proto.params[sp_index].name)
 # TODO : Need to display this address as a string
                     else:
                         print_cast = '(void*)'
@@ -847,11 +847,11 @@
         if 'WsiX11AssociateConnection' == proto.name:
             funcs.append("#if defined(__linux__) || defined(XCB_NVIDIA)")
         if proto.name == "EnumerateLayers":
-            c_call = proto.c_call().replace("(" + proto.params[0].name, "((XGL_PHYSICAL_GPU)gpuw->nextObject", 1)
+            c_call = proto.c_call().replace("(" + proto.params[0].name, "((VK_PHYSICAL_GPU)gpuw->nextObject", 1)
             funcs.append('%s%s\n'
                      '{\n'
                      '    if (gpu != NULL) {\n'
-                     '        XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) %s;\n'
+                     '        VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) %s;\n'
                      '        pCurObj = gpuw;\n'
                      '        loader_platform_thread_once(&tabOnce, init%s);\n'
                      '        %snextTable.%s;\n'
@@ -859,34 +859,34 @@
                      '    %s'
                      '    } else {\n'
                      '        if (pOutLayerCount == NULL || pOutLayers == NULL || pOutLayers[0] == NULL)\n'
-                     '            return XGL_ERROR_INVALID_POINTER;\n'
+                     '            return VK_ERROR_INVALID_POINTER;\n'
                      '        // This layer compatible with all GPUs\n'
                      '        *pOutLayerCount = 1;\n'
                      '        strncpy((char *) pOutLayers[0], "%s", maxStringSize);\n'
-                     '        return XGL_SUCCESS;\n'
+                     '        return VK_SUCCESS;\n'
                      '    }\n'
                          '}' % (qual, decl, proto.params[0].name, self.layer_name, ret_val, c_call,f_open, log_func, f_close, stmt, self.layer_name))
         elif 'GetExtensionSupport' == proto.name:
-            c_call = proto.c_call().replace("(" + proto.params[0].name, "((XGL_PHYSICAL_GPU)gpuw->nextObject", 1)
+            c_call = proto.c_call().replace("(" + proto.params[0].name, "((VK_PHYSICAL_GPU)gpuw->nextObject", 1)
             funcs.append('%s%s\n'
                          '{\n'
-                         '    XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) %s;\n'
-                         '    XGL_RESULT result;\n'
+                         '    VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) %s;\n'
+                         '    VK_RESULT result;\n'
                          '    /* This entrypoint is NOT going to init its own dispatch table since loader calls here early */\n'
                          '    if (!strncmp(pExtName, "%s", strlen("%s")))\n'
                          '    {\n'
-                         '        result = XGL_SUCCESS;\n'
+                         '        result = VK_SUCCESS;\n'
                          '    } else if (nextTable.GetExtensionSupport != NULL)\n'
                          '    {\n'
                          '        result = nextTable.%s;\n'
                          '        %s    %s        %s\n'
                          '    } else\n'
                          '    {\n'
-                         '        result = XGL_ERROR_INVALID_EXTENSION;\n'
+                         '        result = VK_ERROR_INVALID_EXTENSION;\n'
                          '    }\n'
                          '%s'
                          '}' % (qual, decl, proto.params[0].name, self.layer_name, self.layer_name, c_call, f_open, log_func, f_close, stmt))
-        elif proto.params[0].ty != "XGL_PHYSICAL_GPU":
+        elif proto.params[0].ty != "VK_PHYSICAL_GPU":
             funcs.append('%s%s\n'
                      '{\n'
                      '    %snextTable.%s;\n'
@@ -894,10 +894,10 @@
                      '%s'
                      '}' % (qual, decl, ret_val, proto.c_call(), f_open, log_func, f_close, stmt))
         else:
-            c_call = proto.c_call().replace("(" + proto.params[0].name, "((XGL_PHYSICAL_GPU)gpuw->nextObject", 1)
+            c_call = proto.c_call().replace("(" + proto.params[0].name, "((VK_PHYSICAL_GPU)gpuw->nextObject", 1)
             funcs.append('%s%s\n'
                      '{\n'
-                     '    XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) %s;\n'
+                     '    VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) %s;\n'
                      '    pCurObj = gpuw;\n'
                      '    loader_platform_thread_once(&tabOnce, init%s);\n'
                      '    %snextTable.%s;\n'
@@ -911,7 +911,7 @@
     def generate_body(self):
         self.layer_name = "APIDumpCpp"
         body = [self._generate_layer_initialization_with_lock(),
-                self._generate_dispatch_entrypoints("XGL_LAYER_EXPORT"),
+                self._generate_dispatch_entrypoints("VK_LAYER_EXPORT"),
                 self._generate_layer_gpa_function()]
 
         return "\n\n".join(body)
@@ -922,11 +922,11 @@
         header_txt = []
         header_txt.append('#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>')
         header_txt.append('#include "loader_platform.h"')
-        header_txt.append('#include "xglLayer.h"\n#include "xgl_struct_string_helper.h"\n')
+        header_txt.append('#include "vkLayer.h"\n#include "vk_struct_string_helper.h"\n')
         header_txt.append('// The following is #included again to catch certain OS-specific functions being used:')
         header_txt.append('#include "loader_platform.h"')
-        header_txt.append('static XGL_LAYER_DISPATCH_TABLE nextTable;')
-        header_txt.append('static XGL_BASE_LAYER_OBJECT *pCurObj;\n')
+        header_txt.append('static VK_LAYER_DISPATCH_TABLE nextTable;')
+        header_txt.append('static VK_BASE_LAYER_OBJECT *pCurObj;\n')
         header_txt.append('static LOADER_PLATFORM_THREAD_ONCE_DECLARATION(tabOnce);')
         header_txt.append('static int printLockInitialized = 0;')
         header_txt.append('static loader_platform_thread_mutex printLock;\n')
@@ -947,13 +947,13 @@
         header_txt.append('    assert(maxTID < MAX_TID);')
         header_txt.append('    return retVal;')
         header_txt.append('}\n')
-        header_txt.append('static FILE* pOutFile;\nstatic char* outFileName = "xgl_apidump.txt";')
+        header_txt.append('static FILE* pOutFile;\nstatic char* outFileName = "vk_apidump.txt";')
         return "\n".join(header_txt)
 
     def generate_body(self):
         self.layer_name = "APIDumpFile"
         body = [self._generate_layer_initialization_with_lock(),
-                self._generate_dispatch_entrypoints("XGL_LAYER_EXPORT"),
+                self._generate_dispatch_entrypoints("VK_LAYER_EXPORT"),
                 self._generate_layer_gpa_function()]
 
         return "\n\n".join(body)
@@ -964,11 +964,11 @@
         header_txt = []
         header_txt.append('#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>')
         header_txt.append('#include "loader_platform.h"')
-        header_txt.append('#include "xglLayer.h"\n#include "xgl_struct_string_helper_no_addr.h"\n')
+        header_txt.append('#include "vkLayer.h"\n#include "vk_struct_string_helper_no_addr.h"\n')
         header_txt.append('// The following is #included again to catch certain OS-specific functions being used:')
         header_txt.append('#include "loader_platform.h"')
-        header_txt.append('static XGL_LAYER_DISPATCH_TABLE nextTable;')
-        header_txt.append('static XGL_BASE_LAYER_OBJECT *pCurObj;\n')
+        header_txt.append('static VK_LAYER_DISPATCH_TABLE nextTable;')
+        header_txt.append('static VK_BASE_LAYER_OBJECT *pCurObj;\n')
         header_txt.append('static LOADER_PLATFORM_THREAD_ONCE_DECLARATION(tabOnce);')
         header_txt.append('static int printLockInitialized = 0;')
         header_txt.append('static loader_platform_thread_mutex printLock;\n')
@@ -995,7 +995,7 @@
         self.layer_name = "APIDumpNoAddr"
         self.no_addr = True
         body = [self._generate_layer_initialization_with_lock(),
-                self._generate_dispatch_entrypoints("XGL_LAYER_EXPORT"),
+                self._generate_dispatch_entrypoints("VK_LAYER_EXPORT"),
                 self._generate_layer_gpa_function()]
 
         return "\n\n".join(body)
@@ -1006,11 +1006,11 @@
         header_txt = []
         header_txt.append('#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>')
         header_txt.append('#include "loader_platform.h"')
-        header_txt.append('#include "xglLayer.h"\n#include "xgl_struct_string_helper_no_addr_cpp.h"\n')
+        header_txt.append('#include "vkLayer.h"\n#include "vk_struct_string_helper_no_addr_cpp.h"\n')
         header_txt.append('// The following is #included again to catch certain OS-specific functions being used:')
         header_txt.append('#include "loader_platform.h"')
-        header_txt.append('static XGL_LAYER_DISPATCH_TABLE nextTable;')
-        header_txt.append('static XGL_BASE_LAYER_OBJECT *pCurObj;\n')
+        header_txt.append('static VK_LAYER_DISPATCH_TABLE nextTable;')
+        header_txt.append('static VK_BASE_LAYER_OBJECT *pCurObj;\n')
         header_txt.append('static LOADER_PLATFORM_THREAD_ONCE_DECLARATION(tabOnce);')
         header_txt.append('static int printLockInitialized = 0;')
         header_txt.append('static loader_platform_thread_mutex printLock;\n')
@@ -1037,7 +1037,7 @@
         self.layer_name = "APIDumpNoAddrCpp"
         self.no_addr = True
         body = [self._generate_layer_initialization_with_lock(),
-                self._generate_dispatch_entrypoints("XGL_LAYER_EXPORT"),
+                self._generate_dispatch_entrypoints("VK_LAYER_EXPORT"),
                 self._generate_layer_gpa_function()]
 
         return "\n\n".join(body)
@@ -1046,7 +1046,7 @@
     def generate_header(self):
         header_txt = []
         header_txt.append('#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n#include "loader_platform.h"')
-        header_txt.append('#include "object_track.h"\n\nstatic XGL_LAYER_DISPATCH_TABLE nextTable;\nstatic XGL_BASE_LAYER_OBJECT *pCurObj;')
+        header_txt.append('#include "object_track.h"\n\nstatic VK_LAYER_DISPATCH_TABLE nextTable;\nstatic VK_BASE_LAYER_OBJECT *pCurObj;')
         header_txt.append('// The following is #included again to catch certain OS-specific functions being used:')
         header_txt.append('#include "loader_platform.h"')
         header_txt.append('#include "layers_config.h"')
@@ -1064,9 +1064,9 @@
         header_txt.append('    struct _objNode *pNextObj;')
         header_txt.append('    struct _objNode *pNextGlobal;')
         header_txt.append('} objNode;')
-        header_txt.append('static objNode *pObjectHead[XGL_NUM_OBJECT_TYPE] = {0};')
+        header_txt.append('static objNode *pObjectHead[VK_NUM_OBJECT_TYPE] = {0};')
         header_txt.append('static objNode *pGlobalHead = NULL;')
-        header_txt.append('static uint64_t numObjs[XGL_NUM_OBJECT_TYPE] = {0};')
+        header_txt.append('static uint64_t numObjs[VK_NUM_OBJECT_TYPE] = {0};')
         header_txt.append('static uint64_t numTotalObjs = 0;')
         header_txt.append('static uint32_t maxMemReferences = 0;')
         header_txt.append('// Debug function to print global list and each individual object list')
@@ -1075,24 +1075,24 @@
         header_txt.append('    objNode* pTrav = pGlobalHead;')
         header_txt.append('    printf("=====GLOBAL OBJECT LIST (%lu total objs):\\n", numTotalObjs);')
         header_txt.append('    while (pTrav) {')
-        header_txt.append('        printf("   ObjNode (%p) w/ %s obj %p has pNextGlobal %p\\n", (void*)pTrav, string_XGL_OBJECT_TYPE(pTrav->obj.objType), pTrav->obj.pObj, (void*)pTrav->pNextGlobal);')
+        header_txt.append('        printf("   ObjNode (%p) w/ %s obj %p has pNextGlobal %p\\n", (void*)pTrav, string_VK_OBJECT_TYPE(pTrav->obj.objType), pTrav->obj.pObj, (void*)pTrav->pNextGlobal);')
         header_txt.append('        pTrav = pTrav->pNextGlobal;')
         header_txt.append('    }')
-        header_txt.append('    for (uint32_t i = 0; i < XGL_NUM_OBJECT_TYPE; i++) {')
+        header_txt.append('    for (uint32_t i = 0; i < VK_NUM_OBJECT_TYPE; i++) {')
         header_txt.append('        pTrav = pObjectHead[i];')
         header_txt.append('        if (pTrav) {')
-        header_txt.append('            printf("=====%s OBJECT LIST (%lu objs):\\n", string_XGL_OBJECT_TYPE(pTrav->obj.objType), numObjs[i]);')
+        header_txt.append('            printf("=====%s OBJECT LIST (%lu objs):\\n", string_VK_OBJECT_TYPE(pTrav->obj.objType), numObjs[i]);')
         header_txt.append('            while (pTrav) {')
-        header_txt.append('                printf("   ObjNode (%p) w/ %s obj %p has pNextObj %p\\n", (void*)pTrav, string_XGL_OBJECT_TYPE(pTrav->obj.objType), pTrav->obj.pObj, (void*)pTrav->pNextObj);')
+        header_txt.append('                printf("   ObjNode (%p) w/ %s obj %p has pNextObj %p\\n", (void*)pTrav, string_VK_OBJECT_TYPE(pTrav->obj.objType), pTrav->obj.pObj, (void*)pTrav->pNextObj);')
         header_txt.append('                pTrav = pTrav->pNextObj;')
         header_txt.append('            }')
         header_txt.append('        }')
         header_txt.append('    }')
         header_txt.append('}')
-        header_txt.append('static void ll_insert_obj(void* pObj, XGL_OBJECT_TYPE objType) {')
+        header_txt.append('static void ll_insert_obj(void* pObj, VK_OBJECT_TYPE objType) {')
         header_txt.append('    char str[1024];')
-        header_txt.append('    sprintf(str, "OBJ[%llu] : CREATE %s object %p", object_track_index++, string_XGL_OBJECT_TYPE(objType), (void*)pObj);')
-        header_txt.append('    layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, pObj, 0, OBJTRACK_NONE, "OBJTRACK", str);')
+        header_txt.append('    sprintf(str, "OBJ[%llu] : CREATE %s object %p", object_track_index++, string_VK_OBJECT_TYPE(objType), (void*)pObj);')
+        header_txt.append('    layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, pObj, 0, OBJTRACK_NONE, "OBJTRACK", str);')
         header_txt.append('    objNode* pNewObjNode = (objNode*)malloc(sizeof(objNode));')
         header_txt.append('    pNewObjNode->obj.pObj = pObj;')
         header_txt.append('    pNewObjNode->obj.objType = objType;')
@@ -1107,11 +1107,11 @@
         header_txt.append('    // increment obj counts')
         header_txt.append('    numObjs[objType]++;')
         header_txt.append('    numTotalObjs++;')
-        header_txt.append('    //sprintf(str, "OBJ_STAT : %lu total objs & %lu %s objs.", numTotalObjs, numObjs[objType], string_XGL_OBJECT_TYPE(objType));')
+        header_txt.append('    //sprintf(str, "OBJ_STAT : %lu total objs & %lu %s objs.", numTotalObjs, numObjs[objType], string_VK_OBJECT_TYPE(objType));')
         header_txt.append('    if (0) ll_print_lists();')
         header_txt.append('}')
         header_txt.append('// Traverse global list and return type for given object')
-        header_txt.append('static XGL_OBJECT_TYPE ll_get_obj_type(XGL_OBJECT object) {')
+        header_txt.append('static VK_OBJECT_TYPE ll_get_obj_type(VK_OBJECT object) {')
         header_txt.append('    objNode *pTrav = pGlobalHead;')
         header_txt.append('    while (pTrav) {')
         header_txt.append('        if (pTrav->obj.pObj == object)')
@@ -1120,11 +1120,11 @@
         header_txt.append('    }')
         header_txt.append('    char str[1024];')
         header_txt.append('    sprintf(str, "Attempting look-up on obj %p but it is NOT in the global list!", (void*)object);')
-        header_txt.append('    layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, object, 0, OBJTRACK_MISSING_OBJECT, "OBJTRACK", str);')
-        header_txt.append('    return XGL_OBJECT_TYPE_UNKNOWN;')
+        header_txt.append('    layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, object, 0, OBJTRACK_MISSING_OBJECT, "OBJTRACK", str);')
+        header_txt.append('    return VK_OBJECT_TYPE_UNKNOWN;')
         header_txt.append('}')
         header_txt.append('#if 0')
-        header_txt.append('static uint64_t ll_get_obj_uses(void* pObj, XGL_OBJECT_TYPE objType) {')
+        header_txt.append('static uint64_t ll_get_obj_uses(void* pObj, VK_OBJECT_TYPE objType) {')
         header_txt.append('    objNode *pTrav = pObjectHead[objType];')
         header_txt.append('    while (pTrav) {')
         header_txt.append('        if (pTrav->obj.pObj == pObj) {')
@@ -1135,22 +1135,22 @@
         header_txt.append('    return 0;')
         header_txt.append('}')
         header_txt.append('#endif')
-        header_txt.append('static void ll_increment_use_count(void* pObj, XGL_OBJECT_TYPE objType) {')
+        header_txt.append('static void ll_increment_use_count(void* pObj, VK_OBJECT_TYPE objType) {')
         header_txt.append('    objNode *pTrav = pObjectHead[objType];')
         header_txt.append('    while (pTrav) {')
         header_txt.append('        if (pTrav->obj.pObj == pObj) {')
         header_txt.append('            pTrav->obj.numUses++;')
         header_txt.append('            char str[1024];')
-        header_txt.append('            sprintf(str, "OBJ[%llu] : USING %s object %p (%lu total uses)", object_track_index++, string_XGL_OBJECT_TYPE(objType), (void*)pObj, pTrav->obj.numUses);')
-        header_txt.append('            layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, pObj, 0, OBJTRACK_NONE, "OBJTRACK", str);')
+        header_txt.append('            sprintf(str, "OBJ[%llu] : USING %s object %p (%lu total uses)", object_track_index++, string_VK_OBJECT_TYPE(objType), (void*)pObj, pTrav->obj.numUses);')
+        header_txt.append('            layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, pObj, 0, OBJTRACK_NONE, "OBJTRACK", str);')
         header_txt.append('            return;')
         header_txt.append('        }')
         header_txt.append('        pTrav = pTrav->pNextObj;')
         header_txt.append('    }')
         header_txt.append('    // If we do not find obj, insert it and then increment count')
         header_txt.append('    char str[1024];')
-        header_txt.append('    sprintf(str, "Unable to increment count for obj %p, will add to list as %s type and increment count", pObj, string_XGL_OBJECT_TYPE(objType));')
-        header_txt.append('    layerCbMsg(XGL_DBG_MSG_WARNING, XGL_VALIDATION_LEVEL_0, pObj, 0, OBJTRACK_UNKNOWN_OBJECT, "OBJTRACK", str);')
+        header_txt.append('    sprintf(str, "Unable to increment count for obj %p, will add to list as %s type and increment count", pObj, string_VK_OBJECT_TYPE(objType));')
+        header_txt.append('    layerCbMsg(VK_DBG_MSG_WARNING, VK_VALIDATION_LEVEL_0, pObj, 0, OBJTRACK_UNKNOWN_OBJECT, "OBJTRACK", str);')
         header_txt.append('')
         header_txt.append('    ll_insert_obj(pObj, objType);')
         header_txt.append('    ll_increment_use_count(pObj, objType);')
@@ -1158,7 +1158,7 @@
         header_txt.append('// We usually do not know Obj type when we destroy it so have to fetch')
         header_txt.append('//  Type from global list w/ ll_destroy_obj()')
         header_txt.append('//   and then do the full removal from both lists w/ ll_remove_obj_type()')
-        header_txt.append('static void ll_remove_obj_type(void* pObj, XGL_OBJECT_TYPE objType) {')
+        header_txt.append('static void ll_remove_obj_type(void* pObj, VK_OBJECT_TYPE objType) {')
         header_txt.append('    objNode *pTrav = pObjectHead[objType];')
         header_txt.append('    objNode *pPrev = pObjectHead[objType];')
         header_txt.append('    while (pTrav) {')
@@ -1170,16 +1170,16 @@
         header_txt.append('            assert(numObjs[objType] > 0);')
         header_txt.append('            numObjs[objType]--;')
         header_txt.append('            char str[1024];')
-        header_txt.append('            sprintf(str, "OBJ[%llu] : DESTROY %s object %p", object_track_index++, string_XGL_OBJECT_TYPE(objType), (void*)pObj);')
-        header_txt.append('            layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, pObj, 0, OBJTRACK_NONE, "OBJTRACK", str);')
+        header_txt.append('            sprintf(str, "OBJ[%llu] : DESTROY %s object %p", object_track_index++, string_VK_OBJECT_TYPE(objType), (void*)pObj);')
+        header_txt.append('            layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, pObj, 0, OBJTRACK_NONE, "OBJTRACK", str);')
         header_txt.append('            return;')
         header_txt.append('        }')
         header_txt.append('        pPrev = pTrav;')
         header_txt.append('        pTrav = pTrav->pNextObj;')
         header_txt.append('    }')
         header_txt.append('    char str[1024];')
-        header_txt.append('    sprintf(str, "OBJ INTERNAL ERROR : Obj %p was in global list but not in %s list", pObj, string_XGL_OBJECT_TYPE(objType));')
-        header_txt.append('    layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, pObj, 0, OBJTRACK_INTERNAL_ERROR, "OBJTRACK", str);')
+        header_txt.append('    sprintf(str, "OBJ INTERNAL ERROR : Obj %p was in global list but not in %s list", pObj, string_VK_OBJECT_TYPE(objType));')
+        header_txt.append('    layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, pObj, 0, OBJTRACK_INTERNAL_ERROR, "OBJTRACK", str);')
         header_txt.append('}')
         header_txt.append('// Parse global list to find obj type, then remove obj from obj type list, finally')
         header_txt.append('//   remove obj from global list')
@@ -1196,8 +1196,8 @@
         header_txt.append('            assert(numTotalObjs > 0);')
         header_txt.append('            numTotalObjs--;')
         header_txt.append('            char str[1024];')
-        header_txt.append('            sprintf(str, "OBJ_STAT Removed %s obj %p that was used %lu times (%lu total objs remain & %lu %s objs).", string_XGL_OBJECT_TYPE(pTrav->obj.objType), pTrav->obj.pObj, pTrav->obj.numUses, numTotalObjs, numObjs[pTrav->obj.objType], string_XGL_OBJECT_TYPE(pTrav->obj.objType));')
-        header_txt.append('            layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, pObj, 0, OBJTRACK_NONE, "OBJTRACK", str);')
+        header_txt.append('            sprintf(str, "OBJ_STAT Removed %s obj %p that was used %lu times (%lu total objs remain & %lu %s objs).", string_VK_OBJECT_TYPE(pTrav->obj.objType), pTrav->obj.pObj, pTrav->obj.numUses, numTotalObjs, numObjs[pTrav->obj.objType], string_VK_OBJECT_TYPE(pTrav->obj.objType));')
+        header_txt.append('            layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, pObj, 0, OBJTRACK_NONE, "OBJTRACK", str);')
         header_txt.append('            free(pTrav);')
         header_txt.append('            return;')
         header_txt.append('        }')
@@ -1206,10 +1206,10 @@
         header_txt.append('    }')
         header_txt.append('    char str[1024];')
         header_txt.append('    sprintf(str, "Unable to remove obj %p. Was it created? Has it already been destroyed?", pObj);')
-        header_txt.append('    layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, pObj, 0, OBJTRACK_DESTROY_OBJECT_FAILED, "OBJTRACK", str);')
+        header_txt.append('    layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, pObj, 0, OBJTRACK_DESTROY_OBJECT_FAILED, "OBJTRACK", str);')
         header_txt.append('}')
         header_txt.append('// Set selected flag state for an object node')
-        header_txt.append('static void set_status(void* pObj, XGL_OBJECT_TYPE objType, OBJECT_STATUS status_flag) {')
+        header_txt.append('static void set_status(void* pObj, VK_OBJECT_TYPE objType, OBJECT_STATUS status_flag) {')
         header_txt.append('    if (pObj != NULL) {')
         header_txt.append('        objNode *pTrav = pObjectHead[objType];')
         header_txt.append('        while (pTrav) {')
@@ -1221,24 +1221,24 @@
         header_txt.append('        }')
         header_txt.append('        // If we do not find it print an error')
         header_txt.append('        char str[1024];')
-        header_txt.append('        sprintf(str, "Unable to set status for non-existent object %p of %s type", pObj, string_XGL_OBJECT_TYPE(objType));')
-        header_txt.append('        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, pObj, 0, OBJTRACK_UNKNOWN_OBJECT, "OBJTRACK", str);')
+        header_txt.append('        sprintf(str, "Unable to set status for non-existent object %p of %s type", pObj, string_VK_OBJECT_TYPE(objType));')
+        header_txt.append('        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, pObj, 0, OBJTRACK_UNKNOWN_OBJECT, "OBJTRACK", str);')
         header_txt.append('    }');
         header_txt.append('}')
         header_txt.append('')
         header_txt.append('// Track selected state for an object node')
-        header_txt.append('static void track_object_status(void* pObj, XGL_STATE_BIND_POINT stateBindPoint) {')
-        header_txt.append('    objNode *pTrav = pObjectHead[XGL_OBJECT_TYPE_CMD_BUFFER];')
+        header_txt.append('static void track_object_status(void* pObj, VK_STATE_BIND_POINT stateBindPoint) {')
+        header_txt.append('    objNode *pTrav = pObjectHead[VK_OBJECT_TYPE_CMD_BUFFER];')
         header_txt.append('')
         header_txt.append('    while (pTrav) {')
         header_txt.append('        if (pTrav->obj.pObj == pObj) {')
-        header_txt.append('            if (stateBindPoint == XGL_STATE_BIND_VIEWPORT) {')
+        header_txt.append('            if (stateBindPoint == VK_STATE_BIND_VIEWPORT) {')
         header_txt.append('                pTrav->obj.status |= OBJSTATUS_VIEWPORT_BOUND;')
-        header_txt.append('            } else if (stateBindPoint == XGL_STATE_BIND_RASTER) {')
+        header_txt.append('            } else if (stateBindPoint == VK_STATE_BIND_RASTER) {')
         header_txt.append('                pTrav->obj.status |= OBJSTATUS_RASTER_BOUND;')
-        header_txt.append('            } else if (stateBindPoint == XGL_STATE_BIND_COLOR_BLEND) {')
+        header_txt.append('            } else if (stateBindPoint == VK_STATE_BIND_COLOR_BLEND) {')
         header_txt.append('                pTrav->obj.status |= OBJSTATUS_COLOR_BLEND_BOUND;')
-        header_txt.append('            } else if (stateBindPoint == XGL_STATE_BIND_DEPTH_STENCIL) {')
+        header_txt.append('            } else if (stateBindPoint == VK_STATE_BIND_DEPTH_STENCIL) {')
         header_txt.append('                pTrav->obj.status |= OBJSTATUS_DEPTH_STENCIL_BOUND;')
         header_txt.append('            }')
         header_txt.append('            return;')
@@ -1248,11 +1248,11 @@
         header_txt.append('    // If we do not find it print an error')
         header_txt.append('    char str[1024];')
         header_txt.append('    sprintf(str, "Unable to track status for non-existent Command Buffer object %p", pObj);')
-        header_txt.append('    layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, pObj, 0, OBJTRACK_UNKNOWN_OBJECT, "OBJTRACK", str);')
+        header_txt.append('    layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, pObj, 0, OBJTRACK_UNKNOWN_OBJECT, "OBJTRACK", str);')
         header_txt.append('}')
         header_txt.append('')
         header_txt.append('// Reset selected flag state for an object node')
-        header_txt.append('static void reset_status(void* pObj, XGL_OBJECT_TYPE objType, OBJECT_STATUS status_flag) {')
+        header_txt.append('static void reset_status(void* pObj, VK_OBJECT_TYPE objType, OBJECT_STATUS status_flag) {')
         header_txt.append('    objNode *pTrav = pObjectHead[objType];')
         header_txt.append('    while (pTrav) {')
         header_txt.append('        if (pTrav->obj.pObj == pObj) {')
@@ -1263,49 +1263,49 @@
         header_txt.append('    }')
         header_txt.append('    // If we do not find it print an error')
         header_txt.append('    char str[1024];')
-        header_txt.append('    sprintf(str, "Unable to reset status for non-existent object %p of %s type", pObj, string_XGL_OBJECT_TYPE(objType));')
-        header_txt.append('    layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, pObj, 0, OBJTRACK_UNKNOWN_OBJECT, "OBJTRACK", str);')
+        header_txt.append('    sprintf(str, "Unable to reset status for non-existent object %p of %s type", pObj, string_VK_OBJECT_TYPE(objType));')
+        header_txt.append('    layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, pObj, 0, OBJTRACK_UNKNOWN_OBJECT, "OBJTRACK", str);')
         header_txt.append('}')
         header_txt.append('')
         header_txt.append('// Check object status for selected flag state')
-        header_txt.append('static bool32_t validate_status(void* pObj, XGL_OBJECT_TYPE objType, OBJECT_STATUS status_mask, OBJECT_STATUS status_flag, XGL_DBG_MSG_TYPE error_level, OBJECT_TRACK_ERROR error_code, char* fail_msg) {')
+        header_txt.append('static bool32_t validate_status(void* pObj, VK_OBJECT_TYPE objType, OBJECT_STATUS status_mask, OBJECT_STATUS status_flag, VK_DBG_MSG_TYPE error_level, OBJECT_TRACK_ERROR error_code, char* fail_msg) {')
         header_txt.append('    objNode *pTrav = pObjectHead[objType];')
         header_txt.append('    while (pTrav) {')
         header_txt.append('        if (pTrav->obj.pObj == pObj) {')
         header_txt.append('            if ((pTrav->obj.status & status_mask) != status_flag) {')
         header_txt.append('                char str[1024];')
-        header_txt.append('                sprintf(str, "OBJECT VALIDATION WARNING: %s object %p: %s", string_XGL_OBJECT_TYPE(objType), (void*)pObj, fail_msg);')
-        header_txt.append('                layerCbMsg(error_level, XGL_VALIDATION_LEVEL_0, pObj, 0, error_code, "OBJTRACK", str);')
-        header_txt.append('                return XGL_FALSE;')
+        header_txt.append('                sprintf(str, "OBJECT VALIDATION WARNING: %s object %p: %s", string_VK_OBJECT_TYPE(objType), (void*)pObj, fail_msg);')
+        header_txt.append('                layerCbMsg(error_level, VK_VALIDATION_LEVEL_0, pObj, 0, error_code, "OBJTRACK", str);')
+        header_txt.append('                return VK_FALSE;')
         header_txt.append('            }')
-        header_txt.append('            return XGL_TRUE;')
+        header_txt.append('            return VK_TRUE;')
         header_txt.append('        }')
         header_txt.append('        pTrav = pTrav->pNextObj;')
         header_txt.append('    }')
-        header_txt.append('    if (objType != XGL_OBJECT_TYPE_PRESENTABLE_IMAGE_MEMORY) {')
+        header_txt.append('    if (objType != VK_OBJECT_TYPE_PRESENTABLE_IMAGE_MEMORY) {')
         header_txt.append('        // If we do not find it print an error')
         header_txt.append('        char str[1024];')
-        header_txt.append('        sprintf(str, "Unable to obtain status for non-existent object %p of %s type", pObj, string_XGL_OBJECT_TYPE(objType));')
-        header_txt.append('        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, pObj, 0, OBJTRACK_UNKNOWN_OBJECT, "OBJTRACK", str);')
+        header_txt.append('        sprintf(str, "Unable to obtain status for non-existent object %p of %s type", pObj, string_VK_OBJECT_TYPE(objType));')
+        header_txt.append('        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, pObj, 0, OBJTRACK_UNKNOWN_OBJECT, "OBJTRACK", str);')
         header_txt.append('    }')
-        header_txt.append('    return XGL_FALSE;')
+        header_txt.append('    return VK_FALSE;')
         header_txt.append('}')
         header_txt.append('')
         header_txt.append('static void validate_draw_state_flags(void* pObj) {')
-        header_txt.append('    validate_status((void*)pObj, XGL_OBJECT_TYPE_CMD_BUFFER, OBJSTATUS_VIEWPORT_BOUND,      OBJSTATUS_VIEWPORT_BOUND,      XGL_DBG_MSG_ERROR,    OBJTRACK_VIEWPORT_NOT_BOUND,      "Viewport object not bound to this command buffer");')
-        header_txt.append('    validate_status((void*)pObj, XGL_OBJECT_TYPE_CMD_BUFFER, OBJSTATUS_RASTER_BOUND,        OBJSTATUS_RASTER_BOUND,        XGL_DBG_MSG_ERROR,    OBJTRACK_RASTER_NOT_BOUND,        "Raster object not bound to this command buffer");')
-        header_txt.append('    validate_status((void*)pObj, XGL_OBJECT_TYPE_CMD_BUFFER, OBJSTATUS_COLOR_BLEND_BOUND,   OBJSTATUS_COLOR_BLEND_BOUND,   XGL_DBG_MSG_UNKNOWN,  OBJTRACK_COLOR_BLEND_NOT_BOUND,   "Color-blend object not bound to this command buffer");')
-        header_txt.append('    validate_status((void*)pObj, XGL_OBJECT_TYPE_CMD_BUFFER, OBJSTATUS_DEPTH_STENCIL_BOUND, OBJSTATUS_DEPTH_STENCIL_BOUND, XGL_DBG_MSG_UNKNOWN,  OBJTRACK_DEPTH_STENCIL_NOT_BOUND, "Depth-stencil object not bound to this command buffer");')
+        header_txt.append('    validate_status((void*)pObj, VK_OBJECT_TYPE_CMD_BUFFER, OBJSTATUS_VIEWPORT_BOUND,      OBJSTATUS_VIEWPORT_BOUND,      VK_DBG_MSG_ERROR,    OBJTRACK_VIEWPORT_NOT_BOUND,      "Viewport object not bound to this command buffer");')
+        header_txt.append('    validate_status((void*)pObj, VK_OBJECT_TYPE_CMD_BUFFER, OBJSTATUS_RASTER_BOUND,        OBJSTATUS_RASTER_BOUND,        VK_DBG_MSG_ERROR,    OBJTRACK_RASTER_NOT_BOUND,        "Raster object not bound to this command buffer");')
+        header_txt.append('    validate_status((void*)pObj, VK_OBJECT_TYPE_CMD_BUFFER, OBJSTATUS_COLOR_BLEND_BOUND,   OBJSTATUS_COLOR_BLEND_BOUND,   VK_DBG_MSG_UNKNOWN,  OBJTRACK_COLOR_BLEND_NOT_BOUND,   "Color-blend object not bound to this command buffer");')
+        header_txt.append('    validate_status((void*)pObj, VK_OBJECT_TYPE_CMD_BUFFER, OBJSTATUS_DEPTH_STENCIL_BOUND, OBJSTATUS_DEPTH_STENCIL_BOUND, VK_DBG_MSG_UNKNOWN,  OBJTRACK_DEPTH_STENCIL_NOT_BOUND, "Depth-stencil object not bound to this command buffer");')
         header_txt.append('}')
         header_txt.append('')
-        header_txt.append('static void validate_memory_mapping_status(const XGL_GPU_MEMORY* pMemRefs, uint32_t numRefs) {')
+        header_txt.append('static void validate_memory_mapping_status(const VK_GPU_MEMORY* pMemRefs, uint32_t numRefs) {')
         header_txt.append('    uint32_t i;')
         header_txt.append('    for (i = 0; i < numRefs; i++) {')
         header_txt.append('        if (pMemRefs[i]) {')
         header_txt.append('            // If mem reference is in a presentable image memory list, skip the check of the GPU_MEMORY list')
-        header_txt.append('            if (!validate_status((void *)pMemRefs[i], XGL_OBJECT_TYPE_PRESENTABLE_IMAGE_MEMORY, OBJSTATUS_NONE, OBJSTATUS_NONE, XGL_DBG_MSG_UNKNOWN, OBJTRACK_NONE, NULL) == XGL_TRUE)')
+        header_txt.append('            if (!validate_status((void *)pMemRefs[i], VK_OBJECT_TYPE_PRESENTABLE_IMAGE_MEMORY, OBJSTATUS_NONE, OBJSTATUS_NONE, VK_DBG_MSG_UNKNOWN, OBJTRACK_NONE, NULL) == VK_TRUE)')
         header_txt.append('            {')
-        header_txt.append('                validate_status((void *)pMemRefs[i], XGL_OBJECT_TYPE_GPU_MEMORY, OBJSTATUS_GPU_MEM_MAPPED, OBJSTATUS_NONE, XGL_DBG_MSG_ERROR, OBJTRACK_GPU_MEM_MAPPED, "A Mapped Memory Object was referenced in a command buffer");')
+        header_txt.append('                validate_status((void *)pMemRefs[i], VK_OBJECT_TYPE_GPU_MEMORY, OBJSTATUS_GPU_MEM_MAPPED, OBJSTATUS_NONE, VK_DBG_MSG_ERROR, OBJTRACK_GPU_MEM_MAPPED, "A Mapped Memory Object was referenced in a command buffer");')
         header_txt.append('            }')
         header_txt.append('        }')
         header_txt.append('    }')
@@ -1314,19 +1314,19 @@
         header_txt.append('static void validate_mem_ref_count(uint32_t numRefs) {')
         header_txt.append('    if (maxMemReferences == 0) {')
         header_txt.append('        char str[1024];')
-        header_txt.append('        sprintf(str, "xglQueueSubmit called before calling xglGetGpuInfo");')
-        header_txt.append('        layerCbMsg(XGL_DBG_MSG_WARNING, XGL_VALIDATION_LEVEL_0, NULL, 0, OBJTRACK_GETGPUINFO_NOT_CALLED, "OBJTRACK", str);')
+        header_txt.append('        sprintf(str, "vkQueueSubmit called before calling vkGetGpuInfo");')
+        header_txt.append('        layerCbMsg(VK_DBG_MSG_WARNING, VK_VALIDATION_LEVEL_0, NULL, 0, OBJTRACK_GETGPUINFO_NOT_CALLED, "OBJTRACK", str);')
         header_txt.append('    } else {')
         header_txt.append('        if (numRefs > maxMemReferences) {')
         header_txt.append('            char str[1024];')
-        header_txt.append('            sprintf(str, "xglQueueSubmit Memory reference count (%d) exceeds allowable GPU limit (%d)", numRefs, maxMemReferences);')
-        header_txt.append('            layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, OBJTRACK_MEMREFCOUNT_MAX_EXCEEDED, "OBJTRACK", str);')
+        header_txt.append('            sprintf(str, "vkQueueSubmit Memory reference count (%d) exceeds allowable GPU limit (%d)", numRefs, maxMemReferences);')
+        header_txt.append('            layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, OBJTRACK_MEMREFCOUNT_MAX_EXCEEDED, "OBJTRACK", str);')
         header_txt.append('        }')
         header_txt.append('    }')
         header_txt.append('}')
         header_txt.append('')
         header_txt.append('static void setGpuQueueInfoState(void *pData) {')
-        header_txt.append('    maxMemReferences = ((XGL_PHYSICAL_GPU_QUEUE_PROPERTIES *)pData)->maxMemReferences;')
+        header_txt.append('    maxMemReferences = ((VK_PHYSICAL_GPU_QUEUE_PROPERTIES *)pData)->maxMemReferences;')
         header_txt.append('}')
         return "\n".join(header_txt)
 
@@ -1334,12 +1334,12 @@
         if proto.name in [ 'DbgRegisterMsgCallback', 'DbgUnregisterMsgCallback' ]:
             # use default version
             return None
-        obj_type_mapping = {base_t : base_t.replace("XGL_", "XGL_OBJECT_TYPE_") for base_t in xgl.object_type_list}
+        obj_type_mapping = {base_t : base_t.replace("VK_", "VK_OBJECT_TYPE_") for base_t in xgl.object_type_list}
         # For the various "super-types" we have to use function to distinguish sub type
-        for obj_type in ["XGL_BASE_OBJECT", "XGL_OBJECT", "XGL_DYNAMIC_STATE_OBJECT"]:
+        for obj_type in ["VK_BASE_OBJECT", "VK_OBJECT", "VK_DYNAMIC_STATE_OBJECT"]:
             obj_type_mapping[obj_type] = "ll_get_obj_type(object)"
 
-        decl = proto.c_func(prefix="xgl", attr="XGLAPI")
+        decl = proto.c_func(prefix="vk", attr="VKAPI")
         param0_name = proto.params[0].name
         p0_type = proto.params[0].ty.strip('*').strip('const ')
         create_line = ''
@@ -1353,15 +1353,15 @@
             using_line += '    ll_increment_use_count((void*)%s, %s);\n' % (param0_name, obj_type_mapping[p0_type])
             using_line += '    loader_platform_thread_unlock_mutex(&objLock);\n'
         if 'QueueSubmit' in proto.name:
-            using_line += '    set_status((void*)fence, XGL_OBJECT_TYPE_FENCE, OBJSTATUS_FENCE_IS_SUBMITTED);\n'
+            using_line += '    set_status((void*)fence, VK_OBJECT_TYPE_FENCE, OBJSTATUS_FENCE_IS_SUBMITTED);\n'
             using_line += '    // TODO: Fix for updated memory reference mechanism\n'
             using_line += '    // validate_memory_mapping_status(pMemRefs, memRefCount);\n'
             using_line += '    // validate_mem_ref_count(memRefCount);\n'
         elif 'GetFenceStatus' in proto.name:
             using_line += '    // Warn if submitted_flag is not set\n'
-            using_line += '    validate_status((void*)fence, XGL_OBJECT_TYPE_FENCE, OBJSTATUS_FENCE_IS_SUBMITTED, OBJSTATUS_FENCE_IS_SUBMITTED, XGL_DBG_MSG_ERROR, OBJTRACK_INVALID_FENCE, "Status Requested for Unsubmitted Fence");\n'
+            using_line += '    validate_status((void*)fence, VK_OBJECT_TYPE_FENCE, OBJSTATUS_FENCE_IS_SUBMITTED, OBJSTATUS_FENCE_IS_SUBMITTED, VK_DBG_MSG_ERROR, OBJTRACK_INVALID_FENCE, "Status Requested for Unsubmitted Fence");\n'
         elif 'EndCommandBuffer' in proto.name:
-            using_line += '    reset_status((void*)cmdBuffer, XGL_OBJECT_TYPE_CMD_BUFFER, (OBJSTATUS_VIEWPORT_BOUND    |\n'
+            using_line += '    reset_status((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER, (OBJSTATUS_VIEWPORT_BOUND    |\n'
             using_line += '                                                                OBJSTATUS_RASTER_BOUND      |\n'
             using_line += '                                                                OBJSTATUS_COLOR_BLEND_BOUND |\n'
             using_line += '                                                                OBJSTATUS_DEPTH_STENCIL_BOUND));\n'
@@ -1370,20 +1370,20 @@
         elif 'CmdDraw' in proto.name:
             using_line += '    validate_draw_state_flags((void *)cmdBuffer);\n'
         elif 'MapMemory' in proto.name:
-            using_line += '    set_status((void*)mem, XGL_OBJECT_TYPE_GPU_MEMORY, OBJSTATUS_GPU_MEM_MAPPED);\n'
+            using_line += '    set_status((void*)mem, VK_OBJECT_TYPE_GPU_MEMORY, OBJSTATUS_GPU_MEM_MAPPED);\n'
         elif 'UnmapMemory' in proto.name:
-            using_line += '    reset_status((void*)mem, XGL_OBJECT_TYPE_GPU_MEMORY, OBJSTATUS_GPU_MEM_MAPPED);\n'
+            using_line += '    reset_status((void*)mem, VK_OBJECT_TYPE_GPU_MEMORY, OBJSTATUS_GPU_MEM_MAPPED);\n'
         if 'AllocDescriptor' in proto.name: # Allocates array of DSs
             create_line =  '    for (uint32_t i = 0; i < *pCount; i++) {\n'
             create_line += '        loader_platform_thread_lock_mutex(&objLock);\n'
-            create_line += '        ll_insert_obj((void*)pDescriptorSets[i], XGL_OBJECT_TYPE_DESCRIPTOR_SET);\n'
+            create_line += '        ll_insert_obj((void*)pDescriptorSets[i], VK_OBJECT_TYPE_DESCRIPTOR_SET);\n'
             create_line += '        loader_platform_thread_unlock_mutex(&objLock);\n'
             create_line += '    }\n'
         elif 'CreatePresentableImage' in proto.name:
             create_line = '    loader_platform_thread_lock_mutex(&objLock);\n'
             create_line += '    ll_insert_obj((void*)*%s, %s);\n' % (proto.params[-2].name, obj_type_mapping[proto.params[-2].ty.strip('*').strip('const ')])
-            create_line += '    ll_insert_obj((void*)*pMem, XGL_OBJECT_TYPE_PRESENTABLE_IMAGE_MEMORY);\n'
-            # create_line += '    ll_insert_obj((void*)*%s, XGL_OBJECT_TYPE_PRESENTABLE_IMAGE_MEMORY);\n' % (obj_type_mapping[proto.params[-1].ty.strip('*').strip('const ')])
+            create_line += '    ll_insert_obj((void*)*pMem, VK_OBJECT_TYPE_PRESENTABLE_IMAGE_MEMORY);\n'
+            # create_line += '    ll_insert_obj((void*)*%s, VK_OBJECT_TYPE_PRESENTABLE_IMAGE_MEMORY);\n' % (obj_type_mapping[proto.params[-1].ty.strip('*').strip('const ')])
             create_line += '    loader_platform_thread_unlock_mutex(&objLock);\n'
         elif 'Create' in proto.name or 'Alloc' in proto.name:
             create_line = '    loader_platform_thread_lock_mutex(&objLock);\n'
@@ -1402,30 +1402,30 @@
                 using_line = ''
             if 'DestroyDevice' in proto.name:
                 destroy_line += '    // Report any remaining objects in LL\n    objNode *pTrav = pGlobalHead;\n    while (pTrav) {\n'
-                destroy_line += '        if (pTrav->obj.objType == XGL_OBJECT_TYPE_PRESENTABLE_IMAGE_MEMORY) {\n'
+                destroy_line += '        if (pTrav->obj.objType == VK_OBJECT_TYPE_PRESENTABLE_IMAGE_MEMORY) {\n'
                 destroy_line += '            objNode *pDel = pTrav;\n'
                 destroy_line += '            pTrav = pTrav->pNextGlobal;\n'
                 destroy_line += '            ll_destroy_obj((void*)(pDel->obj.pObj));\n'
                 destroy_line += '        } else {\n'
                 destroy_line += '            char str[1024];\n'
-                destroy_line += '            sprintf(str, "OBJ ERROR : %s object %p has not been destroyed (was used %lu times).", string_XGL_OBJECT_TYPE(pTrav->obj.objType), pTrav->obj.pObj, pTrav->obj.numUses);\n'
-                destroy_line += '            layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, device, 0, OBJTRACK_OBJECT_LEAK, "OBJTRACK", str);\n'
+                destroy_line += '            sprintf(str, "OBJ ERROR : %s object %p has not been destroyed (was used %lu times).", string_VK_OBJECT_TYPE(pTrav->obj.objType), pTrav->obj.pObj, pTrav->obj.numUses);\n'
+                destroy_line += '            layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, device, 0, OBJTRACK_OBJECT_LEAK, "OBJTRACK", str);\n'
                 destroy_line += '            pTrav = pTrav->pNextGlobal;\n'
                 destroy_line += '        }\n'
                 destroy_line += '    }\n'
         ret_val = ''
         stmt = ''
         if proto.ret != "void":
-            ret_val = "XGL_RESULT result = "
+            ret_val = "VK_RESULT result = "
             stmt = "    return result;\n"
         if 'WsiX11AssociateConnection' == proto.name:
             funcs.append("#if defined(__linux__) || defined(XCB_NVIDIA)")
         if proto.name == "EnumerateLayers":
-            c_call = proto.c_call().replace("(" + proto.params[0].name, "((XGL_PHYSICAL_GPU)gpuw->nextObject", 1)
+            c_call = proto.c_call().replace("(" + proto.params[0].name, "((VK_PHYSICAL_GPU)gpuw->nextObject", 1)
             funcs.append('%s%s\n'
                      '{\n'
                      '    if (gpu != NULL) {\n'
-                     '        XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) %s;\n'
+                     '        VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) %s;\n'
                      '    %s'
                      '        pCurObj = gpuw;\n'
                      '        loader_platform_thread_once(&tabOnce, init%s);\n'
@@ -1434,36 +1434,36 @@
                      '    %s'
                      '    } else {\n'
                      '        if (pOutLayerCount == NULL || pOutLayers == NULL || pOutLayers[0] == NULL)\n'
-                     '            return XGL_ERROR_INVALID_POINTER;\n'
+                     '            return VK_ERROR_INVALID_POINTER;\n'
                      '        // This layer compatible with all GPUs\n'
                      '        *pOutLayerCount = 1;\n'
                      '        strncpy((char *) pOutLayers[0], "%s", maxStringSize);\n'
-                     '        return XGL_SUCCESS;\n'
+                     '        return VK_SUCCESS;\n'
                      '    }\n'
                          '}' % (qual, decl, proto.params[0].name, using_line, self.layer_name, ret_val, c_call, create_line, destroy_line, stmt, self.layer_name))
         elif 'GetExtensionSupport' == proto.name:
-            c_call = proto.c_call().replace("(" + proto.params[0].name, "((XGL_PHYSICAL_GPU)gpuw->nextObject", 1)
+            c_call = proto.c_call().replace("(" + proto.params[0].name, "((VK_PHYSICAL_GPU)gpuw->nextObject", 1)
             funcs.append('%s%s\n'
                      '{\n'
-                     '    XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) %s;\n'
-                     '    XGL_RESULT result;\n'
+                     '    VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) %s;\n'
+                     '    VK_RESULT result;\n'
                      '    /* This entrypoint is NOT going to init its own dispatch table since loader calls this early */\n'
                      '    if (!strncmp(pExtName, "%s", strlen("%s")) ||\n'
                      '        !strncmp(pExtName, "objTrackGetObjectCount", strlen("objTrackGetObjectCount")) ||\n'
                      '        !strncmp(pExtName, "objTrackGetObjects", strlen("objTrackGetObjects")))\n'
                      '    {\n'
-                     '        result = XGL_SUCCESS;\n'
+                     '        result = VK_SUCCESS;\n'
                      '    } else if (nextTable.GetExtensionSupport != NULL)\n'
                      '    {\n'
                      '    %s'
                      '        result = nextTable.%s;\n'
                      '    } else\n'
                      '    {\n'
-                     '        result = XGL_ERROR_INVALID_EXTENSION;\n'
+                     '        result = VK_ERROR_INVALID_EXTENSION;\n'
                      '    }\n'
                      '%s'
                      '}' % (qual, decl, proto.params[0].name, self.layer_name, self.layer_name, using_line, c_call,  stmt))
-        elif proto.params[0].ty != "XGL_PHYSICAL_GPU":
+        elif proto.params[0].ty != "VK_PHYSICAL_GPU":
             funcs.append('%s%s\n'
                      '{\n'
                      '%s'
@@ -1472,17 +1472,17 @@
                      '%s'
                      '}' % (qual, decl, using_line, ret_val, proto.c_call(), create_line, destroy_line, stmt))
         else:
-            c_call = proto.c_call().replace("(" + proto.params[0].name, "((XGL_PHYSICAL_GPU)gpuw->nextObject", 1)
+            c_call = proto.c_call().replace("(" + proto.params[0].name, "((VK_PHYSICAL_GPU)gpuw->nextObject", 1)
             gpu_state = ''
             if 'GetGpuInfo' in proto.name:
-                gpu_state =  '    if (infoType == XGL_INFO_TYPE_PHYSICAL_GPU_QUEUE_PROPERTIES) {\n'
+                gpu_state =  '    if (infoType == VK_INFO_TYPE_PHYSICAL_GPU_QUEUE_PROPERTIES) {\n'
                 gpu_state += '        if (pData != NULL) {\n'
                 gpu_state += '            setGpuQueueInfoState(pData);\n'
                 gpu_state += '        }\n'
                 gpu_state += '    }\n'
             funcs.append('%s%s\n'
                      '{\n'
-                     '    XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) %s;\n'
+                     '    VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) %s;\n'
                      '%s'
                      '    pCurObj = gpuw;\n'
                      '    loader_platform_thread_once(&tabOnce, init%s);\n'
@@ -1498,7 +1498,7 @@
     def generate_body(self):
         self.layer_name = "ObjectTracker"
         body = [self._generate_layer_initialization(True, lockname='obj'),
-                self._generate_dispatch_entrypoints("XGL_LAYER_EXPORT"),
+                self._generate_dispatch_entrypoints("VK_LAYER_EXPORT"),
                 self._generate_extensions(),
                 self._generate_layer_gpa_function(extensions=['objTrackGetObjectCount', 'objTrackGetObjects'])]
 
@@ -1523,14 +1523,14 @@
         print("Available subcommands are: %s" % " ".join(subcommands))
         exit(1)
 
-    hfp = xgl_helper.HeaderFileParser(sys.argv[2])
+    hfp = vk_helper.HeaderFileParser(sys.argv[2])
     hfp.parse()
-    xgl_helper.enum_val_dict = hfp.get_enum_val_dict()
-    xgl_helper.enum_type_dict = hfp.get_enum_type_dict()
-    xgl_helper.struct_dict = hfp.get_struct_dict()
-    xgl_helper.typedef_fwd_dict = hfp.get_typedef_fwd_dict()
-    xgl_helper.typedef_rev_dict = hfp.get_typedef_rev_dict()
-    xgl_helper.types_dict = hfp.get_types_dict()
+    vk_helper.enum_val_dict = hfp.get_enum_val_dict()
+    vk_helper.enum_type_dict = hfp.get_enum_type_dict()
+    vk_helper.struct_dict = hfp.get_struct_dict()
+    vk_helper.typedef_fwd_dict = hfp.get_typedef_fwd_dict()
+    vk_helper.typedef_rev_dict = hfp.get_typedef_rev_dict()
+    vk_helper.types_dict = hfp.get_types_dict()
 
     subcmd = subcommands[sys.argv[1]](sys.argv[2:])
     subcmd.run()
diff --git a/xgl.py b/xgl.py
old mode 100644
new mode 100755
index 3a2d728..861d4fe
--- a/xgl.py
+++ b/xgl.py
@@ -1,4 +1,4 @@
-"""XGL API description"""
+"""VK API description"""
 
 # Copyright (C) 2014 LunarG, Inc.
 #
@@ -99,7 +99,7 @@
             return "%s %s%s(%s)" % format_vals
 
     def c_pretty_decl(self, name, attr=""):
-        """Return a named declaration in C, with xgl.h formatting."""
+        """Return a named declaration in C, with vulkan.h formatting."""
         plist = []
         for param in self.params:
             idx = param.ty.find("[")
@@ -131,11 +131,11 @@
         return "%s(%s)" % (self.name, self.c_params(need_type=False))
 
     def object_in_params(self):
-        """Return the params that are simple XGL objects and are inputs."""
+        """Return the params that are simple VK objects and are inputs."""
         return [param for param in self.params if param.ty in objects]
 
     def object_out_params(self):
-        """Return the params that are simple XGL objects and are outputs."""
+        """Return the params that are simple VK objects and are outputs."""
         return [param for param in self.params
                 if param.dereferenced_type() in objects]
 
@@ -178,465 +178,465 @@
 
         return "\n".join(lines)
 
-# XGL core API
+# VK core API
 core = Extension(
-    name="XGL_CORE",
-    headers=["xgl.h", "xglDbg.h"],
+    name="VK_CORE",
+    headers=["vulkan.h", "xglDbg.h"],
     objects=[
-        "XGL_INSTANCE",
-        "XGL_PHYSICAL_GPU",
-        "XGL_BASE_OBJECT",
-        "XGL_DEVICE",
-        "XGL_QUEUE",
-        "XGL_GPU_MEMORY",
-        "XGL_OBJECT",
-        "XGL_BUFFER",
-        "XGL_BUFFER_VIEW",
-        "XGL_IMAGE",
-        "XGL_IMAGE_VIEW",
-        "XGL_COLOR_ATTACHMENT_VIEW",
-        "XGL_DEPTH_STENCIL_VIEW",
-        "XGL_SHADER",
-        "XGL_PIPELINE",
-        "XGL_SAMPLER",
-        "XGL_DESCRIPTOR_SET",
-        "XGL_DESCRIPTOR_SET_LAYOUT",
-        "XGL_DESCRIPTOR_SET_LAYOUT_CHAIN",
-        "XGL_DESCRIPTOR_POOL",
-        "XGL_DYNAMIC_STATE_OBJECT",
-        "XGL_DYNAMIC_VP_STATE_OBJECT",
-        "XGL_DYNAMIC_RS_STATE_OBJECT",
-        "XGL_DYNAMIC_CB_STATE_OBJECT",
-        "XGL_DYNAMIC_DS_STATE_OBJECT",
-        "XGL_CMD_BUFFER",
-        "XGL_FENCE",
-        "XGL_SEMAPHORE",
-        "XGL_EVENT",
-        "XGL_QUERY_POOL",
-        "XGL_FRAMEBUFFER",
-        "XGL_RENDER_PASS",
+        "VK_INSTANCE",
+        "VK_PHYSICAL_GPU",
+        "VK_BASE_OBJECT",
+        "VK_DEVICE",
+        "VK_QUEUE",
+        "VK_GPU_MEMORY",
+        "VK_OBJECT",
+        "VK_BUFFER",
+        "VK_BUFFER_VIEW",
+        "VK_IMAGE",
+        "VK_IMAGE_VIEW",
+        "VK_COLOR_ATTACHMENT_VIEW",
+        "VK_DEPTH_STENCIL_VIEW",
+        "VK_SHADER",
+        "VK_PIPELINE",
+        "VK_SAMPLER",
+        "VK_DESCRIPTOR_SET",
+        "VK_DESCRIPTOR_SET_LAYOUT",
+        "VK_DESCRIPTOR_SET_LAYOUT_CHAIN",
+        "VK_DESCRIPTOR_POOL",
+        "VK_DYNAMIC_STATE_OBJECT",
+        "VK_DYNAMIC_VP_STATE_OBJECT",
+        "VK_DYNAMIC_RS_STATE_OBJECT",
+        "VK_DYNAMIC_CB_STATE_OBJECT",
+        "VK_DYNAMIC_DS_STATE_OBJECT",
+        "VK_CMD_BUFFER",
+        "VK_FENCE",
+        "VK_SEMAPHORE",
+        "VK_EVENT",
+        "VK_QUERY_POOL",
+        "VK_FRAMEBUFFER",
+        "VK_RENDER_PASS",
     ],
     protos=[
-        Proto("XGL_RESULT", "CreateInstance",
-            [Param("const XGL_INSTANCE_CREATE_INFO*", "pCreateInfo"),
-             Param("XGL_INSTANCE*", "pInstance")]),
+        Proto("VK_RESULT", "CreateInstance",
+            [Param("const VK_INSTANCE_CREATE_INFO*", "pCreateInfo"),
+             Param("VK_INSTANCE*", "pInstance")]),
 
-        Proto("XGL_RESULT", "DestroyInstance",
-            [Param("XGL_INSTANCE", "instance")]),
+        Proto("VK_RESULT", "DestroyInstance",
+            [Param("VK_INSTANCE", "instance")]),
 
-        Proto("XGL_RESULT", "EnumerateGpus",
-            [Param("XGL_INSTANCE", "instance"),
+        Proto("VK_RESULT", "EnumerateGpus",
+            [Param("VK_INSTANCE", "instance"),
              Param("uint32_t", "maxGpus"),
              Param("uint32_t*", "pGpuCount"),
-             Param("XGL_PHYSICAL_GPU*", "pGpus")]),
+             Param("VK_PHYSICAL_GPU*", "pGpus")]),
 
-        Proto("XGL_RESULT", "GetGpuInfo",
-            [Param("XGL_PHYSICAL_GPU", "gpu"),
-             Param("XGL_PHYSICAL_GPU_INFO_TYPE", "infoType"),
+        Proto("VK_RESULT", "GetGpuInfo",
+            [Param("VK_PHYSICAL_GPU", "gpu"),
+             Param("VK_PHYSICAL_GPU_INFO_TYPE", "infoType"),
              Param("size_t*", "pDataSize"),
              Param("void*", "pData")]),
 
         Proto("void*", "GetProcAddr",
-            [Param("XGL_PHYSICAL_GPU", "gpu"),
+            [Param("VK_PHYSICAL_GPU", "gpu"),
              Param("const char*", "pName")]),
 
-        Proto("XGL_RESULT", "CreateDevice",
-            [Param("XGL_PHYSICAL_GPU", "gpu"),
-             Param("const XGL_DEVICE_CREATE_INFO*", "pCreateInfo"),
-             Param("XGL_DEVICE*", "pDevice")]),
+        Proto("VK_RESULT", "CreateDevice",
+            [Param("VK_PHYSICAL_GPU", "gpu"),
+             Param("const VK_DEVICE_CREATE_INFO*", "pCreateInfo"),
+             Param("VK_DEVICE*", "pDevice")]),
 
-        Proto("XGL_RESULT", "DestroyDevice",
-            [Param("XGL_DEVICE", "device")]),
+        Proto("VK_RESULT", "DestroyDevice",
+            [Param("VK_DEVICE", "device")]),
 
-        Proto("XGL_RESULT", "GetExtensionSupport",
-            [Param("XGL_PHYSICAL_GPU", "gpu"),
+        Proto("VK_RESULT", "GetExtensionSupport",
+            [Param("VK_PHYSICAL_GPU", "gpu"),
              Param("const char*", "pExtName")]),
 
-        Proto("XGL_RESULT", "EnumerateLayers",
-            [Param("XGL_PHYSICAL_GPU", "gpu"),
+        Proto("VK_RESULT", "EnumerateLayers",
+            [Param("VK_PHYSICAL_GPU", "gpu"),
              Param("size_t", "maxLayerCount"),
              Param("size_t", "maxStringSize"),
              Param("size_t*", "pOutLayerCount"),
              Param("char* const*", "pOutLayers"),
              Param("void*", "pReserved")]),
 
-        Proto("XGL_RESULT", "GetDeviceQueue",
-            [Param("XGL_DEVICE", "device"),
+        Proto("VK_RESULT", "GetDeviceQueue",
+            [Param("VK_DEVICE", "device"),
              Param("uint32_t", "queueNodeIndex"),
              Param("uint32_t", "queueIndex"),
-             Param("XGL_QUEUE*", "pQueue")]),
+             Param("VK_QUEUE*", "pQueue")]),
 
-        Proto("XGL_RESULT", "QueueSubmit",
-            [Param("XGL_QUEUE", "queue"),
+        Proto("VK_RESULT", "QueueSubmit",
+            [Param("VK_QUEUE", "queue"),
              Param("uint32_t", "cmdBufferCount"),
-             Param("const XGL_CMD_BUFFER*", "pCmdBuffers"),
-             Param("XGL_FENCE", "fence")]),
+             Param("const VK_CMD_BUFFER*", "pCmdBuffers"),
+             Param("VK_FENCE", "fence")]),
 
-        Proto("XGL_RESULT", "QueueAddMemReference",
-            [Param("XGL_QUEUE", "queue"),
-             Param("XGL_GPU_MEMORY", "mem")]),
+        Proto("VK_RESULT", "QueueAddMemReference",
+            [Param("VK_QUEUE", "queue"),
+             Param("VK_GPU_MEMORY", "mem")]),
 
-        Proto("XGL_RESULT", "QueueRemoveMemReference",
-            [Param("XGL_QUEUE", "queue"),
-             Param("XGL_GPU_MEMORY", "mem")]),
+        Proto("VK_RESULT", "QueueRemoveMemReference",
+            [Param("VK_QUEUE", "queue"),
+             Param("VK_GPU_MEMORY", "mem")]),
 
-        Proto("XGL_RESULT", "QueueWaitIdle",
-            [Param("XGL_QUEUE", "queue")]),
+        Proto("VK_RESULT", "QueueWaitIdle",
+            [Param("VK_QUEUE", "queue")]),
 
-        Proto("XGL_RESULT", "DeviceWaitIdle",
-            [Param("XGL_DEVICE", "device")]),
+        Proto("VK_RESULT", "DeviceWaitIdle",
+            [Param("VK_DEVICE", "device")]),
 
-        Proto("XGL_RESULT", "AllocMemory",
-            [Param("XGL_DEVICE", "device"),
-             Param("const XGL_MEMORY_ALLOC_INFO*", "pAllocInfo"),
-             Param("XGL_GPU_MEMORY*", "pMem")]),
+        Proto("VK_RESULT", "AllocMemory",
+            [Param("VK_DEVICE", "device"),
+             Param("const VK_MEMORY_ALLOC_INFO*", "pAllocInfo"),
+             Param("VK_GPU_MEMORY*", "pMem")]),
 
-        Proto("XGL_RESULT", "FreeMemory",
-            [Param("XGL_GPU_MEMORY", "mem")]),
+        Proto("VK_RESULT", "FreeMemory",
+            [Param("VK_GPU_MEMORY", "mem")]),
 
-        Proto("XGL_RESULT", "SetMemoryPriority",
-            [Param("XGL_GPU_MEMORY", "mem"),
-             Param("XGL_MEMORY_PRIORITY", "priority")]),
+        Proto("VK_RESULT", "SetMemoryPriority",
+            [Param("VK_GPU_MEMORY", "mem"),
+             Param("VK_MEMORY_PRIORITY", "priority")]),
 
-        Proto("XGL_RESULT", "MapMemory",
-            [Param("XGL_GPU_MEMORY", "mem"),
-             Param("XGL_FLAGS", "flags"),
+        Proto("VK_RESULT", "MapMemory",
+            [Param("VK_GPU_MEMORY", "mem"),
+             Param("VK_FLAGS", "flags"),
              Param("void**", "ppData")]),
 
-        Proto("XGL_RESULT", "UnmapMemory",
-            [Param("XGL_GPU_MEMORY", "mem")]),
+        Proto("VK_RESULT", "UnmapMemory",
+            [Param("VK_GPU_MEMORY", "mem")]),
 
-        Proto("XGL_RESULT", "PinSystemMemory",
-            [Param("XGL_DEVICE", "device"),
+        Proto("VK_RESULT", "PinSystemMemory",
+            [Param("VK_DEVICE", "device"),
              Param("const void*", "pSysMem"),
              Param("size_t", "memSize"),
-             Param("XGL_GPU_MEMORY*", "pMem")]),
+             Param("VK_GPU_MEMORY*", "pMem")]),
 
-        Proto("XGL_RESULT", "GetMultiGpuCompatibility",
-            [Param("XGL_PHYSICAL_GPU", "gpu0"),
-             Param("XGL_PHYSICAL_GPU", "gpu1"),
-             Param("XGL_GPU_COMPATIBILITY_INFO*", "pInfo")]),
+        Proto("VK_RESULT", "GetMultiGpuCompatibility",
+            [Param("VK_PHYSICAL_GPU", "gpu0"),
+             Param("VK_PHYSICAL_GPU", "gpu1"),
+             Param("VK_GPU_COMPATIBILITY_INFO*", "pInfo")]),
 
-        Proto("XGL_RESULT", "OpenSharedMemory",
-            [Param("XGL_DEVICE", "device"),
-             Param("const XGL_MEMORY_OPEN_INFO*", "pOpenInfo"),
-             Param("XGL_GPU_MEMORY*", "pMem")]),
+        Proto("VK_RESULT", "OpenSharedMemory",
+            [Param("VK_DEVICE", "device"),
+             Param("const VK_MEMORY_OPEN_INFO*", "pOpenInfo"),
+             Param("VK_GPU_MEMORY*", "pMem")]),
 
-        Proto("XGL_RESULT", "OpenSharedSemaphore",
-            [Param("XGL_DEVICE", "device"),
-             Param("const XGL_SEMAPHORE_OPEN_INFO*", "pOpenInfo"),
-             Param("XGL_SEMAPHORE*", "pSemaphore")]),
+        Proto("VK_RESULT", "OpenSharedSemaphore",
+            [Param("VK_DEVICE", "device"),
+             Param("const VK_SEMAPHORE_OPEN_INFO*", "pOpenInfo"),
+             Param("VK_SEMAPHORE*", "pSemaphore")]),
 
-        Proto("XGL_RESULT", "OpenPeerMemory",
-            [Param("XGL_DEVICE", "device"),
-             Param("const XGL_PEER_MEMORY_OPEN_INFO*", "pOpenInfo"),
-             Param("XGL_GPU_MEMORY*", "pMem")]),
+        Proto("VK_RESULT", "OpenPeerMemory",
+            [Param("VK_DEVICE", "device"),
+             Param("const VK_PEER_MEMORY_OPEN_INFO*", "pOpenInfo"),
+             Param("VK_GPU_MEMORY*", "pMem")]),
 
-        Proto("XGL_RESULT", "OpenPeerImage",
-            [Param("XGL_DEVICE", "device"),
-             Param("const XGL_PEER_IMAGE_OPEN_INFO*", "pOpenInfo"),
-             Param("XGL_IMAGE*", "pImage"),
-             Param("XGL_GPU_MEMORY*", "pMem")]),
+        Proto("VK_RESULT", "OpenPeerImage",
+            [Param("VK_DEVICE", "device"),
+             Param("const VK_PEER_IMAGE_OPEN_INFO*", "pOpenInfo"),
+             Param("VK_IMAGE*", "pImage"),
+             Param("VK_GPU_MEMORY*", "pMem")]),
 
-        Proto("XGL_RESULT", "DestroyObject",
-            [Param("XGL_OBJECT", "object")]),
+        Proto("VK_RESULT", "DestroyObject",
+            [Param("VK_OBJECT", "object")]),
 
-        Proto("XGL_RESULT", "GetObjectInfo",
-            [Param("XGL_BASE_OBJECT", "object"),
-             Param("XGL_OBJECT_INFO_TYPE", "infoType"),
+        Proto("VK_RESULT", "GetObjectInfo",
+            [Param("VK_BASE_OBJECT", "object"),
+             Param("VK_OBJECT_INFO_TYPE", "infoType"),
              Param("size_t*", "pDataSize"),
              Param("void*", "pData")]),
 
-        Proto("XGL_RESULT", "BindObjectMemory",
-            [Param("XGL_OBJECT", "object"),
+        Proto("VK_RESULT", "BindObjectMemory",
+            [Param("VK_OBJECT", "object"),
              Param("uint32_t", "allocationIdx"),
-             Param("XGL_GPU_MEMORY", "mem"),
-             Param("XGL_GPU_SIZE", "offset")]),
+             Param("VK_GPU_MEMORY", "mem"),
+             Param("VK_GPU_SIZE", "offset")]),
 
-        Proto("XGL_RESULT", "BindObjectMemoryRange",
-            [Param("XGL_OBJECT", "object"),
+        Proto("VK_RESULT", "BindObjectMemoryRange",
+            [Param("VK_OBJECT", "object"),
              Param("uint32_t", "allocationIdx"),
-             Param("XGL_GPU_SIZE", "rangeOffset"),
-             Param("XGL_GPU_SIZE", "rangeSize"),
-             Param("XGL_GPU_MEMORY", "mem"),
-             Param("XGL_GPU_SIZE", "memOffset")]),
+             Param("VK_GPU_SIZE", "rangeOffset"),
+             Param("VK_GPU_SIZE", "rangeSize"),
+             Param("VK_GPU_MEMORY", "mem"),
+             Param("VK_GPU_SIZE", "memOffset")]),
 
-        Proto("XGL_RESULT", "BindImageMemoryRange",
-            [Param("XGL_IMAGE", "image"),
+        Proto("VK_RESULT", "BindImageMemoryRange",
+            [Param("VK_IMAGE", "image"),
              Param("uint32_t", "allocationIdx"),
-             Param("const XGL_IMAGE_MEMORY_BIND_INFO*", "bindInfo"),
-             Param("XGL_GPU_MEMORY", "mem"),
-             Param("XGL_GPU_SIZE", "memOffset")]),
+             Param("const VK_IMAGE_MEMORY_BIND_INFO*", "bindInfo"),
+             Param("VK_GPU_MEMORY", "mem"),
+             Param("VK_GPU_SIZE", "memOffset")]),
 
-        Proto("XGL_RESULT", "CreateFence",
-            [Param("XGL_DEVICE", "device"),
-             Param("const XGL_FENCE_CREATE_INFO*", "pCreateInfo"),
-             Param("XGL_FENCE*", "pFence")]),
+        Proto("VK_RESULT", "CreateFence",
+            [Param("VK_DEVICE", "device"),
+             Param("const VK_FENCE_CREATE_INFO*", "pCreateInfo"),
+             Param("VK_FENCE*", "pFence")]),
 
-        Proto("XGL_RESULT", "ResetFences",
-            [Param("XGL_DEVICE", "device"),
+        Proto("VK_RESULT", "ResetFences",
+            [Param("VK_DEVICE", "device"),
              Param("uint32_t", "fenceCount"),
-             Param("XGL_FENCE*", "pFences")]),
+             Param("VK_FENCE*", "pFences")]),
 
-        Proto("XGL_RESULT", "GetFenceStatus",
-            [Param("XGL_FENCE", "fence")]),
+        Proto("VK_RESULT", "GetFenceStatus",
+            [Param("VK_FENCE", "fence")]),
 
-        Proto("XGL_RESULT", "WaitForFences",
-            [Param("XGL_DEVICE", "device"),
+        Proto("VK_RESULT", "WaitForFences",
+            [Param("VK_DEVICE", "device"),
              Param("uint32_t", "fenceCount"),
-             Param("const XGL_FENCE*", "pFences"),
+             Param("const VK_FENCE*", "pFences"),
              Param("bool32_t", "waitAll"),
              Param("uint64_t", "timeout")]),
 
-        Proto("XGL_RESULT", "CreateSemaphore",
-            [Param("XGL_DEVICE", "device"),
-             Param("const XGL_SEMAPHORE_CREATE_INFO*", "pCreateInfo"),
-             Param("XGL_SEMAPHORE*", "pSemaphore")]),
+        Proto("VK_RESULT", "CreateSemaphore",
+            [Param("VK_DEVICE", "device"),
+             Param("const VK_SEMAPHORE_CREATE_INFO*", "pCreateInfo"),
+             Param("VK_SEMAPHORE*", "pSemaphore")]),
 
-        Proto("XGL_RESULT", "QueueSignalSemaphore",
-            [Param("XGL_QUEUE", "queue"),
-             Param("XGL_SEMAPHORE", "semaphore")]),
+        Proto("VK_RESULT", "QueueSignalSemaphore",
+            [Param("VK_QUEUE", "queue"),
+             Param("VK_SEMAPHORE", "semaphore")]),
 
-        Proto("XGL_RESULT", "QueueWaitSemaphore",
-            [Param("XGL_QUEUE", "queue"),
-             Param("XGL_SEMAPHORE", "semaphore")]),
+        Proto("VK_RESULT", "QueueWaitSemaphore",
+            [Param("VK_QUEUE", "queue"),
+             Param("VK_SEMAPHORE", "semaphore")]),
 
-        Proto("XGL_RESULT", "CreateEvent",
-            [Param("XGL_DEVICE", "device"),
-             Param("const XGL_EVENT_CREATE_INFO*", "pCreateInfo"),
-             Param("XGL_EVENT*", "pEvent")]),
+        Proto("VK_RESULT", "CreateEvent",
+            [Param("VK_DEVICE", "device"),
+             Param("const VK_EVENT_CREATE_INFO*", "pCreateInfo"),
+             Param("VK_EVENT*", "pEvent")]),
 
-        Proto("XGL_RESULT", "GetEventStatus",
-            [Param("XGL_EVENT", "event")]),
+        Proto("VK_RESULT", "GetEventStatus",
+            [Param("VK_EVENT", "event")]),
 
-        Proto("XGL_RESULT", "SetEvent",
-            [Param("XGL_EVENT", "event")]),
+        Proto("VK_RESULT", "SetEvent",
+            [Param("VK_EVENT", "event")]),
 
-        Proto("XGL_RESULT", "ResetEvent",
-            [Param("XGL_EVENT", "event")]),
+        Proto("VK_RESULT", "ResetEvent",
+            [Param("VK_EVENT", "event")]),
 
-        Proto("XGL_RESULT", "CreateQueryPool",
-            [Param("XGL_DEVICE", "device"),
-             Param("const XGL_QUERY_POOL_CREATE_INFO*", "pCreateInfo"),
-             Param("XGL_QUERY_POOL*", "pQueryPool")]),
+        Proto("VK_RESULT", "CreateQueryPool",
+            [Param("VK_DEVICE", "device"),
+             Param("const VK_QUERY_POOL_CREATE_INFO*", "pCreateInfo"),
+             Param("VK_QUERY_POOL*", "pQueryPool")]),
 
-        Proto("XGL_RESULT", "GetQueryPoolResults",
-            [Param("XGL_QUERY_POOL", "queryPool"),
+        Proto("VK_RESULT", "GetQueryPoolResults",
+            [Param("VK_QUERY_POOL", "queryPool"),
              Param("uint32_t", "startQuery"),
              Param("uint32_t", "queryCount"),
              Param("size_t*", "pDataSize"),
              Param("void*", "pData")]),
 
-        Proto("XGL_RESULT", "GetFormatInfo",
-            [Param("XGL_DEVICE", "device"),
-             Param("XGL_FORMAT", "format"),
-             Param("XGL_FORMAT_INFO_TYPE", "infoType"),
+        Proto("VK_RESULT", "GetFormatInfo",
+            [Param("VK_DEVICE", "device"),
+             Param("VK_FORMAT", "format"),
+             Param("VK_FORMAT_INFO_TYPE", "infoType"),
              Param("size_t*", "pDataSize"),
              Param("void*", "pData")]),
 
-        Proto("XGL_RESULT", "CreateBuffer",
-            [Param("XGL_DEVICE", "device"),
-             Param("const XGL_BUFFER_CREATE_INFO*", "pCreateInfo"),
-             Param("XGL_BUFFER*", "pBuffer")]),
+        Proto("VK_RESULT", "CreateBuffer",
+            [Param("VK_DEVICE", "device"),
+             Param("const VK_BUFFER_CREATE_INFO*", "pCreateInfo"),
+             Param("VK_BUFFER*", "pBuffer")]),
 
-        Proto("XGL_RESULT", "CreateBufferView",
-            [Param("XGL_DEVICE", "device"),
-             Param("const XGL_BUFFER_VIEW_CREATE_INFO*", "pCreateInfo"),
-             Param("XGL_BUFFER_VIEW*", "pView")]),
+        Proto("VK_RESULT", "CreateBufferView",
+            [Param("VK_DEVICE", "device"),
+             Param("const VK_BUFFER_VIEW_CREATE_INFO*", "pCreateInfo"),
+             Param("VK_BUFFER_VIEW*", "pView")]),
 
-        Proto("XGL_RESULT", "CreateImage",
-            [Param("XGL_DEVICE", "device"),
-             Param("const XGL_IMAGE_CREATE_INFO*", "pCreateInfo"),
-             Param("XGL_IMAGE*", "pImage")]),
+        Proto("VK_RESULT", "CreateImage",
+            [Param("VK_DEVICE", "device"),
+             Param("const VK_IMAGE_CREATE_INFO*", "pCreateInfo"),
+             Param("VK_IMAGE*", "pImage")]),
 
-        Proto("XGL_RESULT", "GetImageSubresourceInfo",
-            [Param("XGL_IMAGE", "image"),
-             Param("const XGL_IMAGE_SUBRESOURCE*", "pSubresource"),
-             Param("XGL_SUBRESOURCE_INFO_TYPE", "infoType"),
+        Proto("VK_RESULT", "GetImageSubresourceInfo",
+            [Param("VK_IMAGE", "image"),
+             Param("const VK_IMAGE_SUBRESOURCE*", "pSubresource"),
+             Param("VK_SUBRESOURCE_INFO_TYPE", "infoType"),
              Param("size_t*", "pDataSize"),
              Param("void*", "pData")]),
 
-        Proto("XGL_RESULT", "CreateImageView",
-            [Param("XGL_DEVICE", "device"),
-             Param("const XGL_IMAGE_VIEW_CREATE_INFO*", "pCreateInfo"),
-             Param("XGL_IMAGE_VIEW*", "pView")]),
+        Proto("VK_RESULT", "CreateImageView",
+            [Param("VK_DEVICE", "device"),
+             Param("const VK_IMAGE_VIEW_CREATE_INFO*", "pCreateInfo"),
+             Param("VK_IMAGE_VIEW*", "pView")]),
 
-        Proto("XGL_RESULT", "CreateColorAttachmentView",
-            [Param("XGL_DEVICE", "device"),
-             Param("const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO*", "pCreateInfo"),
-             Param("XGL_COLOR_ATTACHMENT_VIEW*", "pView")]),
+        Proto("VK_RESULT", "CreateColorAttachmentView",
+            [Param("VK_DEVICE", "device"),
+             Param("const VK_COLOR_ATTACHMENT_VIEW_CREATE_INFO*", "pCreateInfo"),
+             Param("VK_COLOR_ATTACHMENT_VIEW*", "pView")]),
 
-        Proto("XGL_RESULT", "CreateDepthStencilView",
-            [Param("XGL_DEVICE", "device"),
-             Param("const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO*", "pCreateInfo"),
-             Param("XGL_DEPTH_STENCIL_VIEW*", "pView")]),
+        Proto("VK_RESULT", "CreateDepthStencilView",
+            [Param("VK_DEVICE", "device"),
+             Param("const VK_DEPTH_STENCIL_VIEW_CREATE_INFO*", "pCreateInfo"),
+             Param("VK_DEPTH_STENCIL_VIEW*", "pView")]),
 
-        Proto("XGL_RESULT", "CreateShader",
-            [Param("XGL_DEVICE", "device"),
-             Param("const XGL_SHADER_CREATE_INFO*", "pCreateInfo"),
-             Param("XGL_SHADER*", "pShader")]),
+        Proto("VK_RESULT", "CreateShader",
+            [Param("VK_DEVICE", "device"),
+             Param("const VK_SHADER_CREATE_INFO*", "pCreateInfo"),
+             Param("VK_SHADER*", "pShader")]),
 
-        Proto("XGL_RESULT", "CreateGraphicsPipeline",
-            [Param("XGL_DEVICE", "device"),
-             Param("const XGL_GRAPHICS_PIPELINE_CREATE_INFO*", "pCreateInfo"),
-             Param("XGL_PIPELINE*", "pPipeline")]),
+        Proto("VK_RESULT", "CreateGraphicsPipeline",
+            [Param("VK_DEVICE", "device"),
+             Param("const VK_GRAPHICS_PIPELINE_CREATE_INFO*", "pCreateInfo"),
+             Param("VK_PIPELINE*", "pPipeline")]),
 
-        Proto("XGL_RESULT", "CreateGraphicsPipelineDerivative",
-            [Param("XGL_DEVICE", "device"),
-             Param("const XGL_GRAPHICS_PIPELINE_CREATE_INFO*", "pCreateInfo"),
-             Param("XGL_PIPELINE", "basePipeline"),
-             Param("XGL_PIPELINE*", "pPipeline")]),
+        Proto("VK_RESULT", "CreateGraphicsPipelineDerivative",
+            [Param("VK_DEVICE", "device"),
+             Param("const VK_GRAPHICS_PIPELINE_CREATE_INFO*", "pCreateInfo"),
+             Param("VK_PIPELINE", "basePipeline"),
+             Param("VK_PIPELINE*", "pPipeline")]),
 
-        Proto("XGL_RESULT", "CreateComputePipeline",
-            [Param("XGL_DEVICE", "device"),
-             Param("const XGL_COMPUTE_PIPELINE_CREATE_INFO*", "pCreateInfo"),
-             Param("XGL_PIPELINE*", "pPipeline")]),
+        Proto("VK_RESULT", "CreateComputePipeline",
+            [Param("VK_DEVICE", "device"),
+             Param("const VK_COMPUTE_PIPELINE_CREATE_INFO*", "pCreateInfo"),
+             Param("VK_PIPELINE*", "pPipeline")]),
 
-        Proto("XGL_RESULT", "StorePipeline",
-            [Param("XGL_PIPELINE", "pipeline"),
+        Proto("VK_RESULT", "StorePipeline",
+            [Param("VK_PIPELINE", "pipeline"),
              Param("size_t*", "pDataSize"),
              Param("void*", "pData")]),
 
-        Proto("XGL_RESULT", "LoadPipeline",
-            [Param("XGL_DEVICE", "device"),
+        Proto("VK_RESULT", "LoadPipeline",
+            [Param("VK_DEVICE", "device"),
              Param("size_t", "dataSize"),
              Param("const void*", "pData"),
-             Param("XGL_PIPELINE*", "pPipeline")]),
+             Param("VK_PIPELINE*", "pPipeline")]),
 
-        Proto("XGL_RESULT", "LoadPipelineDerivative",
-            [Param("XGL_DEVICE", "device"),
+        Proto("VK_RESULT", "LoadPipelineDerivative",
+            [Param("VK_DEVICE", "device"),
              Param("size_t", "dataSize"),
              Param("const void*", "pData"),
-             Param("XGL_PIPELINE", "basePipeline"),
-             Param("XGL_PIPELINE*", "pPipeline")]),
+             Param("VK_PIPELINE", "basePipeline"),
+             Param("VK_PIPELINE*", "pPipeline")]),
 
-        Proto("XGL_RESULT", "CreateSampler",
-            [Param("XGL_DEVICE", "device"),
-             Param("const XGL_SAMPLER_CREATE_INFO*", "pCreateInfo"),
-             Param("XGL_SAMPLER*", "pSampler")]),
+        Proto("VK_RESULT", "CreateSampler",
+            [Param("VK_DEVICE", "device"),
+             Param("const VK_SAMPLER_CREATE_INFO*", "pCreateInfo"),
+             Param("VK_SAMPLER*", "pSampler")]),
 
-        Proto("XGL_RESULT", "CreateDescriptorSetLayout",
-            [Param("XGL_DEVICE", "device"),
-             Param("const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO*", "pCreateInfo"),
-             Param("XGL_DESCRIPTOR_SET_LAYOUT*", "pSetLayout")]),
+        Proto("VK_RESULT", "CreateDescriptorSetLayout",
+            [Param("VK_DEVICE", "device"),
+             Param("const VK_DESCRIPTOR_SET_LAYOUT_CREATE_INFO*", "pCreateInfo"),
+             Param("VK_DESCRIPTOR_SET_LAYOUT*", "pSetLayout")]),
 
-        Proto("XGL_RESULT", "CreateDescriptorSetLayoutChain",
-            [Param("XGL_DEVICE", "device"),
+        Proto("VK_RESULT", "CreateDescriptorSetLayoutChain",
+            [Param("VK_DEVICE", "device"),
              Param("uint32_t", "setLayoutArrayCount"),
-             Param("const XGL_DESCRIPTOR_SET_LAYOUT*", "pSetLayoutArray"),
-             Param("XGL_DESCRIPTOR_SET_LAYOUT_CHAIN*", "pLayoutChain")]),
+             Param("const VK_DESCRIPTOR_SET_LAYOUT*", "pSetLayoutArray"),
+             Param("VK_DESCRIPTOR_SET_LAYOUT_CHAIN*", "pLayoutChain")]),
 
-        Proto("XGL_RESULT", "BeginDescriptorPoolUpdate",
-            [Param("XGL_DEVICE", "device"),
-             Param("XGL_DESCRIPTOR_UPDATE_MODE", "updateMode")]),
+        Proto("VK_RESULT", "BeginDescriptorPoolUpdate",
+            [Param("VK_DEVICE", "device"),
+             Param("VK_DESCRIPTOR_UPDATE_MODE", "updateMode")]),
 
-        Proto("XGL_RESULT", "EndDescriptorPoolUpdate",
-            [Param("XGL_DEVICE", "device"),
-             Param("XGL_CMD_BUFFER", "cmd")]),
+        Proto("VK_RESULT", "EndDescriptorPoolUpdate",
+            [Param("VK_DEVICE", "device"),
+             Param("VK_CMD_BUFFER", "cmd")]),
 
-        Proto("XGL_RESULT", "CreateDescriptorPool",
-            [Param("XGL_DEVICE", "device"),
-             Param("XGL_DESCRIPTOR_POOL_USAGE", "poolUsage"),
+        Proto("VK_RESULT", "CreateDescriptorPool",
+            [Param("VK_DEVICE", "device"),
+             Param("VK_DESCRIPTOR_POOL_USAGE", "poolUsage"),
              Param("uint32_t", "maxSets"),
-             Param("const XGL_DESCRIPTOR_POOL_CREATE_INFO*", "pCreateInfo"),
-             Param("XGL_DESCRIPTOR_POOL*", "pDescriptorPool")]),
+             Param("const VK_DESCRIPTOR_POOL_CREATE_INFO*", "pCreateInfo"),
+             Param("VK_DESCRIPTOR_POOL*", "pDescriptorPool")]),
 
-        Proto("XGL_RESULT", "ResetDescriptorPool",
-            [Param("XGL_DESCRIPTOR_POOL", "descriptorPool")]),
+        Proto("VK_RESULT", "ResetDescriptorPool",
+            [Param("VK_DESCRIPTOR_POOL", "descriptorPool")]),
 
-        Proto("XGL_RESULT", "AllocDescriptorSets",
-            [Param("XGL_DESCRIPTOR_POOL", "descriptorPool"),
-             Param("XGL_DESCRIPTOR_SET_USAGE", "setUsage"),
+        Proto("VK_RESULT", "AllocDescriptorSets",
+            [Param("VK_DESCRIPTOR_POOL", "descriptorPool"),
+             Param("VK_DESCRIPTOR_SET_USAGE", "setUsage"),
              Param("uint32_t", "count"),
-             Param("const XGL_DESCRIPTOR_SET_LAYOUT*", "pSetLayouts"),
-             Param("XGL_DESCRIPTOR_SET*", "pDescriptorSets"),
+             Param("const VK_DESCRIPTOR_SET_LAYOUT*", "pSetLayouts"),
+             Param("VK_DESCRIPTOR_SET*", "pDescriptorSets"),
              Param("uint32_t*", "pCount")]),
 
         Proto("void", "ClearDescriptorSets",
-            [Param("XGL_DESCRIPTOR_POOL", "descriptorPool"),
+            [Param("VK_DESCRIPTOR_POOL", "descriptorPool"),
              Param("uint32_t", "count"),
-             Param("const XGL_DESCRIPTOR_SET*", "pDescriptorSets")]),
+             Param("const VK_DESCRIPTOR_SET*", "pDescriptorSets")]),
 
         Proto("void", "UpdateDescriptors",
-            [Param("XGL_DESCRIPTOR_SET", "descriptorSet"),
+            [Param("VK_DESCRIPTOR_SET", "descriptorSet"),
              Param("uint32_t", "updateCount"),
              Param("const void**", "ppUpdateArray")]),
 
-        Proto("XGL_RESULT", "CreateDynamicViewportState",
-            [Param("XGL_DEVICE", "device"),
-             Param("const XGL_DYNAMIC_VP_STATE_CREATE_INFO*", "pCreateInfo"),
-             Param("XGL_DYNAMIC_VP_STATE_OBJECT*", "pState")]),
+        Proto("VK_RESULT", "CreateDynamicViewportState",
+            [Param("VK_DEVICE", "device"),
+             Param("const VK_DYNAMIC_VP_STATE_CREATE_INFO*", "pCreateInfo"),
+             Param("VK_DYNAMIC_VP_STATE_OBJECT*", "pState")]),
 
-        Proto("XGL_RESULT", "CreateDynamicRasterState",
-            [Param("XGL_DEVICE", "device"),
-             Param("const XGL_DYNAMIC_RS_STATE_CREATE_INFO*", "pCreateInfo"),
-             Param("XGL_DYNAMIC_RS_STATE_OBJECT*", "pState")]),
+        Proto("VK_RESULT", "CreateDynamicRasterState",
+            [Param("VK_DEVICE", "device"),
+             Param("const VK_DYNAMIC_RS_STATE_CREATE_INFO*", "pCreateInfo"),
+             Param("VK_DYNAMIC_RS_STATE_OBJECT*", "pState")]),
 
-        Proto("XGL_RESULT", "CreateDynamicColorBlendState",
-            [Param("XGL_DEVICE", "device"),
-             Param("const XGL_DYNAMIC_CB_STATE_CREATE_INFO*", "pCreateInfo"),
-             Param("XGL_DYNAMIC_CB_STATE_OBJECT*", "pState")]),
+        Proto("VK_RESULT", "CreateDynamicColorBlendState",
+            [Param("VK_DEVICE", "device"),
+             Param("const VK_DYNAMIC_CB_STATE_CREATE_INFO*", "pCreateInfo"),
+             Param("VK_DYNAMIC_CB_STATE_OBJECT*", "pState")]),
 
-        Proto("XGL_RESULT", "CreateDynamicDepthStencilState",
-            [Param("XGL_DEVICE", "device"),
-             Param("const XGL_DYNAMIC_DS_STATE_CREATE_INFO*", "pCreateInfo"),
-             Param("XGL_DYNAMIC_DS_STATE_OBJECT*", "pState")]),
+        Proto("VK_RESULT", "CreateDynamicDepthStencilState",
+            [Param("VK_DEVICE", "device"),
+             Param("const VK_DYNAMIC_DS_STATE_CREATE_INFO*", "pCreateInfo"),
+             Param("VK_DYNAMIC_DS_STATE_OBJECT*", "pState")]),
 
-        Proto("XGL_RESULT", "CreateCommandBuffer",
-            [Param("XGL_DEVICE", "device"),
-             Param("const XGL_CMD_BUFFER_CREATE_INFO*", "pCreateInfo"),
-             Param("XGL_CMD_BUFFER*", "pCmdBuffer")]),
+        Proto("VK_RESULT", "CreateCommandBuffer",
+            [Param("VK_DEVICE", "device"),
+             Param("const VK_CMD_BUFFER_CREATE_INFO*", "pCreateInfo"),
+             Param("VK_CMD_BUFFER*", "pCmdBuffer")]),
 
-        Proto("XGL_RESULT", "BeginCommandBuffer",
-            [Param("XGL_CMD_BUFFER", "cmdBuffer"),
-             Param("const XGL_CMD_BUFFER_BEGIN_INFO*", "pBeginInfo")]),
+        Proto("VK_RESULT", "BeginCommandBuffer",
+            [Param("VK_CMD_BUFFER", "cmdBuffer"),
+             Param("const VK_CMD_BUFFER_BEGIN_INFO*", "pBeginInfo")]),
 
-        Proto("XGL_RESULT", "EndCommandBuffer",
-            [Param("XGL_CMD_BUFFER", "cmdBuffer")]),
+        Proto("VK_RESULT", "EndCommandBuffer",
+            [Param("VK_CMD_BUFFER", "cmdBuffer")]),
 
-        Proto("XGL_RESULT", "ResetCommandBuffer",
-            [Param("XGL_CMD_BUFFER", "cmdBuffer")]),
+        Proto("VK_RESULT", "ResetCommandBuffer",
+            [Param("VK_CMD_BUFFER", "cmdBuffer")]),
 
         Proto("void", "CmdBindPipeline",
-            [Param("XGL_CMD_BUFFER", "cmdBuffer"),
-             Param("XGL_PIPELINE_BIND_POINT", "pipelineBindPoint"),
-             Param("XGL_PIPELINE", "pipeline")]),
+            [Param("VK_CMD_BUFFER", "cmdBuffer"),
+             Param("VK_PIPELINE_BIND_POINT", "pipelineBindPoint"),
+             Param("VK_PIPELINE", "pipeline")]),
 
         Proto("void", "CmdBindDynamicStateObject",
-            [Param("XGL_CMD_BUFFER", "cmdBuffer"),
-             Param("XGL_STATE_BIND_POINT", "stateBindPoint"),
-             Param("XGL_DYNAMIC_STATE_OBJECT", "state")]),
+            [Param("VK_CMD_BUFFER", "cmdBuffer"),
+             Param("VK_STATE_BIND_POINT", "stateBindPoint"),
+             Param("VK_DYNAMIC_STATE_OBJECT", "state")]),
 
         Proto("void", "CmdBindDescriptorSets",
-            [Param("XGL_CMD_BUFFER", "cmdBuffer"),
-             Param("XGL_PIPELINE_BIND_POINT", "pipelineBindPoint"),
-             Param("XGL_DESCRIPTOR_SET_LAYOUT_CHAIN", "layoutChain"),
+            [Param("VK_CMD_BUFFER", "cmdBuffer"),
+             Param("VK_PIPELINE_BIND_POINT", "pipelineBindPoint"),
+             Param("VK_DESCRIPTOR_SET_LAYOUT_CHAIN", "layoutChain"),
              Param("uint32_t", "layoutChainSlot"),
              Param("uint32_t", "count"),
-             Param("const XGL_DESCRIPTOR_SET*", "pDescriptorSets"),
+             Param("const VK_DESCRIPTOR_SET*", "pDescriptorSets"),
              Param("const uint32_t*", "pUserData")]),
 
         Proto("void", "CmdBindVertexBuffer",
-            [Param("XGL_CMD_BUFFER", "cmdBuffer"),
-             Param("XGL_BUFFER", "buffer"),
-             Param("XGL_GPU_SIZE", "offset"),
+            [Param("VK_CMD_BUFFER", "cmdBuffer"),
+             Param("VK_BUFFER", "buffer"),
+             Param("VK_GPU_SIZE", "offset"),
              Param("uint32_t", "binding")]),
 
         Proto("void", "CmdBindIndexBuffer",
-            [Param("XGL_CMD_BUFFER", "cmdBuffer"),
-             Param("XGL_BUFFER", "buffer"),
-             Param("XGL_GPU_SIZE", "offset"),
-             Param("XGL_INDEX_TYPE", "indexType")]),
+            [Param("VK_CMD_BUFFER", "cmdBuffer"),
+             Param("VK_BUFFER", "buffer"),
+             Param("VK_GPU_SIZE", "offset"),
+             Param("VK_INDEX_TYPE", "indexType")]),
 
         Proto("void", "CmdDraw",
-            [Param("XGL_CMD_BUFFER", "cmdBuffer"),
+            [Param("VK_CMD_BUFFER", "cmdBuffer"),
              Param("uint32_t", "firstVertex"),
              Param("uint32_t", "vertexCount"),
              Param("uint32_t", "firstInstance"),
              Param("uint32_t", "instanceCount")]),
 
         Proto("void", "CmdDrawIndexed",
-            [Param("XGL_CMD_BUFFER", "cmdBuffer"),
+            [Param("VK_CMD_BUFFER", "cmdBuffer"),
              Param("uint32_t", "firstIndex"),
              Param("uint32_t", "indexCount"),
              Param("int32_t", "vertexOffset"),
@@ -644,321 +644,321 @@
              Param("uint32_t", "instanceCount")]),
 
         Proto("void", "CmdDrawIndirect",
-            [Param("XGL_CMD_BUFFER", "cmdBuffer"),
-             Param("XGL_BUFFER", "buffer"),
-             Param("XGL_GPU_SIZE", "offset"),
+            [Param("VK_CMD_BUFFER", "cmdBuffer"),
+             Param("VK_BUFFER", "buffer"),
+             Param("VK_GPU_SIZE", "offset"),
              Param("uint32_t", "count"),
              Param("uint32_t", "stride")]),
 
         Proto("void", "CmdDrawIndexedIndirect",
-            [Param("XGL_CMD_BUFFER", "cmdBuffer"),
-             Param("XGL_BUFFER", "buffer"),
-             Param("XGL_GPU_SIZE", "offset"),
+            [Param("VK_CMD_BUFFER", "cmdBuffer"),
+             Param("VK_BUFFER", "buffer"),
+             Param("VK_GPU_SIZE", "offset"),
              Param("uint32_t", "count"),
              Param("uint32_t", "stride")]),
 
         Proto("void", "CmdDispatch",
-            [Param("XGL_CMD_BUFFER", "cmdBuffer"),
+            [Param("VK_CMD_BUFFER", "cmdBuffer"),
              Param("uint32_t", "x"),
              Param("uint32_t", "y"),
              Param("uint32_t", "z")]),
 
         Proto("void", "CmdDispatchIndirect",
-            [Param("XGL_CMD_BUFFER", "cmdBuffer"),
-             Param("XGL_BUFFER", "buffer"),
-             Param("XGL_GPU_SIZE", "offset")]),
+            [Param("VK_CMD_BUFFER", "cmdBuffer"),
+             Param("VK_BUFFER", "buffer"),
+             Param("VK_GPU_SIZE", "offset")]),
 
         Proto("void", "CmdCopyBuffer",
-            [Param("XGL_CMD_BUFFER", "cmdBuffer"),
-             Param("XGL_BUFFER", "srcBuffer"),
-             Param("XGL_BUFFER", "destBuffer"),
+            [Param("VK_CMD_BUFFER", "cmdBuffer"),
+             Param("VK_BUFFER", "srcBuffer"),
+             Param("VK_BUFFER", "destBuffer"),
              Param("uint32_t", "regionCount"),
-             Param("const XGL_BUFFER_COPY*", "pRegions")]),
+             Param("const VK_BUFFER_COPY*", "pRegions")]),
 
         Proto("void", "CmdCopyImage",
-            [Param("XGL_CMD_BUFFER", "cmdBuffer"),
-             Param("XGL_IMAGE", "srcImage"),
-             Param("XGL_IMAGE_LAYOUT", "srcImageLayout"),
-             Param("XGL_IMAGE", "destImage"),
-             Param("XGL_IMAGE_LAYOUT", "destImageLayout"),
+            [Param("VK_CMD_BUFFER", "cmdBuffer"),
+             Param("VK_IMAGE", "srcImage"),
+             Param("VK_IMAGE_LAYOUT", "srcImageLayout"),
+             Param("VK_IMAGE", "destImage"),
+             Param("VK_IMAGE_LAYOUT", "destImageLayout"),
              Param("uint32_t", "regionCount"),
-             Param("const XGL_IMAGE_COPY*", "pRegions")]),
+             Param("const VK_IMAGE_COPY*", "pRegions")]),
 
         Proto("void", "CmdBlitImage",
-            [Param("XGL_CMD_BUFFER", "cmdBuffer"),
-             Param("XGL_IMAGE", "srcImage"),
-             Param("XGL_IMAGE_LAYOUT", "srcImageLayout"),
-             Param("XGL_IMAGE", "destImage"),
-             Param("XGL_IMAGE_LAYOUT", "destImageLayout"),
+            [Param("VK_CMD_BUFFER", "cmdBuffer"),
+             Param("VK_IMAGE", "srcImage"),
+             Param("VK_IMAGE_LAYOUT", "srcImageLayout"),
+             Param("VK_IMAGE", "destImage"),
+             Param("VK_IMAGE_LAYOUT", "destImageLayout"),
              Param("uint32_t", "regionCount"),
-             Param("const XGL_IMAGE_BLIT*", "pRegions")]),
+             Param("const VK_IMAGE_BLIT*", "pRegions")]),
 
         Proto("void", "CmdCopyBufferToImage",
-            [Param("XGL_CMD_BUFFER", "cmdBuffer"),
-             Param("XGL_BUFFER", "srcBuffer"),
-             Param("XGL_IMAGE", "destImage"),
-             Param("XGL_IMAGE_LAYOUT", "destImageLayout"),
+            [Param("VK_CMD_BUFFER", "cmdBuffer"),
+             Param("VK_BUFFER", "srcBuffer"),
+             Param("VK_IMAGE", "destImage"),
+             Param("VK_IMAGE_LAYOUT", "destImageLayout"),
              Param("uint32_t", "regionCount"),
-             Param("const XGL_BUFFER_IMAGE_COPY*", "pRegions")]),
+             Param("const VK_BUFFER_IMAGE_COPY*", "pRegions")]),
 
         Proto("void", "CmdCopyImageToBuffer",
-            [Param("XGL_CMD_BUFFER", "cmdBuffer"),
-             Param("XGL_IMAGE", "srcImage"),
-             Param("XGL_IMAGE_LAYOUT", "srcImageLayout"),
-             Param("XGL_BUFFER", "destBuffer"),
+            [Param("VK_CMD_BUFFER", "cmdBuffer"),
+             Param("VK_IMAGE", "srcImage"),
+             Param("VK_IMAGE_LAYOUT", "srcImageLayout"),
+             Param("VK_BUFFER", "destBuffer"),
              Param("uint32_t", "regionCount"),
-             Param("const XGL_BUFFER_IMAGE_COPY*", "pRegions")]),
+             Param("const VK_BUFFER_IMAGE_COPY*", "pRegions")]),
 
         Proto("void", "CmdCloneImageData",
-            [Param("XGL_CMD_BUFFER", "cmdBuffer"),
-             Param("XGL_IMAGE", "srcImage"),
-             Param("XGL_IMAGE_LAYOUT", "srcImageLayout"),
-             Param("XGL_IMAGE", "destImage"),
-             Param("XGL_IMAGE_LAYOUT", "destImageLayout")]),
+            [Param("VK_CMD_BUFFER", "cmdBuffer"),
+             Param("VK_IMAGE", "srcImage"),
+             Param("VK_IMAGE_LAYOUT", "srcImageLayout"),
+             Param("VK_IMAGE", "destImage"),
+             Param("VK_IMAGE_LAYOUT", "destImageLayout")]),
 
         Proto("void", "CmdUpdateBuffer",
-            [Param("XGL_CMD_BUFFER", "cmdBuffer"),
-             Param("XGL_BUFFER", "destBuffer"),
-             Param("XGL_GPU_SIZE", "destOffset"),
-             Param("XGL_GPU_SIZE", "dataSize"),
+            [Param("VK_CMD_BUFFER", "cmdBuffer"),
+             Param("VK_BUFFER", "destBuffer"),
+             Param("VK_GPU_SIZE", "destOffset"),
+             Param("VK_GPU_SIZE", "dataSize"),
              Param("const uint32_t*", "pData")]),
 
         Proto("void", "CmdFillBuffer",
-            [Param("XGL_CMD_BUFFER", "cmdBuffer"),
-             Param("XGL_BUFFER", "destBuffer"),
-             Param("XGL_GPU_SIZE", "destOffset"),
-             Param("XGL_GPU_SIZE", "fillSize"),
+            [Param("VK_CMD_BUFFER", "cmdBuffer"),
+             Param("VK_BUFFER", "destBuffer"),
+             Param("VK_GPU_SIZE", "destOffset"),
+             Param("VK_GPU_SIZE", "fillSize"),
              Param("uint32_t", "data")]),
 
         Proto("void", "CmdClearColorImage",
-            [Param("XGL_CMD_BUFFER", "cmdBuffer"),
-             Param("XGL_IMAGE", "image"),
-             Param("XGL_IMAGE_LAYOUT", "imageLayout"),
-	     Param("XGL_CLEAR_COLOR", "color"),
+            [Param("VK_CMD_BUFFER", "cmdBuffer"),
+             Param("VK_IMAGE", "image"),
+             Param("VK_IMAGE_LAYOUT", "imageLayout"),
+	     Param("VK_CLEAR_COLOR", "color"),
              Param("uint32_t", "rangeCount"),
-             Param("const XGL_IMAGE_SUBRESOURCE_RANGE*", "pRanges")]),
+             Param("const VK_IMAGE_SUBRESOURCE_RANGE*", "pRanges")]),
 
         Proto("void", "CmdClearDepthStencil",
-            [Param("XGL_CMD_BUFFER", "cmdBuffer"),
-             Param("XGL_IMAGE", "image"),
-             Param("XGL_IMAGE_LAYOUT", "imageLayout"),
+            [Param("VK_CMD_BUFFER", "cmdBuffer"),
+             Param("VK_IMAGE", "image"),
+             Param("VK_IMAGE_LAYOUT", "imageLayout"),
              Param("float", "depth"),
              Param("uint32_t", "stencil"),
              Param("uint32_t", "rangeCount"),
-             Param("const XGL_IMAGE_SUBRESOURCE_RANGE*", "pRanges")]),
+             Param("const VK_IMAGE_SUBRESOURCE_RANGE*", "pRanges")]),
 
         Proto("void", "CmdResolveImage",
-            [Param("XGL_CMD_BUFFER", "cmdBuffer"),
-             Param("XGL_IMAGE", "srcImage"),
-             Param("XGL_IMAGE_LAYOUT", "srcImageLayout"),
-             Param("XGL_IMAGE", "destImage"),
-             Param("XGL_IMAGE_LAYOUT", "destImageLayout"),
+            [Param("VK_CMD_BUFFER", "cmdBuffer"),
+             Param("VK_IMAGE", "srcImage"),
+             Param("VK_IMAGE_LAYOUT", "srcImageLayout"),
+             Param("VK_IMAGE", "destImage"),
+             Param("VK_IMAGE_LAYOUT", "destImageLayout"),
              Param("uint32_t", "rectCount"),
-             Param("const XGL_IMAGE_RESOLVE*", "pRects")]),
+             Param("const VK_IMAGE_RESOLVE*", "pRects")]),
 
         Proto("void", "CmdSetEvent",
-            [Param("XGL_CMD_BUFFER", "cmdBuffer"),
-             Param("XGL_EVENT", "event"),
-             Param("XGL_PIPE_EVENT", "pipeEvent")]),
+            [Param("VK_CMD_BUFFER", "cmdBuffer"),
+             Param("VK_EVENT", "event"),
+             Param("VK_PIPE_EVENT", "pipeEvent")]),
 
         Proto("void", "CmdResetEvent",
-            [Param("XGL_CMD_BUFFER", "cmdBuffer"),
-             Param("XGL_EVENT", "event"),
-             Param("XGL_PIPE_EVENT", "pipeEvent")]),
+            [Param("VK_CMD_BUFFER", "cmdBuffer"),
+             Param("VK_EVENT", "event"),
+             Param("VK_PIPE_EVENT", "pipeEvent")]),
 
         Proto("void", "CmdWaitEvents",
-            [Param("XGL_CMD_BUFFER", "cmdBuffer"),
-             Param("const XGL_EVENT_WAIT_INFO*", "pWaitInfo")]),
+            [Param("VK_CMD_BUFFER", "cmdBuffer"),
+             Param("const VK_EVENT_WAIT_INFO*", "pWaitInfo")]),
 
         Proto("void", "CmdPipelineBarrier",
-            [Param("XGL_CMD_BUFFER", "cmdBuffer"),
-             Param("const XGL_PIPELINE_BARRIER*", "pBarrier")]),
+            [Param("VK_CMD_BUFFER", "cmdBuffer"),
+             Param("const VK_PIPELINE_BARRIER*", "pBarrier")]),
 
         Proto("void", "CmdBeginQuery",
-            [Param("XGL_CMD_BUFFER", "cmdBuffer"),
-             Param("XGL_QUERY_POOL", "queryPool"),
+            [Param("VK_CMD_BUFFER", "cmdBuffer"),
+             Param("VK_QUERY_POOL", "queryPool"),
              Param("uint32_t", "slot"),
-             Param("XGL_FLAGS", "flags")]),
+             Param("VK_FLAGS", "flags")]),
 
         Proto("void", "CmdEndQuery",
-            [Param("XGL_CMD_BUFFER", "cmdBuffer"),
-             Param("XGL_QUERY_POOL", "queryPool"),
+            [Param("VK_CMD_BUFFER", "cmdBuffer"),
+             Param("VK_QUERY_POOL", "queryPool"),
              Param("uint32_t", "slot")]),
 
         Proto("void", "CmdResetQueryPool",
-            [Param("XGL_CMD_BUFFER", "cmdBuffer"),
-             Param("XGL_QUERY_POOL", "queryPool"),
+            [Param("VK_CMD_BUFFER", "cmdBuffer"),
+             Param("VK_QUERY_POOL", "queryPool"),
              Param("uint32_t", "startQuery"),
              Param("uint32_t", "queryCount")]),
 
         Proto("void", "CmdWriteTimestamp",
-            [Param("XGL_CMD_BUFFER", "cmdBuffer"),
-             Param("XGL_TIMESTAMP_TYPE", "timestampType"),
-             Param("XGL_BUFFER", "destBuffer"),
-             Param("XGL_GPU_SIZE", "destOffset")]),
+            [Param("VK_CMD_BUFFER", "cmdBuffer"),
+             Param("VK_TIMESTAMP_TYPE", "timestampType"),
+             Param("VK_BUFFER", "destBuffer"),
+             Param("VK_GPU_SIZE", "destOffset")]),
 
         Proto("void", "CmdInitAtomicCounters",
-            [Param("XGL_CMD_BUFFER", "cmdBuffer"),
-             Param("XGL_PIPELINE_BIND_POINT", "pipelineBindPoint"),
+            [Param("VK_CMD_BUFFER", "cmdBuffer"),
+             Param("VK_PIPELINE_BIND_POINT", "pipelineBindPoint"),
              Param("uint32_t", "startCounter"),
              Param("uint32_t", "counterCount"),
              Param("const uint32_t*", "pData")]),
 
         Proto("void", "CmdLoadAtomicCounters",
-            [Param("XGL_CMD_BUFFER", "cmdBuffer"),
-             Param("XGL_PIPELINE_BIND_POINT", "pipelineBindPoint"),
+            [Param("VK_CMD_BUFFER", "cmdBuffer"),
+             Param("VK_PIPELINE_BIND_POINT", "pipelineBindPoint"),
              Param("uint32_t", "startCounter"),
              Param("uint32_t", "counterCount"),
-             Param("XGL_BUFFER", "srcBuffer"),
-             Param("XGL_GPU_SIZE", "srcOffset")]),
+             Param("VK_BUFFER", "srcBuffer"),
+             Param("VK_GPU_SIZE", "srcOffset")]),
 
         Proto("void", "CmdSaveAtomicCounters",
-            [Param("XGL_CMD_BUFFER", "cmdBuffer"),
-             Param("XGL_PIPELINE_BIND_POINT", "pipelineBindPoint"),
+            [Param("VK_CMD_BUFFER", "cmdBuffer"),
+             Param("VK_PIPELINE_BIND_POINT", "pipelineBindPoint"),
              Param("uint32_t", "startCounter"),
              Param("uint32_t", "counterCount"),
-             Param("XGL_BUFFER", "destBuffer"),
-             Param("XGL_GPU_SIZE", "destOffset")]),
+             Param("VK_BUFFER", "destBuffer"),
+             Param("VK_GPU_SIZE", "destOffset")]),
 
-        Proto("XGL_RESULT", "CreateFramebuffer",
-            [Param("XGL_DEVICE", "device"),
-             Param("const XGL_FRAMEBUFFER_CREATE_INFO*", "pCreateInfo"),
-             Param("XGL_FRAMEBUFFER*", "pFramebuffer")]),
+        Proto("VK_RESULT", "CreateFramebuffer",
+            [Param("VK_DEVICE", "device"),
+             Param("const VK_FRAMEBUFFER_CREATE_INFO*", "pCreateInfo"),
+             Param("VK_FRAMEBUFFER*", "pFramebuffer")]),
 
-        Proto("XGL_RESULT", "CreateRenderPass",
-            [Param("XGL_DEVICE", "device"),
-             Param("const XGL_RENDER_PASS_CREATE_INFO*", "pCreateInfo"),
-             Param("XGL_RENDER_PASS*", "pRenderPass")]),
+        Proto("VK_RESULT", "CreateRenderPass",
+            [Param("VK_DEVICE", "device"),
+             Param("const VK_RENDER_PASS_CREATE_INFO*", "pCreateInfo"),
+             Param("VK_RENDER_PASS*", "pRenderPass")]),
 
         Proto("void", "CmdBeginRenderPass",
-            [Param("XGL_CMD_BUFFER", "cmdBuffer"),
-             Param("const XGL_RENDER_PASS_BEGIN*", "pRenderPassBegin")]),
+            [Param("VK_CMD_BUFFER", "cmdBuffer"),
+             Param("const VK_RENDER_PASS_BEGIN*", "pRenderPassBegin")]),
 
         Proto("void", "CmdEndRenderPass",
-            [Param("XGL_CMD_BUFFER", "cmdBuffer"),
-             Param("XGL_RENDER_PASS", "renderPass")]),
+            [Param("VK_CMD_BUFFER", "cmdBuffer"),
+             Param("VK_RENDER_PASS", "renderPass")]),
 
-        Proto("XGL_RESULT", "DbgSetValidationLevel",
-            [Param("XGL_DEVICE", "device"),
-             Param("XGL_VALIDATION_LEVEL", "validationLevel")]),
+        Proto("VK_RESULT", "DbgSetValidationLevel",
+            [Param("VK_DEVICE", "device"),
+             Param("VK_VALIDATION_LEVEL", "validationLevel")]),
 
-        Proto("XGL_RESULT", "DbgRegisterMsgCallback",
-            [Param("XGL_INSTANCE", "instance"),
-             Param("XGL_DBG_MSG_CALLBACK_FUNCTION", "pfnMsgCallback"),
+        Proto("VK_RESULT", "DbgRegisterMsgCallback",
+            [Param("VK_INSTANCE", "instance"),
+             Param("VK_DBG_MSG_CALLBACK_FUNCTION", "pfnMsgCallback"),
              Param("void*", "pUserData")]),
 
-        Proto("XGL_RESULT", "DbgUnregisterMsgCallback",
-            [Param("XGL_INSTANCE", "instance"),
-             Param("XGL_DBG_MSG_CALLBACK_FUNCTION", "pfnMsgCallback")]),
+        Proto("VK_RESULT", "DbgUnregisterMsgCallback",
+            [Param("VK_INSTANCE", "instance"),
+             Param("VK_DBG_MSG_CALLBACK_FUNCTION", "pfnMsgCallback")]),
 
-        Proto("XGL_RESULT", "DbgSetMessageFilter",
-            [Param("XGL_DEVICE", "device"),
+        Proto("VK_RESULT", "DbgSetMessageFilter",
+            [Param("VK_DEVICE", "device"),
              Param("int32_t", "msgCode"),
-             Param("XGL_DBG_MSG_FILTER", "filter")]),
+             Param("VK_DBG_MSG_FILTER", "filter")]),
 
-        Proto("XGL_RESULT", "DbgSetObjectTag",
-            [Param("XGL_BASE_OBJECT", "object"),
+        Proto("VK_RESULT", "DbgSetObjectTag",
+            [Param("VK_BASE_OBJECT", "object"),
              Param("size_t", "tagSize"),
              Param("const void*", "pTag")]),
 
-        Proto("XGL_RESULT", "DbgSetGlobalOption",
-            [Param("XGL_INSTANCE", "instance"),
-             Param("XGL_DBG_GLOBAL_OPTION", "dbgOption"),
+        Proto("VK_RESULT", "DbgSetGlobalOption",
+            [Param("VK_INSTANCE", "instance"),
+             Param("VK_DBG_GLOBAL_OPTION", "dbgOption"),
              Param("size_t", "dataSize"),
              Param("const void*", "pData")]),
 
-        Proto("XGL_RESULT", "DbgSetDeviceOption",
-            [Param("XGL_DEVICE", "device"),
-             Param("XGL_DBG_DEVICE_OPTION", "dbgOption"),
+        Proto("VK_RESULT", "DbgSetDeviceOption",
+            [Param("VK_DEVICE", "device"),
+             Param("VK_DBG_DEVICE_OPTION", "dbgOption"),
              Param("size_t", "dataSize"),
              Param("const void*", "pData")]),
 
         Proto("void", "CmdDbgMarkerBegin",
-            [Param("XGL_CMD_BUFFER", "cmdBuffer"),
+            [Param("VK_CMD_BUFFER", "cmdBuffer"),
              Param("const char*", "pMarker")]),
 
         Proto("void", "CmdDbgMarkerEnd",
-            [Param("XGL_CMD_BUFFER", "cmdBuffer")]),
+            [Param("VK_CMD_BUFFER", "cmdBuffer")]),
     ],
 )
 
 wsi_x11 = Extension(
-    name="XGL_WSI_X11",
+    name="VK_WSI_X11",
     headers=["xglWsiX11Ext.h"],
     objects=[],
     protos=[
-        Proto("XGL_RESULT", "WsiX11AssociateConnection",
-            [Param("XGL_PHYSICAL_GPU", "gpu"),
-             Param("const XGL_WSI_X11_CONNECTION_INFO*", "pConnectionInfo")]),
+        Proto("VK_RESULT", "WsiX11AssociateConnection",
+            [Param("VK_PHYSICAL_GPU", "gpu"),
+             Param("const VK_WSI_X11_CONNECTION_INFO*", "pConnectionInfo")]),
 
-        Proto("XGL_RESULT", "WsiX11GetMSC",
-            [Param("XGL_DEVICE", "device"),
+        Proto("VK_RESULT", "WsiX11GetMSC",
+            [Param("VK_DEVICE", "device"),
              Param("xcb_window_t", "window"),
              Param("xcb_randr_crtc_t", "crtc"),
              Param("uint64_t*", "pMsc")]),
 
-        Proto("XGL_RESULT", "WsiX11CreatePresentableImage",
-            [Param("XGL_DEVICE", "device"),
-             Param("const XGL_WSI_X11_PRESENTABLE_IMAGE_CREATE_INFO*", "pCreateInfo"),
-             Param("XGL_IMAGE*", "pImage"),
-             Param("XGL_GPU_MEMORY*", "pMem")]),
+        Proto("VK_RESULT", "WsiX11CreatePresentableImage",
+            [Param("VK_DEVICE", "device"),
+             Param("const VK_WSI_X11_PRESENTABLE_IMAGE_CREATE_INFO*", "pCreateInfo"),
+             Param("VK_IMAGE*", "pImage"),
+             Param("VK_GPU_MEMORY*", "pMem")]),
 
-        Proto("XGL_RESULT", "WsiX11QueuePresent",
-            [Param("XGL_QUEUE", "queue"),
-             Param("const XGL_WSI_X11_PRESENT_INFO*", "pPresentInfo"),
-             Param("XGL_FENCE", "fence")]),
+        Proto("VK_RESULT", "WsiX11QueuePresent",
+            [Param("VK_QUEUE", "queue"),
+             Param("const VK_WSI_X11_PRESENT_INFO*", "pPresentInfo"),
+             Param("VK_FENCE", "fence")]),
     ],
 )
 
 extensions = [core, wsi_x11]
 
 object_root_list = [
-    "XGL_INSTANCE",
-    "XGL_PHYSICAL_GPU",
-    "XGL_BASE_OBJECT"
+    "VK_INSTANCE",
+    "VK_PHYSICAL_GPU",
+    "VK_BASE_OBJECT"
 ]
 
 object_base_list = [
-    "XGL_DEVICE",
-    "XGL_QUEUE",
-    "XGL_GPU_MEMORY",
-    "XGL_OBJECT"
+    "VK_DEVICE",
+    "VK_QUEUE",
+    "VK_GPU_MEMORY",
+    "VK_OBJECT"
 ]
 
 object_list = [
-    "XGL_BUFFER",
-    "XGL_BUFFER_VIEW",
-    "XGL_IMAGE",
-    "XGL_IMAGE_VIEW",
-    "XGL_COLOR_ATTACHMENT_VIEW",
-    "XGL_DEPTH_STENCIL_VIEW",
-    "XGL_SHADER",
-    "XGL_PIPELINE",
-    "XGL_SAMPLER",
-    "XGL_DESCRIPTOR_SET",
-    "XGL_DESCRIPTOR_SET_LAYOUT",
-    "XGL_DESCRIPTOR_SET_LAYOUT_CHAIN",
-    "XGL_DESCRIPTOR_POOL",
-    "XGL_DYNAMIC_STATE_OBJECT",
-    "XGL_CMD_BUFFER",
-    "XGL_FENCE",
-    "XGL_SEMAPHORE",
-    "XGL_EVENT",
-    "XGL_QUERY_POOL",
-    "XGL_FRAMEBUFFER",
-    "XGL_RENDER_PASS"
+    "VK_BUFFER",
+    "VK_BUFFER_VIEW",
+    "VK_IMAGE",
+    "VK_IMAGE_VIEW",
+    "VK_COLOR_ATTACHMENT_VIEW",
+    "VK_DEPTH_STENCIL_VIEW",
+    "VK_SHADER",
+    "VK_PIPELINE",
+    "VK_SAMPLER",
+    "VK_DESCRIPTOR_SET",
+    "VK_DESCRIPTOR_SET_LAYOUT",
+    "VK_DESCRIPTOR_SET_LAYOUT_CHAIN",
+    "VK_DESCRIPTOR_POOL",
+    "VK_DYNAMIC_STATE_OBJECT",
+    "VK_CMD_BUFFER",
+    "VK_FENCE",
+    "VK_SEMAPHORE",
+    "VK_EVENT",
+    "VK_QUERY_POOL",
+    "VK_FRAMEBUFFER",
+    "VK_RENDER_PASS"
 ]
 
 object_dynamic_state_list = [
-    "XGL_DYNAMIC_VP_STATE_OBJECT",
-    "XGL_DYNAMIC_RS_STATE_OBJECT",
-    "XGL_DYNAMIC_CB_STATE_OBJECT",
-    "XGL_DYNAMIC_DS_STATE_OBJECT"
+    "VK_DYNAMIC_VP_STATE_OBJECT",
+    "VK_DYNAMIC_RS_STATE_OBJECT",
+    "VK_DYNAMIC_CB_STATE_OBJECT",
+    "VK_DYNAMIC_DS_STATE_OBJECT"
 ]
 
 object_type_list = object_root_list + object_base_list + object_list + object_dynamic_state_list
 
-object_parent_list = ["XGL_BASE_OBJECT", "XGL_OBJECT", "XGL_DYNAMIC_STATE_OBJECT"]
+object_parent_list = ["VK_BASE_OBJECT", "VK_OBJECT", "VK_DYNAMIC_STATE_OBJECT"]
 
 headers = []
 objects = []
@@ -977,7 +977,7 @@
     with open(filename, "r") as fp:
         for line in fp:
             line = line.strip()
-            if line.startswith("XGL_DEFINE"):
+            if line.startswith("VK_DEFINE"):
                 begin = line.find("(") + 1
                 end = line.find(",")
                 # extract the object type
@@ -989,7 +989,7 @@
     # parse proto_lines to protos
     protos = []
     for line in proto_lines:
-        first, rest = line.split(" (XGLAPI *xgl")
+        first, rest = line.split(" (VKAPI *vk")
         second, third = rest.split("Type)(")
 
         # get the return type, no space before "*"
@@ -1017,18 +1017,18 @@
         protos.append(Proto(proto_ret, proto_name, params))
 
     # make them an extension and print
-    ext = Extension("XGL_CORE",
-            headers=["xgl.h", "xglDbg.h"],
+    ext = Extension("VK_CORE",
+            headers=["vulkan.h", "xglDbg.h"],
             objects=object_lines,
             protos=protos)
     print("core =", str(ext))
 
     print("")
-    print("typedef struct _XGL_LAYER_DISPATCH_TABLE")
+    print("typedef struct _VK_LAYER_DISPATCH_TABLE")
     print("{")
     for proto in ext.protos:
-        print("    xgl%sType %s;" % (proto.name, proto.name))
-    print("} XGL_LAYER_DISPATCH_TABLE;")
+        print("    vk%sType %s;" % (proto.name, proto.name))
+    print("} VK_LAYER_DISPATCH_TABLE;")
 
 if __name__ == "__main__":
-    parse_xgl_h("include/xgl.h")
+    parse_xgl_h("include/vulkan.h")