Docs grammar and spelling fixes

8 files changed, 44 insertions, 44 deletions

diff --git a/docs/guide/types/attributes.md b/docs/guide/types/attributes.md
index 1796785d..b4453108 100644
--- a/docs/guide/types/attributes.md
+++ b/docs/guide/types/attributes.md
@@ -4,7 +4,7 @@ There are a number of custom attributes and annotations you can add to types in
 
 ## Structure Packing
 
-Use the attribute `__packed` in a structure definition to indicate that structure fields should be packed without padding. This is similar to `#pragma pack(1)` in MSVC and `__attribute__((packed))` in GCC/Clang. 
+Use the attribute `__packed` in a structure definition to indicate that structure fields should be packed without padding. This is similar to `#pragma pack(1)` in MSVC and `__attribute__((packed))` in GCC/Clang.
 
 ### Examples
 
@@ -26,8 +26,8 @@ struct PackedHeader __packed
     uint32_t version;     /* Offset: 0xA */
     void (* callback)();  /* Offset: 0xE */
 };
-  
-/* These also work, thanks to Clang's broad feature support across targets */ 
+
+/* These also work, thanks to Clang's broad feature support across targets */
 struct __attribute__((packed)) Header
 {
     uint16_t size;        /* Offset: 0x0 */
@@ -78,7 +78,7 @@ See [Working with C++ Types and Virtual Function Tables](cpp.md).
 
 ## Functions That Don't Return
 
-If you know that a function does not return (either via infinite loop, or terminating the process), you can annotate their definition with `__noreturn` to inform the analysis of this. Any calls to these functions will cause disassembly in the caller to stop, assuming execution does not continue. 
+If you know that a function does not return (either via infinite loop, or terminating the process), you can annotate their definition with `__noreturn` to inform the analysis of this. Any calls to these functions will cause disassembly in the caller to stop, assuming execution does not continue.
 
 ### Examples
 
@@ -110,7 +110,7 @@ __convention("convention_name")
 
 Due to the nature of parsing with Clang, most dedicated convention keywords are only available on their relevant targets. For example, `__stdcall` and `__fastcall` only apply to X86-based targets.
 
-If you have a custom calling convention, or one with no dedicated keyword, you can specify the convention name with the `__convention("name")` attribute. 
+If you have a custom calling convention, or one with no dedicated keyword, you can specify the convention name with the `__convention("name")` attribute.
 
 ### Examples
 
@@ -164,14 +164,14 @@ int get_twice(int arg) __pure
 }
 int main()
 {
-    (void)get_twice(1); /* result is unused, this will be dead code eliminated */ 
+    (void)get_twice(1); /* result is unused, this will be dead code eliminated */
 }
 ```
 
 ## Offset Pointers
 
 Offset pointers, often called shifted pointers, relative pointers, or adjusted pointers, represent a pointer to a structure that has been offset by a certain number of bytes.
-Annotating these offset pointers allows Binary Ninja to deduce types for dereferences through them, find the structure's start, and render proper member names. 
+Annotating these offset pointers allows Binary Ninja to deduce types for dereferences through them, find the structure's start, and render proper member names.
 
 These are often seen in intrusive linked lists, where structures have a pointer to the next item in the list, but the pointer is offset from the base of the structure and
 instead points to the member containing the pointer to the next item. Iterating through the items in the list involves following the pointer, then shifting the result by the offset
@@ -180,7 +180,7 @@ in any dereferences, and saving a couple instructions.
 
 ### Examples
 
-You will see uses of the offset pointers annotated with `(var - offset)` in IL views and `ADJ(var)` in Pseudo-C.  
+You will see uses of the offset pointers annotated with `(var - offset)` in IL views and `ADJ(var)` in Pseudo-C.
 
 ``` C
 /* High Level IL */
@@ -284,7 +284,7 @@ struct BaseClassDescriptor
 };
 
 /* ...results in the following presentation in Linear View */
-struct BaseClassDescriptor type_info::`RTTI Base Class Descriptor at (0,32,4,82)' = 
+struct BaseClassDescriptor type_info::`RTTI Base Class Descriptor at (0,32,4,82)' =
 {
     struct TypeDescriptor* __ptr32 __based(start) pTypeDescriptor = class type_info `RTTI Type Descriptor'  { 0x180000000 + 0x11180 }
     uint32_t numContainedBases = 0x0
@@ -296,7 +296,7 @@ struct BaseClassDescriptor type_info::`RTTI Base Class Descriptor at (0,32,4,82)
 }
 ```
 
-You can define structures who reference other structures relative to their variable address in memory. Address references are _relative to the pointer, not the base of the structure._ 
+You can define structures who reference other structures relative to their variable address in memory. Address references are _relative to the pointer, not the base of the structure._
 
 ``` C
 /* This structure definition... */
@@ -314,7 +314,7 @@ struct Texture tile_red
 {
     uint32_t width = 128
     uint32_t height = 128
-    char* __based(var, 0x10) texNameOffset = string_tile_red  { &tile_red->texNameOffset + 0x10 } 
+    char* __based(var, 0x10) texNameOffset = string_tile_red  { &tile_red->texNameOffset + 0x10 }
     uint32_t mask = 0
     uint32_t flags = 0
 }
@@ -323,9 +323,9 @@ char string_tile_red[9] = "tile_red", 0;
 
 ## Pointers with Custom Sizes
 
-Some structures store pointers with a size different than the platform's address width. For example, a 32-bit image base-relative pointer used on an 64-bit architecture. These sized pointers can be annotated with the `__ptr8`, `__ptr16`, `__ptr32`, `__ptr64`, or `__ptr_width()` attributes.
+Some structures store pointers with a size different from the platform's address width. For example, a 32-bit image base-relative pointer used on an 64-bit architecture. These sized pointers can be annotated with the `__ptr8`, `__ptr16`, `__ptr32`, `__ptr64`, or `__ptr_width()` attributes.
 
-These are often combined with [Based Pointers](#based-pointers), since pointers smaller than the address width cannot point to parts of memory without being shifted first. 
+These are often combined with [Based Pointers](#based-pointers), since pointers smaller than the address width cannot point to parts of memory without being shifted first.
 
 ### Examples
 
diff --git a/docs/guide/types/basictypes.md b/docs/guide/types/basictypes.md
index abebeafe..dcfd36f6 100644
--- a/docs/guide/types/basictypes.md
+++ b/docs/guide/types/basictypes.md
@@ -79,7 +79,7 @@ Types in the list have their class indicated by icons:
 
 #### Type Containers
 
-All of the type containers described in the [type introduction](index.md) are available in the Types View along with `User Types` in a section of its own.
+All the type containers described in the [type introduction](index.md) are available in the Types View along with `User Types` in a section of its own.
 
 * **User Types**: In your analysis: Types created by you, either manually or through actions/plugins
 * **System Types**: In your analysis: Types created by analysis or imported during analysis, such as from Libraries or Debug Info
@@ -129,4 +129,4 @@ the name of a type will take you to its definition.
 
 ### Structure Offset Annotations
 
-The Types view annotates code references to structure offsets if a structure member is not present. These annotations use the same convention as in the graph/linear view, showing the offset position and width. For example, the `__offset(0x8).q` token means the code references the offset 0x8 bytes into this structure, and the size of the access is a qword (8 bytes). You can press S on an offset annotation and a structure member of the appropriate type will be created there. Additionally, if you right click the structure name, you can choose to create all of these references.
+The Types view annotates code references to structure offsets if a structure member is not present. These annotations use the same convention as in the graph/linear view, showing the offset position and width. For example, the `__offset(0x8).q` token means the code references the offset 0x8 bytes into this structure, and the size of the access is a qword (8 bytes). You can press S on an offset annotation and a structure member of the appropriate type will be created there. Additionally, if you right-click the structure name, you can choose to create all of these references.
diff --git a/docs/guide/types/cpp.md b/docs/guide/types/cpp.md
index 455e59fd..c803a926 100644
--- a/docs/guide/types/cpp.md
+++ b/docs/guide/types/cpp.md
@@ -398,13 +398,13 @@ Now, go to the data section and apply the virtual function table structures to t
 virtual function tables themselves:
 
 ``` C
-00004020  struct vtable_for_Animal _vtable_for_Animal = 
+00004020  struct vtable_for_Animal _vtable_for_Animal =
 00004020  {
 00004020      void (* make_sound)(struct Animal* this) = nullptr
 00004028      void (* approach)(struct Animal* this) = Animal::approach()
 00004030  }
 
-00004050  struct vtable_for_Flying _vtable_for_Flying = 
+00004050  struct vtable_for_Flying _vtable_for_Flying =
 00004050  {
 00004050      void (* fly)(struct Flying* this) = Flying::fly
 00004058  }
@@ -473,20 +473,20 @@ Apply the new virtual function table structures to the virtual function tables i
 the data section:
 
 ``` C
-00004078  struct vtable_for_Dog _vtable_for_Dog = 
+00004078  struct vtable_for_Dog _vtable_for_Dog =
 00004078  {
 00004078      void (* make_sound)(struct Animal* this) = Dog::make_sound()
 00004080      void (* approach)(struct Animal* this) = Animal::approach()
 00004088  }
 
-000040b0  struct vtable_for_Cat _vtable_for_Cat = 
+000040b0  struct vtable_for_Cat _vtable_for_Cat =
 000040b0  {
 000040b0      void (* make_sound)(struct Animal* this) = Cat::make_sound
 000040b8      void (* approach)(struct Animal* this) = Cat::approach()
 000040c0      void (* nap)(struct Cat* this) = Cat::nap()
 000040c8  }
 
-000040f0  struct vtable_for_Lion _vtable_for_Lion = 
+000040f0  struct vtable_for_Lion _vtable_for_Lion =
 000040f0  {
 000040f0      void (* make_sound)(struct Animal* this) = Lion::make_sound
 000040f8      void (* approach)(struct Animal* this) = Cat::approach()
@@ -543,13 +543,13 @@ Apply the virtual function table structures to the corresponding virtual functio
 data section:
 
 ``` C
-00004130  struct vtable_for_Bird_as_Animal _vtable_for_Bird_as_Animal = 
+00004130  struct vtable_for_Bird_as_Animal _vtable_for_Bird_as_Animal =
 00004130  {
 00004130      void (* make_sound)(struct Animal* this) = Bird::make_sound()
 00004138      void (* approach)(struct Animal* this) = Bird::approach()
 00004140  }
 
-00004150  struct vtable_for_Bird_as_Flying _vtable_for_Bird_as_Flying = 
+00004150  struct vtable_for_Bird_as_Flying _vtable_for_Bird_as_Flying =
 00004150  {
 00004150      void (* fly)(struct Flying* this) = Flying::fly
 00004158  }
diff --git a/docs/guide/types/debuginfo.md b/docs/guide/types/debuginfo.md
index 5468bb6c..501e0b67 100644
--- a/docs/guide/types/debuginfo.md
+++ b/docs/guide/types/debuginfo.md
@@ -1,8 +1,8 @@
 # Debug Info
 
-Debug Info is a mechanism for importing types, function signatures, and data variables from either the original binary (eg. an ELF compiled with DWARF) or a supplemental file (eg. a PDB).
+Debug Info is a mechanism for importing types, function signatures, and data variables from either the original binary (e.g. an ELF compiled with DWARF) or a supplemental file (e.g. a PDB).
 
-Currently debug info plugins are limited to types, function signatures, and data variables, but in the future will include line number information, comments, local variables, and possibly more.
+Currently, debug info plugins are limited to types, function signatures, and data variables, but in the future will include line number information, comments, local variables, and possibly more.
 
 ## Supported Debug Info
 
@@ -10,7 +10,7 @@ We currently support [PDBs](https://github.com/Vector35/binaryninja-api/tree/dev
 
 For PDBs, Binary Ninja will automatically try to source from specified local folders and Microsoft's symbol server ([see the PDB settings for more information](../settings.md#settings-reference)).
 
-DWARF supports information compiled in to ELF binaries, information from external ELF files (`.dwo`, `.debug`, etc), information compiled in to Mach-O's, and information from external `.dSYM` files as well. Support for DWARF information in PEs is [planned](https://github.com/Vector35/binaryninja-api/issues/1555).
+DWARF supports information compiled in to ELF binaries, information from external ELF files (`.dwo`, `.debug`, etc.), information compiled in to Mach-O's, and information from external `.dSYM` files as well. Support for DWARF information in PEs is [planned](https://github.com/Vector35/binaryninja-api/issues/1555).
 
 ## Applying Debug Info
 
@@ -34,13 +34,13 @@ DWARF information is imported from files that contain DWARF sections. Currently,
 
 #### DWARF Import Limitations
 
-[DWARF version 5](https://dwarfstd.org/dwarf5std.html) is mostly backwards compatible with DWARF version 4, which we originally targetted with our DWARF import plugin, with the caveats descibed in [this issue](https://github.com/Vector35/binaryninja-api/issues/5423).
+[DWARF version 5](https://dwarfstd.org/dwarf5std.html) is mostly backwards compatible with DWARF version 4, which we originally targeted with our DWARF import plugin, with the caveats described in [this issue](https://github.com/Vector35/binaryninja-api/issues/5423).
 
 Components are supported by the API, but not in the parser. The [same issue](https://github.com/Vector35/binaryninja-api/issues/5423) as above would also allow us to support components more easily as well.
 
 #### DWARF Export Limitations
 
-Our [DWARF Export plugin](https://github.com/Vector35/binaryninja-api/tree/dev/plugins/dwarf/dwarf_export) is also open source and uses a different system from our debug information import plugins. It also does not support function-local variable names or types. The export plugin currently will export the global variables, function prototypes, and all the types in your binary view except for ones that are FunctionTypeClass or VarArgsTypeClass.
+Our [DWARF Export plugin](https://github.com/Vector35/binaryninja-api/tree/dev/plugins/dwarf/dwarf_export) is also open source and uses a different system from our debug information import plugins. It also does not support function-local variable names or types. The export plugin currently will export the global variables, function prototypes, and all the types in your binary view except for ones that are `FunctionTypeClass` or `VarArgsTypeClass`.
 
 #### Special Note for `.dSYM` Files
 
diff --git a/docs/guide/types/index.md b/docs/guide/types/index.md
index 7abcae64..375533af 100644
--- a/docs/guide/types/index.md
+++ b/docs/guide/types/index.md
@@ -10,7 +10,7 @@ There's so many things to learn about working with Types in Binary Ninja that we
 Additionally, several types of containers for type information are documented here:
 
 - [Debug Info](debuginfo.md): Debug Info can provide additional type information (examples include DWARF and PDB files)
-- [Type Libraries](typelibraries.md): Type Libraries contain types from commonly-used dynamic libraries 
+- [Type Libraries](typelibraries.md): Type Libraries contain types from commonly-used dynamic libraries
 - [Platform Types](platformtypes.md): Types that automatically apply to a platform
 - [Type Archives](typearchives.md): How you can use type archives to share types between analysis databases
 - [Signature Libraries](../../dev/annotation.md#signature-libraries): Signature libraries are used to match names of functions with signatures for code that is statically compiled
diff --git a/docs/guide/types/platformtypes.md b/docs/guide/types/platformtypes.md
index 286615e6..cf1b8fc4 100644
--- a/docs/guide/types/platformtypes.md
+++ b/docs/guide/types/platformtypes.md
@@ -3,9 +3,9 @@
 Binary Ninja pulls type information from a variety of sources. The highest-level source are the platform types loaded for the given platform (which includes operating system and architecture). There are two sources of platform types. The first are shipped with the product in a [binary path](../index.md#directories). The second location is in your [user folder](../index.md#user-folder) and is intended for you to put custom platform types.
 
 ???+ Danger "Warning"
-    Do NOT make changes to platform types in the binary path as they will be overwritten any time Binary Ninja updates. 
+    Do NOT make changes to platform types in the binary path as they will be overwritten any time Binary Ninja updates.
 
-Platform types are used to define types that should be available to all programs available on that particular platform. They are only for global common types. Consider, for example, that you might want to add the following on windows:
+Platform types are used to define types that should be available to all programs available on that particular platform. They are only for global common types. Consider, for example, that you might want to add the following on Windows:
 
 ```
 typedef uint8_t u8;
@@ -17,7 +17,7 @@ You could write this type into:
 /home/user/.binaryninja/types/platform/windows-x86.c
 ```
 
-And any time you opened a 32bit windows binary, that type would be available to use. However, please note that these are not substitutes for [Type Libraries](../../dev/annotation.md#type-libraries).  Type Libraries are used to provide a collection of types for a given library such as a libc, or common DLL. 
+And any time you opened a 32bit windows binary, that type would be available to use. However, please note that these are not substitutes for [Type Libraries](../../dev/annotation.md#type-libraries).  Type Libraries are used to provide a collection of types for a given library such as a libc, or common DLL.
 
 ???+ Warning "Tip"
     If you don't know the specific platform (and thus filename) you need to create for a given file, just enter `bv.platform` in the scripting console.
@@ -26,7 +26,7 @@ And any time you opened a 32bit windows binary, that type would be available to
 
 You may wish to provide types that are common across multiple architectures or platforms. The easiest way to do this is to use a `#include "filename.c"` line in the specific platform so that any common types will be loaded.
 
-The base path for these files is in your [user folder](../index.md#user-folder) inside of a "types/platform" subfolder.
+The base path for these files is in your [user folder](../index.md#user-folder) inside a "types/platform" subfolder.
 
 For example, something like:
 
diff --git a/docs/guide/types/type.md b/docs/guide/types/type.md
index b3ab9f09..9b0306b4 100644
--- a/docs/guide/types/type.md
+++ b/docs/guide/types/type.md
@@ -33,7 +33,7 @@ When used on an integer, all matching enumeration members will be shown.
 1. Name of currently selected enum
 1. Checkbox (set by default) that hides enums with no matching members for the current integer.
 
-However in instances where the hotkey is used on other variables, the display will only be used to apply the enum type to the selection and does not allow editing.
+However, in instances where the hotkey is used on other variables, the display will only be used to apply the enum type to the selection and does not allow editing.
 
 ## Union Field Resolution
 
@@ -61,7 +61,7 @@ typedef struct
 
 This is a tagged union; there's an enum defining the different variants of the union, and then the actual union variants/members. The union should take up as much space as the largest variant, so in this case it will usually be 8 bytes (depends on the target machine's pointer width), but only one variant can occupy those bytes at a time.
 
-When you apply a union type to a variable, you can use the "Field Resolution" option in the right-click menu to change which variant is used for a given instruction. 
+When you apply a union type to a variable, you can use the "Field Resolution" option in the right-click menu to change which variant is used for a given instruction.
 
 ![Field Resolution Menu](../../img/select-union-field-resolution.png "Field Resolution Menu")
 
@@ -125,4 +125,4 @@ This also works within data variables with structure type. For example, if the s
 
 Many characters commonly used in function naming are not valid C characters. For example, `::` in C++ types, braces or brackets. While we use clang's type-parser for such APIs as [parse_type_string](https://api.binary.ninja/binaryninja.binaryview-module.html#binaryninja.binaryview.BinaryView.parse_type_string) (note there's also [another version](https://api.binary.ninja/binaryninja.typeparser-module.html#binaryninja.typeparser.TypeParser.parse_type_string) of that API independent of the BinaryView off of the TypeParser module).
 
-To resolve this, we use `` ` `` (the backtick character) to enclose strings that should be treated as atomic units in the type-parser. You may notice this yourself if you by creating a struct with `:` in the name and then using `n` on the variable to see how it is escaped in the change name dialog.
+To resolve this, we use `` ` `` (the backtick character) to enclose strings that should be treated as atomic units in the type-parser. You may notice this yourself if you create a struct with `:` in the name and then use `n` on the variable to see how it is escaped in the change name dialog.
diff --git a/docs/guide/types/typeimportexport.md b/docs/guide/types/typeimportexport.md
index 43fbfa90..c245deef 100644
--- a/docs/guide/types/typeimportexport.md
+++ b/docs/guide/types/typeimportexport.md
@@ -21,7 +21,7 @@ This feature enables a number of workflows:
 
 ### Porting Analysis Between Target Versions
 
-If you're working with version 1 of a file which has symbols and you now want to port your work over to version 2 (as long as they both have symbols). This isn't going to be perfect as this feature isn't interactive and doesn't take into account changes in parameter counts or ordering, so *use this with caution*.
+If you're working with version 1 of a file which has symbols, and you now want to port your work over to version 2 (as long as they both have symbols). This isn't going to be perfect as this feature isn't interactive and doesn't take into account changes in parameter counts or ordering, so *use this with caution*.
 
 ### Quickly Defining Externs
 
@@ -35,17 +35,17 @@ If you already have a collection of headers containing types you want to use, yo
 - `-I<path>` for various user header paths
 - `-D<macro>=<value>` for macro definitions
 - `-x c -std=c99` to specify C99 mode
-- Other Clang-compatible command-line flags are accepted (eg `-fms-extensions`, `-fms-compatibility`, etc)
+- Other Clang-compatible command-line flags are accepted (e.g. `-fms-extensions`, `-fms-compatibility`, etc.)
 
 You can specify that types from system headers, accessed via `#include <header.h>`, will be in the results. Otherwise, only files from user headers, accessed via `#include "header.h"` will be used.
 
-You can also specify Define Binary Ninja Macros, which makes the type parser include the various parser extensions that Binary Ninja allows in the Type View editors, eg `__packed`, `__padding`, `__syscall`, etc. You probably only want to use this option when importing a header file exported using [Export Header File](#export-header-file). 
+You can also specify Define Binary Ninja Macros, which makes the type parser include the various parser extensions that Binary Ninja allows in the Type View editors, e.g. `__packed`, `__padding`, `__syscall`, etc. You probably only want to use this option when importing a header file exported using [Export Header File](#export-header-file).
 
 After specifying the file(s) and flag(s), pressing Preview will give a list of all the types and functions defined in the file(s). You may check or uncheck the box next to any of the types/functions to control whether they will be imported to your analysis.
 
 If there were any parse errors, those will be shown instead of a list of types. Generally speaking, what this means is you're missing either header search paths or compile definitions. See the section below on [finding system headers](#finding-system-headers).
 
-After pressing Import, all the checked types/functions will be added to your analysis. Imported types will override any existing types you had defined so they are disabled by default as indicated via the `Exists Already` column. Imported functions will replace signatures of any functions in your analysis whose name matches signatures found in the header. 
+After pressing Import, all the checked types/functions will be added to your analysis. Imported types will override any existing types you had defined, so they are disabled by default as indicated via the `Exists Already` column. Imported functions will replace signatures of any functions in your analysis whose name matches signatures found in the header.
 
 ![Importing a header file](../../img/import-header.png "Importing a header file")
 
@@ -105,7 +105,7 @@ From this example, the flags would be:
 
 ##### For Windows
 
-For windows, there's no easy command to list all the include paths so you have to piece them together from the `Include Directory` property in a Visual Studio project. You also want to include `-x c -std=c99` since Windows headers include lots of C++ types that the type importer currently does not support.
+For windows, there's no easy command to list all the include paths, so you have to piece them together from the `Include Directory` property in a Visual Studio project. You also want to include `-x c -std=c99` since Windows headers include lots of C++ types that the type importer currently does not support.
 
 You will end up with something like the following for user mode:
 
@@ -136,7 +136,7 @@ Note that some header files might require manually including a specific `windows
 
 ##### Cross-Platform Targets
 
-If you are analyzing a target that is for a different operating system, you need to both find the header include paths for that system, and copy (or mount) them to a location accessible by the computer running Binary Ninja.   
+If you are analyzing a target that is for a different operating system, you need to both find the header include paths for that system, and copy (or mount) them to a location accessible by the computer running Binary Ninja.
 
 ### Export Header File
 
@@ -147,9 +147,9 @@ If you want to compile code using the structures you defined during your analysi
 Binary Ninja pulls type information from a variety of sources. The highest-level source are the platform types loaded for the given platform (which includes operating system and architecture). There are two sources of platform types. The first are shipped with the product in a [binary path](../index.md#directories). The second location is in your [user folder](../index.md#user-folder) and is intended for you to put custom platform types.
 
 ???+ Danger "Warning"
-    Do NOT make changes to platform types in the binary path as they will be overwritten any time Binary Ninja updates. 
+    Do NOT make changes to platform types in the binary path as they will be overwritten any time Binary Ninja updates.
 
-Platform types are used to define types that should be available to all programs available on that particular platform. They are only for global common types. Consider, for example, that you might want to add the following on windows:
+Platform types are used to define types that should be available to all programs available on that particular platform. They are only for global common types. Consider, for example, that you might want to add the following on Windows:
 
 ```
 typedef uint8_t u8;
@@ -161,7 +161,7 @@ You could write this type into:
 /home/user/.binaryninja/types/platform/windows-x86.c
 ```
 
-And any time you opened a 32bit windows binary, that type would be available to use. However, please note that these are not substitutes for [Type Libraries](../../dev/annotation.md#type-libraries).  Type Libraries are used to provide a collection of types for a given library such as a libc, or common DLL. 
+And any time you opened a 32bit Windows binary, that type would be available to use. However, please note that these are not substitutes for [Type Libraries](../../dev/annotation.md#type-libraries).  Type Libraries are used to provide a collection of types for a given library such as a libc, or common DLL.
 
 ???+ Warning "Tip"
     If you don't know the specific platform (and thus filename) you need to create for a given file, just enter `bv.platform` in the scripting console.