Source code for binaryninja._binaryninjacore

import ctypes, os

from typing import Optional, AnyStr
from .enums import *# Load core module
import platform
core = None
_base_path = None
core_platform = platform.system()
if core_platform == "Darwin":
	_base_path = os.path.join(os.path.dirname(__file__), "..", "..", "..", "MacOS")
	core = ctypes.CDLL(os.path.join(_base_path, "libbinaryninjacore.dylib"))

elif core_platform == "Linux":
	_base_path = os.path.join(os.path.dirname(__file__), "..", "..")
	core = ctypes.CDLL(os.path.join(_base_path, "libbinaryninjacore.so.1"))

elif (core_platform == "Windows") or (core_platform.find("CYGWIN_NT") == 0):
	_base_path = os.path.join(os.path.dirname(__file__), "..", "..")
	core = ctypes.CDLL(os.path.join(_base_path, "binaryninjacore.dll"))
else:
	raise Exception("OS not supported")


def cstr(var: Optional[AnyStr]) -> Optional[bytes]:
	if var is None:
		return None
	if isinstance(var, bytes):
		return var
	return var.encode("utf-8")


def pyNativeStr(arg: AnyStr) -> str:
	if isinstance(arg, str):
		return arg
	else:
		return arg.decode('utf8')


def free_string(value:ctypes.c_char_p) -> None:
	BNFreeString(ctypes.cast(value, ctypes.POINTER(ctypes.c_byte)))

# Type definitions
ActionTypeEnum = ctypes.c_int
class BNActiveAnalysisInfo(ctypes.Structure):
	pass


BNActiveAnalysisInfoHandle = ctypes.POINTER(BNActiveAnalysisInfo)


class BNActivity(ctypes.Structure):
	pass


BNActivityHandle = ctypes.POINTER(BNActivity)


class BNAddressRange(ctypes.Structure):
	pass


BNAddressRangeHandle = ctypes.POINTER(BNAddressRange)


class BNAnalysisCompletionEvent(ctypes.Structure):
	pass


BNAnalysisCompletionEventHandle = ctypes.POINTER(BNAnalysisCompletionEvent)


class BNAnalysisContext(ctypes.Structure):
	pass


BNAnalysisContextHandle = ctypes.POINTER(BNAnalysisContext)


class BNAnalysisInfo(ctypes.Structure):
	pass


BNAnalysisInfoHandle = ctypes.POINTER(BNAnalysisInfo)


AnalysisModeEnum = ctypes.c_int
class BNAnalysisParameters(ctypes.Structure):
	pass


BNAnalysisParametersHandle = ctypes.POINTER(BNAnalysisParameters)


class BNAnalysisProgress(ctypes.Structure):
	pass


BNAnalysisProgressHandle = ctypes.POINTER(BNAnalysisProgress)


AnalysisSkipReasonEnum = ctypes.c_int
AnalysisStateEnum = ctypes.c_int
AnalysisWarningActionTypeEnum = ctypes.c_int
class BNArchitecture(ctypes.Structure):
	pass


BNArchitectureHandle = ctypes.POINTER(BNArchitecture)


class BNArchitectureAndAddress(ctypes.Structure):
	pass


BNArchitectureAndAddressHandle = ctypes.POINTER(BNArchitectureAndAddress)


class BNBackgroundTask(ctypes.Structure):
	pass


BNBackgroundTaskHandle = ctypes.POINTER(BNBackgroundTask)


class BNBaseStructure(ctypes.Structure):
	pass


BNBaseStructureHandle = ctypes.POINTER(BNBaseStructure)


class BNBasicBlock(ctypes.Structure):
	pass


BNBasicBlockHandle = ctypes.POINTER(BNBasicBlock)


class BNBasicBlockEdge(ctypes.Structure):
	pass


BNBasicBlockEdgeHandle = ctypes.POINTER(BNBasicBlockEdge)


class BNBinaryDataNotification(ctypes.Structure):
	pass


BNBinaryDataNotificationHandle = ctypes.POINTER(BNBinaryDataNotification)


class BNBinaryReader(ctypes.Structure):
	pass


BNBinaryReaderHandle = ctypes.POINTER(BNBinaryReader)


class BNBinaryView(ctypes.Structure):
	pass


BNBinaryViewHandle = ctypes.POINTER(BNBinaryView)


class BNBinaryViewEvent(ctypes.Structure):
	pass


BNBinaryViewEventHandle = ctypes.POINTER(BNBinaryViewEvent)


BinaryViewEventTypeEnum = ctypes.c_int
class BNBinaryViewType(ctypes.Structure):
	pass


BNBinaryViewTypeHandle = ctypes.POINTER(BNBinaryViewType)


class BNBinaryWriter(ctypes.Structure):
	pass


BNBinaryWriterHandle = ctypes.POINTER(BNBinaryWriter)


class BNBoolWithConfidence(ctypes.Structure):
	pass


BNBoolWithConfidenceHandle = ctypes.POINTER(BNBoolWithConfidence)


BranchTypeEnum = ctypes.c_int
class BNCallingConvention(ctypes.Structure):
	pass


BNCallingConventionHandle = ctypes.POINTER(BNCallingConvention)


CallingConventionNameEnum = ctypes.c_int
class BNCallingConventionWithConfidence(ctypes.Structure):
	pass


BNCallingConventionWithConfidenceHandle = ctypes.POINTER(BNCallingConventionWithConfidence)


class BNChangelogEntry(ctypes.Structure):
	@property
	def notes(self):
		return pyNativeStr(self._notes)
	@notes.setter
	def notes(self, value):
		self._notes = cstr(value)


BNChangelogEntryHandle = ctypes.POINTER(BNChangelogEntry)


class BNComponent(ctypes.Structure):
	pass


BNComponentHandle = ctypes.POINTER(BNComponent)


class BNConstantReference(ctypes.Structure):
	pass


BNConstantReferenceHandle = ctypes.POINTER(BNConstantReference)


class BNCustomArchitecture(ctypes.Structure):
	pass


BNCustomArchitectureHandle = ctypes.POINTER(BNCustomArchitecture)


class BNCustomBinaryView(ctypes.Structure):
	pass


BNCustomBinaryViewHandle = ctypes.POINTER(BNCustomBinaryView)


class BNCustomBinaryViewType(ctypes.Structure):
	pass


BNCustomBinaryViewTypeHandle = ctypes.POINTER(BNCustomBinaryViewType)


class BNCustomCallingConvention(ctypes.Structure):
	pass


BNCustomCallingConventionHandle = ctypes.POINTER(BNCustomCallingConvention)


class BNCustomDataRenderer(ctypes.Structure):
	pass


BNCustomDataRendererHandle = ctypes.POINTER(BNCustomDataRenderer)


class BNCustomFlowGraph(ctypes.Structure):
	pass


BNCustomFlowGraphHandle = ctypes.POINTER(BNCustomFlowGraph)


class BNCustomRelocationHandler(ctypes.Structure):
	pass


BNCustomRelocationHandlerHandle = ctypes.POINTER(BNCustomRelocationHandler)


class BNCustomTransform(ctypes.Structure):
	pass


BNCustomTransformHandle = ctypes.POINTER(BNCustomTransform)


class BNDataBuffer(ctypes.Structure):
	pass


BNDataBufferHandle = ctypes.POINTER(BNDataBuffer)


DataFlowQueryOptionEnum = ctypes.c_int
class BNDataRenderer(ctypes.Structure):
	pass


BNDataRendererHandle = ctypes.POINTER(BNDataRenderer)


class BNDataRendererContainer(ctypes.Structure):
	pass


BNDataRendererContainerHandle = ctypes.POINTER(BNDataRendererContainer)


class BNDataVariable(ctypes.Structure):
	pass


BNDataVariableHandle = ctypes.POINTER(BNDataVariable)


class BNDataVariableAndName(ctypes.Structure):
	@property
	def name(self):
		return pyNativeStr(self._name)
	@name.setter
	def name(self, value):
		self._name = cstr(value)


BNDataVariableAndNameHandle = ctypes.POINTER(BNDataVariableAndName)


class BNDataVariableAndNameAndDebugParser(ctypes.Structure):
	@property
	def name(self):
		return pyNativeStr(self._name)
	@name.setter
	def name(self, value):
		self._name = cstr(value)
	@property
	def parser(self):
		return pyNativeStr(self._parser)
	@parser.setter
	def parser(self, value):
		self._parser = cstr(value)


BNDataVariableAndNameAndDebugParserHandle = ctypes.POINTER(BNDataVariableAndNameAndDebugParser)


class BNDatabase(ctypes.Structure):
	pass


BNDatabaseHandle = ctypes.POINTER(BNDatabase)


DeadStoreEliminationEnum = ctypes.c_int
class BNDebugFunctionInfo(ctypes.Structure):
	@property
	def shortName(self):
		return pyNativeStr(self._shortName)
	@shortName.setter
	def shortName(self, value):
		self._shortName = cstr(value)
	@property
	def fullName(self):
		return pyNativeStr(self._fullName)
	@fullName.setter
	def fullName(self, value):
		self._fullName = cstr(value)
	@property
	def rawName(self):
		return pyNativeStr(self._rawName)
	@rawName.setter
	def rawName(self, value):
		self._rawName = cstr(value)


BNDebugFunctionInfoHandle = ctypes.POINTER(BNDebugFunctionInfo)


class BNDebugInfo(ctypes.Structure):
	pass


BNDebugInfoHandle = ctypes.POINTER(BNDebugInfo)


class BNDebugInfoParser(ctypes.Structure):
	pass


BNDebugInfoParserHandle = ctypes.POINTER(BNDebugInfoParser)


DisassemblyOptionEnum = ctypes.c_int
class BNDisassemblySettings(ctypes.Structure):
	pass


BNDisassemblySettingsHandle = ctypes.POINTER(BNDisassemblySettings)


class BNDisassemblyTextLine(ctypes.Structure):
	pass


BNDisassemblyTextLineHandle = ctypes.POINTER(BNDisassemblyTextLine)


class BNDisassemblyTextLineTypeInfo(ctypes.Structure):
	pass


BNDisassemblyTextLineTypeInfoHandle = ctypes.POINTER(BNDisassemblyTextLineTypeInfo)


class BNDisassemblyTextRenderer(ctypes.Structure):
	pass


BNDisassemblyTextRendererHandle = ctypes.POINTER(BNDisassemblyTextRenderer)


class BNDownloadInstance(ctypes.Structure):
	pass


BNDownloadInstanceHandle = ctypes.POINTER(BNDownloadInstance)


class BNDownloadInstanceCallbacks(ctypes.Structure):
	pass


BNDownloadInstanceCallbacksHandle = ctypes.POINTER(BNDownloadInstanceCallbacks)


class BNDownloadInstanceInputOutputCallbacks(ctypes.Structure):
	pass


BNDownloadInstanceInputOutputCallbacksHandle = ctypes.POINTER(BNDownloadInstanceInputOutputCallbacks)


class BNDownloadInstanceOutputCallbacks(ctypes.Structure):
	pass


BNDownloadInstanceOutputCallbacksHandle = ctypes.POINTER(BNDownloadInstanceOutputCallbacks)


class BNDownloadInstanceResponse(ctypes.Structure):
	pass


BNDownloadInstanceResponseHandle = ctypes.POINTER(BNDownloadInstanceResponse)


class BNDownloadProvider(ctypes.Structure):
	pass


BNDownloadProviderHandle = ctypes.POINTER(BNDownloadProvider)


class BNDownloadProviderCallbacks(ctypes.Structure):
	pass


BNDownloadProviderCallbacksHandle = ctypes.POINTER(BNDownloadProviderCallbacks)


EdgePenStyleEnum = ctypes.c_int
class BNEdgeStyle(ctypes.Structure):
	pass


BNEdgeStyleHandle = ctypes.POINTER(BNEdgeStyle)


EndiannessEnum = ctypes.c_int
class BNEnterpriseServerCallbacks(ctypes.Structure):
	pass


BNEnterpriseServerCallbacksHandle = ctypes.POINTER(BNEnterpriseServerCallbacks)


class BNEnumeration(ctypes.Structure):
	pass


BNEnumerationHandle = ctypes.POINTER(BNEnumeration)


class BNEnumerationBuilder(ctypes.Structure):
	pass


BNEnumerationBuilderHandle = ctypes.POINTER(BNEnumerationBuilder)


class BNEnumerationMember(ctypes.Structure):
	@property
	def name(self):
		return pyNativeStr(self._name)
	@name.setter
	def name(self, value):
		self._name = cstr(value)


BNEnumerationMemberHandle = ctypes.POINTER(BNEnumerationMember)


class BNExternalLibrary(ctypes.Structure):
	pass


BNExternalLibraryHandle = ctypes.POINTER(BNExternalLibrary)


class BNExternalLocation(ctypes.Structure):
	pass


BNExternalLocationHandle = ctypes.POINTER(BNExternalLocation)


class BNFileAccessor(ctypes.Structure):
	pass


BNFileAccessorHandle = ctypes.POINTER(BNFileAccessor)


class BNFileMetadata(ctypes.Structure):
	pass


BNFileMetadataHandle = ctypes.POINTER(BNFileMetadata)


FindFlagEnum = ctypes.c_int
FindRangeTypeEnum = ctypes.c_int
FindTypeEnum = ctypes.c_int
class BNFlagConditionForSemanticClass(ctypes.Structure):
	pass


BNFlagConditionForSemanticClassHandle = ctypes.POINTER(BNFlagConditionForSemanticClass)


FlagRoleEnum = ctypes.c_int
class BNFlowGraph(ctypes.Structure):
	pass


BNFlowGraphHandle = ctypes.POINTER(BNFlowGraph)


class BNFlowGraphEdge(ctypes.Structure):
	pass


BNFlowGraphEdgeHandle = ctypes.POINTER(BNFlowGraphEdge)


class BNFlowGraphLayoutRequest(ctypes.Structure):
	pass


BNFlowGraphLayoutRequestHandle = ctypes.POINTER(BNFlowGraphLayoutRequest)


class BNFlowGraphNode(ctypes.Structure):
	pass


BNFlowGraphNodeHandle = ctypes.POINTER(BNFlowGraphNode)


FlowGraphOptionEnum = ctypes.c_int
class BNFormInputField(ctypes.Structure):
	@property
	def prompt(self):
		return pyNativeStr(self._prompt)
	@prompt.setter
	def prompt(self, value):
		self._prompt = cstr(value)
	@property
	def ext(self):
		return pyNativeStr(self._ext)
	@ext.setter
	def ext(self, value):
		self._ext = cstr(value)
	@property
	def defaultName(self):
		return pyNativeStr(self._defaultName)
	@defaultName.setter
	def defaultName(self, value):
		self._defaultName = cstr(value)
	@property
	def stringResult(self):
		return pyNativeStr(self._stringResult)
	@stringResult.setter
	def stringResult(self, value):
		self._stringResult = cstr(value)
	@property
	def stringDefault(self):
		return pyNativeStr(self._stringDefault)
	@stringDefault.setter
	def stringDefault(self, value):
		self._stringDefault = cstr(value)


BNFormInputFieldHandle = ctypes.POINTER(BNFormInputField)


FormInputFieldTypeEnum = ctypes.c_int
class BNFunction(ctypes.Structure):
	pass


BNFunctionHandle = ctypes.POINTER(BNFunction)


FunctionAnalysisSkipOverrideEnum = ctypes.c_int
FunctionGraphTypeEnum = ctypes.c_int
class BNFunctionParameter(ctypes.Structure):
	@property
	def name(self):
		return pyNativeStr(self._name)
	@name.setter
	def name(self, value):
		self._name = cstr(value)


BNFunctionParameterHandle = ctypes.POINTER(BNFunctionParameter)


class BNFunctionRecognizer(ctypes.Structure):
	pass


BNFunctionRecognizerHandle = ctypes.POINTER(BNFunctionRecognizer)


FunctionUpdateTypeEnum = ctypes.c_int
class BNHighLevelILFunction(ctypes.Structure):
	pass


BNHighLevelILFunctionHandle = ctypes.POINTER(BNHighLevelILFunction)


class BNHighLevelILInstruction(ctypes.Structure):
	pass


BNHighLevelILInstructionHandle = ctypes.POINTER(BNHighLevelILInstruction)


HighLevelILOperationEnum = ctypes.c_int
class BNHighlightColor(ctypes.Structure):
	pass


BNHighlightColorHandle = ctypes.POINTER(BNHighlightColor)


HighlightColorStyleEnum = ctypes.c_int
HighlightStandardColorEnum = ctypes.c_int
ILBranchDependenceEnum = ctypes.c_int
class BNILBranchInstructionAndDependence(ctypes.Structure):
	pass


BNILBranchInstructionAndDependenceHandle = ctypes.POINTER(BNILBranchInstructionAndDependence)


class BNILIndexRange(ctypes.Structure):
	pass


BNILIndexRangeHandle = ctypes.POINTER(BNILIndexRange)


ILInstructionAttributeEnum = ctypes.c_int
class BNILReferenceSource(ctypes.Structure):
	pass


BNILReferenceSourceHandle = ctypes.POINTER(BNILReferenceSource)


ImplicitRegisterExtendEnum = ctypes.c_int
class BNIndirectBranchInfo(ctypes.Structure):
	pass


BNIndirectBranchInfoHandle = ctypes.POINTER(BNIndirectBranchInfo)


class BNInheritedStructureMember(ctypes.Structure):
	pass


BNInheritedStructureMemberHandle = ctypes.POINTER(BNInheritedStructureMember)


class BNInstructionInfo(ctypes.Structure):
	pass


BNInstructionInfoHandle = ctypes.POINTER(BNInstructionInfo)


class BNInstructionTextLine(ctypes.Structure):
	pass


BNInstructionTextLineHandle = ctypes.POINTER(BNInstructionTextLine)


class BNInstructionTextToken(ctypes.Structure):
	@property
	def text(self):
		return pyNativeStr(self._text)
	@text.setter
	def text(self, value):
		self._text = cstr(value)


BNInstructionTextTokenHandle = ctypes.POINTER(BNInstructionTextToken)


InstructionTextTokenContextEnum = ctypes.c_int
InstructionTextTokenTypeEnum = ctypes.c_int
IntegerDisplayTypeEnum = ctypes.c_int
class BNInteractionHandlerCallbacks(ctypes.Structure):
	pass


BNInteractionHandlerCallbacksHandle = ctypes.POINTER(BNInteractionHandlerCallbacks)


IntrinsicClassEnum = ctypes.c_int
class BNKeyValueStore(ctypes.Structure):
	pass


BNKeyValueStoreHandle = ctypes.POINTER(BNKeyValueStore)


class BNLanguageRepresentationFunction(ctypes.Structure):
	pass


BNLanguageRepresentationFunctionHandle = ctypes.POINTER(BNLanguageRepresentationFunction)


class BNLinearDisassemblyLine(ctypes.Structure):
	pass


BNLinearDisassemblyLineHandle = ctypes.POINTER(BNLinearDisassemblyLine)


LinearDisassemblyLineTypeEnum = ctypes.c_int
class BNLinearViewCursor(ctypes.Structure):
	pass


BNLinearViewCursorHandle = ctypes.POINTER(BNLinearViewCursor)


class BNLinearViewObject(ctypes.Structure):
	pass


BNLinearViewObjectHandle = ctypes.POINTER(BNLinearViewObject)


class BNLinearViewObjectIdentifier(ctypes.Structure):
	@property
	def name(self):
		return pyNativeStr(self._name)
	@name.setter
	def name(self, value):
		self._name = cstr(value)


BNLinearViewObjectIdentifierHandle = ctypes.POINTER(BNLinearViewObjectIdentifier)


LinearViewObjectIdentifierTypeEnum = ctypes.c_int
LogLevelEnum = ctypes.c_int
class BNLogListener(ctypes.Structure):
	pass


BNLogListenerHandle = ctypes.POINTER(BNLogListener)


class BNLogger(ctypes.Structure):
	pass


BNLoggerHandle = ctypes.POINTER(BNLogger)


class BNLookupTableEntry(ctypes.Structure):
	pass


BNLookupTableEntryHandle = ctypes.POINTER(BNLookupTableEntry)


LowLevelILFlagConditionEnum = ctypes.c_int
class BNLowLevelILFunction(ctypes.Structure):
	pass


BNLowLevelILFunctionHandle = ctypes.POINTER(BNLowLevelILFunction)


class BNLowLevelILInstruction(ctypes.Structure):
	pass


BNLowLevelILInstructionHandle = ctypes.POINTER(BNLowLevelILInstruction)


class BNLowLevelILLabel(ctypes.Structure):
	pass


BNLowLevelILLabelHandle = ctypes.POINTER(BNLowLevelILLabel)


LowLevelILOperationEnum = ctypes.c_int
class BNMainThreadAction(ctypes.Structure):
	pass


BNMainThreadActionHandle = ctypes.POINTER(BNMainThreadAction)


class BNMainThreadCallbacks(ctypes.Structure):
	pass


BNMainThreadCallbacksHandle = ctypes.POINTER(BNMainThreadCallbacks)


class BNMediumLevelILFunction(ctypes.Structure):
	pass


BNMediumLevelILFunctionHandle = ctypes.POINTER(BNMediumLevelILFunction)


class BNMediumLevelILInstruction(ctypes.Structure):
	pass


BNMediumLevelILInstructionHandle = ctypes.POINTER(BNMediumLevelILInstruction)


class BNMediumLevelILLabel(ctypes.Structure):
	pass


BNMediumLevelILLabelHandle = ctypes.POINTER(BNMediumLevelILLabel)


MediumLevelILOperationEnum = ctypes.c_int
MemberAccessEnum = ctypes.c_int
MemberScopeEnum = ctypes.c_int
class BNMemoryUsageInfo(ctypes.Structure):
	@property
	def name(self):
		return pyNativeStr(self._name)
	@name.setter
	def name(self, value):
		self._name = cstr(value)


BNMemoryUsageInfoHandle = ctypes.POINTER(BNMemoryUsageInfo)


class BNMergedVariable(ctypes.Structure):
	pass


BNMergedVariableHandle = ctypes.POINTER(BNMergedVariable)


MessageBoxButtonResultEnum = ctypes.c_int
MessageBoxButtonSetEnum = ctypes.c_int
MessageBoxIconEnum = ctypes.c_int
class BNMetadata(ctypes.Structure):
	pass


BNMetadataHandle = ctypes.POINTER(BNMetadata)


MetadataTypeEnum = ctypes.c_int
class BNMetadataValueStore(ctypes.Structure):
	pass


BNMetadataValueStoreHandle = ctypes.POINTER(BNMetadataValueStore)


ModificationStatusEnum = ctypes.c_int
class BNNameAndType(ctypes.Structure):
	@property
	def name(self):
		return pyNativeStr(self._name)
	@name.setter
	def name(self, value):
		self._name = cstr(value)


BNNameAndTypeHandle = ctypes.POINTER(BNNameAndType)


class BNNameList(ctypes.Structure):
	@property
	def join(self):
		return pyNativeStr(self._join)
	@join.setter
	def join(self, value):
		self._join = cstr(value)


BNNameListHandle = ctypes.POINTER(BNNameList)


class BNNameSpace(ctypes.Structure):
	@property
	def join(self):
		return pyNativeStr(self._join)
	@join.setter
	def join(self, value):
		self._join = cstr(value)


BNNameSpaceHandle = ctypes.POINTER(BNNameSpace)


NameTypeEnum = ctypes.c_int
class BNNamedTypeReference(ctypes.Structure):
	pass


BNNamedTypeReferenceHandle = ctypes.POINTER(BNNamedTypeReference)


class BNNamedTypeReferenceBuilder(ctypes.Structure):
	pass


BNNamedTypeReferenceBuilderHandle = ctypes.POINTER(BNNamedTypeReferenceBuilder)


NamedTypeReferenceClassEnum = ctypes.c_int
class BNNavigationHandler(ctypes.Structure):
	pass


BNNavigationHandlerHandle = ctypes.POINTER(BNNavigationHandler)


class BNObjectDestructionCallbacks(ctypes.Structure):
	pass


BNObjectDestructionCallbacksHandle = ctypes.POINTER(BNObjectDestructionCallbacks)


class BNOffsetWithConfidence(ctypes.Structure):
	pass


BNOffsetWithConfidenceHandle = ctypes.POINTER(BNOffsetWithConfidence)


class BNParameterVariablesWithConfidence(ctypes.Structure):
	pass


BNParameterVariablesWithConfidenceHandle = ctypes.POINTER(BNParameterVariablesWithConfidence)


class BNParsedType(ctypes.Structure):
	pass


BNParsedTypeHandle = ctypes.POINTER(BNParsedType)


class BNPerformanceInfo(ctypes.Structure):
	@property
	def name(self):
		return pyNativeStr(self._name)
	@name.setter
	def name(self, value):
		self._name = cstr(value)


BNPerformanceInfoHandle = ctypes.POINTER(BNPerformanceInfo)


class BNPlatform(ctypes.Structure):
	pass


BNPlatformHandle = ctypes.POINTER(BNPlatform)


class BNPluginCommand(ctypes.Structure):
	@property
	def name(self):
		return pyNativeStr(self._name)
	@name.setter
	def name(self, value):
		self._name = cstr(value)
	@property
	def description(self):
		return pyNativeStr(self._description)
	@description.setter
	def description(self, value):
		self._description = cstr(value)


BNPluginCommandHandle = ctypes.POINTER(BNPluginCommand)


PluginCommandTypeEnum = ctypes.c_int
PluginLoadOrderEnum = ctypes.c_int
PluginOriginEnum = ctypes.c_int
PluginStatusEnum = ctypes.c_int
PluginTypeEnum = ctypes.c_int
class BNPoint(ctypes.Structure):
	pass


BNPointHandle = ctypes.POINTER(BNPoint)


PointerSuffixEnum = ctypes.c_int
class BNPossibleValueSet(ctypes.Structure):
	pass


BNPossibleValueSetHandle = ctypes.POINTER(BNPossibleValueSet)


class BNProject(ctypes.Structure):
	pass


BNProjectHandle = ctypes.POINTER(BNProject)


class BNProjectFile(ctypes.Structure):
	pass


BNProjectFileHandle = ctypes.POINTER(BNProjectFile)


class BNProjectFolder(ctypes.Structure):
	pass


BNProjectFolderHandle = ctypes.POINTER(BNProjectFolder)


class BNProjectNotification(ctypes.Structure):
	pass


BNProjectNotificationHandle = ctypes.POINTER(BNProjectNotification)


class BNQualifiedName(ctypes.Structure):
	@property
	def join(self):
		return pyNativeStr(self._join)
	@join.setter
	def join(self, value):
		self._join = cstr(value)


BNQualifiedNameHandle = ctypes.POINTER(BNQualifiedName)


class BNQualifiedNameAndType(ctypes.Structure):
	pass


BNQualifiedNameAndTypeHandle = ctypes.POINTER(BNQualifiedNameAndType)


class BNQualifiedNameList(ctypes.Structure):
	pass


BNQualifiedNameListHandle = ctypes.POINTER(BNQualifiedNameList)


class BNQualifiedNameTypeAndId(ctypes.Structure):
	@property
	def id(self):
		return pyNativeStr(self._id)
	@id.setter
	def id(self, value):
		self._id = cstr(value)


BNQualifiedNameTypeAndIdHandle = ctypes.POINTER(BNQualifiedNameTypeAndId)


class BNRange(ctypes.Structure):
	pass


BNRangeHandle = ctypes.POINTER(BNRange)


class BNReferenceSource(ctypes.Structure):
	pass


BNReferenceSourceHandle = ctypes.POINTER(BNReferenceSource)


ReferenceTypeEnum = ctypes.c_int
class BNRegisterInfo(ctypes.Structure):
	pass


BNRegisterInfoHandle = ctypes.POINTER(BNRegisterInfo)


class BNRegisterOrConstant(ctypes.Structure):
	pass


BNRegisterOrConstantHandle = ctypes.POINTER(BNRegisterOrConstant)


class BNRegisterSetWithConfidence(ctypes.Structure):
	pass


BNRegisterSetWithConfidenceHandle = ctypes.POINTER(BNRegisterSetWithConfidence)


class BNRegisterStackAdjustment(ctypes.Structure):
	pass


BNRegisterStackAdjustmentHandle = ctypes.POINTER(BNRegisterStackAdjustment)


class BNRegisterStackInfo(ctypes.Structure):
	pass


BNRegisterStackInfoHandle = ctypes.POINTER(BNRegisterStackInfo)


class BNRegisterValue(ctypes.Structure):
	pass


BNRegisterValueHandle = ctypes.POINTER(BNRegisterValue)


RegisterValueTypeEnum = ctypes.c_int
class BNRegisterValueWithConfidence(ctypes.Structure):
	pass


BNRegisterValueWithConfidenceHandle = ctypes.POINTER(BNRegisterValueWithConfidence)


class BNRelocation(ctypes.Structure):
	pass


BNRelocationHandle = ctypes.POINTER(BNRelocation)


class BNRelocationHandler(ctypes.Structure):
	pass


BNRelocationHandlerHandle = ctypes.POINTER(BNRelocationHandler)


class BNRelocationInfo(ctypes.Structure):
	pass


BNRelocationInfoHandle = ctypes.POINTER(BNRelocationInfo)


RelocationTypeEnum = ctypes.c_int
class BNRepoPlugin(ctypes.Structure):
	pass


BNRepoPluginHandle = ctypes.POINTER(BNRepoPlugin)


class BNReportCollection(ctypes.Structure):
	pass


BNReportCollectionHandle = ctypes.POINTER(BNReportCollection)


ReportTypeEnum = ctypes.c_int
class BNRepository(ctypes.Structure):
	pass


BNRepositoryHandle = ctypes.POINTER(BNRepository)


class BNRepositoryManager(ctypes.Structure):
	pass


BNRepositoryManagerHandle = ctypes.POINTER(BNRepositoryManager)


SaveOptionEnum = ctypes.c_int
class BNSaveSettings(ctypes.Structure):
	pass


BNSaveSettingsHandle = ctypes.POINTER(BNSaveSettings)


class BNScriptingInstance(ctypes.Structure):
	pass


BNScriptingInstanceHandle = ctypes.POINTER(BNScriptingInstance)


class BNScriptingInstanceCallbacks(ctypes.Structure):
	pass


BNScriptingInstanceCallbacksHandle = ctypes.POINTER(BNScriptingInstanceCallbacks)


class BNScriptingOutputListener(ctypes.Structure):
	pass


BNScriptingOutputListenerHandle = ctypes.POINTER(BNScriptingOutputListener)


class BNScriptingProvider(ctypes.Structure):
	pass


BNScriptingProviderHandle = ctypes.POINTER(BNScriptingProvider)


class BNScriptingProviderCallbacks(ctypes.Structure):
	pass


BNScriptingProviderCallbacksHandle = ctypes.POINTER(BNScriptingProviderCallbacks)


ScriptingProviderExecuteResultEnum = ctypes.c_int
ScriptingProviderInputReadyStateEnum = ctypes.c_int
class BNSecretsProvider(ctypes.Structure):
	pass


BNSecretsProviderHandle = ctypes.POINTER(BNSecretsProvider)


class BNSecretsProviderCallbacks(ctypes.Structure):
	pass


BNSecretsProviderCallbacksHandle = ctypes.POINTER(BNSecretsProviderCallbacks)


class BNSection(ctypes.Structure):
	pass


BNSectionHandle = ctypes.POINTER(BNSection)


SectionSemanticsEnum = ctypes.c_int
class BNSegment(ctypes.Structure):
	pass


BNSegmentHandle = ctypes.POINTER(BNSegment)


SegmentFlagEnum = ctypes.c_int
class BNSettings(ctypes.Structure):
	pass


BNSettingsHandle = ctypes.POINTER(BNSettings)


SettingsScopeEnum = ctypes.c_int
class BNSnapshot(ctypes.Structure):
	pass


BNSnapshotHandle = ctypes.POINTER(BNSnapshot)


class BNStackVariableReference(ctypes.Structure):
	@property
	def name(self):
		return pyNativeStr(self._name)
	@name.setter
	def name(self, value):
		self._name = cstr(value)


BNStackVariableReferenceHandle = ctypes.POINTER(BNStackVariableReference)


class BNStringReference(ctypes.Structure):
	pass


BNStringReferenceHandle = ctypes.POINTER(BNStringReference)


StringTypeEnum = ctypes.c_int
class BNStructure(ctypes.Structure):
	pass


BNStructureHandle = ctypes.POINTER(BNStructure)


class BNStructureBuilder(ctypes.Structure):
	pass


BNStructureBuilderHandle = ctypes.POINTER(BNStructureBuilder)


class BNStructureMember(ctypes.Structure):
	@property
	def name(self):
		return pyNativeStr(self._name)
	@name.setter
	def name(self, value):
		self._name = cstr(value)


BNStructureMemberHandle = ctypes.POINTER(BNStructureMember)


StructureVariantEnum = ctypes.c_int
class BNSymbol(ctypes.Structure):
	pass


BNSymbolHandle = ctypes.POINTER(BNSymbol)


SymbolBindingEnum = ctypes.c_int
class BNSymbolQueue(ctypes.Structure):
	pass


BNSymbolQueueHandle = ctypes.POINTER(BNSymbolQueue)


SymbolTypeEnum = ctypes.c_int
SyncStatusEnum = ctypes.c_int
class BNSystemCallInfo(ctypes.Structure):
	pass


BNSystemCallInfoHandle = ctypes.POINTER(BNSystemCallInfo)


class BNTag(ctypes.Structure):
	pass


BNTagHandle = ctypes.POINTER(BNTag)


class BNTagReference(ctypes.Structure):
	pass


BNTagReferenceHandle = ctypes.POINTER(BNTagReference)


TagReferenceTypeEnum = ctypes.c_int
class BNTagType(ctypes.Structure):
	pass


BNTagTypeHandle = ctypes.POINTER(BNTagType)


TagTypeTypeEnum = ctypes.c_int
class BNTemporaryFile(ctypes.Structure):
	pass


BNTemporaryFileHandle = ctypes.POINTER(BNTemporaryFile)


ThemeColorEnum = ctypes.c_int
TokenEscapingTypeEnum = ctypes.c_int
class BNTransform(ctypes.Structure):
	pass


BNTransformHandle = ctypes.POINTER(BNTransform)


class BNTransformParameter(ctypes.Structure):
	@property
	def name(self):
		return pyNativeStr(self._name)
	@name.setter
	def name(self, value):
		self._name = cstr(value)


BNTransformParameterHandle = ctypes.POINTER(BNTransformParameter)


class BNTransformParameterInfo(ctypes.Structure):
	@property
	def name(self):
		return pyNativeStr(self._name)
	@name.setter
	def name(self, value):
		self._name = cstr(value)
	@property
	def longName(self):
		return pyNativeStr(self._longName)
	@longName.setter
	def longName(self, value):
		self._longName = cstr(value)


BNTransformParameterInfoHandle = ctypes.POINTER(BNTransformParameterInfo)


TransformTypeEnum = ctypes.c_int
class BNType(ctypes.Structure):
	pass


BNTypeHandle = ctypes.POINTER(BNType)


class BNTypeArchive(ctypes.Structure):
	pass


BNTypeArchiveHandle = ctypes.POINTER(BNTypeArchive)


class BNTypeArchiveNotification(ctypes.Structure):
	pass


BNTypeArchiveNotificationHandle = ctypes.POINTER(BNTypeArchiveNotification)


class BNTypeBuilder(ctypes.Structure):
	pass


BNTypeBuilderHandle = ctypes.POINTER(BNTypeBuilder)


TypeClassEnum = ctypes.c_int
class BNTypeContainer(ctypes.Structure):
	pass


BNTypeContainerHandle = ctypes.POINTER(BNTypeContainer)


TypeContainerTypeEnum = ctypes.c_int
class BNTypeContext(ctypes.Structure):
	pass


BNTypeContextHandle = ctypes.POINTER(BNTypeContext)


class BNTypeDefinitionLine(ctypes.Structure):
	@property
	def rootTypeName(self):
		return pyNativeStr(self._rootTypeName)
	@rootTypeName.setter
	def rootTypeName(self, value):
		self._rootTypeName = cstr(value)


BNTypeDefinitionLineHandle = ctypes.POINTER(BNTypeDefinitionLine)


TypeDefinitionLineTypeEnum = ctypes.c_int
class BNTypeField(ctypes.Structure):
	pass


BNTypeFieldHandle = ctypes.POINTER(BNTypeField)


class BNTypeFieldReference(ctypes.Structure):
	pass


BNTypeFieldReferenceHandle = ctypes.POINTER(BNTypeFieldReference)


class BNTypeFieldReferenceSizeInfo(ctypes.Structure):
	pass


BNTypeFieldReferenceSizeInfoHandle = ctypes.POINTER(BNTypeFieldReferenceSizeInfo)


class BNTypeFieldReferenceTypeInfo(ctypes.Structure):
	pass


BNTypeFieldReferenceTypeInfoHandle = ctypes.POINTER(BNTypeFieldReferenceTypeInfo)


class BNTypeLibrary(ctypes.Structure):
	pass


BNTypeLibraryHandle = ctypes.POINTER(BNTypeLibrary)


class BNTypeLibraryMapping(ctypes.Structure):
	pass


BNTypeLibraryMappingHandle = ctypes.POINTER(BNTypeLibraryMapping)


class BNTypeParser(ctypes.Structure):
	pass


BNTypeParserHandle = ctypes.POINTER(BNTypeParser)


class BNTypeParserCallbacks(ctypes.Structure):
	pass


BNTypeParserCallbacksHandle = ctypes.POINTER(BNTypeParserCallbacks)


class BNTypeParserError(ctypes.Structure):
	@property
	def message(self):
		return pyNativeStr(self._message)
	@message.setter
	def message(self, value):
		self._message = cstr(value)
	@property
	def fileName(self):
		return pyNativeStr(self._fileName)
	@fileName.setter
	def fileName(self, value):
		self._fileName = cstr(value)


BNTypeParserErrorHandle = ctypes.POINTER(BNTypeParserError)


TypeParserErrorSeverityEnum = ctypes.c_int
TypeParserOptionEnum = ctypes.c_int
class BNTypeParserResult(ctypes.Structure):
	pass


BNTypeParserResultHandle = ctypes.POINTER(BNTypeParserResult)


class BNTypePrinter(ctypes.Structure):
	pass


BNTypePrinterHandle = ctypes.POINTER(BNTypePrinter)


class BNTypePrinterCallbacks(ctypes.Structure):
	pass


BNTypePrinterCallbacksHandle = ctypes.POINTER(BNTypePrinterCallbacks)


class BNTypeReferenceSource(ctypes.Structure):
	pass


BNTypeReferenceSourceHandle = ctypes.POINTER(BNTypeReferenceSource)


TypeReferenceTypeEnum = ctypes.c_int
class BNTypeWithConfidence(ctypes.Structure):
	pass


BNTypeWithConfidenceHandle = ctypes.POINTER(BNTypeWithConfidence)


class BNUndoAction(ctypes.Structure):
	@property
	def summaryText(self):
		return pyNativeStr(self._summaryText)
	@summaryText.setter
	def summaryText(self, value):
		self._summaryText = cstr(value)


BNUndoActionHandle = ctypes.POINTER(BNUndoAction)


class BNUndoEntry(ctypes.Structure):
	@property
	def id(self):
		return pyNativeStr(self._id)
	@id.setter
	def id(self, value):
		self._id = cstr(value)


BNUndoEntryHandle = ctypes.POINTER(BNUndoEntry)


class BNUpdateChannel(ctypes.Structure):
	@property
	def name(self):
		return pyNativeStr(self._name)
	@name.setter
	def name(self, value):
		self._name = cstr(value)
	@property
	def description(self):
		return pyNativeStr(self._description)
	@description.setter
	def description(self, value):
		self._description = cstr(value)
	@property
	def latestVersion(self):
		return pyNativeStr(self._latestVersion)
	@latestVersion.setter
	def latestVersion(self, value):
		self._latestVersion = cstr(value)


BNUpdateChannelHandle = ctypes.POINTER(BNUpdateChannel)


class BNUpdateChannelFullInfo(ctypes.Structure):
	@property
	def name(self):
		return pyNativeStr(self._name)
	@name.setter
	def name(self, value):
		self._name = cstr(value)
	@property
	def desc(self):
		return pyNativeStr(self._desc)
	@desc.setter
	def desc(self, value):
		self._desc = cstr(value)
	@property
	def latestVersion(self):
		return pyNativeStr(self._latestVersion)
	@latestVersion.setter
	def latestVersion(self, value):
		self._latestVersion = cstr(value)


BNUpdateChannelFullInfoHandle = ctypes.POINTER(BNUpdateChannelFullInfo)


UpdateResultEnum = ctypes.c_int
class BNUpdateVersion(ctypes.Structure):
	@property
	def version(self):
		return pyNativeStr(self._version)
	@version.setter
	def version(self, value):
		self._version = cstr(value)
	@property
	def notes(self):
		return pyNativeStr(self._notes)
	@notes.setter
	def notes(self, value):
		self._notes = cstr(value)


BNUpdateVersionHandle = ctypes.POINTER(BNUpdateVersion)


class BNUpdateVersionNew(ctypes.Structure):
	@property
	def name(self):
		return pyNativeStr(self._name)
	@name.setter
	def name(self, value):
		self._name = cstr(value)


BNUpdateVersionNewHandle = ctypes.POINTER(BNUpdateVersionNew)


class BNUser(ctypes.Structure):
	pass


BNUserHandle = ctypes.POINTER(BNUser)


class BNUserVariableValue(ctypes.Structure):
	pass


BNUserVariableValueHandle = ctypes.POINTER(BNUserVariableValue)


class BNValueRange(ctypes.Structure):
	pass


BNValueRangeHandle = ctypes.POINTER(BNValueRange)


class BNVariable(ctypes.Structure):
	pass


BNVariableHandle = ctypes.POINTER(BNVariable)


class BNVariableNameAndType(ctypes.Structure):
	@property
	def name(self):
		return pyNativeStr(self._name)
	@name.setter
	def name(self, value):
		self._name = cstr(value)


BNVariableNameAndTypeHandle = ctypes.POINTER(BNVariableNameAndType)


class BNVariableReferenceSource(ctypes.Structure):
	pass


BNVariableReferenceSourceHandle = ctypes.POINTER(BNVariableReferenceSource)


VariableSourceTypeEnum = ctypes.c_int
class BNVersionInfo(ctypes.Structure):
	@property
	def channel(self):
		return pyNativeStr(self._channel)
	@channel.setter
	def channel(self, value):
		self._channel = cstr(value)


BNVersionInfoHandle = ctypes.POINTER(BNVersionInfo)


class BNWebsocketClient(ctypes.Structure):
	pass


BNWebsocketClientHandle = ctypes.POINTER(BNWebsocketClient)


class BNWebsocketClientCallbacks(ctypes.Structure):
	pass


BNWebsocketClientCallbacksHandle = ctypes.POINTER(BNWebsocketClientCallbacks)


class BNWebsocketClientOutputCallbacks(ctypes.Structure):
	pass


BNWebsocketClientOutputCallbacksHandle = ctypes.POINTER(BNWebsocketClientOutputCallbacks)


class BNWebsocketProvider(ctypes.Structure):
	pass


BNWebsocketProviderHandle = ctypes.POINTER(BNWebsocketProvider)


class BNWebsocketProviderCallbacks(ctypes.Structure):
	pass


BNWebsocketProviderCallbacksHandle = ctypes.POINTER(BNWebsocketProviderCallbacks)


class BNWorkflow(ctypes.Structure):
	pass


BNWorkflowHandle = ctypes.POINTER(BNWorkflow)


PluginLoadStatusEnum = ctypes.c_int

# Structure definitions
BNActiveAnalysisInfo._fields_ = [
		("func", ctypes.POINTER(BNFunction)),
		("analysisTime", ctypes.c_ulonglong),
		("updateCount", ctypes.c_ulonglong),
		("submitCount", ctypes.c_ulonglong),
	]
BNAddressRange._fields_ = [
		("start", ctypes.c_ulonglong),
		("end", ctypes.c_ulonglong),
	]
BNAnalysisInfo._fields_ = [
		("state", AnalysisStateEnum),
		("analysisTime", ctypes.c_ulonglong),
		("activeInfo", ctypes.POINTER(BNActiveAnalysisInfo)),
		("count", ctypes.c_ulonglong),
	]
BNAnalysisParameters._fields_ = [
		("maxAnalysisTime", ctypes.c_ulonglong),
		("maxFunctionSize", ctypes.c_ulonglong),
		("maxFunctionAnalysisTime", ctypes.c_ulonglong),
		("maxFunctionUpdateCount", ctypes.c_ulonglong),
		("maxFunctionSubmitCount", ctypes.c_ulonglong),
		("suppressNewAutoFunctionAnalysis", ctypes.c_bool),
		("mode", AnalysisModeEnum),
		("alwaysAnalyzeIndirectBranches", ctypes.c_bool),
		("advancedAnalysisCacheSize", ctypes.c_ulonglong),
	]
BNAnalysisProgress._fields_ = [
		("state", AnalysisStateEnum),
		("count", ctypes.c_ulonglong),
		("total", ctypes.c_ulonglong),
	]
BNArchitectureAndAddress._fields_ = [
		("arch", ctypes.POINTER(BNArchitecture)),
		("address", ctypes.c_ulonglong),
	]
BNBaseStructure._fields_ = [
		("type", ctypes.POINTER(BNNamedTypeReference)),
		("offset", ctypes.c_ulonglong),
		("width", ctypes.c_ulonglong),
	]
BNBasicBlockEdge._fields_ = [
		("type", BranchTypeEnum),
		("target", ctypes.POINTER(BNBasicBlock)),
		("backEdge", ctypes.c_bool),
		("fallThrough", ctypes.c_bool),
	]
BNBinaryDataNotification._fields_ = [
		("context", ctypes.c_void_p),
		("notificationBarrier", ctypes.CFUNCTYPE(ctypes.c_ulonglong, ctypes.c_void_p, ctypes.POINTER(BNBinaryView))),
		("dataWritten", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.c_ulonglong, ctypes.c_ulonglong)),
		("dataInserted", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.c_ulonglong, ctypes.c_ulonglong)),
		("dataRemoved", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.c_ulonglong, ctypes.c_ulonglong)),
		("functionAdded", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNFunction))),
		("functionRemoved", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNFunction))),
		("functionUpdated", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNFunction))),
		("functionUpdateRequested", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNFunction))),
		("dataVariableAdded", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNDataVariable))),
		("dataVariableRemoved", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNDataVariable))),
		("dataVariableUpdated", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNDataVariable))),
		("dataMetadataUpdated", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.c_ulonglong)),
		("tagTypeUpdated", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNTagType))),
		("tagAdded", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNTagReference))),
		("tagRemoved", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNTagReference))),
		("tagUpdated", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNTagReference))),
		("symbolAdded", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNSymbol))),
		("symbolRemoved", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNSymbol))),
		("symbolUpdated", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNSymbol))),
		("stringFound", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), StringTypeEnum, ctypes.c_ulonglong, ctypes.c_ulonglong)),
		("stringRemoved", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), StringTypeEnum, ctypes.c_ulonglong, ctypes.c_ulonglong)),
		("typeDefined", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNQualifiedName), ctypes.POINTER(BNType))),
		("typeUndefined", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNQualifiedName), ctypes.POINTER(BNType))),
		("typeReferenceChanged", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNQualifiedName), ctypes.POINTER(BNType))),
		("typeFieldReferenceChanged", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNQualifiedName), ctypes.c_ulonglong)),
		("segmentAdded", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNSegment))),
		("segmentRemoved", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNSegment))),
		("segmentUpdated", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNSegment))),
		("sectionAdded", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNSection))),
		("sectionRemoved", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNSection))),
		("sectionUpdated", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNSection))),
		("componentNameUpdated", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.c_char_p, ctypes.POINTER(BNComponent))),
		("componentAdded", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNComponent))),
		("componentMoved", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNComponent), ctypes.POINTER(BNComponent), ctypes.POINTER(BNComponent))),
		("componentRemoved", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNComponent), ctypes.POINTER(BNComponent))),
		("componentFunctionAdded", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNComponent), ctypes.POINTER(BNFunction))),
		("componentFunctionRemoved", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNComponent), ctypes.POINTER(BNFunction))),
		("componentDataVariableAdded", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNComponent), ctypes.POINTER(BNDataVariable))),
		("componentDataVariableRemoved", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNComponent), ctypes.POINTER(BNDataVariable))),
		("externalLibraryAdded", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNExternalLibrary))),
		("externalLibraryUpdated", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNExternalLibrary))),
		("externalLibraryRemoved", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNExternalLibrary))),
		("externalLocationAdded", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNExternalLocation))),
		("externalLocationUpdated", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNExternalLocation))),
		("externalLocationRemoved", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNExternalLocation))),
		("typeArchiveAttached", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.c_char_p, ctypes.c_char_p)),
		("typeArchiveDetached", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.c_char_p, ctypes.c_char_p)),
		("typeArchiveConnected", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNTypeArchive))),
		("typeArchiveDisconnected", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNTypeArchive))),
	]
BNBinaryViewEvent._fields_ = [
		("type", BinaryViewEventTypeEnum),
		("callback", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView))),
		("ctx", ctypes.c_void_p),
	]
BNBoolWithConfidence._fields_ = [
		("value", ctypes.c_bool),
		("confidence", ctypes.c_ubyte),
	]
BNCallingConventionWithConfidence._fields_ = [
		("convention", ctypes.POINTER(BNCallingConvention)),
		("confidence", ctypes.c_ubyte),
	]
BNConstantReference._fields_ = [
		("value", ctypes.c_longlong),
		("size", ctypes.c_ulonglong),
		("pointer", ctypes.c_bool),
		("intermediate", ctypes.c_bool),
	]
BNCustomArchitecture._fields_ = [
		("context", ctypes.c_void_p),
		("init", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNArchitecture))),
		("getEndianness", ctypes.CFUNCTYPE(EndiannessEnum, ctypes.c_void_p)),
		("getAddressSize", ctypes.CFUNCTYPE(ctypes.c_ulonglong, ctypes.c_void_p)),
		("getDefaultIntegerSize", ctypes.CFUNCTYPE(ctypes.c_ulonglong, ctypes.c_void_p)),
		("getInstructionAlignment", ctypes.CFUNCTYPE(ctypes.c_ulonglong, ctypes.c_void_p)),
		("getMaxInstructionLength", ctypes.CFUNCTYPE(ctypes.c_ulonglong, ctypes.c_void_p)),
		("getOpcodeDisplayLength", ctypes.CFUNCTYPE(ctypes.c_ulonglong, ctypes.c_void_p)),
		("getAssociatedArchitectureByAddress", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.POINTER(ctypes.c_ulonglong))),
		("getInstructionInfo", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(ctypes.c_ubyte), ctypes.c_ulonglong, ctypes.c_ulonglong, ctypes.POINTER(BNInstructionInfo))),
		("getInstructionText", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(ctypes.c_ubyte), ctypes.c_ulonglong, ctypes.POINTER(ctypes.c_ulonglong), ctypes.POINTER(ctypes.POINTER(BNInstructionTextToken)), ctypes.POINTER(ctypes.c_ulonglong))),
		("freeInstructionText", ctypes.CFUNCTYPE(None, ctypes.POINTER(BNInstructionTextToken), ctypes.c_ulonglong)),
		("getInstructionLowLevelIL", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(ctypes.c_ubyte), ctypes.c_ulonglong, ctypes.POINTER(ctypes.c_ulonglong), ctypes.POINTER(BNLowLevelILFunction))),
		("getRegisterName", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.c_uint)),
		("getFlagName", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.c_uint)),
		("getFlagWriteTypeName", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.c_uint)),
		("getSemanticFlagClassName", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.c_uint)),
		("getSemanticFlagGroupName", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.c_uint)),
		("getFullWidthRegisters", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.POINTER(ctypes.c_ulonglong))),
		("getAllRegisters", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.POINTER(ctypes.c_ulonglong))),
		("getAllFlags", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.POINTER(ctypes.c_ulonglong))),
		("getAllFlagWriteTypes", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.POINTER(ctypes.c_ulonglong))),
		("getAllSemanticFlagClasses", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.POINTER(ctypes.c_ulonglong))),
		("getAllSemanticFlagGroups", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.POINTER(ctypes.c_ulonglong))),
		("getFlagRole", ctypes.CFUNCTYPE(FlagRoleEnum, ctypes.c_void_p, ctypes.c_uint, ctypes.c_uint)),
		("getFlagsRequiredForFlagCondition", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, LowLevelILFlagConditionEnum, ctypes.c_uint, ctypes.POINTER(ctypes.c_ulonglong))),
		("getFlagsRequiredForSemanticFlagGroup", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.c_uint, ctypes.POINTER(ctypes.c_ulonglong))),
		("getFlagConditionsForSemanticFlagGroup", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.c_uint, ctypes.POINTER(ctypes.c_ulonglong))),
		("freeFlagConditionsForSemanticFlagGroup", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNFlagConditionForSemanticClass))),
		("getFlagsWrittenByFlagWriteType", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.c_uint, ctypes.POINTER(ctypes.c_ulonglong))),
		("getSemanticClassForFlagWriteType", ctypes.CFUNCTYPE(ctypes.c_uint, ctypes.c_void_p, ctypes.c_uint)),
		("getFlagWriteLowLevelIL", ctypes.CFUNCTYPE(ctypes.c_ulonglong, ctypes.c_void_p, LowLevelILOperationEnum, ctypes.c_ulonglong, ctypes.c_uint, ctypes.c_uint, ctypes.POINTER(BNRegisterOrConstant), ctypes.c_ulonglong, ctypes.POINTER(BNLowLevelILFunction))),
		("getFlagConditionLowLevelIL", ctypes.CFUNCTYPE(ctypes.c_ulonglong, ctypes.c_void_p, LowLevelILFlagConditionEnum, ctypes.c_uint, ctypes.POINTER(BNLowLevelILFunction))),
		("getSemanticFlagGroupLowLevelIL", ctypes.CFUNCTYPE(ctypes.c_ulonglong, ctypes.c_void_p, ctypes.c_uint, ctypes.POINTER(BNLowLevelILFunction))),
		("freeRegisterList", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(ctypes.c_uint))),
		("getRegisterInfo", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.c_uint, ctypes.POINTER(BNRegisterInfo))),
		("getStackPointerRegister", ctypes.CFUNCTYPE(ctypes.c_uint, ctypes.c_void_p)),
		("getLinkRegister", ctypes.CFUNCTYPE(ctypes.c_uint, ctypes.c_void_p)),
		("getGlobalRegisters", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.POINTER(ctypes.c_ulonglong))),
		("getSystemRegisters", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.POINTER(ctypes.c_ulonglong))),
		("getRegisterStackName", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.c_uint)),
		("getAllRegisterStacks", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.POINTER(ctypes.c_ulonglong))),
		("getRegisterStackInfo", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.c_uint, ctypes.POINTER(BNRegisterStackInfo))),
		("getIntrinsicClass", ctypes.CFUNCTYPE(IntrinsicClassEnum, ctypes.c_void_p, ctypes.c_uint)),
		("getIntrinsicName", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.c_uint)),
		("getAllIntrinsics", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.POINTER(ctypes.c_ulonglong))),
		("getIntrinsicInputs", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.c_uint, ctypes.POINTER(ctypes.c_ulonglong))),
		("freeNameAndTypeList", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNNameAndType), ctypes.c_ulonglong)),
		("getIntrinsicOutputs", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.c_uint, ctypes.POINTER(ctypes.c_ulonglong))),
		("freeTypeList", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNTypeWithConfidence), ctypes.c_ulonglong)),
		("canAssemble", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p)),
		("assemble", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_char_p, ctypes.c_ulonglong, ctypes.POINTER(BNDataBuffer), ctypes.POINTER(ctypes.c_char_p))),
		("isNeverBranchPatchAvailable", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(ctypes.c_ubyte), ctypes.c_ulonglong, ctypes.c_ulonglong)),
		("isAlwaysBranchPatchAvailable", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(ctypes.c_ubyte), ctypes.c_ulonglong, ctypes.c_ulonglong)),
		("isInvertBranchPatchAvailable", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(ctypes.c_ubyte), ctypes.c_ulonglong, ctypes.c_ulonglong)),
		("isSkipAndReturnZeroPatchAvailable", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(ctypes.c_ubyte), ctypes.c_ulonglong, ctypes.c_ulonglong)),
		("isSkipAndReturnValuePatchAvailable", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(ctypes.c_ubyte), ctypes.c_ulonglong, ctypes.c_ulonglong)),
		("convertToNop", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(ctypes.c_ubyte), ctypes.c_ulonglong, ctypes.c_ulonglong)),
		("alwaysBranch", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(ctypes.c_ubyte), ctypes.c_ulonglong, ctypes.c_ulonglong)),
		("invertBranch", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(ctypes.c_ubyte), ctypes.c_ulonglong, ctypes.c_ulonglong)),
		("skipAndReturnValue", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(ctypes.c_ubyte), ctypes.c_ulonglong, ctypes.c_ulonglong, ctypes.c_ulonglong)),
	]
BNCustomBinaryView._fields_ = [
		("context", ctypes.c_void_p),
		("init", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p)),
		("freeObject", ctypes.CFUNCTYPE(None, ctypes.c_void_p)),
		("externalRefTaken", ctypes.CFUNCTYPE(None, ctypes.c_void_p)),
		("externalRefReleased", ctypes.CFUNCTYPE(None, ctypes.c_void_p)),
		("read", ctypes.CFUNCTYPE(ctypes.c_ulonglong, ctypes.c_void_p, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong)),
		("write", ctypes.CFUNCTYPE(ctypes.c_ulonglong, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_void_p, ctypes.c_ulonglong)),
		("insert", ctypes.CFUNCTYPE(ctypes.c_ulonglong, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_void_p, ctypes.c_ulonglong)),
		("remove", ctypes.CFUNCTYPE(ctypes.c_ulonglong, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong)),
		("getModification", ctypes.CFUNCTYPE(ModificationStatusEnum, ctypes.c_void_p, ctypes.c_ulonglong)),
		("isValidOffset", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong)),
		("isOffsetReadable", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong)),
		("isOffsetWritable", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong)),
		("isOffsetExecutable", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong)),
		("isOffsetBackedByFile", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong)),
		("getNextValidOffset", ctypes.CFUNCTYPE(ctypes.c_ulonglong, ctypes.c_void_p, ctypes.c_ulonglong)),
		("getStart", ctypes.CFUNCTYPE(ctypes.c_ulonglong, ctypes.c_void_p)),
		("getLength", ctypes.CFUNCTYPE(ctypes.c_ulonglong, ctypes.c_void_p)),
		("getEntryPoint", ctypes.CFUNCTYPE(ctypes.c_ulonglong, ctypes.c_void_p)),
		("isExecutable", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p)),
		("getDefaultEndianness", ctypes.CFUNCTYPE(EndiannessEnum, ctypes.c_void_p)),
		("isRelocatable", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p)),
		("getAddressSize", ctypes.CFUNCTYPE(ctypes.c_ulonglong, ctypes.c_void_p)),
		("save", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNFileAccessor))),
	]
BNCustomBinaryViewType._fields_ = [
		("context", ctypes.c_void_p),
		("create", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.POINTER(BNBinaryView))),
		("parse", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.POINTER(BNBinaryView))),
		("isValidForData", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNBinaryView))),
		("isDeprecated", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p)),
		("getLoadSettingsForData", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.POINTER(BNBinaryView))),
	]
BNCustomCallingConvention._fields_ = [
		("context", ctypes.c_void_p),
		("freeObject", ctypes.CFUNCTYPE(None, ctypes.c_void_p)),
		("getCallerSavedRegisters", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.POINTER(ctypes.c_ulonglong))),
		("getCalleeSavedRegisters", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.POINTER(ctypes.c_ulonglong))),
		("getIntegerArgumentRegisters", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.POINTER(ctypes.c_ulonglong))),
		("getFloatArgumentRegisters", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.POINTER(ctypes.c_ulonglong))),
		("freeRegisterList", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(ctypes.c_uint))),
		("areArgumentRegistersSharedIndex", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p)),
		("isStackReservedForArgumentRegisters", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p)),
		("isStackAdjustedOnReturn", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p)),
		("isEligibleForHeuristics", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p)),
		("getIntegerReturnValueRegister", ctypes.CFUNCTYPE(ctypes.c_uint, ctypes.c_void_p)),
		("getHighIntegerReturnValueRegister", ctypes.CFUNCTYPE(ctypes.c_uint, ctypes.c_void_p)),
		("getFloatReturnValueRegister", ctypes.CFUNCTYPE(ctypes.c_uint, ctypes.c_void_p)),
		("getGlobalPointerRegister", ctypes.CFUNCTYPE(ctypes.c_uint, ctypes.c_void_p)),
		("getImplicitlyDefinedRegisters", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.POINTER(ctypes.c_ulonglong))),
		("getIncomingRegisterValue", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.c_uint, ctypes.POINTER(BNFunction), ctypes.POINTER(BNRegisterValue))),
		("getIncomingFlagValue", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.c_uint, ctypes.POINTER(BNFunction), ctypes.POINTER(BNRegisterValue))),
		("getIncomingVariableForParameterVariable", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNVariable), ctypes.POINTER(BNFunction), ctypes.POINTER(BNVariable))),
		("getParameterVariableForIncomingVariable", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNVariable), ctypes.POINTER(BNFunction), ctypes.POINTER(BNVariable))),
		("areArgumentRegistersUsedForVarArgs", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p)),
	]
BNCustomDataRenderer._fields_ = [
		("context", ctypes.c_void_p),
		("freeObject", ctypes.CFUNCTYPE(None, ctypes.c_void_p)),
		("isValidForData", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.c_ulonglong, ctypes.POINTER(BNType), ctypes.POINTER(BNTypeContext), ctypes.c_ulonglong)),
		("getLinesForData", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.c_ulonglong, ctypes.POINTER(BNType), ctypes.POINTER(BNInstructionTextToken), ctypes.c_ulonglong, ctypes.c_ulonglong, ctypes.POINTER(ctypes.c_ulonglong), ctypes.POINTER(BNTypeContext), ctypes.c_ulonglong)),
		("freeLines", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNDisassemblyTextLine), ctypes.c_ulonglong)),
	]
BNCustomFlowGraph._fields_ = [
		("context", ctypes.c_void_p),
		("prepareForLayout", ctypes.CFUNCTYPE(None, ctypes.c_void_p)),
		("populateNodes", ctypes.CFUNCTYPE(None, ctypes.c_void_p)),
		("completeLayout", ctypes.CFUNCTYPE(None, ctypes.c_void_p)),
		("update", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p)),
		("freeObject", ctypes.CFUNCTYPE(None, ctypes.c_void_p)),
		("externalRefTaken", ctypes.CFUNCTYPE(None, ctypes.c_void_p)),
		("externalRefReleased", ctypes.CFUNCTYPE(None, ctypes.c_void_p)),
	]
BNCustomRelocationHandler._fields_ = [
		("context", ctypes.c_void_p),
		("freeObject", ctypes.CFUNCTYPE(None, ctypes.c_void_p)),
		("getRelocationInfo", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNArchitecture), ctypes.POINTER(BNRelocationInfo), ctypes.c_ulonglong)),
		("applyRelocation", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNArchitecture), ctypes.POINTER(BNRelocation), ctypes.POINTER(ctypes.c_ubyte), ctypes.c_ulonglong)),
		("getOperandForExternalRelocation", ctypes.CFUNCTYPE(ctypes.c_ulonglong, ctypes.c_void_p, ctypes.POINTER(ctypes.c_ubyte), ctypes.c_ulonglong, ctypes.c_ulonglong, ctypes.POINTER(BNLowLevelILFunction), ctypes.POINTER(BNRelocation))),
	]
BNCustomTransform._fields_ = [
		("context", ctypes.c_void_p),
		("getParameters", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.POINTER(ctypes.c_ulonglong))),
		("freeParameters", ctypes.CFUNCTYPE(None, ctypes.POINTER(BNTransformParameterInfo), ctypes.c_ulonglong)),
		("decode", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNDataBuffer), ctypes.POINTER(BNDataBuffer), ctypes.POINTER(BNTransformParameter), ctypes.c_ulonglong)),
		("encode", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNDataBuffer), ctypes.POINTER(BNDataBuffer), ctypes.POINTER(BNTransformParameter), ctypes.c_ulonglong)),
	]
BNDataVariable._fields_ = [
		("address", ctypes.c_ulonglong),
		("type", ctypes.POINTER(BNType)),
		("autoDiscovered", ctypes.c_bool),
		("typeConfidence", ctypes.c_ubyte),
	]
BNDataVariableAndName._fields_ = [
		("address", ctypes.c_ulonglong),
		("type", ctypes.POINTER(BNType)),
		("_name", ctypes.c_char_p),
		("autoDiscovered", ctypes.c_bool),
		("typeConfidence", ctypes.c_ubyte),
	]
BNDataVariableAndNameAndDebugParser._fields_ = [
		("address", ctypes.c_ulonglong),
		("type", ctypes.POINTER(BNType)),
		("_name", ctypes.c_char_p),
		("_parser", ctypes.c_char_p),
		("autoDiscovered", ctypes.c_bool),
		("typeConfidence", ctypes.c_ubyte),
	]
BNDebugFunctionInfo._fields_ = [
		("_shortName", ctypes.c_char_p),
		("_fullName", ctypes.c_char_p),
		("_rawName", ctypes.c_char_p),
		("address", ctypes.c_ulonglong),
		("type", ctypes.POINTER(BNType)),
		("platform", ctypes.POINTER(BNPlatform)),
		("components", ctypes.POINTER(ctypes.c_char_p)),
		("componentN", ctypes.c_ulonglong),
	]
BNDisassemblyTextLineTypeInfo._fields_ = [
		("hasTypeInfo", ctypes.c_bool),
		("parentType", ctypes.POINTER(BNType)),
		("fieldIndex", ctypes.c_ulonglong),
		("offset", ctypes.c_ulonglong),
	]
BNDownloadInstanceCallbacks._fields_ = [
		("context", ctypes.c_void_p),
		("destroyInstance", ctypes.CFUNCTYPE(None, ctypes.c_void_p)),
		("performRequest", ctypes.CFUNCTYPE(ctypes.c_int, ctypes.c_void_p, ctypes.c_char_p)),
		("performCustomRequest", ctypes.CFUNCTYPE(ctypes.c_int, ctypes.c_void_p, ctypes.c_char_p, ctypes.c_char_p, ctypes.c_ulonglong, ctypes.POINTER(ctypes.c_char_p), ctypes.POINTER(ctypes.c_char_p), ctypes.POINTER(ctypes.POINTER(BNDownloadInstanceResponse)))),
		("freeResponse", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNDownloadInstanceResponse))),
	]
BNDownloadInstanceInputOutputCallbacks._fields_ = [
		("readCallback", ctypes.CFUNCTYPE(ctypes.c_longlong, ctypes.POINTER(ctypes.c_ubyte), ctypes.c_ulonglong, ctypes.c_void_p)),
		("readContext", ctypes.c_void_p),
		("writeCallback", ctypes.CFUNCTYPE(ctypes.c_ulonglong, ctypes.POINTER(ctypes.c_ubyte), ctypes.c_ulonglong, ctypes.c_void_p)),
		("writeContext", ctypes.c_void_p),
		("progressCallback", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong)),
		("progressContext", ctypes.c_void_p),
	]
BNDownloadInstanceOutputCallbacks._fields_ = [
		("writeCallback", ctypes.CFUNCTYPE(ctypes.c_ulonglong, ctypes.POINTER(ctypes.c_ubyte), ctypes.c_ulonglong, ctypes.c_void_p)),
		("writeContext", ctypes.c_void_p),
		("progressCallback", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong)),
		("progressContext", ctypes.c_void_p),
	]
BNDownloadInstanceResponse._fields_ = [
		("statusCode", ctypes.c_ushort),
		("headerCount", ctypes.c_ulonglong),
		("headerKeys", ctypes.POINTER(ctypes.c_char_p)),
		("headerValues", ctypes.POINTER(ctypes.c_char_p)),
	]
BNDownloadProviderCallbacks._fields_ = [
		("context", ctypes.c_void_p),
		("createInstance", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p)),
	]
BNEdgeStyle._fields_ = [
		("style", EdgePenStyleEnum),
		("width", ctypes.c_ulonglong),
		("color", ThemeColorEnum),
	]
BNEnterpriseServerCallbacks._fields_ = [
		("context", ctypes.c_void_p),
		("licenseStatusChanged", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.c_bool)),
	]
BNEnumerationMember._fields_ = [
		("_name", ctypes.c_char_p),
		("value", ctypes.c_ulonglong),
		("isDefault", ctypes.c_bool),
	]
BNFileAccessor._fields_ = [
		("context", ctypes.c_void_p),
		("getLength", ctypes.CFUNCTYPE(ctypes.c_ulonglong, ctypes.c_void_p)),
		("read", ctypes.CFUNCTYPE(ctypes.c_ulonglong, ctypes.c_void_p, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong)),
		("write", ctypes.CFUNCTYPE(ctypes.c_ulonglong, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_void_p, ctypes.c_ulonglong)),
	]
BNFlagConditionForSemanticClass._fields_ = [
		("semanticClass", ctypes.c_uint),
		("condition", LowLevelILFlagConditionEnum),
	]
BNFlowGraphEdge._fields_ = [
		("type", BranchTypeEnum),
		("target", ctypes.POINTER(BNFlowGraphNode)),
		("points", ctypes.POINTER(BNPoint)),
		("pointCount", ctypes.c_ulonglong),
		("backEdge", ctypes.c_bool),
		("style", BNEdgeStyle),
	]
BNFormInputField._fields_ = [
		("type", FormInputFieldTypeEnum),
		("_prompt", ctypes.c_char_p),
		("view", ctypes.POINTER(BNBinaryView)),
		("currentAddress", ctypes.c_ulonglong),
		("choices", ctypes.POINTER(ctypes.c_char_p)),
		("count", ctypes.c_ulonglong),
		("_ext", ctypes.c_char_p),
		("_defaultName", ctypes.c_char_p),
		("intResult", ctypes.c_longlong),
		("addressResult", ctypes.c_ulonglong),
		("_stringResult", ctypes.c_char_p),
		("indexResult", ctypes.c_ulonglong),
		("hasDefault", ctypes.c_bool),
		("intDefault", ctypes.c_longlong),
		("addressDefault", ctypes.c_ulonglong),
		("_stringDefault", ctypes.c_char_p),
		("indexDefault", ctypes.c_ulonglong),
	]
BNFunctionRecognizer._fields_ = [
		("context", ctypes.c_void_p),
		("recognizeLowLevelIL", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNFunction), ctypes.POINTER(BNLowLevelILFunction))),
		("recognizeMediumLevelIL", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNFunction), ctypes.POINTER(BNMediumLevelILFunction))),
	]
BNHighLevelILInstruction._fields_ = [
		("operation", HighLevelILOperationEnum),
		("attributes", ctypes.c_uint),
		("sourceOperand", ctypes.c_uint),
		("size", ctypes.c_ulonglong),
		("operands", ctypes.c_ulonglong * 5),
		("address", ctypes.c_ulonglong),
		("parent", ctypes.c_ulonglong),
	]
BNHighlightColor._fields_ = [
		("style", HighlightColorStyleEnum),
		("color", HighlightStandardColorEnum),
		("mixColor", HighlightStandardColorEnum),
		("mix", ctypes.c_ubyte),
		("r", ctypes.c_ubyte),
		("g", ctypes.c_ubyte),
		("b", ctypes.c_ubyte),
		("alpha", ctypes.c_ubyte),
	]
BNILBranchInstructionAndDependence._fields_ = [
		("branch", ctypes.c_ulonglong),
		("dependence", ILBranchDependenceEnum),
	]
BNILIndexRange._fields_ = [
		("start", ctypes.c_ulonglong),
		("end", ctypes.c_ulonglong),
	]
BNILReferenceSource._fields_ = [
		("func", ctypes.POINTER(BNFunction)),
		("arch", ctypes.POINTER(BNArchitecture)),
		("addr", ctypes.c_ulonglong),
		("type", FunctionGraphTypeEnum),
		("exprId", ctypes.c_ulonglong),
	]
BNIndirectBranchInfo._fields_ = [
		("sourceArch", ctypes.POINTER(BNArchitecture)),
		("sourceAddr", ctypes.c_ulonglong),
		("destArch", ctypes.POINTER(BNArchitecture)),
		("destAddr", ctypes.c_ulonglong),
		("autoDefined", ctypes.c_bool),
	]
BNInstructionInfo._fields_ = [
		("length", ctypes.c_ulonglong),
		("branchCount", ctypes.c_ulonglong),
		("archTransitionByTargetAddr", ctypes.c_bool),
		("branchDelay", ctypes.c_bool),
		("branchType", BranchTypeEnum * 3),
		("branchTarget", ctypes.c_ulonglong * 3),
		("branchArch", ctypes.POINTER(BNArchitecture) * 3),
	]
BNInstructionTextLine._fields_ = [
		("tokens", ctypes.POINTER(BNInstructionTextToken)),
		("count", ctypes.c_ulonglong),
	]
BNInstructionTextToken._fields_ = [
		("type", InstructionTextTokenTypeEnum),
		("_text", ctypes.c_char_p),
		("value", ctypes.c_ulonglong),
		("width", ctypes.c_ulonglong),
		("size", ctypes.c_ulonglong),
		("operand", ctypes.c_ulonglong),
		("context", InstructionTextTokenContextEnum),
		("confidence", ctypes.c_ubyte),
		("address", ctypes.c_ulonglong),
		("typeNames", ctypes.POINTER(ctypes.c_char_p)),
		("namesCount", ctypes.c_ulonglong),
		("exprIndex", ctypes.c_ulonglong),
	]
BNInteractionHandlerCallbacks._fields_ = [
		("context", ctypes.c_void_p),
		("showPlainTextReport", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.c_char_p, ctypes.c_char_p)),
		("showMarkdownReport", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.c_char_p, ctypes.c_char_p, ctypes.c_char_p)),
		("showHTMLReport", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.c_char_p, ctypes.c_char_p, ctypes.c_char_p)),
		("showGraphReport", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.c_char_p, ctypes.POINTER(BNFlowGraph))),
		("showReportCollection", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.c_char_p, ctypes.POINTER(BNReportCollection))),
		("getTextLineInput", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(ctypes.c_char_p), ctypes.c_char_p, ctypes.c_char_p)),
		("getIntegerInput", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(ctypes.c_longlong), ctypes.c_char_p, ctypes.c_char_p)),
		("getAddressInput", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(ctypes.c_ulonglong), ctypes.c_char_p, ctypes.c_char_p, ctypes.POINTER(BNBinaryView), ctypes.c_ulonglong)),
		("getChoiceInput", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(ctypes.c_ulonglong), ctypes.c_char_p, ctypes.c_char_p, ctypes.POINTER(ctypes.c_char_p), ctypes.c_ulonglong)),
		("getLargeChoiceInput", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(ctypes.c_ulonglong), ctypes.c_char_p, ctypes.c_char_p, ctypes.POINTER(ctypes.c_char_p), ctypes.c_ulonglong)),
		("getOpenFileNameInput", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(ctypes.c_char_p), ctypes.c_char_p, ctypes.c_char_p)),
		("getSaveFileNameInput", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(ctypes.c_char_p), ctypes.c_char_p, ctypes.c_char_p, ctypes.c_char_p)),
		("getDirectoryNameInput", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(ctypes.c_char_p), ctypes.c_char_p, ctypes.c_char_p)),
		("getFormInput", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNFormInputField), ctypes.c_ulonglong, ctypes.c_char_p)),
		("showMessageBox", ctypes.CFUNCTYPE(MessageBoxButtonResultEnum, ctypes.c_void_p, ctypes.c_char_p, ctypes.c_char_p, MessageBoxButtonSetEnum, MessageBoxIconEnum)),
		("openUrl", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_char_p)),
		("runProgressDialog", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_char_p, ctypes.c_bool, ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong), ctypes.c_void_p), ctypes.c_void_p)),
	]
BNLinearViewObjectIdentifier._fields_ = [
		("_name", ctypes.c_char_p),
		("type", LinearViewObjectIdentifierTypeEnum),
		("start", ctypes.c_ulonglong),
		("end", ctypes.c_ulonglong),
	]
BNLogListener._fields_ = [
		("context", ctypes.c_void_p),
		("log", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.c_ulonglong, LogLevelEnum, ctypes.c_char_p, ctypes.c_char_p, ctypes.c_ulonglong)),
		("close", ctypes.CFUNCTYPE(None, ctypes.c_void_p)),
		("getLogLevel", ctypes.CFUNCTYPE(LogLevelEnum, ctypes.c_void_p)),
	]
BNLookupTableEntry._fields_ = [
		("fromValues", ctypes.POINTER(ctypes.c_longlong)),
		("fromCount", ctypes.c_ulonglong),
		("toValue", ctypes.c_longlong),
	]
BNLowLevelILInstruction._fields_ = [
		("operation", LowLevelILOperationEnum),
		("attributes", ctypes.c_uint),
		("size", ctypes.c_ulonglong),
		("flags", ctypes.c_uint),
		("sourceOperand", ctypes.c_uint),
		("operands", ctypes.c_ulonglong * 4),
		("address", ctypes.c_ulonglong),
	]
BNLowLevelILLabel._fields_ = [
		("resolved", ctypes.c_bool),
		("ref", ctypes.c_ulonglong),
		("operand", ctypes.c_ulonglong),
	]
BNMainThreadCallbacks._fields_ = [
		("context", ctypes.c_void_p),
		("addAction", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNMainThreadAction))),
	]
BNMediumLevelILInstruction._fields_ = [
		("operation", MediumLevelILOperationEnum),
		("attributes", ctypes.c_uint),
		("sourceOperand", ctypes.c_uint),
		("size", ctypes.c_ulonglong),
		("operands", ctypes.c_ulonglong * 5),
		("address", ctypes.c_ulonglong),
	]
BNMediumLevelILLabel._fields_ = [
		("resolved", ctypes.c_bool),
		("ref", ctypes.c_ulonglong),
		("operand", ctypes.c_ulonglong),
	]
BNMemoryUsageInfo._fields_ = [
		("_name", ctypes.c_char_p),
		("value", ctypes.c_ulonglong),
	]
BNMetadataValueStore._fields_ = [
		("size", ctypes.c_ulonglong),
		("keys", ctypes.POINTER(ctypes.c_char_p)),
		("values", ctypes.POINTER(ctypes.POINTER(BNMetadata))),
	]
BNNameAndType._fields_ = [
		("_name", ctypes.c_char_p),
		("type", ctypes.POINTER(BNType)),
		("typeConfidence", ctypes.c_ubyte),
	]
BNNameList._fields_ = [
		("name", ctypes.POINTER(ctypes.c_char_p)),
		("_join", ctypes.c_char_p),
		("nameCount", ctypes.c_ulonglong),
	]
BNNameSpace._fields_ = [
		("name", ctypes.POINTER(ctypes.c_char_p)),
		("_join", ctypes.c_char_p),
		("nameCount", ctypes.c_ulonglong),
	]
BNNavigationHandler._fields_ = [
		("context", ctypes.c_void_p),
		("getCurrentView", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p)),
		("getCurrentOffset", ctypes.CFUNCTYPE(ctypes.c_ulonglong, ctypes.c_void_p)),
		("navigate", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_char_p, ctypes.c_ulonglong)),
	]
BNObjectDestructionCallbacks._fields_ = [
		("context", ctypes.c_void_p),
		("destructBinaryView", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView))),
		("destructFileMetadata", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNFileMetadata))),
		("destructFunction", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNFunction))),
	]
BNOffsetWithConfidence._fields_ = [
		("value", ctypes.c_longlong),
		("confidence", ctypes.c_ubyte),
	]
BNParameterVariablesWithConfidence._fields_ = [
		("vars", ctypes.POINTER(BNVariable)),
		("count", ctypes.c_ulonglong),
		("confidence", ctypes.c_ubyte),
	]
BNPerformanceInfo._fields_ = [
		("_name", ctypes.c_char_p),
		("seconds", ctypes.c_double),
	]
BNPluginCommand._fields_ = [
		("_name", ctypes.c_char_p),
		("_description", ctypes.c_char_p),
		("type", PluginCommandTypeEnum),
		("context", ctypes.c_void_p),
		("defaultCommand", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView))),
		("addressCommand", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.c_ulonglong)),
		("rangeCommand", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.c_ulonglong, ctypes.c_ulonglong)),
		("functionCommand", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNFunction))),
		("lowLevelILFunctionCommand", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNLowLevelILFunction))),
		("lowLevelILInstructionCommand", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNLowLevelILFunction), ctypes.c_ulonglong)),
		("mediumLevelILFunctionCommand", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNMediumLevelILFunction))),
		("mediumLevelILInstructionCommand", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNMediumLevelILFunction), ctypes.c_ulonglong)),
		("highLevelILFunctionCommand", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNHighLevelILFunction))),
		("highLevelILInstructionCommand", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNHighLevelILFunction), ctypes.c_ulonglong)),
		("defaultIsValid", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNBinaryView))),
		("addressIsValid", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.c_ulonglong)),
		("rangeIsValid", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.c_ulonglong, ctypes.c_ulonglong)),
		("functionIsValid", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNFunction))),
		("lowLevelILFunctionIsValid", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNLowLevelILFunction))),
		("lowLevelILInstructionIsValid", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNLowLevelILFunction), ctypes.c_ulonglong)),
		("mediumLevelILFunctionIsValid", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNMediumLevelILFunction))),
		("mediumLevelILInstructionIsValid", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNMediumLevelILFunction), ctypes.c_ulonglong)),
		("highLevelILFunctionIsValid", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNHighLevelILFunction))),
		("highLevelILInstructionIsValid", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNHighLevelILFunction), ctypes.c_ulonglong)),
	]
BNPoint._fields_ = [
		("x", ctypes.c_float),
		("y", ctypes.c_float),
	]
BNPossibleValueSet._fields_ = [
		("state", RegisterValueTypeEnum),
		("value", ctypes.c_longlong),
		("offset", ctypes.c_longlong),
		("size", ctypes.c_ulonglong),
		("ranges", ctypes.POINTER(BNValueRange)),
		("valueSet", ctypes.POINTER(ctypes.c_longlong)),
		("table", ctypes.POINTER(BNLookupTableEntry)),
		("count", ctypes.c_ulonglong),
	]
BNProjectNotification._fields_ = [
		("context", ctypes.c_void_p),
		("beforeOpenProject", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNProject))),
		("afterOpenProject", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNProject))),
		("beforeCloseProject", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNProject))),
		("afterCloseProject", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNProject))),
		("beforeProjectMetadataWritten", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNProject), ctypes.c_char_p, ctypes.POINTER(BNMetadata))),
		("afterProjectMetadataWritten", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNProject), ctypes.c_char_p, ctypes.POINTER(BNMetadata))),
		("beforeProjectFileCreated", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNProject), ctypes.POINTER(BNProjectFile))),
		("afterProjectFileCreated", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNProject), ctypes.POINTER(BNProjectFile))),
		("beforeProjectFileUpdated", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNProject), ctypes.POINTER(BNProjectFile))),
		("afterProjectFileUpdated", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNProject), ctypes.POINTER(BNProjectFile))),
		("beforeProjectFileDeleted", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNProject), ctypes.POINTER(BNProjectFile))),
		("afterProjectFileDeleted", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNProject), ctypes.POINTER(BNProjectFile))),
		("beforeProjectFolderCreated", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNProject), ctypes.POINTER(BNProjectFolder))),
		("afterProjectFolderCreated", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNProject), ctypes.POINTER(BNProjectFolder))),
		("beforeProjectFolderUpdated", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNProject), ctypes.POINTER(BNProjectFolder))),
		("afterProjectFolderUpdated", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNProject), ctypes.POINTER(BNProjectFolder))),
		("beforeProjectFolderDeleted", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNProject), ctypes.POINTER(BNProjectFolder))),
		("afterProjectFolderDeleted", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNProject), ctypes.POINTER(BNProjectFolder))),
	]
BNQualifiedName._fields_ = [
		("name", ctypes.POINTER(ctypes.c_char_p)),
		("_join", ctypes.c_char_p),
		("nameCount", ctypes.c_ulonglong),
	]
BNQualifiedNameAndType._fields_ = [
		("name", BNQualifiedName),
		("type", ctypes.POINTER(BNType)),
	]
BNQualifiedNameList._fields_ = [
		("names", ctypes.POINTER(BNQualifiedName)),
		("count", ctypes.c_ulonglong),
	]
BNQualifiedNameTypeAndId._fields_ = [
		("name", BNQualifiedName),
		("_id", ctypes.c_char_p),
		("type", ctypes.POINTER(BNType)),
	]
BNRange._fields_ = [
		("start", ctypes.c_ulonglong),
		("end", ctypes.c_ulonglong),
	]
BNReferenceSource._fields_ = [
		("func", ctypes.POINTER(BNFunction)),
		("arch", ctypes.POINTER(BNArchitecture)),
		("addr", ctypes.c_ulonglong),
	]
BNRegisterInfo._fields_ = [
		("fullWidthRegister", ctypes.c_uint),
		("offset", ctypes.c_ulonglong),
		("size", ctypes.c_ulonglong),
		("extend", ImplicitRegisterExtendEnum),
	]
BNRegisterOrConstant._fields_ = [
		("constant", ctypes.c_bool),
		("reg", ctypes.c_uint),
		("value", ctypes.c_ulonglong),
	]
BNRegisterSetWithConfidence._fields_ = [
		("regs", ctypes.POINTER(ctypes.c_uint)),
		("count", ctypes.c_ulonglong),
		("confidence", ctypes.c_ubyte),
	]
BNRegisterStackAdjustment._fields_ = [
		("regStack", ctypes.c_uint),
		("adjustment", ctypes.c_int),
		("confidence", ctypes.c_ubyte),
	]
BNRegisterStackInfo._fields_ = [
		("firstStorageReg", ctypes.c_uint),
		("firstTopRelativeReg", ctypes.c_uint),
		("storageCount", ctypes.c_uint),
		("topRelativeCount", ctypes.c_uint),
		("stackTopReg", ctypes.c_uint),
	]
BNRegisterValue._fields_ = [
		("state", RegisterValueTypeEnum),
		("value", ctypes.c_longlong),
		("offset", ctypes.c_longlong),
		("size", ctypes.c_ulonglong),
	]
BNRegisterValueWithConfidence._fields_ = [
		("value", BNRegisterValue),
		("confidence", ctypes.c_ubyte),
	]
BNRelocationInfo._fields_ = [
		("type", RelocationTypeEnum),
		("pcRelative", ctypes.c_bool),
		("baseRelative", ctypes.c_bool),
		("base", ctypes.c_ulonglong),
		("size", ctypes.c_ulonglong),
		("truncateSize", ctypes.c_ulonglong),
		("nativeType", ctypes.c_ulonglong),
		("addend", ctypes.c_ulonglong),
		("hasSign", ctypes.c_bool),
		("implicitAddend", ctypes.c_bool),
		("external", ctypes.c_bool),
		("symbolIndex", ctypes.c_ulonglong),
		("sectionIndex", ctypes.c_ulonglong),
		("address", ctypes.c_ulonglong),
		("target", ctypes.c_ulonglong),
		("dataRelocation", ctypes.c_bool),
		("relocationDataCache", ctypes.c_ubyte * 8),
		("prev", ctypes.POINTER(BNRelocationInfo)),
		("next", ctypes.POINTER(BNRelocationInfo)),
	]
BNScriptingInstanceCallbacks._fields_ = [
		("context", ctypes.c_void_p),
		("destroyInstance", ctypes.CFUNCTYPE(None, ctypes.c_void_p)),
		("externalRefTaken", ctypes.CFUNCTYPE(None, ctypes.c_void_p)),
		("externalRefReleased", ctypes.CFUNCTYPE(None, ctypes.c_void_p)),
		("executeScriptInput", ctypes.CFUNCTYPE(ScriptingProviderExecuteResultEnum, ctypes.c_void_p, ctypes.c_char_p)),
		("executeScriptInputFromFilename", ctypes.CFUNCTYPE(ScriptingProviderExecuteResultEnum, ctypes.c_void_p, ctypes.c_char_p)),
		("cancelScriptInput", ctypes.CFUNCTYPE(None, ctypes.c_void_p)),
		("releaseBinaryView", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView))),
		("setCurrentBinaryView", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView))),
		("setCurrentFunction", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNFunction))),
		("setCurrentBasicBlock", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBasicBlock))),
		("setCurrentAddress", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.c_ulonglong)),
		("setCurrentSelection", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong)),
		("completeInput", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.c_char_p, ctypes.c_ulonglong)),
		("stop", ctypes.CFUNCTYPE(None, ctypes.c_void_p)),
	]
BNScriptingOutputListener._fields_ = [
		("context", ctypes.c_void_p),
		("output", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.c_char_p)),
		("warning", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.c_char_p)),
		("error", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.c_char_p)),
		("inputReadyStateChanged", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ScriptingProviderInputReadyStateEnum)),
	]
BNScriptingProviderCallbacks._fields_ = [
		("context", ctypes.c_void_p),
		("createInstance", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p)),
		("loadModule", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_char_p, ctypes.c_char_p, ctypes.c_bool)),
		("installModules", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_char_p)),
	]
BNSecretsProviderCallbacks._fields_ = [
		("context", ctypes.c_void_p),
		("hasData", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_char_p)),
		("getData", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.c_char_p)),
		("storeData", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_char_p, ctypes.c_char_p)),
		("deleteData", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_char_p)),
	]
BNStackVariableReference._fields_ = [
		("sourceOperand", ctypes.c_uint),
		("typeConfidence", ctypes.c_ubyte),
		("type", ctypes.POINTER(BNType)),
		("_name", ctypes.c_char_p),
		("varIdentifier", ctypes.c_ulonglong),
		("referencedOffset", ctypes.c_longlong),
		("size", ctypes.c_ulonglong),
	]
BNStringReference._fields_ = [
		("type", StringTypeEnum),
		("start", ctypes.c_ulonglong),
		("length", ctypes.c_ulonglong),
	]
BNStructureMember._fields_ = [
		("type", ctypes.POINTER(BNType)),
		("_name", ctypes.c_char_p),
		("offset", ctypes.c_ulonglong),
		("typeConfidence", ctypes.c_ubyte),
		("access", MemberAccessEnum),
		("scope", MemberScopeEnum),
	]
BNSystemCallInfo._fields_ = [
		("number", ctypes.c_uint),
		("name", BNQualifiedName),
		("type", ctypes.POINTER(BNType)),
	]
BNTagReference._fields_ = [
		("refType", TagReferenceTypeEnum),
		("autoDefined", ctypes.c_bool),
		("tag", ctypes.POINTER(BNTag)),
		("arch", ctypes.POINTER(BNArchitecture)),
		("func", ctypes.POINTER(BNFunction)),
		("addr", ctypes.c_ulonglong),
	]
BNTransformParameter._fields_ = [
		("_name", ctypes.c_char_p),
		("value", ctypes.POINTER(BNDataBuffer)),
	]
BNTransformParameterInfo._fields_ = [
		("_name", ctypes.c_char_p),
		("_longName", ctypes.c_char_p),
		("fixedLength", ctypes.c_ulonglong),
	]
BNTypeArchiveNotification._fields_ = [
		("context", ctypes.c_void_p),
		("typeAdded", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNTypeArchive), ctypes.c_char_p, ctypes.POINTER(BNType))),
		("typeUpdated", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNTypeArchive), ctypes.c_char_p, ctypes.POINTER(BNType), ctypes.POINTER(BNType))),
		("typeRenamed", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNTypeArchive), ctypes.c_char_p, ctypes.POINTER(BNQualifiedName), ctypes.POINTER(BNQualifiedName))),
		("typeDeleted", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNTypeArchive), ctypes.c_char_p, ctypes.POINTER(BNType))),
	]
BNTypeContext._fields_ = [
		("type", ctypes.POINTER(BNType)),
		("offset", ctypes.c_ulonglong),
	]
BNTypeDefinitionLine._fields_ = [
		("lineType", TypeDefinitionLineTypeEnum),
		("tokens", ctypes.POINTER(BNInstructionTextToken)),
		("count", ctypes.c_ulonglong),
		("type", ctypes.POINTER(BNType)),
		("parentType", ctypes.POINTER(BNType)),
		("rootType", ctypes.POINTER(BNType)),
		("_rootTypeName", ctypes.c_char_p),
		("baseType", ctypes.POINTER(BNNamedTypeReference)),
		("baseOffset", ctypes.c_ulonglong),
		("offset", ctypes.c_ulonglong),
		("fieldIndex", ctypes.c_ulonglong),
	]
BNTypeField._fields_ = [
		("name", BNQualifiedName),
		("offset", ctypes.c_ulonglong),
	]
BNTypeFieldReferenceSizeInfo._fields_ = [
		("offset", ctypes.c_ulonglong),
		("sizes", ctypes.POINTER(ctypes.c_ulonglong)),
		("count", ctypes.c_ulonglong),
	]
BNTypeFieldReferenceTypeInfo._fields_ = [
		("offset", ctypes.c_ulonglong),
		("types", ctypes.POINTER(BNTypeWithConfidence)),
		("count", ctypes.c_ulonglong),
	]
BNTypeParserCallbacks._fields_ = [
		("context", ctypes.c_void_p),
		("getOptionText", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, TypeParserOptionEnum, ctypes.c_char_p, ctypes.POINTER(ctypes.c_char_p))),
		("preprocessSource", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_char_p, ctypes.c_char_p, ctypes.POINTER(BNPlatform), ctypes.POINTER(BNQualifiedNameTypeAndId), ctypes.c_ulonglong, ctypes.POINTER(ctypes.c_char_p), ctypes.c_ulonglong, ctypes.POINTER(ctypes.c_char_p), ctypes.c_ulonglong, ctypes.POINTER(ctypes.c_char_p), ctypes.POINTER(ctypes.POINTER(BNTypeParserError)), ctypes.POINTER(ctypes.c_ulonglong))),
		("parseTypesFromSource", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_char_p, ctypes.c_char_p, ctypes.POINTER(BNPlatform), ctypes.POINTER(BNQualifiedNameTypeAndId), ctypes.c_ulonglong, ctypes.POINTER(ctypes.c_char_p), ctypes.c_ulonglong, ctypes.POINTER(ctypes.c_char_p), ctypes.c_ulonglong, ctypes.c_char_p, ctypes.POINTER(BNTypeParserResult), ctypes.POINTER(ctypes.POINTER(BNTypeParserError)), ctypes.POINTER(ctypes.c_ulonglong))),
		("parseTypeString", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_char_p, ctypes.POINTER(BNPlatform), ctypes.POINTER(BNQualifiedNameTypeAndId), ctypes.c_ulonglong, ctypes.POINTER(BNQualifiedNameAndType), ctypes.POINTER(ctypes.POINTER(BNTypeParserError)), ctypes.POINTER(ctypes.c_ulonglong))),
		("freeString", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.c_char_p)),
		("freeResult", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNTypeParserResult))),
		("freeErrorList", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNTypeParserError), ctypes.c_ulonglong)),
	]
BNTypeParserError._fields_ = [
		("severity", TypeParserErrorSeverityEnum),
		("_message", ctypes.c_char_p),
		("_fileName", ctypes.c_char_p),
		("line", ctypes.c_ulonglong),
		("column", ctypes.c_ulonglong),
	]
BNTypeParserResult._fields_ = [
		("types", ctypes.POINTER(BNParsedType)),
		("variables", ctypes.POINTER(BNParsedType)),
		("functions", ctypes.POINTER(BNParsedType)),
		("typeCount", ctypes.c_ulonglong),
		("variableCount", ctypes.c_ulonglong),
		("functionCount", ctypes.c_ulonglong),
	]
BNTypePrinterCallbacks._fields_ = [
		("context", ctypes.c_void_p),
		("getTypeTokens", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNType), ctypes.POINTER(BNPlatform), ctypes.POINTER(BNQualifiedName), ctypes.c_ubyte, TokenEscapingTypeEnum, ctypes.POINTER(ctypes.POINTER(BNInstructionTextToken)), ctypes.POINTER(ctypes.c_ulonglong))),
		("getTypeTokensBeforeName", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNType), ctypes.POINTER(BNPlatform), ctypes.c_ubyte, ctypes.POINTER(BNType), TokenEscapingTypeEnum, ctypes.POINTER(ctypes.POINTER(BNInstructionTextToken)), ctypes.POINTER(ctypes.c_ulonglong))),
		("getTypeTokensAfterName", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNType), ctypes.POINTER(BNPlatform), ctypes.c_ubyte, ctypes.POINTER(BNType), TokenEscapingTypeEnum, ctypes.POINTER(ctypes.POINTER(BNInstructionTextToken)), ctypes.POINTER(ctypes.c_ulonglong))),
		("getTypeString", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNType), ctypes.POINTER(BNPlatform), ctypes.POINTER(BNQualifiedName), TokenEscapingTypeEnum, ctypes.POINTER(ctypes.c_char_p))),
		("getTypeStringBeforeName", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNType), ctypes.POINTER(BNPlatform), TokenEscapingTypeEnum, ctypes.POINTER(ctypes.c_char_p))),
		("getTypeStringAfterName", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNType), ctypes.POINTER(BNPlatform), TokenEscapingTypeEnum, ctypes.POINTER(ctypes.c_char_p))),
		("getTypeLines", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNType), ctypes.POINTER(BNTypeContainer), ctypes.POINTER(BNQualifiedName), ctypes.c_int, ctypes.c_bool, TokenEscapingTypeEnum, ctypes.POINTER(ctypes.POINTER(BNTypeDefinitionLine)), ctypes.POINTER(ctypes.c_ulonglong))),
		("printAllTypes", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNQualifiedName), ctypes.POINTER(ctypes.POINTER(BNType)), ctypes.c_ulonglong, ctypes.POINTER(BNBinaryView), ctypes.c_int, TokenEscapingTypeEnum, ctypes.POINTER(ctypes.c_char_p))),
		("freeTokens", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNInstructionTextToken), ctypes.c_ulonglong)),
		("freeString", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.c_char_p)),
		("freeLines", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNTypeDefinitionLine), ctypes.c_ulonglong)),
	]
BNTypeReferenceSource._fields_ = [
		("name", BNQualifiedName),
		("offset", ctypes.c_ulonglong),
		("type", TypeReferenceTypeEnum),
	]
BNTypeWithConfidence._fields_ = [
		("type", ctypes.POINTER(BNType)),
		("confidence", ctypes.c_ubyte),
	]
BNUndoAction._fields_ = [
		("actionType", ActionTypeEnum),
		("_summaryText", ctypes.c_char_p),
		("summaryTokens", ctypes.POINTER(BNInstructionTextToken)),
		("summaryTokenCount", ctypes.c_ulonglong),
	]
BNUndoEntry._fields_ = [
		("valid", ctypes.c_bool),
		("user", ctypes.POINTER(BNUser)),
		("_id", ctypes.c_char_p),
		("actions", ctypes.POINTER(BNUndoAction)),
		("actionCount", ctypes.c_ulonglong),
		("timestamp", ctypes.c_ulonglong),
	]
BNUpdateChannel._fields_ = [
		("_name", ctypes.c_char_p),
		("_description", ctypes.c_char_p),
		("_latestVersion", ctypes.c_char_p),
	]
BNUpdateChannelFullInfo._fields_ = [
		("versions", ctypes.POINTER(BNUpdateVersionNew)),
		("versionCount", ctypes.c_ulonglong),
		("changelogEntries", ctypes.POINTER(BNChangelogEntry)),
		("changelogEntryCount", ctypes.c_ulonglong),
		("_name", ctypes.c_char_p),
		("_desc", ctypes.c_char_p),
		("_latestVersion", ctypes.c_char_p),
	]
BNUpdateVersion._fields_ = [
		("_version", ctypes.c_char_p),
		("_notes", ctypes.c_char_p),
		("time", ctypes.c_ulonglong),
	]
BNValueRange._fields_ = [
		("start", ctypes.c_ulonglong),
		("end", ctypes.c_ulonglong),
		("step", ctypes.c_ulonglong),
	]
BNVariable._fields_ = [
		("type", VariableSourceTypeEnum),
		("index", ctypes.c_uint),
		("storage", ctypes.c_longlong),
	]
BNVariableNameAndType._fields_ = [
		("var", BNVariable),
		("type", ctypes.POINTER(BNType)),
		("_name", ctypes.c_char_p),
		("autoDefined", ctypes.c_bool),
		("typeConfidence", ctypes.c_ubyte),
	]
BNVariableReferenceSource._fields_ = [
		("var", BNVariable),
		("source", BNILReferenceSource),
	]
BNVersionInfo._fields_ = [
		("major", ctypes.c_uint),
		("minor", ctypes.c_uint),
		("build", ctypes.c_uint),
		("_channel", ctypes.c_char_p),
	]
BNWebsocketClientCallbacks._fields_ = [
		("context", ctypes.c_void_p),
		("destroyClient", ctypes.CFUNCTYPE(None, ctypes.c_void_p)),
		("connect", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_char_p, ctypes.c_ulonglong, ctypes.POINTER(ctypes.c_char_p), ctypes.POINTER(ctypes.c_char_p))),
		("write", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.POINTER(ctypes.c_ubyte), ctypes.c_ulonglong, ctypes.c_void_p)),
		("disconnect", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p)),
	]
BNWebsocketClientOutputCallbacks._fields_ = [
		("context", ctypes.c_void_p),
		("connectedCallback", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p)),
		("disconnectedCallback", ctypes.CFUNCTYPE(None, ctypes.c_void_p)),
		("errorCallback", ctypes.CFUNCTYPE(None, ctypes.c_char_p, ctypes.c_void_p)),
		("readCallback", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.POINTER(ctypes.c_ubyte), ctypes.c_ulonglong, ctypes.c_void_p)),
	]
BNWebsocketProviderCallbacks._fields_ = [
		("context", ctypes.c_void_p),
		("createClient", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p)),
	]
BNChangelogEntry._fields_ = [
		("version", BNVersionInfo),
		("_notes", ctypes.c_char_p),
		("time", ctypes.c_ulonglong),
	]
BNDisassemblyTextLine._fields_ = [
		("addr", ctypes.c_ulonglong),
		("instrIndex", ctypes.c_ulonglong),
		("tokens", ctypes.POINTER(BNInstructionTextToken)),
		("count", ctypes.c_ulonglong),
		("highlight", BNHighlightColor),
		("tags", ctypes.POINTER(ctypes.POINTER(BNTag))),
		("tagCount", ctypes.c_ulonglong),
		("typeInfo", BNDisassemblyTextLineTypeInfo),
	]
BNFunctionParameter._fields_ = [
		("_name", ctypes.c_char_p),
		("type", ctypes.POINTER(BNType)),
		("typeConfidence", ctypes.c_ubyte),
		("defaultLocation", ctypes.c_bool),
		("location", BNVariable),
	]
BNInheritedStructureMember._fields_ = [
		("base", ctypes.POINTER(BNNamedTypeReference)),
		("baseOffset", ctypes.c_ulonglong),
		("member", BNStructureMember),
		("memberIndex", ctypes.c_ulonglong),
	]
BNLinearDisassemblyLine._fields_ = [
		("type", LinearDisassemblyLineTypeEnum),
		("function", ctypes.POINTER(BNFunction)),
		("block", ctypes.POINTER(BNBasicBlock)),
		("contents", BNDisassemblyTextLine),
	]
BNMergedVariable._fields_ = [
		("target", BNVariable),
		("sources", ctypes.POINTER(BNVariable)),
		("sourceCount", ctypes.c_ulonglong),
	]
BNParsedType._fields_ = [
		("name", BNQualifiedName),
		("type", ctypes.POINTER(BNType)),
		("isUser", ctypes.c_bool),
	]
BNTypeFieldReference._fields_ = [
		("func", ctypes.POINTER(BNFunction)),
		("arch", ctypes.POINTER(BNArchitecture)),
		("addr", ctypes.c_ulonglong),
		("size", ctypes.c_ulonglong),
		("incomingType", BNTypeWithConfidence),
	]
BNUpdateVersionNew._fields_ = [
		("version", BNVersionInfo),
		("_name", ctypes.c_char_p),
		("time", ctypes.c_ulonglong),
	]
BNUserVariableValue._fields_ = [
		("var", BNVariable),
		("defSite", BNArchitectureAndAddress),
		("value", BNPossibleValueSet),
	]

# Function definitions
# -------------------------------------------------------
# _BNAbortAnalysis

_BNAbortAnalysis = core.BNAbortAnalysis
_BNAbortAnalysis.restype = None
_BNAbortAnalysis.argtypes = [
		ctypes.POINTER(BNBinaryView),
	]


# noinspection PyPep8Naming
def BNAbortAnalysis(
		view: ctypes.POINTER(BNBinaryView)
		) -> None:
	return _BNAbortAnalysis(view)


# -------------------------------------------------------
# _BNAbortFlowGraphLayoutRequest

_BNAbortFlowGraphLayoutRequest = core.BNAbortFlowGraphLayoutRequest
_BNAbortFlowGraphLayoutRequest.restype = None
_BNAbortFlowGraphLayoutRequest.argtypes = [
		ctypes.POINTER(BNFlowGraphLayoutRequest),
	]


# noinspection PyPep8Naming
def BNAbortFlowGraphLayoutRequest(
		graph: ctypes.POINTER(BNFlowGraphLayoutRequest)
		) -> None:
	return _BNAbortFlowGraphLayoutRequest(graph)


# -------------------------------------------------------
# _BNActivityGetName

_BNActivityGetName = core.BNActivityGetName
_BNActivityGetName.restype = ctypes.POINTER(ctypes.c_byte)
_BNActivityGetName.argtypes = [
		ctypes.POINTER(BNActivity),
	]


# noinspection PyPep8Naming
def BNActivityGetName(
		activity: ctypes.POINTER(BNActivity)
		) -> Optional[Optional[str]]:
	result = _BNActivityGetName(activity)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNAddAnalysisCompletionEvent

_BNAddAnalysisCompletionEvent = core.BNAddAnalysisCompletionEvent
_BNAddAnalysisCompletionEvent.restype = ctypes.POINTER(BNAnalysisCompletionEvent)
_BNAddAnalysisCompletionEvent.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_void_p,
		ctypes.CFUNCTYPE(None, ctypes.c_void_p),
	]


# noinspection PyPep8Naming
def BNAddAnalysisCompletionEvent(
		view: ctypes.POINTER(BNBinaryView), 
		ctxt: Optional[ctypes.c_void_p], 
		callback: ctypes.CFUNCTYPE(None, ctypes.c_void_p)
		) -> Optional[ctypes.POINTER(BNAnalysisCompletionEvent)]:
	result = _BNAddAnalysisCompletionEvent(view, ctxt, callback)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNAddAnalysisOption

_BNAddAnalysisOption = core.BNAddAnalysisOption
_BNAddAnalysisOption.restype = None
_BNAddAnalysisOption.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNAddAnalysisOption(
		view: ctypes.POINTER(BNBinaryView), 
		name: Optional[str]
		) -> None:
	return _BNAddAnalysisOption(view, cstr(name))


# -------------------------------------------------------
# _BNAddArchitectureRedirection

_BNAddArchitectureRedirection = core.BNAddArchitectureRedirection
_BNAddArchitectureRedirection.restype = None
_BNAddArchitectureRedirection.argtypes = [
		ctypes.POINTER(BNArchitecture),
		ctypes.POINTER(BNArchitecture),
		ctypes.POINTER(BNArchitecture),
	]


# noinspection PyPep8Naming
def BNAddArchitectureRedirection(
		arch: ctypes.POINTER(BNArchitecture), 
		from_: ctypes.POINTER(BNArchitecture), 
		to: ctypes.POINTER(BNArchitecture)
		) -> None:
	return _BNAddArchitectureRedirection(arch, from_, to)


# -------------------------------------------------------
# _BNAddAutoAddressTag

_BNAddAutoAddressTag = core.BNAddAutoAddressTag
_BNAddAutoAddressTag.restype = None
_BNAddAutoAddressTag.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNArchitecture),
		ctypes.c_ulonglong,
		ctypes.POINTER(BNTag),
	]


# noinspection PyPep8Naming
def BNAddAutoAddressTag(
		func: ctypes.POINTER(BNFunction), 
		arch: ctypes.POINTER(BNArchitecture), 
		addr: int, 
		tag: ctypes.POINTER(BNTag)
		) -> None:
	return _BNAddAutoAddressTag(func, arch, addr, tag)


# -------------------------------------------------------
# _BNAddAutoDataTag

_BNAddAutoDataTag = core.BNAddAutoDataTag
_BNAddAutoDataTag.restype = None
_BNAddAutoDataTag.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
		ctypes.POINTER(BNTag),
	]


# noinspection PyPep8Naming
def BNAddAutoDataTag(
		view: ctypes.POINTER(BNBinaryView), 
		addr: int, 
		tag: ctypes.POINTER(BNTag)
		) -> None:
	return _BNAddAutoDataTag(view, addr, tag)


# -------------------------------------------------------
# _BNAddAutoFunctionTag

_BNAddAutoFunctionTag = core.BNAddAutoFunctionTag
_BNAddAutoFunctionTag.restype = None
_BNAddAutoFunctionTag.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNTag),
	]


# noinspection PyPep8Naming
def BNAddAutoFunctionTag(
		func: ctypes.POINTER(BNFunction), 
		tag: ctypes.POINTER(BNTag)
		) -> None:
	return _BNAddAutoFunctionTag(func, tag)


# -------------------------------------------------------
# _BNAddAutoSection

_BNAddAutoSection = core.BNAddAutoSection
_BNAddAutoSection.restype = None
_BNAddAutoSection.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_char_p,
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
		SectionSemanticsEnum,
		ctypes.c_char_p,
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
		ctypes.c_char_p,
		ctypes.c_char_p,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNAddAutoSection(
		view: ctypes.POINTER(BNBinaryView), 
		name: Optional[str], 
		start: int, 
		length: int, 
		semantics: SectionSemantics, 
		type: Optional[str], 
		align: int, 
		entrySize: int, 
		linkedSection: Optional[str], 
		infoSection: Optional[str], 
		infoData: int
		) -> None:
	return _BNAddAutoSection(view, cstr(name), start, length, semantics, cstr(type), align, entrySize, cstr(linkedSection), cstr(infoSection), infoData)


# -------------------------------------------------------
# _BNAddAutoSegment

_BNAddAutoSegment = core.BNAddAutoSegment
_BNAddAutoSegment.restype = None
_BNAddAutoSegment.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
		ctypes.c_uint,
	]


# noinspection PyPep8Naming
def BNAddAutoSegment(
		view: ctypes.POINTER(BNBinaryView), 
		start: int, 
		length: int, 
		dataOffset: int, 
		dataLength: int, 
		flags: int
		) -> None:
	return _BNAddAutoSegment(view, start, length, dataOffset, dataLength, flags)


# -------------------------------------------------------
# _BNAddBinaryViewTypeLibrary

_BNAddBinaryViewTypeLibrary = core.BNAddBinaryViewTypeLibrary
_BNAddBinaryViewTypeLibrary.restype = None
_BNAddBinaryViewTypeLibrary.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNTypeLibrary),
	]


# noinspection PyPep8Naming
def BNAddBinaryViewTypeLibrary(
		view: ctypes.POINTER(BNBinaryView), 
		lib: ctypes.POINTER(BNTypeLibrary)
		) -> None:
	return _BNAddBinaryViewTypeLibrary(view, lib)


# -------------------------------------------------------
# _BNAddDebugDataVariable

_BNAddDebugDataVariable = core.BNAddDebugDataVariable
_BNAddDebugDataVariable.restype = ctypes.c_bool
_BNAddDebugDataVariable.argtypes = [
		ctypes.POINTER(BNDebugInfo),
		ctypes.c_ulonglong,
		ctypes.POINTER(BNType),
		ctypes.c_char_p,
		ctypes.POINTER(ctypes.c_char_p),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNAddDebugDataVariable(
		debugInfo: ctypes.POINTER(BNDebugInfo), 
		address: int, 
		type: ctypes.POINTER(BNType), 
		name: Optional[str], 
		components: ctypes.POINTER(ctypes.c_char_p), 
		components_count: int
		) -> bool:
	return _BNAddDebugDataVariable(debugInfo, address, type, cstr(name), components, components_count)


# -------------------------------------------------------
# _BNAddDebugDataVariableInfo

_BNAddDebugDataVariableInfo = core.BNAddDebugDataVariableInfo
_BNAddDebugDataVariableInfo.restype = ctypes.c_bool
_BNAddDebugDataVariableInfo.argtypes = [
		ctypes.POINTER(BNDebugInfo),
		ctypes.POINTER(BNDataVariableAndName),
	]


# noinspection PyPep8Naming
def BNAddDebugDataVariableInfo(
		debugInfo: ctypes.POINTER(BNDebugInfo), 
		var: ctypes.POINTER(BNDataVariableAndName)
		) -> bool:
	return _BNAddDebugDataVariableInfo(debugInfo, var)


# -------------------------------------------------------
# _BNAddDebugFunction

_BNAddDebugFunction = core.BNAddDebugFunction
_BNAddDebugFunction.restype = ctypes.c_bool
_BNAddDebugFunction.argtypes = [
		ctypes.POINTER(BNDebugInfo),
		ctypes.POINTER(BNDebugFunctionInfo),
	]


# noinspection PyPep8Naming
def BNAddDebugFunction(
		debugInfo: ctypes.POINTER(BNDebugInfo), 
		func: ctypes.POINTER(BNDebugFunctionInfo)
		) -> bool:
	return _BNAddDebugFunction(debugInfo, func)


# -------------------------------------------------------
# _BNAddDebugType

_BNAddDebugType = core.BNAddDebugType
_BNAddDebugType.restype = ctypes.c_bool
_BNAddDebugType.argtypes = [
		ctypes.POINTER(BNDebugInfo),
		ctypes.c_char_p,
		ctypes.POINTER(BNType),
		ctypes.POINTER(ctypes.c_char_p),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNAddDebugType(
		debugInfo: ctypes.POINTER(BNDebugInfo), 
		name: Optional[str], 
		type: ctypes.POINTER(BNType), 
		components: ctypes.POINTER(ctypes.c_char_p), 
		components_count: int
		) -> bool:
	return _BNAddDebugType(debugInfo, cstr(name), type, components, components_count)


# -------------------------------------------------------
# _BNAddEntryPointForAnalysis

_BNAddEntryPointForAnalysis = core.BNAddEntryPointForAnalysis
_BNAddEntryPointForAnalysis.restype = None
_BNAddEntryPointForAnalysis.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNPlatform),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNAddEntryPointForAnalysis(
		view: ctypes.POINTER(BNBinaryView), 
		platform: ctypes.POINTER(BNPlatform), 
		addr: int
		) -> None:
	return _BNAddEntryPointForAnalysis(view, platform, addr)


# -------------------------------------------------------
# _BNAddEnumerationBuilderMember

_BNAddEnumerationBuilderMember = core.BNAddEnumerationBuilderMember
_BNAddEnumerationBuilderMember.restype = None
_BNAddEnumerationBuilderMember.argtypes = [
		ctypes.POINTER(BNEnumerationBuilder),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNAddEnumerationBuilderMember(
		e: ctypes.POINTER(BNEnumerationBuilder), 
		name: Optional[str]
		) -> None:
	return _BNAddEnumerationBuilderMember(e, cstr(name))


# -------------------------------------------------------
# _BNAddEnumerationBuilderMemberWithValue

_BNAddEnumerationBuilderMemberWithValue = core.BNAddEnumerationBuilderMemberWithValue
_BNAddEnumerationBuilderMemberWithValue.restype = None
_BNAddEnumerationBuilderMemberWithValue.argtypes = [
		ctypes.POINTER(BNEnumerationBuilder),
		ctypes.c_char_p,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNAddEnumerationBuilderMemberWithValue(
		e: ctypes.POINTER(BNEnumerationBuilder), 
		name: Optional[str], 
		value: int
		) -> None:
	return _BNAddEnumerationBuilderMemberWithValue(e, cstr(name), value)


# -------------------------------------------------------
# _BNAddExpressionParserMagicValue

_BNAddExpressionParserMagicValue = core.BNAddExpressionParserMagicValue
_BNAddExpressionParserMagicValue.restype = None
_BNAddExpressionParserMagicValue.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_char_p,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNAddExpressionParserMagicValue(
		view: ctypes.POINTER(BNBinaryView), 
		name: Optional[str], 
		value: int
		) -> None:
	return _BNAddExpressionParserMagicValue(view, cstr(name), value)


# -------------------------------------------------------
# _BNAddExpressionParserMagicValues

_BNAddExpressionParserMagicValues = core.BNAddExpressionParserMagicValues
_BNAddExpressionParserMagicValues.restype = None
_BNAddExpressionParserMagicValues.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(ctypes.c_char_p),
		ctypes.POINTER(ctypes.c_ulonglong),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNAddExpressionParserMagicValues(
		view: ctypes.POINTER(BNBinaryView), 
		names: ctypes.POINTER(ctypes.c_char_p), 
		values: ctypes.POINTER(ctypes.c_ulonglong), 
		count: int
		) -> None:
	return _BNAddExpressionParserMagicValues(view, names, values, count)


# -------------------------------------------------------
# _BNAddFlowGraphNode

_BNAddFlowGraphNode = core.BNAddFlowGraphNode
_BNAddFlowGraphNode.restype = ctypes.c_ulonglong
_BNAddFlowGraphNode.argtypes = [
		ctypes.POINTER(BNFlowGraph),
		ctypes.POINTER(BNFlowGraphNode),
	]


# noinspection PyPep8Naming
def BNAddFlowGraphNode(
		graph: ctypes.POINTER(BNFlowGraph), 
		node: ctypes.POINTER(BNFlowGraphNode)
		) -> int:
	return _BNAddFlowGraphNode(graph, node)


# -------------------------------------------------------
# _BNAddFlowGraphNodeOutgoingEdge

_BNAddFlowGraphNodeOutgoingEdge = core.BNAddFlowGraphNodeOutgoingEdge
_BNAddFlowGraphNodeOutgoingEdge.restype = None
_BNAddFlowGraphNodeOutgoingEdge.argtypes = [
		ctypes.POINTER(BNFlowGraphNode),
		BranchTypeEnum,
		ctypes.POINTER(BNFlowGraphNode),
		BNEdgeStyle,
	]


# noinspection PyPep8Naming
def BNAddFlowGraphNodeOutgoingEdge(
		node: ctypes.POINTER(BNFlowGraphNode), 
		type: BranchType, 
		target: ctypes.POINTER(BNFlowGraphNode), 
		edgeStyle: BNEdgeStyle
		) -> None:
	return _BNAddFlowGraphNodeOutgoingEdge(node, type, target, edgeStyle)


# -------------------------------------------------------
# _BNAddFunctionForAnalysis

_BNAddFunctionForAnalysis = core.BNAddFunctionForAnalysis
_BNAddFunctionForAnalysis.restype = ctypes.POINTER(BNFunction)
_BNAddFunctionForAnalysis.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNPlatform),
		ctypes.c_ulonglong,
		ctypes.c_bool,
		ctypes.POINTER(BNType),
	]


# noinspection PyPep8Naming
def BNAddFunctionForAnalysis(
		view: ctypes.POINTER(BNBinaryView), 
		platform: ctypes.POINTER(BNPlatform), 
		addr: int, 
		autoDiscovered: bool, 
		type: ctypes.POINTER(BNType)
		) -> Optional[ctypes.POINTER(BNFunction)]:
	result = _BNAddFunctionForAnalysis(view, platform, addr, autoDiscovered, type)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNAddGraphReportToCollection

_BNAddGraphReportToCollection = core.BNAddGraphReportToCollection
_BNAddGraphReportToCollection.restype = None
_BNAddGraphReportToCollection.argtypes = [
		ctypes.POINTER(BNReportCollection),
		ctypes.POINTER(BNBinaryView),
		ctypes.c_char_p,
		ctypes.POINTER(BNFlowGraph),
	]


# noinspection PyPep8Naming
def BNAddGraphReportToCollection(
		reports: ctypes.POINTER(BNReportCollection), 
		view: ctypes.POINTER(BNBinaryView), 
		title: Optional[str], 
		graph: ctypes.POINTER(BNFlowGraph)
		) -> None:
	return _BNAddGraphReportToCollection(reports, view, cstr(title), graph)


# -------------------------------------------------------
# _BNAddHTMLReportToCollection

_BNAddHTMLReportToCollection = core.BNAddHTMLReportToCollection
_BNAddHTMLReportToCollection.restype = None
_BNAddHTMLReportToCollection.argtypes = [
		ctypes.POINTER(BNReportCollection),
		ctypes.POINTER(BNBinaryView),
		ctypes.c_char_p,
		ctypes.c_char_p,
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNAddHTMLReportToCollection(
		reports: ctypes.POINTER(BNReportCollection), 
		view: ctypes.POINTER(BNBinaryView), 
		title: Optional[str], 
		contents: Optional[str], 
		plaintext: Optional[str]
		) -> None:
	return _BNAddHTMLReportToCollection(reports, view, cstr(title), cstr(contents), cstr(plaintext))


# -------------------------------------------------------
# _BNAddLowLevelILLabelForAddress

_BNAddLowLevelILLabelForAddress = core.BNAddLowLevelILLabelForAddress
_BNAddLowLevelILLabelForAddress.restype = None
_BNAddLowLevelILLabelForAddress.argtypes = [
		ctypes.POINTER(BNLowLevelILFunction),
		ctypes.POINTER(BNArchitecture),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNAddLowLevelILLabelForAddress(
		func: ctypes.POINTER(BNLowLevelILFunction), 
		arch: ctypes.POINTER(BNArchitecture), 
		addr: int
		) -> None:
	return _BNAddLowLevelILLabelForAddress(func, arch, addr)


# -------------------------------------------------------
# _BNAddMarkdownReportToCollection

_BNAddMarkdownReportToCollection = core.BNAddMarkdownReportToCollection
_BNAddMarkdownReportToCollection.restype = None
_BNAddMarkdownReportToCollection.argtypes = [
		ctypes.POINTER(BNReportCollection),
		ctypes.POINTER(BNBinaryView),
		ctypes.c_char_p,
		ctypes.c_char_p,
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNAddMarkdownReportToCollection(
		reports: ctypes.POINTER(BNReportCollection), 
		view: ctypes.POINTER(BNBinaryView), 
		title: Optional[str], 
		contents: Optional[str], 
		plaintext: Optional[str]
		) -> None:
	return _BNAddMarkdownReportToCollection(reports, view, cstr(title), cstr(contents), cstr(plaintext))


# -------------------------------------------------------
# _BNAddOptionalPluginDependency

_BNAddOptionalPluginDependency = core.BNAddOptionalPluginDependency
_BNAddOptionalPluginDependency.restype = None
_BNAddOptionalPluginDependency.argtypes = [
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNAddOptionalPluginDependency(
		name: Optional[str]
		) -> None:
	return _BNAddOptionalPluginDependency(cstr(name))


# -------------------------------------------------------
# _BNAddPlainTextReportToCollection

_BNAddPlainTextReportToCollection = core.BNAddPlainTextReportToCollection
_BNAddPlainTextReportToCollection.restype = None
_BNAddPlainTextReportToCollection.argtypes = [
		ctypes.POINTER(BNReportCollection),
		ctypes.POINTER(BNBinaryView),
		ctypes.c_char_p,
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNAddPlainTextReportToCollection(
		reports: ctypes.POINTER(BNReportCollection), 
		view: ctypes.POINTER(BNBinaryView), 
		title: Optional[str], 
		contents: Optional[str]
		) -> None:
	return _BNAddPlainTextReportToCollection(reports, view, cstr(title), cstr(contents))


# -------------------------------------------------------
# _BNAddRelatedPlatform

_BNAddRelatedPlatform = core.BNAddRelatedPlatform
_BNAddRelatedPlatform.restype = None
_BNAddRelatedPlatform.argtypes = [
		ctypes.POINTER(BNPlatform),
		ctypes.POINTER(BNArchitecture),
		ctypes.POINTER(BNPlatform),
	]


# noinspection PyPep8Naming
def BNAddRelatedPlatform(
		platform: ctypes.POINTER(BNPlatform), 
		arch: ctypes.POINTER(BNArchitecture), 
		related: ctypes.POINTER(BNPlatform)
		) -> None:
	return _BNAddRelatedPlatform(platform, arch, related)


# -------------------------------------------------------
# _BNAddRequiredPluginDependency

_BNAddRequiredPluginDependency = core.BNAddRequiredPluginDependency
_BNAddRequiredPluginDependency.restype = None
_BNAddRequiredPluginDependency.argtypes = [
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNAddRequiredPluginDependency(
		name: Optional[str]
		) -> None:
	return _BNAddRequiredPluginDependency(cstr(name))


# -------------------------------------------------------
# _BNAddStructureBuilderMember

_BNAddStructureBuilderMember = core.BNAddStructureBuilderMember
_BNAddStructureBuilderMember.restype = None
_BNAddStructureBuilderMember.argtypes = [
		ctypes.POINTER(BNStructureBuilder),
		ctypes.POINTER(BNTypeWithConfidence),
		ctypes.c_char_p,
		MemberAccessEnum,
		MemberScopeEnum,
	]


# noinspection PyPep8Naming
def BNAddStructureBuilderMember(
		s: ctypes.POINTER(BNStructureBuilder), 
		type: ctypes.POINTER(BNTypeWithConfidence), 
		name: Optional[str], 
		access: MemberAccess, 
		scope: MemberScope
		) -> None:
	return _BNAddStructureBuilderMember(s, type, cstr(name), access, scope)


# -------------------------------------------------------
# _BNAddStructureBuilderMemberAtOffset

_BNAddStructureBuilderMemberAtOffset = core.BNAddStructureBuilderMemberAtOffset
_BNAddStructureBuilderMemberAtOffset.restype = None
_BNAddStructureBuilderMemberAtOffset.argtypes = [
		ctypes.POINTER(BNStructureBuilder),
		ctypes.POINTER(BNTypeWithConfidence),
		ctypes.c_char_p,
		ctypes.c_ulonglong,
		ctypes.c_bool,
		MemberAccessEnum,
		MemberScopeEnum,
	]


# noinspection PyPep8Naming
def BNAddStructureBuilderMemberAtOffset(
		s: ctypes.POINTER(BNStructureBuilder), 
		type: ctypes.POINTER(BNTypeWithConfidence), 
		name: Optional[str], 
		offset: int, 
		overwriteExisting: bool, 
		access: MemberAccess, 
		scope: MemberScope
		) -> None:
	return _BNAddStructureBuilderMemberAtOffset(s, type, cstr(name), offset, overwriteExisting, access, scope)


# -------------------------------------------------------
# _BNAddTag

_BNAddTag = core.BNAddTag
_BNAddTag.restype = None
_BNAddTag.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNTag),
		ctypes.c_bool,
	]


# noinspection PyPep8Naming
def BNAddTag(
		view: ctypes.POINTER(BNBinaryView), 
		tag: ctypes.POINTER(BNTag), 
		user: bool
		) -> None:
	return _BNAddTag(view, tag, user)


# -------------------------------------------------------
# _BNAddTagType

_BNAddTagType = core.BNAddTagType
_BNAddTagType.restype = None
_BNAddTagType.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNTagType),
	]


# noinspection PyPep8Naming
def BNAddTagType(
		view: ctypes.POINTER(BNBinaryView), 
		tagType: ctypes.POINTER(BNTagType)
		) -> None:
	return _BNAddTagType(view, tagType)


# -------------------------------------------------------
# _BNAddTypeArchiveTypes

_BNAddTypeArchiveTypes = core.BNAddTypeArchiveTypes
_BNAddTypeArchiveTypes.restype = ctypes.c_bool
_BNAddTypeArchiveTypes.argtypes = [
		ctypes.POINTER(BNTypeArchive),
		ctypes.POINTER(BNQualifiedNameAndType),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNAddTypeArchiveTypes(
		archive: ctypes.POINTER(BNTypeArchive), 
		types: ctypes.POINTER(BNQualifiedNameAndType), 
		count: int
		) -> bool:
	return _BNAddTypeArchiveTypes(archive, types, count)


# -------------------------------------------------------
# _BNAddTypeLibraryAlternateName

_BNAddTypeLibraryAlternateName = core.BNAddTypeLibraryAlternateName
_BNAddTypeLibraryAlternateName.restype = None
_BNAddTypeLibraryAlternateName.argtypes = [
		ctypes.POINTER(BNTypeLibrary),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNAddTypeLibraryAlternateName(
		lib: ctypes.POINTER(BNTypeLibrary), 
		name: Optional[str]
		) -> None:
	return _BNAddTypeLibraryAlternateName(lib, cstr(name))


# -------------------------------------------------------
# _BNAddTypeLibraryNamedObject

_BNAddTypeLibraryNamedObject = core.BNAddTypeLibraryNamedObject
_BNAddTypeLibraryNamedObject.restype = None
_BNAddTypeLibraryNamedObject.argtypes = [
		ctypes.POINTER(BNTypeLibrary),
		ctypes.POINTER(BNQualifiedName),
		ctypes.POINTER(BNType),
	]


# noinspection PyPep8Naming
def BNAddTypeLibraryNamedObject(
		lib: ctypes.POINTER(BNTypeLibrary), 
		name: ctypes.POINTER(BNQualifiedName), 
		type: ctypes.POINTER(BNType)
		) -> None:
	return _BNAddTypeLibraryNamedObject(lib, name, type)


# -------------------------------------------------------
# _BNAddTypeLibraryNamedType

_BNAddTypeLibraryNamedType = core.BNAddTypeLibraryNamedType
_BNAddTypeLibraryNamedType.restype = None
_BNAddTypeLibraryNamedType.argtypes = [
		ctypes.POINTER(BNTypeLibrary),
		ctypes.POINTER(BNQualifiedName),
		ctypes.POINTER(BNType),
	]


# noinspection PyPep8Naming
def BNAddTypeLibraryNamedType(
		lib: ctypes.POINTER(BNTypeLibrary), 
		name: ctypes.POINTER(BNQualifiedName), 
		type: ctypes.POINTER(BNType)
		) -> None:
	return _BNAddTypeLibraryNamedType(lib, name, type)


# -------------------------------------------------------
# _BNAddTypeLibraryNamedTypeSource

_BNAddTypeLibraryNamedTypeSource = core.BNAddTypeLibraryNamedTypeSource
_BNAddTypeLibraryNamedTypeSource.restype = None
_BNAddTypeLibraryNamedTypeSource.argtypes = [
		ctypes.POINTER(BNTypeLibrary),
		ctypes.POINTER(BNQualifiedName),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNAddTypeLibraryNamedTypeSource(
		lib: ctypes.POINTER(BNTypeLibrary), 
		name: ctypes.POINTER(BNQualifiedName), 
		source: Optional[str]
		) -> None:
	return _BNAddTypeLibraryNamedTypeSource(lib, name, cstr(source))


# -------------------------------------------------------
# _BNAddTypeLibraryPlatform

_BNAddTypeLibraryPlatform = core.BNAddTypeLibraryPlatform
_BNAddTypeLibraryPlatform.restype = None
_BNAddTypeLibraryPlatform.argtypes = [
		ctypes.POINTER(BNTypeLibrary),
		ctypes.POINTER(BNPlatform),
	]


# noinspection PyPep8Naming
def BNAddTypeLibraryPlatform(
		lib: ctypes.POINTER(BNTypeLibrary), 
		platform: ctypes.POINTER(BNPlatform)
		) -> None:
	return _BNAddTypeLibraryPlatform(lib, platform)


# -------------------------------------------------------
# _BNAddTypeMemberTokens

_BNAddTypeMemberTokens = core.BNAddTypeMemberTokens
_BNAddTypeMemberTokens.restype = ctypes.c_bool
_BNAddTypeMemberTokens.argtypes = [
		ctypes.POINTER(BNType),
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(ctypes.POINTER(BNInstructionTextToken)),
		ctypes.POINTER(ctypes.c_ulonglong),
		ctypes.c_longlong,
		ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)),
		ctypes.POINTER(ctypes.c_ulonglong),
		ctypes.c_ulonglong,
		ctypes.c_bool,
	]


# noinspection PyPep8Naming
def BNAddTypeMemberTokens(
		type: ctypes.POINTER(BNType), 
		data: ctypes.POINTER(BNBinaryView), 
		tokens: ctypes.POINTER(ctypes.POINTER(BNInstructionTextToken)), 
		tokenCount: ctypes.POINTER(ctypes.c_ulonglong), 
		offset: int, 
		nameList: ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)), 
		nameCount: ctypes.POINTER(ctypes.c_ulonglong), 
		size: int, 
		indirect: bool
		) -> bool:
	return _BNAddTypeMemberTokens(type, data, tokens, tokenCount, offset, nameList, nameCount, size, indirect)


# -------------------------------------------------------
# _BNAddUserAddressTag

_BNAddUserAddressTag = core.BNAddUserAddressTag
_BNAddUserAddressTag.restype = None
_BNAddUserAddressTag.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNArchitecture),
		ctypes.c_ulonglong,
		ctypes.POINTER(BNTag),
	]


# noinspection PyPep8Naming
def BNAddUserAddressTag(
		func: ctypes.POINTER(BNFunction), 
		arch: ctypes.POINTER(BNArchitecture), 
		addr: int, 
		tag: ctypes.POINTER(BNTag)
		) -> None:
	return _BNAddUserAddressTag(func, arch, addr, tag)


# -------------------------------------------------------
# _BNAddUserCodeReference

_BNAddUserCodeReference = core.BNAddUserCodeReference
_BNAddUserCodeReference.restype = None
_BNAddUserCodeReference.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNArchitecture),
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNAddUserCodeReference(
		func: ctypes.POINTER(BNFunction), 
		fromArch: ctypes.POINTER(BNArchitecture), 
		fromAddr: int, 
		toAddr: int
		) -> None:
	return _BNAddUserCodeReference(func, fromArch, fromAddr, toAddr)


# -------------------------------------------------------
# _BNAddUserDataReference

_BNAddUserDataReference = core.BNAddUserDataReference
_BNAddUserDataReference.restype = None
_BNAddUserDataReference.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNAddUserDataReference(
		view: ctypes.POINTER(BNBinaryView), 
		fromAddr: int, 
		toAddr: int
		) -> None:
	return _BNAddUserDataReference(view, fromAddr, toAddr)


# -------------------------------------------------------
# _BNAddUserDataTag

_BNAddUserDataTag = core.BNAddUserDataTag
_BNAddUserDataTag.restype = None
_BNAddUserDataTag.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
		ctypes.POINTER(BNTag),
	]


# noinspection PyPep8Naming
def BNAddUserDataTag(
		view: ctypes.POINTER(BNBinaryView), 
		addr: int, 
		tag: ctypes.POINTER(BNTag)
		) -> None:
	return _BNAddUserDataTag(view, addr, tag)


# -------------------------------------------------------
# _BNAddUserFunctionTag

_BNAddUserFunctionTag = core.BNAddUserFunctionTag
_BNAddUserFunctionTag.restype = None
_BNAddUserFunctionTag.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNTag),
	]


# noinspection PyPep8Naming
def BNAddUserFunctionTag(
		func: ctypes.POINTER(BNFunction), 
		tag: ctypes.POINTER(BNTag)
		) -> None:
	return _BNAddUserFunctionTag(func, tag)


# -------------------------------------------------------
# _BNAddUserSection

_BNAddUserSection = core.BNAddUserSection
_BNAddUserSection.restype = None
_BNAddUserSection.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_char_p,
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
		SectionSemanticsEnum,
		ctypes.c_char_p,
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
		ctypes.c_char_p,
		ctypes.c_char_p,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNAddUserSection(
		view: ctypes.POINTER(BNBinaryView), 
		name: Optional[str], 
		start: int, 
		length: int, 
		semantics: SectionSemantics, 
		type: Optional[str], 
		align: int, 
		entrySize: int, 
		linkedSection: Optional[str], 
		infoSection: Optional[str], 
		infoData: int
		) -> None:
	return _BNAddUserSection(view, cstr(name), start, length, semantics, cstr(type), align, entrySize, cstr(linkedSection), cstr(infoSection), infoData)


# -------------------------------------------------------
# _BNAddUserSegment

_BNAddUserSegment = core.BNAddUserSegment
_BNAddUserSegment.restype = None
_BNAddUserSegment.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
		ctypes.c_uint,
	]


# noinspection PyPep8Naming
def BNAddUserSegment(
		view: ctypes.POINTER(BNBinaryView), 
		start: int, 
		length: int, 
		dataOffset: int, 
		dataLength: int, 
		flags: int
		) -> None:
	return _BNAddUserSegment(view, start, length, dataOffset, dataLength, flags)


# -------------------------------------------------------
# _BNAddUserTypeFieldReference

_BNAddUserTypeFieldReference = core.BNAddUserTypeFieldReference
_BNAddUserTypeFieldReference.restype = None
_BNAddUserTypeFieldReference.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNArchitecture),
		ctypes.c_ulonglong,
		ctypes.POINTER(BNQualifiedName),
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNAddUserTypeFieldReference(
		func: ctypes.POINTER(BNFunction), 
		fromArch: ctypes.POINTER(BNArchitecture), 
		fromAddr: int, 
		name: ctypes.POINTER(BNQualifiedName), 
		offset: int, 
		size: int
		) -> None:
	return _BNAddUserTypeFieldReference(func, fromArch, fromAddr, name, offset, size)


# -------------------------------------------------------
# _BNAddUserTypeReference

_BNAddUserTypeReference = core.BNAddUserTypeReference
_BNAddUserTypeReference.restype = None
_BNAddUserTypeReference.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNArchitecture),
		ctypes.c_ulonglong,
		ctypes.POINTER(BNQualifiedName),
	]


# noinspection PyPep8Naming
def BNAddUserTypeReference(
		func: ctypes.POINTER(BNFunction), 
		fromArch: ctypes.POINTER(BNArchitecture), 
		fromAddr: int, 
		name: ctypes.POINTER(BNQualifiedName)
		) -> None:
	return _BNAddUserTypeReference(func, fromArch, fromAddr, name)


# -------------------------------------------------------
# _BNAllocString

_BNAllocString = core.BNAllocString
_BNAllocString.restype = ctypes.c_void_p
_BNAllocString.argtypes = [
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNAllocString(
		contents: Optional[str]
		) -> Optional[Optional[str]]:
	result = _BNAllocString(cstr(contents))
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNAllocStringList

_BNAllocStringList = core.BNAllocStringList
_BNAllocStringList.restype = ctypes.POINTER(ctypes.c_char_p)
_BNAllocStringList.argtypes = [
		ctypes.POINTER(ctypes.c_char_p),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNAllocStringList(
		contents: ctypes.POINTER(ctypes.c_char_p), 
		size: int
		) -> Optional[ctypes.POINTER(ctypes.c_char_p)]:
	result = _BNAllocStringList(contents, size)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNAlwaysBranch

_BNAlwaysBranch = core.BNAlwaysBranch
_BNAlwaysBranch.restype = ctypes.c_bool
_BNAlwaysBranch.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNArchitecture),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNAlwaysBranch(
		view: ctypes.POINTER(BNBinaryView), 
		arch: ctypes.POINTER(BNArchitecture), 
		addr: int
		) -> bool:
	return _BNAlwaysBranch(view, arch, addr)


# -------------------------------------------------------
# _BNAnalysisContextGetFunction

_BNAnalysisContextGetFunction = core.BNAnalysisContextGetFunction
_BNAnalysisContextGetFunction.restype = ctypes.POINTER(BNFunction)
_BNAnalysisContextGetFunction.argtypes = [
		ctypes.POINTER(BNAnalysisContext),
	]


# noinspection PyPep8Naming
def BNAnalysisContextGetFunction(
		analysisContext: ctypes.POINTER(BNAnalysisContext)
		) -> Optional[ctypes.POINTER(BNFunction)]:
	result = _BNAnalysisContextGetFunction(analysisContext)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNAnalysisContextGetHighLevelILFunction

_BNAnalysisContextGetHighLevelILFunction = core.BNAnalysisContextGetHighLevelILFunction
_BNAnalysisContextGetHighLevelILFunction.restype = ctypes.POINTER(BNHighLevelILFunction)
_BNAnalysisContextGetHighLevelILFunction.argtypes = [
		ctypes.POINTER(BNAnalysisContext),
	]


# noinspection PyPep8Naming
def BNAnalysisContextGetHighLevelILFunction(
		analysisContext: ctypes.POINTER(BNAnalysisContext)
		) -> Optional[ctypes.POINTER(BNHighLevelILFunction)]:
	result = _BNAnalysisContextGetHighLevelILFunction(analysisContext)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNAnalysisContextGetLowLevelILFunction

_BNAnalysisContextGetLowLevelILFunction = core.BNAnalysisContextGetLowLevelILFunction
_BNAnalysisContextGetLowLevelILFunction.restype = ctypes.POINTER(BNLowLevelILFunction)
_BNAnalysisContextGetLowLevelILFunction.argtypes = [
		ctypes.POINTER(BNAnalysisContext),
	]


# noinspection PyPep8Naming
def BNAnalysisContextGetLowLevelILFunction(
		analysisContext: ctypes.POINTER(BNAnalysisContext)
		) -> Optional[ctypes.POINTER(BNLowLevelILFunction)]:
	result = _BNAnalysisContextGetLowLevelILFunction(analysisContext)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNAnalysisContextGetMediumLevelILFunction

_BNAnalysisContextGetMediumLevelILFunction = core.BNAnalysisContextGetMediumLevelILFunction
_BNAnalysisContextGetMediumLevelILFunction.restype = ctypes.POINTER(BNMediumLevelILFunction)
_BNAnalysisContextGetMediumLevelILFunction.argtypes = [
		ctypes.POINTER(BNAnalysisContext),
	]


# noinspection PyPep8Naming
def BNAnalysisContextGetMediumLevelILFunction(
		analysisContext: ctypes.POINTER(BNAnalysisContext)
		) -> Optional[ctypes.POINTER(BNMediumLevelILFunction)]:
	result = _BNAnalysisContextGetMediumLevelILFunction(analysisContext)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNAnalysisContextInform

_BNAnalysisContextInform = core.BNAnalysisContextInform
_BNAnalysisContextInform.restype = ctypes.c_bool
_BNAnalysisContextInform.argtypes = [
		ctypes.POINTER(BNAnalysisContext),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNAnalysisContextInform(
		analysisContext: ctypes.POINTER(BNAnalysisContext), 
		request: Optional[str]
		) -> bool:
	return _BNAnalysisContextInform(analysisContext, cstr(request))


# -------------------------------------------------------
# _BNAppendDataBuffer

_BNAppendDataBuffer = core.BNAppendDataBuffer
_BNAppendDataBuffer.restype = None
_BNAppendDataBuffer.argtypes = [
		ctypes.POINTER(BNDataBuffer),
		ctypes.POINTER(BNDataBuffer),
	]


# noinspection PyPep8Naming
def BNAppendDataBuffer(
		dest: ctypes.POINTER(BNDataBuffer), 
		src: ctypes.POINTER(BNDataBuffer)
		) -> None:
	return _BNAppendDataBuffer(dest, src)


# -------------------------------------------------------
# _BNAppendDataBufferContents

_BNAppendDataBufferContents = core.BNAppendDataBufferContents
_BNAppendDataBufferContents.restype = None
_BNAppendDataBufferContents.argtypes = [
		ctypes.POINTER(BNDataBuffer),
		ctypes.c_void_p,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNAppendDataBufferContents(
		dest: ctypes.POINTER(BNDataBuffer), 
		src: Optional[ctypes.c_void_p], 
		len: int
		) -> None:
	return _BNAppendDataBufferContents(dest, src, len)


# -------------------------------------------------------
# _BNAppendPath

_BNAppendPath = core.BNAppendPath
_BNAppendPath.restype = ctypes.POINTER(ctypes.c_byte)
_BNAppendPath.argtypes = [
		ctypes.c_char_p,
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNAppendPath(
		path: Optional[str], 
		part: Optional[str]
		) -> Optional[Optional[str]]:
	result = _BNAppendPath(cstr(path), cstr(part))
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNAppendSymbolQueue

_BNAppendSymbolQueue = core.BNAppendSymbolQueue
_BNAppendSymbolQueue.restype = None
_BNAppendSymbolQueue.argtypes = [
		ctypes.POINTER(BNSymbolQueue),
		ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(ctypes.POINTER(BNSymbol)), ctypes.POINTER(ctypes.POINTER(BNType))),
		ctypes.c_void_p,
		ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNSymbol), ctypes.POINTER(BNType)),
		ctypes.c_void_p,
	]


# noinspection PyPep8Naming
def BNAppendSymbolQueue(
		queue: ctypes.POINTER(BNSymbolQueue), 
		resolve: ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(ctypes.POINTER(BNSymbol)), ctypes.POINTER(ctypes.POINTER(BNType))), 
		resolveContext: Optional[ctypes.c_void_p], 
		add: ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNSymbol), ctypes.POINTER(BNType)), 
		addContext: Optional[ctypes.c_void_p]
		) -> None:
	return _BNAppendSymbolQueue(queue, resolve, resolveContext, add, addContext)


# -------------------------------------------------------
# _BNApplyAutoDiscoveredFunctionType

_BNApplyAutoDiscoveredFunctionType = core.BNApplyAutoDiscoveredFunctionType
_BNApplyAutoDiscoveredFunctionType.restype = None
_BNApplyAutoDiscoveredFunctionType.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNType),
	]


# noinspection PyPep8Naming
def BNApplyAutoDiscoveredFunctionType(
		func: ctypes.POINTER(BNFunction), 
		type: ctypes.POINTER(BNType)
		) -> None:
	return _BNApplyAutoDiscoveredFunctionType(func, type)


# -------------------------------------------------------
# _BNApplyDebugInfo

_BNApplyDebugInfo = core.BNApplyDebugInfo
_BNApplyDebugInfo.restype = None
_BNApplyDebugInfo.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNDebugInfo),
	]


# noinspection PyPep8Naming
def BNApplyDebugInfo(
		view: ctypes.POINTER(BNBinaryView), 
		newDebugInfo: ctypes.POINTER(BNDebugInfo)
		) -> None:
	return _BNApplyDebugInfo(view, newDebugInfo)


# -------------------------------------------------------
# _BNApplyImportedTypes

_BNApplyImportedTypes = core.BNApplyImportedTypes
_BNApplyImportedTypes.restype = None
_BNApplyImportedTypes.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNSymbol),
		ctypes.POINTER(BNType),
	]


# noinspection PyPep8Naming
def BNApplyImportedTypes(
		func: ctypes.POINTER(BNFunction), 
		sym: ctypes.POINTER(BNSymbol), 
		type: ctypes.POINTER(BNType)
		) -> None:
	return _BNApplyImportedTypes(func, sym, type)


# -------------------------------------------------------
# _BNApplySnapshotData

_BNApplySnapshotData = core.BNApplySnapshotData
_BNApplySnapshotData.restype = None
_BNApplySnapshotData.argtypes = [
		ctypes.POINTER(BNFileMetadata),
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNKeyValueStore),
		ctypes.POINTER(BNKeyValueStore),
		ctypes.c_void_p,
		ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong),
		ctypes.c_bool,
		ctypes.c_bool,
	]


# noinspection PyPep8Naming
def BNApplySnapshotData(
		file: ctypes.POINTER(BNFileMetadata), 
		view: ctypes.POINTER(BNBinaryView), 
		data: ctypes.POINTER(BNKeyValueStore), 
		cache: ctypes.POINTER(BNKeyValueStore), 
		ctxt: Optional[ctypes.c_void_p], 
		progress: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong), 
		openForConfiguration: bool, 
		restoreRawView: bool
		) -> None:
	return _BNApplySnapshotData(file, view, data, cache, ctxt, progress, openForConfiguration, restoreRawView)


# -------------------------------------------------------
# _BNArchitectureAlwaysBranch

_BNArchitectureAlwaysBranch = core.BNArchitectureAlwaysBranch
_BNArchitectureAlwaysBranch.restype = ctypes.c_bool
_BNArchitectureAlwaysBranch.argtypes = [
		ctypes.POINTER(BNArchitecture),
		ctypes.POINTER(ctypes.c_ubyte),
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNArchitectureAlwaysBranch(
		arch: ctypes.POINTER(BNArchitecture), 
		data: ctypes.POINTER(ctypes.c_ubyte), 
		addr: int, 
		len: int
		) -> bool:
	return _BNArchitectureAlwaysBranch(arch, data, addr, len)


# -------------------------------------------------------
# _BNArchitectureConvertToNop

_BNArchitectureConvertToNop = core.BNArchitectureConvertToNop
_BNArchitectureConvertToNop.restype = ctypes.c_bool
_BNArchitectureConvertToNop.argtypes = [
		ctypes.POINTER(BNArchitecture),
		ctypes.POINTER(ctypes.c_ubyte),
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNArchitectureConvertToNop(
		arch: ctypes.POINTER(BNArchitecture), 
		data: ctypes.POINTER(ctypes.c_ubyte), 
		addr: int, 
		len: int
		) -> bool:
	return _BNArchitectureConvertToNop(arch, data, addr, len)


# -------------------------------------------------------
# _BNArchitectureGetRelocationHandler

_BNArchitectureGetRelocationHandler = core.BNArchitectureGetRelocationHandler
_BNArchitectureGetRelocationHandler.restype = ctypes.POINTER(BNRelocationHandler)
_BNArchitectureGetRelocationHandler.argtypes = [
		ctypes.POINTER(BNArchitecture),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNArchitectureGetRelocationHandler(
		arch: ctypes.POINTER(BNArchitecture), 
		viewName: Optional[str]
		) -> Optional[ctypes.POINTER(BNRelocationHandler)]:
	result = _BNArchitectureGetRelocationHandler(arch, cstr(viewName))
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNArchitectureInvertBranch

_BNArchitectureInvertBranch = core.BNArchitectureInvertBranch
_BNArchitectureInvertBranch.restype = ctypes.c_bool
_BNArchitectureInvertBranch.argtypes = [
		ctypes.POINTER(BNArchitecture),
		ctypes.POINTER(ctypes.c_ubyte),
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNArchitectureInvertBranch(
		arch: ctypes.POINTER(BNArchitecture), 
		data: ctypes.POINTER(ctypes.c_ubyte), 
		addr: int, 
		len: int
		) -> bool:
	return _BNArchitectureInvertBranch(arch, data, addr, len)


# -------------------------------------------------------
# _BNArchitectureRegisterRelocationHandler

_BNArchitectureRegisterRelocationHandler = core.BNArchitectureRegisterRelocationHandler
_BNArchitectureRegisterRelocationHandler.restype = None
_BNArchitectureRegisterRelocationHandler.argtypes = [
		ctypes.POINTER(BNArchitecture),
		ctypes.c_char_p,
		ctypes.POINTER(BNRelocationHandler),
	]


# noinspection PyPep8Naming
def BNArchitectureRegisterRelocationHandler(
		arch: ctypes.POINTER(BNArchitecture), 
		viewName: Optional[str], 
		handler: ctypes.POINTER(BNRelocationHandler)
		) -> None:
	return _BNArchitectureRegisterRelocationHandler(arch, cstr(viewName), handler)


# -------------------------------------------------------
# _BNArchitectureSkipAndReturnValue

_BNArchitectureSkipAndReturnValue = core.BNArchitectureSkipAndReturnValue
_BNArchitectureSkipAndReturnValue.restype = ctypes.c_bool
_BNArchitectureSkipAndReturnValue.argtypes = [
		ctypes.POINTER(BNArchitecture),
		ctypes.POINTER(ctypes.c_ubyte),
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNArchitectureSkipAndReturnValue(
		arch: ctypes.POINTER(BNArchitecture), 
		data: ctypes.POINTER(ctypes.c_ubyte), 
		addr: int, 
		len: int, 
		value: int
		) -> bool:
	return _BNArchitectureSkipAndReturnValue(arch, data, addr, len, value)


# -------------------------------------------------------
# _BNAreArgumentRegistersSharedIndex

_BNAreArgumentRegistersSharedIndex = core.BNAreArgumentRegistersSharedIndex
_BNAreArgumentRegistersSharedIndex.restype = ctypes.c_bool
_BNAreArgumentRegistersSharedIndex.argtypes = [
		ctypes.POINTER(BNCallingConvention),
	]


# noinspection PyPep8Naming
def BNAreArgumentRegistersSharedIndex(
		cc: ctypes.POINTER(BNCallingConvention)
		) -> bool:
	return _BNAreArgumentRegistersSharedIndex(cc)


# -------------------------------------------------------
# _BNAreArgumentRegistersUsedForVarArgs

_BNAreArgumentRegistersUsedForVarArgs = core.BNAreArgumentRegistersUsedForVarArgs
_BNAreArgumentRegistersUsedForVarArgs.restype = ctypes.c_bool
_BNAreArgumentRegistersUsedForVarArgs.argtypes = [
		ctypes.POINTER(BNCallingConvention),
	]


# noinspection PyPep8Naming
def BNAreArgumentRegistersUsedForVarArgs(
		cc: ctypes.POINTER(BNCallingConvention)
		) -> bool:
	return _BNAreArgumentRegistersUsedForVarArgs(cc)


# -------------------------------------------------------
# _BNAreAutoUpdatesEnabled

_BNAreAutoUpdatesEnabled = core.BNAreAutoUpdatesEnabled
_BNAreAutoUpdatesEnabled.restype = ctypes.c_bool
_BNAreAutoUpdatesEnabled.argtypes = [
	]


# noinspection PyPep8Naming
def BNAreAutoUpdatesEnabled(
		) -> bool:
	return _BNAreAutoUpdatesEnabled()


# -------------------------------------------------------
# _BNAreUpdatesAvailable

_BNAreUpdatesAvailable = core.BNAreUpdatesAvailable
_BNAreUpdatesAvailable.restype = ctypes.c_bool
_BNAreUpdatesAvailable.argtypes = [
		ctypes.c_char_p,
		ctypes.POINTER(ctypes.c_ulonglong),
		ctypes.POINTER(ctypes.c_ulonglong),
		ctypes.POINTER(ctypes.c_char_p),
	]


# noinspection PyPep8Naming
def BNAreUpdatesAvailable(
		channel: Optional[str], 
		expireTime: ctypes.POINTER(ctypes.c_ulonglong), 
		serverTime: ctypes.POINTER(ctypes.c_ulonglong), 
		errors: ctypes.POINTER(ctypes.c_char_p)
		) -> bool:
	return _BNAreUpdatesAvailable(cstr(channel), expireTime, serverTime, errors)


# -------------------------------------------------------
# _BNAssemble

_BNAssemble = core.BNAssemble
_BNAssemble.restype = ctypes.c_bool
_BNAssemble.argtypes = [
		ctypes.POINTER(BNArchitecture),
		ctypes.c_char_p,
		ctypes.c_ulonglong,
		ctypes.POINTER(BNDataBuffer),
		ctypes.POINTER(ctypes.c_char_p),
	]


# noinspection PyPep8Naming
def BNAssemble(
		arch: ctypes.POINTER(BNArchitecture), 
		code: Optional[str], 
		addr: int, 
		result: ctypes.POINTER(BNDataBuffer), 
		errors: ctypes.POINTER(ctypes.c_char_p)
		) -> bool:
	return _BNAssemble(arch, cstr(code), addr, result, errors)


# -------------------------------------------------------
# _BNAssignDataBuffer

_BNAssignDataBuffer = core.BNAssignDataBuffer
_BNAssignDataBuffer.restype = None
_BNAssignDataBuffer.argtypes = [
		ctypes.POINTER(BNDataBuffer),
		ctypes.POINTER(BNDataBuffer),
	]


# noinspection PyPep8Naming
def BNAssignDataBuffer(
		dest: ctypes.POINTER(BNDataBuffer), 
		src: ctypes.POINTER(BNDataBuffer)
		) -> None:
	return _BNAssignDataBuffer(dest, src)


# -------------------------------------------------------
# _BNAuthenticateEnterpriseServerWithCredentials

_BNAuthenticateEnterpriseServerWithCredentials = core.BNAuthenticateEnterpriseServerWithCredentials
_BNAuthenticateEnterpriseServerWithCredentials.restype = ctypes.c_bool
_BNAuthenticateEnterpriseServerWithCredentials.argtypes = [
		ctypes.c_char_p,
		ctypes.c_char_p,
		ctypes.c_bool,
	]


# noinspection PyPep8Naming
def BNAuthenticateEnterpriseServerWithCredentials(
		username: Optional[str], 
		password: Optional[str], 
		remember: bool
		) -> bool:
	return _BNAuthenticateEnterpriseServerWithCredentials(cstr(username), cstr(password), remember)


# -------------------------------------------------------
# _BNAuthenticateEnterpriseServerWithMethod

_BNAuthenticateEnterpriseServerWithMethod = core.BNAuthenticateEnterpriseServerWithMethod
_BNAuthenticateEnterpriseServerWithMethod.restype = ctypes.c_bool
_BNAuthenticateEnterpriseServerWithMethod.argtypes = [
		ctypes.c_char_p,
		ctypes.c_bool,
	]


# noinspection PyPep8Naming
def BNAuthenticateEnterpriseServerWithMethod(
		method: Optional[str], 
		remember: bool
		) -> bool:
	return _BNAuthenticateEnterpriseServerWithMethod(cstr(method), remember)


# -------------------------------------------------------
# _BNBasicBlockCanExit

_BNBasicBlockCanExit = core.BNBasicBlockCanExit
_BNBasicBlockCanExit.restype = ctypes.c_bool
_BNBasicBlockCanExit.argtypes = [
		ctypes.POINTER(BNBasicBlock),
	]


# noinspection PyPep8Naming
def BNBasicBlockCanExit(
		block: ctypes.POINTER(BNBasicBlock)
		) -> bool:
	return _BNBasicBlockCanExit(block)


# -------------------------------------------------------
# _BNBasicBlockHasInvalidInstructions

_BNBasicBlockHasInvalidInstructions = core.BNBasicBlockHasInvalidInstructions
_BNBasicBlockHasInvalidInstructions.restype = ctypes.c_bool
_BNBasicBlockHasInvalidInstructions.argtypes = [
		ctypes.POINTER(BNBasicBlock),
	]


# noinspection PyPep8Naming
def BNBasicBlockHasInvalidInstructions(
		block: ctypes.POINTER(BNBasicBlock)
		) -> bool:
	return _BNBasicBlockHasInvalidInstructions(block)


# -------------------------------------------------------
# _BNBasicBlockHasUndeterminedOutgoingEdges

_BNBasicBlockHasUndeterminedOutgoingEdges = core.BNBasicBlockHasUndeterminedOutgoingEdges
_BNBasicBlockHasUndeterminedOutgoingEdges.restype = ctypes.c_bool
_BNBasicBlockHasUndeterminedOutgoingEdges.argtypes = [
		ctypes.POINTER(BNBasicBlock),
	]


# noinspection PyPep8Naming
def BNBasicBlockHasUndeterminedOutgoingEdges(
		block: ctypes.POINTER(BNBasicBlock)
		) -> bool:
	return _BNBasicBlockHasUndeterminedOutgoingEdges(block)


# -------------------------------------------------------
# _BNBasicBlockSetCanExit

_BNBasicBlockSetCanExit = core.BNBasicBlockSetCanExit
_BNBasicBlockSetCanExit.restype = None
_BNBasicBlockSetCanExit.argtypes = [
		ctypes.POINTER(BNBasicBlock),
		ctypes.c_bool,
	]


# noinspection PyPep8Naming
def BNBasicBlockSetCanExit(
		block: ctypes.POINTER(BNBasicBlock), 
		value: bool
		) -> None:
	return _BNBasicBlockSetCanExit(block, value)


# -------------------------------------------------------
# _BNBeginBackgroundTask

_BNBeginBackgroundTask = core.BNBeginBackgroundTask
_BNBeginBackgroundTask.restype = ctypes.POINTER(BNBackgroundTask)
_BNBeginBackgroundTask.argtypes = [
		ctypes.c_char_p,
		ctypes.c_bool,
	]


# noinspection PyPep8Naming
def BNBeginBackgroundTask(
		initialText: Optional[str], 
		canCancel: bool
		) -> Optional[ctypes.POINTER(BNBackgroundTask)]:
	result = _BNBeginBackgroundTask(cstr(initialText), canCancel)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNBeginBulkModifySymbols

_BNBeginBulkModifySymbols = core.BNBeginBulkModifySymbols
_BNBeginBulkModifySymbols.restype = None
_BNBeginBulkModifySymbols.argtypes = [
		ctypes.POINTER(BNBinaryView),
	]


# noinspection PyPep8Naming
def BNBeginBulkModifySymbols(
		view: ctypes.POINTER(BNBinaryView)
		) -> None:
	return _BNBeginBulkModifySymbols(view)


# -------------------------------------------------------
# _BNBeginKeyValueStoreNamespace

_BNBeginKeyValueStoreNamespace = core.BNBeginKeyValueStoreNamespace
_BNBeginKeyValueStoreNamespace.restype = None
_BNBeginKeyValueStoreNamespace.argtypes = [
		ctypes.POINTER(BNKeyValueStore),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNBeginKeyValueStoreNamespace(
		store: ctypes.POINTER(BNKeyValueStore), 
		name: Optional[str]
		) -> None:
	return _BNBeginKeyValueStoreNamespace(store, cstr(name))


# -------------------------------------------------------
# _BNBeginUndoActions

_BNBeginUndoActions = core.BNBeginUndoActions
_BNBeginUndoActions.restype = ctypes.POINTER(ctypes.c_byte)
_BNBeginUndoActions.argtypes = [
		ctypes.POINTER(BNFileMetadata),
		ctypes.c_bool,
	]


# noinspection PyPep8Naming
def BNBeginUndoActions(
		file: ctypes.POINTER(BNFileMetadata), 
		anonymousAllowed: bool
		) -> Optional[Optional[str]]:
	result = _BNBeginUndoActions(file, anonymousAllowed)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNBinaryViewAddExternalLibrary

_BNBinaryViewAddExternalLibrary = core.BNBinaryViewAddExternalLibrary
_BNBinaryViewAddExternalLibrary.restype = ctypes.POINTER(BNExternalLibrary)
_BNBinaryViewAddExternalLibrary.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_char_p,
		ctypes.POINTER(BNProjectFile),
		ctypes.c_bool,
	]


# noinspection PyPep8Naming
def BNBinaryViewAddExternalLibrary(
		view: ctypes.POINTER(BNBinaryView), 
		name: Optional[str], 
		backingFile: ctypes.POINTER(BNProjectFile), 
		isAuto: bool
		) -> Optional[ctypes.POINTER(BNExternalLibrary)]:
	result = _BNBinaryViewAddExternalLibrary(view, cstr(name), backingFile, isAuto)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNBinaryViewAddExternalLocation

_BNBinaryViewAddExternalLocation = core.BNBinaryViewAddExternalLocation
_BNBinaryViewAddExternalLocation.restype = ctypes.POINTER(BNExternalLocation)
_BNBinaryViewAddExternalLocation.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNSymbol),
		ctypes.POINTER(BNExternalLibrary),
		ctypes.c_char_p,
		ctypes.POINTER(ctypes.c_ulonglong),
		ctypes.c_bool,
	]


# noinspection PyPep8Naming
def BNBinaryViewAddExternalLocation(
		view: ctypes.POINTER(BNBinaryView), 
		sourceSymbol: ctypes.POINTER(BNSymbol), 
		library: ctypes.POINTER(BNExternalLibrary), 
		targetSymbol: Optional[str], 
		targetAddress: ctypes.POINTER(ctypes.c_ulonglong), 
		isAuto: bool
		) -> Optional[ctypes.POINTER(BNExternalLocation)]:
	result = _BNBinaryViewAddExternalLocation(view, sourceSymbol, library, cstr(targetSymbol), targetAddress, isAuto)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNBinaryViewAttachTypeArchive

_BNBinaryViewAttachTypeArchive = core.BNBinaryViewAttachTypeArchive
_BNBinaryViewAttachTypeArchive.restype = ctypes.POINTER(BNTypeArchive)
_BNBinaryViewAttachTypeArchive.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_char_p,
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNBinaryViewAttachTypeArchive(
		view: ctypes.POINTER(BNBinaryView), 
		id: Optional[str], 
		path: Optional[str]
		) -> Optional[ctypes.POINTER(BNTypeArchive)]:
	result = _BNBinaryViewAttachTypeArchive(view, cstr(id), cstr(path))
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNBinaryViewDetachTypeArchive

_BNBinaryViewDetachTypeArchive = core.BNBinaryViewDetachTypeArchive
_BNBinaryViewDetachTypeArchive.restype = ctypes.c_bool
_BNBinaryViewDetachTypeArchive.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNBinaryViewDetachTypeArchive(
		view: ctypes.POINTER(BNBinaryView), 
		id: Optional[str]
		) -> bool:
	return _BNBinaryViewDetachTypeArchive(view, cstr(id))


# -------------------------------------------------------
# _BNBinaryViewDisassociateTypeArchiveType

_BNBinaryViewDisassociateTypeArchiveType = core.BNBinaryViewDisassociateTypeArchiveType
_BNBinaryViewDisassociateTypeArchiveType.restype = ctypes.c_bool
_BNBinaryViewDisassociateTypeArchiveType.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNBinaryViewDisassociateTypeArchiveType(
		view: ctypes.POINTER(BNBinaryView), 
		typeId: Optional[str]
		) -> bool:
	return _BNBinaryViewDisassociateTypeArchiveType(view, cstr(typeId))


# -------------------------------------------------------
# _BNBinaryViewExportObjectToTypeLibrary

_BNBinaryViewExportObjectToTypeLibrary = core.BNBinaryViewExportObjectToTypeLibrary
_BNBinaryViewExportObjectToTypeLibrary.restype = None
_BNBinaryViewExportObjectToTypeLibrary.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNTypeLibrary),
		ctypes.POINTER(BNQualifiedName),
		ctypes.POINTER(BNType),
	]


# noinspection PyPep8Naming
def BNBinaryViewExportObjectToTypeLibrary(
		view: ctypes.POINTER(BNBinaryView), 
		lib: ctypes.POINTER(BNTypeLibrary), 
		name: ctypes.POINTER(BNQualifiedName), 
		type: ctypes.POINTER(BNType)
		) -> None:
	return _BNBinaryViewExportObjectToTypeLibrary(view, lib, name, type)


# -------------------------------------------------------
# _BNBinaryViewExportTypeToTypeLibrary

_BNBinaryViewExportTypeToTypeLibrary = core.BNBinaryViewExportTypeToTypeLibrary
_BNBinaryViewExportTypeToTypeLibrary.restype = None
_BNBinaryViewExportTypeToTypeLibrary.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNTypeLibrary),
		ctypes.POINTER(BNQualifiedName),
		ctypes.POINTER(BNType),
	]


# noinspection PyPep8Naming
def BNBinaryViewExportTypeToTypeLibrary(
		view: ctypes.POINTER(BNBinaryView), 
		lib: ctypes.POINTER(BNTypeLibrary), 
		name: ctypes.POINTER(BNQualifiedName), 
		type: ctypes.POINTER(BNType)
		) -> None:
	return _BNBinaryViewExportTypeToTypeLibrary(view, lib, name, type)


# -------------------------------------------------------
# _BNBinaryViewGetAssociatedTypeArchiveTypeSource

_BNBinaryViewGetAssociatedTypeArchiveTypeSource = core.BNBinaryViewGetAssociatedTypeArchiveTypeSource
_BNBinaryViewGetAssociatedTypeArchiveTypeSource.restype = ctypes.c_bool
_BNBinaryViewGetAssociatedTypeArchiveTypeSource.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_char_p,
		ctypes.c_char_p,
		ctypes.POINTER(ctypes.c_char_p),
	]


# noinspection PyPep8Naming
def BNBinaryViewGetAssociatedTypeArchiveTypeSource(
		view: ctypes.POINTER(BNBinaryView), 
		archiveId: Optional[str], 
		archiveTypeId: Optional[str], 
		typeId: ctypes.POINTER(ctypes.c_char_p)
		) -> bool:
	return _BNBinaryViewGetAssociatedTypeArchiveTypeSource(view, cstr(archiveId), cstr(archiveTypeId), typeId)


# -------------------------------------------------------
# _BNBinaryViewGetAssociatedTypeArchiveTypeTarget

_BNBinaryViewGetAssociatedTypeArchiveTypeTarget = core.BNBinaryViewGetAssociatedTypeArchiveTypeTarget
_BNBinaryViewGetAssociatedTypeArchiveTypeTarget.restype = ctypes.c_bool
_BNBinaryViewGetAssociatedTypeArchiveTypeTarget.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_char_p,
		ctypes.POINTER(ctypes.c_char_p),
		ctypes.POINTER(ctypes.c_char_p),
	]


# noinspection PyPep8Naming
def BNBinaryViewGetAssociatedTypeArchiveTypeTarget(
		view: ctypes.POINTER(BNBinaryView), 
		typeId: Optional[str], 
		archiveId: ctypes.POINTER(ctypes.c_char_p), 
		archiveTypeId: ctypes.POINTER(ctypes.c_char_p)
		) -> bool:
	return _BNBinaryViewGetAssociatedTypeArchiveTypeTarget(view, cstr(typeId), archiveId, archiveTypeId)


# -------------------------------------------------------
# _BNBinaryViewGetAssociatedTypeArchiveTypes

_BNBinaryViewGetAssociatedTypeArchiveTypes = core.BNBinaryViewGetAssociatedTypeArchiveTypes
_BNBinaryViewGetAssociatedTypeArchiveTypes.restype = ctypes.c_ulonglong
_BNBinaryViewGetAssociatedTypeArchiveTypes.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)),
		ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)),
		ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)),
	]


# noinspection PyPep8Naming
def BNBinaryViewGetAssociatedTypeArchiveTypes(
		view: ctypes.POINTER(BNBinaryView), 
		typeIds: ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)), 
		archiveIds: ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)), 
		archiveTypeIds: ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p))
		) -> int:
	return _BNBinaryViewGetAssociatedTypeArchiveTypes(view, typeIds, archiveIds, archiveTypeIds)


# -------------------------------------------------------
# _BNBinaryViewGetAssociatedTypesFromArchive

_BNBinaryViewGetAssociatedTypesFromArchive = core.BNBinaryViewGetAssociatedTypesFromArchive
_BNBinaryViewGetAssociatedTypesFromArchive.restype = ctypes.c_ulonglong
_BNBinaryViewGetAssociatedTypesFromArchive.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_char_p,
		ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)),
		ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)),
	]


# noinspection PyPep8Naming
def BNBinaryViewGetAssociatedTypesFromArchive(
		view: ctypes.POINTER(BNBinaryView), 
		archiveId: Optional[str], 
		typeIds: ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)), 
		archiveTypeIds: ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p))
		) -> int:
	return _BNBinaryViewGetAssociatedTypesFromArchive(view, cstr(archiveId), typeIds, archiveTypeIds)


# -------------------------------------------------------
# _BNBinaryViewGetAutoMetadata

_BNBinaryViewGetAutoMetadata = core.BNBinaryViewGetAutoMetadata
_BNBinaryViewGetAutoMetadata.restype = ctypes.POINTER(BNMetadata)
_BNBinaryViewGetAutoMetadata.argtypes = [
		ctypes.POINTER(BNBinaryView),
	]


# noinspection PyPep8Naming
def BNBinaryViewGetAutoMetadata(
		view: ctypes.POINTER(BNBinaryView)
		) -> Optional[ctypes.POINTER(BNMetadata)]:
	result = _BNBinaryViewGetAutoMetadata(view)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNBinaryViewGetExternalLibraries

_BNBinaryViewGetExternalLibraries = core.BNBinaryViewGetExternalLibraries
_BNBinaryViewGetExternalLibraries.restype = ctypes.POINTER(ctypes.POINTER(BNExternalLibrary))
_BNBinaryViewGetExternalLibraries.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNBinaryViewGetExternalLibraries(
		view: ctypes.POINTER(BNBinaryView), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.POINTER(BNExternalLibrary))]:
	result = _BNBinaryViewGetExternalLibraries(view, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNBinaryViewGetExternalLibrary

_BNBinaryViewGetExternalLibrary = core.BNBinaryViewGetExternalLibrary
_BNBinaryViewGetExternalLibrary.restype = ctypes.POINTER(BNExternalLibrary)
_BNBinaryViewGetExternalLibrary.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNBinaryViewGetExternalLibrary(
		view: ctypes.POINTER(BNBinaryView), 
		name: Optional[str]
		) -> Optional[ctypes.POINTER(BNExternalLibrary)]:
	result = _BNBinaryViewGetExternalLibrary(view, cstr(name))
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNBinaryViewGetExternalLocation

_BNBinaryViewGetExternalLocation = core.BNBinaryViewGetExternalLocation
_BNBinaryViewGetExternalLocation.restype = ctypes.POINTER(BNExternalLocation)
_BNBinaryViewGetExternalLocation.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNSymbol),
	]


# noinspection PyPep8Naming
def BNBinaryViewGetExternalLocation(
		view: ctypes.POINTER(BNBinaryView), 
		sourceSymbol: ctypes.POINTER(BNSymbol)
		) -> Optional[ctypes.POINTER(BNExternalLocation)]:
	result = _BNBinaryViewGetExternalLocation(view, sourceSymbol)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNBinaryViewGetExternalLocations

_BNBinaryViewGetExternalLocations = core.BNBinaryViewGetExternalLocations
_BNBinaryViewGetExternalLocations.restype = ctypes.POINTER(ctypes.POINTER(BNExternalLocation))
_BNBinaryViewGetExternalLocations.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNBinaryViewGetExternalLocations(
		view: ctypes.POINTER(BNBinaryView), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.POINTER(BNExternalLocation))]:
	result = _BNBinaryViewGetExternalLocations(view, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNBinaryViewGetLoadSettings

_BNBinaryViewGetLoadSettings = core.BNBinaryViewGetLoadSettings
_BNBinaryViewGetLoadSettings.restype = ctypes.POINTER(BNSettings)
_BNBinaryViewGetLoadSettings.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNBinaryViewGetLoadSettings(
		view: ctypes.POINTER(BNBinaryView), 
		typeName: Optional[str]
		) -> Optional[ctypes.POINTER(BNSettings)]:
	result = _BNBinaryViewGetLoadSettings(view, cstr(typeName))
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNBinaryViewGetLoadSettingsTypeNames

_BNBinaryViewGetLoadSettingsTypeNames = core.BNBinaryViewGetLoadSettingsTypeNames
_BNBinaryViewGetLoadSettingsTypeNames.restype = ctypes.POINTER(ctypes.c_char_p)
_BNBinaryViewGetLoadSettingsTypeNames.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNBinaryViewGetLoadSettingsTypeNames(
		view: ctypes.POINTER(BNBinaryView), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_char_p)]:
	result = _BNBinaryViewGetLoadSettingsTypeNames(view, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNBinaryViewGetMetadata

_BNBinaryViewGetMetadata = core.BNBinaryViewGetMetadata
_BNBinaryViewGetMetadata.restype = ctypes.POINTER(BNMetadata)
_BNBinaryViewGetMetadata.argtypes = [
		ctypes.POINTER(BNBinaryView),
	]


# noinspection PyPep8Naming
def BNBinaryViewGetMetadata(
		view: ctypes.POINTER(BNBinaryView)
		) -> Optional[ctypes.POINTER(BNMetadata)]:
	result = _BNBinaryViewGetMetadata(view)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNBinaryViewGetTypeArchive

_BNBinaryViewGetTypeArchive = core.BNBinaryViewGetTypeArchive
_BNBinaryViewGetTypeArchive.restype = ctypes.POINTER(BNTypeArchive)
_BNBinaryViewGetTypeArchive.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNBinaryViewGetTypeArchive(
		view: ctypes.POINTER(BNBinaryView), 
		id: Optional[str]
		) -> Optional[ctypes.POINTER(BNTypeArchive)]:
	result = _BNBinaryViewGetTypeArchive(view, cstr(id))
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNBinaryViewGetTypeArchivePath

_BNBinaryViewGetTypeArchivePath = core.BNBinaryViewGetTypeArchivePath
_BNBinaryViewGetTypeArchivePath.restype = ctypes.POINTER(ctypes.c_byte)
_BNBinaryViewGetTypeArchivePath.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNBinaryViewGetTypeArchivePath(
		view: ctypes.POINTER(BNBinaryView), 
		id: Optional[str]
		) -> Optional[Optional[str]]:
	result = _BNBinaryViewGetTypeArchivePath(view, cstr(id))
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNBinaryViewGetTypeArchiveSyncStatus

_BNBinaryViewGetTypeArchiveSyncStatus = core.BNBinaryViewGetTypeArchiveSyncStatus
_BNBinaryViewGetTypeArchiveSyncStatus.restype = SyncStatusEnum
_BNBinaryViewGetTypeArchiveSyncStatus.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNBinaryViewGetTypeArchiveSyncStatus(
		view: ctypes.POINTER(BNBinaryView), 
		typeId: Optional[str]
		) -> SyncStatus:
	return _BNBinaryViewGetTypeArchiveSyncStatus(view, cstr(typeId))


# -------------------------------------------------------
# _BNBinaryViewGetTypeArchiveTypeNameList

_BNBinaryViewGetTypeArchiveTypeNameList = core.BNBinaryViewGetTypeArchiveTypeNameList
_BNBinaryViewGetTypeArchiveTypeNameList.restype = ctypes.c_ulonglong
_BNBinaryViewGetTypeArchiveTypeNameList.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(ctypes.POINTER(BNQualifiedName)),
	]


# noinspection PyPep8Naming
def BNBinaryViewGetTypeArchiveTypeNameList(
		view: ctypes.POINTER(BNBinaryView), 
		names: ctypes.POINTER(ctypes.POINTER(BNQualifiedName))
		) -> int:
	return _BNBinaryViewGetTypeArchiveTypeNameList(view, names)


# -------------------------------------------------------
# _BNBinaryViewGetTypeArchiveTypeNames

_BNBinaryViewGetTypeArchiveTypeNames = core.BNBinaryViewGetTypeArchiveTypeNames
_BNBinaryViewGetTypeArchiveTypeNames.restype = ctypes.c_ulonglong
_BNBinaryViewGetTypeArchiveTypeNames.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNQualifiedName),
		ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)),
		ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)),
	]


# noinspection PyPep8Naming
def BNBinaryViewGetTypeArchiveTypeNames(
		view: ctypes.POINTER(BNBinaryView), 
		name: ctypes.POINTER(BNQualifiedName), 
		archiveIds: ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)), 
		archiveTypeIds: ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p))
		) -> int:
	return _BNBinaryViewGetTypeArchiveTypeNames(view, name, archiveIds, archiveTypeIds)


# -------------------------------------------------------
# _BNBinaryViewGetTypeArchives

_BNBinaryViewGetTypeArchives = core.BNBinaryViewGetTypeArchives
_BNBinaryViewGetTypeArchives.restype = ctypes.c_ulonglong
_BNBinaryViewGetTypeArchives.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)),
		ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)),
	]


# noinspection PyPep8Naming
def BNBinaryViewGetTypeArchives(
		view: ctypes.POINTER(BNBinaryView), 
		ids: ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)), 
		paths: ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p))
		) -> int:
	return _BNBinaryViewGetTypeArchives(view, ids, paths)


# -------------------------------------------------------
# _BNBinaryViewGetTypeNameByGuid

_BNBinaryViewGetTypeNameByGuid = core.BNBinaryViewGetTypeNameByGuid
_BNBinaryViewGetTypeNameByGuid.restype = BNQualifiedName
_BNBinaryViewGetTypeNameByGuid.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNBinaryViewGetTypeNameByGuid(
		view: ctypes.POINTER(BNBinaryView), 
		guid: Optional[str]
		) -> BNQualifiedName:
	return _BNBinaryViewGetTypeNameByGuid(view, cstr(guid))


# -------------------------------------------------------
# _BNBinaryViewImportTypeLibraryObject

_BNBinaryViewImportTypeLibraryObject = core.BNBinaryViewImportTypeLibraryObject
_BNBinaryViewImportTypeLibraryObject.restype = ctypes.POINTER(BNType)
_BNBinaryViewImportTypeLibraryObject.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(ctypes.POINTER(BNTypeLibrary)),
		ctypes.POINTER(BNQualifiedName),
	]


# noinspection PyPep8Naming
def BNBinaryViewImportTypeLibraryObject(
		view: ctypes.POINTER(BNBinaryView), 
		lib: ctypes.POINTER(ctypes.POINTER(BNTypeLibrary)), 
		name: ctypes.POINTER(BNQualifiedName)
		) -> Optional[ctypes.POINTER(BNType)]:
	result = _BNBinaryViewImportTypeLibraryObject(view, lib, name)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNBinaryViewImportTypeLibraryType

_BNBinaryViewImportTypeLibraryType = core.BNBinaryViewImportTypeLibraryType
_BNBinaryViewImportTypeLibraryType.restype = ctypes.POINTER(BNType)
_BNBinaryViewImportTypeLibraryType.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(ctypes.POINTER(BNTypeLibrary)),
		ctypes.POINTER(BNQualifiedName),
	]


# noinspection PyPep8Naming
def BNBinaryViewImportTypeLibraryType(
		view: ctypes.POINTER(BNBinaryView), 
		lib: ctypes.POINTER(ctypes.POINTER(BNTypeLibrary)), 
		name: ctypes.POINTER(BNQualifiedName)
		) -> Optional[ctypes.POINTER(BNType)]:
	result = _BNBinaryViewImportTypeLibraryType(view, lib, name)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNBinaryViewImportTypeLibraryTypeByGuid

_BNBinaryViewImportTypeLibraryTypeByGuid = core.BNBinaryViewImportTypeLibraryTypeByGuid
_BNBinaryViewImportTypeLibraryTypeByGuid.restype = ctypes.POINTER(BNType)
_BNBinaryViewImportTypeLibraryTypeByGuid.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNBinaryViewImportTypeLibraryTypeByGuid(
		view: ctypes.POINTER(BNBinaryView), 
		guid: Optional[str]
		) -> Optional[ctypes.POINTER(BNType)]:
	result = _BNBinaryViewImportTypeLibraryTypeByGuid(view, cstr(guid))
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNBinaryViewLookupImportedObjectLibrary

_BNBinaryViewLookupImportedObjectLibrary = core.BNBinaryViewLookupImportedObjectLibrary
_BNBinaryViewLookupImportedObjectLibrary.restype = ctypes.c_bool
_BNBinaryViewLookupImportedObjectLibrary.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNPlatform),
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.POINTER(BNTypeLibrary)),
		ctypes.POINTER(BNQualifiedName),
	]


# noinspection PyPep8Naming
def BNBinaryViewLookupImportedObjectLibrary(
		view: ctypes.POINTER(BNBinaryView), 
		tgtPlatform: ctypes.POINTER(BNPlatform), 
		tgtAddr: int, 
		lib: ctypes.POINTER(ctypes.POINTER(BNTypeLibrary)), 
		name: ctypes.POINTER(BNQualifiedName)
		) -> bool:
	return _BNBinaryViewLookupImportedObjectLibrary(view, tgtPlatform, tgtAddr, lib, name)


# -------------------------------------------------------
# _BNBinaryViewLookupImportedTypeLibrary

_BNBinaryViewLookupImportedTypeLibrary = core.BNBinaryViewLookupImportedTypeLibrary
_BNBinaryViewLookupImportedTypeLibrary.restype = ctypes.c_bool
_BNBinaryViewLookupImportedTypeLibrary.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNQualifiedName),
		ctypes.POINTER(ctypes.POINTER(BNTypeLibrary)),
		ctypes.POINTER(BNQualifiedName),
	]


# noinspection PyPep8Naming
def BNBinaryViewLookupImportedTypeLibrary(
		view: ctypes.POINTER(BNBinaryView), 
		typeName: ctypes.POINTER(BNQualifiedName), 
		lib: ctypes.POINTER(ctypes.POINTER(BNTypeLibrary)), 
		resultName: ctypes.POINTER(BNQualifiedName)
		) -> bool:
	return _BNBinaryViewLookupImportedTypeLibrary(view, typeName, lib, resultName)


# -------------------------------------------------------
# _BNBinaryViewPullTypeArchiveTypes

_BNBinaryViewPullTypeArchiveTypes = core.BNBinaryViewPullTypeArchiveTypes
_BNBinaryViewPullTypeArchiveTypes.restype = ctypes.c_bool
_BNBinaryViewPullTypeArchiveTypes.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_char_p,
		ctypes.POINTER(ctypes.c_char_p),
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)),
		ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNBinaryViewPullTypeArchiveTypes(
		view: ctypes.POINTER(BNBinaryView), 
		archiveId: Optional[str], 
		archiveTypeIds: ctypes.POINTER(ctypes.c_char_p), 
		archiveTypeIdCount: int, 
		updatedArchiveTypeIds: ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)), 
		updatedAnalysisTypeIds: ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)), 
		updatedTypeCount: ctypes.POINTER(ctypes.c_ulonglong)
		) -> bool:
	return _BNBinaryViewPullTypeArchiveTypes(view, cstr(archiveId), archiveTypeIds, archiveTypeIdCount, updatedArchiveTypeIds, updatedAnalysisTypeIds, updatedTypeCount)


# -------------------------------------------------------
# _BNBinaryViewPushTypeArchiveTypes

_BNBinaryViewPushTypeArchiveTypes = core.BNBinaryViewPushTypeArchiveTypes
_BNBinaryViewPushTypeArchiveTypes.restype = ctypes.c_bool
_BNBinaryViewPushTypeArchiveTypes.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_char_p,
		ctypes.POINTER(ctypes.c_char_p),
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)),
		ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNBinaryViewPushTypeArchiveTypes(
		view: ctypes.POINTER(BNBinaryView), 
		archiveId: Optional[str], 
		typeIds: ctypes.POINTER(ctypes.c_char_p), 
		typeIdCount: int, 
		updatedAnalysisTypeIds: ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)), 
		updatedArchiveTypeIds: ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)), 
		updatedTypeCount: ctypes.POINTER(ctypes.c_ulonglong)
		) -> bool:
	return _BNBinaryViewPushTypeArchiveTypes(view, cstr(archiveId), typeIds, typeIdCount, updatedAnalysisTypeIds, updatedArchiveTypeIds, updatedTypeCount)


# -------------------------------------------------------
# _BNBinaryViewQueryMetadata

_BNBinaryViewQueryMetadata = core.BNBinaryViewQueryMetadata
_BNBinaryViewQueryMetadata.restype = ctypes.POINTER(BNMetadata)
_BNBinaryViewQueryMetadata.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNBinaryViewQueryMetadata(
		view: ctypes.POINTER(BNBinaryView), 
		key: Optional[str]
		) -> Optional[ctypes.POINTER(BNMetadata)]:
	result = _BNBinaryViewQueryMetadata(view, cstr(key))
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNBinaryViewRecordImportedObjectLibrary

_BNBinaryViewRecordImportedObjectLibrary = core.BNBinaryViewRecordImportedObjectLibrary
_BNBinaryViewRecordImportedObjectLibrary.restype = None
_BNBinaryViewRecordImportedObjectLibrary.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNPlatform),
		ctypes.c_ulonglong,
		ctypes.POINTER(BNTypeLibrary),
		ctypes.POINTER(BNQualifiedName),
	]


# noinspection PyPep8Naming
def BNBinaryViewRecordImportedObjectLibrary(
		view: ctypes.POINTER(BNBinaryView), 
		tgtPlatform: ctypes.POINTER(BNPlatform), 
		tgtAddr: int, 
		lib: ctypes.POINTER(BNTypeLibrary), 
		name: ctypes.POINTER(BNQualifiedName)
		) -> None:
	return _BNBinaryViewRecordImportedObjectLibrary(view, tgtPlatform, tgtAddr, lib, name)


# -------------------------------------------------------
# _BNBinaryViewRemoveExternalLibrary

_BNBinaryViewRemoveExternalLibrary = core.BNBinaryViewRemoveExternalLibrary
_BNBinaryViewRemoveExternalLibrary.restype = None
_BNBinaryViewRemoveExternalLibrary.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNBinaryViewRemoveExternalLibrary(
		view: ctypes.POINTER(BNBinaryView), 
		name: Optional[str]
		) -> None:
	return _BNBinaryViewRemoveExternalLibrary(view, cstr(name))


# -------------------------------------------------------
# _BNBinaryViewRemoveExternalLocation

_BNBinaryViewRemoveExternalLocation = core.BNBinaryViewRemoveExternalLocation
_BNBinaryViewRemoveExternalLocation.restype = None
_BNBinaryViewRemoveExternalLocation.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNSymbol),
	]


# noinspection PyPep8Naming
def BNBinaryViewRemoveExternalLocation(
		view: ctypes.POINTER(BNBinaryView), 
		sourceSymbol: ctypes.POINTER(BNSymbol)
		) -> None:
	return _BNBinaryViewRemoveExternalLocation(view, sourceSymbol)


# -------------------------------------------------------
# _BNBinaryViewRemoveMetadata

_BNBinaryViewRemoveMetadata = core.BNBinaryViewRemoveMetadata
_BNBinaryViewRemoveMetadata.restype = None
_BNBinaryViewRemoveMetadata.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNBinaryViewRemoveMetadata(
		view: ctypes.POINTER(BNBinaryView), 
		key: Optional[str]
		) -> None:
	return _BNBinaryViewRemoveMetadata(view, cstr(key))


# -------------------------------------------------------
# _BNBinaryViewSetLoadSettings

_BNBinaryViewSetLoadSettings = core.BNBinaryViewSetLoadSettings
_BNBinaryViewSetLoadSettings.restype = None
_BNBinaryViewSetLoadSettings.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_char_p,
		ctypes.POINTER(BNSettings),
	]


# noinspection PyPep8Naming
def BNBinaryViewSetLoadSettings(
		view: ctypes.POINTER(BNBinaryView), 
		typeName: Optional[str], 
		settings: ctypes.POINTER(BNSettings)
		) -> None:
	return _BNBinaryViewSetLoadSettings(view, cstr(typeName), settings)


# -------------------------------------------------------
# _BNBinaryViewSetManualDependencies

_BNBinaryViewSetManualDependencies = core.BNBinaryViewSetManualDependencies
_BNBinaryViewSetManualDependencies.restype = None
_BNBinaryViewSetManualDependencies.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNQualifiedName),
		ctypes.POINTER(BNQualifiedName),
		ctypes.POINTER(ctypes.c_char_p),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNBinaryViewSetManualDependencies(
		view: ctypes.POINTER(BNBinaryView), 
		viewTypeNames: ctypes.POINTER(BNQualifiedName), 
		libTypeNames: ctypes.POINTER(BNQualifiedName), 
		libNames: ctypes.POINTER(ctypes.c_char_p), 
		count: int
		) -> None:
	return _BNBinaryViewSetManualDependencies(view, viewTypeNames, libTypeNames, libNames, count)


# -------------------------------------------------------
# _BNBinaryViewStoreMetadata

_BNBinaryViewStoreMetadata = core.BNBinaryViewStoreMetadata
_BNBinaryViewStoreMetadata.restype = None
_BNBinaryViewStoreMetadata.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_char_p,
		ctypes.POINTER(BNMetadata),
		ctypes.c_bool,
	]


# noinspection PyPep8Naming
def BNBinaryViewStoreMetadata(
		view: ctypes.POINTER(BNBinaryView), 
		key: Optional[str], 
		value: ctypes.POINTER(BNMetadata), 
		isAuto: bool
		) -> None:
	return _BNBinaryViewStoreMetadata(view, cstr(key), value, isAuto)


# -------------------------------------------------------
# _BNCanArchitectureAssemble

_BNCanArchitectureAssemble = core.BNCanArchitectureAssemble
_BNCanArchitectureAssemble.restype = ctypes.c_bool
_BNCanArchitectureAssemble.argtypes = [
		ctypes.POINTER(BNArchitecture),
	]


# noinspection PyPep8Naming
def BNCanArchitectureAssemble(
		arch: ctypes.POINTER(BNArchitecture)
		) -> bool:
	return _BNCanArchitectureAssemble(arch)


# -------------------------------------------------------
# _BNCanAssemble

_BNCanAssemble = core.BNCanAssemble
_BNCanAssemble.restype = ctypes.c_bool
_BNCanAssemble.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNArchitecture),
	]


# noinspection PyPep8Naming
def BNCanAssemble(
		view: ctypes.POINTER(BNBinaryView), 
		arch: ctypes.POINTER(BNArchitecture)
		) -> bool:
	return _BNCanAssemble(view, arch)


# -------------------------------------------------------
# _BNCanCancelBackgroundTask

_BNCanCancelBackgroundTask = core.BNCanCancelBackgroundTask
_BNCanCancelBackgroundTask.restype = ctypes.c_bool
_BNCanCancelBackgroundTask.argtypes = [
		ctypes.POINTER(BNBackgroundTask),
	]


# noinspection PyPep8Naming
def BNCanCancelBackgroundTask(
		task: ctypes.POINTER(BNBackgroundTask)
		) -> bool:
	return _BNCanCancelBackgroundTask(task)


# -------------------------------------------------------
# _BNCanFunctionReturn

_BNCanFunctionReturn = core.BNCanFunctionReturn
_BNCanFunctionReturn.restype = BNBoolWithConfidence
_BNCanFunctionReturn.argtypes = [
		ctypes.POINTER(BNFunction),
	]


# noinspection PyPep8Naming
def BNCanFunctionReturn(
		func: ctypes.POINTER(BNFunction)
		) -> BNBoolWithConfidence:
	return _BNCanFunctionReturn(func)


# -------------------------------------------------------
# _BNCanRedo

_BNCanRedo = core.BNCanRedo
_BNCanRedo.restype = ctypes.c_bool
_BNCanRedo.argtypes = [
		ctypes.POINTER(BNFileMetadata),
	]


# noinspection PyPep8Naming
def BNCanRedo(
		file: ctypes.POINTER(BNFileMetadata)
		) -> bool:
	return _BNCanRedo(file)


# -------------------------------------------------------
# _BNCanUndo

_BNCanUndo = core.BNCanUndo
_BNCanUndo.restype = ctypes.c_bool
_BNCanUndo.argtypes = [
		ctypes.POINTER(BNFileMetadata),
	]


# noinspection PyPep8Naming
def BNCanUndo(
		file: ctypes.POINTER(BNFileMetadata)
		) -> bool:
	return _BNCanUndo(file)


# -------------------------------------------------------
# _BNCancelAnalysisCompletionEvent

_BNCancelAnalysisCompletionEvent = core.BNCancelAnalysisCompletionEvent
_BNCancelAnalysisCompletionEvent.restype = None
_BNCancelAnalysisCompletionEvent.argtypes = [
		ctypes.POINTER(BNAnalysisCompletionEvent),
	]


# noinspection PyPep8Naming
def BNCancelAnalysisCompletionEvent(
		event: ctypes.POINTER(BNAnalysisCompletionEvent)
		) -> None:
	return _BNCancelAnalysisCompletionEvent(event)


# -------------------------------------------------------
# _BNCancelBackgroundTask

_BNCancelBackgroundTask = core.BNCancelBackgroundTask
_BNCancelBackgroundTask.restype = None
_BNCancelBackgroundTask.argtypes = [
		ctypes.POINTER(BNBackgroundTask),
	]


# noinspection PyPep8Naming
def BNCancelBackgroundTask(
		task: ctypes.POINTER(BNBackgroundTask)
		) -> None:
	return _BNCancelBackgroundTask(task)


# -------------------------------------------------------
# _BNCancelEnterpriseServerAuthentication

_BNCancelEnterpriseServerAuthentication = core.BNCancelEnterpriseServerAuthentication
_BNCancelEnterpriseServerAuthentication.restype = None
_BNCancelEnterpriseServerAuthentication.argtypes = [
	]


# noinspection PyPep8Naming
def BNCancelEnterpriseServerAuthentication(
		) -> None:
	return _BNCancelEnterpriseServerAuthentication()


# -------------------------------------------------------
# _BNCancelScriptInput

_BNCancelScriptInput = core.BNCancelScriptInput
_BNCancelScriptInput.restype = None
_BNCancelScriptInput.argtypes = [
		ctypes.POINTER(BNScriptingInstance),
	]


# noinspection PyPep8Naming
def BNCancelScriptInput(
		instance: ctypes.POINTER(BNScriptingInstance)
		) -> None:
	return _BNCancelScriptInput(instance)


# -------------------------------------------------------
# _BNCheckForStringAnnotationType

_BNCheckForStringAnnotationType = core.BNCheckForStringAnnotationType
_BNCheckForStringAnnotationType.restype = ctypes.c_bool
_BNCheckForStringAnnotationType.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_char_p),
		ctypes.POINTER(StringTypeEnum),
		ctypes.c_bool,
		ctypes.c_bool,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNCheckForStringAnnotationType(
		view: ctypes.POINTER(BNBinaryView), 
		addr: int, 
		value: ctypes.POINTER(ctypes.c_char_p), 
		strType: ctypes.POINTER(StringTypeEnum), 
		allowShortStrings: bool, 
		allowLargeStrings: bool, 
		childWidth: int
		) -> bool:
	return _BNCheckForStringAnnotationType(view, addr, value, strType, allowShortStrings, allowLargeStrings, childWidth)


# -------------------------------------------------------
# _BNClearDataBuffer

_BNClearDataBuffer = core.BNClearDataBuffer
_BNClearDataBuffer.restype = None
_BNClearDataBuffer.argtypes = [
		ctypes.POINTER(BNDataBuffer),
	]


# noinspection PyPep8Naming
def BNClearDataBuffer(
		buf: ctypes.POINTER(BNDataBuffer)
		) -> None:
	return _BNClearDataBuffer(buf)


# -------------------------------------------------------
# _BNClearTypeLibraryPlatforms

_BNClearTypeLibraryPlatforms = core.BNClearTypeLibraryPlatforms
_BNClearTypeLibraryPlatforms.restype = None
_BNClearTypeLibraryPlatforms.argtypes = [
		ctypes.POINTER(BNTypeLibrary),
	]


# noinspection PyPep8Naming
def BNClearTypeLibraryPlatforms(
		lib: ctypes.POINTER(BNTypeLibrary)
		) -> None:
	return _BNClearTypeLibraryPlatforms(lib)


# -------------------------------------------------------
# _BNClearUndoEntries

_BNClearUndoEntries = core.BNClearUndoEntries
_BNClearUndoEntries.restype = None
_BNClearUndoEntries.argtypes = [
		ctypes.POINTER(BNFileMetadata),
	]


# noinspection PyPep8Naming
def BNClearUndoEntries(
		file: ctypes.POINTER(BNFileMetadata)
		) -> None:
	return _BNClearUndoEntries(file)


# -------------------------------------------------------
# _BNClearUserVariableValue

_BNClearUserVariableValue = core.BNClearUserVariableValue
_BNClearUserVariableValue.restype = None
_BNClearUserVariableValue.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNVariable),
		ctypes.POINTER(BNArchitectureAndAddress),
	]


# noinspection PyPep8Naming
def BNClearUserVariableValue(
		func: ctypes.POINTER(BNFunction), 
		var: ctypes.POINTER(BNVariable), 
		defSite: ctypes.POINTER(BNArchitectureAndAddress)
		) -> None:
	return _BNClearUserVariableValue(func, var, defSite)


# -------------------------------------------------------
# _BNCloseFile

_BNCloseFile = core.BNCloseFile
_BNCloseFile.restype = None
_BNCloseFile.argtypes = [
		ctypes.POINTER(BNFileMetadata),
	]


# noinspection PyPep8Naming
def BNCloseFile(
		file: ctypes.POINTER(BNFileMetadata)
		) -> None:
	return _BNCloseFile(file)


# -------------------------------------------------------
# _BNCloseLogs

_BNCloseLogs = core.BNCloseLogs
_BNCloseLogs.restype = None
_BNCloseLogs.argtypes = [
	]


# noinspection PyPep8Naming
def BNCloseLogs(
		) -> None:
	return _BNCloseLogs()


# -------------------------------------------------------
# _BNCloseTypeArchive

_BNCloseTypeArchive = core.BNCloseTypeArchive
_BNCloseTypeArchive.restype = None
_BNCloseTypeArchive.argtypes = [
		ctypes.POINTER(BNTypeArchive),
	]


# noinspection PyPep8Naming
def BNCloseTypeArchive(
		archive: ctypes.POINTER(BNTypeArchive)
		) -> None:
	return _BNCloseTypeArchive(archive)


# -------------------------------------------------------
# _BNCommitUndoActions

_BNCommitUndoActions = core.BNCommitUndoActions
_BNCommitUndoActions.restype = None
_BNCommitUndoActions.argtypes = [
		ctypes.POINTER(BNFileMetadata),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNCommitUndoActions(
		file: ctypes.POINTER(BNFileMetadata), 
		id: Optional[str]
		) -> None:
	return _BNCommitUndoActions(file, cstr(id))


# -------------------------------------------------------
# _BNCompareLinearViewCursors

_BNCompareLinearViewCursors = core.BNCompareLinearViewCursors
_BNCompareLinearViewCursors.restype = ctypes.c_int
_BNCompareLinearViewCursors.argtypes = [
		ctypes.POINTER(BNLinearViewCursor),
		ctypes.POINTER(BNLinearViewCursor),
	]


# noinspection PyPep8Naming
def BNCompareLinearViewCursors(
		a: ctypes.POINTER(BNLinearViewCursor), 
		b: ctypes.POINTER(BNLinearViewCursor)
		) -> int:
	return _BNCompareLinearViewCursors(a, b)


# -------------------------------------------------------
# _BNCompareLinearViewObjectChildren

_BNCompareLinearViewObjectChildren = core.BNCompareLinearViewObjectChildren
_BNCompareLinearViewObjectChildren.restype = ctypes.c_int
_BNCompareLinearViewObjectChildren.argtypes = [
		ctypes.POINTER(BNLinearViewObject),
		ctypes.POINTER(BNLinearViewObject),
		ctypes.POINTER(BNLinearViewObject),
	]


# noinspection PyPep8Naming
def BNCompareLinearViewObjectChildren(
		obj: ctypes.POINTER(BNLinearViewObject), 
		a: ctypes.POINTER(BNLinearViewObject), 
		b: ctypes.POINTER(BNLinearViewObject)
		) -> int:
	return _BNCompareLinearViewObjectChildren(obj, a, b)


# -------------------------------------------------------
# _BNComponentAddAllMembersFromComponent

_BNComponentAddAllMembersFromComponent = core.BNComponentAddAllMembersFromComponent
_BNComponentAddAllMembersFromComponent.restype = None
_BNComponentAddAllMembersFromComponent.argtypes = [
		ctypes.POINTER(BNComponent),
		ctypes.POINTER(BNComponent),
	]


# noinspection PyPep8Naming
def BNComponentAddAllMembersFromComponent(
		component: ctypes.POINTER(BNComponent), 
		fromComponent: ctypes.POINTER(BNComponent)
		) -> None:
	return _BNComponentAddAllMembersFromComponent(component, fromComponent)


# -------------------------------------------------------
# _BNComponentAddComponent

_BNComponentAddComponent = core.BNComponentAddComponent
_BNComponentAddComponent.restype = ctypes.c_bool
_BNComponentAddComponent.argtypes = [
		ctypes.POINTER(BNComponent),
		ctypes.POINTER(BNComponent),
	]


# noinspection PyPep8Naming
def BNComponentAddComponent(
		parent: ctypes.POINTER(BNComponent), 
		component: ctypes.POINTER(BNComponent)
		) -> bool:
	return _BNComponentAddComponent(parent, component)


# -------------------------------------------------------
# _BNComponentAddDataVariable

_BNComponentAddDataVariable = core.BNComponentAddDataVariable
_BNComponentAddDataVariable.restype = ctypes.c_bool
_BNComponentAddDataVariable.argtypes = [
		ctypes.POINTER(BNComponent),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNComponentAddDataVariable(
		component: ctypes.POINTER(BNComponent), 
		address: int
		) -> bool:
	return _BNComponentAddDataVariable(component, address)


# -------------------------------------------------------
# _BNComponentAddFunctionReference

_BNComponentAddFunctionReference = core.BNComponentAddFunctionReference
_BNComponentAddFunctionReference.restype = ctypes.c_bool
_BNComponentAddFunctionReference.argtypes = [
		ctypes.POINTER(BNComponent),
		ctypes.POINTER(BNFunction),
	]


# noinspection PyPep8Naming
def BNComponentAddFunctionReference(
		component: ctypes.POINTER(BNComponent), 
		function: ctypes.POINTER(BNFunction)
		) -> bool:
	return _BNComponentAddFunctionReference(component, function)


# -------------------------------------------------------
# _BNComponentContainsComponent

_BNComponentContainsComponent = core.BNComponentContainsComponent
_BNComponentContainsComponent.restype = ctypes.c_bool
_BNComponentContainsComponent.argtypes = [
		ctypes.POINTER(BNComponent),
		ctypes.POINTER(BNComponent),
	]


# noinspection PyPep8Naming
def BNComponentContainsComponent(
		parent: ctypes.POINTER(BNComponent), 
		component: ctypes.POINTER(BNComponent)
		) -> bool:
	return _BNComponentContainsComponent(parent, component)


# -------------------------------------------------------
# _BNComponentContainsDataVariable

_BNComponentContainsDataVariable = core.BNComponentContainsDataVariable
_BNComponentContainsDataVariable.restype = ctypes.c_bool
_BNComponentContainsDataVariable.argtypes = [
		ctypes.POINTER(BNComponent),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNComponentContainsDataVariable(
		component: ctypes.POINTER(BNComponent), 
		address: int
		) -> bool:
	return _BNComponentContainsDataVariable(component, address)


# -------------------------------------------------------
# _BNComponentContainsFunction

_BNComponentContainsFunction = core.BNComponentContainsFunction
_BNComponentContainsFunction.restype = ctypes.c_bool
_BNComponentContainsFunction.argtypes = [
		ctypes.POINTER(BNComponent),
		ctypes.POINTER(BNFunction),
	]


# noinspection PyPep8Naming
def BNComponentContainsFunction(
		component: ctypes.POINTER(BNComponent), 
		function: ctypes.POINTER(BNFunction)
		) -> bool:
	return _BNComponentContainsFunction(component, function)


# -------------------------------------------------------
# _BNComponentFreeReferencedTypes

_BNComponentFreeReferencedTypes = core.BNComponentFreeReferencedTypes
_BNComponentFreeReferencedTypes.restype = None
_BNComponentFreeReferencedTypes.argtypes = [
		ctypes.POINTER(ctypes.POINTER(BNType)),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNComponentFreeReferencedTypes(
		types: ctypes.POINTER(ctypes.POINTER(BNType)), 
		count: int
		) -> None:
	return _BNComponentFreeReferencedTypes(types, count)


# -------------------------------------------------------
# _BNComponentGetContainedComponents

_BNComponentGetContainedComponents = core.BNComponentGetContainedComponents
_BNComponentGetContainedComponents.restype = ctypes.POINTER(ctypes.POINTER(BNComponent))
_BNComponentGetContainedComponents.argtypes = [
		ctypes.POINTER(BNComponent),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNComponentGetContainedComponents(
		component: ctypes.POINTER(BNComponent), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.POINTER(BNComponent))]:
	result = _BNComponentGetContainedComponents(component, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNComponentGetContainedDataVariables

_BNComponentGetContainedDataVariables = core.BNComponentGetContainedDataVariables
_BNComponentGetContainedDataVariables.restype = ctypes.POINTER(BNDataVariable)
_BNComponentGetContainedDataVariables.argtypes = [
		ctypes.POINTER(BNComponent),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNComponentGetContainedDataVariables(
		component: ctypes.POINTER(BNComponent), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNDataVariable)]:
	result = _BNComponentGetContainedDataVariables(component, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNComponentGetContainedFunctions

_BNComponentGetContainedFunctions = core.BNComponentGetContainedFunctions
_BNComponentGetContainedFunctions.restype = ctypes.POINTER(ctypes.POINTER(BNFunction))
_BNComponentGetContainedFunctions.argtypes = [
		ctypes.POINTER(BNComponent),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNComponentGetContainedFunctions(
		component: ctypes.POINTER(BNComponent), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.POINTER(BNFunction))]:
	result = _BNComponentGetContainedFunctions(component, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNComponentGetDisplayName

_BNComponentGetDisplayName = core.BNComponentGetDisplayName
_BNComponentGetDisplayName.restype = ctypes.POINTER(ctypes.c_byte)
_BNComponentGetDisplayName.argtypes = [
		ctypes.POINTER(BNComponent),
	]


# noinspection PyPep8Naming
def BNComponentGetDisplayName(
		component: ctypes.POINTER(BNComponent)
		) -> Optional[Optional[str]]:
	result = _BNComponentGetDisplayName(component)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNComponentGetGuid

_BNComponentGetGuid = core.BNComponentGetGuid
_BNComponentGetGuid.restype = ctypes.POINTER(ctypes.c_byte)
_BNComponentGetGuid.argtypes = [
		ctypes.POINTER(BNComponent),
	]


# noinspection PyPep8Naming
def BNComponentGetGuid(
		component: ctypes.POINTER(BNComponent)
		) -> Optional[Optional[str]]:
	result = _BNComponentGetGuid(component)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNComponentGetOriginalName

_BNComponentGetOriginalName = core.BNComponentGetOriginalName
_BNComponentGetOriginalName.restype = ctypes.POINTER(ctypes.c_byte)
_BNComponentGetOriginalName.argtypes = [
		ctypes.POINTER(BNComponent),
	]


# noinspection PyPep8Naming
def BNComponentGetOriginalName(
		component: ctypes.POINTER(BNComponent)
		) -> Optional[Optional[str]]:
	result = _BNComponentGetOriginalName(component)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNComponentGetParent

_BNComponentGetParent = core.BNComponentGetParent
_BNComponentGetParent.restype = ctypes.POINTER(BNComponent)
_BNComponentGetParent.argtypes = [
		ctypes.POINTER(BNComponent),
	]


# noinspection PyPep8Naming
def BNComponentGetParent(
		component: ctypes.POINTER(BNComponent)
		) -> Optional[ctypes.POINTER(BNComponent)]:
	result = _BNComponentGetParent(component)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNComponentGetReferencedDataVariables

_BNComponentGetReferencedDataVariables = core.BNComponentGetReferencedDataVariables
_BNComponentGetReferencedDataVariables.restype = ctypes.POINTER(BNDataVariable)
_BNComponentGetReferencedDataVariables.argtypes = [
		ctypes.POINTER(BNComponent),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNComponentGetReferencedDataVariables(
		component: ctypes.POINTER(BNComponent), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNDataVariable)]:
	result = _BNComponentGetReferencedDataVariables(component, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNComponentGetReferencedDataVariablesRecursive

_BNComponentGetReferencedDataVariablesRecursive = core.BNComponentGetReferencedDataVariablesRecursive
_BNComponentGetReferencedDataVariablesRecursive.restype = ctypes.POINTER(BNDataVariable)
_BNComponentGetReferencedDataVariablesRecursive.argtypes = [
		ctypes.POINTER(BNComponent),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNComponentGetReferencedDataVariablesRecursive(
		component: ctypes.POINTER(BNComponent), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNDataVariable)]:
	result = _BNComponentGetReferencedDataVariablesRecursive(component, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNComponentGetReferencedTypes

_BNComponentGetReferencedTypes = core.BNComponentGetReferencedTypes
_BNComponentGetReferencedTypes.restype = ctypes.POINTER(ctypes.POINTER(BNType))
_BNComponentGetReferencedTypes.argtypes = [
		ctypes.POINTER(BNComponent),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNComponentGetReferencedTypes(
		component: ctypes.POINTER(BNComponent), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.POINTER(BNType))]:
	result = _BNComponentGetReferencedTypes(component, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNComponentGetReferencedTypesRecursive

_BNComponentGetReferencedTypesRecursive = core.BNComponentGetReferencedTypesRecursive
_BNComponentGetReferencedTypesRecursive.restype = ctypes.POINTER(ctypes.POINTER(BNType))
_BNComponentGetReferencedTypesRecursive.argtypes = [
		ctypes.POINTER(BNComponent),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNComponentGetReferencedTypesRecursive(
		component: ctypes.POINTER(BNComponent), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.POINTER(BNType))]:
	result = _BNComponentGetReferencedTypesRecursive(component, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNComponentGetView

_BNComponentGetView = core.BNComponentGetView
_BNComponentGetView.restype = ctypes.POINTER(BNBinaryView)
_BNComponentGetView.argtypes = [
		ctypes.POINTER(BNComponent),
	]


# noinspection PyPep8Naming
def BNComponentGetView(
		component: ctypes.POINTER(BNComponent)
		) -> Optional[ctypes.POINTER(BNBinaryView)]:
	result = _BNComponentGetView(component)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNComponentRemoveAllFunctions

_BNComponentRemoveAllFunctions = core.BNComponentRemoveAllFunctions
_BNComponentRemoveAllFunctions.restype = None
_BNComponentRemoveAllFunctions.argtypes = [
		ctypes.POINTER(BNComponent),
	]


# noinspection PyPep8Naming
def BNComponentRemoveAllFunctions(
		component: ctypes.POINTER(BNComponent)
		) -> None:
	return _BNComponentRemoveAllFunctions(component)


# -------------------------------------------------------
# _BNComponentRemoveComponent

_BNComponentRemoveComponent = core.BNComponentRemoveComponent
_BNComponentRemoveComponent.restype = ctypes.c_bool
_BNComponentRemoveComponent.argtypes = [
		ctypes.POINTER(BNComponent),
	]


# noinspection PyPep8Naming
def BNComponentRemoveComponent(
		component: ctypes.POINTER(BNComponent)
		) -> bool:
	return _BNComponentRemoveComponent(component)


# -------------------------------------------------------
# _BNComponentRemoveDataVariable

_BNComponentRemoveDataVariable = core.BNComponentRemoveDataVariable
_BNComponentRemoveDataVariable.restype = ctypes.c_bool
_BNComponentRemoveDataVariable.argtypes = [
		ctypes.POINTER(BNComponent),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNComponentRemoveDataVariable(
		component: ctypes.POINTER(BNComponent), 
		address: int
		) -> bool:
	return _BNComponentRemoveDataVariable(component, address)


# -------------------------------------------------------
# _BNComponentRemoveFunctionReference

_BNComponentRemoveFunctionReference = core.BNComponentRemoveFunctionReference
_BNComponentRemoveFunctionReference.restype = ctypes.c_bool
_BNComponentRemoveFunctionReference.argtypes = [
		ctypes.POINTER(BNComponent),
		ctypes.POINTER(BNFunction),
	]


# noinspection PyPep8Naming
def BNComponentRemoveFunctionReference(
		component: ctypes.POINTER(BNComponent), 
		function: ctypes.POINTER(BNFunction)
		) -> bool:
	return _BNComponentRemoveFunctionReference(component, function)


# -------------------------------------------------------
# _BNComponentSetName

_BNComponentSetName = core.BNComponentSetName
_BNComponentSetName.restype = None
_BNComponentSetName.argtypes = [
		ctypes.POINTER(BNComponent),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNComponentSetName(
		component: ctypes.POINTER(BNComponent), 
		name: Optional[str]
		) -> None:
	return _BNComponentSetName(component, cstr(name))


# -------------------------------------------------------
# _BNComponentsEqual

_BNComponentsEqual = core.BNComponentsEqual
_BNComponentsEqual.restype = ctypes.c_bool
_BNComponentsEqual.argtypes = [
		ctypes.POINTER(BNComponent),
		ctypes.POINTER(BNComponent),
	]


# noinspection PyPep8Naming
def BNComponentsEqual(
		a: ctypes.POINTER(BNComponent), 
		b: ctypes.POINTER(BNComponent)
		) -> bool:
	return _BNComponentsEqual(a, b)


# -------------------------------------------------------
# _BNComponentsNotEqual

_BNComponentsNotEqual = core.BNComponentsNotEqual
_BNComponentsNotEqual.restype = ctypes.c_bool
_BNComponentsNotEqual.argtypes = [
		ctypes.POINTER(BNComponent),
		ctypes.POINTER(BNComponent),
	]


# noinspection PyPep8Naming
def BNComponentsNotEqual(
		a: ctypes.POINTER(BNComponent), 
		b: ctypes.POINTER(BNComponent)
		) -> bool:
	return _BNComponentsNotEqual(a, b)


# -------------------------------------------------------
# _BNConnectEnterpriseServer

_BNConnectEnterpriseServer = core.BNConnectEnterpriseServer
_BNConnectEnterpriseServer.restype = ctypes.c_bool
_BNConnectEnterpriseServer.argtypes = [
	]


# noinspection PyPep8Naming
def BNConnectEnterpriseServer(
		) -> bool:
	return _BNConnectEnterpriseServer()


# -------------------------------------------------------
# _BNConnectWebsocketClient

_BNConnectWebsocketClient = core.BNConnectWebsocketClient
_BNConnectWebsocketClient.restype = ctypes.c_bool
_BNConnectWebsocketClient.argtypes = [
		ctypes.POINTER(BNWebsocketClient),
		ctypes.c_char_p,
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_char_p),
		ctypes.POINTER(ctypes.c_char_p),
		ctypes.POINTER(BNWebsocketClientOutputCallbacks),
	]


# noinspection PyPep8Naming
def BNConnectWebsocketClient(
		client: ctypes.POINTER(BNWebsocketClient), 
		url: Optional[str], 
		headerCount: int, 
		headerKeys: ctypes.POINTER(ctypes.c_char_p), 
		headerValues: ctypes.POINTER(ctypes.c_char_p), 
		callbacks: ctypes.POINTER(BNWebsocketClientOutputCallbacks)
		) -> bool:
	return _BNConnectWebsocketClient(client, cstr(url), headerCount, headerKeys, headerValues, callbacks)


# -------------------------------------------------------
# _BNConvertToNop

_BNConvertToNop = core.BNConvertToNop
_BNConvertToNop.restype = ctypes.c_bool
_BNConvertToNop.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNArchitecture),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNConvertToNop(
		view: ctypes.POINTER(BNBinaryView), 
		arch: ctypes.POINTER(BNArchitecture), 
		addr: int
		) -> bool:
	return _BNConvertToNop(view, arch, addr)


# -------------------------------------------------------
# _BNCopyFile

_BNCopyFile = core.BNCopyFile
_BNCopyFile.restype = ctypes.c_bool
_BNCopyFile.argtypes = [
		ctypes.c_char_p,
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNCopyFile(
		source: Optional[str], 
		dest: Optional[str]
		) -> bool:
	return _BNCopyFile(cstr(source), cstr(dest))


# -------------------------------------------------------
# _BNCoreEnumFromString

_BNCoreEnumFromString = core.BNCoreEnumFromString
_BNCoreEnumFromString.restype = ctypes.c_bool
_BNCoreEnumFromString.argtypes = [
		ctypes.c_char_p,
		ctypes.c_char_p,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNCoreEnumFromString(
		enumName: Optional[str], 
		value: Optional[str], 
		result: ctypes.POINTER(ctypes.c_ulonglong)
		) -> bool:
	return _BNCoreEnumFromString(cstr(enumName), cstr(value), result)


# -------------------------------------------------------
# _BNCoreEnumToString

_BNCoreEnumToString = core.BNCoreEnumToString
_BNCoreEnumToString.restype = ctypes.c_bool
_BNCoreEnumToString.argtypes = [
		ctypes.c_char_p,
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_char_p),
	]


# noinspection PyPep8Naming
def BNCoreEnumToString(
		enumName: Optional[str], 
		value: int, 
		result: ctypes.POINTER(ctypes.c_char_p)
		) -> bool:
	return _BNCoreEnumToString(cstr(enumName), value, result)


# -------------------------------------------------------
# _BNCreateActivity

_BNCreateActivity = core.BNCreateActivity
_BNCreateActivity.restype = ctypes.POINTER(BNActivity)
_BNCreateActivity.argtypes = [
		ctypes.c_char_p,
		ctypes.c_void_p,
		ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNAnalysisContext)),
	]


# noinspection PyPep8Naming
def BNCreateActivity(
		configuration: Optional[str], 
		ctxt: Optional[ctypes.c_void_p], 
		action: ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNAnalysisContext))
		) -> Optional[ctypes.POINTER(BNActivity)]:
	result = _BNCreateActivity(cstr(configuration), ctxt, action)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateAnalysisContext

_BNCreateAnalysisContext = core.BNCreateAnalysisContext
_BNCreateAnalysisContext.restype = ctypes.POINTER(BNAnalysisContext)
_BNCreateAnalysisContext.argtypes = [
	]


# noinspection PyPep8Naming
def BNCreateAnalysisContext(
		) -> Optional[ctypes.POINTER(BNAnalysisContext)]:
	result = _BNCreateAnalysisContext()
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateArrayType

_BNCreateArrayType = core.BNCreateArrayType
_BNCreateArrayType.restype = ctypes.POINTER(BNType)
_BNCreateArrayType.argtypes = [
		ctypes.POINTER(BNTypeWithConfidence),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNCreateArrayType(
		type: ctypes.POINTER(BNTypeWithConfidence), 
		elem: int
		) -> Optional[ctypes.POINTER(BNType)]:
	result = _BNCreateArrayType(type, elem)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateArrayTypeBuilder

_BNCreateArrayTypeBuilder = core.BNCreateArrayTypeBuilder
_BNCreateArrayTypeBuilder.restype = ctypes.POINTER(BNTypeBuilder)
_BNCreateArrayTypeBuilder.argtypes = [
		ctypes.POINTER(BNTypeWithConfidence),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNCreateArrayTypeBuilder(
		type: ctypes.POINTER(BNTypeWithConfidence), 
		elem: int
		) -> Optional[ctypes.POINTER(BNTypeBuilder)]:
	result = _BNCreateArrayTypeBuilder(type, elem)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateAutoStackVariable

_BNCreateAutoStackVariable = core.BNCreateAutoStackVariable
_BNCreateAutoStackVariable.restype = None
_BNCreateAutoStackVariable.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.c_longlong,
		ctypes.POINTER(BNTypeWithConfidence),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNCreateAutoStackVariable(
		func: ctypes.POINTER(BNFunction), 
		offset: int, 
		type: ctypes.POINTER(BNTypeWithConfidence), 
		name: Optional[str]
		) -> None:
	return _BNCreateAutoStackVariable(func, offset, type, cstr(name))


# -------------------------------------------------------
# _BNCreateAutoVariable

_BNCreateAutoVariable = core.BNCreateAutoVariable
_BNCreateAutoVariable.restype = None
_BNCreateAutoVariable.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNVariable),
		ctypes.POINTER(BNTypeWithConfidence),
		ctypes.c_char_p,
		ctypes.c_bool,
	]


# noinspection PyPep8Naming
def BNCreateAutoVariable(
		func: ctypes.POINTER(BNFunction), 
		var: ctypes.POINTER(BNVariable), 
		type: ctypes.POINTER(BNTypeWithConfidence), 
		name: Optional[str], 
		ignoreDisjointUses: bool
		) -> None:
	return _BNCreateAutoVariable(func, var, type, cstr(name), ignoreDisjointUses)


# -------------------------------------------------------
# _BNCreateBinaryDataView

_BNCreateBinaryDataView = core.BNCreateBinaryDataView
_BNCreateBinaryDataView.restype = ctypes.POINTER(BNBinaryView)
_BNCreateBinaryDataView.argtypes = [
		ctypes.POINTER(BNFileMetadata),
	]


# noinspection PyPep8Naming
def BNCreateBinaryDataView(
		file: ctypes.POINTER(BNFileMetadata)
		) -> Optional[ctypes.POINTER(BNBinaryView)]:
	result = _BNCreateBinaryDataView(file)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateBinaryDataViewFromBuffer

_BNCreateBinaryDataViewFromBuffer = core.BNCreateBinaryDataViewFromBuffer
_BNCreateBinaryDataViewFromBuffer.restype = ctypes.POINTER(BNBinaryView)
_BNCreateBinaryDataViewFromBuffer.argtypes = [
		ctypes.POINTER(BNFileMetadata),
		ctypes.POINTER(BNDataBuffer),
	]


# noinspection PyPep8Naming
def BNCreateBinaryDataViewFromBuffer(
		file: ctypes.POINTER(BNFileMetadata), 
		buf: ctypes.POINTER(BNDataBuffer)
		) -> Optional[ctypes.POINTER(BNBinaryView)]:
	result = _BNCreateBinaryDataViewFromBuffer(file, buf)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateBinaryDataViewFromData

_BNCreateBinaryDataViewFromData = core.BNCreateBinaryDataViewFromData
_BNCreateBinaryDataViewFromData.restype = ctypes.POINTER(BNBinaryView)
_BNCreateBinaryDataViewFromData.argtypes = [
		ctypes.POINTER(BNFileMetadata),
		ctypes.c_void_p,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNCreateBinaryDataViewFromData(
		file: ctypes.POINTER(BNFileMetadata), 
		data: Optional[ctypes.c_void_p], 
		len: int
		) -> Optional[ctypes.POINTER(BNBinaryView)]:
	result = _BNCreateBinaryDataViewFromData(file, data, len)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateBinaryDataViewFromFile

_BNCreateBinaryDataViewFromFile = core.BNCreateBinaryDataViewFromFile
_BNCreateBinaryDataViewFromFile.restype = ctypes.POINTER(BNBinaryView)
_BNCreateBinaryDataViewFromFile.argtypes = [
		ctypes.POINTER(BNFileMetadata),
		ctypes.POINTER(BNFileAccessor),
	]


# noinspection PyPep8Naming
def BNCreateBinaryDataViewFromFile(
		file: ctypes.POINTER(BNFileMetadata), 
		accessor: ctypes.POINTER(BNFileAccessor)
		) -> Optional[ctypes.POINTER(BNBinaryView)]:
	result = _BNCreateBinaryDataViewFromFile(file, accessor)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateBinaryDataViewFromFilename

_BNCreateBinaryDataViewFromFilename = core.BNCreateBinaryDataViewFromFilename
_BNCreateBinaryDataViewFromFilename.restype = ctypes.POINTER(BNBinaryView)
_BNCreateBinaryDataViewFromFilename.argtypes = [
		ctypes.POINTER(BNFileMetadata),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNCreateBinaryDataViewFromFilename(
		file: ctypes.POINTER(BNFileMetadata), 
		filename: Optional[str]
		) -> Optional[ctypes.POINTER(BNBinaryView)]:
	result = _BNCreateBinaryDataViewFromFilename(file, cstr(filename))
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateBinaryReader

_BNCreateBinaryReader = core.BNCreateBinaryReader
_BNCreateBinaryReader.restype = ctypes.POINTER(BNBinaryReader)
_BNCreateBinaryReader.argtypes = [
		ctypes.POINTER(BNBinaryView),
	]


# noinspection PyPep8Naming
def BNCreateBinaryReader(
		view: ctypes.POINTER(BNBinaryView)
		) -> Optional[ctypes.POINTER(BNBinaryReader)]:
	result = _BNCreateBinaryReader(view)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateBinaryViewOfType

_BNCreateBinaryViewOfType = core.BNCreateBinaryViewOfType
_BNCreateBinaryViewOfType.restype = ctypes.POINTER(BNBinaryView)
_BNCreateBinaryViewOfType.argtypes = [
		ctypes.POINTER(BNBinaryViewType),
		ctypes.POINTER(BNBinaryView),
	]


# noinspection PyPep8Naming
def BNCreateBinaryViewOfType(
		type: ctypes.POINTER(BNBinaryViewType), 
		data: ctypes.POINTER(BNBinaryView)
		) -> Optional[ctypes.POINTER(BNBinaryView)]:
	result = _BNCreateBinaryViewOfType(type, data)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateBinaryWriter

_BNCreateBinaryWriter = core.BNCreateBinaryWriter
_BNCreateBinaryWriter.restype = ctypes.POINTER(BNBinaryWriter)
_BNCreateBinaryWriter.argtypes = [
		ctypes.POINTER(BNBinaryView),
	]


# noinspection PyPep8Naming
def BNCreateBinaryWriter(
		view: ctypes.POINTER(BNBinaryView)
		) -> Optional[ctypes.POINTER(BNBinaryWriter)]:
	result = _BNCreateBinaryWriter(view)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateBoolType

_BNCreateBoolType = core.BNCreateBoolType
_BNCreateBoolType.restype = ctypes.POINTER(BNType)
_BNCreateBoolType.argtypes = [
	]


# noinspection PyPep8Naming
def BNCreateBoolType(
		) -> Optional[ctypes.POINTER(BNType)]:
	result = _BNCreateBoolType()
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateBoolTypeBuilder

_BNCreateBoolTypeBuilder = core.BNCreateBoolTypeBuilder
_BNCreateBoolTypeBuilder.restype = ctypes.POINTER(BNTypeBuilder)
_BNCreateBoolTypeBuilder.argtypes = [
	]


# noinspection PyPep8Naming
def BNCreateBoolTypeBuilder(
		) -> Optional[ctypes.POINTER(BNTypeBuilder)]:
	result = _BNCreateBoolTypeBuilder()
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateCallingConvention

_BNCreateCallingConvention = core.BNCreateCallingConvention
_BNCreateCallingConvention.restype = ctypes.POINTER(BNCallingConvention)
_BNCreateCallingConvention.argtypes = [
		ctypes.POINTER(BNArchitecture),
		ctypes.c_char_p,
		ctypes.POINTER(BNCustomCallingConvention),
	]


# noinspection PyPep8Naming
def BNCreateCallingConvention(
		arch: ctypes.POINTER(BNArchitecture), 
		name: Optional[str], 
		cc: ctypes.POINTER(BNCustomCallingConvention)
		) -> Optional[ctypes.POINTER(BNCallingConvention)]:
	result = _BNCreateCallingConvention(arch, cstr(name), cc)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateComponent

_BNCreateComponent = core.BNCreateComponent
_BNCreateComponent.restype = ctypes.POINTER(BNComponent)
_BNCreateComponent.argtypes = [
		ctypes.POINTER(BNBinaryView),
	]


# noinspection PyPep8Naming
def BNCreateComponent(
		view: ctypes.POINTER(BNBinaryView)
		) -> Optional[ctypes.POINTER(BNComponent)]:
	result = _BNCreateComponent(view)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateComponentWithName

_BNCreateComponentWithName = core.BNCreateComponentWithName
_BNCreateComponentWithName.restype = ctypes.POINTER(BNComponent)
_BNCreateComponentWithName.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNCreateComponentWithName(
		view: ctypes.POINTER(BNBinaryView), 
		name: Optional[str]
		) -> Optional[ctypes.POINTER(BNComponent)]:
	result = _BNCreateComponentWithName(view, cstr(name))
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateComponentWithParent

_BNCreateComponentWithParent = core.BNCreateComponentWithParent
_BNCreateComponentWithParent.restype = ctypes.POINTER(BNComponent)
_BNCreateComponentWithParent.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNCreateComponentWithParent(
		view: ctypes.POINTER(BNBinaryView), 
		parentGUID: Optional[str]
		) -> Optional[ctypes.POINTER(BNComponent)]:
	result = _BNCreateComponentWithParent(view, cstr(parentGUID))
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateComponentWithParentAndName

_BNCreateComponentWithParentAndName = core.BNCreateComponentWithParentAndName
_BNCreateComponentWithParentAndName.restype = ctypes.POINTER(BNComponent)
_BNCreateComponentWithParentAndName.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_char_p,
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNCreateComponentWithParentAndName(
		view: ctypes.POINTER(BNBinaryView), 
		parentGUID: Optional[str], 
		name: Optional[str]
		) -> Optional[ctypes.POINTER(BNComponent)]:
	result = _BNCreateComponentWithParentAndName(view, cstr(parentGUID), cstr(name))
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateCustomBinaryView

_BNCreateCustomBinaryView = core.BNCreateCustomBinaryView
_BNCreateCustomBinaryView.restype = ctypes.POINTER(BNBinaryView)
_BNCreateCustomBinaryView.argtypes = [
		ctypes.c_char_p,
		ctypes.POINTER(BNFileMetadata),
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNCustomBinaryView),
	]


# noinspection PyPep8Naming
def BNCreateCustomBinaryView(
		name: Optional[str], 
		file: ctypes.POINTER(BNFileMetadata), 
		parent: ctypes.POINTER(BNBinaryView), 
		view: ctypes.POINTER(BNCustomBinaryView)
		) -> Optional[ctypes.POINTER(BNBinaryView)]:
	result = _BNCreateCustomBinaryView(cstr(name), file, parent, view)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateCustomFlowGraph

_BNCreateCustomFlowGraph = core.BNCreateCustomFlowGraph
_BNCreateCustomFlowGraph.restype = ctypes.POINTER(BNFlowGraph)
_BNCreateCustomFlowGraph.argtypes = [
		ctypes.POINTER(BNCustomFlowGraph),
	]


# noinspection PyPep8Naming
def BNCreateCustomFlowGraph(
		callbacks: ctypes.POINTER(BNCustomFlowGraph)
		) -> Optional[ctypes.POINTER(BNFlowGraph)]:
	result = _BNCreateCustomFlowGraph(callbacks)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateDataBuffer

_BNCreateDataBuffer = core.BNCreateDataBuffer
_BNCreateDataBuffer.restype = ctypes.POINTER(BNDataBuffer)
_BNCreateDataBuffer.argtypes = [
		ctypes.c_void_p,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNCreateDataBuffer(
		data: Optional[ctypes.c_void_p], 
		len: int
		) -> Optional[ctypes.POINTER(BNDataBuffer)]:
	result = _BNCreateDataBuffer(data, len)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateDataRenderer

_BNCreateDataRenderer = core.BNCreateDataRenderer
_BNCreateDataRenderer.restype = ctypes.POINTER(BNDataRenderer)
_BNCreateDataRenderer.argtypes = [
		ctypes.POINTER(BNCustomDataRenderer),
	]


# noinspection PyPep8Naming
def BNCreateDataRenderer(
		renderer: ctypes.POINTER(BNCustomDataRenderer)
		) -> Optional[ctypes.POINTER(BNDataRenderer)]:
	result = _BNCreateDataRenderer(renderer)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateDatabase

_BNCreateDatabase = core.BNCreateDatabase
_BNCreateDatabase.restype = ctypes.c_bool
_BNCreateDatabase.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_char_p,
		ctypes.POINTER(BNSaveSettings),
	]


# noinspection PyPep8Naming
def BNCreateDatabase(
		data: ctypes.POINTER(BNBinaryView), 
		path: Optional[str], 
		settings: ctypes.POINTER(BNSaveSettings)
		) -> bool:
	return _BNCreateDatabase(data, cstr(path), settings)


# -------------------------------------------------------
# _BNCreateDatabaseWithProgress

_BNCreateDatabaseWithProgress = core.BNCreateDatabaseWithProgress
_BNCreateDatabaseWithProgress.restype = ctypes.c_bool
_BNCreateDatabaseWithProgress.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_char_p,
		ctypes.c_void_p,
		ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong),
		ctypes.POINTER(BNSaveSettings),
	]


# noinspection PyPep8Naming
def BNCreateDatabaseWithProgress(
		data: ctypes.POINTER(BNBinaryView), 
		path: Optional[str], 
		ctxt: Optional[ctypes.c_void_p], 
		progress: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong), 
		settings: ctypes.POINTER(BNSaveSettings)
		) -> bool:
	return _BNCreateDatabaseWithProgress(data, cstr(path), ctxt, progress, settings)


# -------------------------------------------------------
# _BNCreateDirectory

_BNCreateDirectory = core.BNCreateDirectory
_BNCreateDirectory.restype = ctypes.c_bool
_BNCreateDirectory.argtypes = [
		ctypes.c_char_p,
		ctypes.c_bool,
	]


# noinspection PyPep8Naming
def BNCreateDirectory(
		path: Optional[str], 
		createSubdirectories: bool
		) -> bool:
	return _BNCreateDirectory(cstr(path), createSubdirectories)


# -------------------------------------------------------
# _BNCreateDisassemblySettings

_BNCreateDisassemblySettings = core.BNCreateDisassemblySettings
_BNCreateDisassemblySettings.restype = ctypes.POINTER(BNDisassemblySettings)
_BNCreateDisassemblySettings.argtypes = [
	]


# noinspection PyPep8Naming
def BNCreateDisassemblySettings(
		) -> Optional[ctypes.POINTER(BNDisassemblySettings)]:
	result = _BNCreateDisassemblySettings()
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateDisassemblyTextRenderer

_BNCreateDisassemblyTextRenderer = core.BNCreateDisassemblyTextRenderer
_BNCreateDisassemblyTextRenderer.restype = ctypes.POINTER(BNDisassemblyTextRenderer)
_BNCreateDisassemblyTextRenderer.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNDisassemblySettings),
	]


# noinspection PyPep8Naming
def BNCreateDisassemblyTextRenderer(
		func: ctypes.POINTER(BNFunction), 
		settings: ctypes.POINTER(BNDisassemblySettings)
		) -> Optional[ctypes.POINTER(BNDisassemblyTextRenderer)]:
	result = _BNCreateDisassemblyTextRenderer(func, settings)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateDownloadProviderInstance

_BNCreateDownloadProviderInstance = core.BNCreateDownloadProviderInstance
_BNCreateDownloadProviderInstance.restype = ctypes.POINTER(BNDownloadInstance)
_BNCreateDownloadProviderInstance.argtypes = [
		ctypes.POINTER(BNDownloadProvider),
	]


# noinspection PyPep8Naming
def BNCreateDownloadProviderInstance(
		provider: ctypes.POINTER(BNDownloadProvider)
		) -> Optional[ctypes.POINTER(BNDownloadInstance)]:
	result = _BNCreateDownloadProviderInstance(provider)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateEnumerationBuilder

_BNCreateEnumerationBuilder = core.BNCreateEnumerationBuilder
_BNCreateEnumerationBuilder.restype = ctypes.POINTER(BNEnumerationBuilder)
_BNCreateEnumerationBuilder.argtypes = [
	]


# noinspection PyPep8Naming
def BNCreateEnumerationBuilder(
		) -> Optional[ctypes.POINTER(BNEnumerationBuilder)]:
	result = _BNCreateEnumerationBuilder()
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateEnumerationBuilderFromEnumeration

_BNCreateEnumerationBuilderFromEnumeration = core.BNCreateEnumerationBuilderFromEnumeration
_BNCreateEnumerationBuilderFromEnumeration.restype = ctypes.POINTER(BNEnumerationBuilder)
_BNCreateEnumerationBuilderFromEnumeration.argtypes = [
		ctypes.POINTER(BNEnumeration),
	]


# noinspection PyPep8Naming
def BNCreateEnumerationBuilderFromEnumeration(
		e: ctypes.POINTER(BNEnumeration)
		) -> Optional[ctypes.POINTER(BNEnumerationBuilder)]:
	result = _BNCreateEnumerationBuilderFromEnumeration(e)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateEnumerationType

_BNCreateEnumerationType = core.BNCreateEnumerationType
_BNCreateEnumerationType.restype = ctypes.POINTER(BNType)
_BNCreateEnumerationType.argtypes = [
		ctypes.POINTER(BNArchitecture),
		ctypes.POINTER(BNEnumeration),
		ctypes.c_ulonglong,
		ctypes.POINTER(BNBoolWithConfidence),
	]


# noinspection PyPep8Naming
def BNCreateEnumerationType(
		arch: ctypes.POINTER(BNArchitecture), 
		e: ctypes.POINTER(BNEnumeration), 
		width: int, 
		isSigned: ctypes.POINTER(BNBoolWithConfidence)
		) -> Optional[ctypes.POINTER(BNType)]:
	result = _BNCreateEnumerationType(arch, e, width, isSigned)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateEnumerationTypeBuilder

_BNCreateEnumerationTypeBuilder = core.BNCreateEnumerationTypeBuilder
_BNCreateEnumerationTypeBuilder.restype = ctypes.POINTER(BNTypeBuilder)
_BNCreateEnumerationTypeBuilder.argtypes = [
		ctypes.POINTER(BNArchitecture),
		ctypes.POINTER(BNEnumeration),
		ctypes.c_ulonglong,
		ctypes.POINTER(BNBoolWithConfidence),
	]


# noinspection PyPep8Naming
def BNCreateEnumerationTypeBuilder(
		arch: ctypes.POINTER(BNArchitecture), 
		e: ctypes.POINTER(BNEnumeration), 
		width: int, 
		isSigned: ctypes.POINTER(BNBoolWithConfidence)
		) -> Optional[ctypes.POINTER(BNTypeBuilder)]:
	result = _BNCreateEnumerationTypeBuilder(arch, e, width, isSigned)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateEnumerationTypeBuilderWithBuilder

_BNCreateEnumerationTypeBuilderWithBuilder = core.BNCreateEnumerationTypeBuilderWithBuilder
_BNCreateEnumerationTypeBuilderWithBuilder.restype = ctypes.POINTER(BNTypeBuilder)
_BNCreateEnumerationTypeBuilderWithBuilder.argtypes = [
		ctypes.POINTER(BNArchitecture),
		ctypes.POINTER(BNEnumerationBuilder),
		ctypes.c_ulonglong,
		ctypes.POINTER(BNBoolWithConfidence),
	]


# noinspection PyPep8Naming
def BNCreateEnumerationTypeBuilderWithBuilder(
		arch: ctypes.POINTER(BNArchitecture), 
		e: ctypes.POINTER(BNEnumerationBuilder), 
		width: int, 
		isSigned: ctypes.POINTER(BNBoolWithConfidence)
		) -> Optional[ctypes.POINTER(BNTypeBuilder)]:
	result = _BNCreateEnumerationTypeBuilderWithBuilder(arch, e, width, isSigned)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateEnumerationTypeOfWidth

_BNCreateEnumerationTypeOfWidth = core.BNCreateEnumerationTypeOfWidth
_BNCreateEnumerationTypeOfWidth.restype = ctypes.POINTER(BNType)
_BNCreateEnumerationTypeOfWidth.argtypes = [
		ctypes.POINTER(BNEnumeration),
		ctypes.c_ulonglong,
		ctypes.POINTER(BNBoolWithConfidence),
	]


# noinspection PyPep8Naming
def BNCreateEnumerationTypeOfWidth(
		e: ctypes.POINTER(BNEnumeration), 
		width: int, 
		isSigned: ctypes.POINTER(BNBoolWithConfidence)
		) -> Optional[ctypes.POINTER(BNType)]:
	result = _BNCreateEnumerationTypeOfWidth(e, width, isSigned)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateFileMetadata

_BNCreateFileMetadata = core.BNCreateFileMetadata
_BNCreateFileMetadata.restype = ctypes.POINTER(BNFileMetadata)
_BNCreateFileMetadata.argtypes = [
	]


# noinspection PyPep8Naming
def BNCreateFileMetadata(
		) -> Optional[ctypes.POINTER(BNFileMetadata)]:
	result = _BNCreateFileMetadata()
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateFloatType

_BNCreateFloatType = core.BNCreateFloatType
_BNCreateFloatType.restype = ctypes.POINTER(BNType)
_BNCreateFloatType.argtypes = [
		ctypes.c_ulonglong,
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNCreateFloatType(
		width: int, 
		altName: Optional[str]
		) -> Optional[ctypes.POINTER(BNType)]:
	result = _BNCreateFloatType(width, cstr(altName))
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateFloatTypeBuilder

_BNCreateFloatTypeBuilder = core.BNCreateFloatTypeBuilder
_BNCreateFloatTypeBuilder.restype = ctypes.POINTER(BNTypeBuilder)
_BNCreateFloatTypeBuilder.argtypes = [
		ctypes.c_ulonglong,
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNCreateFloatTypeBuilder(
		width: int, 
		altName: Optional[str]
		) -> Optional[ctypes.POINTER(BNTypeBuilder)]:
	result = _BNCreateFloatTypeBuilder(width, cstr(altName))
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateFlowGraph

_BNCreateFlowGraph = core.BNCreateFlowGraph
_BNCreateFlowGraph.restype = ctypes.POINTER(BNFlowGraph)
_BNCreateFlowGraph.argtypes = [
	]


# noinspection PyPep8Naming
def BNCreateFlowGraph(
		) -> Optional[ctypes.POINTER(BNFlowGraph)]:
	result = _BNCreateFlowGraph()
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateFlowGraphNode

_BNCreateFlowGraphNode = core.BNCreateFlowGraphNode
_BNCreateFlowGraphNode.restype = ctypes.POINTER(BNFlowGraphNode)
_BNCreateFlowGraphNode.argtypes = [
		ctypes.POINTER(BNFlowGraph),
	]


# noinspection PyPep8Naming
def BNCreateFlowGraphNode(
		graph: ctypes.POINTER(BNFlowGraph)
		) -> Optional[ctypes.POINTER(BNFlowGraphNode)]:
	result = _BNCreateFlowGraphNode(graph)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateFunctionGraph

_BNCreateFunctionGraph = core.BNCreateFunctionGraph
_BNCreateFunctionGraph.restype = ctypes.POINTER(BNFlowGraph)
_BNCreateFunctionGraph.argtypes = [
		ctypes.POINTER(BNFunction),
		FunctionGraphTypeEnum,
		ctypes.POINTER(BNDisassemblySettings),
	]


# noinspection PyPep8Naming
def BNCreateFunctionGraph(
		func: ctypes.POINTER(BNFunction), 
		type: FunctionGraphType, 
		settings: ctypes.POINTER(BNDisassemblySettings)
		) -> Optional[ctypes.POINTER(BNFlowGraph)]:
	result = _BNCreateFunctionGraph(func, type, settings)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateFunctionType

_BNCreateFunctionType = core.BNCreateFunctionType
_BNCreateFunctionType.restype = ctypes.POINTER(BNType)
_BNCreateFunctionType.argtypes = [
		ctypes.POINTER(BNTypeWithConfidence),
		ctypes.POINTER(BNCallingConventionWithConfidence),
		ctypes.POINTER(BNFunctionParameter),
		ctypes.c_ulonglong,
		ctypes.POINTER(BNBoolWithConfidence),
		ctypes.POINTER(BNBoolWithConfidence),
		ctypes.POINTER(BNOffsetWithConfidence),
		ctypes.POINTER(ctypes.c_uint),
		ctypes.POINTER(BNOffsetWithConfidence),
		ctypes.c_ulonglong,
		ctypes.POINTER(BNRegisterSetWithConfidence),
		NameTypeEnum,
		ctypes.POINTER(BNBoolWithConfidence),
	]


# noinspection PyPep8Naming
def BNCreateFunctionType(
		returnValue: ctypes.POINTER(BNTypeWithConfidence), 
		callingConvention: ctypes.POINTER(BNCallingConventionWithConfidence), 
		params: ctypes.POINTER(BNFunctionParameter), 
		paramCount: int, 
		varArg: ctypes.POINTER(BNBoolWithConfidence), 
		canReturn: ctypes.POINTER(BNBoolWithConfidence), 
		stackAdjust: ctypes.POINTER(BNOffsetWithConfidence), 
		regStackAdjustRegs: ctypes.POINTER(ctypes.c_uint), 
		regStackAdjustValues: ctypes.POINTER(BNOffsetWithConfidence), 
		regStackAdjustCount: int, 
		returnRegs: ctypes.POINTER(BNRegisterSetWithConfidence), 
		ft: NameType, 
		pure: ctypes.POINTER(BNBoolWithConfidence)
		) -> Optional[ctypes.POINTER(BNType)]:
	result = _BNCreateFunctionType(returnValue, callingConvention, params, paramCount, varArg, canReturn, stackAdjust, regStackAdjustRegs, regStackAdjustValues, regStackAdjustCount, returnRegs, ft, pure)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateFunctionTypeBuilder

_BNCreateFunctionTypeBuilder = core.BNCreateFunctionTypeBuilder
_BNCreateFunctionTypeBuilder.restype = ctypes.POINTER(BNTypeBuilder)
_BNCreateFunctionTypeBuilder.argtypes = [
		ctypes.POINTER(BNTypeWithConfidence),
		ctypes.POINTER(BNCallingConventionWithConfidence),
		ctypes.POINTER(BNFunctionParameter),
		ctypes.c_ulonglong,
		ctypes.POINTER(BNBoolWithConfidence),
		ctypes.POINTER(BNBoolWithConfidence),
		ctypes.POINTER(BNOffsetWithConfidence),
		ctypes.POINTER(ctypes.c_uint),
		ctypes.POINTER(BNOffsetWithConfidence),
		ctypes.c_ulonglong,
		ctypes.POINTER(BNRegisterSetWithConfidence),
		NameTypeEnum,
		ctypes.POINTER(BNBoolWithConfidence),
	]


# noinspection PyPep8Naming
def BNCreateFunctionTypeBuilder(
		returnValue: ctypes.POINTER(BNTypeWithConfidence), 
		callingConvention: ctypes.POINTER(BNCallingConventionWithConfidence), 
		params: ctypes.POINTER(BNFunctionParameter), 
		paramCount: int, 
		varArg: ctypes.POINTER(BNBoolWithConfidence), 
		canReturn: ctypes.POINTER(BNBoolWithConfidence), 
		stackAdjust: ctypes.POINTER(BNOffsetWithConfidence), 
		regStackAdjustRegs: ctypes.POINTER(ctypes.c_uint), 
		regStackAdjustValues: ctypes.POINTER(BNOffsetWithConfidence), 
		regStackAdjustCount: int, 
		returnRegs: ctypes.POINTER(BNRegisterSetWithConfidence), 
		ft: NameType, 
		pure: ctypes.POINTER(BNBoolWithConfidence)
		) -> Optional[ctypes.POINTER(BNTypeBuilder)]:
	result = _BNCreateFunctionTypeBuilder(returnValue, callingConvention, params, paramCount, varArg, canReturn, stackAdjust, regStackAdjustRegs, regStackAdjustValues, regStackAdjustCount, returnRegs, ft, pure)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateHighLevelILDisassemblyTextRenderer

_BNCreateHighLevelILDisassemblyTextRenderer = core.BNCreateHighLevelILDisassemblyTextRenderer
_BNCreateHighLevelILDisassemblyTextRenderer.restype = ctypes.POINTER(BNDisassemblyTextRenderer)
_BNCreateHighLevelILDisassemblyTextRenderer.argtypes = [
		ctypes.POINTER(BNHighLevelILFunction),
		ctypes.POINTER(BNDisassemblySettings),
	]


# noinspection PyPep8Naming
def BNCreateHighLevelILDisassemblyTextRenderer(
		func: ctypes.POINTER(BNHighLevelILFunction), 
		settings: ctypes.POINTER(BNDisassemblySettings)
		) -> Optional[ctypes.POINTER(BNDisassemblyTextRenderer)]:
	result = _BNCreateHighLevelILDisassemblyTextRenderer(func, settings)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateHighLevelILFunction

_BNCreateHighLevelILFunction = core.BNCreateHighLevelILFunction
_BNCreateHighLevelILFunction.restype = ctypes.POINTER(BNHighLevelILFunction)
_BNCreateHighLevelILFunction.argtypes = [
		ctypes.POINTER(BNArchitecture),
		ctypes.POINTER(BNFunction),
	]


# noinspection PyPep8Naming
def BNCreateHighLevelILFunction(
		arch: ctypes.POINTER(BNArchitecture), 
		func: ctypes.POINTER(BNFunction)
		) -> Optional[ctypes.POINTER(BNHighLevelILFunction)]:
	result = _BNCreateHighLevelILFunction(arch, func)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateHighLevelILFunctionGraph

_BNCreateHighLevelILFunctionGraph = core.BNCreateHighLevelILFunctionGraph
_BNCreateHighLevelILFunctionGraph.restype = ctypes.POINTER(BNFlowGraph)
_BNCreateHighLevelILFunctionGraph.argtypes = [
		ctypes.POINTER(BNHighLevelILFunction),
		ctypes.POINTER(BNDisassemblySettings),
	]


# noinspection PyPep8Naming
def BNCreateHighLevelILFunctionGraph(
		func: ctypes.POINTER(BNHighLevelILFunction), 
		settings: ctypes.POINTER(BNDisassemblySettings)
		) -> Optional[ctypes.POINTER(BNFlowGraph)]:
	result = _BNCreateHighLevelILFunctionGraph(func, settings)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateIntegerType

_BNCreateIntegerType = core.BNCreateIntegerType
_BNCreateIntegerType.restype = ctypes.POINTER(BNType)
_BNCreateIntegerType.argtypes = [
		ctypes.c_ulonglong,
		ctypes.POINTER(BNBoolWithConfidence),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNCreateIntegerType(
		width: int, 
		sign: ctypes.POINTER(BNBoolWithConfidence), 
		altName: Optional[str]
		) -> Optional[ctypes.POINTER(BNType)]:
	result = _BNCreateIntegerType(width, sign, cstr(altName))
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateIntegerTypeBuilder

_BNCreateIntegerTypeBuilder = core.BNCreateIntegerTypeBuilder
_BNCreateIntegerTypeBuilder.restype = ctypes.POINTER(BNTypeBuilder)
_BNCreateIntegerTypeBuilder.argtypes = [
		ctypes.c_ulonglong,
		ctypes.POINTER(BNBoolWithConfidence),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNCreateIntegerTypeBuilder(
		width: int, 
		sign: ctypes.POINTER(BNBoolWithConfidence), 
		altName: Optional[str]
		) -> Optional[ctypes.POINTER(BNTypeBuilder)]:
	result = _BNCreateIntegerTypeBuilder(width, sign, cstr(altName))
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateKeyValueStore

_BNCreateKeyValueStore = core.BNCreateKeyValueStore
_BNCreateKeyValueStore.restype = ctypes.POINTER(BNKeyValueStore)
_BNCreateKeyValueStore.argtypes = [
	]


# noinspection PyPep8Naming
def BNCreateKeyValueStore(
		) -> Optional[ctypes.POINTER(BNKeyValueStore)]:
	result = _BNCreateKeyValueStore()
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateKeyValueStoreFromDataBuffer

_BNCreateKeyValueStoreFromDataBuffer = core.BNCreateKeyValueStoreFromDataBuffer
_BNCreateKeyValueStoreFromDataBuffer.restype = ctypes.POINTER(BNKeyValueStore)
_BNCreateKeyValueStoreFromDataBuffer.argtypes = [
		ctypes.POINTER(BNDataBuffer),
	]


# noinspection PyPep8Naming
def BNCreateKeyValueStoreFromDataBuffer(
		buffer: ctypes.POINTER(BNDataBuffer)
		) -> Optional[ctypes.POINTER(BNKeyValueStore)]:
	result = _BNCreateKeyValueStoreFromDataBuffer(buffer)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateLanguageRepresentationFunction

_BNCreateLanguageRepresentationFunction = core.BNCreateLanguageRepresentationFunction
_BNCreateLanguageRepresentationFunction.restype = ctypes.POINTER(BNLanguageRepresentationFunction)
_BNCreateLanguageRepresentationFunction.argtypes = [
		ctypes.POINTER(BNArchitecture),
		ctypes.POINTER(BNFunction),
	]


# noinspection PyPep8Naming
def BNCreateLanguageRepresentationFunction(
		arch: ctypes.POINTER(BNArchitecture), 
		func: ctypes.POINTER(BNFunction)
		) -> Optional[ctypes.POINTER(BNLanguageRepresentationFunction)]:
	result = _BNCreateLanguageRepresentationFunction(arch, func)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateLinearViewCursor

_BNCreateLinearViewCursor = core.BNCreateLinearViewCursor
_BNCreateLinearViewCursor.restype = ctypes.POINTER(BNLinearViewCursor)
_BNCreateLinearViewCursor.argtypes = [
		ctypes.POINTER(BNLinearViewObject),
	]


# noinspection PyPep8Naming
def BNCreateLinearViewCursor(
		root: ctypes.POINTER(BNLinearViewObject)
		) -> Optional[ctypes.POINTER(BNLinearViewCursor)]:
	result = _BNCreateLinearViewCursor(root)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateLinearViewDataOnly

_BNCreateLinearViewDataOnly = core.BNCreateLinearViewDataOnly
_BNCreateLinearViewDataOnly.restype = ctypes.POINTER(BNLinearViewObject)
_BNCreateLinearViewDataOnly.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNDisassemblySettings),
	]


# noinspection PyPep8Naming
def BNCreateLinearViewDataOnly(
		view: ctypes.POINTER(BNBinaryView), 
		settings: ctypes.POINTER(BNDisassemblySettings)
		) -> Optional[ctypes.POINTER(BNLinearViewObject)]:
	result = _BNCreateLinearViewDataOnly(view, settings)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateLinearViewDisassembly

_BNCreateLinearViewDisassembly = core.BNCreateLinearViewDisassembly
_BNCreateLinearViewDisassembly.restype = ctypes.POINTER(BNLinearViewObject)
_BNCreateLinearViewDisassembly.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNDisassemblySettings),
	]


# noinspection PyPep8Naming
def BNCreateLinearViewDisassembly(
		view: ctypes.POINTER(BNBinaryView), 
		settings: ctypes.POINTER(BNDisassemblySettings)
		) -> Optional[ctypes.POINTER(BNLinearViewObject)]:
	result = _BNCreateLinearViewDisassembly(view, settings)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateLinearViewHighLevelIL

_BNCreateLinearViewHighLevelIL = core.BNCreateLinearViewHighLevelIL
_BNCreateLinearViewHighLevelIL.restype = ctypes.POINTER(BNLinearViewObject)
_BNCreateLinearViewHighLevelIL.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNDisassemblySettings),
	]


# noinspection PyPep8Naming
def BNCreateLinearViewHighLevelIL(
		view: ctypes.POINTER(BNBinaryView), 
		settings: ctypes.POINTER(BNDisassemblySettings)
		) -> Optional[ctypes.POINTER(BNLinearViewObject)]:
	result = _BNCreateLinearViewHighLevelIL(view, settings)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateLinearViewHighLevelILSSAForm

_BNCreateLinearViewHighLevelILSSAForm = core.BNCreateLinearViewHighLevelILSSAForm
_BNCreateLinearViewHighLevelILSSAForm.restype = ctypes.POINTER(BNLinearViewObject)
_BNCreateLinearViewHighLevelILSSAForm.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNDisassemblySettings),
	]


# noinspection PyPep8Naming
def BNCreateLinearViewHighLevelILSSAForm(
		view: ctypes.POINTER(BNBinaryView), 
		settings: ctypes.POINTER(BNDisassemblySettings)
		) -> Optional[ctypes.POINTER(BNLinearViewObject)]:
	result = _BNCreateLinearViewHighLevelILSSAForm(view, settings)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateLinearViewLanguageRepresentation

_BNCreateLinearViewLanguageRepresentation = core.BNCreateLinearViewLanguageRepresentation
_BNCreateLinearViewLanguageRepresentation.restype = ctypes.POINTER(BNLinearViewObject)
_BNCreateLinearViewLanguageRepresentation.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNDisassemblySettings),
	]


# noinspection PyPep8Naming
def BNCreateLinearViewLanguageRepresentation(
		view: ctypes.POINTER(BNBinaryView), 
		settings: ctypes.POINTER(BNDisassemblySettings)
		) -> Optional[ctypes.POINTER(BNLinearViewObject)]:
	result = _BNCreateLinearViewLanguageRepresentation(view, settings)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateLinearViewLiftedIL

_BNCreateLinearViewLiftedIL = core.BNCreateLinearViewLiftedIL
_BNCreateLinearViewLiftedIL.restype = ctypes.POINTER(BNLinearViewObject)
_BNCreateLinearViewLiftedIL.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNDisassemblySettings),
	]


# noinspection PyPep8Naming
def BNCreateLinearViewLiftedIL(
		view: ctypes.POINTER(BNBinaryView), 
		settings: ctypes.POINTER(BNDisassemblySettings)
		) -> Optional[ctypes.POINTER(BNLinearViewObject)]:
	result = _BNCreateLinearViewLiftedIL(view, settings)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateLinearViewLowLevelIL

_BNCreateLinearViewLowLevelIL = core.BNCreateLinearViewLowLevelIL
_BNCreateLinearViewLowLevelIL.restype = ctypes.POINTER(BNLinearViewObject)
_BNCreateLinearViewLowLevelIL.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNDisassemblySettings),
	]


# noinspection PyPep8Naming
def BNCreateLinearViewLowLevelIL(
		view: ctypes.POINTER(BNBinaryView), 
		settings: ctypes.POINTER(BNDisassemblySettings)
		) -> Optional[ctypes.POINTER(BNLinearViewObject)]:
	result = _BNCreateLinearViewLowLevelIL(view, settings)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateLinearViewLowLevelILSSAForm

_BNCreateLinearViewLowLevelILSSAForm = core.BNCreateLinearViewLowLevelILSSAForm
_BNCreateLinearViewLowLevelILSSAForm.restype = ctypes.POINTER(BNLinearViewObject)
_BNCreateLinearViewLowLevelILSSAForm.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNDisassemblySettings),
	]


# noinspection PyPep8Naming
def BNCreateLinearViewLowLevelILSSAForm(
		view: ctypes.POINTER(BNBinaryView), 
		settings: ctypes.POINTER(BNDisassemblySettings)
		) -> Optional[ctypes.POINTER(BNLinearViewObject)]:
	result = _BNCreateLinearViewLowLevelILSSAForm(view, settings)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateLinearViewMappedMediumLevelIL

_BNCreateLinearViewMappedMediumLevelIL = core.BNCreateLinearViewMappedMediumLevelIL
_BNCreateLinearViewMappedMediumLevelIL.restype = ctypes.POINTER(BNLinearViewObject)
_BNCreateLinearViewMappedMediumLevelIL.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNDisassemblySettings),
	]


# noinspection PyPep8Naming
def BNCreateLinearViewMappedMediumLevelIL(
		view: ctypes.POINTER(BNBinaryView), 
		settings: ctypes.POINTER(BNDisassemblySettings)
		) -> Optional[ctypes.POINTER(BNLinearViewObject)]:
	result = _BNCreateLinearViewMappedMediumLevelIL(view, settings)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateLinearViewMappedMediumLevelILSSAForm

_BNCreateLinearViewMappedMediumLevelILSSAForm = core.BNCreateLinearViewMappedMediumLevelILSSAForm
_BNCreateLinearViewMappedMediumLevelILSSAForm.restype = ctypes.POINTER(BNLinearViewObject)
_BNCreateLinearViewMappedMediumLevelILSSAForm.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNDisassemblySettings),
	]


# noinspection PyPep8Naming
def BNCreateLinearViewMappedMediumLevelILSSAForm(
		view: ctypes.POINTER(BNBinaryView), 
		settings: ctypes.POINTER(BNDisassemblySettings)
		) -> Optional[ctypes.POINTER(BNLinearViewObject)]:
	result = _BNCreateLinearViewMappedMediumLevelILSSAForm(view, settings)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateLinearViewMediumLevelIL

_BNCreateLinearViewMediumLevelIL = core.BNCreateLinearViewMediumLevelIL
_BNCreateLinearViewMediumLevelIL.restype = ctypes.POINTER(BNLinearViewObject)
_BNCreateLinearViewMediumLevelIL.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNDisassemblySettings),
	]


# noinspection PyPep8Naming
def BNCreateLinearViewMediumLevelIL(
		view: ctypes.POINTER(BNBinaryView), 
		settings: ctypes.POINTER(BNDisassemblySettings)
		) -> Optional[ctypes.POINTER(BNLinearViewObject)]:
	result = _BNCreateLinearViewMediumLevelIL(view, settings)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateLinearViewMediumLevelILSSAForm

_BNCreateLinearViewMediumLevelILSSAForm = core.BNCreateLinearViewMediumLevelILSSAForm
_BNCreateLinearViewMediumLevelILSSAForm.restype = ctypes.POINTER(BNLinearViewObject)
_BNCreateLinearViewMediumLevelILSSAForm.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNDisassemblySettings),
	]


# noinspection PyPep8Naming
def BNCreateLinearViewMediumLevelILSSAForm(
		view: ctypes.POINTER(BNBinaryView), 
		settings: ctypes.POINTER(BNDisassemblySettings)
		) -> Optional[ctypes.POINTER(BNLinearViewObject)]:
	result = _BNCreateLinearViewMediumLevelILSSAForm(view, settings)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateLinearViewSingleFunctionDisassembly

_BNCreateLinearViewSingleFunctionDisassembly = core.BNCreateLinearViewSingleFunctionDisassembly
_BNCreateLinearViewSingleFunctionDisassembly.restype = ctypes.POINTER(BNLinearViewObject)
_BNCreateLinearViewSingleFunctionDisassembly.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNDisassemblySettings),
	]


# noinspection PyPep8Naming
def BNCreateLinearViewSingleFunctionDisassembly(
		func: ctypes.POINTER(BNFunction), 
		settings: ctypes.POINTER(BNDisassemblySettings)
		) -> Optional[ctypes.POINTER(BNLinearViewObject)]:
	result = _BNCreateLinearViewSingleFunctionDisassembly(func, settings)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateLinearViewSingleFunctionHighLevelIL

_BNCreateLinearViewSingleFunctionHighLevelIL = core.BNCreateLinearViewSingleFunctionHighLevelIL
_BNCreateLinearViewSingleFunctionHighLevelIL.restype = ctypes.POINTER(BNLinearViewObject)
_BNCreateLinearViewSingleFunctionHighLevelIL.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNDisassemblySettings),
	]


# noinspection PyPep8Naming
def BNCreateLinearViewSingleFunctionHighLevelIL(
		func: ctypes.POINTER(BNFunction), 
		settings: ctypes.POINTER(BNDisassemblySettings)
		) -> Optional[ctypes.POINTER(BNLinearViewObject)]:
	result = _BNCreateLinearViewSingleFunctionHighLevelIL(func, settings)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateLinearViewSingleFunctionHighLevelILSSAForm

_BNCreateLinearViewSingleFunctionHighLevelILSSAForm = core.BNCreateLinearViewSingleFunctionHighLevelILSSAForm
_BNCreateLinearViewSingleFunctionHighLevelILSSAForm.restype = ctypes.POINTER(BNLinearViewObject)
_BNCreateLinearViewSingleFunctionHighLevelILSSAForm.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNDisassemblySettings),
	]


# noinspection PyPep8Naming
def BNCreateLinearViewSingleFunctionHighLevelILSSAForm(
		func: ctypes.POINTER(BNFunction), 
		settings: ctypes.POINTER(BNDisassemblySettings)
		) -> Optional[ctypes.POINTER(BNLinearViewObject)]:
	result = _BNCreateLinearViewSingleFunctionHighLevelILSSAForm(func, settings)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateLinearViewSingleFunctionLanguageRepresentation

_BNCreateLinearViewSingleFunctionLanguageRepresentation = core.BNCreateLinearViewSingleFunctionLanguageRepresentation
_BNCreateLinearViewSingleFunctionLanguageRepresentation.restype = ctypes.POINTER(BNLinearViewObject)
_BNCreateLinearViewSingleFunctionLanguageRepresentation.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNDisassemblySettings),
	]


# noinspection PyPep8Naming
def BNCreateLinearViewSingleFunctionLanguageRepresentation(
		func: ctypes.POINTER(BNFunction), 
		settings: ctypes.POINTER(BNDisassemblySettings)
		) -> Optional[ctypes.POINTER(BNLinearViewObject)]:
	result = _BNCreateLinearViewSingleFunctionLanguageRepresentation(func, settings)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateLinearViewSingleFunctionLiftedIL

_BNCreateLinearViewSingleFunctionLiftedIL = core.BNCreateLinearViewSingleFunctionLiftedIL
_BNCreateLinearViewSingleFunctionLiftedIL.restype = ctypes.POINTER(BNLinearViewObject)
_BNCreateLinearViewSingleFunctionLiftedIL.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNDisassemblySettings),
	]


# noinspection PyPep8Naming
def BNCreateLinearViewSingleFunctionLiftedIL(
		func: ctypes.POINTER(BNFunction), 
		settings: ctypes.POINTER(BNDisassemblySettings)
		) -> Optional[ctypes.POINTER(BNLinearViewObject)]:
	result = _BNCreateLinearViewSingleFunctionLiftedIL(func, settings)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateLinearViewSingleFunctionLowLevelIL

_BNCreateLinearViewSingleFunctionLowLevelIL = core.BNCreateLinearViewSingleFunctionLowLevelIL
_BNCreateLinearViewSingleFunctionLowLevelIL.restype = ctypes.POINTER(BNLinearViewObject)
_BNCreateLinearViewSingleFunctionLowLevelIL.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNDisassemblySettings),
	]


# noinspection PyPep8Naming
def BNCreateLinearViewSingleFunctionLowLevelIL(
		func: ctypes.POINTER(BNFunction), 
		settings: ctypes.POINTER(BNDisassemblySettings)
		) -> Optional[ctypes.POINTER(BNLinearViewObject)]:
	result = _BNCreateLinearViewSingleFunctionLowLevelIL(func, settings)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateLinearViewSingleFunctionLowLevelILSSAForm

_BNCreateLinearViewSingleFunctionLowLevelILSSAForm = core.BNCreateLinearViewSingleFunctionLowLevelILSSAForm
_BNCreateLinearViewSingleFunctionLowLevelILSSAForm.restype = ctypes.POINTER(BNLinearViewObject)
_BNCreateLinearViewSingleFunctionLowLevelILSSAForm.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNDisassemblySettings),
	]


# noinspection PyPep8Naming
def BNCreateLinearViewSingleFunctionLowLevelILSSAForm(
		func: ctypes.POINTER(BNFunction), 
		settings: ctypes.POINTER(BNDisassemblySettings)
		) -> Optional[ctypes.POINTER(BNLinearViewObject)]:
	result = _BNCreateLinearViewSingleFunctionLowLevelILSSAForm(func, settings)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateLinearViewSingleFunctionMappedMediumLevelIL

_BNCreateLinearViewSingleFunctionMappedMediumLevelIL = core.BNCreateLinearViewSingleFunctionMappedMediumLevelIL
_BNCreateLinearViewSingleFunctionMappedMediumLevelIL.restype = ctypes.POINTER(BNLinearViewObject)
_BNCreateLinearViewSingleFunctionMappedMediumLevelIL.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNDisassemblySettings),
	]


# noinspection PyPep8Naming
def BNCreateLinearViewSingleFunctionMappedMediumLevelIL(
		func: ctypes.POINTER(BNFunction), 
		settings: ctypes.POINTER(BNDisassemblySettings)
		) -> Optional[ctypes.POINTER(BNLinearViewObject)]:
	result = _BNCreateLinearViewSingleFunctionMappedMediumLevelIL(func, settings)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateLinearViewSingleFunctionMappedMediumLevelILSSAForm

_BNCreateLinearViewSingleFunctionMappedMediumLevelILSSAForm = core.BNCreateLinearViewSingleFunctionMappedMediumLevelILSSAForm
_BNCreateLinearViewSingleFunctionMappedMediumLevelILSSAForm.restype = ctypes.POINTER(BNLinearViewObject)
_BNCreateLinearViewSingleFunctionMappedMediumLevelILSSAForm.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNDisassemblySettings),
	]


# noinspection PyPep8Naming
def BNCreateLinearViewSingleFunctionMappedMediumLevelILSSAForm(
		func: ctypes.POINTER(BNFunction), 
		settings: ctypes.POINTER(BNDisassemblySettings)
		) -> Optional[ctypes.POINTER(BNLinearViewObject)]:
	result = _BNCreateLinearViewSingleFunctionMappedMediumLevelILSSAForm(func, settings)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateLinearViewSingleFunctionMediumLevelIL

_BNCreateLinearViewSingleFunctionMediumLevelIL = core.BNCreateLinearViewSingleFunctionMediumLevelIL
_BNCreateLinearViewSingleFunctionMediumLevelIL.restype = ctypes.POINTER(BNLinearViewObject)
_BNCreateLinearViewSingleFunctionMediumLevelIL.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNDisassemblySettings),
	]


# noinspection PyPep8Naming
def BNCreateLinearViewSingleFunctionMediumLevelIL(
		func: ctypes.POINTER(BNFunction), 
		settings: ctypes.POINTER(BNDisassemblySettings)
		) -> Optional[ctypes.POINTER(BNLinearViewObject)]:
	result = _BNCreateLinearViewSingleFunctionMediumLevelIL(func, settings)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateLinearViewSingleFunctionMediumLevelILSSAForm

_BNCreateLinearViewSingleFunctionMediumLevelILSSAForm = core.BNCreateLinearViewSingleFunctionMediumLevelILSSAForm
_BNCreateLinearViewSingleFunctionMediumLevelILSSAForm.restype = ctypes.POINTER(BNLinearViewObject)
_BNCreateLinearViewSingleFunctionMediumLevelILSSAForm.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNDisassemblySettings),
	]


# noinspection PyPep8Naming
def BNCreateLinearViewSingleFunctionMediumLevelILSSAForm(
		func: ctypes.POINTER(BNFunction), 
		settings: ctypes.POINTER(BNDisassemblySettings)
		) -> Optional[ctypes.POINTER(BNLinearViewObject)]:
	result = _BNCreateLinearViewSingleFunctionMediumLevelILSSAForm(func, settings)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateLowLevelILDisassemblyTextRenderer

_BNCreateLowLevelILDisassemblyTextRenderer = core.BNCreateLowLevelILDisassemblyTextRenderer
_BNCreateLowLevelILDisassemblyTextRenderer.restype = ctypes.POINTER(BNDisassemblyTextRenderer)
_BNCreateLowLevelILDisassemblyTextRenderer.argtypes = [
		ctypes.POINTER(BNLowLevelILFunction),
		ctypes.POINTER(BNDisassemblySettings),
	]


# noinspection PyPep8Naming
def BNCreateLowLevelILDisassemblyTextRenderer(
		func: ctypes.POINTER(BNLowLevelILFunction), 
		settings: ctypes.POINTER(BNDisassemblySettings)
		) -> Optional[ctypes.POINTER(BNDisassemblyTextRenderer)]:
	result = _BNCreateLowLevelILDisassemblyTextRenderer(func, settings)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateLowLevelILFunction

_BNCreateLowLevelILFunction = core.BNCreateLowLevelILFunction
_BNCreateLowLevelILFunction.restype = ctypes.POINTER(BNLowLevelILFunction)
_BNCreateLowLevelILFunction.argtypes = [
		ctypes.POINTER(BNArchitecture),
		ctypes.POINTER(BNFunction),
	]


# noinspection PyPep8Naming
def BNCreateLowLevelILFunction(
		arch: ctypes.POINTER(BNArchitecture), 
		func: ctypes.POINTER(BNFunction)
		) -> Optional[ctypes.POINTER(BNLowLevelILFunction)]:
	result = _BNCreateLowLevelILFunction(arch, func)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateLowLevelILFunctionGraph

_BNCreateLowLevelILFunctionGraph = core.BNCreateLowLevelILFunctionGraph
_BNCreateLowLevelILFunctionGraph.restype = ctypes.POINTER(BNFlowGraph)
_BNCreateLowLevelILFunctionGraph.argtypes = [
		ctypes.POINTER(BNLowLevelILFunction),
		ctypes.POINTER(BNDisassemblySettings),
	]


# noinspection PyPep8Naming
def BNCreateLowLevelILFunctionGraph(
		func: ctypes.POINTER(BNLowLevelILFunction), 
		settings: ctypes.POINTER(BNDisassemblySettings)
		) -> Optional[ctypes.POINTER(BNFlowGraph)]:
	result = _BNCreateLowLevelILFunctionGraph(func, settings)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateMediumLevelILDisassemblyTextRenderer

_BNCreateMediumLevelILDisassemblyTextRenderer = core.BNCreateMediumLevelILDisassemblyTextRenderer
_BNCreateMediumLevelILDisassemblyTextRenderer.restype = ctypes.POINTER(BNDisassemblyTextRenderer)
_BNCreateMediumLevelILDisassemblyTextRenderer.argtypes = [
		ctypes.POINTER(BNMediumLevelILFunction),
		ctypes.POINTER(BNDisassemblySettings),
	]


# noinspection PyPep8Naming
def BNCreateMediumLevelILDisassemblyTextRenderer(
		func: ctypes.POINTER(BNMediumLevelILFunction), 
		settings: ctypes.POINTER(BNDisassemblySettings)
		) -> Optional[ctypes.POINTER(BNDisassemblyTextRenderer)]:
	result = _BNCreateMediumLevelILDisassemblyTextRenderer(func, settings)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateMediumLevelILFunction

_BNCreateMediumLevelILFunction = core.BNCreateMediumLevelILFunction
_BNCreateMediumLevelILFunction.restype = ctypes.POINTER(BNMediumLevelILFunction)
_BNCreateMediumLevelILFunction.argtypes = [
		ctypes.POINTER(BNArchitecture),
		ctypes.POINTER(BNFunction),
	]


# noinspection PyPep8Naming
def BNCreateMediumLevelILFunction(
		arch: ctypes.POINTER(BNArchitecture), 
		func: ctypes.POINTER(BNFunction)
		) -> Optional[ctypes.POINTER(BNMediumLevelILFunction)]:
	result = _BNCreateMediumLevelILFunction(arch, func)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateMediumLevelILFunctionGraph

_BNCreateMediumLevelILFunctionGraph = core.BNCreateMediumLevelILFunctionGraph
_BNCreateMediumLevelILFunctionGraph.restype = ctypes.POINTER(BNFlowGraph)
_BNCreateMediumLevelILFunctionGraph.argtypes = [
		ctypes.POINTER(BNMediumLevelILFunction),
		ctypes.POINTER(BNDisassemblySettings),
	]


# noinspection PyPep8Naming
def BNCreateMediumLevelILFunctionGraph(
		func: ctypes.POINTER(BNMediumLevelILFunction), 
		settings: ctypes.POINTER(BNDisassemblySettings)
		) -> Optional[ctypes.POINTER(BNFlowGraph)]:
	result = _BNCreateMediumLevelILFunctionGraph(func, settings)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateMetadataArray

_BNCreateMetadataArray = core.BNCreateMetadataArray
_BNCreateMetadataArray.restype = ctypes.POINTER(BNMetadata)
_BNCreateMetadataArray.argtypes = [
		ctypes.POINTER(ctypes.POINTER(BNMetadata)),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNCreateMetadataArray(
		data: ctypes.POINTER(ctypes.POINTER(BNMetadata)), 
		size: int
		) -> Optional[ctypes.POINTER(BNMetadata)]:
	result = _BNCreateMetadataArray(data, size)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateMetadataBooleanData

_BNCreateMetadataBooleanData = core.BNCreateMetadataBooleanData
_BNCreateMetadataBooleanData.restype = ctypes.POINTER(BNMetadata)
_BNCreateMetadataBooleanData.argtypes = [
		ctypes.c_bool,
	]


# noinspection PyPep8Naming
def BNCreateMetadataBooleanData(
		data: bool
		) -> Optional[ctypes.POINTER(BNMetadata)]:
	result = _BNCreateMetadataBooleanData(data)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateMetadataBooleanListData

_BNCreateMetadataBooleanListData = core.BNCreateMetadataBooleanListData
_BNCreateMetadataBooleanListData.restype = ctypes.POINTER(BNMetadata)
_BNCreateMetadataBooleanListData.argtypes = [
		ctypes.POINTER(ctypes.c_bool),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNCreateMetadataBooleanListData(
		data: ctypes.POINTER(ctypes.c_bool), 
		size: int
		) -> Optional[ctypes.POINTER(BNMetadata)]:
	result = _BNCreateMetadataBooleanListData(data, size)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateMetadataDoubleData

_BNCreateMetadataDoubleData = core.BNCreateMetadataDoubleData
_BNCreateMetadataDoubleData.restype = ctypes.POINTER(BNMetadata)
_BNCreateMetadataDoubleData.argtypes = [
		ctypes.c_double,
	]


# noinspection PyPep8Naming
def BNCreateMetadataDoubleData(
		data: float
		) -> Optional[ctypes.POINTER(BNMetadata)]:
	result = _BNCreateMetadataDoubleData(data)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateMetadataDoubleListData

_BNCreateMetadataDoubleListData = core.BNCreateMetadataDoubleListData
_BNCreateMetadataDoubleListData.restype = ctypes.POINTER(BNMetadata)
_BNCreateMetadataDoubleListData.argtypes = [
		ctypes.POINTER(ctypes.c_double),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNCreateMetadataDoubleListData(
		data: ctypes.POINTER(ctypes.c_double), 
		size: int
		) -> Optional[ctypes.POINTER(BNMetadata)]:
	result = _BNCreateMetadataDoubleListData(data, size)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateMetadataOfType

_BNCreateMetadataOfType = core.BNCreateMetadataOfType
_BNCreateMetadataOfType.restype = ctypes.POINTER(BNMetadata)
_BNCreateMetadataOfType.argtypes = [
		MetadataTypeEnum,
	]


# noinspection PyPep8Naming
def BNCreateMetadataOfType(
		type: MetadataType
		) -> Optional[ctypes.POINTER(BNMetadata)]:
	result = _BNCreateMetadataOfType(type)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateMetadataRawData

_BNCreateMetadataRawData = core.BNCreateMetadataRawData
_BNCreateMetadataRawData.restype = ctypes.POINTER(BNMetadata)
_BNCreateMetadataRawData.argtypes = [
		ctypes.POINTER(ctypes.c_ubyte),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNCreateMetadataRawData(
		data: ctypes.POINTER(ctypes.c_ubyte), 
		size: int
		) -> Optional[ctypes.POINTER(BNMetadata)]:
	result = _BNCreateMetadataRawData(data, size)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateMetadataSignedIntegerData

_BNCreateMetadataSignedIntegerData = core.BNCreateMetadataSignedIntegerData
_BNCreateMetadataSignedIntegerData.restype = ctypes.POINTER(BNMetadata)
_BNCreateMetadataSignedIntegerData.argtypes = [
		ctypes.c_longlong,
	]


# noinspection PyPep8Naming
def BNCreateMetadataSignedIntegerData(
		data: int
		) -> Optional[ctypes.POINTER(BNMetadata)]:
	result = _BNCreateMetadataSignedIntegerData(data)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateMetadataSignedIntegerListData

_BNCreateMetadataSignedIntegerListData = core.BNCreateMetadataSignedIntegerListData
_BNCreateMetadataSignedIntegerListData.restype = ctypes.POINTER(BNMetadata)
_BNCreateMetadataSignedIntegerListData.argtypes = [
		ctypes.POINTER(ctypes.c_longlong),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNCreateMetadataSignedIntegerListData(
		data: ctypes.POINTER(ctypes.c_longlong), 
		size: int
		) -> Optional[ctypes.POINTER(BNMetadata)]:
	result = _BNCreateMetadataSignedIntegerListData(data, size)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateMetadataStringData

_BNCreateMetadataStringData = core.BNCreateMetadataStringData
_BNCreateMetadataStringData.restype = ctypes.POINTER(BNMetadata)
_BNCreateMetadataStringData.argtypes = [
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNCreateMetadataStringData(
		data: Optional[str]
		) -> Optional[ctypes.POINTER(BNMetadata)]:
	result = _BNCreateMetadataStringData(cstr(data))
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateMetadataStringListData

_BNCreateMetadataStringListData = core.BNCreateMetadataStringListData
_BNCreateMetadataStringListData.restype = ctypes.POINTER(BNMetadata)
_BNCreateMetadataStringListData.argtypes = [
		ctypes.POINTER(ctypes.c_char_p),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNCreateMetadataStringListData(
		data: ctypes.POINTER(ctypes.c_char_p), 
		size: int
		) -> Optional[ctypes.POINTER(BNMetadata)]:
	result = _BNCreateMetadataStringListData(data, size)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateMetadataUnsignedIntegerData

_BNCreateMetadataUnsignedIntegerData = core.BNCreateMetadataUnsignedIntegerData
_BNCreateMetadataUnsignedIntegerData.restype = ctypes.POINTER(BNMetadata)
_BNCreateMetadataUnsignedIntegerData.argtypes = [
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNCreateMetadataUnsignedIntegerData(
		data: int
		) -> Optional[ctypes.POINTER(BNMetadata)]:
	result = _BNCreateMetadataUnsignedIntegerData(data)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateMetadataUnsignedIntegerListData

_BNCreateMetadataUnsignedIntegerListData = core.BNCreateMetadataUnsignedIntegerListData
_BNCreateMetadataUnsignedIntegerListData.restype = ctypes.POINTER(BNMetadata)
_BNCreateMetadataUnsignedIntegerListData.argtypes = [
		ctypes.POINTER(ctypes.c_ulonglong),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNCreateMetadataUnsignedIntegerListData(
		data: ctypes.POINTER(ctypes.c_ulonglong), 
		size: int
		) -> Optional[ctypes.POINTER(BNMetadata)]:
	result = _BNCreateMetadataUnsignedIntegerListData(data, size)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateMetadataValueStore

_BNCreateMetadataValueStore = core.BNCreateMetadataValueStore
_BNCreateMetadataValueStore.restype = ctypes.POINTER(BNMetadata)
_BNCreateMetadataValueStore.argtypes = [
		ctypes.POINTER(ctypes.c_char_p),
		ctypes.POINTER(ctypes.POINTER(BNMetadata)),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNCreateMetadataValueStore(
		keys: ctypes.POINTER(ctypes.c_char_p), 
		values: ctypes.POINTER(ctypes.POINTER(BNMetadata)), 
		size: int
		) -> Optional[ctypes.POINTER(BNMetadata)]:
	result = _BNCreateMetadataValueStore(keys, values, size)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateNamedType

_BNCreateNamedType = core.BNCreateNamedType
_BNCreateNamedType.restype = ctypes.POINTER(BNNamedTypeReference)
_BNCreateNamedType.argtypes = [
		NamedTypeReferenceClassEnum,
		ctypes.c_char_p,
		ctypes.POINTER(BNQualifiedName),
	]


# noinspection PyPep8Naming
def BNCreateNamedType(
		cls: NamedTypeReferenceClass, 
		id: Optional[str], 
		name: ctypes.POINTER(BNQualifiedName)
		) -> Optional[ctypes.POINTER(BNNamedTypeReference)]:
	result = _BNCreateNamedType(cls, cstr(id), name)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateNamedTypeBuilder

_BNCreateNamedTypeBuilder = core.BNCreateNamedTypeBuilder
_BNCreateNamedTypeBuilder.restype = ctypes.POINTER(BNNamedTypeReferenceBuilder)
_BNCreateNamedTypeBuilder.argtypes = [
		NamedTypeReferenceClassEnum,
		ctypes.c_char_p,
		ctypes.POINTER(BNQualifiedName),
	]


# noinspection PyPep8Naming
def BNCreateNamedTypeBuilder(
		cls: NamedTypeReferenceClass, 
		id: Optional[str], 
		name: ctypes.POINTER(BNQualifiedName)
		) -> Optional[ctypes.POINTER(BNNamedTypeReferenceBuilder)]:
	result = _BNCreateNamedTypeBuilder(cls, cstr(id), name)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateNamedTypeReference

_BNCreateNamedTypeReference = core.BNCreateNamedTypeReference
_BNCreateNamedTypeReference.restype = ctypes.POINTER(BNType)
_BNCreateNamedTypeReference.argtypes = [
		ctypes.POINTER(BNNamedTypeReference),
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
		ctypes.POINTER(BNBoolWithConfidence),
		ctypes.POINTER(BNBoolWithConfidence),
	]


# noinspection PyPep8Naming
def BNCreateNamedTypeReference(
		nt: ctypes.POINTER(BNNamedTypeReference), 
		width: int, 
		align: int, 
		cnst: ctypes.POINTER(BNBoolWithConfidence), 
		vltl: ctypes.POINTER(BNBoolWithConfidence)
		) -> Optional[ctypes.POINTER(BNType)]:
	result = _BNCreateNamedTypeReference(nt, width, align, cnst, vltl)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateNamedTypeReferenceBuilder

_BNCreateNamedTypeReferenceBuilder = core.BNCreateNamedTypeReferenceBuilder
_BNCreateNamedTypeReferenceBuilder.restype = ctypes.POINTER(BNTypeBuilder)
_BNCreateNamedTypeReferenceBuilder.argtypes = [
		ctypes.POINTER(BNNamedTypeReference),
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
		ctypes.POINTER(BNBoolWithConfidence),
		ctypes.POINTER(BNBoolWithConfidence),
	]


# noinspection PyPep8Naming
def BNCreateNamedTypeReferenceBuilder(
		nt: ctypes.POINTER(BNNamedTypeReference), 
		width: int, 
		align: int, 
		cnst: ctypes.POINTER(BNBoolWithConfidence), 
		vltl: ctypes.POINTER(BNBoolWithConfidence)
		) -> Optional[ctypes.POINTER(BNTypeBuilder)]:
	result = _BNCreateNamedTypeReferenceBuilder(nt, width, align, cnst, vltl)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateNamedTypeReferenceBuilderFromType

_BNCreateNamedTypeReferenceBuilderFromType = core.BNCreateNamedTypeReferenceBuilderFromType
_BNCreateNamedTypeReferenceBuilderFromType.restype = ctypes.POINTER(BNTypeBuilder)
_BNCreateNamedTypeReferenceBuilderFromType.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNQualifiedName),
	]


# noinspection PyPep8Naming
def BNCreateNamedTypeReferenceBuilderFromType(
		view: ctypes.POINTER(BNBinaryView), 
		name: ctypes.POINTER(BNQualifiedName)
		) -> Optional[ctypes.POINTER(BNTypeBuilder)]:
	result = _BNCreateNamedTypeReferenceBuilderFromType(view, name)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateNamedTypeReferenceBuilderFromTypeAndId

_BNCreateNamedTypeReferenceBuilderFromTypeAndId = core.BNCreateNamedTypeReferenceBuilderFromTypeAndId
_BNCreateNamedTypeReferenceBuilderFromTypeAndId.restype = ctypes.POINTER(BNTypeBuilder)
_BNCreateNamedTypeReferenceBuilderFromTypeAndId.argtypes = [
		ctypes.c_char_p,
		ctypes.POINTER(BNQualifiedName),
		ctypes.POINTER(BNType),
	]


# noinspection PyPep8Naming
def BNCreateNamedTypeReferenceBuilderFromTypeAndId(
		id: Optional[str], 
		name: ctypes.POINTER(BNQualifiedName), 
		type: ctypes.POINTER(BNType)
		) -> Optional[ctypes.POINTER(BNTypeBuilder)]:
	result = _BNCreateNamedTypeReferenceBuilderFromTypeAndId(cstr(id), name, type)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateNamedTypeReferenceBuilderWithBuilder

_BNCreateNamedTypeReferenceBuilderWithBuilder = core.BNCreateNamedTypeReferenceBuilderWithBuilder
_BNCreateNamedTypeReferenceBuilderWithBuilder.restype = ctypes.POINTER(BNTypeBuilder)
_BNCreateNamedTypeReferenceBuilderWithBuilder.argtypes = [
		ctypes.POINTER(BNNamedTypeReferenceBuilder),
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
		ctypes.POINTER(BNBoolWithConfidence),
		ctypes.POINTER(BNBoolWithConfidence),
	]


# noinspection PyPep8Naming
def BNCreateNamedTypeReferenceBuilderWithBuilder(
		nt: ctypes.POINTER(BNNamedTypeReferenceBuilder), 
		width: int, 
		align: int, 
		cnst: ctypes.POINTER(BNBoolWithConfidence), 
		vltl: ctypes.POINTER(BNBoolWithConfidence)
		) -> Optional[ctypes.POINTER(BNTypeBuilder)]:
	result = _BNCreateNamedTypeReferenceBuilderWithBuilder(nt, width, align, cnst, vltl)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateNamedTypeReferenceFromType

_BNCreateNamedTypeReferenceFromType = core.BNCreateNamedTypeReferenceFromType
_BNCreateNamedTypeReferenceFromType.restype = ctypes.POINTER(BNType)
_BNCreateNamedTypeReferenceFromType.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNQualifiedName),
	]


# noinspection PyPep8Naming
def BNCreateNamedTypeReferenceFromType(
		view: ctypes.POINTER(BNBinaryView), 
		name: ctypes.POINTER(BNQualifiedName)
		) -> Optional[ctypes.POINTER(BNType)]:
	result = _BNCreateNamedTypeReferenceFromType(view, name)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateNamedTypeReferenceFromTypeAndId

_BNCreateNamedTypeReferenceFromTypeAndId = core.BNCreateNamedTypeReferenceFromTypeAndId
_BNCreateNamedTypeReferenceFromTypeAndId.restype = ctypes.POINTER(BNType)
_BNCreateNamedTypeReferenceFromTypeAndId.argtypes = [
		ctypes.c_char_p,
		ctypes.POINTER(BNQualifiedName),
		ctypes.POINTER(BNType),
	]


# noinspection PyPep8Naming
def BNCreateNamedTypeReferenceFromTypeAndId(
		id: Optional[str], 
		name: ctypes.POINTER(BNQualifiedName), 
		type: ctypes.POINTER(BNType)
		) -> Optional[ctypes.POINTER(BNType)]:
	result = _BNCreateNamedTypeReferenceFromTypeAndId(cstr(id), name, type)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreatePlatform

_BNCreatePlatform = core.BNCreatePlatform
_BNCreatePlatform.restype = ctypes.POINTER(BNPlatform)
_BNCreatePlatform.argtypes = [
		ctypes.POINTER(BNArchitecture),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNCreatePlatform(
		arch: ctypes.POINTER(BNArchitecture), 
		name: Optional[str]
		) -> Optional[ctypes.POINTER(BNPlatform)]:
	result = _BNCreatePlatform(arch, cstr(name))
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreatePlatformWithTypes

_BNCreatePlatformWithTypes = core.BNCreatePlatformWithTypes
_BNCreatePlatformWithTypes.restype = ctypes.POINTER(BNPlatform)
_BNCreatePlatformWithTypes.argtypes = [
		ctypes.POINTER(BNArchitecture),
		ctypes.c_char_p,
		ctypes.c_char_p,
		ctypes.POINTER(ctypes.c_char_p),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNCreatePlatformWithTypes(
		arch: ctypes.POINTER(BNArchitecture), 
		name: Optional[str], 
		typeFile: Optional[str], 
		includeDirs: ctypes.POINTER(ctypes.c_char_p), 
		includeDirCount: int
		) -> Optional[ctypes.POINTER(BNPlatform)]:
	result = _BNCreatePlatformWithTypes(arch, cstr(name), cstr(typeFile), includeDirs, includeDirCount)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreatePointerType

_BNCreatePointerType = core.BNCreatePointerType
_BNCreatePointerType.restype = ctypes.POINTER(BNType)
_BNCreatePointerType.argtypes = [
		ctypes.POINTER(BNArchitecture),
		ctypes.POINTER(BNTypeWithConfidence),
		ctypes.POINTER(BNBoolWithConfidence),
		ctypes.POINTER(BNBoolWithConfidence),
		ReferenceTypeEnum,
	]


# noinspection PyPep8Naming
def BNCreatePointerType(
		arch: ctypes.POINTER(BNArchitecture), 
		type: ctypes.POINTER(BNTypeWithConfidence), 
		cnst: ctypes.POINTER(BNBoolWithConfidence), 
		vltl: ctypes.POINTER(BNBoolWithConfidence), 
		refType: ReferenceType
		) -> Optional[ctypes.POINTER(BNType)]:
	result = _BNCreatePointerType(arch, type, cnst, vltl, refType)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreatePointerTypeBuilder

_BNCreatePointerTypeBuilder = core.BNCreatePointerTypeBuilder
_BNCreatePointerTypeBuilder.restype = ctypes.POINTER(BNTypeBuilder)
_BNCreatePointerTypeBuilder.argtypes = [
		ctypes.POINTER(BNArchitecture),
		ctypes.POINTER(BNTypeWithConfidence),
		ctypes.POINTER(BNBoolWithConfidence),
		ctypes.POINTER(BNBoolWithConfidence),
		ReferenceTypeEnum,
	]


# noinspection PyPep8Naming
def BNCreatePointerTypeBuilder(
		arch: ctypes.POINTER(BNArchitecture), 
		type: ctypes.POINTER(BNTypeWithConfidence), 
		cnst: ctypes.POINTER(BNBoolWithConfidence), 
		vltl: ctypes.POINTER(BNBoolWithConfidence), 
		refType: ReferenceType
		) -> Optional[ctypes.POINTER(BNTypeBuilder)]:
	result = _BNCreatePointerTypeBuilder(arch, type, cnst, vltl, refType)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreatePointerTypeBuilderOfWidth

_BNCreatePointerTypeBuilderOfWidth = core.BNCreatePointerTypeBuilderOfWidth
_BNCreatePointerTypeBuilderOfWidth.restype = ctypes.POINTER(BNTypeBuilder)
_BNCreatePointerTypeBuilderOfWidth.argtypes = [
		ctypes.c_ulonglong,
		ctypes.POINTER(BNTypeWithConfidence),
		ctypes.POINTER(BNBoolWithConfidence),
		ctypes.POINTER(BNBoolWithConfidence),
		ReferenceTypeEnum,
	]


# noinspection PyPep8Naming
def BNCreatePointerTypeBuilderOfWidth(
		width: int, 
		type: ctypes.POINTER(BNTypeWithConfidence), 
		cnst: ctypes.POINTER(BNBoolWithConfidence), 
		vltl: ctypes.POINTER(BNBoolWithConfidence), 
		refType: ReferenceType
		) -> Optional[ctypes.POINTER(BNTypeBuilder)]:
	result = _BNCreatePointerTypeBuilderOfWidth(width, type, cnst, vltl, refType)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreatePointerTypeOfWidth

_BNCreatePointerTypeOfWidth = core.BNCreatePointerTypeOfWidth
_BNCreatePointerTypeOfWidth.restype = ctypes.POINTER(BNType)
_BNCreatePointerTypeOfWidth.argtypes = [
		ctypes.c_ulonglong,
		ctypes.POINTER(BNTypeWithConfidence),
		ctypes.POINTER(BNBoolWithConfidence),
		ctypes.POINTER(BNBoolWithConfidence),
		ReferenceTypeEnum,
	]


# noinspection PyPep8Naming
def BNCreatePointerTypeOfWidth(
		width: int, 
		type: ctypes.POINTER(BNTypeWithConfidence), 
		cnst: ctypes.POINTER(BNBoolWithConfidence), 
		vltl: ctypes.POINTER(BNBoolWithConfidence), 
		refType: ReferenceType
		) -> Optional[ctypes.POINTER(BNType)]:
	result = _BNCreatePointerTypeOfWidth(width, type, cnst, vltl, refType)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateProject

_BNCreateProject = core.BNCreateProject
_BNCreateProject.restype = ctypes.POINTER(BNProject)
_BNCreateProject.argtypes = [
		ctypes.c_char_p,
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNCreateProject(
		path: Optional[str], 
		name: Optional[str]
		) -> Optional[ctypes.POINTER(BNProject)]:
	result = _BNCreateProject(cstr(path), cstr(name))
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateRelocationHandler

_BNCreateRelocationHandler = core.BNCreateRelocationHandler
_BNCreateRelocationHandler.restype = ctypes.POINTER(BNRelocationHandler)
_BNCreateRelocationHandler.argtypes = [
		ctypes.POINTER(BNCustomRelocationHandler),
	]


# noinspection PyPep8Naming
def BNCreateRelocationHandler(
		handler: ctypes.POINTER(BNCustomRelocationHandler)
		) -> Optional[ctypes.POINTER(BNRelocationHandler)]:
	result = _BNCreateRelocationHandler(handler)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateReportCollection

_BNCreateReportCollection = core.BNCreateReportCollection
_BNCreateReportCollection.restype = ctypes.POINTER(BNReportCollection)
_BNCreateReportCollection.argtypes = [
	]


# noinspection PyPep8Naming
def BNCreateReportCollection(
		) -> Optional[ctypes.POINTER(BNReportCollection)]:
	result = _BNCreateReportCollection()
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateRepositoryManager

_BNCreateRepositoryManager = core.BNCreateRepositoryManager
_BNCreateRepositoryManager.restype = ctypes.POINTER(BNRepositoryManager)
_BNCreateRepositoryManager.argtypes = [
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNCreateRepositoryManager(
		enabledPluginsPath: Optional[str]
		) -> Optional[ctypes.POINTER(BNRepositoryManager)]:
	result = _BNCreateRepositoryManager(cstr(enabledPluginsPath))
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateSaveSettings

_BNCreateSaveSettings = core.BNCreateSaveSettings
_BNCreateSaveSettings.restype = ctypes.POINTER(BNSaveSettings)
_BNCreateSaveSettings.argtypes = [
	]


# noinspection PyPep8Naming
def BNCreateSaveSettings(
		) -> Optional[ctypes.POINTER(BNSaveSettings)]:
	result = _BNCreateSaveSettings()
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateScriptingProviderInstance

_BNCreateScriptingProviderInstance = core.BNCreateScriptingProviderInstance
_BNCreateScriptingProviderInstance.restype = ctypes.POINTER(BNScriptingInstance)
_BNCreateScriptingProviderInstance.argtypes = [
		ctypes.POINTER(BNScriptingProvider),
	]


# noinspection PyPep8Naming
def BNCreateScriptingProviderInstance(
		provider: ctypes.POINTER(BNScriptingProvider)
		) -> Optional[ctypes.POINTER(BNScriptingInstance)]:
	result = _BNCreateScriptingProviderInstance(provider)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateSegment

_BNCreateSegment = core.BNCreateSegment
_BNCreateSegment.restype = ctypes.POINTER(BNSegment)
_BNCreateSegment.argtypes = [
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
		ctypes.c_uint,
		ctypes.c_bool,
	]


# noinspection PyPep8Naming
def BNCreateSegment(
		start: int, 
		length: int, 
		dataOffset: int, 
		dataLength: int, 
		flags: int, 
		autoDefined: bool
		) -> Optional[ctypes.POINTER(BNSegment)]:
	result = _BNCreateSegment(start, length, dataOffset, dataLength, flags, autoDefined)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateSettings

_BNCreateSettings = core.BNCreateSettings
_BNCreateSettings.restype = ctypes.POINTER(BNSettings)
_BNCreateSettings.argtypes = [
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNCreateSettings(
		schemaId: Optional[str]
		) -> Optional[ctypes.POINTER(BNSettings)]:
	result = _BNCreateSettings(cstr(schemaId))
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateSnapshotedView

_BNCreateSnapshotedView = core.BNCreateSnapshotedView
_BNCreateSnapshotedView.restype = ctypes.c_bool
_BNCreateSnapshotedView.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNCreateSnapshotedView(
		data: ctypes.POINTER(BNBinaryView), 
		viewName: Optional[str]
		) -> bool:
	return _BNCreateSnapshotedView(data, cstr(viewName))


# -------------------------------------------------------
# _BNCreateSnapshotedViewWithProgress

_BNCreateSnapshotedViewWithProgress = core.BNCreateSnapshotedViewWithProgress
_BNCreateSnapshotedViewWithProgress.restype = ctypes.c_bool
_BNCreateSnapshotedViewWithProgress.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_char_p,
		ctypes.c_void_p,
		ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNCreateSnapshotedViewWithProgress(
		data: ctypes.POINTER(BNBinaryView), 
		viewName: Optional[str], 
		ctxt: Optional[ctypes.c_void_p], 
		progress: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong)
		) -> bool:
	return _BNCreateSnapshotedViewWithProgress(data, cstr(viewName), ctxt, progress)


# -------------------------------------------------------
# _BNCreateStructureBuilder

_BNCreateStructureBuilder = core.BNCreateStructureBuilder
_BNCreateStructureBuilder.restype = ctypes.POINTER(BNStructureBuilder)
_BNCreateStructureBuilder.argtypes = [
	]


# noinspection PyPep8Naming
def BNCreateStructureBuilder(
		) -> Optional[ctypes.POINTER(BNStructureBuilder)]:
	result = _BNCreateStructureBuilder()
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateStructureBuilderFromStructure

_BNCreateStructureBuilderFromStructure = core.BNCreateStructureBuilderFromStructure
_BNCreateStructureBuilderFromStructure.restype = ctypes.POINTER(BNStructureBuilder)
_BNCreateStructureBuilderFromStructure.argtypes = [
		ctypes.POINTER(BNStructure),
	]


# noinspection PyPep8Naming
def BNCreateStructureBuilderFromStructure(
		s: ctypes.POINTER(BNStructure)
		) -> Optional[ctypes.POINTER(BNStructureBuilder)]:
	result = _BNCreateStructureBuilderFromStructure(s)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateStructureBuilderWithOptions

_BNCreateStructureBuilderWithOptions = core.BNCreateStructureBuilderWithOptions
_BNCreateStructureBuilderWithOptions.restype = ctypes.POINTER(BNStructureBuilder)
_BNCreateStructureBuilderWithOptions.argtypes = [
		StructureVariantEnum,
		ctypes.c_bool,
	]


# noinspection PyPep8Naming
def BNCreateStructureBuilderWithOptions(
		type: StructureVariant, 
		packed: bool
		) -> Optional[ctypes.POINTER(BNStructureBuilder)]:
	result = _BNCreateStructureBuilderWithOptions(type, packed)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateStructureFromOffsetAccess

_BNCreateStructureFromOffsetAccess = core.BNCreateStructureFromOffsetAccess
_BNCreateStructureFromOffsetAccess.restype = ctypes.POINTER(BNStructure)
_BNCreateStructureFromOffsetAccess.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNQualifiedName),
		ctypes.POINTER(ctypes.c_bool),
	]


# noinspection PyPep8Naming
def BNCreateStructureFromOffsetAccess(
		view: ctypes.POINTER(BNBinaryView), 
		name: ctypes.POINTER(BNQualifiedName), 
		newMember: ctypes.POINTER(ctypes.c_bool)
		) -> Optional[ctypes.POINTER(BNStructure)]:
	result = _BNCreateStructureFromOffsetAccess(view, name, newMember)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateStructureMemberFromAccess

_BNCreateStructureMemberFromAccess = core.BNCreateStructureMemberFromAccess
_BNCreateStructureMemberFromAccess.restype = BNTypeWithConfidence
_BNCreateStructureMemberFromAccess.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNQualifiedName),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNCreateStructureMemberFromAccess(
		view: ctypes.POINTER(BNBinaryView), 
		name: ctypes.POINTER(BNQualifiedName), 
		offset: int
		) -> BNTypeWithConfidence:
	return _BNCreateStructureMemberFromAccess(view, name, offset)


# -------------------------------------------------------
# _BNCreateStructureType

_BNCreateStructureType = core.BNCreateStructureType
_BNCreateStructureType.restype = ctypes.POINTER(BNType)
_BNCreateStructureType.argtypes = [
		ctypes.POINTER(BNStructure),
	]


# noinspection PyPep8Naming
def BNCreateStructureType(
		s: ctypes.POINTER(BNStructure)
		) -> Optional[ctypes.POINTER(BNType)]:
	result = _BNCreateStructureType(s)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateStructureTypeBuilder

_BNCreateStructureTypeBuilder = core.BNCreateStructureTypeBuilder
_BNCreateStructureTypeBuilder.restype = ctypes.POINTER(BNTypeBuilder)
_BNCreateStructureTypeBuilder.argtypes = [
		ctypes.POINTER(BNStructure),
	]


# noinspection PyPep8Naming
def BNCreateStructureTypeBuilder(
		s: ctypes.POINTER(BNStructure)
		) -> Optional[ctypes.POINTER(BNTypeBuilder)]:
	result = _BNCreateStructureTypeBuilder(s)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateStructureTypeBuilderWithBuilder

_BNCreateStructureTypeBuilderWithBuilder = core.BNCreateStructureTypeBuilderWithBuilder
_BNCreateStructureTypeBuilderWithBuilder.restype = ctypes.POINTER(BNTypeBuilder)
_BNCreateStructureTypeBuilderWithBuilder.argtypes = [
		ctypes.POINTER(BNStructureBuilder),
	]


# noinspection PyPep8Naming
def BNCreateStructureTypeBuilderWithBuilder(
		s: ctypes.POINTER(BNStructureBuilder)
		) -> Optional[ctypes.POINTER(BNTypeBuilder)]:
	result = _BNCreateStructureTypeBuilderWithBuilder(s)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateSymbol

_BNCreateSymbol = core.BNCreateSymbol
_BNCreateSymbol.restype = ctypes.POINTER(BNSymbol)
_BNCreateSymbol.argtypes = [
		SymbolTypeEnum,
		ctypes.c_char_p,
		ctypes.c_char_p,
		ctypes.c_char_p,
		ctypes.c_ulonglong,
		SymbolBindingEnum,
		ctypes.POINTER(BNNameSpace),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNCreateSymbol(
		type: SymbolType, 
		shortName: Optional[str], 
		fullName: Optional[str], 
		rawName: Optional[str], 
		addr: int, 
		binding: SymbolBinding, 
		nameSpace: ctypes.POINTER(BNNameSpace), 
		ordinal: int
		) -> Optional[ctypes.POINTER(BNSymbol)]:
	result = _BNCreateSymbol(type, cstr(shortName), cstr(fullName), cstr(rawName), addr, binding, nameSpace, ordinal)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateSymbolQueue

_BNCreateSymbolQueue = core.BNCreateSymbolQueue
_BNCreateSymbolQueue.restype = ctypes.POINTER(BNSymbolQueue)
_BNCreateSymbolQueue.argtypes = [
	]


# noinspection PyPep8Naming
def BNCreateSymbolQueue(
		) -> Optional[ctypes.POINTER(BNSymbolQueue)]:
	result = _BNCreateSymbolQueue()
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateTag

_BNCreateTag = core.BNCreateTag
_BNCreateTag.restype = ctypes.POINTER(BNTag)
_BNCreateTag.argtypes = [
		ctypes.POINTER(BNTagType),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNCreateTag(
		type: ctypes.POINTER(BNTagType), 
		data: Optional[str]
		) -> Optional[ctypes.POINTER(BNTag)]:
	result = _BNCreateTag(type, cstr(data))
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateTagType

_BNCreateTagType = core.BNCreateTagType
_BNCreateTagType.restype = ctypes.POINTER(BNTagType)
_BNCreateTagType.argtypes = [
		ctypes.POINTER(BNBinaryView),
	]


# noinspection PyPep8Naming
def BNCreateTagType(
		view: ctypes.POINTER(BNBinaryView)
		) -> Optional[ctypes.POINTER(BNTagType)]:
	result = _BNCreateTagType(view)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateTemporaryFile

_BNCreateTemporaryFile = core.BNCreateTemporaryFile
_BNCreateTemporaryFile.restype = ctypes.POINTER(BNTemporaryFile)
_BNCreateTemporaryFile.argtypes = [
	]


# noinspection PyPep8Naming
def BNCreateTemporaryFile(
		) -> Optional[ctypes.POINTER(BNTemporaryFile)]:
	result = _BNCreateTemporaryFile()
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateTemporaryFileWithContents

_BNCreateTemporaryFileWithContents = core.BNCreateTemporaryFileWithContents
_BNCreateTemporaryFileWithContents.restype = ctypes.POINTER(BNTemporaryFile)
_BNCreateTemporaryFileWithContents.argtypes = [
		ctypes.POINTER(BNDataBuffer),
	]


# noinspection PyPep8Naming
def BNCreateTemporaryFileWithContents(
		data: ctypes.POINTER(BNDataBuffer)
		) -> Optional[ctypes.POINTER(BNTemporaryFile)]:
	result = _BNCreateTemporaryFileWithContents(data)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateTypeArchive

_BNCreateTypeArchive = core.BNCreateTypeArchive
_BNCreateTypeArchive.restype = ctypes.POINTER(BNTypeArchive)
_BNCreateTypeArchive.argtypes = [
		ctypes.c_char_p,
		ctypes.POINTER(BNPlatform),
	]


# noinspection PyPep8Naming
def BNCreateTypeArchive(
		path: Optional[str], 
		platform: ctypes.POINTER(BNPlatform)
		) -> Optional[ctypes.POINTER(BNTypeArchive)]:
	result = _BNCreateTypeArchive(cstr(path), platform)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateTypeArchiveWithId

_BNCreateTypeArchiveWithId = core.BNCreateTypeArchiveWithId
_BNCreateTypeArchiveWithId.restype = ctypes.POINTER(BNTypeArchive)
_BNCreateTypeArchiveWithId.argtypes = [
		ctypes.c_char_p,
		ctypes.POINTER(BNPlatform),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNCreateTypeArchiveWithId(
		path: Optional[str], 
		platform: ctypes.POINTER(BNPlatform), 
		id: Optional[str]
		) -> Optional[ctypes.POINTER(BNTypeArchive)]:
	result = _BNCreateTypeArchiveWithId(cstr(path), platform, cstr(id))
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateTypeBuilderFromType

_BNCreateTypeBuilderFromType = core.BNCreateTypeBuilderFromType
_BNCreateTypeBuilderFromType.restype = ctypes.POINTER(BNTypeBuilder)
_BNCreateTypeBuilderFromType.argtypes = [
		ctypes.POINTER(BNType),
	]


# noinspection PyPep8Naming
def BNCreateTypeBuilderFromType(
		type: ctypes.POINTER(BNType)
		) -> Optional[ctypes.POINTER(BNTypeBuilder)]:
	result = _BNCreateTypeBuilderFromType(type)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateUserFunction

_BNCreateUserFunction = core.BNCreateUserFunction
_BNCreateUserFunction.restype = ctypes.POINTER(BNFunction)
_BNCreateUserFunction.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNPlatform),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNCreateUserFunction(
		view: ctypes.POINTER(BNBinaryView), 
		platform: ctypes.POINTER(BNPlatform), 
		addr: int
		) -> Optional[ctypes.POINTER(BNFunction)]:
	result = _BNCreateUserFunction(view, platform, addr)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateUserStackVariable

_BNCreateUserStackVariable = core.BNCreateUserStackVariable
_BNCreateUserStackVariable.restype = None
_BNCreateUserStackVariable.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.c_longlong,
		ctypes.POINTER(BNTypeWithConfidence),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNCreateUserStackVariable(
		func: ctypes.POINTER(BNFunction), 
		offset: int, 
		type: ctypes.POINTER(BNTypeWithConfidence), 
		name: Optional[str]
		) -> None:
	return _BNCreateUserStackVariable(func, offset, type, cstr(name))


# -------------------------------------------------------
# _BNCreateUserVariable

_BNCreateUserVariable = core.BNCreateUserVariable
_BNCreateUserVariable.restype = None
_BNCreateUserVariable.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNVariable),
		ctypes.POINTER(BNTypeWithConfidence),
		ctypes.c_char_p,
		ctypes.c_bool,
	]


# noinspection PyPep8Naming
def BNCreateUserVariable(
		func: ctypes.POINTER(BNFunction), 
		var: ctypes.POINTER(BNVariable), 
		type: ctypes.POINTER(BNTypeWithConfidence), 
		name: Optional[str], 
		ignoreDisjointUses: bool
		) -> None:
	return _BNCreateUserVariable(func, var, type, cstr(name), ignoreDisjointUses)


# -------------------------------------------------------
# _BNCreateVoidType

_BNCreateVoidType = core.BNCreateVoidType
_BNCreateVoidType.restype = ctypes.POINTER(BNType)
_BNCreateVoidType.argtypes = [
	]


# noinspection PyPep8Naming
def BNCreateVoidType(
		) -> Optional[ctypes.POINTER(BNType)]:
	result = _BNCreateVoidType()
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateVoidTypeBuilder

_BNCreateVoidTypeBuilder = core.BNCreateVoidTypeBuilder
_BNCreateVoidTypeBuilder.restype = ctypes.POINTER(BNTypeBuilder)
_BNCreateVoidTypeBuilder.argtypes = [
	]


# noinspection PyPep8Naming
def BNCreateVoidTypeBuilder(
		) -> Optional[ctypes.POINTER(BNTypeBuilder)]:
	result = _BNCreateVoidTypeBuilder()
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateWebsocketProviderClient

_BNCreateWebsocketProviderClient = core.BNCreateWebsocketProviderClient
_BNCreateWebsocketProviderClient.restype = ctypes.POINTER(BNWebsocketClient)
_BNCreateWebsocketProviderClient.argtypes = [
		ctypes.POINTER(BNWebsocketProvider),
	]


# noinspection PyPep8Naming
def BNCreateWebsocketProviderClient(
		provider: ctypes.POINTER(BNWebsocketProvider)
		) -> Optional[ctypes.POINTER(BNWebsocketClient)]:
	result = _BNCreateWebsocketProviderClient(provider)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateWideCharType

_BNCreateWideCharType = core.BNCreateWideCharType
_BNCreateWideCharType.restype = ctypes.POINTER(BNType)
_BNCreateWideCharType.argtypes = [
		ctypes.c_ulonglong,
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNCreateWideCharType(
		width: int, 
		altName: Optional[str]
		) -> Optional[ctypes.POINTER(BNType)]:
	result = _BNCreateWideCharType(width, cstr(altName))
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateWideCharTypeBuilder

_BNCreateWideCharTypeBuilder = core.BNCreateWideCharTypeBuilder
_BNCreateWideCharTypeBuilder.restype = ctypes.POINTER(BNTypeBuilder)
_BNCreateWideCharTypeBuilder.argtypes = [
		ctypes.c_ulonglong,
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNCreateWideCharTypeBuilder(
		width: int, 
		altName: Optional[str]
		) -> Optional[ctypes.POINTER(BNTypeBuilder)]:
	result = _BNCreateWideCharTypeBuilder(width, cstr(altName))
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateWorkflow

_BNCreateWorkflow = core.BNCreateWorkflow
_BNCreateWorkflow.restype = ctypes.POINTER(BNWorkflow)
_BNCreateWorkflow.argtypes = [
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNCreateWorkflow(
		name: Optional[str]
		) -> Optional[ctypes.POINTER(BNWorkflow)]:
	result = _BNCreateWorkflow(cstr(name))
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNDataBufferToBase64

_BNDataBufferToBase64 = core.BNDataBufferToBase64
_BNDataBufferToBase64.restype = ctypes.POINTER(ctypes.c_byte)
_BNDataBufferToBase64.argtypes = [
		ctypes.POINTER(BNDataBuffer),
	]


# noinspection PyPep8Naming
def BNDataBufferToBase64(
		buf: ctypes.POINTER(BNDataBuffer)
		) -> Optional[Optional[str]]:
	result = _BNDataBufferToBase64(buf)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNDataBufferToEscapedString

_BNDataBufferToEscapedString = core.BNDataBufferToEscapedString
_BNDataBufferToEscapedString.restype = ctypes.POINTER(ctypes.c_byte)
_BNDataBufferToEscapedString.argtypes = [
		ctypes.POINTER(BNDataBuffer),
		ctypes.c_bool,
	]


# noinspection PyPep8Naming
def BNDataBufferToEscapedString(
		buf: ctypes.POINTER(BNDataBuffer), 
		nullTerminates: bool
		) -> Optional[Optional[str]]:
	result = _BNDataBufferToEscapedString(buf, nullTerminates)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNDatabaseHasGlobal

_BNDatabaseHasGlobal = core.BNDatabaseHasGlobal
_BNDatabaseHasGlobal.restype = ctypes.c_int
_BNDatabaseHasGlobal.argtypes = [
		ctypes.POINTER(BNDatabase),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNDatabaseHasGlobal(
		database: ctypes.POINTER(BNDatabase), 
		key: Optional[str]
		) -> int:
	return _BNDatabaseHasGlobal(database, cstr(key))


# -------------------------------------------------------
# _BNDatabaseReloadConnection

_BNDatabaseReloadConnection = core.BNDatabaseReloadConnection
_BNDatabaseReloadConnection.restype = None
_BNDatabaseReloadConnection.argtypes = [
		ctypes.POINTER(BNDatabase),
	]


# noinspection PyPep8Naming
def BNDatabaseReloadConnection(
		database: ctypes.POINTER(BNDatabase)
		) -> None:
	return _BNDatabaseReloadConnection(database)


# -------------------------------------------------------
# _BNDeauthenticateEnterpriseServer

_BNDeauthenticateEnterpriseServer = core.BNDeauthenticateEnterpriseServer
_BNDeauthenticateEnterpriseServer.restype = ctypes.c_bool
_BNDeauthenticateEnterpriseServer.argtypes = [
	]


# noinspection PyPep8Naming
def BNDeauthenticateEnterpriseServer(
		) -> bool:
	return _BNDeauthenticateEnterpriseServer()


# -------------------------------------------------------
# _BNDecode

_BNDecode = core.BNDecode
_BNDecode.restype = ctypes.c_bool
_BNDecode.argtypes = [
		ctypes.POINTER(BNTransform),
		ctypes.POINTER(BNDataBuffer),
		ctypes.POINTER(BNDataBuffer),
		ctypes.POINTER(BNTransformParameter),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNDecode(
		xform: ctypes.POINTER(BNTransform), 
		input: ctypes.POINTER(BNDataBuffer), 
		output: ctypes.POINTER(BNDataBuffer), 
		params: ctypes.POINTER(BNTransformParameter), 
		paramCount: int
		) -> bool:
	return _BNDecode(xform, input, output, params, paramCount)


# -------------------------------------------------------
# _BNDecodeBase64

_BNDecodeBase64 = core.BNDecodeBase64
_BNDecodeBase64.restype = ctypes.POINTER(BNDataBuffer)
_BNDecodeBase64.argtypes = [
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNDecodeBase64(
		str: Optional[str]
		) -> Optional[ctypes.POINTER(BNDataBuffer)]:
	result = _BNDecodeBase64(cstr(str))
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNDecodeEscapedString

_BNDecodeEscapedString = core.BNDecodeEscapedString
_BNDecodeEscapedString.restype = ctypes.POINTER(BNDataBuffer)
_BNDecodeEscapedString.argtypes = [
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNDecodeEscapedString(
		str: Optional[str]
		) -> Optional[ctypes.POINTER(BNDataBuffer)]:
	result = _BNDecodeEscapedString(cstr(str))
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNDefineAnalysisType

_BNDefineAnalysisType = core.BNDefineAnalysisType
_BNDefineAnalysisType.restype = BNQualifiedName
_BNDefineAnalysisType.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_char_p,
		ctypes.POINTER(BNQualifiedName),
		ctypes.POINTER(BNType),
	]


# noinspection PyPep8Naming
def BNDefineAnalysisType(
		view: ctypes.POINTER(BNBinaryView), 
		id: Optional[str], 
		defaultName: ctypes.POINTER(BNQualifiedName), 
		type: ctypes.POINTER(BNType)
		) -> BNQualifiedName:
	return _BNDefineAnalysisType(view, cstr(id), defaultName, type)


# -------------------------------------------------------
# _BNDefineAnalysisTypes

_BNDefineAnalysisTypes = core.BNDefineAnalysisTypes
_BNDefineAnalysisTypes.restype = ctypes.c_ulonglong
_BNDefineAnalysisTypes.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNQualifiedNameTypeAndId),
		ctypes.c_ulonglong,
		ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong),
		ctypes.c_void_p,
		ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)),
		ctypes.POINTER(ctypes.POINTER(BNQualifiedName)),
	]


# noinspection PyPep8Naming
def BNDefineAnalysisTypes(
		view: ctypes.POINTER(BNBinaryView), 
		types: ctypes.POINTER(BNQualifiedNameTypeAndId), 
		count: int, 
		progress: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong), 
		progressContext: Optional[ctypes.c_void_p], 
		resultIds: ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)), 
		resultNames: ctypes.POINTER(ctypes.POINTER(BNQualifiedName))
		) -> int:
	return _BNDefineAnalysisTypes(view, types, count, progress, progressContext, resultIds, resultNames)


# -------------------------------------------------------
# _BNDefineAutoSymbol

_BNDefineAutoSymbol = core.BNDefineAutoSymbol
_BNDefineAutoSymbol.restype = None
_BNDefineAutoSymbol.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNSymbol),
	]


# noinspection PyPep8Naming
def BNDefineAutoSymbol(
		view: ctypes.POINTER(BNBinaryView), 
		sym: ctypes.POINTER(BNSymbol)
		) -> None:
	return _BNDefineAutoSymbol(view, sym)


# -------------------------------------------------------
# _BNDefineAutoSymbolAndVariableOrFunction

_BNDefineAutoSymbolAndVariableOrFunction = core.BNDefineAutoSymbolAndVariableOrFunction
_BNDefineAutoSymbolAndVariableOrFunction.restype = ctypes.POINTER(BNSymbol)
_BNDefineAutoSymbolAndVariableOrFunction.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNPlatform),
		ctypes.POINTER(BNSymbol),
		ctypes.POINTER(BNType),
	]


# noinspection PyPep8Naming
def BNDefineAutoSymbolAndVariableOrFunction(
		view: ctypes.POINTER(BNBinaryView), 
		platform: ctypes.POINTER(BNPlatform), 
		sym: ctypes.POINTER(BNSymbol), 
		type: ctypes.POINTER(BNType)
		) -> Optional[ctypes.POINTER(BNSymbol)]:
	result = _BNDefineAutoSymbolAndVariableOrFunction(view, platform, sym, type)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNDefineDataVariable

_BNDefineDataVariable = core.BNDefineDataVariable
_BNDefineDataVariable.restype = None
_BNDefineDataVariable.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
		ctypes.POINTER(BNTypeWithConfidence),
	]


# noinspection PyPep8Naming
def BNDefineDataVariable(
		view: ctypes.POINTER(BNBinaryView), 
		addr: int, 
		type: ctypes.POINTER(BNTypeWithConfidence)
		) -> None:
	return _BNDefineDataVariable(view, addr, type)


# -------------------------------------------------------
# _BNDefineImportedFunction

_BNDefineImportedFunction = core.BNDefineImportedFunction
_BNDefineImportedFunction.restype = None
_BNDefineImportedFunction.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNSymbol),
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNType),
	]


# noinspection PyPep8Naming
def BNDefineImportedFunction(
		view: ctypes.POINTER(BNBinaryView), 
		importAddressSym: ctypes.POINTER(BNSymbol), 
		func: ctypes.POINTER(BNFunction), 
		type: ctypes.POINTER(BNType)
		) -> None:
	return _BNDefineImportedFunction(view, importAddressSym, func, type)


# -------------------------------------------------------
# _BNDefineRelocation

_BNDefineRelocation = core.BNDefineRelocation
_BNDefineRelocation.restype = None
_BNDefineRelocation.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNArchitecture),
		ctypes.POINTER(BNRelocationInfo),
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNDefineRelocation(
		view: ctypes.POINTER(BNBinaryView), 
		arch: ctypes.POINTER(BNArchitecture), 
		info: ctypes.POINTER(BNRelocationInfo), 
		target: int, 
		reloc: int
		) -> None:
	return _BNDefineRelocation(view, arch, info, target, reloc)


# -------------------------------------------------------
# _BNDefineSymbolRelocation

_BNDefineSymbolRelocation = core.BNDefineSymbolRelocation
_BNDefineSymbolRelocation.restype = None
_BNDefineSymbolRelocation.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNArchitecture),
		ctypes.POINTER(BNRelocationInfo),
		ctypes.POINTER(BNSymbol),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNDefineSymbolRelocation(
		view: ctypes.POINTER(BNBinaryView), 
		arch: ctypes.POINTER(BNArchitecture), 
		info: ctypes.POINTER(BNRelocationInfo), 
		target: ctypes.POINTER(BNSymbol), 
		reloc: int
		) -> None:
	return _BNDefineSymbolRelocation(view, arch, info, target, reloc)


# -------------------------------------------------------
# _BNDefineUserAnalysisType

_BNDefineUserAnalysisType = core.BNDefineUserAnalysisType
_BNDefineUserAnalysisType.restype = None
_BNDefineUserAnalysisType.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNQualifiedName),
		ctypes.POINTER(BNType),
	]


# noinspection PyPep8Naming
def BNDefineUserAnalysisType(
		view: ctypes.POINTER(BNBinaryView), 
		name: ctypes.POINTER(BNQualifiedName), 
		type: ctypes.POINTER(BNType)
		) -> None:
	return _BNDefineUserAnalysisType(view, name, type)


# -------------------------------------------------------
# _BNDefineUserAnalysisTypes

_BNDefineUserAnalysisTypes = core.BNDefineUserAnalysisTypes
_BNDefineUserAnalysisTypes.restype = None
_BNDefineUserAnalysisTypes.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNQualifiedNameAndType),
		ctypes.c_ulonglong,
		ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong),
		ctypes.c_void_p,
	]


# noinspection PyPep8Naming
def BNDefineUserAnalysisTypes(
		view: ctypes.POINTER(BNBinaryView), 
		types: ctypes.POINTER(BNQualifiedNameAndType), 
		count: int, 
		progress: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong), 
		progressContext: Optional[ctypes.c_void_p]
		) -> None:
	return _BNDefineUserAnalysisTypes(view, types, count, progress, progressContext)


# -------------------------------------------------------
# _BNDefineUserDataVariable

_BNDefineUserDataVariable = core.BNDefineUserDataVariable
_BNDefineUserDataVariable.restype = None
_BNDefineUserDataVariable.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
		ctypes.POINTER(BNTypeWithConfidence),
	]


# noinspection PyPep8Naming
def BNDefineUserDataVariable(
		view: ctypes.POINTER(BNBinaryView), 
		addr: int, 
		type: ctypes.POINTER(BNTypeWithConfidence)
		) -> None:
	return _BNDefineUserDataVariable(view, addr, type)


# -------------------------------------------------------
# _BNDefineUserSymbol

_BNDefineUserSymbol = core.BNDefineUserSymbol
_BNDefineUserSymbol.restype = None
_BNDefineUserSymbol.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNSymbol),
	]


# noinspection PyPep8Naming
def BNDefineUserSymbol(
		view: ctypes.POINTER(BNBinaryView), 
		sym: ctypes.POINTER(BNSymbol)
		) -> None:
	return _BNDefineUserSymbol(view, sym)


# -------------------------------------------------------
# _BNDeleteAutoStackVariable

_BNDeleteAutoStackVariable = core.BNDeleteAutoStackVariable
_BNDeleteAutoStackVariable.restype = None
_BNDeleteAutoStackVariable.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.c_longlong,
	]


# noinspection PyPep8Naming
def BNDeleteAutoStackVariable(
		func: ctypes.POINTER(BNFunction), 
		offset: int
		) -> None:
	return _BNDeleteAutoStackVariable(func, offset)


# -------------------------------------------------------
# _BNDeleteDirectory

_BNDeleteDirectory = core.BNDeleteDirectory
_BNDeleteDirectory.restype = ctypes.c_bool
_BNDeleteDirectory.argtypes = [
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNDeleteDirectory(
		path: Optional[str]
		) -> bool:
	return _BNDeleteDirectory(cstr(path))


# -------------------------------------------------------
# _BNDeleteFile

_BNDeleteFile = core.BNDeleteFile
_BNDeleteFile.restype = ctypes.c_bool
_BNDeleteFile.argtypes = [
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNDeleteFile(
		path: Optional[str]
		) -> bool:
	return _BNDeleteFile(cstr(path))


# -------------------------------------------------------
# _BNDeleteSecretsProviderData

_BNDeleteSecretsProviderData = core.BNDeleteSecretsProviderData
_BNDeleteSecretsProviderData.restype = ctypes.c_bool
_BNDeleteSecretsProviderData.argtypes = [
		ctypes.POINTER(BNSecretsProvider),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNDeleteSecretsProviderData(
		provider: ctypes.POINTER(BNSecretsProvider), 
		key: Optional[str]
		) -> bool:
	return _BNDeleteSecretsProviderData(provider, cstr(key))


# -------------------------------------------------------
# _BNDeleteTypeArchiveType

_BNDeleteTypeArchiveType = core.BNDeleteTypeArchiveType
_BNDeleteTypeArchiveType.restype = ctypes.c_bool
_BNDeleteTypeArchiveType.argtypes = [
		ctypes.POINTER(BNTypeArchive),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNDeleteTypeArchiveType(
		archive: ctypes.POINTER(BNTypeArchive), 
		id: Optional[str]
		) -> bool:
	return _BNDeleteTypeArchiveType(archive, cstr(id))


# -------------------------------------------------------
# _BNDeleteUserStackVariable

_BNDeleteUserStackVariable = core.BNDeleteUserStackVariable
_BNDeleteUserStackVariable.restype = None
_BNDeleteUserStackVariable.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.c_longlong,
	]


# noinspection PyPep8Naming
def BNDeleteUserStackVariable(
		func: ctypes.POINTER(BNFunction), 
		offset: int
		) -> None:
	return _BNDeleteUserStackVariable(func, offset)


# -------------------------------------------------------
# _BNDeleteUserVariable

_BNDeleteUserVariable = core.BNDeleteUserVariable
_BNDeleteUserVariable.restype = None
_BNDeleteUserVariable.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNVariable),
	]


# noinspection PyPep8Naming
def BNDeleteUserVariable(
		func: ctypes.POINTER(BNFunction), 
		var: ctypes.POINTER(BNVariable)
		) -> None:
	return _BNDeleteUserVariable(func, var)


# -------------------------------------------------------
# _BNDemangleGNU3

_BNDemangleGNU3 = core.BNDemangleGNU3
_BNDemangleGNU3.restype = ctypes.c_bool
_BNDemangleGNU3.argtypes = [
		ctypes.POINTER(BNArchitecture),
		ctypes.c_char_p,
		ctypes.POINTER(ctypes.POINTER(BNType)),
		ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)),
		ctypes.POINTER(ctypes.c_ulonglong),
		ctypes.c_bool,
	]


# noinspection PyPep8Naming
def BNDemangleGNU3(
		arch: ctypes.POINTER(BNArchitecture), 
		mangledName: Optional[str], 
		outType: ctypes.POINTER(ctypes.POINTER(BNType)), 
		outVarName: ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)), 
		outVarNameElements: ctypes.POINTER(ctypes.c_ulonglong), 
		simplify: bool
		) -> bool:
	return _BNDemangleGNU3(arch, cstr(mangledName), outType, outVarName, outVarNameElements, simplify)


# -------------------------------------------------------
# _BNDemangleGNU3WithOptions

_BNDemangleGNU3WithOptions = core.BNDemangleGNU3WithOptions
_BNDemangleGNU3WithOptions.restype = ctypes.c_bool
_BNDemangleGNU3WithOptions.argtypes = [
		ctypes.POINTER(BNArchitecture),
		ctypes.c_char_p,
		ctypes.POINTER(ctypes.POINTER(BNType)),
		ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)),
		ctypes.POINTER(ctypes.c_ulonglong),
		ctypes.POINTER(BNBinaryView),
	]


# noinspection PyPep8Naming
def BNDemangleGNU3WithOptions(
		arch: ctypes.POINTER(BNArchitecture), 
		mangledName: Optional[str], 
		outType: ctypes.POINTER(ctypes.POINTER(BNType)), 
		outVarName: ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)), 
		outVarNameElements: ctypes.POINTER(ctypes.c_ulonglong), 
		view: ctypes.POINTER(BNBinaryView)
		) -> bool:
	return _BNDemangleGNU3WithOptions(arch, cstr(mangledName), outType, outVarName, outVarNameElements, view)


# -------------------------------------------------------
# _BNDemangleMS

_BNDemangleMS = core.BNDemangleMS
_BNDemangleMS.restype = ctypes.c_bool
_BNDemangleMS.argtypes = [
		ctypes.POINTER(BNArchitecture),
		ctypes.c_char_p,
		ctypes.POINTER(ctypes.POINTER(BNType)),
		ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)),
		ctypes.POINTER(ctypes.c_ulonglong),
		ctypes.c_bool,
	]


# noinspection PyPep8Naming
def BNDemangleMS(
		arch: ctypes.POINTER(BNArchitecture), 
		mangledName: Optional[str], 
		outType: ctypes.POINTER(ctypes.POINTER(BNType)), 
		outVarName: ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)), 
		outVarNameElements: ctypes.POINTER(ctypes.c_ulonglong), 
		simplify: bool
		) -> bool:
	return _BNDemangleMS(arch, cstr(mangledName), outType, outVarName, outVarNameElements, simplify)


# -------------------------------------------------------
# _BNDemangleMSPlatform

_BNDemangleMSPlatform = core.BNDemangleMSPlatform
_BNDemangleMSPlatform.restype = ctypes.c_bool
_BNDemangleMSPlatform.argtypes = [
		ctypes.POINTER(BNPlatform),
		ctypes.c_char_p,
		ctypes.POINTER(ctypes.POINTER(BNType)),
		ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)),
		ctypes.POINTER(ctypes.c_ulonglong),
		ctypes.c_bool,
	]


# noinspection PyPep8Naming
def BNDemangleMSPlatform(
		platform: ctypes.POINTER(BNPlatform), 
		mangledName: Optional[str], 
		outType: ctypes.POINTER(ctypes.POINTER(BNType)), 
		outVarName: ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)), 
		outVarNameElements: ctypes.POINTER(ctypes.c_ulonglong), 
		simplify: bool
		) -> bool:
	return _BNDemangleMSPlatform(platform, cstr(mangledName), outType, outVarName, outVarNameElements, simplify)


# -------------------------------------------------------
# _BNDemangleMSWithOptions

_BNDemangleMSWithOptions = core.BNDemangleMSWithOptions
_BNDemangleMSWithOptions.restype = ctypes.c_bool
_BNDemangleMSWithOptions.argtypes = [
		ctypes.POINTER(BNArchitecture),
		ctypes.c_char_p,
		ctypes.POINTER(ctypes.POINTER(BNType)),
		ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)),
		ctypes.POINTER(ctypes.c_ulonglong),
		ctypes.POINTER(BNBinaryView),
	]


# noinspection PyPep8Naming
def BNDemangleMSWithOptions(
		arch: ctypes.POINTER(BNArchitecture), 
		mangledName: Optional[str], 
		outType: ctypes.POINTER(ctypes.POINTER(BNType)), 
		outVarName: ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)), 
		outVarNameElements: ctypes.POINTER(ctypes.c_ulonglong), 
		view: ctypes.POINTER(BNBinaryView)
		) -> bool:
	return _BNDemangleMSWithOptions(arch, cstr(mangledName), outType, outVarName, outVarNameElements, view)


# -------------------------------------------------------
# _BNDeserializeSettings

_BNDeserializeSettings = core.BNDeserializeSettings
_BNDeserializeSettings.restype = ctypes.c_bool
_BNDeserializeSettings.argtypes = [
		ctypes.POINTER(BNSettings),
		ctypes.c_char_p,
		ctypes.POINTER(BNBinaryView),
		SettingsScopeEnum,
	]


# noinspection PyPep8Naming
def BNDeserializeSettings(
		settings: ctypes.POINTER(BNSettings), 
		contents: Optional[str], 
		view: ctypes.POINTER(BNBinaryView), 
		scope: SettingsScope
		) -> bool:
	return _BNDeserializeSettings(settings, cstr(contents), view, scope)


# -------------------------------------------------------
# _BNDestroySymbolQueue

_BNDestroySymbolQueue = core.BNDestroySymbolQueue
_BNDestroySymbolQueue.restype = None
_BNDestroySymbolQueue.argtypes = [
		ctypes.POINTER(BNSymbolQueue),
	]


# noinspection PyPep8Naming
def BNDestroySymbolQueue(
		queue: ctypes.POINTER(BNSymbolQueue)
		) -> None:
	return _BNDestroySymbolQueue(queue)


# -------------------------------------------------------
# _BNDisablePlugins

_BNDisablePlugins = core.BNDisablePlugins
_BNDisablePlugins.restype = None
_BNDisablePlugins.argtypes = [
	]


# noinspection PyPep8Naming
def BNDisablePlugins(
		) -> None:
	return _BNDisablePlugins()


# -------------------------------------------------------
# _BNDisassemblyTextRendererHasDataFlow

_BNDisassemblyTextRendererHasDataFlow = core.BNDisassemblyTextRendererHasDataFlow
_BNDisassemblyTextRendererHasDataFlow.restype = ctypes.c_bool
_BNDisassemblyTextRendererHasDataFlow.argtypes = [
		ctypes.POINTER(BNDisassemblyTextRenderer),
	]


# noinspection PyPep8Naming
def BNDisassemblyTextRendererHasDataFlow(
		renderer: ctypes.POINTER(BNDisassemblyTextRenderer)
		) -> bool:
	return _BNDisassemblyTextRendererHasDataFlow(renderer)


# -------------------------------------------------------
# _BNDisassemblyTextRendererWrapComment

_BNDisassemblyTextRendererWrapComment = core.BNDisassemblyTextRendererWrapComment
_BNDisassemblyTextRendererWrapComment.restype = ctypes.POINTER(BNDisassemblyTextLine)
_BNDisassemblyTextRendererWrapComment.argtypes = [
		ctypes.POINTER(BNDisassemblyTextRenderer),
		ctypes.POINTER(BNDisassemblyTextLine),
		ctypes.POINTER(ctypes.c_ulonglong),
		ctypes.c_char_p,
		ctypes.c_bool,
		ctypes.c_char_p,
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNDisassemblyTextRendererWrapComment(
		renderer: ctypes.POINTER(BNDisassemblyTextRenderer), 
		inLine: ctypes.POINTER(BNDisassemblyTextLine), 
		outLineCount: ctypes.POINTER(ctypes.c_ulonglong), 
		comment: Optional[str], 
		hasAutoAnnotations: bool, 
		leadingSpaces: Optional[str], 
		indentSpaces: Optional[str]
		) -> Optional[ctypes.POINTER(BNDisassemblyTextLine)]:
	result = _BNDisassemblyTextRendererWrapComment(renderer, inLine, outLineCount, cstr(comment), hasAutoAnnotations, cstr(leadingSpaces), cstr(indentSpaces))
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNDisconnectWebsocketClient

_BNDisconnectWebsocketClient = core.BNDisconnectWebsocketClient
_BNDisconnectWebsocketClient.restype = ctypes.c_bool
_BNDisconnectWebsocketClient.argtypes = [
		ctypes.POINTER(BNWebsocketClient),
	]


# noinspection PyPep8Naming
def BNDisconnectWebsocketClient(
		client: ctypes.POINTER(BNWebsocketClient)
		) -> bool:
	return _BNDisconnectWebsocketClient(client)


# -------------------------------------------------------
# _BNDuplicateDataBuffer

_BNDuplicateDataBuffer = core.BNDuplicateDataBuffer
_BNDuplicateDataBuffer.restype = ctypes.POINTER(BNDataBuffer)
_BNDuplicateDataBuffer.argtypes = [
		ctypes.POINTER(BNDataBuffer),
	]


# noinspection PyPep8Naming
def BNDuplicateDataBuffer(
		buf: ctypes.POINTER(BNDataBuffer)
		) -> Optional[ctypes.POINTER(BNDataBuffer)]:
	result = _BNDuplicateDataBuffer(buf)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNDuplicateDisassemblySettings

_BNDuplicateDisassemblySettings = core.BNDuplicateDisassemblySettings
_BNDuplicateDisassemblySettings.restype = ctypes.POINTER(BNDisassemblySettings)
_BNDuplicateDisassemblySettings.argtypes = [
		ctypes.POINTER(BNDisassemblySettings),
	]


# noinspection PyPep8Naming
def BNDuplicateDisassemblySettings(
		settings: ctypes.POINTER(BNDisassemblySettings)
		) -> Optional[ctypes.POINTER(BNDisassemblySettings)]:
	result = _BNDuplicateDisassemblySettings(settings)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNDuplicateEnumerationBuilder

_BNDuplicateEnumerationBuilder = core.BNDuplicateEnumerationBuilder
_BNDuplicateEnumerationBuilder.restype = ctypes.POINTER(BNEnumerationBuilder)
_BNDuplicateEnumerationBuilder.argtypes = [
		ctypes.POINTER(BNEnumerationBuilder),
	]


# noinspection PyPep8Naming
def BNDuplicateEnumerationBuilder(
		e: ctypes.POINTER(BNEnumerationBuilder)
		) -> Optional[ctypes.POINTER(BNEnumerationBuilder)]:
	result = _BNDuplicateEnumerationBuilder(e)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNDuplicateLinearViewCursor

_BNDuplicateLinearViewCursor = core.BNDuplicateLinearViewCursor
_BNDuplicateLinearViewCursor.restype = ctypes.POINTER(BNLinearViewCursor)
_BNDuplicateLinearViewCursor.argtypes = [
		ctypes.POINTER(BNLinearViewCursor),
	]


# noinspection PyPep8Naming
def BNDuplicateLinearViewCursor(
		cursor: ctypes.POINTER(BNLinearViewCursor)
		) -> Optional[ctypes.POINTER(BNLinearViewCursor)]:
	result = _BNDuplicateLinearViewCursor(cursor)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNDuplicateStructureBuilder

_BNDuplicateStructureBuilder = core.BNDuplicateStructureBuilder
_BNDuplicateStructureBuilder.restype = ctypes.POINTER(BNStructureBuilder)
_BNDuplicateStructureBuilder.argtypes = [
		ctypes.POINTER(BNStructureBuilder),
	]


# noinspection PyPep8Naming
def BNDuplicateStructureBuilder(
		s: ctypes.POINTER(BNStructureBuilder)
		) -> Optional[ctypes.POINTER(BNStructureBuilder)]:
	result = _BNDuplicateStructureBuilder(s)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNDuplicateType

_BNDuplicateType = core.BNDuplicateType
_BNDuplicateType.restype = ctypes.POINTER(BNType)
_BNDuplicateType.argtypes = [
		ctypes.POINTER(BNType),
	]


# noinspection PyPep8Naming
def BNDuplicateType(
		type: ctypes.POINTER(BNType)
		) -> Optional[ctypes.POINTER(BNType)]:
	result = _BNDuplicateType(type)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNDuplicateTypeBuilder

_BNDuplicateTypeBuilder = core.BNDuplicateTypeBuilder
_BNDuplicateTypeBuilder.restype = ctypes.POINTER(BNTypeBuilder)
_BNDuplicateTypeBuilder.argtypes = [
		ctypes.POINTER(BNTypeBuilder),
	]


# noinspection PyPep8Naming
def BNDuplicateTypeBuilder(
		type: ctypes.POINTER(BNTypeBuilder)
		) -> Optional[ctypes.POINTER(BNTypeBuilder)]:
	result = _BNDuplicateTypeBuilder(type)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNDuplicateTypeContainer

_BNDuplicateTypeContainer = core.BNDuplicateTypeContainer
_BNDuplicateTypeContainer.restype = ctypes.POINTER(BNTypeContainer)
_BNDuplicateTypeContainer.argtypes = [
		ctypes.POINTER(BNTypeContainer),
	]


# noinspection PyPep8Naming
def BNDuplicateTypeContainer(
		container: ctypes.POINTER(BNTypeContainer)
		) -> Optional[ctypes.POINTER(BNTypeContainer)]:
	result = _BNDuplicateTypeContainer(container)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNDuplicateTypeLibrary

_BNDuplicateTypeLibrary = core.BNDuplicateTypeLibrary
_BNDuplicateTypeLibrary.restype = ctypes.POINTER(BNTypeLibrary)
_BNDuplicateTypeLibrary.argtypes = [
		ctypes.POINTER(BNTypeLibrary),
	]


# noinspection PyPep8Naming
def BNDuplicateTypeLibrary(
		lib: ctypes.POINTER(BNTypeLibrary)
		) -> Optional[ctypes.POINTER(BNTypeLibrary)]:
	result = _BNDuplicateTypeLibrary(lib)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNEncode

_BNEncode = core.BNEncode
_BNEncode.restype = ctypes.c_bool
_BNEncode.argtypes = [
		ctypes.POINTER(BNTransform),
		ctypes.POINTER(BNDataBuffer),
		ctypes.POINTER(BNDataBuffer),
		ctypes.POINTER(BNTransformParameter),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNEncode(
		xform: ctypes.POINTER(BNTransform), 
		input: ctypes.POINTER(BNDataBuffer), 
		output: ctypes.POINTER(BNDataBuffer), 
		params: ctypes.POINTER(BNTransformParameter), 
		paramCount: int
		) -> bool:
	return _BNEncode(xform, input, output, params, paramCount)


# -------------------------------------------------------
# _BNEndBulkModifySymbols

_BNEndBulkModifySymbols = core.BNEndBulkModifySymbols
_BNEndBulkModifySymbols.restype = None
_BNEndBulkModifySymbols.argtypes = [
		ctypes.POINTER(BNBinaryView),
	]


# noinspection PyPep8Naming
def BNEndBulkModifySymbols(
		view: ctypes.POINTER(BNBinaryView)
		) -> None:
	return _BNEndBulkModifySymbols(view)


# -------------------------------------------------------
# _BNEndKeyValueStoreNamespace

_BNEndKeyValueStoreNamespace = core.BNEndKeyValueStoreNamespace
_BNEndKeyValueStoreNamespace.restype = None
_BNEndKeyValueStoreNamespace.argtypes = [
		ctypes.POINTER(BNKeyValueStore),
	]


# noinspection PyPep8Naming
def BNEndKeyValueStoreNamespace(
		store: ctypes.POINTER(BNKeyValueStore)
		) -> None:
	return _BNEndKeyValueStoreNamespace(store)


# -------------------------------------------------------
# _BNEscapeTypeName

_BNEscapeTypeName = core.BNEscapeTypeName
_BNEscapeTypeName.restype = ctypes.POINTER(ctypes.c_byte)
_BNEscapeTypeName.argtypes = [
		ctypes.c_char_p,
		TokenEscapingTypeEnum,
	]


# noinspection PyPep8Naming
def BNEscapeTypeName(
		name: Optional[str], 
		escaping: TokenEscapingType
		) -> Optional[Optional[str]]:
	result = _BNEscapeTypeName(cstr(name), escaping)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNExecuteMainThreadAction

_BNExecuteMainThreadAction = core.BNExecuteMainThreadAction
_BNExecuteMainThreadAction.restype = None
_BNExecuteMainThreadAction.argtypes = [
		ctypes.POINTER(BNMainThreadAction),
	]


# noinspection PyPep8Naming
def BNExecuteMainThreadAction(
		action: ctypes.POINTER(BNMainThreadAction)
		) -> None:
	return _BNExecuteMainThreadAction(action)


# -------------------------------------------------------
# _BNExecuteOnMainThread

_BNExecuteOnMainThread = core.BNExecuteOnMainThread
_BNExecuteOnMainThread.restype = ctypes.POINTER(BNMainThreadAction)
_BNExecuteOnMainThread.argtypes = [
		ctypes.c_void_p,
		ctypes.CFUNCTYPE(None, ctypes.c_void_p),
	]


# noinspection PyPep8Naming
def BNExecuteOnMainThread(
		ctxt: Optional[ctypes.c_void_p], 
		func: ctypes.CFUNCTYPE(None, ctypes.c_void_p)
		) -> Optional[ctypes.POINTER(BNMainThreadAction)]:
	result = _BNExecuteOnMainThread(ctxt, func)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNExecuteOnMainThreadAndWait

_BNExecuteOnMainThreadAndWait = core.BNExecuteOnMainThreadAndWait
_BNExecuteOnMainThreadAndWait.restype = None
_BNExecuteOnMainThreadAndWait.argtypes = [
		ctypes.c_void_p,
		ctypes.CFUNCTYPE(None, ctypes.c_void_p),
	]


# noinspection PyPep8Naming
def BNExecuteOnMainThreadAndWait(
		ctxt: Optional[ctypes.c_void_p], 
		func: ctypes.CFUNCTYPE(None, ctypes.c_void_p)
		) -> None:
	return _BNExecuteOnMainThreadAndWait(ctxt, func)


# -------------------------------------------------------
# _BNExecuteScriptInput

_BNExecuteScriptInput = core.BNExecuteScriptInput
_BNExecuteScriptInput.restype = ScriptingProviderExecuteResultEnum
_BNExecuteScriptInput.argtypes = [
		ctypes.POINTER(BNScriptingInstance),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNExecuteScriptInput(
		instance: ctypes.POINTER(BNScriptingInstance), 
		input: Optional[str]
		) -> ScriptingProviderExecuteResult:
	return _BNExecuteScriptInput(instance, cstr(input))


# -------------------------------------------------------
# _BNExecuteScriptInputFromFilename

_BNExecuteScriptInputFromFilename = core.BNExecuteScriptInputFromFilename
_BNExecuteScriptInputFromFilename.restype = ScriptingProviderExecuteResultEnum
_BNExecuteScriptInputFromFilename.argtypes = [
		ctypes.POINTER(BNScriptingInstance),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNExecuteScriptInputFromFilename(
		instance: ctypes.POINTER(BNScriptingInstance), 
		filename: Optional[str]
		) -> ScriptingProviderExecuteResult:
	return _BNExecuteScriptInputFromFilename(instance, cstr(filename))


# -------------------------------------------------------
# _BNExecuteWorkerProcess

_BNExecuteWorkerProcess = core.BNExecuteWorkerProcess
_BNExecuteWorkerProcess.restype = ctypes.c_bool
_BNExecuteWorkerProcess.argtypes = [
		ctypes.c_char_p,
		ctypes.POINTER(ctypes.c_char_p),
		ctypes.POINTER(BNDataBuffer),
		ctypes.POINTER(ctypes.c_char_p),
		ctypes.POINTER(ctypes.c_char_p),
		ctypes.c_bool,
		ctypes.c_bool,
	]


# noinspection PyPep8Naming
def BNExecuteWorkerProcess(
		path: Optional[str], 
		args: ctypes.POINTER(ctypes.c_char_p), 
		input: ctypes.POINTER(BNDataBuffer), 
		output: ctypes.POINTER(ctypes.c_char_p), 
		error: ctypes.POINTER(ctypes.c_char_p), 
		stdoutIsText: bool, 
		stderrIsText: bool
		) -> bool:
	return _BNExecuteWorkerProcess(cstr(path), args, input, output, error, stdoutIsText, stderrIsText)


# -------------------------------------------------------
# _BNExternalLibraryGetBackingFile

_BNExternalLibraryGetBackingFile = core.BNExternalLibraryGetBackingFile
_BNExternalLibraryGetBackingFile.restype = ctypes.POINTER(BNProjectFile)
_BNExternalLibraryGetBackingFile.argtypes = [
		ctypes.POINTER(BNExternalLibrary),
	]


# noinspection PyPep8Naming
def BNExternalLibraryGetBackingFile(
		lib: ctypes.POINTER(BNExternalLibrary)
		) -> Optional[ctypes.POINTER(BNProjectFile)]:
	result = _BNExternalLibraryGetBackingFile(lib)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNExternalLibraryGetName

_BNExternalLibraryGetName = core.BNExternalLibraryGetName
_BNExternalLibraryGetName.restype = ctypes.POINTER(ctypes.c_byte)
_BNExternalLibraryGetName.argtypes = [
		ctypes.POINTER(BNExternalLibrary),
	]


# noinspection PyPep8Naming
def BNExternalLibraryGetName(
		lib: ctypes.POINTER(BNExternalLibrary)
		) -> Optional[Optional[str]]:
	result = _BNExternalLibraryGetName(lib)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNExternalLibrarySetBackingFile

_BNExternalLibrarySetBackingFile = core.BNExternalLibrarySetBackingFile
_BNExternalLibrarySetBackingFile.restype = None
_BNExternalLibrarySetBackingFile.argtypes = [
		ctypes.POINTER(BNExternalLibrary),
		ctypes.POINTER(BNProjectFile),
	]


# noinspection PyPep8Naming
def BNExternalLibrarySetBackingFile(
		lib: ctypes.POINTER(BNExternalLibrary), 
		file: ctypes.POINTER(BNProjectFile)
		) -> None:
	return _BNExternalLibrarySetBackingFile(lib, file)


# -------------------------------------------------------
# _BNExternalLocationGetExternalLibrary

_BNExternalLocationGetExternalLibrary = core.BNExternalLocationGetExternalLibrary
_BNExternalLocationGetExternalLibrary.restype = ctypes.POINTER(BNExternalLibrary)
_BNExternalLocationGetExternalLibrary.argtypes = [
		ctypes.POINTER(BNExternalLocation),
	]


# noinspection PyPep8Naming
def BNExternalLocationGetExternalLibrary(
		loc: ctypes.POINTER(BNExternalLocation)
		) -> Optional[ctypes.POINTER(BNExternalLibrary)]:
	result = _BNExternalLocationGetExternalLibrary(loc)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNExternalLocationGetSourceSymbol

_BNExternalLocationGetSourceSymbol = core.BNExternalLocationGetSourceSymbol
_BNExternalLocationGetSourceSymbol.restype = ctypes.POINTER(BNSymbol)
_BNExternalLocationGetSourceSymbol.argtypes = [
		ctypes.POINTER(BNExternalLocation),
	]


# noinspection PyPep8Naming
def BNExternalLocationGetSourceSymbol(
		loc: ctypes.POINTER(BNExternalLocation)
		) -> Optional[ctypes.POINTER(BNSymbol)]:
	result = _BNExternalLocationGetSourceSymbol(loc)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNExternalLocationGetTargetAddress

_BNExternalLocationGetTargetAddress = core.BNExternalLocationGetTargetAddress
_BNExternalLocationGetTargetAddress.restype = ctypes.c_ulonglong
_BNExternalLocationGetTargetAddress.argtypes = [
		ctypes.POINTER(BNExternalLocation),
	]


# noinspection PyPep8Naming
def BNExternalLocationGetTargetAddress(
		loc: ctypes.POINTER(BNExternalLocation)
		) -> int:
	return _BNExternalLocationGetTargetAddress(loc)


# -------------------------------------------------------
# _BNExternalLocationGetTargetSymbol

_BNExternalLocationGetTargetSymbol = core.BNExternalLocationGetTargetSymbol
_BNExternalLocationGetTargetSymbol.restype = ctypes.POINTER(ctypes.c_byte)
_BNExternalLocationGetTargetSymbol.argtypes = [
		ctypes.POINTER(BNExternalLocation),
	]


# noinspection PyPep8Naming
def BNExternalLocationGetTargetSymbol(
		loc: ctypes.POINTER(BNExternalLocation)
		) -> Optional[Optional[str]]:
	result = _BNExternalLocationGetTargetSymbol(loc)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNExternalLocationHasTargetAddress

_BNExternalLocationHasTargetAddress = core.BNExternalLocationHasTargetAddress
_BNExternalLocationHasTargetAddress.restype = ctypes.c_bool
_BNExternalLocationHasTargetAddress.argtypes = [
		ctypes.POINTER(BNExternalLocation),
	]


# noinspection PyPep8Naming
def BNExternalLocationHasTargetAddress(
		loc: ctypes.POINTER(BNExternalLocation)
		) -> bool:
	return _BNExternalLocationHasTargetAddress(loc)


# -------------------------------------------------------
# _BNExternalLocationHasTargetSymbol

_BNExternalLocationHasTargetSymbol = core.BNExternalLocationHasTargetSymbol
_BNExternalLocationHasTargetSymbol.restype = ctypes.c_bool
_BNExternalLocationHasTargetSymbol.argtypes = [
		ctypes.POINTER(BNExternalLocation),
	]


# noinspection PyPep8Naming
def BNExternalLocationHasTargetSymbol(
		loc: ctypes.POINTER(BNExternalLocation)
		) -> bool:
	return _BNExternalLocationHasTargetSymbol(loc)


# -------------------------------------------------------
# _BNExternalLocationSetExternalLibrary

_BNExternalLocationSetExternalLibrary = core.BNExternalLocationSetExternalLibrary
_BNExternalLocationSetExternalLibrary.restype = None
_BNExternalLocationSetExternalLibrary.argtypes = [
		ctypes.POINTER(BNExternalLocation),
		ctypes.POINTER(BNExternalLibrary),
	]


# noinspection PyPep8Naming
def BNExternalLocationSetExternalLibrary(
		loc: ctypes.POINTER(BNExternalLocation), 
		library: ctypes.POINTER(BNExternalLibrary)
		) -> None:
	return _BNExternalLocationSetExternalLibrary(loc, library)


# -------------------------------------------------------
# _BNExternalLocationSetTargetAddress

_BNExternalLocationSetTargetAddress = core.BNExternalLocationSetTargetAddress
_BNExternalLocationSetTargetAddress.restype = ctypes.c_bool
_BNExternalLocationSetTargetAddress.argtypes = [
		ctypes.POINTER(BNExternalLocation),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNExternalLocationSetTargetAddress(
		loc: ctypes.POINTER(BNExternalLocation), 
		address: ctypes.POINTER(ctypes.c_ulonglong)
		) -> bool:
	return _BNExternalLocationSetTargetAddress(loc, address)


# -------------------------------------------------------
# _BNExternalLocationSetTargetSymbol

_BNExternalLocationSetTargetSymbol = core.BNExternalLocationSetTargetSymbol
_BNExternalLocationSetTargetSymbol.restype = ctypes.c_bool
_BNExternalLocationSetTargetSymbol.argtypes = [
		ctypes.POINTER(BNExternalLocation),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNExternalLocationSetTargetSymbol(
		loc: ctypes.POINTER(BNExternalLocation), 
		symbol: Optional[str]
		) -> bool:
	return _BNExternalLocationSetTargetSymbol(loc, cstr(symbol))


# -------------------------------------------------------
# _BNFileMetadataGetSessionId

_BNFileMetadataGetSessionId = core.BNFileMetadataGetSessionId
_BNFileMetadataGetSessionId.restype = ctypes.c_ulonglong
_BNFileMetadataGetSessionId.argtypes = [
		ctypes.POINTER(BNFileMetadata),
	]


# noinspection PyPep8Naming
def BNFileMetadataGetSessionId(
		file: ctypes.POINTER(BNFileMetadata)
		) -> int:
	return _BNFileMetadataGetSessionId(file)


# -------------------------------------------------------
# _BNFileSize

_BNFileSize = core.BNFileSize
_BNFileSize.restype = ctypes.c_bool
_BNFileSize.argtypes = [
		ctypes.c_char_p,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNFileSize(
		path: Optional[str], 
		size: ctypes.POINTER(ctypes.c_ulonglong)
		) -> bool:
	return _BNFileSize(cstr(path), size)


# -------------------------------------------------------
# _BNFinalizeArchitectureHook

_BNFinalizeArchitectureHook = core.BNFinalizeArchitectureHook
_BNFinalizeArchitectureHook.restype = None
_BNFinalizeArchitectureHook.argtypes = [
		ctypes.POINTER(BNArchitecture),
	]


# noinspection PyPep8Naming
def BNFinalizeArchitectureHook(
		base: ctypes.POINTER(BNArchitecture)
		) -> None:
	return _BNFinalizeArchitectureHook(base)


# -------------------------------------------------------
# _BNFinalizeEnumerationBuilder

_BNFinalizeEnumerationBuilder = core.BNFinalizeEnumerationBuilder
_BNFinalizeEnumerationBuilder.restype = ctypes.POINTER(BNEnumeration)
_BNFinalizeEnumerationBuilder.argtypes = [
		ctypes.POINTER(BNEnumerationBuilder),
	]


# noinspection PyPep8Naming
def BNFinalizeEnumerationBuilder(
		e: ctypes.POINTER(BNEnumerationBuilder)
		) -> Optional[ctypes.POINTER(BNEnumeration)]:
	result = _BNFinalizeEnumerationBuilder(e)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNFinalizeHighLevelILFunction

_BNFinalizeHighLevelILFunction = core.BNFinalizeHighLevelILFunction
_BNFinalizeHighLevelILFunction.restype = None
_BNFinalizeHighLevelILFunction.argtypes = [
		ctypes.POINTER(BNHighLevelILFunction),
	]


# noinspection PyPep8Naming
def BNFinalizeHighLevelILFunction(
		func: ctypes.POINTER(BNHighLevelILFunction)
		) -> None:
	return _BNFinalizeHighLevelILFunction(func)


# -------------------------------------------------------
# _BNFinalizeLowLevelILFunction

_BNFinalizeLowLevelILFunction = core.BNFinalizeLowLevelILFunction
_BNFinalizeLowLevelILFunction.restype = None
_BNFinalizeLowLevelILFunction.argtypes = [
		ctypes.POINTER(BNLowLevelILFunction),
	]


# noinspection PyPep8Naming
def BNFinalizeLowLevelILFunction(
		func: ctypes.POINTER(BNLowLevelILFunction)
		) -> None:
	return _BNFinalizeLowLevelILFunction(func)


# -------------------------------------------------------
# _BNFinalizeMediumLevelILFunction

_BNFinalizeMediumLevelILFunction = core.BNFinalizeMediumLevelILFunction
_BNFinalizeMediumLevelILFunction.restype = None
_BNFinalizeMediumLevelILFunction.argtypes = [
		ctypes.POINTER(BNMediumLevelILFunction),
	]


# noinspection PyPep8Naming
def BNFinalizeMediumLevelILFunction(
		func: ctypes.POINTER(BNMediumLevelILFunction)
		) -> None:
	return _BNFinalizeMediumLevelILFunction(func)


# -------------------------------------------------------
# _BNFinalizeNamedTypeReferenceBuilder

_BNFinalizeNamedTypeReferenceBuilder = core.BNFinalizeNamedTypeReferenceBuilder
_BNFinalizeNamedTypeReferenceBuilder.restype = ctypes.POINTER(BNNamedTypeReference)
_BNFinalizeNamedTypeReferenceBuilder.argtypes = [
		ctypes.POINTER(BNNamedTypeReferenceBuilder),
	]


# noinspection PyPep8Naming
def BNFinalizeNamedTypeReferenceBuilder(
		s: ctypes.POINTER(BNNamedTypeReferenceBuilder)
		) -> Optional[ctypes.POINTER(BNNamedTypeReference)]:
	result = _BNFinalizeNamedTypeReferenceBuilder(s)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNFinalizeStructureBuilder

_BNFinalizeStructureBuilder = core.BNFinalizeStructureBuilder
_BNFinalizeStructureBuilder.restype = ctypes.POINTER(BNStructure)
_BNFinalizeStructureBuilder.argtypes = [
		ctypes.POINTER(BNStructureBuilder),
	]


# noinspection PyPep8Naming
def BNFinalizeStructureBuilder(
		s: ctypes.POINTER(BNStructureBuilder)
		) -> Optional[ctypes.POINTER(BNStructure)]:
	result = _BNFinalizeStructureBuilder(s)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNFinalizeTypeBuilder

_BNFinalizeTypeBuilder = core.BNFinalizeTypeBuilder
_BNFinalizeTypeBuilder.restype = ctypes.POINTER(BNType)
_BNFinalizeTypeBuilder.argtypes = [
		ctypes.POINTER(BNTypeBuilder),
	]


# noinspection PyPep8Naming
def BNFinalizeTypeBuilder(
		type: ctypes.POINTER(BNTypeBuilder)
		) -> Optional[ctypes.POINTER(BNType)]:
	result = _BNFinalizeTypeBuilder(type)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNFinalizeTypeLibrary

_BNFinalizeTypeLibrary = core.BNFinalizeTypeLibrary
_BNFinalizeTypeLibrary.restype = ctypes.c_bool
_BNFinalizeTypeLibrary.argtypes = [
		ctypes.POINTER(BNTypeLibrary),
	]


# noinspection PyPep8Naming
def BNFinalizeTypeLibrary(
		lib: ctypes.POINTER(BNTypeLibrary)
		) -> bool:
	return _BNFinalizeTypeLibrary(lib)


# -------------------------------------------------------
# _BNFindAllConstantWithProgress

_BNFindAllConstantWithProgress = core.BNFindAllConstantWithProgress
_BNFindAllConstantWithProgress.restype = ctypes.c_bool
_BNFindAllConstantWithProgress.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
		ctypes.POINTER(BNDisassemblySettings),
		FunctionGraphTypeEnum,
		ctypes.c_void_p,
		ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong),
		ctypes.c_void_p,
		ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.POINTER(BNLinearDisassemblyLine)),
	]


# noinspection PyPep8Naming
def BNFindAllConstantWithProgress(
		view: ctypes.POINTER(BNBinaryView), 
		start: int, 
		end: int, 
		constant: int, 
		settings: ctypes.POINTER(BNDisassemblySettings), 
		graph: FunctionGraphType, 
		ctxt: Optional[ctypes.c_void_p], 
		progress: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong), 
		matchCtxt: Optional[ctypes.c_void_p], 
		matchCallback: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.POINTER(BNLinearDisassemblyLine))
		) -> bool:
	return _BNFindAllConstantWithProgress(view, start, end, constant, settings, graph, ctxt, progress, matchCtxt, matchCallback)


# -------------------------------------------------------
# _BNFindAllDataWithProgress

_BNFindAllDataWithProgress = core.BNFindAllDataWithProgress
_BNFindAllDataWithProgress.restype = ctypes.c_bool
_BNFindAllDataWithProgress.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
		ctypes.POINTER(BNDataBuffer),
		FindFlagEnum,
		ctypes.c_void_p,
		ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong),
		ctypes.c_void_p,
		ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.POINTER(BNDataBuffer)),
	]


# noinspection PyPep8Naming
def BNFindAllDataWithProgress(
		view: ctypes.POINTER(BNBinaryView), 
		start: int, 
		end: int, 
		data: ctypes.POINTER(BNDataBuffer), 
		flags: FindFlag, 
		ctxt: Optional[ctypes.c_void_p], 
		progress: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong), 
		matchCtxt: Optional[ctypes.c_void_p], 
		matchCallback: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.POINTER(BNDataBuffer))
		) -> bool:
	return _BNFindAllDataWithProgress(view, start, end, data, flags, ctxt, progress, matchCtxt, matchCallback)


# -------------------------------------------------------
# _BNFindAllTextWithProgress

_BNFindAllTextWithProgress = core.BNFindAllTextWithProgress
_BNFindAllTextWithProgress.restype = ctypes.c_bool
_BNFindAllTextWithProgress.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
		ctypes.c_char_p,
		ctypes.POINTER(BNDisassemblySettings),
		FindFlagEnum,
		FunctionGraphTypeEnum,
		ctypes.c_void_p,
		ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong),
		ctypes.c_void_p,
		ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_char_p, ctypes.POINTER(BNLinearDisassemblyLine)),
	]


# noinspection PyPep8Naming
def BNFindAllTextWithProgress(
		view: ctypes.POINTER(BNBinaryView), 
		start: int, 
		end: int, 
		data: Optional[str], 
		settings: ctypes.POINTER(BNDisassemblySettings), 
		flags: FindFlag, 
		graph: FunctionGraphType, 
		ctxt: Optional[ctypes.c_void_p], 
		progress: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong), 
		matchCtxt: Optional[ctypes.c_void_p], 
		matchCallback: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_char_p, ctypes.POINTER(BNLinearDisassemblyLine))
		) -> bool:
	return _BNFindAllTextWithProgress(view, start, end, cstr(data), settings, flags, graph, ctxt, progress, matchCtxt, matchCallback)


# -------------------------------------------------------
# _BNFindNextConstant

_BNFindNextConstant = core.BNFindNextConstant
_BNFindNextConstant.restype = ctypes.c_bool
_BNFindNextConstant.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
		ctypes.POINTER(BNDisassemblySettings),
		FunctionGraphTypeEnum,
	]


# noinspection PyPep8Naming
def BNFindNextConstant(
		view: ctypes.POINTER(BNBinaryView), 
		start: int, 
		constant: int, 
		result: ctypes.POINTER(ctypes.c_ulonglong), 
		settings: ctypes.POINTER(BNDisassemblySettings), 
		graph: FunctionGraphType
		) -> bool:
	return _BNFindNextConstant(view, start, constant, result, settings, graph)


# -------------------------------------------------------
# _BNFindNextConstantWithProgress

_BNFindNextConstantWithProgress = core.BNFindNextConstantWithProgress
_BNFindNextConstantWithProgress.restype = ctypes.c_bool
_BNFindNextConstantWithProgress.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
		ctypes.POINTER(BNDisassemblySettings),
		FunctionGraphTypeEnum,
		ctypes.c_void_p,
		ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNFindNextConstantWithProgress(
		view: ctypes.POINTER(BNBinaryView), 
		start: int, 
		end: int, 
		constant: int, 
		result: ctypes.POINTER(ctypes.c_ulonglong), 
		settings: ctypes.POINTER(BNDisassemblySettings), 
		graph: FunctionGraphType, 
		ctxt: Optional[ctypes.c_void_p], 
		progress: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong)
		) -> bool:
	return _BNFindNextConstantWithProgress(view, start, end, constant, result, settings, graph, ctxt, progress)


# -------------------------------------------------------
# _BNFindNextData

_BNFindNextData = core.BNFindNextData
_BNFindNextData.restype = ctypes.c_bool
_BNFindNextData.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
		ctypes.POINTER(BNDataBuffer),
		ctypes.POINTER(ctypes.c_ulonglong),
		FindFlagEnum,
	]


# noinspection PyPep8Naming
def BNFindNextData(
		view: ctypes.POINTER(BNBinaryView), 
		start: int, 
		data: ctypes.POINTER(BNDataBuffer), 
		result: ctypes.POINTER(ctypes.c_ulonglong), 
		flags: FindFlag
		) -> bool:
	return _BNFindNextData(view, start, data, result, flags)


# -------------------------------------------------------
# _BNFindNextDataWithProgress

_BNFindNextDataWithProgress = core.BNFindNextDataWithProgress
_BNFindNextDataWithProgress.restype = ctypes.c_bool
_BNFindNextDataWithProgress.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
		ctypes.POINTER(BNDataBuffer),
		ctypes.POINTER(ctypes.c_ulonglong),
		FindFlagEnum,
		ctypes.c_void_p,
		ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNFindNextDataWithProgress(
		view: ctypes.POINTER(BNBinaryView), 
		start: int, 
		end: int, 
		data: ctypes.POINTER(BNDataBuffer), 
		result: ctypes.POINTER(ctypes.c_ulonglong), 
		flags: FindFlag, 
		ctxt: Optional[ctypes.c_void_p], 
		progress: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong)
		) -> bool:
	return _BNFindNextDataWithProgress(view, start, end, data, result, flags, ctxt, progress)


# -------------------------------------------------------
# _BNFindNextText

_BNFindNextText = core.BNFindNextText
_BNFindNextText.restype = ctypes.c_bool
_BNFindNextText.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
		ctypes.c_char_p,
		ctypes.POINTER(ctypes.c_ulonglong),
		ctypes.POINTER(BNDisassemblySettings),
		FindFlagEnum,
		FunctionGraphTypeEnum,
	]


# noinspection PyPep8Naming
def BNFindNextText(
		view: ctypes.POINTER(BNBinaryView), 
		start: int, 
		data: Optional[str], 
		result: ctypes.POINTER(ctypes.c_ulonglong), 
		settings: ctypes.POINTER(BNDisassemblySettings), 
		flags: FindFlag, 
		graph: FunctionGraphType
		) -> bool:
	return _BNFindNextText(view, start, cstr(data), result, settings, flags, graph)


# -------------------------------------------------------
# _BNFindNextTextWithProgress

_BNFindNextTextWithProgress = core.BNFindNextTextWithProgress
_BNFindNextTextWithProgress.restype = ctypes.c_bool
_BNFindNextTextWithProgress.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
		ctypes.c_char_p,
		ctypes.POINTER(ctypes.c_ulonglong),
		ctypes.POINTER(BNDisassemblySettings),
		FindFlagEnum,
		FunctionGraphTypeEnum,
		ctypes.c_void_p,
		ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNFindNextTextWithProgress(
		view: ctypes.POINTER(BNBinaryView), 
		start: int, 
		end: int, 
		data: Optional[str], 
		result: ctypes.POINTER(ctypes.c_ulonglong), 
		settings: ctypes.POINTER(BNDisassemblySettings), 
		flags: FindFlag, 
		graph: FunctionGraphType, 
		ctxt: Optional[ctypes.c_void_p], 
		progress: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong)
		) -> bool:
	return _BNFindNextTextWithProgress(view, start, end, cstr(data), result, settings, flags, graph, ctxt, progress)


# -------------------------------------------------------
# _BNFinishBackgroundTask

_BNFinishBackgroundTask = core.BNFinishBackgroundTask
_BNFinishBackgroundTask.restype = None
_BNFinishBackgroundTask.argtypes = [
		ctypes.POINTER(BNBackgroundTask),
	]


# noinspection PyPep8Naming
def BNFinishBackgroundTask(
		task: ctypes.POINTER(BNBackgroundTask)
		) -> None:
	return _BNFinishBackgroundTask(task)


# -------------------------------------------------------
# _BNFinishPrepareForLayout

_BNFinishPrepareForLayout = core.BNFinishPrepareForLayout
_BNFinishPrepareForLayout.restype = None
_BNFinishPrepareForLayout.argtypes = [
		ctypes.POINTER(BNFlowGraph),
	]


# noinspection PyPep8Naming
def BNFinishPrepareForLayout(
		graph: ctypes.POINTER(BNFlowGraph)
		) -> None:
	return _BNFinishPrepareForLayout(graph)


# -------------------------------------------------------
# _BNFlowGraphHasNodes

_BNFlowGraphHasNodes = core.BNFlowGraphHasNodes
_BNFlowGraphHasNodes.restype = ctypes.c_bool
_BNFlowGraphHasNodes.argtypes = [
		ctypes.POINTER(BNFlowGraph),
	]


# noinspection PyPep8Naming
def BNFlowGraphHasNodes(
		graph: ctypes.POINTER(BNFlowGraph)
		) -> bool:
	return _BNFlowGraphHasNodes(graph)


# -------------------------------------------------------
# _BNFlowGraphHasUpdates

_BNFlowGraphHasUpdates = core.BNFlowGraphHasUpdates
_BNFlowGraphHasUpdates.restype = ctypes.c_bool
_BNFlowGraphHasUpdates.argtypes = [
		ctypes.POINTER(BNFlowGraph),
	]


# noinspection PyPep8Naming
def BNFlowGraphHasUpdates(
		graph: ctypes.POINTER(BNFlowGraph)
		) -> bool:
	return _BNFlowGraphHasUpdates(graph)


# -------------------------------------------------------
# _BNFlowGraphUpdateQueryMode

_BNFlowGraphUpdateQueryMode = core.BNFlowGraphUpdateQueryMode
_BNFlowGraphUpdateQueryMode.restype = ctypes.c_bool
_BNFlowGraphUpdateQueryMode.argtypes = [
		ctypes.POINTER(BNFlowGraph),
	]


# noinspection PyPep8Naming
def BNFlowGraphUpdateQueryMode(
		graph: ctypes.POINTER(BNFlowGraph)
		) -> bool:
	return _BNFlowGraphUpdateQueryMode(graph)


# -------------------------------------------------------
# _BNForgetUndoActions

_BNForgetUndoActions = core.BNForgetUndoActions
_BNForgetUndoActions.restype = None
_BNForgetUndoActions.argtypes = [
		ctypes.POINTER(BNFileMetadata),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNForgetUndoActions(
		file: ctypes.POINTER(BNFileMetadata), 
		id: Optional[str]
		) -> None:
	return _BNForgetUndoActions(file, cstr(id))


# -------------------------------------------------------
# _BNFormatTypeParserParseErrors

_BNFormatTypeParserParseErrors = core.BNFormatTypeParserParseErrors
_BNFormatTypeParserParseErrors.restype = ctypes.POINTER(ctypes.c_byte)
_BNFormatTypeParserParseErrors.argtypes = [
		ctypes.POINTER(BNTypeParserError),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNFormatTypeParserParseErrors(
		errors: ctypes.POINTER(BNTypeParserError), 
		count: int
		) -> Optional[Optional[str]]:
	result = _BNFormatTypeParserParseErrors(errors, count)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNFreeActivity

_BNFreeActivity = core.BNFreeActivity
_BNFreeActivity.restype = None
_BNFreeActivity.argtypes = [
		ctypes.POINTER(BNActivity),
	]


# noinspection PyPep8Naming
def BNFreeActivity(
		activity: ctypes.POINTER(BNActivity)
		) -> None:
	return _BNFreeActivity(activity)


# -------------------------------------------------------
# _BNFreeAddressList

_BNFreeAddressList = core.BNFreeAddressList
_BNFreeAddressList.restype = None
_BNFreeAddressList.argtypes = [
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNFreeAddressList(
		addrs: ctypes.POINTER(ctypes.c_ulonglong)
		) -> None:
	return _BNFreeAddressList(addrs)


# -------------------------------------------------------
# _BNFreeAddressRanges

_BNFreeAddressRanges = core.BNFreeAddressRanges
_BNFreeAddressRanges.restype = None
_BNFreeAddressRanges.argtypes = [
		ctypes.POINTER(BNAddressRange),
	]


# noinspection PyPep8Naming
def BNFreeAddressRanges(
		ranges: ctypes.POINTER(BNAddressRange)
		) -> None:
	return _BNFreeAddressRanges(ranges)


# -------------------------------------------------------
# _BNFreeAnalysisCompletionEvent

_BNFreeAnalysisCompletionEvent = core.BNFreeAnalysisCompletionEvent
_BNFreeAnalysisCompletionEvent.restype = None
_BNFreeAnalysisCompletionEvent.argtypes = [
		ctypes.POINTER(BNAnalysisCompletionEvent),
	]


# noinspection PyPep8Naming
def BNFreeAnalysisCompletionEvent(
		event: ctypes.POINTER(BNAnalysisCompletionEvent)
		) -> None:
	return _BNFreeAnalysisCompletionEvent(event)


# -------------------------------------------------------
# _BNFreeAnalysisContext

_BNFreeAnalysisContext = core.BNFreeAnalysisContext
_BNFreeAnalysisContext.restype = None
_BNFreeAnalysisContext.argtypes = [
		ctypes.POINTER(BNAnalysisContext),
	]


# noinspection PyPep8Naming
def BNFreeAnalysisContext(
		analysisContext: ctypes.POINTER(BNAnalysisContext)
		) -> None:
	return _BNFreeAnalysisContext(analysisContext)


# -------------------------------------------------------
# _BNFreeAnalysisInfo

_BNFreeAnalysisInfo = core.BNFreeAnalysisInfo
_BNFreeAnalysisInfo.restype = None
_BNFreeAnalysisInfo.argtypes = [
		ctypes.POINTER(BNAnalysisInfo),
	]


# noinspection PyPep8Naming
def BNFreeAnalysisInfo(
		info: ctypes.POINTER(BNAnalysisInfo)
		) -> None:
	return _BNFreeAnalysisInfo(info)


# -------------------------------------------------------
# _BNFreeAnalysisPerformanceInfo

_BNFreeAnalysisPerformanceInfo = core.BNFreeAnalysisPerformanceInfo
_BNFreeAnalysisPerformanceInfo.restype = None
_BNFreeAnalysisPerformanceInfo.argtypes = [
		ctypes.POINTER(BNPerformanceInfo),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNFreeAnalysisPerformanceInfo(
		info: ctypes.POINTER(BNPerformanceInfo), 
		count: int
		) -> None:
	return _BNFreeAnalysisPerformanceInfo(info, count)


# -------------------------------------------------------
# _BNFreeArchitectureList

_BNFreeArchitectureList = core.BNFreeArchitectureList
_BNFreeArchitectureList.restype = None
_BNFreeArchitectureList.argtypes = [
		ctypes.POINTER(ctypes.POINTER(BNArchitecture)),
	]


# noinspection PyPep8Naming
def BNFreeArchitectureList(
		archs: ctypes.POINTER(ctypes.POINTER(BNArchitecture))
		) -> None:
	return _BNFreeArchitectureList(archs)


# -------------------------------------------------------
# _BNFreeBackgroundTask

_BNFreeBackgroundTask = core.BNFreeBackgroundTask
_BNFreeBackgroundTask.restype = None
_BNFreeBackgroundTask.argtypes = [
		ctypes.POINTER(BNBackgroundTask),
	]


# noinspection PyPep8Naming
def BNFreeBackgroundTask(
		task: ctypes.POINTER(BNBackgroundTask)
		) -> None:
	return _BNFreeBackgroundTask(task)


# -------------------------------------------------------
# _BNFreeBackgroundTaskList

_BNFreeBackgroundTaskList = core.BNFreeBackgroundTaskList
_BNFreeBackgroundTaskList.restype = None
_BNFreeBackgroundTaskList.argtypes = [
		ctypes.POINTER(ctypes.POINTER(BNBackgroundTask)),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNFreeBackgroundTaskList(
		tasks: ctypes.POINTER(ctypes.POINTER(BNBackgroundTask)), 
		count: int
		) -> None:
	return _BNFreeBackgroundTaskList(tasks, count)


# -------------------------------------------------------
# _BNFreeBaseStructureList

_BNFreeBaseStructureList = core.BNFreeBaseStructureList
_BNFreeBaseStructureList.restype = None
_BNFreeBaseStructureList.argtypes = [
		ctypes.POINTER(BNBaseStructure),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNFreeBaseStructureList(
		bases: ctypes.POINTER(BNBaseStructure), 
		count: int
		) -> None:
	return _BNFreeBaseStructureList(bases, count)


# -------------------------------------------------------
# _BNFreeBasicBlock

_BNFreeBasicBlock = core.BNFreeBasicBlock
_BNFreeBasicBlock.restype = None
_BNFreeBasicBlock.argtypes = [
		ctypes.POINTER(BNBasicBlock),
	]


# noinspection PyPep8Naming
def BNFreeBasicBlock(
		block: ctypes.POINTER(BNBasicBlock)
		) -> None:
	return _BNFreeBasicBlock(block)


# -------------------------------------------------------
# _BNFreeBasicBlockEdgeList

_BNFreeBasicBlockEdgeList = core.BNFreeBasicBlockEdgeList
_BNFreeBasicBlockEdgeList.restype = None
_BNFreeBasicBlockEdgeList.argtypes = [
		ctypes.POINTER(BNBasicBlockEdge),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNFreeBasicBlockEdgeList(
		edges: ctypes.POINTER(BNBasicBlockEdge), 
		count: int
		) -> None:
	return _BNFreeBasicBlockEdgeList(edges, count)


# -------------------------------------------------------
# _BNFreeBasicBlockList

_BNFreeBasicBlockList = core.BNFreeBasicBlockList
_BNFreeBasicBlockList.restype = None
_BNFreeBasicBlockList.argtypes = [
		ctypes.POINTER(ctypes.POINTER(BNBasicBlock)),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNFreeBasicBlockList(
		blocks: ctypes.POINTER(ctypes.POINTER(BNBasicBlock)), 
		count: int
		) -> None:
	return _BNFreeBasicBlockList(blocks, count)


# -------------------------------------------------------
# _BNFreeBinaryReader

_BNFreeBinaryReader = core.BNFreeBinaryReader
_BNFreeBinaryReader.restype = None
_BNFreeBinaryReader.argtypes = [
		ctypes.POINTER(BNBinaryReader),
	]


# noinspection PyPep8Naming
def BNFreeBinaryReader(
		stream: ctypes.POINTER(BNBinaryReader)
		) -> None:
	return _BNFreeBinaryReader(stream)


# -------------------------------------------------------
# _BNFreeBinaryView

_BNFreeBinaryView = core.BNFreeBinaryView
_BNFreeBinaryView.restype = None
_BNFreeBinaryView.argtypes = [
		ctypes.POINTER(BNBinaryView),
	]


# noinspection PyPep8Naming
def BNFreeBinaryView(
		view: ctypes.POINTER(BNBinaryView)
		) -> None:
	return _BNFreeBinaryView(view)


# -------------------------------------------------------
# _BNFreeBinaryViewTypeList

_BNFreeBinaryViewTypeList = core.BNFreeBinaryViewTypeList
_BNFreeBinaryViewTypeList.restype = None
_BNFreeBinaryViewTypeList.argtypes = [
		ctypes.POINTER(ctypes.POINTER(BNBinaryViewType)),
	]


# noinspection PyPep8Naming
def BNFreeBinaryViewTypeList(
		types: ctypes.POINTER(ctypes.POINTER(BNBinaryViewType))
		) -> None:
	return _BNFreeBinaryViewTypeList(types)


# -------------------------------------------------------
# _BNFreeBinaryWriter

_BNFreeBinaryWriter = core.BNFreeBinaryWriter
_BNFreeBinaryWriter.restype = None
_BNFreeBinaryWriter.argtypes = [
		ctypes.POINTER(BNBinaryWriter),
	]


# noinspection PyPep8Naming
def BNFreeBinaryWriter(
		stream: ctypes.POINTER(BNBinaryWriter)
		) -> None:
	return _BNFreeBinaryWriter(stream)


# -------------------------------------------------------
# _BNFreeCallingConvention

_BNFreeCallingConvention = core.BNFreeCallingConvention
_BNFreeCallingConvention.restype = None
_BNFreeCallingConvention.argtypes = [
		ctypes.POINTER(BNCallingConvention),
	]


# noinspection PyPep8Naming
def BNFreeCallingConvention(
		cc: ctypes.POINTER(BNCallingConvention)
		) -> None:
	return _BNFreeCallingConvention(cc)


# -------------------------------------------------------
# _BNFreeCallingConventionList

_BNFreeCallingConventionList = core.BNFreeCallingConventionList
_BNFreeCallingConventionList.restype = None
_BNFreeCallingConventionList.argtypes = [
		ctypes.POINTER(ctypes.POINTER(BNCallingConvention)),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNFreeCallingConventionList(
		list: ctypes.POINTER(ctypes.POINTER(BNCallingConvention)), 
		count: int
		) -> None:
	return _BNFreeCallingConventionList(list, count)


# -------------------------------------------------------
# _BNFreeCodeReferences

_BNFreeCodeReferences = core.BNFreeCodeReferences
_BNFreeCodeReferences.restype = None
_BNFreeCodeReferences.argtypes = [
		ctypes.POINTER(BNReferenceSource),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNFreeCodeReferences(
		refs: ctypes.POINTER(BNReferenceSource), 
		count: int
		) -> None:
	return _BNFreeCodeReferences(refs, count)


# -------------------------------------------------------
# _BNFreeComponent

_BNFreeComponent = core.BNFreeComponent
_BNFreeComponent.restype = None
_BNFreeComponent.argtypes = [
		ctypes.POINTER(BNComponent),
	]


# noinspection PyPep8Naming
def BNFreeComponent(
		component: ctypes.POINTER(BNComponent)
		) -> None:
	return _BNFreeComponent(component)


# -------------------------------------------------------
# _BNFreeComponents

_BNFreeComponents = core.BNFreeComponents
_BNFreeComponents.restype = None
_BNFreeComponents.argtypes = [
		ctypes.POINTER(ctypes.POINTER(BNComponent)),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNFreeComponents(
		components: ctypes.POINTER(ctypes.POINTER(BNComponent)), 
		count: int
		) -> None:
	return _BNFreeComponents(components, count)


# -------------------------------------------------------
# _BNFreeConstantReferenceList

_BNFreeConstantReferenceList = core.BNFreeConstantReferenceList
_BNFreeConstantReferenceList.restype = None
_BNFreeConstantReferenceList.argtypes = [
		ctypes.POINTER(BNConstantReference),
	]


# noinspection PyPep8Naming
def BNFreeConstantReferenceList(
		refs: ctypes.POINTER(BNConstantReference)
		) -> None:
	return _BNFreeConstantReferenceList(refs)


# -------------------------------------------------------
# _BNFreeDataBuffer

_BNFreeDataBuffer = core.BNFreeDataBuffer
_BNFreeDataBuffer.restype = None
_BNFreeDataBuffer.argtypes = [
		ctypes.POINTER(BNDataBuffer),
	]


# noinspection PyPep8Naming
def BNFreeDataBuffer(
		buf: ctypes.POINTER(BNDataBuffer)
		) -> None:
	return _BNFreeDataBuffer(buf)


# -------------------------------------------------------
# _BNFreeDataReferences

_BNFreeDataReferences = core.BNFreeDataReferences
_BNFreeDataReferences.restype = None
_BNFreeDataReferences.argtypes = [
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNFreeDataReferences(
		refs: ctypes.POINTER(ctypes.c_ulonglong)
		) -> None:
	return _BNFreeDataReferences(refs)


# -------------------------------------------------------
# _BNFreeDataRenderer

_BNFreeDataRenderer = core.BNFreeDataRenderer
_BNFreeDataRenderer.restype = None
_BNFreeDataRenderer.argtypes = [
		ctypes.POINTER(BNDataRenderer),
	]


# noinspection PyPep8Naming
def BNFreeDataRenderer(
		renderer: ctypes.POINTER(BNDataRenderer)
		) -> None:
	return _BNFreeDataRenderer(renderer)


# -------------------------------------------------------
# _BNFreeDataVariable

_BNFreeDataVariable = core.BNFreeDataVariable
_BNFreeDataVariable.restype = None
_BNFreeDataVariable.argtypes = [
		ctypes.POINTER(BNDataVariable),
	]


# noinspection PyPep8Naming
def BNFreeDataVariable(
		var: ctypes.POINTER(BNDataVariable)
		) -> None:
	return _BNFreeDataVariable(var)


# -------------------------------------------------------
# _BNFreeDataVariableAndName

_BNFreeDataVariableAndName = core.BNFreeDataVariableAndName
_BNFreeDataVariableAndName.restype = None
_BNFreeDataVariableAndName.argtypes = [
		ctypes.POINTER(BNDataVariableAndName),
	]


# noinspection PyPep8Naming
def BNFreeDataVariableAndName(
		var: ctypes.POINTER(BNDataVariableAndName)
		) -> None:
	return _BNFreeDataVariableAndName(var)


# -------------------------------------------------------
# _BNFreeDataVariableAndNameAndDebugParserList

_BNFreeDataVariableAndNameAndDebugParserList = core.BNFreeDataVariableAndNameAndDebugParserList
_BNFreeDataVariableAndNameAndDebugParserList.restype = None
_BNFreeDataVariableAndNameAndDebugParserList.argtypes = [
		ctypes.POINTER(BNDataVariableAndNameAndDebugParser),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNFreeDataVariableAndNameAndDebugParserList(
		vars: ctypes.POINTER(BNDataVariableAndNameAndDebugParser), 
		count: int
		) -> None:
	return _BNFreeDataVariableAndNameAndDebugParserList(vars, count)


# -------------------------------------------------------
# _BNFreeDataVariables

_BNFreeDataVariables = core.BNFreeDataVariables
_BNFreeDataVariables.restype = None
_BNFreeDataVariables.argtypes = [
		ctypes.POINTER(BNDataVariable),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNFreeDataVariables(
		vars: ctypes.POINTER(BNDataVariable), 
		count: int
		) -> None:
	return _BNFreeDataVariables(vars, count)


# -------------------------------------------------------
# _BNFreeDataVariablesAndName

_BNFreeDataVariablesAndName = core.BNFreeDataVariablesAndName
_BNFreeDataVariablesAndName.restype = None
_BNFreeDataVariablesAndName.argtypes = [
		ctypes.POINTER(BNDataVariableAndName),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNFreeDataVariablesAndName(
		vars: ctypes.POINTER(BNDataVariableAndName), 
		count: int
		) -> None:
	return _BNFreeDataVariablesAndName(vars, count)


# -------------------------------------------------------
# _BNFreeDatabase

_BNFreeDatabase = core.BNFreeDatabase
_BNFreeDatabase.restype = None
_BNFreeDatabase.argtypes = [
		ctypes.POINTER(BNDatabase),
	]


# noinspection PyPep8Naming
def BNFreeDatabase(
		database: ctypes.POINTER(BNDatabase)
		) -> None:
	return _BNFreeDatabase(database)


# -------------------------------------------------------
# _BNFreeDebugFunctions

_BNFreeDebugFunctions = core.BNFreeDebugFunctions
_BNFreeDebugFunctions.restype = None
_BNFreeDebugFunctions.argtypes = [
		ctypes.POINTER(BNDebugFunctionInfo),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNFreeDebugFunctions(
		functions: ctypes.POINTER(BNDebugFunctionInfo), 
		count: int
		) -> None:
	return _BNFreeDebugFunctions(functions, count)


# -------------------------------------------------------
# _BNFreeDebugInfoParserList

_BNFreeDebugInfoParserList = core.BNFreeDebugInfoParserList
_BNFreeDebugInfoParserList.restype = None
_BNFreeDebugInfoParserList.argtypes = [
		ctypes.POINTER(ctypes.POINTER(BNDebugInfoParser)),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNFreeDebugInfoParserList(
		parsers: ctypes.POINTER(ctypes.POINTER(BNDebugInfoParser)), 
		count: int
		) -> None:
	return _BNFreeDebugInfoParserList(parsers, count)


# -------------------------------------------------------
# _BNFreeDebugInfoParserReference

_BNFreeDebugInfoParserReference = core.BNFreeDebugInfoParserReference
_BNFreeDebugInfoParserReference.restype = None
_BNFreeDebugInfoParserReference.argtypes = [
		ctypes.POINTER(BNDebugInfoParser),
	]


# noinspection PyPep8Naming
def BNFreeDebugInfoParserReference(
		parser: ctypes.POINTER(BNDebugInfoParser)
		) -> None:
	return _BNFreeDebugInfoParserReference(parser)


# -------------------------------------------------------
# _BNFreeDebugInfoReference

_BNFreeDebugInfoReference = core.BNFreeDebugInfoReference
_BNFreeDebugInfoReference.restype = None
_BNFreeDebugInfoReference.argtypes = [
		ctypes.POINTER(BNDebugInfo),
	]


# noinspection PyPep8Naming
def BNFreeDebugInfoReference(
		debugInfo: ctypes.POINTER(BNDebugInfo)
		) -> None:
	return _BNFreeDebugInfoReference(debugInfo)


# -------------------------------------------------------
# _BNFreeDebugTypes

_BNFreeDebugTypes = core.BNFreeDebugTypes
_BNFreeDebugTypes.restype = None
_BNFreeDebugTypes.argtypes = [
		ctypes.POINTER(BNNameAndType),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNFreeDebugTypes(
		types: ctypes.POINTER(BNNameAndType), 
		count: int
		) -> None:
	return _BNFreeDebugTypes(types, count)


# -------------------------------------------------------
# _BNFreeDemangledName

_BNFreeDemangledName = core.BNFreeDemangledName
_BNFreeDemangledName.restype = None
_BNFreeDemangledName.argtypes = [
		ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNFreeDemangledName(
		name: ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)), 
		nameElements: int
		) -> None:
	return _BNFreeDemangledName(name, nameElements)


# -------------------------------------------------------
# _BNFreeDisassemblySettings

_BNFreeDisassemblySettings = core.BNFreeDisassemblySettings
_BNFreeDisassemblySettings.restype = None
_BNFreeDisassemblySettings.argtypes = [
		ctypes.POINTER(BNDisassemblySettings),
	]


# noinspection PyPep8Naming
def BNFreeDisassemblySettings(
		settings: ctypes.POINTER(BNDisassemblySettings)
		) -> None:
	return _BNFreeDisassemblySettings(settings)


# -------------------------------------------------------
# _BNFreeDisassemblyTextLines

_BNFreeDisassemblyTextLines = core.BNFreeDisassemblyTextLines
_BNFreeDisassemblyTextLines.restype = None
_BNFreeDisassemblyTextLines.argtypes = [
		ctypes.POINTER(BNDisassemblyTextLine),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNFreeDisassemblyTextLines(
		lines: ctypes.POINTER(BNDisassemblyTextLine), 
		count: int
		) -> None:
	return _BNFreeDisassemblyTextLines(lines, count)


# -------------------------------------------------------
# _BNFreeDisassemblyTextRenderer

_BNFreeDisassemblyTextRenderer = core.BNFreeDisassemblyTextRenderer
_BNFreeDisassemblyTextRenderer.restype = None
_BNFreeDisassemblyTextRenderer.argtypes = [
		ctypes.POINTER(BNDisassemblyTextRenderer),
	]


# noinspection PyPep8Naming
def BNFreeDisassemblyTextRenderer(
		renderer: ctypes.POINTER(BNDisassemblyTextRenderer)
		) -> None:
	return _BNFreeDisassemblyTextRenderer(renderer)


# -------------------------------------------------------
# _BNFreeDownloadInstance

_BNFreeDownloadInstance = core.BNFreeDownloadInstance
_BNFreeDownloadInstance.restype = None
_BNFreeDownloadInstance.argtypes = [
		ctypes.POINTER(BNDownloadInstance),
	]


# noinspection PyPep8Naming
def BNFreeDownloadInstance(
		instance: ctypes.POINTER(BNDownloadInstance)
		) -> None:
	return _BNFreeDownloadInstance(instance)


# -------------------------------------------------------
# _BNFreeDownloadInstanceResponse

_BNFreeDownloadInstanceResponse = core.BNFreeDownloadInstanceResponse
_BNFreeDownloadInstanceResponse.restype = None
_BNFreeDownloadInstanceResponse.argtypes = [
		ctypes.POINTER(BNDownloadInstanceResponse),
	]


# noinspection PyPep8Naming
def BNFreeDownloadInstanceResponse(
		response: ctypes.POINTER(BNDownloadInstanceResponse)
		) -> None:
	return _BNFreeDownloadInstanceResponse(response)


# -------------------------------------------------------
# _BNFreeDownloadProviderList

_BNFreeDownloadProviderList = core.BNFreeDownloadProviderList
_BNFreeDownloadProviderList.restype = None
_BNFreeDownloadProviderList.argtypes = [
		ctypes.POINTER(ctypes.POINTER(BNDownloadProvider)),
	]


# noinspection PyPep8Naming
def BNFreeDownloadProviderList(
		providers: ctypes.POINTER(ctypes.POINTER(BNDownloadProvider))
		) -> None:
	return _BNFreeDownloadProviderList(providers)


# -------------------------------------------------------
# _BNFreeEnumeration

_BNFreeEnumeration = core.BNFreeEnumeration
_BNFreeEnumeration.restype = None
_BNFreeEnumeration.argtypes = [
		ctypes.POINTER(BNEnumeration),
	]


# noinspection PyPep8Naming
def BNFreeEnumeration(
		e: ctypes.POINTER(BNEnumeration)
		) -> None:
	return _BNFreeEnumeration(e)


# -------------------------------------------------------
# _BNFreeEnumerationBuilder

_BNFreeEnumerationBuilder = core.BNFreeEnumerationBuilder
_BNFreeEnumerationBuilder.restype = None
_BNFreeEnumerationBuilder.argtypes = [
		ctypes.POINTER(BNEnumerationBuilder),
	]


# noinspection PyPep8Naming
def BNFreeEnumerationBuilder(
		e: ctypes.POINTER(BNEnumerationBuilder)
		) -> None:
	return _BNFreeEnumerationBuilder(e)


# -------------------------------------------------------
# _BNFreeEnumerationMemberList

_BNFreeEnumerationMemberList = core.BNFreeEnumerationMemberList
_BNFreeEnumerationMemberList.restype = None
_BNFreeEnumerationMemberList.argtypes = [
		ctypes.POINTER(BNEnumerationMember),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNFreeEnumerationMemberList(
		members: ctypes.POINTER(BNEnumerationMember), 
		count: int
		) -> None:
	return _BNFreeEnumerationMemberList(members, count)


# -------------------------------------------------------
# _BNFreeExternalLibrary

_BNFreeExternalLibrary = core.BNFreeExternalLibrary
_BNFreeExternalLibrary.restype = None
_BNFreeExternalLibrary.argtypes = [
		ctypes.POINTER(BNExternalLibrary),
	]


# noinspection PyPep8Naming
def BNFreeExternalLibrary(
		lib: ctypes.POINTER(BNExternalLibrary)
		) -> None:
	return _BNFreeExternalLibrary(lib)


# -------------------------------------------------------
# _BNFreeExternalLibraryList

_BNFreeExternalLibraryList = core.BNFreeExternalLibraryList
_BNFreeExternalLibraryList.restype = None
_BNFreeExternalLibraryList.argtypes = [
		ctypes.POINTER(ctypes.POINTER(BNExternalLibrary)),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNFreeExternalLibraryList(
		libs: ctypes.POINTER(ctypes.POINTER(BNExternalLibrary)), 
		count: int
		) -> None:
	return _BNFreeExternalLibraryList(libs, count)


# -------------------------------------------------------
# _BNFreeExternalLocation

_BNFreeExternalLocation = core.BNFreeExternalLocation
_BNFreeExternalLocation.restype = None
_BNFreeExternalLocation.argtypes = [
		ctypes.POINTER(BNExternalLocation),
	]


# noinspection PyPep8Naming
def BNFreeExternalLocation(
		loc: ctypes.POINTER(BNExternalLocation)
		) -> None:
	return _BNFreeExternalLocation(loc)


# -------------------------------------------------------
# _BNFreeExternalLocationList

_BNFreeExternalLocationList = core.BNFreeExternalLocationList
_BNFreeExternalLocationList.restype = None
_BNFreeExternalLocationList.argtypes = [
		ctypes.POINTER(ctypes.POINTER(BNExternalLocation)),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNFreeExternalLocationList(
		locs: ctypes.POINTER(ctypes.POINTER(BNExternalLocation)), 
		count: int
		) -> None:
	return _BNFreeExternalLocationList(locs, count)


# -------------------------------------------------------
# _BNFreeFileMetadata

_BNFreeFileMetadata = core.BNFreeFileMetadata
_BNFreeFileMetadata.restype = None
_BNFreeFileMetadata.argtypes = [
		ctypes.POINTER(BNFileMetadata),
	]


# noinspection PyPep8Naming
def BNFreeFileMetadata(
		file: ctypes.POINTER(BNFileMetadata)
		) -> None:
	return _BNFreeFileMetadata(file)


# -------------------------------------------------------
# _BNFreeFlagConditionsForSemanticFlagGroup

_BNFreeFlagConditionsForSemanticFlagGroup = core.BNFreeFlagConditionsForSemanticFlagGroup
_BNFreeFlagConditionsForSemanticFlagGroup.restype = None
_BNFreeFlagConditionsForSemanticFlagGroup.argtypes = [
		ctypes.POINTER(BNFlagConditionForSemanticClass),
	]


# noinspection PyPep8Naming
def BNFreeFlagConditionsForSemanticFlagGroup(
		conditions: ctypes.POINTER(BNFlagConditionForSemanticClass)
		) -> None:
	return _BNFreeFlagConditionsForSemanticFlagGroup(conditions)


# -------------------------------------------------------
# _BNFreeFlowGraph

_BNFreeFlowGraph = core.BNFreeFlowGraph
_BNFreeFlowGraph.restype = None
_BNFreeFlowGraph.argtypes = [
		ctypes.POINTER(BNFlowGraph),
	]


# noinspection PyPep8Naming
def BNFreeFlowGraph(
		graph: ctypes.POINTER(BNFlowGraph)
		) -> None:
	return _BNFreeFlowGraph(graph)


# -------------------------------------------------------
# _BNFreeFlowGraphLayoutRequest

_BNFreeFlowGraphLayoutRequest = core.BNFreeFlowGraphLayoutRequest
_BNFreeFlowGraphLayoutRequest.restype = None
_BNFreeFlowGraphLayoutRequest.argtypes = [
		ctypes.POINTER(BNFlowGraphLayoutRequest),
	]


# noinspection PyPep8Naming
def BNFreeFlowGraphLayoutRequest(
		layout: ctypes.POINTER(BNFlowGraphLayoutRequest)
		) -> None:
	return _BNFreeFlowGraphLayoutRequest(layout)


# -------------------------------------------------------
# _BNFreeFlowGraphNode

_BNFreeFlowGraphNode = core.BNFreeFlowGraphNode
_BNFreeFlowGraphNode.restype = None
_BNFreeFlowGraphNode.argtypes = [
		ctypes.POINTER(BNFlowGraphNode),
	]


# noinspection PyPep8Naming
def BNFreeFlowGraphNode(
		node: ctypes.POINTER(BNFlowGraphNode)
		) -> None:
	return _BNFreeFlowGraphNode(node)


# -------------------------------------------------------
# _BNFreeFlowGraphNodeEdgeList

_BNFreeFlowGraphNodeEdgeList = core.BNFreeFlowGraphNodeEdgeList
_BNFreeFlowGraphNodeEdgeList.restype = None
_BNFreeFlowGraphNodeEdgeList.argtypes = [
		ctypes.POINTER(BNFlowGraphEdge),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNFreeFlowGraphNodeEdgeList(
		edges: ctypes.POINTER(BNFlowGraphEdge), 
		count: int
		) -> None:
	return _BNFreeFlowGraphNodeEdgeList(edges, count)


# -------------------------------------------------------
# _BNFreeFlowGraphNodeList

_BNFreeFlowGraphNodeList = core.BNFreeFlowGraphNodeList
_BNFreeFlowGraphNodeList.restype = None
_BNFreeFlowGraphNodeList.argtypes = [
		ctypes.POINTER(ctypes.POINTER(BNFlowGraphNode)),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNFreeFlowGraphNodeList(
		nodes: ctypes.POINTER(ctypes.POINTER(BNFlowGraphNode)), 
		count: int
		) -> None:
	return _BNFreeFlowGraphNodeList(nodes, count)


# -------------------------------------------------------
# _BNFreeFormInputResults

_BNFreeFormInputResults = core.BNFreeFormInputResults
_BNFreeFormInputResults.restype = None
_BNFreeFormInputResults.argtypes = [
		ctypes.POINTER(BNFormInputField),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNFreeFormInputResults(
		fields: ctypes.POINTER(BNFormInputField), 
		count: int
		) -> None:
	return _BNFreeFormInputResults(fields, count)


# -------------------------------------------------------
# _BNFreeFullInfoUpdateChannels

_BNFreeFullInfoUpdateChannels = core.BNFreeFullInfoUpdateChannels
_BNFreeFullInfoUpdateChannels.restype = None
_BNFreeFullInfoUpdateChannels.argtypes = [
		ctypes.POINTER(BNUpdateChannelFullInfo),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNFreeFullInfoUpdateChannels(
		list: ctypes.POINTER(BNUpdateChannelFullInfo), 
		count: int
		) -> None:
	return _BNFreeFullInfoUpdateChannels(list, count)


# -------------------------------------------------------
# _BNFreeFunction

_BNFreeFunction = core.BNFreeFunction
_BNFreeFunction.restype = None
_BNFreeFunction.argtypes = [
		ctypes.POINTER(BNFunction),
	]


# noinspection PyPep8Naming
def BNFreeFunction(
		func: ctypes.POINTER(BNFunction)
		) -> None:
	return _BNFreeFunction(func)


# -------------------------------------------------------
# _BNFreeFunctionList

_BNFreeFunctionList = core.BNFreeFunctionList
_BNFreeFunctionList.restype = None
_BNFreeFunctionList.argtypes = [
		ctypes.POINTER(ctypes.POINTER(BNFunction)),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNFreeFunctionList(
		funcs: ctypes.POINTER(ctypes.POINTER(BNFunction)), 
		count: int
		) -> None:
	return _BNFreeFunctionList(funcs, count)


# -------------------------------------------------------
# _BNFreeHighLevelILFunction

_BNFreeHighLevelILFunction = core.BNFreeHighLevelILFunction
_BNFreeHighLevelILFunction.restype = None
_BNFreeHighLevelILFunction.argtypes = [
		ctypes.POINTER(BNHighLevelILFunction),
	]


# noinspection PyPep8Naming
def BNFreeHighLevelILFunction(
		func: ctypes.POINTER(BNHighLevelILFunction)
		) -> None:
	return _BNFreeHighLevelILFunction(func)


# -------------------------------------------------------
# _BNFreeILBranchDependenceList

_BNFreeILBranchDependenceList = core.BNFreeILBranchDependenceList
_BNFreeILBranchDependenceList.restype = None
_BNFreeILBranchDependenceList.argtypes = [
		ctypes.POINTER(BNILBranchInstructionAndDependence),
	]


# noinspection PyPep8Naming
def BNFreeILBranchDependenceList(
		branches: ctypes.POINTER(BNILBranchInstructionAndDependence)
		) -> None:
	return _BNFreeILBranchDependenceList(branches)


# -------------------------------------------------------
# _BNFreeILInstructionList

_BNFreeILInstructionList = core.BNFreeILInstructionList
_BNFreeILInstructionList.restype = None
_BNFreeILInstructionList.argtypes = [
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNFreeILInstructionList(
		list: ctypes.POINTER(ctypes.c_ulonglong)
		) -> None:
	return _BNFreeILInstructionList(list)


# -------------------------------------------------------
# _BNFreeILReferences

_BNFreeILReferences = core.BNFreeILReferences
_BNFreeILReferences.restype = None
_BNFreeILReferences.argtypes = [
		ctypes.POINTER(BNILReferenceSource),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNFreeILReferences(
		refs: ctypes.POINTER(BNILReferenceSource), 
		count: int
		) -> None:
	return _BNFreeILReferences(refs, count)


# -------------------------------------------------------
# _BNFreeIndirectBranchList

_BNFreeIndirectBranchList = core.BNFreeIndirectBranchList
_BNFreeIndirectBranchList.restype = None
_BNFreeIndirectBranchList.argtypes = [
		ctypes.POINTER(BNIndirectBranchInfo),
	]


# noinspection PyPep8Naming
def BNFreeIndirectBranchList(
		branches: ctypes.POINTER(BNIndirectBranchInfo)
		) -> None:
	return _BNFreeIndirectBranchList(branches)


# -------------------------------------------------------
# _BNFreeInheritedStructureMember

_BNFreeInheritedStructureMember = core.BNFreeInheritedStructureMember
_BNFreeInheritedStructureMember.restype = None
_BNFreeInheritedStructureMember.argtypes = [
		ctypes.POINTER(BNInheritedStructureMember),
	]


# noinspection PyPep8Naming
def BNFreeInheritedStructureMember(
		members: ctypes.POINTER(BNInheritedStructureMember)
		) -> None:
	return _BNFreeInheritedStructureMember(members)


# -------------------------------------------------------
# _BNFreeInheritedStructureMemberList

_BNFreeInheritedStructureMemberList = core.BNFreeInheritedStructureMemberList
_BNFreeInheritedStructureMemberList.restype = None
_BNFreeInheritedStructureMemberList.argtypes = [
		ctypes.POINTER(BNInheritedStructureMember),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNFreeInheritedStructureMemberList(
		members: ctypes.POINTER(BNInheritedStructureMember), 
		count: int
		) -> None:
	return _BNFreeInheritedStructureMemberList(members, count)


# -------------------------------------------------------
# _BNFreeInstructionText

_BNFreeInstructionText = core.BNFreeInstructionText
_BNFreeInstructionText.restype = None
_BNFreeInstructionText.argtypes = [
		ctypes.POINTER(BNInstructionTextToken),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNFreeInstructionText(
		tokens: ctypes.POINTER(BNInstructionTextToken), 
		count: int
		) -> None:
	return _BNFreeInstructionText(tokens, count)


# -------------------------------------------------------
# _BNFreeInstructionTextLines

_BNFreeInstructionTextLines = core.BNFreeInstructionTextLines
_BNFreeInstructionTextLines.restype = None
_BNFreeInstructionTextLines.argtypes = [
		ctypes.POINTER(BNInstructionTextLine),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNFreeInstructionTextLines(
		lines: ctypes.POINTER(BNInstructionTextLine), 
		count: int
		) -> None:
	return _BNFreeInstructionTextLines(lines, count)


# -------------------------------------------------------
# _BNFreeKeyValueStore

_BNFreeKeyValueStore = core.BNFreeKeyValueStore
_BNFreeKeyValueStore.restype = None
_BNFreeKeyValueStore.argtypes = [
		ctypes.POINTER(BNKeyValueStore),
	]


# noinspection PyPep8Naming
def BNFreeKeyValueStore(
		store: ctypes.POINTER(BNKeyValueStore)
		) -> None:
	return _BNFreeKeyValueStore(store)


# -------------------------------------------------------
# _BNFreeLLILVariableVersionList

_BNFreeLLILVariableVersionList = core.BNFreeLLILVariableVersionList
_BNFreeLLILVariableVersionList.restype = None
_BNFreeLLILVariableVersionList.argtypes = [
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNFreeLLILVariableVersionList(
		versions: ctypes.POINTER(ctypes.c_ulonglong)
		) -> None:
	return _BNFreeLLILVariableVersionList(versions)


# -------------------------------------------------------
# _BNFreeLLILVariablesList

_BNFreeLLILVariablesList = core.BNFreeLLILVariablesList
_BNFreeLLILVariablesList.restype = None
_BNFreeLLILVariablesList.argtypes = [
		ctypes.POINTER(ctypes.c_uint),
	]


# noinspection PyPep8Naming
def BNFreeLLILVariablesList(
		vars: ctypes.POINTER(ctypes.c_uint)
		) -> None:
	return _BNFreeLLILVariablesList(vars)


# -------------------------------------------------------
# _BNFreeLanguageRepresentationFunction

_BNFreeLanguageRepresentationFunction = core.BNFreeLanguageRepresentationFunction
_BNFreeLanguageRepresentationFunction.restype = None
_BNFreeLanguageRepresentationFunction.argtypes = [
		ctypes.POINTER(BNLanguageRepresentationFunction),
	]


# noinspection PyPep8Naming
def BNFreeLanguageRepresentationFunction(
		func: ctypes.POINTER(BNLanguageRepresentationFunction)
		) -> None:
	return _BNFreeLanguageRepresentationFunction(func)


# -------------------------------------------------------
# _BNFreeLinearDisassemblyLines

_BNFreeLinearDisassemblyLines = core.BNFreeLinearDisassemblyLines
_BNFreeLinearDisassemblyLines.restype = None
_BNFreeLinearDisassemblyLines.argtypes = [
		ctypes.POINTER(BNLinearDisassemblyLine),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNFreeLinearDisassemblyLines(
		lines: ctypes.POINTER(BNLinearDisassemblyLine), 
		count: int
		) -> None:
	return _BNFreeLinearDisassemblyLines(lines, count)


# -------------------------------------------------------
# _BNFreeLinearViewCursor

_BNFreeLinearViewCursor = core.BNFreeLinearViewCursor
_BNFreeLinearViewCursor.restype = None
_BNFreeLinearViewCursor.argtypes = [
		ctypes.POINTER(BNLinearViewCursor),
	]


# noinspection PyPep8Naming
def BNFreeLinearViewCursor(
		cursor: ctypes.POINTER(BNLinearViewCursor)
		) -> None:
	return _BNFreeLinearViewCursor(cursor)


# -------------------------------------------------------
# _BNFreeLinearViewCursorPath

_BNFreeLinearViewCursorPath = core.BNFreeLinearViewCursorPath
_BNFreeLinearViewCursorPath.restype = None
_BNFreeLinearViewCursorPath.argtypes = [
		ctypes.POINTER(BNLinearViewObjectIdentifier),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNFreeLinearViewCursorPath(
		objs: ctypes.POINTER(BNLinearViewObjectIdentifier), 
		count: int
		) -> None:
	return _BNFreeLinearViewCursorPath(objs, count)


# -------------------------------------------------------
# _BNFreeLinearViewCursorPathObjects

_BNFreeLinearViewCursorPathObjects = core.BNFreeLinearViewCursorPathObjects
_BNFreeLinearViewCursorPathObjects.restype = None
_BNFreeLinearViewCursorPathObjects.argtypes = [
		ctypes.POINTER(ctypes.POINTER(BNLinearViewObject)),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNFreeLinearViewCursorPathObjects(
		objs: ctypes.POINTER(ctypes.POINTER(BNLinearViewObject)), 
		count: int
		) -> None:
	return _BNFreeLinearViewCursorPathObjects(objs, count)


# -------------------------------------------------------
# _BNFreeLinearViewObject

_BNFreeLinearViewObject = core.BNFreeLinearViewObject
_BNFreeLinearViewObject.restype = None
_BNFreeLinearViewObject.argtypes = [
		ctypes.POINTER(BNLinearViewObject),
	]


# noinspection PyPep8Naming
def BNFreeLinearViewObject(
		obj: ctypes.POINTER(BNLinearViewObject)
		) -> None:
	return _BNFreeLinearViewObject(obj)


# -------------------------------------------------------
# _BNFreeLinearViewObjectIdentifier

_BNFreeLinearViewObjectIdentifier = core.BNFreeLinearViewObjectIdentifier
_BNFreeLinearViewObjectIdentifier.restype = None
_BNFreeLinearViewObjectIdentifier.argtypes = [
		ctypes.POINTER(BNLinearViewObjectIdentifier),
	]


# noinspection PyPep8Naming
def BNFreeLinearViewObjectIdentifier(
		id: ctypes.POINTER(BNLinearViewObjectIdentifier)
		) -> None:
	return _BNFreeLinearViewObjectIdentifier(id)


# -------------------------------------------------------
# _BNFreeLogger

_BNFreeLogger = core.BNFreeLogger
_BNFreeLogger.restype = None
_BNFreeLogger.argtypes = [
		ctypes.POINTER(BNLogger),
	]


# noinspection PyPep8Naming
def BNFreeLogger(
		logger: ctypes.POINTER(BNLogger)
		) -> None:
	return _BNFreeLogger(logger)


# -------------------------------------------------------
# _BNFreeLowLevelILFunction

_BNFreeLowLevelILFunction = core.BNFreeLowLevelILFunction
_BNFreeLowLevelILFunction.restype = None
_BNFreeLowLevelILFunction.argtypes = [
		ctypes.POINTER(BNLowLevelILFunction),
	]


# noinspection PyPep8Naming
def BNFreeLowLevelILFunction(
		func: ctypes.POINTER(BNLowLevelILFunction)
		) -> None:
	return _BNFreeLowLevelILFunction(func)


# -------------------------------------------------------
# _BNFreeMainThreadAction

_BNFreeMainThreadAction = core.BNFreeMainThreadAction
_BNFreeMainThreadAction.restype = None
_BNFreeMainThreadAction.argtypes = [
		ctypes.POINTER(BNMainThreadAction),
	]


# noinspection PyPep8Naming
def BNFreeMainThreadAction(
		action: ctypes.POINTER(BNMainThreadAction)
		) -> None:
	return _BNFreeMainThreadAction(action)


# -------------------------------------------------------
# _BNFreeMediumLevelILFunction

_BNFreeMediumLevelILFunction = core.BNFreeMediumLevelILFunction
_BNFreeMediumLevelILFunction.restype = None
_BNFreeMediumLevelILFunction.argtypes = [
		ctypes.POINTER(BNMediumLevelILFunction),
	]


# noinspection PyPep8Naming
def BNFreeMediumLevelILFunction(
		func: ctypes.POINTER(BNMediumLevelILFunction)
		) -> None:
	return _BNFreeMediumLevelILFunction(func)


# -------------------------------------------------------
# _BNFreeMemoryUsageInfo

_BNFreeMemoryUsageInfo = core.BNFreeMemoryUsageInfo
_BNFreeMemoryUsageInfo.restype = None
_BNFreeMemoryUsageInfo.argtypes = [
		ctypes.POINTER(BNMemoryUsageInfo),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNFreeMemoryUsageInfo(
		info: ctypes.POINTER(BNMemoryUsageInfo), 
		count: int
		) -> None:
	return _BNFreeMemoryUsageInfo(info, count)


# -------------------------------------------------------
# _BNFreeMergedVariableList

_BNFreeMergedVariableList = core.BNFreeMergedVariableList
_BNFreeMergedVariableList.restype = None
_BNFreeMergedVariableList.argtypes = [
		ctypes.POINTER(BNMergedVariable),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNFreeMergedVariableList(
		vars: ctypes.POINTER(BNMergedVariable), 
		count: int
		) -> None:
	return _BNFreeMergedVariableList(vars, count)


# -------------------------------------------------------
# _BNFreeMetadata

_BNFreeMetadata = core.BNFreeMetadata
_BNFreeMetadata.restype = None
_BNFreeMetadata.argtypes = [
		ctypes.POINTER(BNMetadata),
	]


# noinspection PyPep8Naming
def BNFreeMetadata(
		data: ctypes.POINTER(BNMetadata)
		) -> None:
	return _BNFreeMetadata(data)


# -------------------------------------------------------
# _BNFreeMetadataArray

_BNFreeMetadataArray = core.BNFreeMetadataArray
_BNFreeMetadataArray.restype = None
_BNFreeMetadataArray.argtypes = [
		ctypes.POINTER(ctypes.POINTER(BNMetadata)),
	]


# noinspection PyPep8Naming
def BNFreeMetadataArray(
		data: ctypes.POINTER(ctypes.POINTER(BNMetadata))
		) -> None:
	return _BNFreeMetadataArray(data)


# -------------------------------------------------------
# _BNFreeMetadataBooleanList

_BNFreeMetadataBooleanList = core.BNFreeMetadataBooleanList
_BNFreeMetadataBooleanList.restype = None
_BNFreeMetadataBooleanList.argtypes = [
		ctypes.POINTER(ctypes.c_bool),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNFreeMetadataBooleanList(
		arg0: ctypes.POINTER(ctypes.c_bool), 
		arg1: int
		) -> None:
	return _BNFreeMetadataBooleanList(arg0, arg1)


# -------------------------------------------------------
# _BNFreeMetadataDoubleList

_BNFreeMetadataDoubleList = core.BNFreeMetadataDoubleList
_BNFreeMetadataDoubleList.restype = None
_BNFreeMetadataDoubleList.argtypes = [
		ctypes.POINTER(ctypes.c_double),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNFreeMetadataDoubleList(
		arg0: ctypes.POINTER(ctypes.c_double), 
		arg1: int
		) -> None:
	return _BNFreeMetadataDoubleList(arg0, arg1)


# -------------------------------------------------------
# _BNFreeMetadataRaw

_BNFreeMetadataRaw = core.BNFreeMetadataRaw
_BNFreeMetadataRaw.restype = None
_BNFreeMetadataRaw.argtypes = [
		ctypes.POINTER(ctypes.c_ubyte),
	]


# noinspection PyPep8Naming
def BNFreeMetadataRaw(
		data: ctypes.POINTER(ctypes.c_ubyte)
		) -> None:
	return _BNFreeMetadataRaw(data)


# -------------------------------------------------------
# _BNFreeMetadataSignedIntegerList

_BNFreeMetadataSignedIntegerList = core.BNFreeMetadataSignedIntegerList
_BNFreeMetadataSignedIntegerList.restype = None
_BNFreeMetadataSignedIntegerList.argtypes = [
		ctypes.POINTER(ctypes.c_longlong),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNFreeMetadataSignedIntegerList(
		arg0: ctypes.POINTER(ctypes.c_longlong), 
		arg1: int
		) -> None:
	return _BNFreeMetadataSignedIntegerList(arg0, arg1)


# -------------------------------------------------------
# _BNFreeMetadataStringList

_BNFreeMetadataStringList = core.BNFreeMetadataStringList
_BNFreeMetadataStringList.restype = None
_BNFreeMetadataStringList.argtypes = [
		ctypes.POINTER(ctypes.c_char_p),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNFreeMetadataStringList(
		arg0: ctypes.POINTER(ctypes.c_char_p), 
		arg1: int
		) -> None:
	return _BNFreeMetadataStringList(arg0, arg1)


# -------------------------------------------------------
# _BNFreeMetadataUnsignedIntegerList

_BNFreeMetadataUnsignedIntegerList = core.BNFreeMetadataUnsignedIntegerList
_BNFreeMetadataUnsignedIntegerList.restype = None
_BNFreeMetadataUnsignedIntegerList.argtypes = [
		ctypes.POINTER(ctypes.c_ulonglong),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNFreeMetadataUnsignedIntegerList(
		arg0: ctypes.POINTER(ctypes.c_ulonglong), 
		arg1: int
		) -> None:
	return _BNFreeMetadataUnsignedIntegerList(arg0, arg1)


# -------------------------------------------------------
# _BNFreeMetadataValueStore

_BNFreeMetadataValueStore = core.BNFreeMetadataValueStore
_BNFreeMetadataValueStore.restype = None
_BNFreeMetadataValueStore.argtypes = [
		ctypes.POINTER(BNMetadataValueStore),
	]


# noinspection PyPep8Naming
def BNFreeMetadataValueStore(
		data: ctypes.POINTER(BNMetadataValueStore)
		) -> None:
	return _BNFreeMetadataValueStore(data)


# -------------------------------------------------------
# _BNFreeNameAndTypeList

_BNFreeNameAndTypeList = core.BNFreeNameAndTypeList
_BNFreeNameAndTypeList.restype = None
_BNFreeNameAndTypeList.argtypes = [
		ctypes.POINTER(BNNameAndType),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNFreeNameAndTypeList(
		nt: ctypes.POINTER(BNNameAndType), 
		count: int
		) -> None:
	return _BNFreeNameAndTypeList(nt, count)


# -------------------------------------------------------
# _BNFreeNameSpace

_BNFreeNameSpace = core.BNFreeNameSpace
_BNFreeNameSpace.restype = None
_BNFreeNameSpace.argtypes = [
		ctypes.POINTER(BNNameSpace),
	]


# noinspection PyPep8Naming
def BNFreeNameSpace(
		name: ctypes.POINTER(BNNameSpace)
		) -> None:
	return _BNFreeNameSpace(name)


# -------------------------------------------------------
# _BNFreeNameSpaceList

_BNFreeNameSpaceList = core.BNFreeNameSpaceList
_BNFreeNameSpaceList.restype = None
_BNFreeNameSpaceList.argtypes = [
		ctypes.POINTER(BNNameSpace),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNFreeNameSpaceList(
		nameSpace: ctypes.POINTER(BNNameSpace), 
		count: int
		) -> None:
	return _BNFreeNameSpaceList(nameSpace, count)


# -------------------------------------------------------
# _BNFreeNamedTypeReference

_BNFreeNamedTypeReference = core.BNFreeNamedTypeReference
_BNFreeNamedTypeReference.restype = None
_BNFreeNamedTypeReference.argtypes = [
		ctypes.POINTER(BNNamedTypeReference),
	]


# noinspection PyPep8Naming
def BNFreeNamedTypeReference(
		nt: ctypes.POINTER(BNNamedTypeReference)
		) -> None:
	return _BNFreeNamedTypeReference(nt)


# -------------------------------------------------------
# _BNFreeNamedTypeReferenceBuilder

_BNFreeNamedTypeReferenceBuilder = core.BNFreeNamedTypeReferenceBuilder
_BNFreeNamedTypeReferenceBuilder.restype = None
_BNFreeNamedTypeReferenceBuilder.argtypes = [
		ctypes.POINTER(BNNamedTypeReferenceBuilder),
	]


# noinspection PyPep8Naming
def BNFreeNamedTypeReferenceBuilder(
		s: ctypes.POINTER(BNNamedTypeReferenceBuilder)
		) -> None:
	return _BNFreeNamedTypeReferenceBuilder(s)


# -------------------------------------------------------
# _BNFreeOutputTypeList

_BNFreeOutputTypeList = core.BNFreeOutputTypeList
_BNFreeOutputTypeList.restype = None
_BNFreeOutputTypeList.argtypes = [
		ctypes.POINTER(BNTypeWithConfidence),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNFreeOutputTypeList(
		types: ctypes.POINTER(BNTypeWithConfidence), 
		count: int
		) -> None:
	return _BNFreeOutputTypeList(types, count)


# -------------------------------------------------------
# _BNFreeParameterVariables

_BNFreeParameterVariables = core.BNFreeParameterVariables
_BNFreeParameterVariables.restype = None
_BNFreeParameterVariables.argtypes = [
		ctypes.POINTER(BNParameterVariablesWithConfidence),
	]


# noinspection PyPep8Naming
def BNFreeParameterVariables(
		vars: ctypes.POINTER(BNParameterVariablesWithConfidence)
		) -> None:
	return _BNFreeParameterVariables(vars)


# -------------------------------------------------------
# _BNFreeParseError

_BNFreeParseError = core.BNFreeParseError
_BNFreeParseError.restype = None
_BNFreeParseError.argtypes = [
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNFreeParseError(
		errorString: Optional[str]
		) -> None:
	return _BNFreeParseError(cstr(errorString))


# -------------------------------------------------------
# _BNFreePath

_BNFreePath = core.BNFreePath
_BNFreePath.restype = None
_BNFreePath.argtypes = [
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNFreePath(
		path: Optional[str]
		) -> None:
	return _BNFreePath(cstr(path))


# -------------------------------------------------------
# _BNFreePlatform

_BNFreePlatform = core.BNFreePlatform
_BNFreePlatform.restype = None
_BNFreePlatform.argtypes = [
		ctypes.POINTER(BNPlatform),
	]


# noinspection PyPep8Naming
def BNFreePlatform(
		platform: ctypes.POINTER(BNPlatform)
		) -> None:
	return _BNFreePlatform(platform)


# -------------------------------------------------------
# _BNFreePlatformList

_BNFreePlatformList = core.BNFreePlatformList
_BNFreePlatformList.restype = None
_BNFreePlatformList.argtypes = [
		ctypes.POINTER(ctypes.POINTER(BNPlatform)),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNFreePlatformList(
		platform: ctypes.POINTER(ctypes.POINTER(BNPlatform)), 
		count: int
		) -> None:
	return _BNFreePlatformList(platform, count)


# -------------------------------------------------------
# _BNFreePlatformOSList

_BNFreePlatformOSList = core.BNFreePlatformOSList
_BNFreePlatformOSList.restype = None
_BNFreePlatformOSList.argtypes = [
		ctypes.POINTER(ctypes.c_char_p),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNFreePlatformOSList(
		list: ctypes.POINTER(ctypes.c_char_p), 
		count: int
		) -> None:
	return _BNFreePlatformOSList(list, count)


# -------------------------------------------------------
# _BNFreePlugin

_BNFreePlugin = core.BNFreePlugin
_BNFreePlugin.restype = None
_BNFreePlugin.argtypes = [
		ctypes.POINTER(BNRepoPlugin),
	]


# noinspection PyPep8Naming
def BNFreePlugin(
		plugin: ctypes.POINTER(BNRepoPlugin)
		) -> None:
	return _BNFreePlugin(plugin)


# -------------------------------------------------------
# _BNFreePluginCommandList

_BNFreePluginCommandList = core.BNFreePluginCommandList
_BNFreePluginCommandList.restype = None
_BNFreePluginCommandList.argtypes = [
		ctypes.POINTER(BNPluginCommand),
	]


# noinspection PyPep8Naming
def BNFreePluginCommandList(
		commands: ctypes.POINTER(BNPluginCommand)
		) -> None:
	return _BNFreePluginCommandList(commands)


# -------------------------------------------------------
# _BNFreePluginPlatforms

_BNFreePluginPlatforms = core.BNFreePluginPlatforms
_BNFreePluginPlatforms.restype = None
_BNFreePluginPlatforms.argtypes = [
		ctypes.POINTER(ctypes.c_char_p),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNFreePluginPlatforms(
		platforms: ctypes.POINTER(ctypes.c_char_p), 
		count: int
		) -> None:
	return _BNFreePluginPlatforms(platforms, count)


# -------------------------------------------------------
# _BNFreePluginTypes

_BNFreePluginTypes = core.BNFreePluginTypes
_BNFreePluginTypes.restype = None
_BNFreePluginTypes.argtypes = [
		ctypes.POINTER(PluginTypeEnum),
	]


# noinspection PyPep8Naming
def BNFreePluginTypes(
		r: ctypes.POINTER(PluginTypeEnum)
		) -> None:
	return _BNFreePluginTypes(r)


# -------------------------------------------------------
# _BNFreePossibleValueSet

_BNFreePossibleValueSet = core.BNFreePossibleValueSet
_BNFreePossibleValueSet.restype = None
_BNFreePossibleValueSet.argtypes = [
		ctypes.POINTER(BNPossibleValueSet),
	]


# noinspection PyPep8Naming
def BNFreePossibleValueSet(
		value: ctypes.POINTER(BNPossibleValueSet)
		) -> None:
	return _BNFreePossibleValueSet(value)


# -------------------------------------------------------
# _BNFreeProject

_BNFreeProject = core.BNFreeProject
_BNFreeProject.restype = None
_BNFreeProject.argtypes = [
		ctypes.POINTER(BNProject),
	]


# noinspection PyPep8Naming
def BNFreeProject(
		project: ctypes.POINTER(BNProject)
		) -> None:
	return _BNFreeProject(project)


# -------------------------------------------------------
# _BNFreeProjectFile

_BNFreeProjectFile = core.BNFreeProjectFile
_BNFreeProjectFile.restype = None
_BNFreeProjectFile.argtypes = [
		ctypes.POINTER(BNProjectFile),
	]


# noinspection PyPep8Naming
def BNFreeProjectFile(
		file: ctypes.POINTER(BNProjectFile)
		) -> None:
	return _BNFreeProjectFile(file)


# -------------------------------------------------------
# _BNFreeProjectFileList

_BNFreeProjectFileList = core.BNFreeProjectFileList
_BNFreeProjectFileList.restype = None
_BNFreeProjectFileList.argtypes = [
		ctypes.POINTER(ctypes.POINTER(BNProjectFile)),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNFreeProjectFileList(
		files: ctypes.POINTER(ctypes.POINTER(BNProjectFile)), 
		count: int
		) -> None:
	return _BNFreeProjectFileList(files, count)


# -------------------------------------------------------
# _BNFreeProjectFolder

_BNFreeProjectFolder = core.BNFreeProjectFolder
_BNFreeProjectFolder.restype = None
_BNFreeProjectFolder.argtypes = [
		ctypes.POINTER(BNProjectFolder),
	]


# noinspection PyPep8Naming
def BNFreeProjectFolder(
		folder: ctypes.POINTER(BNProjectFolder)
		) -> None:
	return _BNFreeProjectFolder(folder)


# -------------------------------------------------------
# _BNFreeProjectFolderList

_BNFreeProjectFolderList = core.BNFreeProjectFolderList
_BNFreeProjectFolderList.restype = None
_BNFreeProjectFolderList.argtypes = [
		ctypes.POINTER(ctypes.POINTER(BNProjectFolder)),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNFreeProjectFolderList(
		folders: ctypes.POINTER(ctypes.POINTER(BNProjectFolder)), 
		count: int
		) -> None:
	return _BNFreeProjectFolderList(folders, count)


# -------------------------------------------------------
# _BNFreeProjectList

_BNFreeProjectList = core.BNFreeProjectList
_BNFreeProjectList.restype = None
_BNFreeProjectList.argtypes = [
		ctypes.POINTER(ctypes.POINTER(BNProject)),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNFreeProjectList(
		projects: ctypes.POINTER(ctypes.POINTER(BNProject)), 
		count: int
		) -> None:
	return _BNFreeProjectList(projects, count)


# -------------------------------------------------------
# _BNFreeQualifiedName

_BNFreeQualifiedName = core.BNFreeQualifiedName
_BNFreeQualifiedName.restype = None
_BNFreeQualifiedName.argtypes = [
		ctypes.POINTER(BNQualifiedName),
	]


# noinspection PyPep8Naming
def BNFreeQualifiedName(
		name: ctypes.POINTER(BNQualifiedName)
		) -> None:
	return _BNFreeQualifiedName(name)


# -------------------------------------------------------
# _BNFreeQualifiedNameAndType

_BNFreeQualifiedNameAndType = core.BNFreeQualifiedNameAndType
_BNFreeQualifiedNameAndType.restype = None
_BNFreeQualifiedNameAndType.argtypes = [
		ctypes.POINTER(BNQualifiedNameAndType),
	]


# noinspection PyPep8Naming
def BNFreeQualifiedNameAndType(
		obj: ctypes.POINTER(BNQualifiedNameAndType)
		) -> None:
	return _BNFreeQualifiedNameAndType(obj)


# -------------------------------------------------------
# _BNFreeQualifiedNameAndTypeArray

_BNFreeQualifiedNameAndTypeArray = core.BNFreeQualifiedNameAndTypeArray
_BNFreeQualifiedNameAndTypeArray.restype = None
_BNFreeQualifiedNameAndTypeArray.argtypes = [
		ctypes.POINTER(BNQualifiedNameAndType),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNFreeQualifiedNameAndTypeArray(
		obj: ctypes.POINTER(BNQualifiedNameAndType), 
		count: int
		) -> None:
	return _BNFreeQualifiedNameAndTypeArray(obj, count)


# -------------------------------------------------------
# _BNFreeQualifiedNameArray

_BNFreeQualifiedNameArray = core.BNFreeQualifiedNameArray
_BNFreeQualifiedNameArray.restype = None
_BNFreeQualifiedNameArray.argtypes = [
		ctypes.POINTER(BNQualifiedName),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNFreeQualifiedNameArray(
		names: ctypes.POINTER(BNQualifiedName), 
		count: int
		) -> None:
	return _BNFreeQualifiedNameArray(names, count)


# -------------------------------------------------------
# _BNFreeQualifiedNameTypeAndId

_BNFreeQualifiedNameTypeAndId = core.BNFreeQualifiedNameTypeAndId
_BNFreeQualifiedNameTypeAndId.restype = None
_BNFreeQualifiedNameTypeAndId.argtypes = [
		ctypes.POINTER(BNQualifiedNameTypeAndId),
	]


# noinspection PyPep8Naming
def BNFreeQualifiedNameTypeAndId(
		obj: ctypes.POINTER(BNQualifiedNameTypeAndId)
		) -> None:
	return _BNFreeQualifiedNameTypeAndId(obj)


# -------------------------------------------------------
# _BNFreeRegisterList

_BNFreeRegisterList = core.BNFreeRegisterList
_BNFreeRegisterList.restype = None
_BNFreeRegisterList.argtypes = [
		ctypes.POINTER(ctypes.c_uint),
	]


# noinspection PyPep8Naming
def BNFreeRegisterList(
		regs: ctypes.POINTER(ctypes.c_uint)
		) -> None:
	return _BNFreeRegisterList(regs)


# -------------------------------------------------------
# _BNFreeRegisterSet

_BNFreeRegisterSet = core.BNFreeRegisterSet
_BNFreeRegisterSet.restype = None
_BNFreeRegisterSet.argtypes = [
		ctypes.POINTER(BNRegisterSetWithConfidence),
	]


# noinspection PyPep8Naming
def BNFreeRegisterSet(
		regs: ctypes.POINTER(BNRegisterSetWithConfidence)
		) -> None:
	return _BNFreeRegisterSet(regs)


# -------------------------------------------------------
# _BNFreeRegisterStackAdjustments

_BNFreeRegisterStackAdjustments = core.BNFreeRegisterStackAdjustments
_BNFreeRegisterStackAdjustments.restype = None
_BNFreeRegisterStackAdjustments.argtypes = [
		ctypes.POINTER(BNRegisterStackAdjustment),
	]


# noinspection PyPep8Naming
def BNFreeRegisterStackAdjustments(
		adjustments: ctypes.POINTER(BNRegisterStackAdjustment)
		) -> None:
	return _BNFreeRegisterStackAdjustments(adjustments)


# -------------------------------------------------------
# _BNFreeRelocation

_BNFreeRelocation = core.BNFreeRelocation
_BNFreeRelocation.restype = None
_BNFreeRelocation.argtypes = [
		ctypes.POINTER(BNRelocation),
	]


# noinspection PyPep8Naming
def BNFreeRelocation(
		reloc: ctypes.POINTER(BNRelocation)
		) -> None:
	return _BNFreeRelocation(reloc)


# -------------------------------------------------------
# _BNFreeRelocationHandler

_BNFreeRelocationHandler = core.BNFreeRelocationHandler
_BNFreeRelocationHandler.restype = None
_BNFreeRelocationHandler.argtypes = [
		ctypes.POINTER(BNRelocationHandler),
	]


# noinspection PyPep8Naming
def BNFreeRelocationHandler(
		handler: ctypes.POINTER(BNRelocationHandler)
		) -> None:
	return _BNFreeRelocationHandler(handler)


# -------------------------------------------------------
# _BNFreeRelocationList

_BNFreeRelocationList = core.BNFreeRelocationList
_BNFreeRelocationList.restype = None
_BNFreeRelocationList.argtypes = [
		ctypes.POINTER(ctypes.POINTER(BNRelocation)),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNFreeRelocationList(
		relocations: ctypes.POINTER(ctypes.POINTER(BNRelocation)), 
		count: int
		) -> None:
	return _BNFreeRelocationList(relocations, count)


# -------------------------------------------------------
# _BNFreeRelocationRanges

_BNFreeRelocationRanges = core.BNFreeRelocationRanges
_BNFreeRelocationRanges.restype = None
_BNFreeRelocationRanges.argtypes = [
		ctypes.POINTER(BNRange),
	]


# noinspection PyPep8Naming
def BNFreeRelocationRanges(
		ranges: ctypes.POINTER(BNRange)
		) -> None:
	return _BNFreeRelocationRanges(ranges)


# -------------------------------------------------------
# _BNFreeReportCollection

_BNFreeReportCollection = core.BNFreeReportCollection
_BNFreeReportCollection.restype = None
_BNFreeReportCollection.argtypes = [
		ctypes.POINTER(BNReportCollection),
	]


# noinspection PyPep8Naming
def BNFreeReportCollection(
		reports: ctypes.POINTER(BNReportCollection)
		) -> None:
	return _BNFreeReportCollection(reports)


# -------------------------------------------------------
# _BNFreeRepository

_BNFreeRepository = core.BNFreeRepository
_BNFreeRepository.restype = None
_BNFreeRepository.argtypes = [
		ctypes.POINTER(BNRepository),
	]


# noinspection PyPep8Naming
def BNFreeRepository(
		r: ctypes.POINTER(BNRepository)
		) -> None:
	return _BNFreeRepository(r)


# -------------------------------------------------------
# _BNFreeRepositoryManager

_BNFreeRepositoryManager = core.BNFreeRepositoryManager
_BNFreeRepositoryManager.restype = None
_BNFreeRepositoryManager.argtypes = [
		ctypes.POINTER(BNRepositoryManager),
	]


# noinspection PyPep8Naming
def BNFreeRepositoryManager(
		r: ctypes.POINTER(BNRepositoryManager)
		) -> None:
	return _BNFreeRepositoryManager(r)


# -------------------------------------------------------
# _BNFreeRepositoryManagerRepositoriesList

_BNFreeRepositoryManagerRepositoriesList = core.BNFreeRepositoryManagerRepositoriesList
_BNFreeRepositoryManagerRepositoriesList.restype = None
_BNFreeRepositoryManagerRepositoriesList.argtypes = [
		ctypes.POINTER(ctypes.POINTER(BNRepository)),
	]


# noinspection PyPep8Naming
def BNFreeRepositoryManagerRepositoriesList(
		r: ctypes.POINTER(ctypes.POINTER(BNRepository))
		) -> None:
	return _BNFreeRepositoryManagerRepositoriesList(r)


# -------------------------------------------------------
# _BNFreeRepositoryPluginList

_BNFreeRepositoryPluginList = core.BNFreeRepositoryPluginList
_BNFreeRepositoryPluginList.restype = None
_BNFreeRepositoryPluginList.argtypes = [
		ctypes.POINTER(ctypes.POINTER(BNRepoPlugin)),
	]


# noinspection PyPep8Naming
def BNFreeRepositoryPluginList(
		r: ctypes.POINTER(ctypes.POINTER(BNRepoPlugin))
		) -> None:
	return _BNFreeRepositoryPluginList(r)


# -------------------------------------------------------
# _BNFreeSaveSettings

_BNFreeSaveSettings = core.BNFreeSaveSettings
_BNFreeSaveSettings.restype = None
_BNFreeSaveSettings.argtypes = [
		ctypes.POINTER(BNSaveSettings),
	]


# noinspection PyPep8Naming
def BNFreeSaveSettings(
		settings: ctypes.POINTER(BNSaveSettings)
		) -> None:
	return _BNFreeSaveSettings(settings)


# -------------------------------------------------------
# _BNFreeScriptingInstance

_BNFreeScriptingInstance = core.BNFreeScriptingInstance
_BNFreeScriptingInstance.restype = None
_BNFreeScriptingInstance.argtypes = [
		ctypes.POINTER(BNScriptingInstance),
	]


# noinspection PyPep8Naming
def BNFreeScriptingInstance(
		instance: ctypes.POINTER(BNScriptingInstance)
		) -> None:
	return _BNFreeScriptingInstance(instance)


# -------------------------------------------------------
# _BNFreeScriptingProviderList

_BNFreeScriptingProviderList = core.BNFreeScriptingProviderList
_BNFreeScriptingProviderList.restype = None
_BNFreeScriptingProviderList.argtypes = [
		ctypes.POINTER(ctypes.POINTER(BNScriptingProvider)),
	]


# noinspection PyPep8Naming
def BNFreeScriptingProviderList(
		providers: ctypes.POINTER(ctypes.POINTER(BNScriptingProvider))
		) -> None:
	return _BNFreeScriptingProviderList(providers)


# -------------------------------------------------------
# _BNFreeSecretsProviderList

_BNFreeSecretsProviderList = core.BNFreeSecretsProviderList
_BNFreeSecretsProviderList.restype = None
_BNFreeSecretsProviderList.argtypes = [
		ctypes.POINTER(ctypes.POINTER(BNSecretsProvider)),
	]


# noinspection PyPep8Naming
def BNFreeSecretsProviderList(
		providers: ctypes.POINTER(ctypes.POINTER(BNSecretsProvider))
		) -> None:
	return _BNFreeSecretsProviderList(providers)


# -------------------------------------------------------
# _BNFreeSection

_BNFreeSection = core.BNFreeSection
_BNFreeSection.restype = None
_BNFreeSection.argtypes = [
		ctypes.POINTER(BNSection),
	]


# noinspection PyPep8Naming
def BNFreeSection(
		section: ctypes.POINTER(BNSection)
		) -> None:
	return _BNFreeSection(section)


# -------------------------------------------------------
# _BNFreeSectionList

_BNFreeSectionList = core.BNFreeSectionList
_BNFreeSectionList.restype = None
_BNFreeSectionList.argtypes = [
		ctypes.POINTER(ctypes.POINTER(BNSection)),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNFreeSectionList(
		sections: ctypes.POINTER(ctypes.POINTER(BNSection)), 
		count: int
		) -> None:
	return _BNFreeSectionList(sections, count)


# -------------------------------------------------------
# _BNFreeSegment

_BNFreeSegment = core.BNFreeSegment
_BNFreeSegment.restype = None
_BNFreeSegment.argtypes = [
		ctypes.POINTER(BNSegment),
	]


# noinspection PyPep8Naming
def BNFreeSegment(
		seg: ctypes.POINTER(BNSegment)
		) -> None:
	return _BNFreeSegment(seg)


# -------------------------------------------------------
# _BNFreeSegmentList

_BNFreeSegmentList = core.BNFreeSegmentList
_BNFreeSegmentList.restype = None
_BNFreeSegmentList.argtypes = [
		ctypes.POINTER(ctypes.POINTER(BNSegment)),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNFreeSegmentList(
		segments: ctypes.POINTER(ctypes.POINTER(BNSegment)), 
		count: int
		) -> None:
	return _BNFreeSegmentList(segments, count)


# -------------------------------------------------------
# _BNFreeSettings

_BNFreeSettings = core.BNFreeSettings
_BNFreeSettings.restype = None
_BNFreeSettings.argtypes = [
		ctypes.POINTER(BNSettings),
	]


# noinspection PyPep8Naming
def BNFreeSettings(
		settings: ctypes.POINTER(BNSettings)
		) -> None:
	return _BNFreeSettings(settings)


# -------------------------------------------------------
# _BNFreeSnapshot

_BNFreeSnapshot = core.BNFreeSnapshot
_BNFreeSnapshot.restype = None
_BNFreeSnapshot.argtypes = [
		ctypes.POINTER(BNSnapshot),
	]


# noinspection PyPep8Naming
def BNFreeSnapshot(
		snapshot: ctypes.POINTER(BNSnapshot)
		) -> None:
	return _BNFreeSnapshot(snapshot)


# -------------------------------------------------------
# _BNFreeSnapshotList

_BNFreeSnapshotList = core.BNFreeSnapshotList
_BNFreeSnapshotList.restype = None
_BNFreeSnapshotList.argtypes = [
		ctypes.POINTER(ctypes.POINTER(BNSnapshot)),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNFreeSnapshotList(
		snapshots: ctypes.POINTER(ctypes.POINTER(BNSnapshot)), 
		count: int
		) -> None:
	return _BNFreeSnapshotList(snapshots, count)


# -------------------------------------------------------
# _BNFreeStackVariableReferenceList

_BNFreeStackVariableReferenceList = core.BNFreeStackVariableReferenceList
_BNFreeStackVariableReferenceList.restype = None
_BNFreeStackVariableReferenceList.argtypes = [
		ctypes.POINTER(BNStackVariableReference),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNFreeStackVariableReferenceList(
		refs: ctypes.POINTER(BNStackVariableReference), 
		count: int
		) -> None:
	return _BNFreeStackVariableReferenceList(refs, count)


# -------------------------------------------------------
# _BNFreeString

_BNFreeString = core.BNFreeString
_BNFreeString.restype = None
_BNFreeString.argtypes = [
		ctypes.POINTER(ctypes.c_byte),
	]


# noinspection PyPep8Naming
def BNFreeString(
		str: ctypes.c_char_p
		) -> None:
	return _BNFreeString(str)


# -------------------------------------------------------
# _BNFreeStringList

_BNFreeStringList = core.BNFreeStringList
_BNFreeStringList.restype = None
_BNFreeStringList.argtypes = [
		ctypes.POINTER(ctypes.c_char_p),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNFreeStringList(
		strs: ctypes.POINTER(ctypes.c_char_p), 
		count: int
		) -> None:
	return _BNFreeStringList(strs, count)


# -------------------------------------------------------
# _BNFreeStringReferenceList

_BNFreeStringReferenceList = core.BNFreeStringReferenceList
_BNFreeStringReferenceList.restype = None
_BNFreeStringReferenceList.argtypes = [
		ctypes.POINTER(BNStringReference),
	]


# noinspection PyPep8Naming
def BNFreeStringReferenceList(
		strings: ctypes.POINTER(BNStringReference)
		) -> None:
	return _BNFreeStringReferenceList(strings)


# -------------------------------------------------------
# _BNFreeStructure

_BNFreeStructure = core.BNFreeStructure
_BNFreeStructure.restype = None
_BNFreeStructure.argtypes = [
		ctypes.POINTER(BNStructure),
	]


# noinspection PyPep8Naming
def BNFreeStructure(
		s: ctypes.POINTER(BNStructure)
		) -> None:
	return _BNFreeStructure(s)


# -------------------------------------------------------
# _BNFreeStructureBuilder

_BNFreeStructureBuilder = core.BNFreeStructureBuilder
_BNFreeStructureBuilder.restype = None
_BNFreeStructureBuilder.argtypes = [
		ctypes.POINTER(BNStructureBuilder),
	]


# noinspection PyPep8Naming
def BNFreeStructureBuilder(
		s: ctypes.POINTER(BNStructureBuilder)
		) -> None:
	return _BNFreeStructureBuilder(s)


# -------------------------------------------------------
# _BNFreeStructureMember

_BNFreeStructureMember = core.BNFreeStructureMember
_BNFreeStructureMember.restype = None
_BNFreeStructureMember.argtypes = [
		ctypes.POINTER(BNStructureMember),
	]


# noinspection PyPep8Naming
def BNFreeStructureMember(
		s: ctypes.POINTER(BNStructureMember)
		) -> None:
	return _BNFreeStructureMember(s)


# -------------------------------------------------------
# _BNFreeStructureMemberList

_BNFreeStructureMemberList = core.BNFreeStructureMemberList
_BNFreeStructureMemberList.restype = None
_BNFreeStructureMemberList.argtypes = [
		ctypes.POINTER(BNStructureMember),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNFreeStructureMemberList(
		members: ctypes.POINTER(BNStructureMember), 
		count: int
		) -> None:
	return _BNFreeStructureMemberList(members, count)


# -------------------------------------------------------
# _BNFreeSymbol

_BNFreeSymbol = core.BNFreeSymbol
_BNFreeSymbol.restype = None
_BNFreeSymbol.argtypes = [
		ctypes.POINTER(BNSymbol),
	]


# noinspection PyPep8Naming
def BNFreeSymbol(
		sym: ctypes.POINTER(BNSymbol)
		) -> None:
	return _BNFreeSymbol(sym)


# -------------------------------------------------------
# _BNFreeSymbolList

_BNFreeSymbolList = core.BNFreeSymbolList
_BNFreeSymbolList.restype = None
_BNFreeSymbolList.argtypes = [
		ctypes.POINTER(ctypes.POINTER(BNSymbol)),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNFreeSymbolList(
		syms: ctypes.POINTER(ctypes.POINTER(BNSymbol)), 
		count: int
		) -> None:
	return _BNFreeSymbolList(syms, count)


# -------------------------------------------------------
# _BNFreeSymbolRawBytes

_BNFreeSymbolRawBytes = core.BNFreeSymbolRawBytes
_BNFreeSymbolRawBytes.restype = None
_BNFreeSymbolRawBytes.argtypes = [
		ctypes.c_void_p,
	]


# noinspection PyPep8Naming
def BNFreeSymbolRawBytes(
		bytes: Optional[ctypes.c_void_p]
		) -> None:
	return _BNFreeSymbolRawBytes(bytes)


# -------------------------------------------------------
# _BNFreeSystemCallList

_BNFreeSystemCallList = core.BNFreeSystemCallList
_BNFreeSystemCallList.restype = None
_BNFreeSystemCallList.argtypes = [
		ctypes.POINTER(BNSystemCallInfo),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNFreeSystemCallList(
		syscalls: ctypes.POINTER(BNSystemCallInfo), 
		count: int
		) -> None:
	return _BNFreeSystemCallList(syscalls, count)


# -------------------------------------------------------
# _BNFreeTag

_BNFreeTag = core.BNFreeTag
_BNFreeTag.restype = None
_BNFreeTag.argtypes = [
		ctypes.POINTER(BNTag),
	]


# noinspection PyPep8Naming
def BNFreeTag(
		tag: ctypes.POINTER(BNTag)
		) -> None:
	return _BNFreeTag(tag)


# -------------------------------------------------------
# _BNFreeTagList

_BNFreeTagList = core.BNFreeTagList
_BNFreeTagList.restype = None
_BNFreeTagList.argtypes = [
		ctypes.POINTER(ctypes.POINTER(BNTag)),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNFreeTagList(
		tags: ctypes.POINTER(ctypes.POINTER(BNTag)), 
		count: int
		) -> None:
	return _BNFreeTagList(tags, count)


# -------------------------------------------------------
# _BNFreeTagReferenceTypeCounts

_BNFreeTagReferenceTypeCounts = core.BNFreeTagReferenceTypeCounts
_BNFreeTagReferenceTypeCounts.restype = None
_BNFreeTagReferenceTypeCounts.argtypes = [
		ctypes.POINTER(ctypes.POINTER(BNTagType)),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNFreeTagReferenceTypeCounts(
		tagTypes: ctypes.POINTER(ctypes.POINTER(BNTagType)), 
		counts: ctypes.POINTER(ctypes.c_ulonglong)
		) -> None:
	return _BNFreeTagReferenceTypeCounts(tagTypes, counts)


# -------------------------------------------------------
# _BNFreeTagReferences

_BNFreeTagReferences = core.BNFreeTagReferences
_BNFreeTagReferences.restype = None
_BNFreeTagReferences.argtypes = [
		ctypes.POINTER(BNTagReference),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNFreeTagReferences(
		refs: ctypes.POINTER(BNTagReference), 
		count: int
		) -> None:
	return _BNFreeTagReferences(refs, count)


# -------------------------------------------------------
# _BNFreeTagType

_BNFreeTagType = core.BNFreeTagType
_BNFreeTagType.restype = None
_BNFreeTagType.argtypes = [
		ctypes.POINTER(BNTagType),
	]


# noinspection PyPep8Naming
def BNFreeTagType(
		tagType: ctypes.POINTER(BNTagType)
		) -> None:
	return _BNFreeTagType(tagType)


# -------------------------------------------------------
# _BNFreeTagTypeList

_BNFreeTagTypeList = core.BNFreeTagTypeList
_BNFreeTagTypeList.restype = None
_BNFreeTagTypeList.argtypes = [
		ctypes.POINTER(ctypes.POINTER(BNTagType)),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNFreeTagTypeList(
		tagTypes: ctypes.POINTER(ctypes.POINTER(BNTagType)), 
		count: int
		) -> None:
	return _BNFreeTagTypeList(tagTypes, count)


# -------------------------------------------------------
# _BNFreeTemporaryFile

_BNFreeTemporaryFile = core.BNFreeTemporaryFile
_BNFreeTemporaryFile.restype = None
_BNFreeTemporaryFile.argtypes = [
		ctypes.POINTER(BNTemporaryFile),
	]


# noinspection PyPep8Naming
def BNFreeTemporaryFile(
		file: ctypes.POINTER(BNTemporaryFile)
		) -> None:
	return _BNFreeTemporaryFile(file)


# -------------------------------------------------------
# _BNFreeTransformParameterList

_BNFreeTransformParameterList = core.BNFreeTransformParameterList
_BNFreeTransformParameterList.restype = None
_BNFreeTransformParameterList.argtypes = [
		ctypes.POINTER(BNTransformParameterInfo),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNFreeTransformParameterList(
		params: ctypes.POINTER(BNTransformParameterInfo), 
		count: int
		) -> None:
	return _BNFreeTransformParameterList(params, count)


# -------------------------------------------------------
# _BNFreeTransformTypeList

_BNFreeTransformTypeList = core.BNFreeTransformTypeList
_BNFreeTransformTypeList.restype = None
_BNFreeTransformTypeList.argtypes = [
		ctypes.POINTER(ctypes.POINTER(BNTransform)),
	]


# noinspection PyPep8Naming
def BNFreeTransformTypeList(
		xforms: ctypes.POINTER(ctypes.POINTER(BNTransform))
		) -> None:
	return _BNFreeTransformTypeList(xforms)


# -------------------------------------------------------
# _BNFreeType

_BNFreeType = core.BNFreeType
_BNFreeType.restype = None
_BNFreeType.argtypes = [
		ctypes.POINTER(BNType),
	]


# noinspection PyPep8Naming
def BNFreeType(
		type: ctypes.POINTER(BNType)
		) -> None:
	return _BNFreeType(type)


# -------------------------------------------------------
# _BNFreeTypeAndNameList

_BNFreeTypeAndNameList = core.BNFreeTypeAndNameList
_BNFreeTypeAndNameList.restype = None
_BNFreeTypeAndNameList.argtypes = [
		ctypes.POINTER(BNQualifiedNameAndType),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNFreeTypeAndNameList(
		types: ctypes.POINTER(BNQualifiedNameAndType), 
		count: int
		) -> None:
	return _BNFreeTypeAndNameList(types, count)


# -------------------------------------------------------
# _BNFreeTypeArchiveList

_BNFreeTypeArchiveList = core.BNFreeTypeArchiveList
_BNFreeTypeArchiveList.restype = None
_BNFreeTypeArchiveList.argtypes = [
		ctypes.POINTER(ctypes.POINTER(BNTypeArchive)),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNFreeTypeArchiveList(
		archives: ctypes.POINTER(ctypes.POINTER(BNTypeArchive)), 
		count: int
		) -> None:
	return _BNFreeTypeArchiveList(archives, count)


# -------------------------------------------------------
# _BNFreeTypeArchiveReference

_BNFreeTypeArchiveReference = core.BNFreeTypeArchiveReference
_BNFreeTypeArchiveReference.restype = None
_BNFreeTypeArchiveReference.argtypes = [
		ctypes.POINTER(BNTypeArchive),
	]


# noinspection PyPep8Naming
def BNFreeTypeArchiveReference(
		archive: ctypes.POINTER(BNTypeArchive)
		) -> None:
	return _BNFreeTypeArchiveReference(archive)


# -------------------------------------------------------
# _BNFreeTypeBuilder

_BNFreeTypeBuilder = core.BNFreeTypeBuilder
_BNFreeTypeBuilder.restype = None
_BNFreeTypeBuilder.argtypes = [
		ctypes.POINTER(BNTypeBuilder),
	]


# noinspection PyPep8Naming
def BNFreeTypeBuilder(
		type: ctypes.POINTER(BNTypeBuilder)
		) -> None:
	return _BNFreeTypeBuilder(type)


# -------------------------------------------------------
# _BNFreeTypeContainer

_BNFreeTypeContainer = core.BNFreeTypeContainer
_BNFreeTypeContainer.restype = None
_BNFreeTypeContainer.argtypes = [
		ctypes.POINTER(BNTypeContainer),
	]


# noinspection PyPep8Naming
def BNFreeTypeContainer(
		container: ctypes.POINTER(BNTypeContainer)
		) -> None:
	return _BNFreeTypeContainer(container)


# -------------------------------------------------------
# _BNFreeTypeDefinitionLineList

_BNFreeTypeDefinitionLineList = core.BNFreeTypeDefinitionLineList
_BNFreeTypeDefinitionLineList.restype = None
_BNFreeTypeDefinitionLineList.argtypes = [
		ctypes.POINTER(BNTypeDefinitionLine),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNFreeTypeDefinitionLineList(
		list: ctypes.POINTER(BNTypeDefinitionLine), 
		count: int
		) -> None:
	return _BNFreeTypeDefinitionLineList(list, count)


# -------------------------------------------------------
# _BNFreeTypeFieldReferenceSizeInfo

_BNFreeTypeFieldReferenceSizeInfo = core.BNFreeTypeFieldReferenceSizeInfo
_BNFreeTypeFieldReferenceSizeInfo.restype = None
_BNFreeTypeFieldReferenceSizeInfo.argtypes = [
		ctypes.POINTER(BNTypeFieldReferenceSizeInfo),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNFreeTypeFieldReferenceSizeInfo(
		refs: ctypes.POINTER(BNTypeFieldReferenceSizeInfo), 
		count: int
		) -> None:
	return _BNFreeTypeFieldReferenceSizeInfo(refs, count)


# -------------------------------------------------------
# _BNFreeTypeFieldReferenceSizes

_BNFreeTypeFieldReferenceSizes = core.BNFreeTypeFieldReferenceSizes
_BNFreeTypeFieldReferenceSizes.restype = None
_BNFreeTypeFieldReferenceSizes.argtypes = [
		ctypes.POINTER(ctypes.c_ulonglong),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNFreeTypeFieldReferenceSizes(
		refs: ctypes.POINTER(ctypes.c_ulonglong), 
		count: int
		) -> None:
	return _BNFreeTypeFieldReferenceSizes(refs, count)


# -------------------------------------------------------
# _BNFreeTypeFieldReferenceTypeInfo

_BNFreeTypeFieldReferenceTypeInfo = core.BNFreeTypeFieldReferenceTypeInfo
_BNFreeTypeFieldReferenceTypeInfo.restype = None
_BNFreeTypeFieldReferenceTypeInfo.argtypes = [
		ctypes.POINTER(BNTypeFieldReferenceTypeInfo),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNFreeTypeFieldReferenceTypeInfo(
		refs: ctypes.POINTER(BNTypeFieldReferenceTypeInfo), 
		count: int
		) -> None:
	return _BNFreeTypeFieldReferenceTypeInfo(refs, count)


# -------------------------------------------------------
# _BNFreeTypeFieldReferenceTypes

_BNFreeTypeFieldReferenceTypes = core.BNFreeTypeFieldReferenceTypes
_BNFreeTypeFieldReferenceTypes.restype = None
_BNFreeTypeFieldReferenceTypes.argtypes = [
		ctypes.POINTER(BNTypeWithConfidence),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNFreeTypeFieldReferenceTypes(
		refs: ctypes.POINTER(BNTypeWithConfidence), 
		count: int
		) -> None:
	return _BNFreeTypeFieldReferenceTypes(refs, count)


# -------------------------------------------------------
# _BNFreeTypeFieldReferences

_BNFreeTypeFieldReferences = core.BNFreeTypeFieldReferences
_BNFreeTypeFieldReferences.restype = None
_BNFreeTypeFieldReferences.argtypes = [
		ctypes.POINTER(BNTypeFieldReference),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNFreeTypeFieldReferences(
		refs: ctypes.POINTER(BNTypeFieldReference), 
		count: int
		) -> None:
	return _BNFreeTypeFieldReferences(refs, count)


# -------------------------------------------------------
# _BNFreeTypeIdList

_BNFreeTypeIdList = core.BNFreeTypeIdList
_BNFreeTypeIdList.restype = None
_BNFreeTypeIdList.argtypes = [
		ctypes.POINTER(BNQualifiedNameTypeAndId),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNFreeTypeIdList(
		types: ctypes.POINTER(BNQualifiedNameTypeAndId), 
		count: int
		) -> None:
	return _BNFreeTypeIdList(types, count)


# -------------------------------------------------------
# _BNFreeTypeLibrary

_BNFreeTypeLibrary = core.BNFreeTypeLibrary
_BNFreeTypeLibrary.restype = None
_BNFreeTypeLibrary.argtypes = [
		ctypes.POINTER(BNTypeLibrary),
	]


# noinspection PyPep8Naming
def BNFreeTypeLibrary(
		lib: ctypes.POINTER(BNTypeLibrary)
		) -> None:
	return _BNFreeTypeLibrary(lib)


# -------------------------------------------------------
# _BNFreeTypeLibraryList

_BNFreeTypeLibraryList = core.BNFreeTypeLibraryList
_BNFreeTypeLibraryList.restype = None
_BNFreeTypeLibraryList.argtypes = [
		ctypes.POINTER(ctypes.POINTER(BNTypeLibrary)),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNFreeTypeLibraryList(
		lib: ctypes.POINTER(ctypes.POINTER(BNTypeLibrary)), 
		count: int
		) -> None:
	return _BNFreeTypeLibraryList(lib, count)


# -------------------------------------------------------
# _BNFreeTypeList

_BNFreeTypeList = core.BNFreeTypeList
_BNFreeTypeList.restype = None
_BNFreeTypeList.argtypes = [
		ctypes.POINTER(ctypes.POINTER(BNType)),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNFreeTypeList(
		types: ctypes.POINTER(ctypes.POINTER(BNType)), 
		count: int
		) -> None:
	return _BNFreeTypeList(types, count)


# -------------------------------------------------------
# _BNFreeTypeNameList

_BNFreeTypeNameList = core.BNFreeTypeNameList
_BNFreeTypeNameList.restype = None
_BNFreeTypeNameList.argtypes = [
		ctypes.POINTER(BNQualifiedName),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNFreeTypeNameList(
		names: ctypes.POINTER(BNQualifiedName), 
		count: int
		) -> None:
	return _BNFreeTypeNameList(names, count)


# -------------------------------------------------------
# _BNFreeTypeParameterList

_BNFreeTypeParameterList = core.BNFreeTypeParameterList
_BNFreeTypeParameterList.restype = None
_BNFreeTypeParameterList.argtypes = [
		ctypes.POINTER(BNFunctionParameter),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNFreeTypeParameterList(
		types: ctypes.POINTER(BNFunctionParameter), 
		count: int
		) -> None:
	return _BNFreeTypeParameterList(types, count)


# -------------------------------------------------------
# _BNFreeTypeParserErrors

_BNFreeTypeParserErrors = core.BNFreeTypeParserErrors
_BNFreeTypeParserErrors.restype = None
_BNFreeTypeParserErrors.argtypes = [
		ctypes.POINTER(BNTypeParserError),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNFreeTypeParserErrors(
		errors: ctypes.POINTER(BNTypeParserError), 
		count: int
		) -> None:
	return _BNFreeTypeParserErrors(errors, count)


# -------------------------------------------------------
# _BNFreeTypeParserList

_BNFreeTypeParserList = core.BNFreeTypeParserList
_BNFreeTypeParserList.restype = None
_BNFreeTypeParserList.argtypes = [
		ctypes.POINTER(ctypes.POINTER(BNTypeParser)),
	]


# noinspection PyPep8Naming
def BNFreeTypeParserList(
		parsers: ctypes.POINTER(ctypes.POINTER(BNTypeParser))
		) -> None:
	return _BNFreeTypeParserList(parsers)


# -------------------------------------------------------
# _BNFreeTypeParserResult

_BNFreeTypeParserResult = core.BNFreeTypeParserResult
_BNFreeTypeParserResult.restype = None
_BNFreeTypeParserResult.argtypes = [
		ctypes.POINTER(BNTypeParserResult),
	]


# noinspection PyPep8Naming
def BNFreeTypeParserResult(
		result: ctypes.POINTER(BNTypeParserResult)
		) -> None:
	return _BNFreeTypeParserResult(result)


# -------------------------------------------------------
# _BNFreeTypePrinterList

_BNFreeTypePrinterList = core.BNFreeTypePrinterList
_BNFreeTypePrinterList.restype = None
_BNFreeTypePrinterList.argtypes = [
		ctypes.POINTER(ctypes.POINTER(BNTypePrinter)),
	]


# noinspection PyPep8Naming
def BNFreeTypePrinterList(
		printers: ctypes.POINTER(ctypes.POINTER(BNTypePrinter))
		) -> None:
	return _BNFreeTypePrinterList(printers)


# -------------------------------------------------------
# _BNFreeTypeReferences

_BNFreeTypeReferences = core.BNFreeTypeReferences
_BNFreeTypeReferences.restype = None
_BNFreeTypeReferences.argtypes = [
		ctypes.POINTER(BNTypeReferenceSource),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNFreeTypeReferences(
		refs: ctypes.POINTER(BNTypeReferenceSource), 
		count: int
		) -> None:
	return _BNFreeTypeReferences(refs, count)


# -------------------------------------------------------
# _BNFreeUndoEntries

_BNFreeUndoEntries = core.BNFreeUndoEntries
_BNFreeUndoEntries.restype = None
_BNFreeUndoEntries.argtypes = [
		ctypes.POINTER(BNUndoEntry),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNFreeUndoEntries(
		entries: ctypes.POINTER(BNUndoEntry), 
		count: int
		) -> None:
	return _BNFreeUndoEntries(entries, count)


# -------------------------------------------------------
# _BNFreeUpdateChannelList

_BNFreeUpdateChannelList = core.BNFreeUpdateChannelList
_BNFreeUpdateChannelList.restype = None
_BNFreeUpdateChannelList.argtypes = [
		ctypes.POINTER(BNUpdateChannel),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNFreeUpdateChannelList(
		list: ctypes.POINTER(BNUpdateChannel), 
		count: int
		) -> None:
	return _BNFreeUpdateChannelList(list, count)


# -------------------------------------------------------
# _BNFreeUpdateChannelVersionList

_BNFreeUpdateChannelVersionList = core.BNFreeUpdateChannelVersionList
_BNFreeUpdateChannelVersionList.restype = None
_BNFreeUpdateChannelVersionList.argtypes = [
		ctypes.POINTER(BNUpdateVersion),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNFreeUpdateChannelVersionList(
		list: ctypes.POINTER(BNUpdateVersion), 
		count: int
		) -> None:
	return _BNFreeUpdateChannelVersionList(list, count)


# -------------------------------------------------------
# _BNFreeUser

_BNFreeUser = core.BNFreeUser
_BNFreeUser.restype = None
_BNFreeUser.argtypes = [
		ctypes.POINTER(BNUser),
	]


# noinspection PyPep8Naming
def BNFreeUser(
		user: ctypes.POINTER(BNUser)
		) -> None:
	return _BNFreeUser(user)


# -------------------------------------------------------
# _BNFreeUserList

_BNFreeUserList = core.BNFreeUserList
_BNFreeUserList.restype = None
_BNFreeUserList.argtypes = [
		ctypes.POINTER(ctypes.POINTER(BNUser)),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNFreeUserList(
		users: ctypes.POINTER(ctypes.POINTER(BNUser)), 
		count: int
		) -> None:
	return _BNFreeUserList(users, count)


# -------------------------------------------------------
# _BNFreeUserVariableValues

_BNFreeUserVariableValues = core.BNFreeUserVariableValues
_BNFreeUserVariableValues.restype = None
_BNFreeUserVariableValues.argtypes = [
		ctypes.POINTER(BNUserVariableValue),
	]


# noinspection PyPep8Naming
def BNFreeUserVariableValues(
		result: ctypes.POINTER(BNUserVariableValue)
		) -> None:
	return _BNFreeUserVariableValues(result)


# -------------------------------------------------------
# _BNFreeVariableList

_BNFreeVariableList = core.BNFreeVariableList
_BNFreeVariableList.restype = None
_BNFreeVariableList.argtypes = [
		ctypes.POINTER(BNVariable),
	]


# noinspection PyPep8Naming
def BNFreeVariableList(
		vars: ctypes.POINTER(BNVariable)
		) -> None:
	return _BNFreeVariableList(vars)


# -------------------------------------------------------
# _BNFreeVariableNameAndType

_BNFreeVariableNameAndType = core.BNFreeVariableNameAndType
_BNFreeVariableNameAndType.restype = None
_BNFreeVariableNameAndType.argtypes = [
		ctypes.POINTER(BNVariableNameAndType),
	]


# noinspection PyPep8Naming
def BNFreeVariableNameAndType(
		var: ctypes.POINTER(BNVariableNameAndType)
		) -> None:
	return _BNFreeVariableNameAndType(var)


# -------------------------------------------------------
# _BNFreeVariableNameAndTypeList

_BNFreeVariableNameAndTypeList = core.BNFreeVariableNameAndTypeList
_BNFreeVariableNameAndTypeList.restype = None
_BNFreeVariableNameAndTypeList.argtypes = [
		ctypes.POINTER(BNVariableNameAndType),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNFreeVariableNameAndTypeList(
		vars: ctypes.POINTER(BNVariableNameAndType), 
		count: int
		) -> None:
	return _BNFreeVariableNameAndTypeList(vars, count)


# -------------------------------------------------------
# _BNFreeVariableReferenceSourceList

_BNFreeVariableReferenceSourceList = core.BNFreeVariableReferenceSourceList
_BNFreeVariableReferenceSourceList.restype = None
_BNFreeVariableReferenceSourceList.argtypes = [
		ctypes.POINTER(BNVariableReferenceSource),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNFreeVariableReferenceSourceList(
		vars: ctypes.POINTER(BNVariableReferenceSource), 
		count: int
		) -> None:
	return _BNFreeVariableReferenceSourceList(vars, count)


# -------------------------------------------------------
# _BNFreeWebsocketClient

_BNFreeWebsocketClient = core.BNFreeWebsocketClient
_BNFreeWebsocketClient.restype = None
_BNFreeWebsocketClient.argtypes = [
		ctypes.POINTER(BNWebsocketClient),
	]


# noinspection PyPep8Naming
def BNFreeWebsocketClient(
		client: ctypes.POINTER(BNWebsocketClient)
		) -> None:
	return _BNFreeWebsocketClient(client)


# -------------------------------------------------------
# _BNFreeWebsocketProviderList

_BNFreeWebsocketProviderList = core.BNFreeWebsocketProviderList
_BNFreeWebsocketProviderList.restype = None
_BNFreeWebsocketProviderList.argtypes = [
		ctypes.POINTER(ctypes.POINTER(BNWebsocketProvider)),
	]


# noinspection PyPep8Naming
def BNFreeWebsocketProviderList(
		providers: ctypes.POINTER(ctypes.POINTER(BNWebsocketProvider))
		) -> None:
	return _BNFreeWebsocketProviderList(providers)


# -------------------------------------------------------
# _BNFreeWorkflow

_BNFreeWorkflow = core.BNFreeWorkflow
_BNFreeWorkflow.restype = None
_BNFreeWorkflow.argtypes = [
		ctypes.POINTER(BNWorkflow),
	]


# noinspection PyPep8Naming
def BNFreeWorkflow(
		workflow: ctypes.POINTER(BNWorkflow)
		) -> None:
	return _BNFreeWorkflow(workflow)


# -------------------------------------------------------
# _BNFreeWorkflowList

_BNFreeWorkflowList = core.BNFreeWorkflowList
_BNFreeWorkflowList.restype = None
_BNFreeWorkflowList.argtypes = [
		ctypes.POINTER(ctypes.POINTER(BNWorkflow)),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNFreeWorkflowList(
		workflows: ctypes.POINTER(ctypes.POINTER(BNWorkflow)), 
		count: int
		) -> None:
	return _BNFreeWorkflowList(workflows, count)


# -------------------------------------------------------
# _BNFromVariableIdentifier

_BNFromVariableIdentifier = core.BNFromVariableIdentifier
_BNFromVariableIdentifier.restype = BNVariable
_BNFromVariableIdentifier.argtypes = [
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNFromVariableIdentifier(
		id: int
		) -> BNVariable:
	return _BNFromVariableIdentifier(id)


# -------------------------------------------------------
# _BNFunctionHasExplicitlyDefinedType

_BNFunctionHasExplicitlyDefinedType = core.BNFunctionHasExplicitlyDefinedType
_BNFunctionHasExplicitlyDefinedType.restype = ctypes.c_bool
_BNFunctionHasExplicitlyDefinedType.argtypes = [
		ctypes.POINTER(BNFunction),
	]


# noinspection PyPep8Naming
def BNFunctionHasExplicitlyDefinedType(
		func: ctypes.POINTER(BNFunction)
		) -> bool:
	return _BNFunctionHasExplicitlyDefinedType(func)


# -------------------------------------------------------
# _BNFunctionHasUserAnnotations

_BNFunctionHasUserAnnotations = core.BNFunctionHasUserAnnotations
_BNFunctionHasUserAnnotations.restype = ctypes.c_bool
_BNFunctionHasUserAnnotations.argtypes = [
		ctypes.POINTER(BNFunction),
	]


# noinspection PyPep8Naming
def BNFunctionHasUserAnnotations(
		func: ctypes.POINTER(BNFunction)
		) -> bool:
	return _BNFunctionHasUserAnnotations(func)


# -------------------------------------------------------
# _BNFunctionHasUserType

_BNFunctionHasUserType = core.BNFunctionHasUserType
_BNFunctionHasUserType.restype = ctypes.c_bool
_BNFunctionHasUserType.argtypes = [
		ctypes.POINTER(BNFunction),
	]


# noinspection PyPep8Naming
def BNFunctionHasUserType(
		func: ctypes.POINTER(BNFunction)
		) -> bool:
	return _BNFunctionHasUserType(func)


# -------------------------------------------------------
# _BNFunctionHasVariableArguments

_BNFunctionHasVariableArguments = core.BNFunctionHasVariableArguments
_BNFunctionHasVariableArguments.restype = BNBoolWithConfidence
_BNFunctionHasVariableArguments.argtypes = [
		ctypes.POINTER(BNFunction),
	]


# noinspection PyPep8Naming
def BNFunctionHasVariableArguments(
		func: ctypes.POINTER(BNFunction)
		) -> BNBoolWithConfidence:
	return _BNFunctionHasVariableArguments(func)


# -------------------------------------------------------
# _BNFunctionTypeBuilderCanReturn

_BNFunctionTypeBuilderCanReturn = core.BNFunctionTypeBuilderCanReturn
_BNFunctionTypeBuilderCanReturn.restype = BNBoolWithConfidence
_BNFunctionTypeBuilderCanReturn.argtypes = [
		ctypes.POINTER(BNTypeBuilder),
	]


# noinspection PyPep8Naming
def BNFunctionTypeBuilderCanReturn(
		type: ctypes.POINTER(BNTypeBuilder)
		) -> BNBoolWithConfidence:
	return _BNFunctionTypeBuilderCanReturn(type)


# -------------------------------------------------------
# _BNFunctionTypeCanReturn

_BNFunctionTypeCanReturn = core.BNFunctionTypeCanReturn
_BNFunctionTypeCanReturn.restype = BNBoolWithConfidence
_BNFunctionTypeCanReturn.argtypes = [
		ctypes.POINTER(BNType),
	]


# noinspection PyPep8Naming
def BNFunctionTypeCanReturn(
		type: ctypes.POINTER(BNType)
		) -> BNBoolWithConfidence:
	return _BNFunctionTypeCanReturn(type)


# -------------------------------------------------------
# _BNGenerateAutoDebugTypeId

_BNGenerateAutoDebugTypeId = core.BNGenerateAutoDebugTypeId
_BNGenerateAutoDebugTypeId.restype = ctypes.POINTER(ctypes.c_byte)
_BNGenerateAutoDebugTypeId.argtypes = [
		ctypes.POINTER(BNQualifiedName),
	]


# noinspection PyPep8Naming
def BNGenerateAutoDebugTypeId(
		name: ctypes.POINTER(BNQualifiedName)
		) -> Optional[Optional[str]]:
	result = _BNGenerateAutoDebugTypeId(name)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGenerateAutoDemangledTypeId

_BNGenerateAutoDemangledTypeId = core.BNGenerateAutoDemangledTypeId
_BNGenerateAutoDemangledTypeId.restype = ctypes.POINTER(ctypes.c_byte)
_BNGenerateAutoDemangledTypeId.argtypes = [
		ctypes.POINTER(BNQualifiedName),
	]


# noinspection PyPep8Naming
def BNGenerateAutoDemangledTypeId(
		name: ctypes.POINTER(BNQualifiedName)
		) -> Optional[Optional[str]]:
	result = _BNGenerateAutoDemangledTypeId(name)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGenerateAutoPlatformTypeId

_BNGenerateAutoPlatformTypeId = core.BNGenerateAutoPlatformTypeId
_BNGenerateAutoPlatformTypeId.restype = ctypes.POINTER(ctypes.c_byte)
_BNGenerateAutoPlatformTypeId.argtypes = [
		ctypes.POINTER(BNPlatform),
		ctypes.POINTER(BNQualifiedName),
	]


# noinspection PyPep8Naming
def BNGenerateAutoPlatformTypeId(
		platform: ctypes.POINTER(BNPlatform), 
		name: ctypes.POINTER(BNQualifiedName)
		) -> Optional[Optional[str]]:
	result = _BNGenerateAutoPlatformTypeId(platform, name)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGenerateAutoTypeId

_BNGenerateAutoTypeId = core.BNGenerateAutoTypeId
_BNGenerateAutoTypeId.restype = ctypes.POINTER(ctypes.c_byte)
_BNGenerateAutoTypeId.argtypes = [
		ctypes.c_char_p,
		ctypes.POINTER(BNQualifiedName),
	]


# noinspection PyPep8Naming
def BNGenerateAutoTypeId(
		source: Optional[str], 
		name: ctypes.POINTER(BNQualifiedName)
		) -> Optional[Optional[str]]:
	result = _BNGenerateAutoTypeId(cstr(source), name)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGenerateHighLevelILSSAForm

_BNGenerateHighLevelILSSAForm = core.BNGenerateHighLevelILSSAForm
_BNGenerateHighLevelILSSAForm.restype = None
_BNGenerateHighLevelILSSAForm.argtypes = [
		ctypes.POINTER(BNHighLevelILFunction),
		ctypes.POINTER(BNVariable),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGenerateHighLevelILSSAForm(
		func: ctypes.POINTER(BNHighLevelILFunction), 
		aliases: ctypes.POINTER(BNVariable), 
		aliasCount: int
		) -> None:
	return _BNGenerateHighLevelILSSAForm(func, aliases, aliasCount)


# -------------------------------------------------------
# _BNGenerateLowLevelILSSAForm

_BNGenerateLowLevelILSSAForm = core.BNGenerateLowLevelILSSAForm
_BNGenerateLowLevelILSSAForm.restype = None
_BNGenerateLowLevelILSSAForm.argtypes = [
		ctypes.POINTER(BNLowLevelILFunction),
	]


# noinspection PyPep8Naming
def BNGenerateLowLevelILSSAForm(
		func: ctypes.POINTER(BNLowLevelILFunction)
		) -> None:
	return _BNGenerateLowLevelILSSAForm(func)


# -------------------------------------------------------
# _BNGenerateMediumLevelILSSAForm

_BNGenerateMediumLevelILSSAForm = core.BNGenerateMediumLevelILSSAForm
_BNGenerateMediumLevelILSSAForm.restype = None
_BNGenerateMediumLevelILSSAForm.argtypes = [
		ctypes.POINTER(BNMediumLevelILFunction),
		ctypes.c_bool,
		ctypes.c_bool,
		ctypes.POINTER(BNVariable),
		ctypes.c_ulonglong,
		ctypes.POINTER(BNVariable),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGenerateMediumLevelILSSAForm(
		func: ctypes.POINTER(BNMediumLevelILFunction), 
		analyzeConditionals: bool, 
		handleAliases: bool, 
		knownNotAliases: ctypes.POINTER(BNVariable), 
		knownNotAliasCount: int, 
		knownAliases: ctypes.POINTER(BNVariable), 
		knownAliasCount: int
		) -> None:
	return _BNGenerateMediumLevelILSSAForm(func, analyzeConditionals, handleAliases, knownNotAliases, knownNotAliasCount, knownAliases, knownAliasCount)


# -------------------------------------------------------
# _BNGetActiveUpdateChannel

_BNGetActiveUpdateChannel = core.BNGetActiveUpdateChannel
_BNGetActiveUpdateChannel.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetActiveUpdateChannel.argtypes = [
	]


# noinspection PyPep8Naming
def BNGetActiveUpdateChannel(
		) -> Optional[Optional[str]]:
	result = _BNGetActiveUpdateChannel()
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetAddressForDataOffset

_BNGetAddressForDataOffset = core.BNGetAddressForDataOffset
_BNGetAddressForDataOffset.restype = ctypes.c_bool
_BNGetAddressForDataOffset.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetAddressForDataOffset(
		view: ctypes.POINTER(BNBinaryView), 
		offset: int, 
		addr: ctypes.POINTER(ctypes.c_ulonglong)
		) -> bool:
	return _BNGetAddressForDataOffset(view, offset, addr)


# -------------------------------------------------------
# _BNGetAddressInput

_BNGetAddressInput = core.BNGetAddressInput
_BNGetAddressInput.restype = ctypes.c_bool
_BNGetAddressInput.argtypes = [
		ctypes.POINTER(ctypes.c_ulonglong),
		ctypes.c_char_p,
		ctypes.c_char_p,
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetAddressInput(
		result: ctypes.POINTER(ctypes.c_ulonglong), 
		prompt: Optional[str], 
		title: Optional[str], 
		view: ctypes.POINTER(BNBinaryView), 
		currentAddr: int
		) -> bool:
	return _BNGetAddressInput(result, cstr(prompt), cstr(title), view, currentAddr)


# -------------------------------------------------------
# _BNGetAddressRenderedWidth

_BNGetAddressRenderedWidth = core.BNGetAddressRenderedWidth
_BNGetAddressRenderedWidth.restype = ctypes.c_uint
_BNGetAddressRenderedWidth.argtypes = [
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetAddressRenderedWidth(
		addr: int
		) -> int:
	return _BNGetAddressRenderedWidth(addr)


# -------------------------------------------------------
# _BNGetAddressTagReferences

_BNGetAddressTagReferences = core.BNGetAddressTagReferences
_BNGetAddressTagReferences.restype = ctypes.POINTER(BNTagReference)
_BNGetAddressTagReferences.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetAddressTagReferences(
		func: ctypes.POINTER(BNFunction), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNTagReference)]:
	result = _BNGetAddressTagReferences(func, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetAddressTags

_BNGetAddressTags = core.BNGetAddressTags
_BNGetAddressTags.restype = ctypes.POINTER(ctypes.POINTER(BNTag))
_BNGetAddressTags.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNArchitecture),
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetAddressTags(
		func: ctypes.POINTER(BNFunction), 
		arch: ctypes.POINTER(BNArchitecture), 
		addr: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.POINTER(BNTag))]:
	result = _BNGetAddressTags(func, arch, addr, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetAddressTagsInRange

_BNGetAddressTagsInRange = core.BNGetAddressTagsInRange
_BNGetAddressTagsInRange.restype = ctypes.POINTER(BNTagReference)
_BNGetAddressTagsInRange.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNArchitecture),
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetAddressTagsInRange(
		func: ctypes.POINTER(BNFunction), 
		arch: ctypes.POINTER(BNArchitecture), 
		start: int, 
		end: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNTagReference)]:
	result = _BNGetAddressTagsInRange(func, arch, start, end, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetAddressTagsOfType

_BNGetAddressTagsOfType = core.BNGetAddressTagsOfType
_BNGetAddressTagsOfType.restype = ctypes.POINTER(ctypes.POINTER(BNTag))
_BNGetAddressTagsOfType.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNArchitecture),
		ctypes.c_ulonglong,
		ctypes.POINTER(BNTagType),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetAddressTagsOfType(
		func: ctypes.POINTER(BNFunction), 
		arch: ctypes.POINTER(BNArchitecture), 
		addr: int, 
		tagType: ctypes.POINTER(BNTagType), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.POINTER(BNTag))]:
	result = _BNGetAddressTagsOfType(func, arch, addr, tagType, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetAllAddressTagReferences

_BNGetAllAddressTagReferences = core.BNGetAllAddressTagReferences
_BNGetAllAddressTagReferences.restype = ctypes.POINTER(BNTagReference)
_BNGetAllAddressTagReferences.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetAllAddressTagReferences(
		view: ctypes.POINTER(BNBinaryView), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNTagReference)]:
	result = _BNGetAllAddressTagReferences(view, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetAllArchitectureFlagWriteTypes

_BNGetAllArchitectureFlagWriteTypes = core.BNGetAllArchitectureFlagWriteTypes
_BNGetAllArchitectureFlagWriteTypes.restype = ctypes.POINTER(ctypes.c_uint)
_BNGetAllArchitectureFlagWriteTypes.argtypes = [
		ctypes.POINTER(BNArchitecture),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetAllArchitectureFlagWriteTypes(
		arch: ctypes.POINTER(BNArchitecture), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_uint)]:
	result = _BNGetAllArchitectureFlagWriteTypes(arch, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetAllArchitectureFlags

_BNGetAllArchitectureFlags = core.BNGetAllArchitectureFlags
_BNGetAllArchitectureFlags.restype = ctypes.POINTER(ctypes.c_uint)
_BNGetAllArchitectureFlags.argtypes = [
		ctypes.POINTER(BNArchitecture),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetAllArchitectureFlags(
		arch: ctypes.POINTER(BNArchitecture), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_uint)]:
	result = _BNGetAllArchitectureFlags(arch, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetAllArchitectureIntrinsics

_BNGetAllArchitectureIntrinsics = core.BNGetAllArchitectureIntrinsics
_BNGetAllArchitectureIntrinsics.restype = ctypes.POINTER(ctypes.c_uint)
_BNGetAllArchitectureIntrinsics.argtypes = [
		ctypes.POINTER(BNArchitecture),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetAllArchitectureIntrinsics(
		arch: ctypes.POINTER(BNArchitecture), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_uint)]:
	result = _BNGetAllArchitectureIntrinsics(arch, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetAllArchitectureRegisterStacks

_BNGetAllArchitectureRegisterStacks = core.BNGetAllArchitectureRegisterStacks
_BNGetAllArchitectureRegisterStacks.restype = ctypes.POINTER(ctypes.c_uint)
_BNGetAllArchitectureRegisterStacks.argtypes = [
		ctypes.POINTER(BNArchitecture),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetAllArchitectureRegisterStacks(
		arch: ctypes.POINTER(BNArchitecture), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_uint)]:
	result = _BNGetAllArchitectureRegisterStacks(arch, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetAllArchitectureRegisters

_BNGetAllArchitectureRegisters = core.BNGetAllArchitectureRegisters
_BNGetAllArchitectureRegisters.restype = ctypes.POINTER(ctypes.c_uint)
_BNGetAllArchitectureRegisters.argtypes = [
		ctypes.POINTER(BNArchitecture),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetAllArchitectureRegisters(
		arch: ctypes.POINTER(BNArchitecture), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_uint)]:
	result = _BNGetAllArchitectureRegisters(arch, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetAllArchitectureSemanticFlagClasses

_BNGetAllArchitectureSemanticFlagClasses = core.BNGetAllArchitectureSemanticFlagClasses
_BNGetAllArchitectureSemanticFlagClasses.restype = ctypes.POINTER(ctypes.c_uint)
_BNGetAllArchitectureSemanticFlagClasses.argtypes = [
		ctypes.POINTER(BNArchitecture),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetAllArchitectureSemanticFlagClasses(
		arch: ctypes.POINTER(BNArchitecture), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_uint)]:
	result = _BNGetAllArchitectureSemanticFlagClasses(arch, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetAllArchitectureSemanticFlagGroups

_BNGetAllArchitectureSemanticFlagGroups = core.BNGetAllArchitectureSemanticFlagGroups
_BNGetAllArchitectureSemanticFlagGroups.restype = ctypes.POINTER(ctypes.c_uint)
_BNGetAllArchitectureSemanticFlagGroups.argtypes = [
		ctypes.POINTER(BNArchitecture),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetAllArchitectureSemanticFlagGroups(
		arch: ctypes.POINTER(BNArchitecture), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_uint)]:
	result = _BNGetAllArchitectureSemanticFlagGroups(arch, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetAllFieldsReferenced

_BNGetAllFieldsReferenced = core.BNGetAllFieldsReferenced
_BNGetAllFieldsReferenced.restype = ctypes.POINTER(ctypes.c_ulonglong)
_BNGetAllFieldsReferenced.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNQualifiedName),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetAllFieldsReferenced(
		view: ctypes.POINTER(BNBinaryView), 
		type: ctypes.POINTER(BNQualifiedName), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_ulonglong)]:
	result = _BNGetAllFieldsReferenced(view, type, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetAllFunctionTagReferences

_BNGetAllFunctionTagReferences = core.BNGetAllFunctionTagReferences
_BNGetAllFunctionTagReferences.restype = ctypes.POINTER(BNTagReference)
_BNGetAllFunctionTagReferences.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetAllFunctionTagReferences(
		view: ctypes.POINTER(BNBinaryView), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNTagReference)]:
	result = _BNGetAllFunctionTagReferences(view, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetAllMediumLevelILBranchDependence

_BNGetAllMediumLevelILBranchDependence = core.BNGetAllMediumLevelILBranchDependence
_BNGetAllMediumLevelILBranchDependence.restype = ctypes.POINTER(BNILBranchInstructionAndDependence)
_BNGetAllMediumLevelILBranchDependence.argtypes = [
		ctypes.POINTER(BNMediumLevelILFunction),
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetAllMediumLevelILBranchDependence(
		func: ctypes.POINTER(BNMediumLevelILFunction), 
		instr: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNILBranchInstructionAndDependence)]:
	result = _BNGetAllMediumLevelILBranchDependence(func, instr, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetAllPluginCommands

_BNGetAllPluginCommands = core.BNGetAllPluginCommands
_BNGetAllPluginCommands.restype = ctypes.POINTER(BNPluginCommand)
_BNGetAllPluginCommands.argtypes = [
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetAllPluginCommands(
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNPluginCommand)]:
	result = _BNGetAllPluginCommands(count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetAllSizesReferenced

_BNGetAllSizesReferenced = core.BNGetAllSizesReferenced
_BNGetAllSizesReferenced.restype = ctypes.POINTER(BNTypeFieldReferenceSizeInfo)
_BNGetAllSizesReferenced.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNQualifiedName),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetAllSizesReferenced(
		view: ctypes.POINTER(BNBinaryView), 
		type: ctypes.POINTER(BNQualifiedName), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNTypeFieldReferenceSizeInfo)]:
	result = _BNGetAllSizesReferenced(view, type, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetAllTagReferenceTypeCounts

_BNGetAllTagReferenceTypeCounts = core.BNGetAllTagReferenceTypeCounts
_BNGetAllTagReferenceTypeCounts.restype = None
_BNGetAllTagReferenceTypeCounts.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(ctypes.POINTER(ctypes.POINTER(BNTagType))),
		ctypes.POINTER(ctypes.POINTER(ctypes.c_ulonglong)),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetAllTagReferenceTypeCounts(
		view: ctypes.POINTER(BNBinaryView), 
		tagTypes: ctypes.POINTER(ctypes.POINTER(ctypes.POINTER(BNTagType))), 
		counts: ctypes.POINTER(ctypes.POINTER(ctypes.c_ulonglong)), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> None:
	return _BNGetAllTagReferenceTypeCounts(view, tagTypes, counts, count)


# -------------------------------------------------------
# _BNGetAllTagReferences

_BNGetAllTagReferences = core.BNGetAllTagReferences
_BNGetAllTagReferences.restype = ctypes.POINTER(BNTagReference)
_BNGetAllTagReferences.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetAllTagReferences(
		view: ctypes.POINTER(BNBinaryView), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNTagReference)]:
	result = _BNGetAllTagReferences(view, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetAllTagReferencesOfType

_BNGetAllTagReferencesOfType = core.BNGetAllTagReferencesOfType
_BNGetAllTagReferencesOfType.restype = ctypes.POINTER(BNTagReference)
_BNGetAllTagReferencesOfType.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNTagType),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetAllTagReferencesOfType(
		view: ctypes.POINTER(BNBinaryView), 
		tagType: ctypes.POINTER(BNTagType), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNTagReference)]:
	result = _BNGetAllTagReferencesOfType(view, tagType, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetAllTagReferencesOfTypeCount

_BNGetAllTagReferencesOfTypeCount = core.BNGetAllTagReferencesOfTypeCount
_BNGetAllTagReferencesOfTypeCount.restype = ctypes.c_ulonglong
_BNGetAllTagReferencesOfTypeCount.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNTagType),
	]


# noinspection PyPep8Naming
def BNGetAllTagReferencesOfTypeCount(
		view: ctypes.POINTER(BNBinaryView), 
		tagType: ctypes.POINTER(BNTagType)
		) -> int:
	return _BNGetAllTagReferencesOfTypeCount(view, tagType)


# -------------------------------------------------------
# _BNGetAllTypesReferenced

_BNGetAllTypesReferenced = core.BNGetAllTypesReferenced
_BNGetAllTypesReferenced.restype = ctypes.POINTER(BNTypeFieldReferenceTypeInfo)
_BNGetAllTypesReferenced.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNQualifiedName),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetAllTypesReferenced(
		view: ctypes.POINTER(BNBinaryView), 
		type: ctypes.POINTER(BNQualifiedName), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNTypeFieldReferenceTypeInfo)]:
	result = _BNGetAllTypesReferenced(view, type, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetAllUserVariableValues

_BNGetAllUserVariableValues = core.BNGetAllUserVariableValues
_BNGetAllUserVariableValues.restype = ctypes.POINTER(BNUserVariableValue)
_BNGetAllUserVariableValues.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetAllUserVariableValues(
		func: ctypes.POINTER(BNFunction), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNUserVariableValue)]:
	result = _BNGetAllUserVariableValues(func, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetAllocatedRanges

_BNGetAllocatedRanges = core.BNGetAllocatedRanges
_BNGetAllocatedRanges.restype = ctypes.POINTER(BNAddressRange)
_BNGetAllocatedRanges.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetAllocatedRanges(
		view: ctypes.POINTER(BNBinaryView), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNAddressRange)]:
	result = _BNGetAllocatedRanges(view, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetAnalysisAutoTypeContainer

_BNGetAnalysisAutoTypeContainer = core.BNGetAnalysisAutoTypeContainer
_BNGetAnalysisAutoTypeContainer.restype = ctypes.POINTER(BNTypeContainer)
_BNGetAnalysisAutoTypeContainer.argtypes = [
		ctypes.POINTER(BNBinaryView),
	]


# noinspection PyPep8Naming
def BNGetAnalysisAutoTypeContainer(
		view: ctypes.POINTER(BNBinaryView)
		) -> Optional[ctypes.POINTER(BNTypeContainer)]:
	result = _BNGetAnalysisAutoTypeContainer(view)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetAnalysisDependencySortedTypeList

_BNGetAnalysisDependencySortedTypeList = core.BNGetAnalysisDependencySortedTypeList
_BNGetAnalysisDependencySortedTypeList.restype = ctypes.POINTER(BNQualifiedNameAndType)
_BNGetAnalysisDependencySortedTypeList.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetAnalysisDependencySortedTypeList(
		view: ctypes.POINTER(BNBinaryView), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNQualifiedNameAndType)]:
	result = _BNGetAnalysisDependencySortedTypeList(view, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetAnalysisEntryPoint

_BNGetAnalysisEntryPoint = core.BNGetAnalysisEntryPoint
_BNGetAnalysisEntryPoint.restype = ctypes.POINTER(BNFunction)
_BNGetAnalysisEntryPoint.argtypes = [
		ctypes.POINTER(BNBinaryView),
	]


# noinspection PyPep8Naming
def BNGetAnalysisEntryPoint(
		view: ctypes.POINTER(BNBinaryView)
		) -> Optional[ctypes.POINTER(BNFunction)]:
	result = _BNGetAnalysisEntryPoint(view)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetAnalysisFunction

_BNGetAnalysisFunction = core.BNGetAnalysisFunction
_BNGetAnalysisFunction.restype = ctypes.POINTER(BNFunction)
_BNGetAnalysisFunction.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNPlatform),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetAnalysisFunction(
		view: ctypes.POINTER(BNBinaryView), 
		platform: ctypes.POINTER(BNPlatform), 
		addr: int
		) -> Optional[ctypes.POINTER(BNFunction)]:
	result = _BNGetAnalysisFunction(view, platform, addr)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetAnalysisFunctionList

_BNGetAnalysisFunctionList = core.BNGetAnalysisFunctionList
_BNGetAnalysisFunctionList.restype = ctypes.POINTER(ctypes.POINTER(BNFunction))
_BNGetAnalysisFunctionList.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetAnalysisFunctionList(
		view: ctypes.POINTER(BNBinaryView), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.POINTER(BNFunction))]:
	result = _BNGetAnalysisFunctionList(view, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetAnalysisFunctionsContainingAddress

_BNGetAnalysisFunctionsContainingAddress = core.BNGetAnalysisFunctionsContainingAddress
_BNGetAnalysisFunctionsContainingAddress.restype = ctypes.POINTER(ctypes.POINTER(BNFunction))
_BNGetAnalysisFunctionsContainingAddress.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetAnalysisFunctionsContainingAddress(
		view: ctypes.POINTER(BNBinaryView), 
		addr: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.POINTER(BNFunction))]:
	result = _BNGetAnalysisFunctionsContainingAddress(view, addr, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetAnalysisFunctionsForAddress

_BNGetAnalysisFunctionsForAddress = core.BNGetAnalysisFunctionsForAddress
_BNGetAnalysisFunctionsForAddress.restype = ctypes.POINTER(ctypes.POINTER(BNFunction))
_BNGetAnalysisFunctionsForAddress.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetAnalysisFunctionsForAddress(
		view: ctypes.POINTER(BNBinaryView), 
		addr: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.POINTER(BNFunction))]:
	result = _BNGetAnalysisFunctionsForAddress(view, addr, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetAnalysisInfo

_BNGetAnalysisInfo = core.BNGetAnalysisInfo
_BNGetAnalysisInfo.restype = ctypes.POINTER(BNAnalysisInfo)
_BNGetAnalysisInfo.argtypes = [
		ctypes.POINTER(BNBinaryView),
	]


# noinspection PyPep8Naming
def BNGetAnalysisInfo(
		view: ctypes.POINTER(BNBinaryView)
		) -> Optional[ctypes.POINTER(BNAnalysisInfo)]:
	result = _BNGetAnalysisInfo(view)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetAnalysisProgress

_BNGetAnalysisProgress = core.BNGetAnalysisProgress
_BNGetAnalysisProgress.restype = BNAnalysisProgress
_BNGetAnalysisProgress.argtypes = [
		ctypes.POINTER(BNBinaryView),
	]


# noinspection PyPep8Naming
def BNGetAnalysisProgress(
		view: ctypes.POINTER(BNBinaryView)
		) -> BNAnalysisProgress:
	return _BNGetAnalysisProgress(view)


# -------------------------------------------------------
# _BNGetAnalysisSkipReason

_BNGetAnalysisSkipReason = core.BNGetAnalysisSkipReason
_BNGetAnalysisSkipReason.restype = AnalysisSkipReasonEnum
_BNGetAnalysisSkipReason.argtypes = [
		ctypes.POINTER(BNFunction),
	]


# noinspection PyPep8Naming
def BNGetAnalysisSkipReason(
		func: ctypes.POINTER(BNFunction)
		) -> AnalysisSkipReason:
	return _BNGetAnalysisSkipReason(func)


# -------------------------------------------------------
# _BNGetAnalysisTypeById

_BNGetAnalysisTypeById = core.BNGetAnalysisTypeById
_BNGetAnalysisTypeById.restype = ctypes.POINTER(BNType)
_BNGetAnalysisTypeById.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNGetAnalysisTypeById(
		view: ctypes.POINTER(BNBinaryView), 
		id: Optional[str]
		) -> Optional[ctypes.POINTER(BNType)]:
	result = _BNGetAnalysisTypeById(view, cstr(id))
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetAnalysisTypeByName

_BNGetAnalysisTypeByName = core.BNGetAnalysisTypeByName
_BNGetAnalysisTypeByName.restype = ctypes.POINTER(BNType)
_BNGetAnalysisTypeByName.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNQualifiedName),
	]


# noinspection PyPep8Naming
def BNGetAnalysisTypeByName(
		view: ctypes.POINTER(BNBinaryView), 
		name: ctypes.POINTER(BNQualifiedName)
		) -> Optional[ctypes.POINTER(BNType)]:
	result = _BNGetAnalysisTypeByName(view, name)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetAnalysisTypeByRef

_BNGetAnalysisTypeByRef = core.BNGetAnalysisTypeByRef
_BNGetAnalysisTypeByRef.restype = ctypes.POINTER(BNType)
_BNGetAnalysisTypeByRef.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNNamedTypeReference),
	]


# noinspection PyPep8Naming
def BNGetAnalysisTypeByRef(
		view: ctypes.POINTER(BNBinaryView), 
		ref: ctypes.POINTER(BNNamedTypeReference)
		) -> Optional[ctypes.POINTER(BNType)]:
	result = _BNGetAnalysisTypeByRef(view, ref)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetAnalysisTypeContainer

_BNGetAnalysisTypeContainer = core.BNGetAnalysisTypeContainer
_BNGetAnalysisTypeContainer.restype = ctypes.POINTER(BNTypeContainer)
_BNGetAnalysisTypeContainer.argtypes = [
		ctypes.POINTER(BNBinaryView),
	]


# noinspection PyPep8Naming
def BNGetAnalysisTypeContainer(
		view: ctypes.POINTER(BNBinaryView)
		) -> Optional[ctypes.POINTER(BNTypeContainer)]:
	result = _BNGetAnalysisTypeContainer(view)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetAnalysisTypeId

_BNGetAnalysisTypeId = core.BNGetAnalysisTypeId
_BNGetAnalysisTypeId.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetAnalysisTypeId.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNQualifiedName),
	]


# noinspection PyPep8Naming
def BNGetAnalysisTypeId(
		view: ctypes.POINTER(BNBinaryView), 
		name: ctypes.POINTER(BNQualifiedName)
		) -> Optional[Optional[str]]:
	result = _BNGetAnalysisTypeId(view, name)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetAnalysisTypeList

_BNGetAnalysisTypeList = core.BNGetAnalysisTypeList
_BNGetAnalysisTypeList.restype = ctypes.POINTER(BNQualifiedNameAndType)
_BNGetAnalysisTypeList.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetAnalysisTypeList(
		view: ctypes.POINTER(BNBinaryView), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNQualifiedNameAndType)]:
	result = _BNGetAnalysisTypeList(view, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetAnalysisTypeNameById

_BNGetAnalysisTypeNameById = core.BNGetAnalysisTypeNameById
_BNGetAnalysisTypeNameById.restype = BNQualifiedName
_BNGetAnalysisTypeNameById.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNGetAnalysisTypeNameById(
		view: ctypes.POINTER(BNBinaryView), 
		id: Optional[str]
		) -> BNQualifiedName:
	return _BNGetAnalysisTypeNameById(view, cstr(id))


# -------------------------------------------------------
# _BNGetAnalysisTypeNames

_BNGetAnalysisTypeNames = core.BNGetAnalysisTypeNames
_BNGetAnalysisTypeNames.restype = ctypes.POINTER(BNQualifiedName)
_BNGetAnalysisTypeNames.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(ctypes.c_ulonglong),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNGetAnalysisTypeNames(
		view: ctypes.POINTER(BNBinaryView), 
		count: ctypes.POINTER(ctypes.c_ulonglong), 
		matching: Optional[str]
		) -> Optional[ctypes.POINTER(BNQualifiedName)]:
	result = _BNGetAnalysisTypeNames(view, count, cstr(matching))
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetAnalysisUserTypeContainer

_BNGetAnalysisUserTypeContainer = core.BNGetAnalysisUserTypeContainer
_BNGetAnalysisUserTypeContainer.restype = ctypes.POINTER(BNTypeContainer)
_BNGetAnalysisUserTypeContainer.argtypes = [
		ctypes.POINTER(BNBinaryView),
	]


# noinspection PyPep8Naming
def BNGetAnalysisUserTypeContainer(
		view: ctypes.POINTER(BNBinaryView)
		) -> Optional[ctypes.POINTER(BNTypeContainer)]:
	result = _BNGetAnalysisUserTypeContainer(view)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetArchitectureAddressSize

_BNGetArchitectureAddressSize = core.BNGetArchitectureAddressSize
_BNGetArchitectureAddressSize.restype = ctypes.c_ulonglong
_BNGetArchitectureAddressSize.argtypes = [
		ctypes.POINTER(BNArchitecture),
	]


# noinspection PyPep8Naming
def BNGetArchitectureAddressSize(
		arch: ctypes.POINTER(BNArchitecture)
		) -> int:
	return _BNGetArchitectureAddressSize(arch)


# -------------------------------------------------------
# _BNGetArchitectureByName

_BNGetArchitectureByName = core.BNGetArchitectureByName
_BNGetArchitectureByName.restype = ctypes.POINTER(BNArchitecture)
_BNGetArchitectureByName.argtypes = [
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNGetArchitectureByName(
		name: Optional[str]
		) -> Optional[ctypes.POINTER(BNArchitecture)]:
	result = _BNGetArchitectureByName(cstr(name))
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetArchitectureCallingConventionByName

_BNGetArchitectureCallingConventionByName = core.BNGetArchitectureCallingConventionByName
_BNGetArchitectureCallingConventionByName.restype = ctypes.POINTER(BNCallingConvention)
_BNGetArchitectureCallingConventionByName.argtypes = [
		ctypes.POINTER(BNArchitecture),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNGetArchitectureCallingConventionByName(
		arch: ctypes.POINTER(BNArchitecture), 
		name: Optional[str]
		) -> Optional[ctypes.POINTER(BNCallingConvention)]:
	result = _BNGetArchitectureCallingConventionByName(arch, cstr(name))
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetArchitectureCallingConventions

_BNGetArchitectureCallingConventions = core.BNGetArchitectureCallingConventions
_BNGetArchitectureCallingConventions.restype = ctypes.POINTER(ctypes.POINTER(BNCallingConvention))
_BNGetArchitectureCallingConventions.argtypes = [
		ctypes.POINTER(BNArchitecture),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetArchitectureCallingConventions(
		arch: ctypes.POINTER(BNArchitecture), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.POINTER(BNCallingConvention))]:
	result = _BNGetArchitectureCallingConventions(arch, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetArchitectureCdeclCallingConvention

_BNGetArchitectureCdeclCallingConvention = core.BNGetArchitectureCdeclCallingConvention
_BNGetArchitectureCdeclCallingConvention.restype = ctypes.POINTER(BNCallingConvention)
_BNGetArchitectureCdeclCallingConvention.argtypes = [
		ctypes.POINTER(BNArchitecture),
	]


# noinspection PyPep8Naming
def BNGetArchitectureCdeclCallingConvention(
		arch: ctypes.POINTER(BNArchitecture)
		) -> Optional[ctypes.POINTER(BNCallingConvention)]:
	result = _BNGetArchitectureCdeclCallingConvention(arch)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetArchitectureDefaultCallingConvention

_BNGetArchitectureDefaultCallingConvention = core.BNGetArchitectureDefaultCallingConvention
_BNGetArchitectureDefaultCallingConvention.restype = ctypes.POINTER(BNCallingConvention)
_BNGetArchitectureDefaultCallingConvention.argtypes = [
		ctypes.POINTER(BNArchitecture),
	]


# noinspection PyPep8Naming
def BNGetArchitectureDefaultCallingConvention(
		arch: ctypes.POINTER(BNArchitecture)
		) -> Optional[ctypes.POINTER(BNCallingConvention)]:
	result = _BNGetArchitectureDefaultCallingConvention(arch)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetArchitectureDefaultIntegerSize

_BNGetArchitectureDefaultIntegerSize = core.BNGetArchitectureDefaultIntegerSize
_BNGetArchitectureDefaultIntegerSize.restype = ctypes.c_ulonglong
_BNGetArchitectureDefaultIntegerSize.argtypes = [
		ctypes.POINTER(BNArchitecture),
	]


# noinspection PyPep8Naming
def BNGetArchitectureDefaultIntegerSize(
		arch: ctypes.POINTER(BNArchitecture)
		) -> int:
	return _BNGetArchitectureDefaultIntegerSize(arch)


# -------------------------------------------------------
# _BNGetArchitectureEndianness

_BNGetArchitectureEndianness = core.BNGetArchitectureEndianness
_BNGetArchitectureEndianness.restype = EndiannessEnum
_BNGetArchitectureEndianness.argtypes = [
		ctypes.POINTER(BNArchitecture),
	]


# noinspection PyPep8Naming
def BNGetArchitectureEndianness(
		arch: ctypes.POINTER(BNArchitecture)
		) -> Endianness:
	return _BNGetArchitectureEndianness(arch)


# -------------------------------------------------------
# _BNGetArchitectureFastcallCallingConvention

_BNGetArchitectureFastcallCallingConvention = core.BNGetArchitectureFastcallCallingConvention
_BNGetArchitectureFastcallCallingConvention.restype = ctypes.POINTER(BNCallingConvention)
_BNGetArchitectureFastcallCallingConvention.argtypes = [
		ctypes.POINTER(BNArchitecture),
	]


# noinspection PyPep8Naming
def BNGetArchitectureFastcallCallingConvention(
		arch: ctypes.POINTER(BNArchitecture)
		) -> Optional[ctypes.POINTER(BNCallingConvention)]:
	result = _BNGetArchitectureFastcallCallingConvention(arch)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetArchitectureFlagConditionLowLevelIL

_BNGetArchitectureFlagConditionLowLevelIL = core.BNGetArchitectureFlagConditionLowLevelIL
_BNGetArchitectureFlagConditionLowLevelIL.restype = ctypes.c_ulonglong
_BNGetArchitectureFlagConditionLowLevelIL.argtypes = [
		ctypes.POINTER(BNArchitecture),
		LowLevelILFlagConditionEnum,
		ctypes.c_uint,
		ctypes.POINTER(BNLowLevelILFunction),
	]


# noinspection PyPep8Naming
def BNGetArchitectureFlagConditionLowLevelIL(
		arch: ctypes.POINTER(BNArchitecture), 
		cond: LowLevelILFlagCondition, 
		semClass: int, 
		il: ctypes.POINTER(BNLowLevelILFunction)
		) -> int:
	return _BNGetArchitectureFlagConditionLowLevelIL(arch, cond, semClass, il)


# -------------------------------------------------------
# _BNGetArchitectureFlagConditionsForSemanticFlagGroup

_BNGetArchitectureFlagConditionsForSemanticFlagGroup = core.BNGetArchitectureFlagConditionsForSemanticFlagGroup
_BNGetArchitectureFlagConditionsForSemanticFlagGroup.restype = ctypes.POINTER(BNFlagConditionForSemanticClass)
_BNGetArchitectureFlagConditionsForSemanticFlagGroup.argtypes = [
		ctypes.POINTER(BNArchitecture),
		ctypes.c_uint,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetArchitectureFlagConditionsForSemanticFlagGroup(
		arch: ctypes.POINTER(BNArchitecture), 
		semGroup: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNFlagConditionForSemanticClass)]:
	result = _BNGetArchitectureFlagConditionsForSemanticFlagGroup(arch, semGroup, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetArchitectureFlagName

_BNGetArchitectureFlagName = core.BNGetArchitectureFlagName
_BNGetArchitectureFlagName.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetArchitectureFlagName.argtypes = [
		ctypes.POINTER(BNArchitecture),
		ctypes.c_uint,
	]


# noinspection PyPep8Naming
def BNGetArchitectureFlagName(
		arch: ctypes.POINTER(BNArchitecture), 
		flag: int
		) -> Optional[Optional[str]]:
	result = _BNGetArchitectureFlagName(arch, flag)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetArchitectureFlagRole

_BNGetArchitectureFlagRole = core.BNGetArchitectureFlagRole
_BNGetArchitectureFlagRole.restype = FlagRoleEnum
_BNGetArchitectureFlagRole.argtypes = [
		ctypes.POINTER(BNArchitecture),
		ctypes.c_uint,
		ctypes.c_uint,
	]


# noinspection PyPep8Naming
def BNGetArchitectureFlagRole(
		arch: ctypes.POINTER(BNArchitecture), 
		flag: int, 
		semClass: int
		) -> FlagRole:
	return _BNGetArchitectureFlagRole(arch, flag, semClass)


# -------------------------------------------------------
# _BNGetArchitectureFlagWriteLowLevelIL

_BNGetArchitectureFlagWriteLowLevelIL = core.BNGetArchitectureFlagWriteLowLevelIL
_BNGetArchitectureFlagWriteLowLevelIL.restype = ctypes.c_ulonglong
_BNGetArchitectureFlagWriteLowLevelIL.argtypes = [
		ctypes.POINTER(BNArchitecture),
		LowLevelILOperationEnum,
		ctypes.c_ulonglong,
		ctypes.c_uint,
		ctypes.c_uint,
		ctypes.POINTER(BNRegisterOrConstant),
		ctypes.c_ulonglong,
		ctypes.POINTER(BNLowLevelILFunction),
	]


# noinspection PyPep8Naming
def BNGetArchitectureFlagWriteLowLevelIL(
		arch: ctypes.POINTER(BNArchitecture), 
		op: LowLevelILOperation, 
		size: int, 
		flagWriteType: int, 
		flag: int, 
		operands: ctypes.POINTER(BNRegisterOrConstant), 
		operandCount: int, 
		il: ctypes.POINTER(BNLowLevelILFunction)
		) -> int:
	return _BNGetArchitectureFlagWriteLowLevelIL(arch, op, size, flagWriteType, flag, operands, operandCount, il)


# -------------------------------------------------------
# _BNGetArchitectureFlagWriteTypeName

_BNGetArchitectureFlagWriteTypeName = core.BNGetArchitectureFlagWriteTypeName
_BNGetArchitectureFlagWriteTypeName.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetArchitectureFlagWriteTypeName.argtypes = [
		ctypes.POINTER(BNArchitecture),
		ctypes.c_uint,
	]


# noinspection PyPep8Naming
def BNGetArchitectureFlagWriteTypeName(
		arch: ctypes.POINTER(BNArchitecture), 
		flags: int
		) -> Optional[Optional[str]]:
	result = _BNGetArchitectureFlagWriteTypeName(arch, flags)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetArchitectureFlagsRequiredForFlagCondition

_BNGetArchitectureFlagsRequiredForFlagCondition = core.BNGetArchitectureFlagsRequiredForFlagCondition
_BNGetArchitectureFlagsRequiredForFlagCondition.restype = ctypes.POINTER(ctypes.c_uint)
_BNGetArchitectureFlagsRequiredForFlagCondition.argtypes = [
		ctypes.POINTER(BNArchitecture),
		LowLevelILFlagConditionEnum,
		ctypes.c_uint,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetArchitectureFlagsRequiredForFlagCondition(
		arch: ctypes.POINTER(BNArchitecture), 
		cond: LowLevelILFlagCondition, 
		semClass: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_uint)]:
	result = _BNGetArchitectureFlagsRequiredForFlagCondition(arch, cond, semClass, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetArchitectureFlagsRequiredForSemanticFlagGroup

_BNGetArchitectureFlagsRequiredForSemanticFlagGroup = core.BNGetArchitectureFlagsRequiredForSemanticFlagGroup
_BNGetArchitectureFlagsRequiredForSemanticFlagGroup.restype = ctypes.POINTER(ctypes.c_uint)
_BNGetArchitectureFlagsRequiredForSemanticFlagGroup.argtypes = [
		ctypes.POINTER(BNArchitecture),
		ctypes.c_uint,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetArchitectureFlagsRequiredForSemanticFlagGroup(
		arch: ctypes.POINTER(BNArchitecture), 
		semGroup: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_uint)]:
	result = _BNGetArchitectureFlagsRequiredForSemanticFlagGroup(arch, semGroup, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetArchitectureFlagsWrittenByFlagWriteType

_BNGetArchitectureFlagsWrittenByFlagWriteType = core.BNGetArchitectureFlagsWrittenByFlagWriteType
_BNGetArchitectureFlagsWrittenByFlagWriteType.restype = ctypes.POINTER(ctypes.c_uint)
_BNGetArchitectureFlagsWrittenByFlagWriteType.argtypes = [
		ctypes.POINTER(BNArchitecture),
		ctypes.c_uint,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetArchitectureFlagsWrittenByFlagWriteType(
		arch: ctypes.POINTER(BNArchitecture), 
		writeType: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_uint)]:
	result = _BNGetArchitectureFlagsWrittenByFlagWriteType(arch, writeType, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetArchitectureForViewType

_BNGetArchitectureForViewType = core.BNGetArchitectureForViewType
_BNGetArchitectureForViewType.restype = ctypes.POINTER(BNArchitecture)
_BNGetArchitectureForViewType.argtypes = [
		ctypes.POINTER(BNBinaryViewType),
		ctypes.c_uint,
		EndiannessEnum,
	]


# noinspection PyPep8Naming
def BNGetArchitectureForViewType(
		type: ctypes.POINTER(BNBinaryViewType), 
		id: int, 
		endian: Endianness
		) -> Optional[ctypes.POINTER(BNArchitecture)]:
	result = _BNGetArchitectureForViewType(type, id, endian)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetArchitectureGlobalRegisters

_BNGetArchitectureGlobalRegisters = core.BNGetArchitectureGlobalRegisters
_BNGetArchitectureGlobalRegisters.restype = ctypes.POINTER(ctypes.c_uint)
_BNGetArchitectureGlobalRegisters.argtypes = [
		ctypes.POINTER(BNArchitecture),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetArchitectureGlobalRegisters(
		arch: ctypes.POINTER(BNArchitecture), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_uint)]:
	result = _BNGetArchitectureGlobalRegisters(arch, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetArchitectureInstructionAlignment

_BNGetArchitectureInstructionAlignment = core.BNGetArchitectureInstructionAlignment
_BNGetArchitectureInstructionAlignment.restype = ctypes.c_ulonglong
_BNGetArchitectureInstructionAlignment.argtypes = [
		ctypes.POINTER(BNArchitecture),
	]


# noinspection PyPep8Naming
def BNGetArchitectureInstructionAlignment(
		arch: ctypes.POINTER(BNArchitecture)
		) -> int:
	return _BNGetArchitectureInstructionAlignment(arch)


# -------------------------------------------------------
# _BNGetArchitectureIntrinsicClass

_BNGetArchitectureIntrinsicClass = core.BNGetArchitectureIntrinsicClass
_BNGetArchitectureIntrinsicClass.restype = IntrinsicClassEnum
_BNGetArchitectureIntrinsicClass.argtypes = [
		ctypes.POINTER(BNArchitecture),
		ctypes.c_uint,
	]


# noinspection PyPep8Naming
def BNGetArchitectureIntrinsicClass(
		arch: ctypes.POINTER(BNArchitecture), 
		intrinsic: int
		) -> IntrinsicClass:
	return _BNGetArchitectureIntrinsicClass(arch, intrinsic)


# -------------------------------------------------------
# _BNGetArchitectureIntrinsicInputs

_BNGetArchitectureIntrinsicInputs = core.BNGetArchitectureIntrinsicInputs
_BNGetArchitectureIntrinsicInputs.restype = ctypes.POINTER(BNNameAndType)
_BNGetArchitectureIntrinsicInputs.argtypes = [
		ctypes.POINTER(BNArchitecture),
		ctypes.c_uint,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetArchitectureIntrinsicInputs(
		arch: ctypes.POINTER(BNArchitecture), 
		intrinsic: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNNameAndType)]:
	result = _BNGetArchitectureIntrinsicInputs(arch, intrinsic, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetArchitectureIntrinsicName

_BNGetArchitectureIntrinsicName = core.BNGetArchitectureIntrinsicName
_BNGetArchitectureIntrinsicName.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetArchitectureIntrinsicName.argtypes = [
		ctypes.POINTER(BNArchitecture),
		ctypes.c_uint,
	]


# noinspection PyPep8Naming
def BNGetArchitectureIntrinsicName(
		arch: ctypes.POINTER(BNArchitecture), 
		intrinsic: int
		) -> Optional[Optional[str]]:
	result = _BNGetArchitectureIntrinsicName(arch, intrinsic)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetArchitectureIntrinsicOutputs

_BNGetArchitectureIntrinsicOutputs = core.BNGetArchitectureIntrinsicOutputs
_BNGetArchitectureIntrinsicOutputs.restype = ctypes.POINTER(BNTypeWithConfidence)
_BNGetArchitectureIntrinsicOutputs.argtypes = [
		ctypes.POINTER(BNArchitecture),
		ctypes.c_uint,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetArchitectureIntrinsicOutputs(
		arch: ctypes.POINTER(BNArchitecture), 
		intrinsic: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNTypeWithConfidence)]:
	result = _BNGetArchitectureIntrinsicOutputs(arch, intrinsic, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetArchitectureLinkRegister

_BNGetArchitectureLinkRegister = core.BNGetArchitectureLinkRegister
_BNGetArchitectureLinkRegister.restype = ctypes.c_uint
_BNGetArchitectureLinkRegister.argtypes = [
		ctypes.POINTER(BNArchitecture),
	]


# noinspection PyPep8Naming
def BNGetArchitectureLinkRegister(
		arch: ctypes.POINTER(BNArchitecture)
		) -> int:
	return _BNGetArchitectureLinkRegister(arch)


# -------------------------------------------------------
# _BNGetArchitectureList

_BNGetArchitectureList = core.BNGetArchitectureList
_BNGetArchitectureList.restype = ctypes.POINTER(ctypes.POINTER(BNArchitecture))
_BNGetArchitectureList.argtypes = [
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetArchitectureList(
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.POINTER(BNArchitecture))]:
	result = _BNGetArchitectureList(count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetArchitectureMaxInstructionLength

_BNGetArchitectureMaxInstructionLength = core.BNGetArchitectureMaxInstructionLength
_BNGetArchitectureMaxInstructionLength.restype = ctypes.c_ulonglong
_BNGetArchitectureMaxInstructionLength.argtypes = [
		ctypes.POINTER(BNArchitecture),
	]


# noinspection PyPep8Naming
def BNGetArchitectureMaxInstructionLength(
		arch: ctypes.POINTER(BNArchitecture)
		) -> int:
	return _BNGetArchitectureMaxInstructionLength(arch)


# -------------------------------------------------------
# _BNGetArchitectureName

_BNGetArchitectureName = core.BNGetArchitectureName
_BNGetArchitectureName.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetArchitectureName.argtypes = [
		ctypes.POINTER(BNArchitecture),
	]


# noinspection PyPep8Naming
def BNGetArchitectureName(
		arch: ctypes.POINTER(BNArchitecture)
		) -> Optional[Optional[str]]:
	result = _BNGetArchitectureName(arch)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetArchitectureOpcodeDisplayLength

_BNGetArchitectureOpcodeDisplayLength = core.BNGetArchitectureOpcodeDisplayLength
_BNGetArchitectureOpcodeDisplayLength.restype = ctypes.c_ulonglong
_BNGetArchitectureOpcodeDisplayLength.argtypes = [
		ctypes.POINTER(BNArchitecture),
	]


# noinspection PyPep8Naming
def BNGetArchitectureOpcodeDisplayLength(
		arch: ctypes.POINTER(BNArchitecture)
		) -> int:
	return _BNGetArchitectureOpcodeDisplayLength(arch)


# -------------------------------------------------------
# _BNGetArchitectureRegisterByName

_BNGetArchitectureRegisterByName = core.BNGetArchitectureRegisterByName
_BNGetArchitectureRegisterByName.restype = ctypes.c_uint
_BNGetArchitectureRegisterByName.argtypes = [
		ctypes.POINTER(BNArchitecture),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNGetArchitectureRegisterByName(
		arch: ctypes.POINTER(BNArchitecture), 
		name: Optional[str]
		) -> int:
	return _BNGetArchitectureRegisterByName(arch, cstr(name))


# -------------------------------------------------------
# _BNGetArchitectureRegisterInfo

_BNGetArchitectureRegisterInfo = core.BNGetArchitectureRegisterInfo
_BNGetArchitectureRegisterInfo.restype = BNRegisterInfo
_BNGetArchitectureRegisterInfo.argtypes = [
		ctypes.POINTER(BNArchitecture),
		ctypes.c_uint,
	]


# noinspection PyPep8Naming
def BNGetArchitectureRegisterInfo(
		arch: ctypes.POINTER(BNArchitecture), 
		reg: int
		) -> BNRegisterInfo:
	return _BNGetArchitectureRegisterInfo(arch, reg)


# -------------------------------------------------------
# _BNGetArchitectureRegisterName

_BNGetArchitectureRegisterName = core.BNGetArchitectureRegisterName
_BNGetArchitectureRegisterName.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetArchitectureRegisterName.argtypes = [
		ctypes.POINTER(BNArchitecture),
		ctypes.c_uint,
	]


# noinspection PyPep8Naming
def BNGetArchitectureRegisterName(
		arch: ctypes.POINTER(BNArchitecture), 
		reg: int
		) -> Optional[Optional[str]]:
	result = _BNGetArchitectureRegisterName(arch, reg)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetArchitectureRegisterStackForRegister

_BNGetArchitectureRegisterStackForRegister = core.BNGetArchitectureRegisterStackForRegister
_BNGetArchitectureRegisterStackForRegister.restype = ctypes.c_uint
_BNGetArchitectureRegisterStackForRegister.argtypes = [
		ctypes.POINTER(BNArchitecture),
		ctypes.c_uint,
	]


# noinspection PyPep8Naming
def BNGetArchitectureRegisterStackForRegister(
		arch: ctypes.POINTER(BNArchitecture), 
		reg: int
		) -> int:
	return _BNGetArchitectureRegisterStackForRegister(arch, reg)


# -------------------------------------------------------
# _BNGetArchitectureRegisterStackInfo

_BNGetArchitectureRegisterStackInfo = core.BNGetArchitectureRegisterStackInfo
_BNGetArchitectureRegisterStackInfo.restype = BNRegisterStackInfo
_BNGetArchitectureRegisterStackInfo.argtypes = [
		ctypes.POINTER(BNArchitecture),
		ctypes.c_uint,
	]


# noinspection PyPep8Naming
def BNGetArchitectureRegisterStackInfo(
		arch: ctypes.POINTER(BNArchitecture), 
		regStack: int
		) -> BNRegisterStackInfo:
	return _BNGetArchitectureRegisterStackInfo(arch, regStack)


# -------------------------------------------------------
# _BNGetArchitectureRegisterStackName

_BNGetArchitectureRegisterStackName = core.BNGetArchitectureRegisterStackName
_BNGetArchitectureRegisterStackName.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetArchitectureRegisterStackName.argtypes = [
		ctypes.POINTER(BNArchitecture),
		ctypes.c_uint,
	]


# noinspection PyPep8Naming
def BNGetArchitectureRegisterStackName(
		arch: ctypes.POINTER(BNArchitecture), 
		regStack: int
		) -> Optional[Optional[str]]:
	result = _BNGetArchitectureRegisterStackName(arch, regStack)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetArchitectureSemanticClassForFlagWriteType

_BNGetArchitectureSemanticClassForFlagWriteType = core.BNGetArchitectureSemanticClassForFlagWriteType
_BNGetArchitectureSemanticClassForFlagWriteType.restype = ctypes.c_uint
_BNGetArchitectureSemanticClassForFlagWriteType.argtypes = [
		ctypes.POINTER(BNArchitecture),
		ctypes.c_uint,
	]


# noinspection PyPep8Naming
def BNGetArchitectureSemanticClassForFlagWriteType(
		arch: ctypes.POINTER(BNArchitecture), 
		writeType: int
		) -> int:
	return _BNGetArchitectureSemanticClassForFlagWriteType(arch, writeType)


# -------------------------------------------------------
# _BNGetArchitectureSemanticFlagClassName

_BNGetArchitectureSemanticFlagClassName = core.BNGetArchitectureSemanticFlagClassName
_BNGetArchitectureSemanticFlagClassName.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetArchitectureSemanticFlagClassName.argtypes = [
		ctypes.POINTER(BNArchitecture),
		ctypes.c_uint,
	]


# noinspection PyPep8Naming
def BNGetArchitectureSemanticFlagClassName(
		arch: ctypes.POINTER(BNArchitecture), 
		semClass: int
		) -> Optional[Optional[str]]:
	result = _BNGetArchitectureSemanticFlagClassName(arch, semClass)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetArchitectureSemanticFlagGroupLowLevelIL

_BNGetArchitectureSemanticFlagGroupLowLevelIL = core.BNGetArchitectureSemanticFlagGroupLowLevelIL
_BNGetArchitectureSemanticFlagGroupLowLevelIL.restype = ctypes.c_ulonglong
_BNGetArchitectureSemanticFlagGroupLowLevelIL.argtypes = [
		ctypes.POINTER(BNArchitecture),
		ctypes.c_uint,
		ctypes.POINTER(BNLowLevelILFunction),
	]


# noinspection PyPep8Naming
def BNGetArchitectureSemanticFlagGroupLowLevelIL(
		arch: ctypes.POINTER(BNArchitecture), 
		semGroup: int, 
		il: ctypes.POINTER(BNLowLevelILFunction)
		) -> int:
	return _BNGetArchitectureSemanticFlagGroupLowLevelIL(arch, semGroup, il)


# -------------------------------------------------------
# _BNGetArchitectureSemanticFlagGroupName

_BNGetArchitectureSemanticFlagGroupName = core.BNGetArchitectureSemanticFlagGroupName
_BNGetArchitectureSemanticFlagGroupName.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetArchitectureSemanticFlagGroupName.argtypes = [
		ctypes.POINTER(BNArchitecture),
		ctypes.c_uint,
	]


# noinspection PyPep8Naming
def BNGetArchitectureSemanticFlagGroupName(
		arch: ctypes.POINTER(BNArchitecture), 
		semGroup: int
		) -> Optional[Optional[str]]:
	result = _BNGetArchitectureSemanticFlagGroupName(arch, semGroup)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetArchitectureStackPointerRegister

_BNGetArchitectureStackPointerRegister = core.BNGetArchitectureStackPointerRegister
_BNGetArchitectureStackPointerRegister.restype = ctypes.c_uint
_BNGetArchitectureStackPointerRegister.argtypes = [
		ctypes.POINTER(BNArchitecture),
	]


# noinspection PyPep8Naming
def BNGetArchitectureStackPointerRegister(
		arch: ctypes.POINTER(BNArchitecture)
		) -> int:
	return _BNGetArchitectureStackPointerRegister(arch)


# -------------------------------------------------------
# _BNGetArchitectureStandalonePlatform

_BNGetArchitectureStandalonePlatform = core.BNGetArchitectureStandalonePlatform
_BNGetArchitectureStandalonePlatform.restype = ctypes.POINTER(BNPlatform)
_BNGetArchitectureStandalonePlatform.argtypes = [
		ctypes.POINTER(BNArchitecture),
	]


# noinspection PyPep8Naming
def BNGetArchitectureStandalonePlatform(
		arch: ctypes.POINTER(BNArchitecture)
		) -> Optional[ctypes.POINTER(BNPlatform)]:
	result = _BNGetArchitectureStandalonePlatform(arch)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetArchitectureStdcallCallingConvention

_BNGetArchitectureStdcallCallingConvention = core.BNGetArchitectureStdcallCallingConvention
_BNGetArchitectureStdcallCallingConvention.restype = ctypes.POINTER(BNCallingConvention)
_BNGetArchitectureStdcallCallingConvention.argtypes = [
		ctypes.POINTER(BNArchitecture),
	]


# noinspection PyPep8Naming
def BNGetArchitectureStdcallCallingConvention(
		arch: ctypes.POINTER(BNArchitecture)
		) -> Optional[ctypes.POINTER(BNCallingConvention)]:
	result = _BNGetArchitectureStdcallCallingConvention(arch)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetArchitectureSystemRegisters

_BNGetArchitectureSystemRegisters = core.BNGetArchitectureSystemRegisters
_BNGetArchitectureSystemRegisters.restype = ctypes.POINTER(ctypes.c_uint)
_BNGetArchitectureSystemRegisters.argtypes = [
		ctypes.POINTER(BNArchitecture),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetArchitectureSystemRegisters(
		arch: ctypes.POINTER(BNArchitecture), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_uint)]:
	result = _BNGetArchitectureSystemRegisters(arch, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetArchitectureTypeLibraries

_BNGetArchitectureTypeLibraries = core.BNGetArchitectureTypeLibraries
_BNGetArchitectureTypeLibraries.restype = ctypes.POINTER(ctypes.POINTER(BNTypeLibrary))
_BNGetArchitectureTypeLibraries.argtypes = [
		ctypes.POINTER(BNArchitecture),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetArchitectureTypeLibraries(
		arch: ctypes.POINTER(BNArchitecture), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.POINTER(BNTypeLibrary))]:
	result = _BNGetArchitectureTypeLibraries(arch, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetAssociatedArchitectureByAddress

_BNGetAssociatedArchitectureByAddress = core.BNGetAssociatedArchitectureByAddress
_BNGetAssociatedArchitectureByAddress.restype = ctypes.POINTER(BNArchitecture)
_BNGetAssociatedArchitectureByAddress.argtypes = [
		ctypes.POINTER(BNArchitecture),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetAssociatedArchitectureByAddress(
		arch: ctypes.POINTER(BNArchitecture), 
		addr: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNArchitecture)]:
	result = _BNGetAssociatedArchitectureByAddress(arch, addr)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetAssociatedPlatformByAddress

_BNGetAssociatedPlatformByAddress = core.BNGetAssociatedPlatformByAddress
_BNGetAssociatedPlatformByAddress.restype = ctypes.POINTER(BNPlatform)
_BNGetAssociatedPlatformByAddress.argtypes = [
		ctypes.POINTER(BNPlatform),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetAssociatedPlatformByAddress(
		platform: ctypes.POINTER(BNPlatform), 
		addr: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNPlatform)]:
	result = _BNGetAssociatedPlatformByAddress(platform, addr)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetAutoAddressTagReferences

_BNGetAutoAddressTagReferences = core.BNGetAutoAddressTagReferences
_BNGetAutoAddressTagReferences.restype = ctypes.POINTER(BNTagReference)
_BNGetAutoAddressTagReferences.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetAutoAddressTagReferences(
		func: ctypes.POINTER(BNFunction), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNTagReference)]:
	result = _BNGetAutoAddressTagReferences(func, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetAutoAddressTags

_BNGetAutoAddressTags = core.BNGetAutoAddressTags
_BNGetAutoAddressTags.restype = ctypes.POINTER(ctypes.POINTER(BNTag))
_BNGetAutoAddressTags.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNArchitecture),
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetAutoAddressTags(
		func: ctypes.POINTER(BNFunction), 
		arch: ctypes.POINTER(BNArchitecture), 
		addr: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.POINTER(BNTag))]:
	result = _BNGetAutoAddressTags(func, arch, addr, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetAutoAddressTagsInRange

_BNGetAutoAddressTagsInRange = core.BNGetAutoAddressTagsInRange
_BNGetAutoAddressTagsInRange.restype = ctypes.POINTER(BNTagReference)
_BNGetAutoAddressTagsInRange.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNArchitecture),
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetAutoAddressTagsInRange(
		func: ctypes.POINTER(BNFunction), 
		arch: ctypes.POINTER(BNArchitecture), 
		start: int, 
		end: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNTagReference)]:
	result = _BNGetAutoAddressTagsInRange(func, arch, start, end, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetAutoAddressTagsOfType

_BNGetAutoAddressTagsOfType = core.BNGetAutoAddressTagsOfType
_BNGetAutoAddressTagsOfType.restype = ctypes.POINTER(ctypes.POINTER(BNTag))
_BNGetAutoAddressTagsOfType.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNArchitecture),
		ctypes.c_ulonglong,
		ctypes.POINTER(BNTagType),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetAutoAddressTagsOfType(
		func: ctypes.POINTER(BNFunction), 
		arch: ctypes.POINTER(BNArchitecture), 
		addr: int, 
		tagType: ctypes.POINTER(BNTagType), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.POINTER(BNTag))]:
	result = _BNGetAutoAddressTagsOfType(func, arch, addr, tagType, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetAutoDataTagReferences

_BNGetAutoDataTagReferences = core.BNGetAutoDataTagReferences
_BNGetAutoDataTagReferences.restype = ctypes.POINTER(BNTagReference)
_BNGetAutoDataTagReferences.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetAutoDataTagReferences(
		view: ctypes.POINTER(BNBinaryView), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNTagReference)]:
	result = _BNGetAutoDataTagReferences(view, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetAutoDataTags

_BNGetAutoDataTags = core.BNGetAutoDataTags
_BNGetAutoDataTags.restype = ctypes.POINTER(ctypes.POINTER(BNTag))
_BNGetAutoDataTags.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetAutoDataTags(
		view: ctypes.POINTER(BNBinaryView), 
		addr: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.POINTER(BNTag))]:
	result = _BNGetAutoDataTags(view, addr, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetAutoDataTagsInRange

_BNGetAutoDataTagsInRange = core.BNGetAutoDataTagsInRange
_BNGetAutoDataTagsInRange.restype = ctypes.POINTER(BNTagReference)
_BNGetAutoDataTagsInRange.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetAutoDataTagsInRange(
		view: ctypes.POINTER(BNBinaryView), 
		start: int, 
		end: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNTagReference)]:
	result = _BNGetAutoDataTagsInRange(view, start, end, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetAutoDataTagsOfType

_BNGetAutoDataTagsOfType = core.BNGetAutoDataTagsOfType
_BNGetAutoDataTagsOfType.restype = ctypes.POINTER(ctypes.POINTER(BNTag))
_BNGetAutoDataTagsOfType.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
		ctypes.POINTER(BNTagType),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetAutoDataTagsOfType(
		view: ctypes.POINTER(BNBinaryView), 
		addr: int, 
		tagType: ctypes.POINTER(BNTagType), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.POINTER(BNTag))]:
	result = _BNGetAutoDataTagsOfType(view, addr, tagType, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetAutoDebugTypeIdSource

_BNGetAutoDebugTypeIdSource = core.BNGetAutoDebugTypeIdSource
_BNGetAutoDebugTypeIdSource.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetAutoDebugTypeIdSource.argtypes = [
	]


# noinspection PyPep8Naming
def BNGetAutoDebugTypeIdSource(
		) -> Optional[Optional[str]]:
	result = _BNGetAutoDebugTypeIdSource()
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetAutoDemangledTypeIdSource

_BNGetAutoDemangledTypeIdSource = core.BNGetAutoDemangledTypeIdSource
_BNGetAutoDemangledTypeIdSource.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetAutoDemangledTypeIdSource.argtypes = [
	]


# noinspection PyPep8Naming
def BNGetAutoDemangledTypeIdSource(
		) -> Optional[Optional[str]]:
	result = _BNGetAutoDemangledTypeIdSource()
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetAutoFunctionTagReferences

_BNGetAutoFunctionTagReferences = core.BNGetAutoFunctionTagReferences
_BNGetAutoFunctionTagReferences.restype = ctypes.POINTER(BNTagReference)
_BNGetAutoFunctionTagReferences.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetAutoFunctionTagReferences(
		func: ctypes.POINTER(BNFunction), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNTagReference)]:
	result = _BNGetAutoFunctionTagReferences(func, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetAutoFunctionTags

_BNGetAutoFunctionTags = core.BNGetAutoFunctionTags
_BNGetAutoFunctionTags.restype = ctypes.POINTER(ctypes.POINTER(BNTag))
_BNGetAutoFunctionTags.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetAutoFunctionTags(
		func: ctypes.POINTER(BNFunction), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.POINTER(BNTag))]:
	result = _BNGetAutoFunctionTags(func, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetAutoFunctionTagsOfType

_BNGetAutoFunctionTagsOfType = core.BNGetAutoFunctionTagsOfType
_BNGetAutoFunctionTagsOfType.restype = ctypes.POINTER(ctypes.POINTER(BNTag))
_BNGetAutoFunctionTagsOfType.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNTagType),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetAutoFunctionTagsOfType(
		func: ctypes.POINTER(BNFunction), 
		tagType: ctypes.POINTER(BNTagType), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.POINTER(BNTag))]:
	result = _BNGetAutoFunctionTagsOfType(func, tagType, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetAutoPlatformTypeIdSource

_BNGetAutoPlatformTypeIdSource = core.BNGetAutoPlatformTypeIdSource
_BNGetAutoPlatformTypeIdSource.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetAutoPlatformTypeIdSource.argtypes = [
		ctypes.POINTER(BNPlatform),
	]


# noinspection PyPep8Naming
def BNGetAutoPlatformTypeIdSource(
		platform: ctypes.POINTER(BNPlatform)
		) -> Optional[Optional[str]]:
	result = _BNGetAutoPlatformTypeIdSource(platform)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetBackgroundAnalysisTask

_BNGetBackgroundAnalysisTask = core.BNGetBackgroundAnalysisTask
_BNGetBackgroundAnalysisTask.restype = ctypes.POINTER(BNBackgroundTask)
_BNGetBackgroundAnalysisTask.argtypes = [
		ctypes.POINTER(BNBinaryView),
	]


# noinspection PyPep8Naming
def BNGetBackgroundAnalysisTask(
		view: ctypes.POINTER(BNBinaryView)
		) -> Optional[ctypes.POINTER(BNBackgroundTask)]:
	result = _BNGetBackgroundAnalysisTask(view)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetBackgroundTaskProgressText

_BNGetBackgroundTaskProgressText = core.BNGetBackgroundTaskProgressText
_BNGetBackgroundTaskProgressText.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetBackgroundTaskProgressText.argtypes = [
		ctypes.POINTER(BNBackgroundTask),
	]


# noinspection PyPep8Naming
def BNGetBackgroundTaskProgressText(
		task: ctypes.POINTER(BNBackgroundTask)
		) -> Optional[Optional[str]]:
	result = _BNGetBackgroundTaskProgressText(task)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetBackgroundTaskRuntimeSeconds

_BNGetBackgroundTaskRuntimeSeconds = core.BNGetBackgroundTaskRuntimeSeconds
_BNGetBackgroundTaskRuntimeSeconds.restype = ctypes.c_ulonglong
_BNGetBackgroundTaskRuntimeSeconds.argtypes = [
		ctypes.POINTER(BNBackgroundTask),
	]


# noinspection PyPep8Naming
def BNGetBackgroundTaskRuntimeSeconds(
		task: ctypes.POINTER(BNBackgroundTask)
		) -> int:
	return _BNGetBackgroundTaskRuntimeSeconds(task)


# -------------------------------------------------------
# _BNGetBaseStructuresForStructure

_BNGetBaseStructuresForStructure = core.BNGetBaseStructuresForStructure
_BNGetBaseStructuresForStructure.restype = ctypes.POINTER(BNBaseStructure)
_BNGetBaseStructuresForStructure.argtypes = [
		ctypes.POINTER(BNStructure),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetBaseStructuresForStructure(
		s: ctypes.POINTER(BNStructure), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNBaseStructure)]:
	result = _BNGetBaseStructuresForStructure(s, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetBaseStructuresForStructureBuilder

_BNGetBaseStructuresForStructureBuilder = core.BNGetBaseStructuresForStructureBuilder
_BNGetBaseStructuresForStructureBuilder.restype = ctypes.POINTER(BNBaseStructure)
_BNGetBaseStructuresForStructureBuilder.argtypes = [
		ctypes.POINTER(BNStructureBuilder),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetBaseStructuresForStructureBuilder(
		s: ctypes.POINTER(BNStructureBuilder), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNBaseStructure)]:
	result = _BNGetBaseStructuresForStructureBuilder(s, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetBasicBlockArchitecture

_BNGetBasicBlockArchitecture = core.BNGetBasicBlockArchitecture
_BNGetBasicBlockArchitecture.restype = ctypes.POINTER(BNArchitecture)
_BNGetBasicBlockArchitecture.argtypes = [
		ctypes.POINTER(BNBasicBlock),
	]


# noinspection PyPep8Naming
def BNGetBasicBlockArchitecture(
		block: ctypes.POINTER(BNBasicBlock)
		) -> Optional[ctypes.POINTER(BNArchitecture)]:
	result = _BNGetBasicBlockArchitecture(block)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetBasicBlockDisassemblyText

_BNGetBasicBlockDisassemblyText = core.BNGetBasicBlockDisassemblyText
_BNGetBasicBlockDisassemblyText.restype = ctypes.POINTER(BNDisassemblyTextLine)
_BNGetBasicBlockDisassemblyText.argtypes = [
		ctypes.POINTER(BNBasicBlock),
		ctypes.POINTER(BNDisassemblySettings),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetBasicBlockDisassemblyText(
		block: ctypes.POINTER(BNBasicBlock), 
		settings: ctypes.POINTER(BNDisassemblySettings), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNDisassemblyTextLine)]:
	result = _BNGetBasicBlockDisassemblyText(block, settings, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetBasicBlockDominanceFrontier

_BNGetBasicBlockDominanceFrontier = core.BNGetBasicBlockDominanceFrontier
_BNGetBasicBlockDominanceFrontier.restype = ctypes.POINTER(ctypes.POINTER(BNBasicBlock))
_BNGetBasicBlockDominanceFrontier.argtypes = [
		ctypes.POINTER(BNBasicBlock),
		ctypes.POINTER(ctypes.c_ulonglong),
		ctypes.c_bool,
	]


# noinspection PyPep8Naming
def BNGetBasicBlockDominanceFrontier(
		block: ctypes.POINTER(BNBasicBlock), 
		count: ctypes.POINTER(ctypes.c_ulonglong), 
		post: bool
		) -> Optional[ctypes.POINTER(ctypes.POINTER(BNBasicBlock))]:
	result = _BNGetBasicBlockDominanceFrontier(block, count, post)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetBasicBlockDominatorTreeChildren

_BNGetBasicBlockDominatorTreeChildren = core.BNGetBasicBlockDominatorTreeChildren
_BNGetBasicBlockDominatorTreeChildren.restype = ctypes.POINTER(ctypes.POINTER(BNBasicBlock))
_BNGetBasicBlockDominatorTreeChildren.argtypes = [
		ctypes.POINTER(BNBasicBlock),
		ctypes.POINTER(ctypes.c_ulonglong),
		ctypes.c_bool,
	]


# noinspection PyPep8Naming
def BNGetBasicBlockDominatorTreeChildren(
		block: ctypes.POINTER(BNBasicBlock), 
		count: ctypes.POINTER(ctypes.c_ulonglong), 
		post: bool
		) -> Optional[ctypes.POINTER(ctypes.POINTER(BNBasicBlock))]:
	result = _BNGetBasicBlockDominatorTreeChildren(block, count, post)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetBasicBlockDominators

_BNGetBasicBlockDominators = core.BNGetBasicBlockDominators
_BNGetBasicBlockDominators.restype = ctypes.POINTER(ctypes.POINTER(BNBasicBlock))
_BNGetBasicBlockDominators.argtypes = [
		ctypes.POINTER(BNBasicBlock),
		ctypes.POINTER(ctypes.c_ulonglong),
		ctypes.c_bool,
	]


# noinspection PyPep8Naming
def BNGetBasicBlockDominators(
		block: ctypes.POINTER(BNBasicBlock), 
		count: ctypes.POINTER(ctypes.c_ulonglong), 
		post: bool
		) -> Optional[ctypes.POINTER(ctypes.POINTER(BNBasicBlock))]:
	result = _BNGetBasicBlockDominators(block, count, post)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetBasicBlockEnd

_BNGetBasicBlockEnd = core.BNGetBasicBlockEnd
_BNGetBasicBlockEnd.restype = ctypes.c_ulonglong
_BNGetBasicBlockEnd.argtypes = [
		ctypes.POINTER(BNBasicBlock),
	]


# noinspection PyPep8Naming
def BNGetBasicBlockEnd(
		block: ctypes.POINTER(BNBasicBlock)
		) -> int:
	return _BNGetBasicBlockEnd(block)


# -------------------------------------------------------
# _BNGetBasicBlockFunction

_BNGetBasicBlockFunction = core.BNGetBasicBlockFunction
_BNGetBasicBlockFunction.restype = ctypes.POINTER(BNFunction)
_BNGetBasicBlockFunction.argtypes = [
		ctypes.POINTER(BNBasicBlock),
	]


# noinspection PyPep8Naming
def BNGetBasicBlockFunction(
		block: ctypes.POINTER(BNBasicBlock)
		) -> Optional[ctypes.POINTER(BNFunction)]:
	result = _BNGetBasicBlockFunction(block)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetBasicBlockFunctionGraphType

_BNGetBasicBlockFunctionGraphType = core.BNGetBasicBlockFunctionGraphType
_BNGetBasicBlockFunctionGraphType.restype = FunctionGraphTypeEnum
_BNGetBasicBlockFunctionGraphType.argtypes = [
		ctypes.POINTER(BNBasicBlock),
	]


# noinspection PyPep8Naming
def BNGetBasicBlockFunctionGraphType(
		block: ctypes.POINTER(BNBasicBlock)
		) -> FunctionGraphType:
	return _BNGetBasicBlockFunctionGraphType(block)


# -------------------------------------------------------
# _BNGetBasicBlockHighLevelILFunction

_BNGetBasicBlockHighLevelILFunction = core.BNGetBasicBlockHighLevelILFunction
_BNGetBasicBlockHighLevelILFunction.restype = ctypes.POINTER(BNHighLevelILFunction)
_BNGetBasicBlockHighLevelILFunction.argtypes = [
		ctypes.POINTER(BNBasicBlock),
	]


# noinspection PyPep8Naming
def BNGetBasicBlockHighLevelILFunction(
		block: ctypes.POINTER(BNBasicBlock)
		) -> Optional[ctypes.POINTER(BNHighLevelILFunction)]:
	result = _BNGetBasicBlockHighLevelILFunction(block)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetBasicBlockHighlight

_BNGetBasicBlockHighlight = core.BNGetBasicBlockHighlight
_BNGetBasicBlockHighlight.restype = BNHighlightColor
_BNGetBasicBlockHighlight.argtypes = [
		ctypes.POINTER(BNBasicBlock),
	]


# noinspection PyPep8Naming
def BNGetBasicBlockHighlight(
		block: ctypes.POINTER(BNBasicBlock)
		) -> BNHighlightColor:
	return _BNGetBasicBlockHighlight(block)


# -------------------------------------------------------
# _BNGetBasicBlockImmediateDominator

_BNGetBasicBlockImmediateDominator = core.BNGetBasicBlockImmediateDominator
_BNGetBasicBlockImmediateDominator.restype = ctypes.POINTER(BNBasicBlock)
_BNGetBasicBlockImmediateDominator.argtypes = [
		ctypes.POINTER(BNBasicBlock),
		ctypes.c_bool,
	]


# noinspection PyPep8Naming
def BNGetBasicBlockImmediateDominator(
		block: ctypes.POINTER(BNBasicBlock), 
		post: bool
		) -> Optional[ctypes.POINTER(BNBasicBlock)]:
	result = _BNGetBasicBlockImmediateDominator(block, post)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetBasicBlockIncomingEdges

_BNGetBasicBlockIncomingEdges = core.BNGetBasicBlockIncomingEdges
_BNGetBasicBlockIncomingEdges.restype = ctypes.POINTER(BNBasicBlockEdge)
_BNGetBasicBlockIncomingEdges.argtypes = [
		ctypes.POINTER(BNBasicBlock),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetBasicBlockIncomingEdges(
		block: ctypes.POINTER(BNBasicBlock), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNBasicBlockEdge)]:
	result = _BNGetBasicBlockIncomingEdges(block, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetBasicBlockIndex

_BNGetBasicBlockIndex = core.BNGetBasicBlockIndex
_BNGetBasicBlockIndex.restype = ctypes.c_ulonglong
_BNGetBasicBlockIndex.argtypes = [
		ctypes.POINTER(BNBasicBlock),
	]


# noinspection PyPep8Naming
def BNGetBasicBlockIndex(
		block: ctypes.POINTER(BNBasicBlock)
		) -> int:
	return _BNGetBasicBlockIndex(block)


# -------------------------------------------------------
# _BNGetBasicBlockInstructionContainingAddress

_BNGetBasicBlockInstructionContainingAddress = core.BNGetBasicBlockInstructionContainingAddress
_BNGetBasicBlockInstructionContainingAddress.restype = ctypes.c_bool
_BNGetBasicBlockInstructionContainingAddress.argtypes = [
		ctypes.POINTER(BNBasicBlock),
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetBasicBlockInstructionContainingAddress(
		block: ctypes.POINTER(BNBasicBlock), 
		addr: int, 
		start: ctypes.POINTER(ctypes.c_ulonglong)
		) -> bool:
	return _BNGetBasicBlockInstructionContainingAddress(block, addr, start)


# -------------------------------------------------------
# _BNGetBasicBlockIteratedDominanceFrontier

_BNGetBasicBlockIteratedDominanceFrontier = core.BNGetBasicBlockIteratedDominanceFrontier
_BNGetBasicBlockIteratedDominanceFrontier.restype = ctypes.POINTER(ctypes.POINTER(BNBasicBlock))
_BNGetBasicBlockIteratedDominanceFrontier.argtypes = [
		ctypes.POINTER(ctypes.POINTER(BNBasicBlock)),
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetBasicBlockIteratedDominanceFrontier(
		blocks: ctypes.POINTER(ctypes.POINTER(BNBasicBlock)), 
		incomingCount: int, 
		outputCount: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.POINTER(BNBasicBlock))]:
	result = _BNGetBasicBlockIteratedDominanceFrontier(blocks, incomingCount, outputCount)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetBasicBlockLength

_BNGetBasicBlockLength = core.BNGetBasicBlockLength
_BNGetBasicBlockLength.restype = ctypes.c_ulonglong
_BNGetBasicBlockLength.argtypes = [
		ctypes.POINTER(BNBasicBlock),
	]


# noinspection PyPep8Naming
def BNGetBasicBlockLength(
		block: ctypes.POINTER(BNBasicBlock)
		) -> int:
	return _BNGetBasicBlockLength(block)


# -------------------------------------------------------
# _BNGetBasicBlockLowLevelILFunction

_BNGetBasicBlockLowLevelILFunction = core.BNGetBasicBlockLowLevelILFunction
_BNGetBasicBlockLowLevelILFunction.restype = ctypes.POINTER(BNLowLevelILFunction)
_BNGetBasicBlockLowLevelILFunction.argtypes = [
		ctypes.POINTER(BNBasicBlock),
	]


# noinspection PyPep8Naming
def BNGetBasicBlockLowLevelILFunction(
		block: ctypes.POINTER(BNBasicBlock)
		) -> Optional[ctypes.POINTER(BNLowLevelILFunction)]:
	result = _BNGetBasicBlockLowLevelILFunction(block)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetBasicBlockMediumLevelILFunction

_BNGetBasicBlockMediumLevelILFunction = core.BNGetBasicBlockMediumLevelILFunction
_BNGetBasicBlockMediumLevelILFunction.restype = ctypes.POINTER(BNMediumLevelILFunction)
_BNGetBasicBlockMediumLevelILFunction.argtypes = [
		ctypes.POINTER(BNBasicBlock),
	]


# noinspection PyPep8Naming
def BNGetBasicBlockMediumLevelILFunction(
		block: ctypes.POINTER(BNBasicBlock)
		) -> Optional[ctypes.POINTER(BNMediumLevelILFunction)]:
	result = _BNGetBasicBlockMediumLevelILFunction(block)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetBasicBlockOutgoingEdges

_BNGetBasicBlockOutgoingEdges = core.BNGetBasicBlockOutgoingEdges
_BNGetBasicBlockOutgoingEdges.restype = ctypes.POINTER(BNBasicBlockEdge)
_BNGetBasicBlockOutgoingEdges.argtypes = [
		ctypes.POINTER(BNBasicBlock),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetBasicBlockOutgoingEdges(
		block: ctypes.POINTER(BNBasicBlock), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNBasicBlockEdge)]:
	result = _BNGetBasicBlockOutgoingEdges(block, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetBasicBlockSource

_BNGetBasicBlockSource = core.BNGetBasicBlockSource
_BNGetBasicBlockSource.restype = ctypes.POINTER(BNBasicBlock)
_BNGetBasicBlockSource.argtypes = [
		ctypes.POINTER(BNBasicBlock),
	]


# noinspection PyPep8Naming
def BNGetBasicBlockSource(
		block: ctypes.POINTER(BNBasicBlock)
		) -> Optional[ctypes.POINTER(BNBasicBlock)]:
	result = _BNGetBasicBlockSource(block)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetBasicBlockSourceBlock

_BNGetBasicBlockSourceBlock = core.BNGetBasicBlockSourceBlock
_BNGetBasicBlockSourceBlock.restype = ctypes.POINTER(BNBasicBlock)
_BNGetBasicBlockSourceBlock.argtypes = [
		ctypes.POINTER(BNBasicBlock),
	]


# noinspection PyPep8Naming
def BNGetBasicBlockSourceBlock(
		block: ctypes.POINTER(BNBasicBlock)
		) -> Optional[ctypes.POINTER(BNBasicBlock)]:
	result = _BNGetBasicBlockSourceBlock(block)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetBasicBlockStart

_BNGetBasicBlockStart = core.BNGetBasicBlockStart
_BNGetBasicBlockStart.restype = ctypes.c_ulonglong
_BNGetBasicBlockStart.argtypes = [
		ctypes.POINTER(BNBasicBlock),
	]


# noinspection PyPep8Naming
def BNGetBasicBlockStart(
		block: ctypes.POINTER(BNBasicBlock)
		) -> int:
	return _BNGetBasicBlockStart(block)


# -------------------------------------------------------
# _BNGetBasicBlockStrictDominators

_BNGetBasicBlockStrictDominators = core.BNGetBasicBlockStrictDominators
_BNGetBasicBlockStrictDominators.restype = ctypes.POINTER(ctypes.POINTER(BNBasicBlock))
_BNGetBasicBlockStrictDominators.argtypes = [
		ctypes.POINTER(BNBasicBlock),
		ctypes.POINTER(ctypes.c_ulonglong),
		ctypes.c_bool,
	]


# noinspection PyPep8Naming
def BNGetBasicBlockStrictDominators(
		block: ctypes.POINTER(BNBasicBlock), 
		count: ctypes.POINTER(ctypes.c_ulonglong), 
		post: bool
		) -> Optional[ctypes.POINTER(ctypes.POINTER(BNBasicBlock))]:
	result = _BNGetBasicBlockStrictDominators(block, count, post)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetBasicBlocksForAddress

_BNGetBasicBlocksForAddress = core.BNGetBasicBlocksForAddress
_BNGetBasicBlocksForAddress.restype = ctypes.POINTER(ctypes.POINTER(BNBasicBlock))
_BNGetBasicBlocksForAddress.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetBasicBlocksForAddress(
		view: ctypes.POINTER(BNBinaryView), 
		addr: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.POINTER(BNBasicBlock))]:
	result = _BNGetBasicBlocksForAddress(view, addr, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetBasicBlocksStartingAtAddress

_BNGetBasicBlocksStartingAtAddress = core.BNGetBasicBlocksStartingAtAddress
_BNGetBasicBlocksStartingAtAddress.restype = ctypes.POINTER(ctypes.POINTER(BNBasicBlock))
_BNGetBasicBlocksStartingAtAddress.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetBasicBlocksStartingAtAddress(
		view: ctypes.POINTER(BNBinaryView), 
		addr: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.POINTER(BNBasicBlock))]:
	result = _BNGetBasicBlocksStartingAtAddress(view, addr, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetBinaryReaderEndianness

_BNGetBinaryReaderEndianness = core.BNGetBinaryReaderEndianness
_BNGetBinaryReaderEndianness.restype = EndiannessEnum
_BNGetBinaryReaderEndianness.argtypes = [
		ctypes.POINTER(BNBinaryReader),
	]


# noinspection PyPep8Naming
def BNGetBinaryReaderEndianness(
		stream: ctypes.POINTER(BNBinaryReader)
		) -> Endianness:
	return _BNGetBinaryReaderEndianness(stream)


# -------------------------------------------------------
# _BNGetBinaryReaderVirtualBase

_BNGetBinaryReaderVirtualBase = core.BNGetBinaryReaderVirtualBase
_BNGetBinaryReaderVirtualBase.restype = ctypes.c_ulonglong
_BNGetBinaryReaderVirtualBase.argtypes = [
		ctypes.POINTER(BNBinaryReader),
	]


# noinspection PyPep8Naming
def BNGetBinaryReaderVirtualBase(
		stream: ctypes.POINTER(BNBinaryReader)
		) -> int:
	return _BNGetBinaryReaderVirtualBase(stream)


# -------------------------------------------------------
# _BNGetBinaryViewDefaultLoadSettingsForData

_BNGetBinaryViewDefaultLoadSettingsForData = core.BNGetBinaryViewDefaultLoadSettingsForData
_BNGetBinaryViewDefaultLoadSettingsForData.restype = ctypes.POINTER(BNSettings)
_BNGetBinaryViewDefaultLoadSettingsForData.argtypes = [
		ctypes.POINTER(BNBinaryViewType),
		ctypes.POINTER(BNBinaryView),
	]


# noinspection PyPep8Naming
def BNGetBinaryViewDefaultLoadSettingsForData(
		type: ctypes.POINTER(BNBinaryViewType), 
		data: ctypes.POINTER(BNBinaryView)
		) -> Optional[ctypes.POINTER(BNSettings)]:
	result = _BNGetBinaryViewDefaultLoadSettingsForData(type, data)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetBinaryViewLoadSettingsForData

_BNGetBinaryViewLoadSettingsForData = core.BNGetBinaryViewLoadSettingsForData
_BNGetBinaryViewLoadSettingsForData.restype = ctypes.POINTER(BNSettings)
_BNGetBinaryViewLoadSettingsForData.argtypes = [
		ctypes.POINTER(BNBinaryViewType),
		ctypes.POINTER(BNBinaryView),
	]


# noinspection PyPep8Naming
def BNGetBinaryViewLoadSettingsForData(
		type: ctypes.POINTER(BNBinaryViewType), 
		data: ctypes.POINTER(BNBinaryView)
		) -> Optional[ctypes.POINTER(BNSettings)]:
	result = _BNGetBinaryViewLoadSettingsForData(type, data)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetBinaryViewTypeByName

_BNGetBinaryViewTypeByName = core.BNGetBinaryViewTypeByName
_BNGetBinaryViewTypeByName.restype = ctypes.POINTER(BNBinaryViewType)
_BNGetBinaryViewTypeByName.argtypes = [
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNGetBinaryViewTypeByName(
		name: Optional[str]
		) -> Optional[ctypes.POINTER(BNBinaryViewType)]:
	result = _BNGetBinaryViewTypeByName(cstr(name))
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetBinaryViewTypeLibraries

_BNGetBinaryViewTypeLibraries = core.BNGetBinaryViewTypeLibraries
_BNGetBinaryViewTypeLibraries.restype = ctypes.POINTER(ctypes.POINTER(BNTypeLibrary))
_BNGetBinaryViewTypeLibraries.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetBinaryViewTypeLibraries(
		view: ctypes.POINTER(BNBinaryView), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.POINTER(BNTypeLibrary))]:
	result = _BNGetBinaryViewTypeLibraries(view, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetBinaryViewTypeLibrary

_BNGetBinaryViewTypeLibrary = core.BNGetBinaryViewTypeLibrary
_BNGetBinaryViewTypeLibrary.restype = ctypes.POINTER(BNTypeLibrary)
_BNGetBinaryViewTypeLibrary.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNGetBinaryViewTypeLibrary(
		view: ctypes.POINTER(BNBinaryView), 
		name: Optional[str]
		) -> Optional[ctypes.POINTER(BNTypeLibrary)]:
	result = _BNGetBinaryViewTypeLibrary(view, cstr(name))
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetBinaryViewTypeLongName

_BNGetBinaryViewTypeLongName = core.BNGetBinaryViewTypeLongName
_BNGetBinaryViewTypeLongName.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetBinaryViewTypeLongName.argtypes = [
		ctypes.POINTER(BNBinaryViewType),
	]


# noinspection PyPep8Naming
def BNGetBinaryViewTypeLongName(
		type: ctypes.POINTER(BNBinaryViewType)
		) -> Optional[Optional[str]]:
	result = _BNGetBinaryViewTypeLongName(type)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetBinaryViewTypeName

_BNGetBinaryViewTypeName = core.BNGetBinaryViewTypeName
_BNGetBinaryViewTypeName.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetBinaryViewTypeName.argtypes = [
		ctypes.POINTER(BNBinaryViewType),
	]


# noinspection PyPep8Naming
def BNGetBinaryViewTypeName(
		type: ctypes.POINTER(BNBinaryViewType)
		) -> Optional[Optional[str]]:
	result = _BNGetBinaryViewTypeName(type)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetBinaryViewTypes

_BNGetBinaryViewTypes = core.BNGetBinaryViewTypes
_BNGetBinaryViewTypes.restype = ctypes.POINTER(ctypes.POINTER(BNBinaryViewType))
_BNGetBinaryViewTypes.argtypes = [
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetBinaryViewTypes(
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.POINTER(BNBinaryViewType))]:
	result = _BNGetBinaryViewTypes(count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetBinaryViewTypesForData

_BNGetBinaryViewTypesForData = core.BNGetBinaryViewTypesForData
_BNGetBinaryViewTypesForData.restype = ctypes.POINTER(ctypes.POINTER(BNBinaryViewType))
_BNGetBinaryViewTypesForData.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetBinaryViewTypesForData(
		data: ctypes.POINTER(BNBinaryView), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.POINTER(BNBinaryViewType))]:
	result = _BNGetBinaryViewTypesForData(data, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetBinaryWriterEndianness

_BNGetBinaryWriterEndianness = core.BNGetBinaryWriterEndianness
_BNGetBinaryWriterEndianness.restype = EndiannessEnum
_BNGetBinaryWriterEndianness.argtypes = [
		ctypes.POINTER(BNBinaryWriter),
	]


# noinspection PyPep8Naming
def BNGetBinaryWriterEndianness(
		stream: ctypes.POINTER(BNBinaryWriter)
		) -> Endianness:
	return _BNGetBinaryWriterEndianness(stream)


# -------------------------------------------------------
# _BNGetBuildId

_BNGetBuildId = core.BNGetBuildId
_BNGetBuildId.restype = ctypes.c_uint
_BNGetBuildId.argtypes = [
	]


# noinspection PyPep8Naming
def BNGetBuildId(
		) -> int:
	return _BNGetBuildId()


# -------------------------------------------------------
# _BNGetBundledPluginDirectory

_BNGetBundledPluginDirectory = core.BNGetBundledPluginDirectory
_BNGetBundledPluginDirectory.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetBundledPluginDirectory.argtypes = [
	]


# noinspection PyPep8Naming
def BNGetBundledPluginDirectory(
		) -> Optional[Optional[str]]:
	result = _BNGetBundledPluginDirectory()
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetCallRegisterStackAdjustment

_BNGetCallRegisterStackAdjustment = core.BNGetCallRegisterStackAdjustment
_BNGetCallRegisterStackAdjustment.restype = ctypes.POINTER(BNRegisterStackAdjustment)
_BNGetCallRegisterStackAdjustment.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNArchitecture),
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetCallRegisterStackAdjustment(
		func: ctypes.POINTER(BNFunction), 
		arch: ctypes.POINTER(BNArchitecture), 
		addr: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNRegisterStackAdjustment)]:
	result = _BNGetCallRegisterStackAdjustment(func, arch, addr, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetCallRegisterStackAdjustmentForRegisterStack

_BNGetCallRegisterStackAdjustmentForRegisterStack = core.BNGetCallRegisterStackAdjustmentForRegisterStack
_BNGetCallRegisterStackAdjustmentForRegisterStack.restype = BNRegisterStackAdjustment
_BNGetCallRegisterStackAdjustmentForRegisterStack.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNArchitecture),
		ctypes.c_ulonglong,
		ctypes.c_uint,
	]


# noinspection PyPep8Naming
def BNGetCallRegisterStackAdjustmentForRegisterStack(
		func: ctypes.POINTER(BNFunction), 
		arch: ctypes.POINTER(BNArchitecture), 
		addr: int, 
		regStack: int
		) -> BNRegisterStackAdjustment:
	return _BNGetCallRegisterStackAdjustmentForRegisterStack(func, arch, addr, regStack)


# -------------------------------------------------------
# _BNGetCallStackAdjustment

_BNGetCallStackAdjustment = core.BNGetCallStackAdjustment
_BNGetCallStackAdjustment.restype = BNOffsetWithConfidence
_BNGetCallStackAdjustment.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNArchitecture),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetCallStackAdjustment(
		func: ctypes.POINTER(BNFunction), 
		arch: ctypes.POINTER(BNArchitecture), 
		addr: int
		) -> BNOffsetWithConfidence:
	return _BNGetCallStackAdjustment(func, arch, addr)


# -------------------------------------------------------
# _BNGetCallTypeAdjustment

_BNGetCallTypeAdjustment = core.BNGetCallTypeAdjustment
_BNGetCallTypeAdjustment.restype = BNTypeWithConfidence
_BNGetCallTypeAdjustment.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNArchitecture),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetCallTypeAdjustment(
		func: ctypes.POINTER(BNFunction), 
		arch: ctypes.POINTER(BNArchitecture), 
		addr: int
		) -> BNTypeWithConfidence:
	return _BNGetCallTypeAdjustment(func, arch, addr)


# -------------------------------------------------------
# _BNGetCalleeSavedRegisters

_BNGetCalleeSavedRegisters = core.BNGetCalleeSavedRegisters
_BNGetCalleeSavedRegisters.restype = ctypes.POINTER(ctypes.c_uint)
_BNGetCalleeSavedRegisters.argtypes = [
		ctypes.POINTER(BNCallingConvention),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetCalleeSavedRegisters(
		cc: ctypes.POINTER(BNCallingConvention), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_uint)]:
	result = _BNGetCalleeSavedRegisters(cc, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetCallees

_BNGetCallees = core.BNGetCallees
_BNGetCallees.restype = ctypes.POINTER(ctypes.c_ulonglong)
_BNGetCallees.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNReferenceSource),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetCallees(
		view: ctypes.POINTER(BNBinaryView), 
		callSite: ctypes.POINTER(BNReferenceSource), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_ulonglong)]:
	result = _BNGetCallees(view, callSite, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetCallerSavedRegisters

_BNGetCallerSavedRegisters = core.BNGetCallerSavedRegisters
_BNGetCallerSavedRegisters.restype = ctypes.POINTER(ctypes.c_uint)
_BNGetCallerSavedRegisters.argtypes = [
		ctypes.POINTER(BNCallingConvention),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetCallerSavedRegisters(
		cc: ctypes.POINTER(BNCallingConvention), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_uint)]:
	result = _BNGetCallerSavedRegisters(cc, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetCallers

_BNGetCallers = core.BNGetCallers
_BNGetCallers.restype = ctypes.POINTER(BNReferenceSource)
_BNGetCallers.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetCallers(
		view: ctypes.POINTER(BNBinaryView), 
		callee: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNReferenceSource)]:
	result = _BNGetCallers(view, callee, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetCallingConventionArchitecture

_BNGetCallingConventionArchitecture = core.BNGetCallingConventionArchitecture
_BNGetCallingConventionArchitecture.restype = ctypes.POINTER(BNArchitecture)
_BNGetCallingConventionArchitecture.argtypes = [
		ctypes.POINTER(BNCallingConvention),
	]


# noinspection PyPep8Naming
def BNGetCallingConventionArchitecture(
		cc: ctypes.POINTER(BNCallingConvention)
		) -> Optional[ctypes.POINTER(BNArchitecture)]:
	result = _BNGetCallingConventionArchitecture(cc)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetCallingConventionName

_BNGetCallingConventionName = core.BNGetCallingConventionName
_BNGetCallingConventionName.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetCallingConventionName.argtypes = [
		ctypes.POINTER(BNCallingConvention),
	]


# noinspection PyPep8Naming
def BNGetCallingConventionName(
		cc: ctypes.POINTER(BNCallingConvention)
		) -> Optional[Optional[str]]:
	result = _BNGetCallingConventionName(cc)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetChildType

_BNGetChildType = core.BNGetChildType
_BNGetChildType.restype = BNTypeWithConfidence
_BNGetChildType.argtypes = [
		ctypes.POINTER(BNType),
	]


# noinspection PyPep8Naming
def BNGetChildType(
		type: ctypes.POINTER(BNType)
		) -> BNTypeWithConfidence:
	return _BNGetChildType(type)


# -------------------------------------------------------
# _BNGetChoiceInput

_BNGetChoiceInput = core.BNGetChoiceInput
_BNGetChoiceInput.restype = ctypes.c_bool
_BNGetChoiceInput.argtypes = [
		ctypes.POINTER(ctypes.c_ulonglong),
		ctypes.c_char_p,
		ctypes.c_char_p,
		ctypes.POINTER(ctypes.c_char_p),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetChoiceInput(
		result: ctypes.POINTER(ctypes.c_ulonglong), 
		prompt: Optional[str], 
		title: Optional[str], 
		choices: ctypes.POINTER(ctypes.c_char_p), 
		count: int
		) -> bool:
	return _BNGetChoiceInput(result, cstr(prompt), cstr(title), choices, count)


# -------------------------------------------------------
# _BNGetCodeReferences

_BNGetCodeReferences = core.BNGetCodeReferences
_BNGetCodeReferences.restype = ctypes.POINTER(BNReferenceSource)
_BNGetCodeReferences.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetCodeReferences(
		view: ctypes.POINTER(BNBinaryView), 
		addr: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNReferenceSource)]:
	result = _BNGetCodeReferences(view, addr, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetCodeReferencesForType

_BNGetCodeReferencesForType = core.BNGetCodeReferencesForType
_BNGetCodeReferencesForType.restype = ctypes.POINTER(BNReferenceSource)
_BNGetCodeReferencesForType.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNQualifiedName),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetCodeReferencesForType(
		view: ctypes.POINTER(BNBinaryView), 
		type: ctypes.POINTER(BNQualifiedName), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNReferenceSource)]:
	result = _BNGetCodeReferencesForType(view, type, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetCodeReferencesForTypeField

_BNGetCodeReferencesForTypeField = core.BNGetCodeReferencesForTypeField
_BNGetCodeReferencesForTypeField.restype = ctypes.POINTER(BNTypeFieldReference)
_BNGetCodeReferencesForTypeField.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNQualifiedName),
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetCodeReferencesForTypeField(
		view: ctypes.POINTER(BNBinaryView), 
		type: ctypes.POINTER(BNQualifiedName), 
		offset: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNTypeFieldReference)]:
	result = _BNGetCodeReferencesForTypeField(view, type, offset, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetCodeReferencesForTypeFieldsFrom

_BNGetCodeReferencesForTypeFieldsFrom = core.BNGetCodeReferencesForTypeFieldsFrom
_BNGetCodeReferencesForTypeFieldsFrom.restype = ctypes.POINTER(BNTypeReferenceSource)
_BNGetCodeReferencesForTypeFieldsFrom.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNReferenceSource),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetCodeReferencesForTypeFieldsFrom(
		view: ctypes.POINTER(BNBinaryView), 
		addr: ctypes.POINTER(BNReferenceSource), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNTypeReferenceSource)]:
	result = _BNGetCodeReferencesForTypeFieldsFrom(view, addr, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetCodeReferencesForTypeFieldsFromInRange

_BNGetCodeReferencesForTypeFieldsFromInRange = core.BNGetCodeReferencesForTypeFieldsFromInRange
_BNGetCodeReferencesForTypeFieldsFromInRange.restype = ctypes.POINTER(BNTypeReferenceSource)
_BNGetCodeReferencesForTypeFieldsFromInRange.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNReferenceSource),
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetCodeReferencesForTypeFieldsFromInRange(
		view: ctypes.POINTER(BNBinaryView), 
		addr: ctypes.POINTER(BNReferenceSource), 
		len: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNTypeReferenceSource)]:
	result = _BNGetCodeReferencesForTypeFieldsFromInRange(view, addr, len, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetCodeReferencesForTypeFrom

_BNGetCodeReferencesForTypeFrom = core.BNGetCodeReferencesForTypeFrom
_BNGetCodeReferencesForTypeFrom.restype = ctypes.POINTER(BNTypeReferenceSource)
_BNGetCodeReferencesForTypeFrom.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNReferenceSource),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetCodeReferencesForTypeFrom(
		view: ctypes.POINTER(BNBinaryView), 
		addr: ctypes.POINTER(BNReferenceSource), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNTypeReferenceSource)]:
	result = _BNGetCodeReferencesForTypeFrom(view, addr, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetCodeReferencesForTypeFromInRange

_BNGetCodeReferencesForTypeFromInRange = core.BNGetCodeReferencesForTypeFromInRange
_BNGetCodeReferencesForTypeFromInRange.restype = ctypes.POINTER(BNTypeReferenceSource)
_BNGetCodeReferencesForTypeFromInRange.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNReferenceSource),
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetCodeReferencesForTypeFromInRange(
		view: ctypes.POINTER(BNBinaryView), 
		addr: ctypes.POINTER(BNReferenceSource), 
		len: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNTypeReferenceSource)]:
	result = _BNGetCodeReferencesForTypeFromInRange(view, addr, len, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetCodeReferencesFrom

_BNGetCodeReferencesFrom = core.BNGetCodeReferencesFrom
_BNGetCodeReferencesFrom.restype = ctypes.POINTER(ctypes.c_ulonglong)
_BNGetCodeReferencesFrom.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNReferenceSource),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetCodeReferencesFrom(
		view: ctypes.POINTER(BNBinaryView), 
		src: ctypes.POINTER(BNReferenceSource), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_ulonglong)]:
	result = _BNGetCodeReferencesFrom(view, src, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetCodeReferencesFromInRange

_BNGetCodeReferencesFromInRange = core.BNGetCodeReferencesFromInRange
_BNGetCodeReferencesFromInRange.restype = ctypes.POINTER(ctypes.c_ulonglong)
_BNGetCodeReferencesFromInRange.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNReferenceSource),
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetCodeReferencesFromInRange(
		view: ctypes.POINTER(BNBinaryView), 
		src: ctypes.POINTER(BNReferenceSource), 
		len: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_ulonglong)]:
	result = _BNGetCodeReferencesFromInRange(view, src, len, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetCodeReferencesInRange

_BNGetCodeReferencesInRange = core.BNGetCodeReferencesInRange
_BNGetCodeReferencesInRange.restype = ctypes.POINTER(BNReferenceSource)
_BNGetCodeReferencesInRange.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetCodeReferencesInRange(
		view: ctypes.POINTER(BNBinaryView), 
		addr: int, 
		len: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNReferenceSource)]:
	result = _BNGetCodeReferencesInRange(view, addr, len, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetCommentForAddress

_BNGetCommentForAddress = core.BNGetCommentForAddress
_BNGetCommentForAddress.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetCommentForAddress.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetCommentForAddress(
		func: ctypes.POINTER(BNFunction), 
		addr: int
		) -> Optional[Optional[str]]:
	result = _BNGetCommentForAddress(func, addr)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetCommentedAddresses

_BNGetCommentedAddresses = core.BNGetCommentedAddresses
_BNGetCommentedAddresses.restype = ctypes.POINTER(ctypes.c_ulonglong)
_BNGetCommentedAddresses.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetCommentedAddresses(
		func: ctypes.POINTER(BNFunction), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_ulonglong)]:
	result = _BNGetCommentedAddresses(func, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetComponentByGuid

_BNGetComponentByGuid = core.BNGetComponentByGuid
_BNGetComponentByGuid.restype = ctypes.POINTER(BNComponent)
_BNGetComponentByGuid.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNGetComponentByGuid(
		view: ctypes.POINTER(BNBinaryView), 
		guid: Optional[str]
		) -> Optional[ctypes.POINTER(BNComponent)]:
	result = _BNGetComponentByGuid(view, cstr(guid))
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetComponentByPath

_BNGetComponentByPath = core.BNGetComponentByPath
_BNGetComponentByPath.restype = ctypes.POINTER(BNComponent)
_BNGetComponentByPath.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNGetComponentByPath(
		view: ctypes.POINTER(BNBinaryView), 
		path: Optional[str]
		) -> Optional[ctypes.POINTER(BNComponent)]:
	result = _BNGetComponentByPath(view, cstr(path))
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetConstantData

_BNGetConstantData = core.BNGetConstantData
_BNGetConstantData.restype = ctypes.POINTER(BNDataBuffer)
_BNGetConstantData.argtypes = [
		ctypes.POINTER(BNFunction),
		RegisterValueTypeEnum,
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetConstantData(
		func: ctypes.POINTER(BNFunction), 
		state: RegisterValueType, 
		value: int, 
		size: int
		) -> Optional[ctypes.POINTER(BNDataBuffer)]:
	result = _BNGetConstantData(func, state, value, size)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetConstantsReferencedByInstruction

_BNGetConstantsReferencedByInstruction = core.BNGetConstantsReferencedByInstruction
_BNGetConstantsReferencedByInstruction.restype = ctypes.POINTER(BNConstantReference)
_BNGetConstantsReferencedByInstruction.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNArchitecture),
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetConstantsReferencedByInstruction(
		func: ctypes.POINTER(BNFunction), 
		arch: ctypes.POINTER(BNArchitecture), 
		addr: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNConstantReference)]:
	result = _BNGetConstantsReferencedByInstruction(func, arch, addr, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetConstantsReferencedByInstructionIfAvailable

_BNGetConstantsReferencedByInstructionIfAvailable = core.BNGetConstantsReferencedByInstructionIfAvailable
_BNGetConstantsReferencedByInstructionIfAvailable.restype = ctypes.POINTER(BNConstantReference)
_BNGetConstantsReferencedByInstructionIfAvailable.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNArchitecture),
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetConstantsReferencedByInstructionIfAvailable(
		func: ctypes.POINTER(BNFunction), 
		arch: ctypes.POINTER(BNArchitecture), 
		addr: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNConstantReference)]:
	result = _BNGetConstantsReferencedByInstructionIfAvailable(func, arch, addr, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetCurrentCoreABIVersion

_BNGetCurrentCoreABIVersion = core.BNGetCurrentCoreABIVersion
_BNGetCurrentCoreABIVersion.restype = ctypes.c_uint
_BNGetCurrentCoreABIVersion.argtypes = [
	]


# noinspection PyPep8Naming
def BNGetCurrentCoreABIVersion(
		) -> int:
	return _BNGetCurrentCoreABIVersion()


# -------------------------------------------------------
# _BNGetCurrentOffset

_BNGetCurrentOffset = core.BNGetCurrentOffset
_BNGetCurrentOffset.restype = ctypes.c_ulonglong
_BNGetCurrentOffset.argtypes = [
		ctypes.POINTER(BNFileMetadata),
	]


# noinspection PyPep8Naming
def BNGetCurrentOffset(
		file: ctypes.POINTER(BNFileMetadata)
		) -> int:
	return _BNGetCurrentOffset(file)


# -------------------------------------------------------
# _BNGetCurrentStackTraceString

_BNGetCurrentStackTraceString = core.BNGetCurrentStackTraceString
_BNGetCurrentStackTraceString.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetCurrentStackTraceString.argtypes = [
	]


# noinspection PyPep8Naming
def BNGetCurrentStackTraceString(
		) -> Optional[Optional[str]]:
	result = _BNGetCurrentStackTraceString()
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetCurrentView

_BNGetCurrentView = core.BNGetCurrentView
_BNGetCurrentView.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetCurrentView.argtypes = [
		ctypes.POINTER(BNFileMetadata),
	]


# noinspection PyPep8Naming
def BNGetCurrentView(
		file: ctypes.POINTER(BNFileMetadata)
		) -> Optional[Optional[str]]:
	result = _BNGetCurrentView(file)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetDataBufferByte

_BNGetDataBufferByte = core.BNGetDataBufferByte
_BNGetDataBufferByte.restype = ctypes.c_ubyte
_BNGetDataBufferByte.argtypes = [
		ctypes.POINTER(BNDataBuffer),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetDataBufferByte(
		buf: ctypes.POINTER(BNDataBuffer), 
		offset: int
		) -> int:
	return _BNGetDataBufferByte(buf, offset)


# -------------------------------------------------------
# _BNGetDataBufferContents

_BNGetDataBufferContents = core.BNGetDataBufferContents
_BNGetDataBufferContents.restype = ctypes.c_void_p
_BNGetDataBufferContents.argtypes = [
		ctypes.POINTER(BNDataBuffer),
	]


# noinspection PyPep8Naming
def BNGetDataBufferContents(
		buf: ctypes.POINTER(BNDataBuffer)
		) -> Optional[Optional[ctypes.c_void_p]]:
	result = _BNGetDataBufferContents(buf)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetDataBufferContentsAt

_BNGetDataBufferContentsAt = core.BNGetDataBufferContentsAt
_BNGetDataBufferContentsAt.restype = ctypes.c_void_p
_BNGetDataBufferContentsAt.argtypes = [
		ctypes.POINTER(BNDataBuffer),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetDataBufferContentsAt(
		buf: ctypes.POINTER(BNDataBuffer), 
		offset: int
		) -> Optional[Optional[ctypes.c_void_p]]:
	result = _BNGetDataBufferContentsAt(buf, offset)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetDataBufferLength

_BNGetDataBufferLength = core.BNGetDataBufferLength
_BNGetDataBufferLength.restype = ctypes.c_ulonglong
_BNGetDataBufferLength.argtypes = [
		ctypes.POINTER(BNDataBuffer),
	]


# noinspection PyPep8Naming
def BNGetDataBufferLength(
		buf: ctypes.POINTER(BNDataBuffer)
		) -> int:
	return _BNGetDataBufferLength(buf)


# -------------------------------------------------------
# _BNGetDataBufferSlice

_BNGetDataBufferSlice = core.BNGetDataBufferSlice
_BNGetDataBufferSlice.restype = ctypes.POINTER(BNDataBuffer)
_BNGetDataBufferSlice.argtypes = [
		ctypes.POINTER(BNDataBuffer),
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetDataBufferSlice(
		buf: ctypes.POINTER(BNDataBuffer), 
		start: int, 
		len: int
		) -> Optional[ctypes.POINTER(BNDataBuffer)]:
	result = _BNGetDataBufferSlice(buf, start, len)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetDataReferences

_BNGetDataReferences = core.BNGetDataReferences
_BNGetDataReferences.restype = ctypes.POINTER(ctypes.c_ulonglong)
_BNGetDataReferences.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetDataReferences(
		view: ctypes.POINTER(BNBinaryView), 
		addr: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_ulonglong)]:
	result = _BNGetDataReferences(view, addr, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetDataReferencesForType

_BNGetDataReferencesForType = core.BNGetDataReferencesForType
_BNGetDataReferencesForType.restype = ctypes.POINTER(ctypes.c_ulonglong)
_BNGetDataReferencesForType.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNQualifiedName),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetDataReferencesForType(
		view: ctypes.POINTER(BNBinaryView), 
		type: ctypes.POINTER(BNQualifiedName), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_ulonglong)]:
	result = _BNGetDataReferencesForType(view, type, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetDataReferencesForTypeField

_BNGetDataReferencesForTypeField = core.BNGetDataReferencesForTypeField
_BNGetDataReferencesForTypeField.restype = ctypes.POINTER(ctypes.c_ulonglong)
_BNGetDataReferencesForTypeField.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNQualifiedName),
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetDataReferencesForTypeField(
		view: ctypes.POINTER(BNBinaryView), 
		type: ctypes.POINTER(BNQualifiedName), 
		offset: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_ulonglong)]:
	result = _BNGetDataReferencesForTypeField(view, type, offset, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetDataReferencesFrom

_BNGetDataReferencesFrom = core.BNGetDataReferencesFrom
_BNGetDataReferencesFrom.restype = ctypes.POINTER(ctypes.c_ulonglong)
_BNGetDataReferencesFrom.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetDataReferencesFrom(
		view: ctypes.POINTER(BNBinaryView), 
		addr: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_ulonglong)]:
	result = _BNGetDataReferencesFrom(view, addr, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetDataReferencesFromForTypeField

_BNGetDataReferencesFromForTypeField = core.BNGetDataReferencesFromForTypeField
_BNGetDataReferencesFromForTypeField.restype = ctypes.POINTER(ctypes.c_ulonglong)
_BNGetDataReferencesFromForTypeField.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNQualifiedName),
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetDataReferencesFromForTypeField(
		view: ctypes.POINTER(BNBinaryView), 
		type: ctypes.POINTER(BNQualifiedName), 
		offset: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_ulonglong)]:
	result = _BNGetDataReferencesFromForTypeField(view, type, offset, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetDataReferencesFromInRange

_BNGetDataReferencesFromInRange = core.BNGetDataReferencesFromInRange
_BNGetDataReferencesFromInRange.restype = ctypes.POINTER(ctypes.c_ulonglong)
_BNGetDataReferencesFromInRange.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetDataReferencesFromInRange(
		view: ctypes.POINTER(BNBinaryView), 
		addr: int, 
		len: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_ulonglong)]:
	result = _BNGetDataReferencesFromInRange(view, addr, len, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetDataReferencesInRange

_BNGetDataReferencesInRange = core.BNGetDataReferencesInRange
_BNGetDataReferencesInRange.restype = ctypes.POINTER(ctypes.c_ulonglong)
_BNGetDataReferencesInRange.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetDataReferencesInRange(
		view: ctypes.POINTER(BNBinaryView), 
		addr: int, 
		len: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_ulonglong)]:
	result = _BNGetDataReferencesInRange(view, addr, len, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetDataRendererContainer

_BNGetDataRendererContainer = core.BNGetDataRendererContainer
_BNGetDataRendererContainer.restype = ctypes.POINTER(BNDataRendererContainer)
_BNGetDataRendererContainer.argtypes = [
	]


# noinspection PyPep8Naming
def BNGetDataRendererContainer(
		) -> Optional[ctypes.POINTER(BNDataRendererContainer)]:
	result = _BNGetDataRendererContainer()
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetDataTagReferences

_BNGetDataTagReferences = core.BNGetDataTagReferences
_BNGetDataTagReferences.restype = ctypes.POINTER(BNTagReference)
_BNGetDataTagReferences.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetDataTagReferences(
		view: ctypes.POINTER(BNBinaryView), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNTagReference)]:
	result = _BNGetDataTagReferences(view, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetDataTags

_BNGetDataTags = core.BNGetDataTags
_BNGetDataTags.restype = ctypes.POINTER(ctypes.POINTER(BNTag))
_BNGetDataTags.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetDataTags(
		view: ctypes.POINTER(BNBinaryView), 
		addr: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.POINTER(BNTag))]:
	result = _BNGetDataTags(view, addr, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetDataTagsInRange

_BNGetDataTagsInRange = core.BNGetDataTagsInRange
_BNGetDataTagsInRange.restype = ctypes.POINTER(BNTagReference)
_BNGetDataTagsInRange.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetDataTagsInRange(
		view: ctypes.POINTER(BNBinaryView), 
		start: int, 
		end: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNTagReference)]:
	result = _BNGetDataTagsInRange(view, start, end, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetDataTagsOfType

_BNGetDataTagsOfType = core.BNGetDataTagsOfType
_BNGetDataTagsOfType.restype = ctypes.POINTER(ctypes.POINTER(BNTag))
_BNGetDataTagsOfType.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
		ctypes.POINTER(BNTagType),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetDataTagsOfType(
		view: ctypes.POINTER(BNBinaryView), 
		addr: int, 
		tagType: ctypes.POINTER(BNTagType), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.POINTER(BNTag))]:
	result = _BNGetDataTagsOfType(view, addr, tagType, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetDataVariableAtAddress

_BNGetDataVariableAtAddress = core.BNGetDataVariableAtAddress
_BNGetDataVariableAtAddress.restype = ctypes.c_bool
_BNGetDataVariableAtAddress.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
		ctypes.POINTER(BNDataVariable),
	]


# noinspection PyPep8Naming
def BNGetDataVariableAtAddress(
		view: ctypes.POINTER(BNBinaryView), 
		addr: int, 
		var: ctypes.POINTER(BNDataVariable)
		) -> bool:
	return _BNGetDataVariableAtAddress(view, addr, var)


# -------------------------------------------------------
# _BNGetDataVariableParentComponents

_BNGetDataVariableParentComponents = core.BNGetDataVariableParentComponents
_BNGetDataVariableParentComponents.restype = ctypes.POINTER(ctypes.POINTER(BNComponent))
_BNGetDataVariableParentComponents.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetDataVariableParentComponents(
		view: ctypes.POINTER(BNBinaryView), 
		dataVariable: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.POINTER(BNComponent))]:
	result = _BNGetDataVariableParentComponents(view, dataVariable, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetDataVariables

_BNGetDataVariables = core.BNGetDataVariables
_BNGetDataVariables.restype = ctypes.POINTER(BNDataVariable)
_BNGetDataVariables.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetDataVariables(
		view: ctypes.POINTER(BNBinaryView), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNDataVariable)]:
	result = _BNGetDataVariables(view, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetDatabaseCurrentSnapshot

_BNGetDatabaseCurrentSnapshot = core.BNGetDatabaseCurrentSnapshot
_BNGetDatabaseCurrentSnapshot.restype = ctypes.POINTER(BNSnapshot)
_BNGetDatabaseCurrentSnapshot.argtypes = [
		ctypes.POINTER(BNDatabase),
	]


# noinspection PyPep8Naming
def BNGetDatabaseCurrentSnapshot(
		database: ctypes.POINTER(BNDatabase)
		) -> Optional[ctypes.POINTER(BNSnapshot)]:
	result = _BNGetDatabaseCurrentSnapshot(database)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetDatabaseFile

_BNGetDatabaseFile = core.BNGetDatabaseFile
_BNGetDatabaseFile.restype = ctypes.POINTER(BNFileMetadata)
_BNGetDatabaseFile.argtypes = [
		ctypes.POINTER(BNDatabase),
	]


# noinspection PyPep8Naming
def BNGetDatabaseFile(
		database: ctypes.POINTER(BNDatabase)
		) -> Optional[ctypes.POINTER(BNFileMetadata)]:
	result = _BNGetDatabaseFile(database)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetDatabaseGlobalKeys

_BNGetDatabaseGlobalKeys = core.BNGetDatabaseGlobalKeys
_BNGetDatabaseGlobalKeys.restype = ctypes.POINTER(ctypes.c_char_p)
_BNGetDatabaseGlobalKeys.argtypes = [
		ctypes.POINTER(BNDatabase),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetDatabaseGlobalKeys(
		database: ctypes.POINTER(BNDatabase), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_char_p)]:
	result = _BNGetDatabaseGlobalKeys(database, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetDatabaseSnapshot

_BNGetDatabaseSnapshot = core.BNGetDatabaseSnapshot
_BNGetDatabaseSnapshot.restype = ctypes.POINTER(BNSnapshot)
_BNGetDatabaseSnapshot.argtypes = [
		ctypes.POINTER(BNDatabase),
		ctypes.c_longlong,
	]


# noinspection PyPep8Naming
def BNGetDatabaseSnapshot(
		database: ctypes.POINTER(BNDatabase), 
		id: int
		) -> Optional[ctypes.POINTER(BNSnapshot)]:
	result = _BNGetDatabaseSnapshot(database, id)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetDatabaseSnapshots

_BNGetDatabaseSnapshots = core.BNGetDatabaseSnapshots
_BNGetDatabaseSnapshots.restype = ctypes.POINTER(ctypes.POINTER(BNSnapshot))
_BNGetDatabaseSnapshots.argtypes = [
		ctypes.POINTER(BNDatabase),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetDatabaseSnapshots(
		database: ctypes.POINTER(BNDatabase), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.POINTER(BNSnapshot))]:
	result = _BNGetDatabaseSnapshots(database, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetDebugDataVariableByAddress

_BNGetDebugDataVariableByAddress = core.BNGetDebugDataVariableByAddress
_BNGetDebugDataVariableByAddress.restype = ctypes.POINTER(BNDataVariableAndName)
_BNGetDebugDataVariableByAddress.argtypes = [
		ctypes.POINTER(BNDebugInfo),
		ctypes.c_char_p,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetDebugDataVariableByAddress(
		debugInfo: ctypes.POINTER(BNDebugInfo), 
		parserName: Optional[str], 
		address: int
		) -> Optional[ctypes.POINTER(BNDataVariableAndName)]:
	result = _BNGetDebugDataVariableByAddress(debugInfo, cstr(parserName), address)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetDebugDataVariableByName

_BNGetDebugDataVariableByName = core.BNGetDebugDataVariableByName
_BNGetDebugDataVariableByName.restype = ctypes.POINTER(BNDataVariableAndName)
_BNGetDebugDataVariableByName.argtypes = [
		ctypes.POINTER(BNDebugInfo),
		ctypes.c_char_p,
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNGetDebugDataVariableByName(
		debugInfo: ctypes.POINTER(BNDebugInfo), 
		parserName: Optional[str], 
		variableName: Optional[str]
		) -> Optional[ctypes.POINTER(BNDataVariableAndName)]:
	result = _BNGetDebugDataVariableByName(debugInfo, cstr(parserName), cstr(variableName))
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetDebugDataVariables

_BNGetDebugDataVariables = core.BNGetDebugDataVariables
_BNGetDebugDataVariables.restype = ctypes.POINTER(BNDataVariableAndName)
_BNGetDebugDataVariables.argtypes = [
		ctypes.POINTER(BNDebugInfo),
		ctypes.c_char_p,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetDebugDataVariables(
		debugInfo: ctypes.POINTER(BNDebugInfo), 
		name: Optional[str], 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNDataVariableAndName)]:
	result = _BNGetDebugDataVariables(debugInfo, cstr(name), count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetDebugDataVariablesByAddress

_BNGetDebugDataVariablesByAddress = core.BNGetDebugDataVariablesByAddress
_BNGetDebugDataVariablesByAddress.restype = ctypes.POINTER(BNDataVariableAndNameAndDebugParser)
_BNGetDebugDataVariablesByAddress.argtypes = [
		ctypes.POINTER(BNDebugInfo),
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetDebugDataVariablesByAddress(
		debugInfo: ctypes.POINTER(BNDebugInfo), 
		address: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNDataVariableAndNameAndDebugParser)]:
	result = _BNGetDebugDataVariablesByAddress(debugInfo, address, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetDebugDataVariablesByName

_BNGetDebugDataVariablesByName = core.BNGetDebugDataVariablesByName
_BNGetDebugDataVariablesByName.restype = ctypes.POINTER(BNDataVariableAndName)
_BNGetDebugDataVariablesByName.argtypes = [
		ctypes.POINTER(BNDebugInfo),
		ctypes.c_char_p,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetDebugDataVariablesByName(
		debugInfo: ctypes.POINTER(BNDebugInfo), 
		variableName: Optional[str], 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNDataVariableAndName)]:
	result = _BNGetDebugDataVariablesByName(debugInfo, cstr(variableName), count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetDebugFunctions

_BNGetDebugFunctions = core.BNGetDebugFunctions
_BNGetDebugFunctions.restype = ctypes.POINTER(BNDebugFunctionInfo)
_BNGetDebugFunctions.argtypes = [
		ctypes.POINTER(BNDebugInfo),
		ctypes.c_char_p,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetDebugFunctions(
		debugInfo: ctypes.POINTER(BNDebugInfo), 
		name: Optional[str], 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNDebugFunctionInfo)]:
	result = _BNGetDebugFunctions(debugInfo, cstr(name), count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetDebugInfo

_BNGetDebugInfo = core.BNGetDebugInfo
_BNGetDebugInfo.restype = ctypes.POINTER(BNDebugInfo)
_BNGetDebugInfo.argtypes = [
		ctypes.POINTER(BNBinaryView),
	]


# noinspection PyPep8Naming
def BNGetDebugInfo(
		view: ctypes.POINTER(BNBinaryView)
		) -> Optional[ctypes.POINTER(BNDebugInfo)]:
	result = _BNGetDebugInfo(view)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetDebugInfoParserByName

_BNGetDebugInfoParserByName = core.BNGetDebugInfoParserByName
_BNGetDebugInfoParserByName.restype = ctypes.POINTER(BNDebugInfoParser)
_BNGetDebugInfoParserByName.argtypes = [
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNGetDebugInfoParserByName(
		name: Optional[str]
		) -> Optional[ctypes.POINTER(BNDebugInfoParser)]:
	result = _BNGetDebugInfoParserByName(cstr(name))
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetDebugInfoParserName

_BNGetDebugInfoParserName = core.BNGetDebugInfoParserName
_BNGetDebugInfoParserName.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetDebugInfoParserName.argtypes = [
		ctypes.POINTER(BNDebugInfoParser),
	]


# noinspection PyPep8Naming
def BNGetDebugInfoParserName(
		parser: ctypes.POINTER(BNDebugInfoParser)
		) -> Optional[Optional[str]]:
	result = _BNGetDebugInfoParserName(parser)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetDebugInfoParsers

_BNGetDebugInfoParsers = core.BNGetDebugInfoParsers
_BNGetDebugInfoParsers.restype = ctypes.POINTER(ctypes.POINTER(BNDebugInfoParser))
_BNGetDebugInfoParsers.argtypes = [
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetDebugInfoParsers(
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.POINTER(BNDebugInfoParser))]:
	result = _BNGetDebugInfoParsers(count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetDebugInfoParsersForView

_BNGetDebugInfoParsersForView = core.BNGetDebugInfoParsersForView
_BNGetDebugInfoParsersForView.restype = ctypes.POINTER(ctypes.POINTER(BNDebugInfoParser))
_BNGetDebugInfoParsersForView.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetDebugInfoParsersForView(
		view: ctypes.POINTER(BNBinaryView), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.POINTER(BNDebugInfoParser))]:
	result = _BNGetDebugInfoParsersForView(view, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetDebugInfoTypeContainer

_BNGetDebugInfoTypeContainer = core.BNGetDebugInfoTypeContainer
_BNGetDebugInfoTypeContainer.restype = ctypes.POINTER(BNTypeContainer)
_BNGetDebugInfoTypeContainer.argtypes = [
		ctypes.POINTER(BNDebugInfo),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNGetDebugInfoTypeContainer(
		debugInfo: ctypes.POINTER(BNDebugInfo), 
		parserName: Optional[str]
		) -> Optional[ctypes.POINTER(BNTypeContainer)]:
	result = _BNGetDebugInfoTypeContainer(debugInfo, cstr(parserName))
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetDebugParserNames

_BNGetDebugParserNames = core.BNGetDebugParserNames
_BNGetDebugParserNames.restype = ctypes.POINTER(ctypes.c_char_p)
_BNGetDebugParserNames.argtypes = [
		ctypes.POINTER(BNDebugInfo),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetDebugParserNames(
		debugInfo: ctypes.POINTER(BNDebugInfo), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_char_p)]:
	result = _BNGetDebugParserNames(debugInfo, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetDebugTypeByName

_BNGetDebugTypeByName = core.BNGetDebugTypeByName
_BNGetDebugTypeByName.restype = ctypes.POINTER(BNType)
_BNGetDebugTypeByName.argtypes = [
		ctypes.POINTER(BNDebugInfo),
		ctypes.c_char_p,
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNGetDebugTypeByName(
		debugInfo: ctypes.POINTER(BNDebugInfo), 
		parserName: Optional[str], 
		typeName: Optional[str]
		) -> Optional[ctypes.POINTER(BNType)]:
	result = _BNGetDebugTypeByName(debugInfo, cstr(parserName), cstr(typeName))
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetDebugTypes

_BNGetDebugTypes = core.BNGetDebugTypes
_BNGetDebugTypes.restype = ctypes.POINTER(BNNameAndType)
_BNGetDebugTypes.argtypes = [
		ctypes.POINTER(BNDebugInfo),
		ctypes.c_char_p,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetDebugTypes(
		debugInfo: ctypes.POINTER(BNDebugInfo), 
		name: Optional[str], 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNNameAndType)]:
	result = _BNGetDebugTypes(debugInfo, cstr(name), count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetDebugTypesByName

_BNGetDebugTypesByName = core.BNGetDebugTypesByName
_BNGetDebugTypesByName.restype = ctypes.POINTER(BNNameAndType)
_BNGetDebugTypesByName.argtypes = [
		ctypes.POINTER(BNDebugInfo),
		ctypes.c_char_p,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetDebugTypesByName(
		debugInfo: ctypes.POINTER(BNDebugInfo), 
		typeName: Optional[str], 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNNameAndType)]:
	result = _BNGetDebugTypesByName(debugInfo, cstr(typeName), count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetDefaultArchitecture

_BNGetDefaultArchitecture = core.BNGetDefaultArchitecture
_BNGetDefaultArchitecture.restype = ctypes.POINTER(BNArchitecture)
_BNGetDefaultArchitecture.argtypes = [
		ctypes.POINTER(BNBinaryView),
	]


# noinspection PyPep8Naming
def BNGetDefaultArchitecture(
		view: ctypes.POINTER(BNBinaryView)
		) -> Optional[ctypes.POINTER(BNArchitecture)]:
	result = _BNGetDefaultArchitecture(view)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetDefaultArchitectureFlagConditionLowLevelIL

_BNGetDefaultArchitectureFlagConditionLowLevelIL = core.BNGetDefaultArchitectureFlagConditionLowLevelIL
_BNGetDefaultArchitectureFlagConditionLowLevelIL.restype = ctypes.c_ulonglong
_BNGetDefaultArchitectureFlagConditionLowLevelIL.argtypes = [
		ctypes.POINTER(BNArchitecture),
		LowLevelILFlagConditionEnum,
		ctypes.c_uint,
		ctypes.POINTER(BNLowLevelILFunction),
	]


# noinspection PyPep8Naming
def BNGetDefaultArchitectureFlagConditionLowLevelIL(
		arch: ctypes.POINTER(BNArchitecture), 
		cond: LowLevelILFlagCondition, 
		semClass: int, 
		il: ctypes.POINTER(BNLowLevelILFunction)
		) -> int:
	return _BNGetDefaultArchitectureFlagConditionLowLevelIL(arch, cond, semClass, il)


# -------------------------------------------------------
# _BNGetDefaultArchitectureFlagWriteLowLevelIL

_BNGetDefaultArchitectureFlagWriteLowLevelIL = core.BNGetDefaultArchitectureFlagWriteLowLevelIL
_BNGetDefaultArchitectureFlagWriteLowLevelIL.restype = ctypes.c_ulonglong
_BNGetDefaultArchitectureFlagWriteLowLevelIL.argtypes = [
		ctypes.POINTER(BNArchitecture),
		LowLevelILOperationEnum,
		ctypes.c_ulonglong,
		FlagRoleEnum,
		ctypes.POINTER(BNRegisterOrConstant),
		ctypes.c_ulonglong,
		ctypes.POINTER(BNLowLevelILFunction),
	]


# noinspection PyPep8Naming
def BNGetDefaultArchitectureFlagWriteLowLevelIL(
		arch: ctypes.POINTER(BNArchitecture), 
		op: LowLevelILOperation, 
		size: int, 
		role: FlagRole, 
		operands: ctypes.POINTER(BNRegisterOrConstant), 
		operandCount: int, 
		il: ctypes.POINTER(BNLowLevelILFunction)
		) -> int:
	return _BNGetDefaultArchitectureFlagWriteLowLevelIL(arch, op, size, role, operands, operandCount, il)


# -------------------------------------------------------
# _BNGetDefaultEndianness

_BNGetDefaultEndianness = core.BNGetDefaultEndianness
_BNGetDefaultEndianness.restype = EndiannessEnum
_BNGetDefaultEndianness.argtypes = [
		ctypes.POINTER(BNBinaryView),
	]


# noinspection PyPep8Naming
def BNGetDefaultEndianness(
		view: ctypes.POINTER(BNBinaryView)
		) -> Endianness:
	return _BNGetDefaultEndianness(view)


# -------------------------------------------------------
# _BNGetDefaultIncomingVariableForParameterVariable

_BNGetDefaultIncomingVariableForParameterVariable = core.BNGetDefaultIncomingVariableForParameterVariable
_BNGetDefaultIncomingVariableForParameterVariable.restype = BNVariable
_BNGetDefaultIncomingVariableForParameterVariable.argtypes = [
		ctypes.POINTER(BNCallingConvention),
		ctypes.POINTER(BNVariable),
	]


# noinspection PyPep8Naming
def BNGetDefaultIncomingVariableForParameterVariable(
		cc: ctypes.POINTER(BNCallingConvention), 
		var: ctypes.POINTER(BNVariable)
		) -> BNVariable:
	return _BNGetDefaultIncomingVariableForParameterVariable(cc, var)


# -------------------------------------------------------
# _BNGetDefaultIndexForMediumLevelILVariableDefinition

_BNGetDefaultIndexForMediumLevelILVariableDefinition = core.BNGetDefaultIndexForMediumLevelILVariableDefinition
_BNGetDefaultIndexForMediumLevelILVariableDefinition.restype = ctypes.c_uint
_BNGetDefaultIndexForMediumLevelILVariableDefinition.argtypes = [
		ctypes.POINTER(BNMediumLevelILFunction),
		ctypes.POINTER(BNVariable),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetDefaultIndexForMediumLevelILVariableDefinition(
		func: ctypes.POINTER(BNMediumLevelILFunction), 
		var: ctypes.POINTER(BNVariable), 
		instrIndex: int
		) -> int:
	return _BNGetDefaultIndexForMediumLevelILVariableDefinition(func, var, instrIndex)


# -------------------------------------------------------
# _BNGetDefaultParameterVariableForIncomingVariable

_BNGetDefaultParameterVariableForIncomingVariable = core.BNGetDefaultParameterVariableForIncomingVariable
_BNGetDefaultParameterVariableForIncomingVariable.restype = BNVariable
_BNGetDefaultParameterVariableForIncomingVariable.argtypes = [
		ctypes.POINTER(BNCallingConvention),
		ctypes.POINTER(BNVariable),
	]


# noinspection PyPep8Naming
def BNGetDefaultParameterVariableForIncomingVariable(
		cc: ctypes.POINTER(BNCallingConvention), 
		var: ctypes.POINTER(BNVariable)
		) -> BNVariable:
	return _BNGetDefaultParameterVariableForIncomingVariable(cc, var)


# -------------------------------------------------------
# _BNGetDefaultPlatform

_BNGetDefaultPlatform = core.BNGetDefaultPlatform
_BNGetDefaultPlatform.restype = ctypes.POINTER(BNPlatform)
_BNGetDefaultPlatform.argtypes = [
		ctypes.POINTER(BNBinaryView),
	]


# noinspection PyPep8Naming
def BNGetDefaultPlatform(
		view: ctypes.POINTER(BNBinaryView)
		) -> Optional[ctypes.POINTER(BNPlatform)]:
	result = _BNGetDefaultPlatform(view)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetDefaultTypeParser

_BNGetDefaultTypeParser = core.BNGetDefaultTypeParser
_BNGetDefaultTypeParser.restype = ctypes.POINTER(BNTypeParser)
_BNGetDefaultTypeParser.argtypes = [
	]


# noinspection PyPep8Naming
def BNGetDefaultTypeParser(
		) -> Optional[ctypes.POINTER(BNTypeParser)]:
	result = _BNGetDefaultTypeParser()
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetDirectoryNameInput

_BNGetDirectoryNameInput = core.BNGetDirectoryNameInput
_BNGetDirectoryNameInput.restype = ctypes.c_bool
_BNGetDirectoryNameInput.argtypes = [
		ctypes.POINTER(ctypes.c_char_p),
		ctypes.c_char_p,
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNGetDirectoryNameInput(
		result: ctypes.POINTER(ctypes.c_char_p), 
		prompt: Optional[str], 
		defaultName: Optional[str]
		) -> bool:
	return _BNGetDirectoryNameInput(result, cstr(prompt), cstr(defaultName))


# -------------------------------------------------------
# _BNGetDisassemblyGutterWidth

_BNGetDisassemblyGutterWidth = core.BNGetDisassemblyGutterWidth
_BNGetDisassemblyGutterWidth.restype = ctypes.c_ulonglong
_BNGetDisassemblyGutterWidth.argtypes = [
		ctypes.POINTER(BNDisassemblySettings),
	]


# noinspection PyPep8Naming
def BNGetDisassemblyGutterWidth(
		settings: ctypes.POINTER(BNDisassemblySettings)
		) -> int:
	return _BNGetDisassemblyGutterWidth(settings)


# -------------------------------------------------------
# _BNGetDisassemblyMaximumSymbolWidth

_BNGetDisassemblyMaximumSymbolWidth = core.BNGetDisassemblyMaximumSymbolWidth
_BNGetDisassemblyMaximumSymbolWidth.restype = ctypes.c_ulonglong
_BNGetDisassemblyMaximumSymbolWidth.argtypes = [
		ctypes.POINTER(BNDisassemblySettings),
	]


# noinspection PyPep8Naming
def BNGetDisassemblyMaximumSymbolWidth(
		settings: ctypes.POINTER(BNDisassemblySettings)
		) -> int:
	return _BNGetDisassemblyMaximumSymbolWidth(settings)


# -------------------------------------------------------
# _BNGetDisassemblyTextRendererArchitecture

_BNGetDisassemblyTextRendererArchitecture = core.BNGetDisassemblyTextRendererArchitecture
_BNGetDisassemblyTextRendererArchitecture.restype = ctypes.POINTER(BNArchitecture)
_BNGetDisassemblyTextRendererArchitecture.argtypes = [
		ctypes.POINTER(BNDisassemblyTextRenderer),
	]


# noinspection PyPep8Naming
def BNGetDisassemblyTextRendererArchitecture(
		renderer: ctypes.POINTER(BNDisassemblyTextRenderer)
		) -> Optional[ctypes.POINTER(BNArchitecture)]:
	result = _BNGetDisassemblyTextRendererArchitecture(renderer)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetDisassemblyTextRendererBasicBlock

_BNGetDisassemblyTextRendererBasicBlock = core.BNGetDisassemblyTextRendererBasicBlock
_BNGetDisassemblyTextRendererBasicBlock.restype = ctypes.POINTER(BNBasicBlock)
_BNGetDisassemblyTextRendererBasicBlock.argtypes = [
		ctypes.POINTER(BNDisassemblyTextRenderer),
	]


# noinspection PyPep8Naming
def BNGetDisassemblyTextRendererBasicBlock(
		renderer: ctypes.POINTER(BNDisassemblyTextRenderer)
		) -> Optional[ctypes.POINTER(BNBasicBlock)]:
	result = _BNGetDisassemblyTextRendererBasicBlock(renderer)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetDisassemblyTextRendererFunction

_BNGetDisassemblyTextRendererFunction = core.BNGetDisassemblyTextRendererFunction
_BNGetDisassemblyTextRendererFunction.restype = ctypes.POINTER(BNFunction)
_BNGetDisassemblyTextRendererFunction.argtypes = [
		ctypes.POINTER(BNDisassemblyTextRenderer),
	]


# noinspection PyPep8Naming
def BNGetDisassemblyTextRendererFunction(
		renderer: ctypes.POINTER(BNDisassemblyTextRenderer)
		) -> Optional[ctypes.POINTER(BNFunction)]:
	result = _BNGetDisassemblyTextRendererFunction(renderer)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetDisassemblyTextRendererHighLevelILFunction

_BNGetDisassemblyTextRendererHighLevelILFunction = core.BNGetDisassemblyTextRendererHighLevelILFunction
_BNGetDisassemblyTextRendererHighLevelILFunction.restype = ctypes.POINTER(BNHighLevelILFunction)
_BNGetDisassemblyTextRendererHighLevelILFunction.argtypes = [
		ctypes.POINTER(BNDisassemblyTextRenderer),
	]


# noinspection PyPep8Naming
def BNGetDisassemblyTextRendererHighLevelILFunction(
		renderer: ctypes.POINTER(BNDisassemblyTextRenderer)
		) -> Optional[ctypes.POINTER(BNHighLevelILFunction)]:
	result = _BNGetDisassemblyTextRendererHighLevelILFunction(renderer)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetDisassemblyTextRendererInstructionAnnotations

_BNGetDisassemblyTextRendererInstructionAnnotations = core.BNGetDisassemblyTextRendererInstructionAnnotations
_BNGetDisassemblyTextRendererInstructionAnnotations.restype = ctypes.POINTER(BNInstructionTextToken)
_BNGetDisassemblyTextRendererInstructionAnnotations.argtypes = [
		ctypes.POINTER(BNDisassemblyTextRenderer),
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetDisassemblyTextRendererInstructionAnnotations(
		renderer: ctypes.POINTER(BNDisassemblyTextRenderer), 
		addr: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNInstructionTextToken)]:
	result = _BNGetDisassemblyTextRendererInstructionAnnotations(renderer, addr, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetDisassemblyTextRendererInstructionText

_BNGetDisassemblyTextRendererInstructionText = core.BNGetDisassemblyTextRendererInstructionText
_BNGetDisassemblyTextRendererInstructionText.restype = ctypes.c_bool
_BNGetDisassemblyTextRendererInstructionText.argtypes = [
		ctypes.POINTER(BNDisassemblyTextRenderer),
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
		ctypes.POINTER(ctypes.POINTER(BNDisassemblyTextLine)),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetDisassemblyTextRendererInstructionText(
		renderer: ctypes.POINTER(BNDisassemblyTextRenderer), 
		addr: int, 
		len: ctypes.POINTER(ctypes.c_ulonglong), 
		result: ctypes.POINTER(ctypes.POINTER(BNDisassemblyTextLine)), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> bool:
	return _BNGetDisassemblyTextRendererInstructionText(renderer, addr, len, result, count)


# -------------------------------------------------------
# _BNGetDisassemblyTextRendererIntegerTokens

_BNGetDisassemblyTextRendererIntegerTokens = core.BNGetDisassemblyTextRendererIntegerTokens
_BNGetDisassemblyTextRendererIntegerTokens.restype = ctypes.POINTER(BNInstructionTextToken)
_BNGetDisassemblyTextRendererIntegerTokens.argtypes = [
		ctypes.POINTER(BNDisassemblyTextRenderer),
		ctypes.POINTER(BNInstructionTextToken),
		ctypes.POINTER(BNArchitecture),
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetDisassemblyTextRendererIntegerTokens(
		renderer: ctypes.POINTER(BNDisassemblyTextRenderer), 
		token: ctypes.POINTER(BNInstructionTextToken), 
		arch: ctypes.POINTER(BNArchitecture), 
		addr: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNInstructionTextToken)]:
	result = _BNGetDisassemblyTextRendererIntegerTokens(renderer, token, arch, addr, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetDisassemblyTextRendererLines

_BNGetDisassemblyTextRendererLines = core.BNGetDisassemblyTextRendererLines
_BNGetDisassemblyTextRendererLines.restype = ctypes.c_bool
_BNGetDisassemblyTextRendererLines.argtypes = [
		ctypes.POINTER(BNDisassemblyTextRenderer),
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
		ctypes.POINTER(ctypes.POINTER(BNDisassemblyTextLine)),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetDisassemblyTextRendererLines(
		renderer: ctypes.POINTER(BNDisassemblyTextRenderer), 
		addr: int, 
		len: ctypes.POINTER(ctypes.c_ulonglong), 
		result: ctypes.POINTER(ctypes.POINTER(BNDisassemblyTextLine)), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> bool:
	return _BNGetDisassemblyTextRendererLines(renderer, addr, len, result, count)


# -------------------------------------------------------
# _BNGetDisassemblyTextRendererLowLevelILFunction

_BNGetDisassemblyTextRendererLowLevelILFunction = core.BNGetDisassemblyTextRendererLowLevelILFunction
_BNGetDisassemblyTextRendererLowLevelILFunction.restype = ctypes.POINTER(BNLowLevelILFunction)
_BNGetDisassemblyTextRendererLowLevelILFunction.argtypes = [
		ctypes.POINTER(BNDisassemblyTextRenderer),
	]


# noinspection PyPep8Naming
def BNGetDisassemblyTextRendererLowLevelILFunction(
		renderer: ctypes.POINTER(BNDisassemblyTextRenderer)
		) -> Optional[ctypes.POINTER(BNLowLevelILFunction)]:
	result = _BNGetDisassemblyTextRendererLowLevelILFunction(renderer)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetDisassemblyTextRendererMediumLevelILFunction

_BNGetDisassemblyTextRendererMediumLevelILFunction = core.BNGetDisassemblyTextRendererMediumLevelILFunction
_BNGetDisassemblyTextRendererMediumLevelILFunction.restype = ctypes.POINTER(BNMediumLevelILFunction)
_BNGetDisassemblyTextRendererMediumLevelILFunction.argtypes = [
		ctypes.POINTER(BNDisassemblyTextRenderer),
	]


# noinspection PyPep8Naming
def BNGetDisassemblyTextRendererMediumLevelILFunction(
		renderer: ctypes.POINTER(BNDisassemblyTextRenderer)
		) -> Optional[ctypes.POINTER(BNMediumLevelILFunction)]:
	result = _BNGetDisassemblyTextRendererMediumLevelILFunction(renderer)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetDisassemblyTextRendererSettings

_BNGetDisassemblyTextRendererSettings = core.BNGetDisassemblyTextRendererSettings
_BNGetDisassemblyTextRendererSettings.restype = ctypes.POINTER(BNDisassemblySettings)
_BNGetDisassemblyTextRendererSettings.argtypes = [
		ctypes.POINTER(BNDisassemblyTextRenderer),
	]


# noinspection PyPep8Naming
def BNGetDisassemblyTextRendererSettings(
		renderer: ctypes.POINTER(BNDisassemblyTextRenderer)
		) -> Optional[ctypes.POINTER(BNDisassemblySettings)]:
	result = _BNGetDisassemblyTextRendererSettings(renderer)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetDisassemblyTextRendererStackVariableReferenceTokens

_BNGetDisassemblyTextRendererStackVariableReferenceTokens = core.BNGetDisassemblyTextRendererStackVariableReferenceTokens
_BNGetDisassemblyTextRendererStackVariableReferenceTokens.restype = ctypes.POINTER(BNInstructionTextToken)
_BNGetDisassemblyTextRendererStackVariableReferenceTokens.argtypes = [
		ctypes.POINTER(BNDisassemblyTextRenderer),
		ctypes.POINTER(BNStackVariableReference),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetDisassemblyTextRendererStackVariableReferenceTokens(
		renderer: ctypes.POINTER(BNDisassemblyTextRenderer), 
		ref: ctypes.POINTER(BNStackVariableReference), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNInstructionTextToken)]:
	result = _BNGetDisassemblyTextRendererStackVariableReferenceTokens(renderer, ref, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetDisassemblyTextRendererSymbolTokens

_BNGetDisassemblyTextRendererSymbolTokens = core.BNGetDisassemblyTextRendererSymbolTokens
_BNGetDisassemblyTextRendererSymbolTokens.restype = ctypes.c_bool
_BNGetDisassemblyTextRendererSymbolTokens.argtypes = [
		ctypes.POINTER(BNDisassemblyTextRenderer),
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.POINTER(BNInstructionTextToken)),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetDisassemblyTextRendererSymbolTokens(
		renderer: ctypes.POINTER(BNDisassemblyTextRenderer), 
		addr: int, 
		size: int, 
		operand: int, 
		result: ctypes.POINTER(ctypes.POINTER(BNInstructionTextToken)), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> bool:
	return _BNGetDisassemblyTextRendererSymbolTokens(renderer, addr, size, operand, result, count)


# -------------------------------------------------------
# _BNGetDisassemblyWidth

_BNGetDisassemblyWidth = core.BNGetDisassemblyWidth
_BNGetDisassemblyWidth.restype = ctypes.c_ulonglong
_BNGetDisassemblyWidth.argtypes = [
		ctypes.POINTER(BNDisassemblySettings),
	]


# noinspection PyPep8Naming
def BNGetDisassemblyWidth(
		settings: ctypes.POINTER(BNDisassemblySettings)
		) -> int:
	return _BNGetDisassemblyWidth(settings)


# -------------------------------------------------------
# _BNGetDisplayStringForInteger

_BNGetDisplayStringForInteger = core.BNGetDisplayStringForInteger
_BNGetDisplayStringForInteger.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetDisplayStringForInteger.argtypes = [
		ctypes.POINTER(BNBinaryView),
		IntegerDisplayTypeEnum,
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
		ctypes.c_bool,
	]


# noinspection PyPep8Naming
def BNGetDisplayStringForInteger(
		binaryView: ctypes.POINTER(BNBinaryView), 
		type: IntegerDisplayType, 
		value: int, 
		inputWidth: int, 
		isSigned: bool
		) -> Optional[Optional[str]]:
	result = _BNGetDisplayStringForInteger(binaryView, type, value, inputWidth, isSigned)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetDownloadProviderByName

_BNGetDownloadProviderByName = core.BNGetDownloadProviderByName
_BNGetDownloadProviderByName.restype = ctypes.POINTER(BNDownloadProvider)
_BNGetDownloadProviderByName.argtypes = [
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNGetDownloadProviderByName(
		name: Optional[str]
		) -> Optional[ctypes.POINTER(BNDownloadProvider)]:
	result = _BNGetDownloadProviderByName(cstr(name))
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetDownloadProviderList

_BNGetDownloadProviderList = core.BNGetDownloadProviderList
_BNGetDownloadProviderList.restype = ctypes.POINTER(ctypes.POINTER(BNDownloadProvider))
_BNGetDownloadProviderList.argtypes = [
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetDownloadProviderList(
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.POINTER(BNDownloadProvider))]:
	result = _BNGetDownloadProviderList(count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetDownloadProviderName

_BNGetDownloadProviderName = core.BNGetDownloadProviderName
_BNGetDownloadProviderName.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetDownloadProviderName.argtypes = [
		ctypes.POINTER(BNDownloadProvider),
	]


# noinspection PyPep8Naming
def BNGetDownloadProviderName(
		provider: ctypes.POINTER(BNDownloadProvider)
		) -> Optional[Optional[str]]:
	result = _BNGetDownloadProviderName(provider)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetEndOffset

_BNGetEndOffset = core.BNGetEndOffset
_BNGetEndOffset.restype = ctypes.c_ulonglong
_BNGetEndOffset.argtypes = [
		ctypes.POINTER(BNBinaryView),
	]


# noinspection PyPep8Naming
def BNGetEndOffset(
		view: ctypes.POINTER(BNBinaryView)
		) -> int:
	return _BNGetEndOffset(view)


# -------------------------------------------------------
# _BNGetEnterpriseServerAuthenticationMethods

_BNGetEnterpriseServerAuthenticationMethods = core.BNGetEnterpriseServerAuthenticationMethods
_BNGetEnterpriseServerAuthenticationMethods.restype = ctypes.c_ulonglong
_BNGetEnterpriseServerAuthenticationMethods.argtypes = [
		ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)),
		ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)),
	]


# noinspection PyPep8Naming
def BNGetEnterpriseServerAuthenticationMethods(
		methods: ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)), 
		names: ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p))
		) -> int:
	return _BNGetEnterpriseServerAuthenticationMethods(methods, names)


# -------------------------------------------------------
# _BNGetEnterpriseServerBuildId

_BNGetEnterpriseServerBuildId = core.BNGetEnterpriseServerBuildId
_BNGetEnterpriseServerBuildId.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetEnterpriseServerBuildId.argtypes = [
	]


# noinspection PyPep8Naming
def BNGetEnterpriseServerBuildId(
		) -> Optional[Optional[str]]:
	result = _BNGetEnterpriseServerBuildId()
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetEnterpriseServerId

_BNGetEnterpriseServerId = core.BNGetEnterpriseServerId
_BNGetEnterpriseServerId.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetEnterpriseServerId.argtypes = [
	]


# noinspection PyPep8Naming
def BNGetEnterpriseServerId(
		) -> Optional[Optional[str]]:
	result = _BNGetEnterpriseServerId()
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetEnterpriseServerLastError

_BNGetEnterpriseServerLastError = core.BNGetEnterpriseServerLastError
_BNGetEnterpriseServerLastError.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetEnterpriseServerLastError.argtypes = [
	]


# noinspection PyPep8Naming
def BNGetEnterpriseServerLastError(
		) -> Optional[Optional[str]]:
	result = _BNGetEnterpriseServerLastError()
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetEnterpriseServerLicenseDuration

_BNGetEnterpriseServerLicenseDuration = core.BNGetEnterpriseServerLicenseDuration
_BNGetEnterpriseServerLicenseDuration.restype = ctypes.c_ulonglong
_BNGetEnterpriseServerLicenseDuration.argtypes = [
	]


# noinspection PyPep8Naming
def BNGetEnterpriseServerLicenseDuration(
		) -> int:
	return _BNGetEnterpriseServerLicenseDuration()


# -------------------------------------------------------
# _BNGetEnterpriseServerLicenseExpirationTime

_BNGetEnterpriseServerLicenseExpirationTime = core.BNGetEnterpriseServerLicenseExpirationTime
_BNGetEnterpriseServerLicenseExpirationTime.restype = ctypes.c_ulonglong
_BNGetEnterpriseServerLicenseExpirationTime.argtypes = [
	]


# noinspection PyPep8Naming
def BNGetEnterpriseServerLicenseExpirationTime(
		) -> int:
	return _BNGetEnterpriseServerLicenseExpirationTime()


# -------------------------------------------------------
# _BNGetEnterpriseServerName

_BNGetEnterpriseServerName = core.BNGetEnterpriseServerName
_BNGetEnterpriseServerName.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetEnterpriseServerName.argtypes = [
	]


# noinspection PyPep8Naming
def BNGetEnterpriseServerName(
		) -> Optional[Optional[str]]:
	result = _BNGetEnterpriseServerName()
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetEnterpriseServerReservationTimeLimit

_BNGetEnterpriseServerReservationTimeLimit = core.BNGetEnterpriseServerReservationTimeLimit
_BNGetEnterpriseServerReservationTimeLimit.restype = ctypes.c_ulonglong
_BNGetEnterpriseServerReservationTimeLimit.argtypes = [
	]


# noinspection PyPep8Naming
def BNGetEnterpriseServerReservationTimeLimit(
		) -> int:
	return _BNGetEnterpriseServerReservationTimeLimit()


# -------------------------------------------------------
# _BNGetEnterpriseServerToken

_BNGetEnterpriseServerToken = core.BNGetEnterpriseServerToken
_BNGetEnterpriseServerToken.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetEnterpriseServerToken.argtypes = [
	]


# noinspection PyPep8Naming
def BNGetEnterpriseServerToken(
		) -> Optional[Optional[str]]:
	result = _BNGetEnterpriseServerToken()
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetEnterpriseServerUrl

_BNGetEnterpriseServerUrl = core.BNGetEnterpriseServerUrl
_BNGetEnterpriseServerUrl.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetEnterpriseServerUrl.argtypes = [
	]


# noinspection PyPep8Naming
def BNGetEnterpriseServerUrl(
		) -> Optional[Optional[str]]:
	result = _BNGetEnterpriseServerUrl()
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetEnterpriseServerUsername

_BNGetEnterpriseServerUsername = core.BNGetEnterpriseServerUsername
_BNGetEnterpriseServerUsername.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetEnterpriseServerUsername.argtypes = [
	]


# noinspection PyPep8Naming
def BNGetEnterpriseServerUsername(
		) -> Optional[Optional[str]]:
	result = _BNGetEnterpriseServerUsername()
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetEnterpriseServerVersion

_BNGetEnterpriseServerVersion = core.BNGetEnterpriseServerVersion
_BNGetEnterpriseServerVersion.restype = ctypes.c_ulonglong
_BNGetEnterpriseServerVersion.argtypes = [
	]


# noinspection PyPep8Naming
def BNGetEnterpriseServerVersion(
		) -> int:
	return _BNGetEnterpriseServerVersion()


# -------------------------------------------------------
# _BNGetEntropy

_BNGetEntropy = core.BNGetEntropy
_BNGetEntropy.restype = ctypes.c_ulonglong
_BNGetEntropy.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_float),
	]


# noinspection PyPep8Naming
def BNGetEntropy(
		view: ctypes.POINTER(BNBinaryView), 
		offset: int, 
		len: int, 
		blockSize: int, 
		result: ctypes.POINTER(ctypes.c_float)
		) -> int:
	return _BNGetEntropy(view, offset, len, blockSize, result)


# -------------------------------------------------------
# _BNGetEntryPoint

_BNGetEntryPoint = core.BNGetEntryPoint
_BNGetEntryPoint.restype = ctypes.c_ulonglong
_BNGetEntryPoint.argtypes = [
		ctypes.POINTER(BNBinaryView),
	]


# noinspection PyPep8Naming
def BNGetEntryPoint(
		view: ctypes.POINTER(BNBinaryView)
		) -> int:
	return _BNGetEntryPoint(view)


# -------------------------------------------------------
# _BNGetEnumerationBuilderMembers

_BNGetEnumerationBuilderMembers = core.BNGetEnumerationBuilderMembers
_BNGetEnumerationBuilderMembers.restype = ctypes.POINTER(BNEnumerationMember)
_BNGetEnumerationBuilderMembers.argtypes = [
		ctypes.POINTER(BNEnumerationBuilder),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetEnumerationBuilderMembers(
		e: ctypes.POINTER(BNEnumerationBuilder), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNEnumerationMember)]:
	result = _BNGetEnumerationBuilderMembers(e, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetEnumerationMembers

_BNGetEnumerationMembers = core.BNGetEnumerationMembers
_BNGetEnumerationMembers.restype = ctypes.POINTER(BNEnumerationMember)
_BNGetEnumerationMembers.argtypes = [
		ctypes.POINTER(BNEnumeration),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetEnumerationMembers(
		e: ctypes.POINTER(BNEnumeration), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNEnumerationMember)]:
	result = _BNGetEnumerationMembers(e, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetEnumerationTokensForValue

_BNGetEnumerationTokensForValue = core.BNGetEnumerationTokensForValue
_BNGetEnumerationTokensForValue.restype = ctypes.POINTER(BNInstructionTextToken)
_BNGetEnumerationTokensForValue.argtypes = [
		ctypes.POINTER(BNEnumeration),
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
		ctypes.POINTER(BNType),
	]


# noinspection PyPep8Naming
def BNGetEnumerationTokensForValue(
		e: ctypes.POINTER(BNEnumeration), 
		value: int, 
		width: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong), 
		type: ctypes.POINTER(BNType)
		) -> Optional[ctypes.POINTER(BNInstructionTextToken)]:
	result = _BNGetEnumerationTokensForValue(e, value, width, count, type)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetErrorForDownloadInstance

_BNGetErrorForDownloadInstance = core.BNGetErrorForDownloadInstance
_BNGetErrorForDownloadInstance.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetErrorForDownloadInstance.argtypes = [
		ctypes.POINTER(BNDownloadInstance),
	]


# noinspection PyPep8Naming
def BNGetErrorForDownloadInstance(
		instance: ctypes.POINTER(BNDownloadInstance)
		) -> Optional[Optional[str]]:
	result = _BNGetErrorForDownloadInstance(instance)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetExistingViews

_BNGetExistingViews = core.BNGetExistingViews
_BNGetExistingViews.restype = ctypes.POINTER(ctypes.c_char_p)
_BNGetExistingViews.argtypes = [
		ctypes.POINTER(BNFileMetadata),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetExistingViews(
		file: ctypes.POINTER(BNFileMetadata), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_char_p)]:
	result = _BNGetExistingViews(file, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetExpressionParserMagicValue

_BNGetExpressionParserMagicValue = core.BNGetExpressionParserMagicValue
_BNGetExpressionParserMagicValue.restype = ctypes.c_bool
_BNGetExpressionParserMagicValue.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_char_p,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetExpressionParserMagicValue(
		view: ctypes.POINTER(BNBinaryView), 
		name: Optional[str], 
		value: ctypes.POINTER(ctypes.c_ulonglong)
		) -> bool:
	return _BNGetExpressionParserMagicValue(view, cstr(name), value)


# -------------------------------------------------------
# _BNGetExternalNameSpace

_BNGetExternalNameSpace = core.BNGetExternalNameSpace
_BNGetExternalNameSpace.restype = BNNameSpace
_BNGetExternalNameSpace.argtypes = [
	]


# noinspection PyPep8Naming
def BNGetExternalNameSpace(
		) -> BNNameSpace:
	return _BNGetExternalNameSpace()


# -------------------------------------------------------
# _BNGetFileExtension

_BNGetFileExtension = core.BNGetFileExtension
_BNGetFileExtension.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetFileExtension.argtypes = [
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNGetFileExtension(
		path: Optional[str]
		) -> Optional[Optional[str]]:
	result = _BNGetFileExtension(cstr(path))
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetFileForView

_BNGetFileForView = core.BNGetFileForView
_BNGetFileForView.restype = ctypes.POINTER(BNFileMetadata)
_BNGetFileForView.argtypes = [
		ctypes.POINTER(BNBinaryView),
	]


# noinspection PyPep8Naming
def BNGetFileForView(
		view: ctypes.POINTER(BNBinaryView)
		) -> Optional[ctypes.POINTER(BNFileMetadata)]:
	result = _BNGetFileForView(view)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetFileMetadataDatabase

_BNGetFileMetadataDatabase = core.BNGetFileMetadataDatabase
_BNGetFileMetadataDatabase.restype = ctypes.POINTER(BNDatabase)
_BNGetFileMetadataDatabase.argtypes = [
		ctypes.POINTER(BNFileMetadata),
	]


# noinspection PyPep8Naming
def BNGetFileMetadataDatabase(
		file: ctypes.POINTER(BNFileMetadata)
		) -> Optional[ctypes.POINTER(BNDatabase)]:
	result = _BNGetFileMetadataDatabase(file)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetFileName

_BNGetFileName = core.BNGetFileName
_BNGetFileName.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetFileName.argtypes = [
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNGetFileName(
		path: Optional[str]
		) -> Optional[Optional[str]]:
	result = _BNGetFileName(cstr(path))
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetFilePathsInDirectory

_BNGetFilePathsInDirectory = core.BNGetFilePathsInDirectory
_BNGetFilePathsInDirectory.restype = ctypes.POINTER(ctypes.c_char_p)
_BNGetFilePathsInDirectory.argtypes = [
		ctypes.c_char_p,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetFilePathsInDirectory(
		path: Optional[str], 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_char_p)]:
	result = _BNGetFilePathsInDirectory(cstr(path), count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetFileViewOfType

_BNGetFileViewOfType = core.BNGetFileViewOfType
_BNGetFileViewOfType.restype = ctypes.POINTER(BNBinaryView)
_BNGetFileViewOfType.argtypes = [
		ctypes.POINTER(BNFileMetadata),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNGetFileViewOfType(
		file: ctypes.POINTER(BNFileMetadata), 
		name: Optional[str]
		) -> Optional[ctypes.POINTER(BNBinaryView)]:
	result = _BNGetFileViewOfType(file, cstr(name))
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetFilename

_BNGetFilename = core.BNGetFilename
_BNGetFilename.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetFilename.argtypes = [
		ctypes.POINTER(BNFileMetadata),
	]


# noinspection PyPep8Naming
def BNGetFilename(
		file: ctypes.POINTER(BNFileMetadata)
		) -> Optional[Optional[str]]:
	result = _BNGetFilename(file)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetFirstLinearViewObjectChild

_BNGetFirstLinearViewObjectChild = core.BNGetFirstLinearViewObjectChild
_BNGetFirstLinearViewObjectChild.restype = ctypes.POINTER(BNLinearViewObject)
_BNGetFirstLinearViewObjectChild.argtypes = [
		ctypes.POINTER(BNLinearViewObject),
	]


# noinspection PyPep8Naming
def BNGetFirstLinearViewObjectChild(
		obj: ctypes.POINTER(BNLinearViewObject)
		) -> Optional[ctypes.POINTER(BNLinearViewObject)]:
	result = _BNGetFirstLinearViewObjectChild(obj)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetFlagsReadByLiftedILInstruction

_BNGetFlagsReadByLiftedILInstruction = core.BNGetFlagsReadByLiftedILInstruction
_BNGetFlagsReadByLiftedILInstruction.restype = ctypes.POINTER(ctypes.c_uint)
_BNGetFlagsReadByLiftedILInstruction.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetFlagsReadByLiftedILInstruction(
		func: ctypes.POINTER(BNFunction), 
		i: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_uint)]:
	result = _BNGetFlagsReadByLiftedILInstruction(func, i, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetFlagsWrittenByLiftedILInstruction

_BNGetFlagsWrittenByLiftedILInstruction = core.BNGetFlagsWrittenByLiftedILInstruction
_BNGetFlagsWrittenByLiftedILInstruction.restype = ctypes.POINTER(ctypes.c_uint)
_BNGetFlagsWrittenByLiftedILInstruction.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetFlagsWrittenByLiftedILInstruction(
		func: ctypes.POINTER(BNFunction), 
		i: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_uint)]:
	result = _BNGetFlagsWrittenByLiftedILInstruction(func, i, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetFloatArgumentRegisters

_BNGetFloatArgumentRegisters = core.BNGetFloatArgumentRegisters
_BNGetFloatArgumentRegisters.restype = ctypes.POINTER(ctypes.c_uint)
_BNGetFloatArgumentRegisters.argtypes = [
		ctypes.POINTER(BNCallingConvention),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetFloatArgumentRegisters(
		cc: ctypes.POINTER(BNCallingConvention), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_uint)]:
	result = _BNGetFloatArgumentRegisters(cc, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetFloatReturnValueRegister

_BNGetFloatReturnValueRegister = core.BNGetFloatReturnValueRegister
_BNGetFloatReturnValueRegister.restype = ctypes.c_uint
_BNGetFloatReturnValueRegister.argtypes = [
		ctypes.POINTER(BNCallingConvention),
	]


# noinspection PyPep8Naming
def BNGetFloatReturnValueRegister(
		cc: ctypes.POINTER(BNCallingConvention)
		) -> int:
	return _BNGetFloatReturnValueRegister(cc)


# -------------------------------------------------------
# _BNGetFlowGraphBasicBlock

_BNGetFlowGraphBasicBlock = core.BNGetFlowGraphBasicBlock
_BNGetFlowGraphBasicBlock.restype = ctypes.POINTER(BNBasicBlock)
_BNGetFlowGraphBasicBlock.argtypes = [
		ctypes.POINTER(BNFlowGraphNode),
	]


# noinspection PyPep8Naming
def BNGetFlowGraphBasicBlock(
		node: ctypes.POINTER(BNFlowGraphNode)
		) -> Optional[ctypes.POINTER(BNBasicBlock)]:
	result = _BNGetFlowGraphBasicBlock(node)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetFlowGraphHeight

_BNGetFlowGraphHeight = core.BNGetFlowGraphHeight
_BNGetFlowGraphHeight.restype = ctypes.c_int
_BNGetFlowGraphHeight.argtypes = [
		ctypes.POINTER(BNFlowGraph),
	]


# noinspection PyPep8Naming
def BNGetFlowGraphHeight(
		graph: ctypes.POINTER(BNFlowGraph)
		) -> int:
	return _BNGetFlowGraphHeight(graph)


# -------------------------------------------------------
# _BNGetFlowGraphHighLevelILFunction

_BNGetFlowGraphHighLevelILFunction = core.BNGetFlowGraphHighLevelILFunction
_BNGetFlowGraphHighLevelILFunction.restype = ctypes.POINTER(BNHighLevelILFunction)
_BNGetFlowGraphHighLevelILFunction.argtypes = [
		ctypes.POINTER(BNFlowGraph),
	]


# noinspection PyPep8Naming
def BNGetFlowGraphHighLevelILFunction(
		graph: ctypes.POINTER(BNFlowGraph)
		) -> Optional[ctypes.POINTER(BNHighLevelILFunction)]:
	result = _BNGetFlowGraphHighLevelILFunction(graph)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetFlowGraphLowLevelILFunction

_BNGetFlowGraphLowLevelILFunction = core.BNGetFlowGraphLowLevelILFunction
_BNGetFlowGraphLowLevelILFunction.restype = ctypes.POINTER(BNLowLevelILFunction)
_BNGetFlowGraphLowLevelILFunction.argtypes = [
		ctypes.POINTER(BNFlowGraph),
	]


# noinspection PyPep8Naming
def BNGetFlowGraphLowLevelILFunction(
		graph: ctypes.POINTER(BNFlowGraph)
		) -> Optional[ctypes.POINTER(BNLowLevelILFunction)]:
	result = _BNGetFlowGraphLowLevelILFunction(graph)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetFlowGraphMediumLevelILFunction

_BNGetFlowGraphMediumLevelILFunction = core.BNGetFlowGraphMediumLevelILFunction
_BNGetFlowGraphMediumLevelILFunction.restype = ctypes.POINTER(BNMediumLevelILFunction)
_BNGetFlowGraphMediumLevelILFunction.argtypes = [
		ctypes.POINTER(BNFlowGraph),
	]


# noinspection PyPep8Naming
def BNGetFlowGraphMediumLevelILFunction(
		graph: ctypes.POINTER(BNFlowGraph)
		) -> Optional[ctypes.POINTER(BNMediumLevelILFunction)]:
	result = _BNGetFlowGraphMediumLevelILFunction(graph)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetFlowGraphNode

_BNGetFlowGraphNode = core.BNGetFlowGraphNode
_BNGetFlowGraphNode.restype = ctypes.POINTER(BNFlowGraphNode)
_BNGetFlowGraphNode.argtypes = [
		ctypes.POINTER(BNFlowGraph),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetFlowGraphNode(
		graph: ctypes.POINTER(BNFlowGraph), 
		i: int
		) -> Optional[ctypes.POINTER(BNFlowGraphNode)]:
	result = _BNGetFlowGraphNode(graph, i)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetFlowGraphNodeHeight

_BNGetFlowGraphNodeHeight = core.BNGetFlowGraphNodeHeight
_BNGetFlowGraphNodeHeight.restype = ctypes.c_int
_BNGetFlowGraphNodeHeight.argtypes = [
		ctypes.POINTER(BNFlowGraphNode),
	]


# noinspection PyPep8Naming
def BNGetFlowGraphNodeHeight(
		node: ctypes.POINTER(BNFlowGraphNode)
		) -> int:
	return _BNGetFlowGraphNodeHeight(node)


# -------------------------------------------------------
# _BNGetFlowGraphNodeHighlight

_BNGetFlowGraphNodeHighlight = core.BNGetFlowGraphNodeHighlight
_BNGetFlowGraphNodeHighlight.restype = BNHighlightColor
_BNGetFlowGraphNodeHighlight.argtypes = [
		ctypes.POINTER(BNFlowGraphNode),
	]


# noinspection PyPep8Naming
def BNGetFlowGraphNodeHighlight(
		node: ctypes.POINTER(BNFlowGraphNode)
		) -> BNHighlightColor:
	return _BNGetFlowGraphNodeHighlight(node)


# -------------------------------------------------------
# _BNGetFlowGraphNodeIncomingEdges

_BNGetFlowGraphNodeIncomingEdges = core.BNGetFlowGraphNodeIncomingEdges
_BNGetFlowGraphNodeIncomingEdges.restype = ctypes.POINTER(BNFlowGraphEdge)
_BNGetFlowGraphNodeIncomingEdges.argtypes = [
		ctypes.POINTER(BNFlowGraphNode),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetFlowGraphNodeIncomingEdges(
		node: ctypes.POINTER(BNFlowGraphNode), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNFlowGraphEdge)]:
	result = _BNGetFlowGraphNodeIncomingEdges(node, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetFlowGraphNodeLines

_BNGetFlowGraphNodeLines = core.BNGetFlowGraphNodeLines
_BNGetFlowGraphNodeLines.restype = ctypes.POINTER(BNDisassemblyTextLine)
_BNGetFlowGraphNodeLines.argtypes = [
		ctypes.POINTER(BNFlowGraphNode),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetFlowGraphNodeLines(
		node: ctypes.POINTER(BNFlowGraphNode), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNDisassemblyTextLine)]:
	result = _BNGetFlowGraphNodeLines(node, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetFlowGraphNodeOutgoingEdges

_BNGetFlowGraphNodeOutgoingEdges = core.BNGetFlowGraphNodeOutgoingEdges
_BNGetFlowGraphNodeOutgoingEdges.restype = ctypes.POINTER(BNFlowGraphEdge)
_BNGetFlowGraphNodeOutgoingEdges.argtypes = [
		ctypes.POINTER(BNFlowGraphNode),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetFlowGraphNodeOutgoingEdges(
		node: ctypes.POINTER(BNFlowGraphNode), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNFlowGraphEdge)]:
	result = _BNGetFlowGraphNodeOutgoingEdges(node, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetFlowGraphNodeOwner

_BNGetFlowGraphNodeOwner = core.BNGetFlowGraphNodeOwner
_BNGetFlowGraphNodeOwner.restype = ctypes.POINTER(BNFlowGraph)
_BNGetFlowGraphNodeOwner.argtypes = [
		ctypes.POINTER(BNFlowGraphNode),
	]


# noinspection PyPep8Naming
def BNGetFlowGraphNodeOwner(
		node: ctypes.POINTER(BNFlowGraphNode)
		) -> Optional[ctypes.POINTER(BNFlowGraph)]:
	result = _BNGetFlowGraphNodeOwner(node)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetFlowGraphNodeWidth

_BNGetFlowGraphNodeWidth = core.BNGetFlowGraphNodeWidth
_BNGetFlowGraphNodeWidth.restype = ctypes.c_int
_BNGetFlowGraphNodeWidth.argtypes = [
		ctypes.POINTER(BNFlowGraphNode),
	]


# noinspection PyPep8Naming
def BNGetFlowGraphNodeWidth(
		node: ctypes.POINTER(BNFlowGraphNode)
		) -> int:
	return _BNGetFlowGraphNodeWidth(node)


# -------------------------------------------------------
# _BNGetFlowGraphNodeX

_BNGetFlowGraphNodeX = core.BNGetFlowGraphNodeX
_BNGetFlowGraphNodeX.restype = ctypes.c_int
_BNGetFlowGraphNodeX.argtypes = [
		ctypes.POINTER(BNFlowGraphNode),
	]


# noinspection PyPep8Naming
def BNGetFlowGraphNodeX(
		node: ctypes.POINTER(BNFlowGraphNode)
		) -> int:
	return _BNGetFlowGraphNodeX(node)


# -------------------------------------------------------
# _BNGetFlowGraphNodeY

_BNGetFlowGraphNodeY = core.BNGetFlowGraphNodeY
_BNGetFlowGraphNodeY.restype = ctypes.c_int
_BNGetFlowGraphNodeY.argtypes = [
		ctypes.POINTER(BNFlowGraphNode),
	]


# noinspection PyPep8Naming
def BNGetFlowGraphNodeY(
		node: ctypes.POINTER(BNFlowGraphNode)
		) -> int:
	return _BNGetFlowGraphNodeY(node)


# -------------------------------------------------------
# _BNGetFlowGraphNodes

_BNGetFlowGraphNodes = core.BNGetFlowGraphNodes
_BNGetFlowGraphNodes.restype = ctypes.POINTER(ctypes.POINTER(BNFlowGraphNode))
_BNGetFlowGraphNodes.argtypes = [
		ctypes.POINTER(BNFlowGraph),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetFlowGraphNodes(
		graph: ctypes.POINTER(BNFlowGraph), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.POINTER(BNFlowGraphNode))]:
	result = _BNGetFlowGraphNodes(graph, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetFlowGraphNodesInRegion

_BNGetFlowGraphNodesInRegion = core.BNGetFlowGraphNodesInRegion
_BNGetFlowGraphNodesInRegion.restype = ctypes.POINTER(ctypes.POINTER(BNFlowGraphNode))
_BNGetFlowGraphNodesInRegion.argtypes = [
		ctypes.POINTER(BNFlowGraph),
		ctypes.c_int,
		ctypes.c_int,
		ctypes.c_int,
		ctypes.c_int,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetFlowGraphNodesInRegion(
		graph: ctypes.POINTER(BNFlowGraph), 
		left: int, 
		top: int, 
		right: int, 
		bottom: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.POINTER(BNFlowGraphNode))]:
	result = _BNGetFlowGraphNodesInRegion(graph, left, top, right, bottom, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetFlowGraphWidth

_BNGetFlowGraphWidth = core.BNGetFlowGraphWidth
_BNGetFlowGraphWidth.restype = ctypes.c_int
_BNGetFlowGraphWidth.argtypes = [
		ctypes.POINTER(BNFlowGraph),
	]


# noinspection PyPep8Naming
def BNGetFlowGraphWidth(
		graph: ctypes.POINTER(BNFlowGraph)
		) -> int:
	return _BNGetFlowGraphWidth(graph)


# -------------------------------------------------------
# _BNGetFormInput

_BNGetFormInput = core.BNGetFormInput
_BNGetFormInput.restype = ctypes.c_bool
_BNGetFormInput.argtypes = [
		ctypes.POINTER(BNFormInputField),
		ctypes.c_ulonglong,
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNGetFormInput(
		fields: ctypes.POINTER(BNFormInputField), 
		count: int, 
		title: Optional[str]
		) -> bool:
	return _BNGetFormInput(fields, count, cstr(title))


# -------------------------------------------------------
# _BNGetFullInfoUpdateChannels

_BNGetFullInfoUpdateChannels = core.BNGetFullInfoUpdateChannels
_BNGetFullInfoUpdateChannels.restype = ctypes.POINTER(BNUpdateChannelFullInfo)
_BNGetFullInfoUpdateChannels.argtypes = [
		ctypes.POINTER(ctypes.c_ulonglong),
		ctypes.POINTER(ctypes.c_char_p),
	]


# noinspection PyPep8Naming
def BNGetFullInfoUpdateChannels(
		count: ctypes.POINTER(ctypes.c_ulonglong), 
		errors: ctypes.POINTER(ctypes.c_char_p)
		) -> Optional[ctypes.POINTER(BNUpdateChannelFullInfo)]:
	result = _BNGetFullInfoUpdateChannels(count, errors)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetFullWidthArchitectureRegisters

_BNGetFullWidthArchitectureRegisters = core.BNGetFullWidthArchitectureRegisters
_BNGetFullWidthArchitectureRegisters.restype = ctypes.POINTER(ctypes.c_uint)
_BNGetFullWidthArchitectureRegisters.argtypes = [
		ctypes.POINTER(BNArchitecture),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetFullWidthArchitectureRegisters(
		arch: ctypes.POINTER(BNArchitecture), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_uint)]:
	result = _BNGetFullWidthArchitectureRegisters(arch, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetFunctionAddressRanges

_BNGetFunctionAddressRanges = core.BNGetFunctionAddressRanges
_BNGetFunctionAddressRanges.restype = ctypes.POINTER(BNAddressRange)
_BNGetFunctionAddressRanges.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetFunctionAddressRanges(
		func: ctypes.POINTER(BNFunction), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNAddressRange)]:
	result = _BNGetFunctionAddressRanges(func, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetFunctionAllTagReferences

_BNGetFunctionAllTagReferences = core.BNGetFunctionAllTagReferences
_BNGetFunctionAllTagReferences.restype = ctypes.POINTER(BNTagReference)
_BNGetFunctionAllTagReferences.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetFunctionAllTagReferences(
		func: ctypes.POINTER(BNFunction), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNTagReference)]:
	result = _BNGetFunctionAllTagReferences(func, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetFunctionAnalysisPerformanceInfo

_BNGetFunctionAnalysisPerformanceInfo = core.BNGetFunctionAnalysisPerformanceInfo
_BNGetFunctionAnalysisPerformanceInfo.restype = ctypes.POINTER(BNPerformanceInfo)
_BNGetFunctionAnalysisPerformanceInfo.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetFunctionAnalysisPerformanceInfo(
		func: ctypes.POINTER(BNFunction), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNPerformanceInfo)]:
	result = _BNGetFunctionAnalysisPerformanceInfo(func, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetFunctionAnalysisSkipOverride

_BNGetFunctionAnalysisSkipOverride = core.BNGetFunctionAnalysisSkipOverride
_BNGetFunctionAnalysisSkipOverride.restype = FunctionAnalysisSkipOverrideEnum
_BNGetFunctionAnalysisSkipOverride.argtypes = [
		ctypes.POINTER(BNFunction),
	]


# noinspection PyPep8Naming
def BNGetFunctionAnalysisSkipOverride(
		func: ctypes.POINTER(BNFunction)
		) -> FunctionAnalysisSkipOverride:
	return _BNGetFunctionAnalysisSkipOverride(func)


# -------------------------------------------------------
# _BNGetFunctionArchitecture

_BNGetFunctionArchitecture = core.BNGetFunctionArchitecture
_BNGetFunctionArchitecture.restype = ctypes.POINTER(BNArchitecture)
_BNGetFunctionArchitecture.argtypes = [
		ctypes.POINTER(BNFunction),
	]


# noinspection PyPep8Naming
def BNGetFunctionArchitecture(
		func: ctypes.POINTER(BNFunction)
		) -> Optional[ctypes.POINTER(BNArchitecture)]:
	result = _BNGetFunctionArchitecture(func)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetFunctionBasicBlockAtAddress

_BNGetFunctionBasicBlockAtAddress = core.BNGetFunctionBasicBlockAtAddress
_BNGetFunctionBasicBlockAtAddress.restype = ctypes.POINTER(BNBasicBlock)
_BNGetFunctionBasicBlockAtAddress.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNArchitecture),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetFunctionBasicBlockAtAddress(
		func: ctypes.POINTER(BNFunction), 
		arch: ctypes.POINTER(BNArchitecture), 
		addr: int
		) -> Optional[ctypes.POINTER(BNBasicBlock)]:
	result = _BNGetFunctionBasicBlockAtAddress(func, arch, addr)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetFunctionBasicBlockList

_BNGetFunctionBasicBlockList = core.BNGetFunctionBasicBlockList
_BNGetFunctionBasicBlockList.restype = ctypes.POINTER(ctypes.POINTER(BNBasicBlock))
_BNGetFunctionBasicBlockList.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetFunctionBasicBlockList(
		func: ctypes.POINTER(BNFunction), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.POINTER(BNBasicBlock))]:
	result = _BNGetFunctionBasicBlockList(func, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetFunctionBlockAnnotations

_BNGetFunctionBlockAnnotations = core.BNGetFunctionBlockAnnotations
_BNGetFunctionBlockAnnotations.restype = ctypes.POINTER(BNInstructionTextLine)
_BNGetFunctionBlockAnnotations.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNArchitecture),
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetFunctionBlockAnnotations(
		func: ctypes.POINTER(BNFunction), 
		arch: ctypes.POINTER(BNArchitecture), 
		addr: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNInstructionTextLine)]:
	result = _BNGetFunctionBlockAnnotations(func, arch, addr, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetFunctionCallSites

_BNGetFunctionCallSites = core.BNGetFunctionCallSites
_BNGetFunctionCallSites.restype = ctypes.POINTER(BNReferenceSource)
_BNGetFunctionCallSites.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetFunctionCallSites(
		func: ctypes.POINTER(BNFunction), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNReferenceSource)]:
	result = _BNGetFunctionCallSites(func, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetFunctionCallingConvention

_BNGetFunctionCallingConvention = core.BNGetFunctionCallingConvention
_BNGetFunctionCallingConvention.restype = BNCallingConventionWithConfidence
_BNGetFunctionCallingConvention.argtypes = [
		ctypes.POINTER(BNFunction),
	]


# noinspection PyPep8Naming
def BNGetFunctionCallingConvention(
		func: ctypes.POINTER(BNFunction)
		) -> BNCallingConventionWithConfidence:
	return _BNGetFunctionCallingConvention(func)


# -------------------------------------------------------
# _BNGetFunctionClobberedRegisters

_BNGetFunctionClobberedRegisters = core.BNGetFunctionClobberedRegisters
_BNGetFunctionClobberedRegisters.restype = BNRegisterSetWithConfidence
_BNGetFunctionClobberedRegisters.argtypes = [
		ctypes.POINTER(BNFunction),
	]


# noinspection PyPep8Naming
def BNGetFunctionClobberedRegisters(
		func: ctypes.POINTER(BNFunction)
		) -> BNRegisterSetWithConfidence:
	return _BNGetFunctionClobberedRegisters(func)


# -------------------------------------------------------
# _BNGetFunctionComment

_BNGetFunctionComment = core.BNGetFunctionComment
_BNGetFunctionComment.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetFunctionComment.argtypes = [
		ctypes.POINTER(BNFunction),
	]


# noinspection PyPep8Naming
def BNGetFunctionComment(
		func: ctypes.POINTER(BNFunction)
		) -> Optional[Optional[str]]:
	result = _BNGetFunctionComment(func)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetFunctionData

_BNGetFunctionData = core.BNGetFunctionData
_BNGetFunctionData.restype = ctypes.POINTER(BNBinaryView)
_BNGetFunctionData.argtypes = [
		ctypes.POINTER(BNFunction),
	]


# noinspection PyPep8Naming
def BNGetFunctionData(
		func: ctypes.POINTER(BNFunction)
		) -> Optional[ctypes.POINTER(BNBinaryView)]:
	result = _BNGetFunctionData(func)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetFunctionForFlowGraph

_BNGetFunctionForFlowGraph = core.BNGetFunctionForFlowGraph
_BNGetFunctionForFlowGraph.restype = ctypes.POINTER(BNFunction)
_BNGetFunctionForFlowGraph.argtypes = [
		ctypes.POINTER(BNFlowGraph),
	]


# noinspection PyPep8Naming
def BNGetFunctionForFlowGraph(
		graph: ctypes.POINTER(BNFlowGraph)
		) -> Optional[ctypes.POINTER(BNFunction)]:
	result = _BNGetFunctionForFlowGraph(graph)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetFunctionGlobalPointerValue

_BNGetFunctionGlobalPointerValue = core.BNGetFunctionGlobalPointerValue
_BNGetFunctionGlobalPointerValue.restype = BNRegisterValueWithConfidence
_BNGetFunctionGlobalPointerValue.argtypes = [
		ctypes.POINTER(BNFunction),
	]


# noinspection PyPep8Naming
def BNGetFunctionGlobalPointerValue(
		func: ctypes.POINTER(BNFunction)
		) -> BNRegisterValueWithConfidence:
	return _BNGetFunctionGlobalPointerValue(func)


# -------------------------------------------------------
# _BNGetFunctionHighLevelIL

_BNGetFunctionHighLevelIL = core.BNGetFunctionHighLevelIL
_BNGetFunctionHighLevelIL.restype = ctypes.POINTER(BNHighLevelILFunction)
_BNGetFunctionHighLevelIL.argtypes = [
		ctypes.POINTER(BNFunction),
	]


# noinspection PyPep8Naming
def BNGetFunctionHighLevelIL(
		func: ctypes.POINTER(BNFunction)
		) -> Optional[ctypes.POINTER(BNHighLevelILFunction)]:
	result = _BNGetFunctionHighLevelIL(func)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetFunctionHighLevelILIfAvailable

_BNGetFunctionHighLevelILIfAvailable = core.BNGetFunctionHighLevelILIfAvailable
_BNGetFunctionHighLevelILIfAvailable.restype = ctypes.POINTER(BNHighLevelILFunction)
_BNGetFunctionHighLevelILIfAvailable.argtypes = [
		ctypes.POINTER(BNFunction),
	]


# noinspection PyPep8Naming
def BNGetFunctionHighLevelILIfAvailable(
		func: ctypes.POINTER(BNFunction)
		) -> Optional[ctypes.POINTER(BNHighLevelILFunction)]:
	result = _BNGetFunctionHighLevelILIfAvailable(func)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetFunctionHighestAddress

_BNGetFunctionHighestAddress = core.BNGetFunctionHighestAddress
_BNGetFunctionHighestAddress.restype = ctypes.c_ulonglong
_BNGetFunctionHighestAddress.argtypes = [
		ctypes.POINTER(BNFunction),
	]


# noinspection PyPep8Naming
def BNGetFunctionHighestAddress(
		func: ctypes.POINTER(BNFunction)
		) -> int:
	return _BNGetFunctionHighestAddress(func)


# -------------------------------------------------------
# _BNGetFunctionLanguageRepresentation

_BNGetFunctionLanguageRepresentation = core.BNGetFunctionLanguageRepresentation
_BNGetFunctionLanguageRepresentation.restype = ctypes.POINTER(BNLanguageRepresentationFunction)
_BNGetFunctionLanguageRepresentation.argtypes = [
		ctypes.POINTER(BNFunction),
	]


# noinspection PyPep8Naming
def BNGetFunctionLanguageRepresentation(
		func: ctypes.POINTER(BNFunction)
		) -> Optional[ctypes.POINTER(BNLanguageRepresentationFunction)]:
	result = _BNGetFunctionLanguageRepresentation(func)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetFunctionLanguageRepresentationIfAvailable

_BNGetFunctionLanguageRepresentationIfAvailable = core.BNGetFunctionLanguageRepresentationIfAvailable
_BNGetFunctionLanguageRepresentationIfAvailable.restype = ctypes.POINTER(BNLanguageRepresentationFunction)
_BNGetFunctionLanguageRepresentationIfAvailable.argtypes = [
		ctypes.POINTER(BNFunction),
	]


# noinspection PyPep8Naming
def BNGetFunctionLanguageRepresentationIfAvailable(
		func: ctypes.POINTER(BNFunction)
		) -> Optional[ctypes.POINTER(BNLanguageRepresentationFunction)]:
	result = _BNGetFunctionLanguageRepresentationIfAvailable(func)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetFunctionLiftedIL

_BNGetFunctionLiftedIL = core.BNGetFunctionLiftedIL
_BNGetFunctionLiftedIL.restype = ctypes.POINTER(BNLowLevelILFunction)
_BNGetFunctionLiftedIL.argtypes = [
		ctypes.POINTER(BNFunction),
	]


# noinspection PyPep8Naming
def BNGetFunctionLiftedIL(
		func: ctypes.POINTER(BNFunction)
		) -> Optional[ctypes.POINTER(BNLowLevelILFunction)]:
	result = _BNGetFunctionLiftedIL(func)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetFunctionLiftedILIfAvailable

_BNGetFunctionLiftedILIfAvailable = core.BNGetFunctionLiftedILIfAvailable
_BNGetFunctionLiftedILIfAvailable.restype = ctypes.POINTER(BNLowLevelILFunction)
_BNGetFunctionLiftedILIfAvailable.argtypes = [
		ctypes.POINTER(BNFunction),
	]


# noinspection PyPep8Naming
def BNGetFunctionLiftedILIfAvailable(
		func: ctypes.POINTER(BNFunction)
		) -> Optional[ctypes.POINTER(BNLowLevelILFunction)]:
	result = _BNGetFunctionLiftedILIfAvailable(func)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetFunctionLowLevelIL

_BNGetFunctionLowLevelIL = core.BNGetFunctionLowLevelIL
_BNGetFunctionLowLevelIL.restype = ctypes.POINTER(BNLowLevelILFunction)
_BNGetFunctionLowLevelIL.argtypes = [
		ctypes.POINTER(BNFunction),
	]


# noinspection PyPep8Naming
def BNGetFunctionLowLevelIL(
		func: ctypes.POINTER(BNFunction)
		) -> Optional[ctypes.POINTER(BNLowLevelILFunction)]:
	result = _BNGetFunctionLowLevelIL(func)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetFunctionLowLevelILIfAvailable

_BNGetFunctionLowLevelILIfAvailable = core.BNGetFunctionLowLevelILIfAvailable
_BNGetFunctionLowLevelILIfAvailable.restype = ctypes.POINTER(BNLowLevelILFunction)
_BNGetFunctionLowLevelILIfAvailable.argtypes = [
		ctypes.POINTER(BNFunction),
	]


# noinspection PyPep8Naming
def BNGetFunctionLowLevelILIfAvailable(
		func: ctypes.POINTER(BNFunction)
		) -> Optional[ctypes.POINTER(BNLowLevelILFunction)]:
	result = _BNGetFunctionLowLevelILIfAvailable(func)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetFunctionLowestAddress

_BNGetFunctionLowestAddress = core.BNGetFunctionLowestAddress
_BNGetFunctionLowestAddress.restype = ctypes.c_ulonglong
_BNGetFunctionLowestAddress.argtypes = [
		ctypes.POINTER(BNFunction),
	]


# noinspection PyPep8Naming
def BNGetFunctionLowestAddress(
		func: ctypes.POINTER(BNFunction)
		) -> int:
	return _BNGetFunctionLowestAddress(func)


# -------------------------------------------------------
# _BNGetFunctionMappedMediumLevelIL

_BNGetFunctionMappedMediumLevelIL = core.BNGetFunctionMappedMediumLevelIL
_BNGetFunctionMappedMediumLevelIL.restype = ctypes.POINTER(BNMediumLevelILFunction)
_BNGetFunctionMappedMediumLevelIL.argtypes = [
		ctypes.POINTER(BNFunction),
	]


# noinspection PyPep8Naming
def BNGetFunctionMappedMediumLevelIL(
		func: ctypes.POINTER(BNFunction)
		) -> Optional[ctypes.POINTER(BNMediumLevelILFunction)]:
	result = _BNGetFunctionMappedMediumLevelIL(func)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetFunctionMappedMediumLevelILIfAvailable

_BNGetFunctionMappedMediumLevelILIfAvailable = core.BNGetFunctionMappedMediumLevelILIfAvailable
_BNGetFunctionMappedMediumLevelILIfAvailable.restype = ctypes.POINTER(BNMediumLevelILFunction)
_BNGetFunctionMappedMediumLevelILIfAvailable.argtypes = [
		ctypes.POINTER(BNFunction),
	]


# noinspection PyPep8Naming
def BNGetFunctionMappedMediumLevelILIfAvailable(
		func: ctypes.POINTER(BNFunction)
		) -> Optional[ctypes.POINTER(BNMediumLevelILFunction)]:
	result = _BNGetFunctionMappedMediumLevelILIfAvailable(func)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetFunctionMediumLevelIL

_BNGetFunctionMediumLevelIL = core.BNGetFunctionMediumLevelIL
_BNGetFunctionMediumLevelIL.restype = ctypes.POINTER(BNMediumLevelILFunction)
_BNGetFunctionMediumLevelIL.argtypes = [
		ctypes.POINTER(BNFunction),
	]


# noinspection PyPep8Naming
def BNGetFunctionMediumLevelIL(
		func: ctypes.POINTER(BNFunction)
		) -> Optional[ctypes.POINTER(BNMediumLevelILFunction)]:
	result = _BNGetFunctionMediumLevelIL(func)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetFunctionMediumLevelILIfAvailable

_BNGetFunctionMediumLevelILIfAvailable = core.BNGetFunctionMediumLevelILIfAvailable
_BNGetFunctionMediumLevelILIfAvailable.restype = ctypes.POINTER(BNMediumLevelILFunction)
_BNGetFunctionMediumLevelILIfAvailable.argtypes = [
		ctypes.POINTER(BNFunction),
	]


# noinspection PyPep8Naming
def BNGetFunctionMediumLevelILIfAvailable(
		func: ctypes.POINTER(BNFunction)
		) -> Optional[ctypes.POINTER(BNMediumLevelILFunction)]:
	result = _BNGetFunctionMediumLevelILIfAvailable(func)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetFunctionParameterVariables

_BNGetFunctionParameterVariables = core.BNGetFunctionParameterVariables
_BNGetFunctionParameterVariables.restype = BNParameterVariablesWithConfidence
_BNGetFunctionParameterVariables.argtypes = [
		ctypes.POINTER(BNFunction),
	]


# noinspection PyPep8Naming
def BNGetFunctionParameterVariables(
		func: ctypes.POINTER(BNFunction)
		) -> BNParameterVariablesWithConfidence:
	return _BNGetFunctionParameterVariables(func)


# -------------------------------------------------------
# _BNGetFunctionParentComponents

_BNGetFunctionParentComponents = core.BNGetFunctionParentComponents
_BNGetFunctionParentComponents.restype = ctypes.POINTER(ctypes.POINTER(BNComponent))
_BNGetFunctionParentComponents.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetFunctionParentComponents(
		view: ctypes.POINTER(BNBinaryView), 
		func: ctypes.POINTER(BNFunction), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.POINTER(BNComponent))]:
	result = _BNGetFunctionParentComponents(view, func, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetFunctionPlatform

_BNGetFunctionPlatform = core.BNGetFunctionPlatform
_BNGetFunctionPlatform.restype = ctypes.POINTER(BNPlatform)
_BNGetFunctionPlatform.argtypes = [
		ctypes.POINTER(BNFunction),
	]


# noinspection PyPep8Naming
def BNGetFunctionPlatform(
		func: ctypes.POINTER(BNFunction)
		) -> Optional[ctypes.POINTER(BNPlatform)]:
	result = _BNGetFunctionPlatform(func)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetFunctionRegisterStackAdjustments

_BNGetFunctionRegisterStackAdjustments = core.BNGetFunctionRegisterStackAdjustments
_BNGetFunctionRegisterStackAdjustments.restype = ctypes.POINTER(BNRegisterStackAdjustment)
_BNGetFunctionRegisterStackAdjustments.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetFunctionRegisterStackAdjustments(
		func: ctypes.POINTER(BNFunction), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNRegisterStackAdjustment)]:
	result = _BNGetFunctionRegisterStackAdjustments(func, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetFunctionRegisterValueAtExit

_BNGetFunctionRegisterValueAtExit = core.BNGetFunctionRegisterValueAtExit
_BNGetFunctionRegisterValueAtExit.restype = BNRegisterValueWithConfidence
_BNGetFunctionRegisterValueAtExit.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.c_uint,
	]


# noinspection PyPep8Naming
def BNGetFunctionRegisterValueAtExit(
		func: ctypes.POINTER(BNFunction), 
		reg: int
		) -> BNRegisterValueWithConfidence:
	return _BNGetFunctionRegisterValueAtExit(func, reg)


# -------------------------------------------------------
# _BNGetFunctionReturnRegisters

_BNGetFunctionReturnRegisters = core.BNGetFunctionReturnRegisters
_BNGetFunctionReturnRegisters.restype = BNRegisterSetWithConfidence
_BNGetFunctionReturnRegisters.argtypes = [
		ctypes.POINTER(BNFunction),
	]


# noinspection PyPep8Naming
def BNGetFunctionReturnRegisters(
		func: ctypes.POINTER(BNFunction)
		) -> BNRegisterSetWithConfidence:
	return _BNGetFunctionReturnRegisters(func)


# -------------------------------------------------------
# _BNGetFunctionReturnType

_BNGetFunctionReturnType = core.BNGetFunctionReturnType
_BNGetFunctionReturnType.restype = BNTypeWithConfidence
_BNGetFunctionReturnType.argtypes = [
		ctypes.POINTER(BNFunction),
	]


# noinspection PyPep8Naming
def BNGetFunctionReturnType(
		func: ctypes.POINTER(BNFunction)
		) -> BNTypeWithConfidence:
	return _BNGetFunctionReturnType(func)


# -------------------------------------------------------
# _BNGetFunctionStackAdjustment

_BNGetFunctionStackAdjustment = core.BNGetFunctionStackAdjustment
_BNGetFunctionStackAdjustment.restype = BNOffsetWithConfidence
_BNGetFunctionStackAdjustment.argtypes = [
		ctypes.POINTER(BNFunction),
	]


# noinspection PyPep8Naming
def BNGetFunctionStackAdjustment(
		func: ctypes.POINTER(BNFunction)
		) -> BNOffsetWithConfidence:
	return _BNGetFunctionStackAdjustment(func)


# -------------------------------------------------------
# _BNGetFunctionStart

_BNGetFunctionStart = core.BNGetFunctionStart
_BNGetFunctionStart.restype = ctypes.c_ulonglong
_BNGetFunctionStart.argtypes = [
		ctypes.POINTER(BNFunction),
	]


# noinspection PyPep8Naming
def BNGetFunctionStart(
		func: ctypes.POINTER(BNFunction)
		) -> int:
	return _BNGetFunctionStart(func)


# -------------------------------------------------------
# _BNGetFunctionSymbol

_BNGetFunctionSymbol = core.BNGetFunctionSymbol
_BNGetFunctionSymbol.restype = ctypes.POINTER(BNSymbol)
_BNGetFunctionSymbol.argtypes = [
		ctypes.POINTER(BNFunction),
	]


# noinspection PyPep8Naming
def BNGetFunctionSymbol(
		func: ctypes.POINTER(BNFunction)
		) -> Optional[ctypes.POINTER(BNSymbol)]:
	result = _BNGetFunctionSymbol(func)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetFunctionTagReferences

_BNGetFunctionTagReferences = core.BNGetFunctionTagReferences
_BNGetFunctionTagReferences.restype = ctypes.POINTER(BNTagReference)
_BNGetFunctionTagReferences.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetFunctionTagReferences(
		func: ctypes.POINTER(BNFunction), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNTagReference)]:
	result = _BNGetFunctionTagReferences(func, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetFunctionTagReferencesOfType

_BNGetFunctionTagReferencesOfType = core.BNGetFunctionTagReferencesOfType
_BNGetFunctionTagReferencesOfType.restype = ctypes.POINTER(BNTagReference)
_BNGetFunctionTagReferencesOfType.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNTagType),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetFunctionTagReferencesOfType(
		func: ctypes.POINTER(BNFunction), 
		tagType: ctypes.POINTER(BNTagType), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNTagReference)]:
	result = _BNGetFunctionTagReferencesOfType(func, tagType, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetFunctionTags

_BNGetFunctionTags = core.BNGetFunctionTags
_BNGetFunctionTags.restype = ctypes.POINTER(ctypes.POINTER(BNTag))
_BNGetFunctionTags.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetFunctionTags(
		func: ctypes.POINTER(BNFunction), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.POINTER(BNTag))]:
	result = _BNGetFunctionTags(func, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetFunctionTagsOfType

_BNGetFunctionTagsOfType = core.BNGetFunctionTagsOfType
_BNGetFunctionTagsOfType.restype = ctypes.POINTER(ctypes.POINTER(BNTag))
_BNGetFunctionTagsOfType.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNTagType),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetFunctionTagsOfType(
		func: ctypes.POINTER(BNFunction), 
		tagType: ctypes.POINTER(BNTagType), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.POINTER(BNTag))]:
	result = _BNGetFunctionTagsOfType(func, tagType, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetFunctionType

_BNGetFunctionType = core.BNGetFunctionType
_BNGetFunctionType.restype = ctypes.POINTER(BNType)
_BNGetFunctionType.argtypes = [
		ctypes.POINTER(BNFunction),
	]


# noinspection PyPep8Naming
def BNGetFunctionType(
		func: ctypes.POINTER(BNFunction)
		) -> Optional[ctypes.POINTER(BNType)]:
	result = _BNGetFunctionType(func)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetFunctionTypeTokens

_BNGetFunctionTypeTokens = core.BNGetFunctionTypeTokens
_BNGetFunctionTypeTokens.restype = ctypes.POINTER(BNDisassemblyTextLine)
_BNGetFunctionTypeTokens.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNDisassemblySettings),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetFunctionTypeTokens(
		func: ctypes.POINTER(BNFunction), 
		settings: ctypes.POINTER(BNDisassemblySettings), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNDisassemblyTextLine)]:
	result = _BNGetFunctionTypeTokens(func, settings, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetFunctionVariableDeadStoreElimination

_BNGetFunctionVariableDeadStoreElimination = core.BNGetFunctionVariableDeadStoreElimination
_BNGetFunctionVariableDeadStoreElimination.restype = DeadStoreEliminationEnum
_BNGetFunctionVariableDeadStoreElimination.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNVariable),
	]


# noinspection PyPep8Naming
def BNGetFunctionVariableDeadStoreElimination(
		func: ctypes.POINTER(BNFunction), 
		var: ctypes.POINTER(BNVariable)
		) -> DeadStoreElimination:
	return _BNGetFunctionVariableDeadStoreElimination(func, var)


# -------------------------------------------------------
# _BNGetFunctionVariables

_BNGetFunctionVariables = core.BNGetFunctionVariables
_BNGetFunctionVariables.restype = ctypes.POINTER(BNVariableNameAndType)
_BNGetFunctionVariables.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetFunctionVariables(
		func: ctypes.POINTER(BNFunction), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNVariableNameAndType)]:
	result = _BNGetFunctionVariables(func, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetGlobalCommentForAddress

_BNGetGlobalCommentForAddress = core.BNGetGlobalCommentForAddress
_BNGetGlobalCommentForAddress.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetGlobalCommentForAddress.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetGlobalCommentForAddress(
		view: ctypes.POINTER(BNBinaryView), 
		addr: int
		) -> Optional[Optional[str]]:
	result = _BNGetGlobalCommentForAddress(view, addr)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetGlobalCommentedAddresses

_BNGetGlobalCommentedAddresses = core.BNGetGlobalCommentedAddresses
_BNGetGlobalCommentedAddresses.restype = ctypes.POINTER(ctypes.c_ulonglong)
_BNGetGlobalCommentedAddresses.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetGlobalCommentedAddresses(
		view: ctypes.POINTER(BNBinaryView), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_ulonglong)]:
	result = _BNGetGlobalCommentedAddresses(view, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetGlobalPointerRegister

_BNGetGlobalPointerRegister = core.BNGetGlobalPointerRegister
_BNGetGlobalPointerRegister.restype = ctypes.c_uint
_BNGetGlobalPointerRegister.argtypes = [
		ctypes.POINTER(BNCallingConvention),
	]


# noinspection PyPep8Naming
def BNGetGlobalPointerRegister(
		cc: ctypes.POINTER(BNCallingConvention)
		) -> int:
	return _BNGetGlobalPointerRegister(cc)


# -------------------------------------------------------
# _BNGetGlobalPointerValue

_BNGetGlobalPointerValue = core.BNGetGlobalPointerValue
_BNGetGlobalPointerValue.restype = BNRegisterValueWithConfidence
_BNGetGlobalPointerValue.argtypes = [
		ctypes.POINTER(BNBinaryView),
	]


# noinspection PyPep8Naming
def BNGetGlobalPointerValue(
		view: ctypes.POINTER(BNBinaryView)
		) -> BNRegisterValueWithConfidence:
	return _BNGetGlobalPointerValue(view)


# -------------------------------------------------------
# _BNGetGotoLabelName

_BNGetGotoLabelName = core.BNGetGotoLabelName
_BNGetGotoLabelName.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetGotoLabelName.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetGotoLabelName(
		func: ctypes.POINTER(BNFunction), 
		labelId: int
		) -> Optional[Optional[str]]:
	result = _BNGetGotoLabelName(func, labelId)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetGraphForFlowGraphLayoutRequest

_BNGetGraphForFlowGraphLayoutRequest = core.BNGetGraphForFlowGraphLayoutRequest
_BNGetGraphForFlowGraphLayoutRequest.restype = ctypes.POINTER(BNFlowGraph)
_BNGetGraphForFlowGraphLayoutRequest.argtypes = [
		ctypes.POINTER(BNFlowGraphLayoutRequest),
	]


# noinspection PyPep8Naming
def BNGetGraphForFlowGraphLayoutRequest(
		layout: ctypes.POINTER(BNFlowGraphLayoutRequest)
		) -> Optional[ctypes.POINTER(BNFlowGraph)]:
	result = _BNGetGraphForFlowGraphLayoutRequest(layout)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetHighIntegerReturnValueRegister

_BNGetHighIntegerReturnValueRegister = core.BNGetHighIntegerReturnValueRegister
_BNGetHighIntegerReturnValueRegister.restype = ctypes.c_uint
_BNGetHighIntegerReturnValueRegister.argtypes = [
		ctypes.POINTER(BNCallingConvention),
	]


# noinspection PyPep8Naming
def BNGetHighIntegerReturnValueRegister(
		cc: ctypes.POINTER(BNCallingConvention)
		) -> int:
	return _BNGetHighIntegerReturnValueRegister(cc)


# -------------------------------------------------------
# _BNGetHighLevelILAliasedVariables

_BNGetHighLevelILAliasedVariables = core.BNGetHighLevelILAliasedVariables
_BNGetHighLevelILAliasedVariables.restype = ctypes.POINTER(BNVariable)
_BNGetHighLevelILAliasedVariables.argtypes = [
		ctypes.POINTER(BNHighLevelILFunction),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetHighLevelILAliasedVariables(
		func: ctypes.POINTER(BNHighLevelILFunction), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNVariable)]:
	result = _BNGetHighLevelILAliasedVariables(func, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetHighLevelILBasicBlockForInstruction

_BNGetHighLevelILBasicBlockForInstruction = core.BNGetHighLevelILBasicBlockForInstruction
_BNGetHighLevelILBasicBlockForInstruction.restype = ctypes.POINTER(BNBasicBlock)
_BNGetHighLevelILBasicBlockForInstruction.argtypes = [
		ctypes.POINTER(BNHighLevelILFunction),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetHighLevelILBasicBlockForInstruction(
		func: ctypes.POINTER(BNHighLevelILFunction), 
		i: int
		) -> Optional[ctypes.POINTER(BNBasicBlock)]:
	result = _BNGetHighLevelILBasicBlockForInstruction(func, i)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetHighLevelILBasicBlockList

_BNGetHighLevelILBasicBlockList = core.BNGetHighLevelILBasicBlockList
_BNGetHighLevelILBasicBlockList.restype = ctypes.POINTER(ctypes.POINTER(BNBasicBlock))
_BNGetHighLevelILBasicBlockList.argtypes = [
		ctypes.POINTER(BNHighLevelILFunction),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetHighLevelILBasicBlockList(
		func: ctypes.POINTER(BNHighLevelILFunction), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.POINTER(BNBasicBlock))]:
	result = _BNGetHighLevelILBasicBlockList(func, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetHighLevelILByIndex

_BNGetHighLevelILByIndex = core.BNGetHighLevelILByIndex
_BNGetHighLevelILByIndex.restype = BNHighLevelILInstruction
_BNGetHighLevelILByIndex.argtypes = [
		ctypes.POINTER(BNHighLevelILFunction),
		ctypes.c_ulonglong,
		ctypes.c_bool,
	]


# noinspection PyPep8Naming
def BNGetHighLevelILByIndex(
		func: ctypes.POINTER(BNHighLevelILFunction), 
		i: int, 
		asFullAst: bool
		) -> BNHighLevelILInstruction:
	return _BNGetHighLevelILByIndex(func, i, asFullAst)


# -------------------------------------------------------
# _BNGetHighLevelILExprCount

_BNGetHighLevelILExprCount = core.BNGetHighLevelILExprCount
_BNGetHighLevelILExprCount.restype = ctypes.c_ulonglong
_BNGetHighLevelILExprCount.argtypes = [
		ctypes.POINTER(BNHighLevelILFunction),
	]


# noinspection PyPep8Naming
def BNGetHighLevelILExprCount(
		func: ctypes.POINTER(BNHighLevelILFunction)
		) -> int:
	return _BNGetHighLevelILExprCount(func)


# -------------------------------------------------------
# _BNGetHighLevelILExprIndex

_BNGetHighLevelILExprIndex = core.BNGetHighLevelILExprIndex
_BNGetHighLevelILExprIndex.restype = ctypes.c_ulonglong
_BNGetHighLevelILExprIndex.argtypes = [
		ctypes.POINTER(BNMediumLevelILFunction),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetHighLevelILExprIndex(
		func: ctypes.POINTER(BNMediumLevelILFunction), 
		expr: int
		) -> int:
	return _BNGetHighLevelILExprIndex(func, expr)


# -------------------------------------------------------
# _BNGetHighLevelILExprIndexForLabel

_BNGetHighLevelILExprIndexForLabel = core.BNGetHighLevelILExprIndexForLabel
_BNGetHighLevelILExprIndexForLabel.restype = ctypes.c_ulonglong
_BNGetHighLevelILExprIndexForLabel.argtypes = [
		ctypes.POINTER(BNHighLevelILFunction),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetHighLevelILExprIndexForLabel(
		func: ctypes.POINTER(BNHighLevelILFunction), 
		label: int
		) -> int:
	return _BNGetHighLevelILExprIndexForLabel(func, label)


# -------------------------------------------------------
# _BNGetHighLevelILExprIndexes

_BNGetHighLevelILExprIndexes = core.BNGetHighLevelILExprIndexes
_BNGetHighLevelILExprIndexes.restype = ctypes.POINTER(ctypes.c_ulonglong)
_BNGetHighLevelILExprIndexes.argtypes = [
		ctypes.POINTER(BNMediumLevelILFunction),
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetHighLevelILExprIndexes(
		func: ctypes.POINTER(BNMediumLevelILFunction), 
		expr: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_ulonglong)]:
	result = _BNGetHighLevelILExprIndexes(func, expr, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetHighLevelILExprText

_BNGetHighLevelILExprText = core.BNGetHighLevelILExprText
_BNGetHighLevelILExprText.restype = ctypes.POINTER(BNDisassemblyTextLine)
_BNGetHighLevelILExprText.argtypes = [
		ctypes.POINTER(BNHighLevelILFunction),
		ctypes.c_ulonglong,
		ctypes.c_bool,
		ctypes.POINTER(ctypes.c_ulonglong),
		ctypes.POINTER(BNDisassemblySettings),
	]


# noinspection PyPep8Naming
def BNGetHighLevelILExprText(
		func: ctypes.POINTER(BNHighLevelILFunction), 
		expr: int, 
		asFullAst: bool, 
		count: ctypes.POINTER(ctypes.c_ulonglong), 
		settings: ctypes.POINTER(BNDisassemblySettings)
		) -> Optional[ctypes.POINTER(BNDisassemblyTextLine)]:
	result = _BNGetHighLevelILExprText(func, expr, asFullAst, count, settings)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetHighLevelILExprType

_BNGetHighLevelILExprType = core.BNGetHighLevelILExprType
_BNGetHighLevelILExprType.restype = BNTypeWithConfidence
_BNGetHighLevelILExprType.argtypes = [
		ctypes.POINTER(BNHighLevelILFunction),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetHighLevelILExprType(
		func: ctypes.POINTER(BNHighLevelILFunction), 
		expr: int
		) -> BNTypeWithConfidence:
	return _BNGetHighLevelILExprType(func, expr)


# -------------------------------------------------------
# _BNGetHighLevelILForMediumLevelIL

_BNGetHighLevelILForMediumLevelIL = core.BNGetHighLevelILForMediumLevelIL
_BNGetHighLevelILForMediumLevelIL.restype = ctypes.POINTER(BNHighLevelILFunction)
_BNGetHighLevelILForMediumLevelIL.argtypes = [
		ctypes.POINTER(BNMediumLevelILFunction),
	]


# noinspection PyPep8Naming
def BNGetHighLevelILForMediumLevelIL(
		func: ctypes.POINTER(BNMediumLevelILFunction)
		) -> Optional[ctypes.POINTER(BNHighLevelILFunction)]:
	result = _BNGetHighLevelILForMediumLevelIL(func)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetHighLevelILIndexForInstruction

_BNGetHighLevelILIndexForInstruction = core.BNGetHighLevelILIndexForInstruction
_BNGetHighLevelILIndexForInstruction.restype = ctypes.c_ulonglong
_BNGetHighLevelILIndexForInstruction.argtypes = [
		ctypes.POINTER(BNHighLevelILFunction),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetHighLevelILIndexForInstruction(
		func: ctypes.POINTER(BNHighLevelILFunction), 
		i: int
		) -> int:
	return _BNGetHighLevelILIndexForInstruction(func, i)


# -------------------------------------------------------
# _BNGetHighLevelILInstructionCount

_BNGetHighLevelILInstructionCount = core.BNGetHighLevelILInstructionCount
_BNGetHighLevelILInstructionCount.restype = ctypes.c_ulonglong
_BNGetHighLevelILInstructionCount.argtypes = [
		ctypes.POINTER(BNHighLevelILFunction),
	]


# noinspection PyPep8Naming
def BNGetHighLevelILInstructionCount(
		func: ctypes.POINTER(BNHighLevelILFunction)
		) -> int:
	return _BNGetHighLevelILInstructionCount(func)


# -------------------------------------------------------
# _BNGetHighLevelILInstructionForExpr

_BNGetHighLevelILInstructionForExpr = core.BNGetHighLevelILInstructionForExpr
_BNGetHighLevelILInstructionForExpr.restype = ctypes.c_ulonglong
_BNGetHighLevelILInstructionForExpr.argtypes = [
		ctypes.POINTER(BNHighLevelILFunction),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetHighLevelILInstructionForExpr(
		func: ctypes.POINTER(BNHighLevelILFunction), 
		expr: int
		) -> int:
	return _BNGetHighLevelILInstructionForExpr(func, expr)


# -------------------------------------------------------
# _BNGetHighLevelILInstructionIndex

_BNGetHighLevelILInstructionIndex = core.BNGetHighLevelILInstructionIndex
_BNGetHighLevelILInstructionIndex.restype = ctypes.c_ulonglong
_BNGetHighLevelILInstructionIndex.argtypes = [
		ctypes.POINTER(BNMediumLevelILFunction),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetHighLevelILInstructionIndex(
		func: ctypes.POINTER(BNMediumLevelILFunction), 
		instr: int
		) -> int:
	return _BNGetHighLevelILInstructionIndex(func, instr)


# -------------------------------------------------------
# _BNGetHighLevelILNonSSAExprIndex

_BNGetHighLevelILNonSSAExprIndex = core.BNGetHighLevelILNonSSAExprIndex
_BNGetHighLevelILNonSSAExprIndex.restype = ctypes.c_ulonglong
_BNGetHighLevelILNonSSAExprIndex.argtypes = [
		ctypes.POINTER(BNHighLevelILFunction),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetHighLevelILNonSSAExprIndex(
		func: ctypes.POINTER(BNHighLevelILFunction), 
		expr: int
		) -> int:
	return _BNGetHighLevelILNonSSAExprIndex(func, expr)


# -------------------------------------------------------
# _BNGetHighLevelILNonSSAForm

_BNGetHighLevelILNonSSAForm = core.BNGetHighLevelILNonSSAForm
_BNGetHighLevelILNonSSAForm.restype = ctypes.POINTER(BNHighLevelILFunction)
_BNGetHighLevelILNonSSAForm.argtypes = [
		ctypes.POINTER(BNHighLevelILFunction),
	]


# noinspection PyPep8Naming
def BNGetHighLevelILNonSSAForm(
		func: ctypes.POINTER(BNHighLevelILFunction)
		) -> Optional[ctypes.POINTER(BNHighLevelILFunction)]:
	result = _BNGetHighLevelILNonSSAForm(func)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetHighLevelILNonSSAInstructionIndex

_BNGetHighLevelILNonSSAInstructionIndex = core.BNGetHighLevelILNonSSAInstructionIndex
_BNGetHighLevelILNonSSAInstructionIndex.restype = ctypes.c_ulonglong
_BNGetHighLevelILNonSSAInstructionIndex.argtypes = [
		ctypes.POINTER(BNHighLevelILFunction),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetHighLevelILNonSSAInstructionIndex(
		func: ctypes.POINTER(BNHighLevelILFunction), 
		instr: int
		) -> int:
	return _BNGetHighLevelILNonSSAInstructionIndex(func, instr)


# -------------------------------------------------------
# _BNGetHighLevelILOwnerFunction

_BNGetHighLevelILOwnerFunction = core.BNGetHighLevelILOwnerFunction
_BNGetHighLevelILOwnerFunction.restype = ctypes.POINTER(BNFunction)
_BNGetHighLevelILOwnerFunction.argtypes = [
		ctypes.POINTER(BNHighLevelILFunction),
	]


# noinspection PyPep8Naming
def BNGetHighLevelILOwnerFunction(
		func: ctypes.POINTER(BNHighLevelILFunction)
		) -> Optional[ctypes.POINTER(BNFunction)]:
	result = _BNGetHighLevelILOwnerFunction(func)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetHighLevelILRootExpr

_BNGetHighLevelILRootExpr = core.BNGetHighLevelILRootExpr
_BNGetHighLevelILRootExpr.restype = ctypes.c_ulonglong
_BNGetHighLevelILRootExpr.argtypes = [
		ctypes.POINTER(BNHighLevelILFunction),
	]


# noinspection PyPep8Naming
def BNGetHighLevelILRootExpr(
		func: ctypes.POINTER(BNHighLevelILFunction)
		) -> int:
	return _BNGetHighLevelILRootExpr(func)


# -------------------------------------------------------
# _BNGetHighLevelILSSAExprIndex

_BNGetHighLevelILSSAExprIndex = core.BNGetHighLevelILSSAExprIndex
_BNGetHighLevelILSSAExprIndex.restype = ctypes.c_ulonglong
_BNGetHighLevelILSSAExprIndex.argtypes = [
		ctypes.POINTER(BNHighLevelILFunction),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetHighLevelILSSAExprIndex(
		func: ctypes.POINTER(BNHighLevelILFunction), 
		expr: int
		) -> int:
	return _BNGetHighLevelILSSAExprIndex(func, expr)


# -------------------------------------------------------
# _BNGetHighLevelILSSAForm

_BNGetHighLevelILSSAForm = core.BNGetHighLevelILSSAForm
_BNGetHighLevelILSSAForm.restype = ctypes.POINTER(BNHighLevelILFunction)
_BNGetHighLevelILSSAForm.argtypes = [
		ctypes.POINTER(BNHighLevelILFunction),
	]


# noinspection PyPep8Naming
def BNGetHighLevelILSSAForm(
		func: ctypes.POINTER(BNHighLevelILFunction)
		) -> Optional[ctypes.POINTER(BNHighLevelILFunction)]:
	result = _BNGetHighLevelILSSAForm(func)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetHighLevelILSSAInstructionIndex

_BNGetHighLevelILSSAInstructionIndex = core.BNGetHighLevelILSSAInstructionIndex
_BNGetHighLevelILSSAInstructionIndex.restype = ctypes.c_ulonglong
_BNGetHighLevelILSSAInstructionIndex.argtypes = [
		ctypes.POINTER(BNHighLevelILFunction),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetHighLevelILSSAInstructionIndex(
		func: ctypes.POINTER(BNHighLevelILFunction), 
		instr: int
		) -> int:
	return _BNGetHighLevelILSSAInstructionIndex(func, instr)


# -------------------------------------------------------
# _BNGetHighLevelILSSAMemoryDefinition

_BNGetHighLevelILSSAMemoryDefinition = core.BNGetHighLevelILSSAMemoryDefinition
_BNGetHighLevelILSSAMemoryDefinition.restype = ctypes.c_ulonglong
_BNGetHighLevelILSSAMemoryDefinition.argtypes = [
		ctypes.POINTER(BNHighLevelILFunction),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetHighLevelILSSAMemoryDefinition(
		func: ctypes.POINTER(BNHighLevelILFunction), 
		version: int
		) -> int:
	return _BNGetHighLevelILSSAMemoryDefinition(func, version)


# -------------------------------------------------------
# _BNGetHighLevelILSSAMemoryUses

_BNGetHighLevelILSSAMemoryUses = core.BNGetHighLevelILSSAMemoryUses
_BNGetHighLevelILSSAMemoryUses.restype = ctypes.POINTER(ctypes.c_ulonglong)
_BNGetHighLevelILSSAMemoryUses.argtypes = [
		ctypes.POINTER(BNHighLevelILFunction),
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetHighLevelILSSAMemoryUses(
		func: ctypes.POINTER(BNHighLevelILFunction), 
		version: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_ulonglong)]:
	result = _BNGetHighLevelILSSAMemoryUses(func, version, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetHighLevelILSSAMemoryVersionAtILInstruction

_BNGetHighLevelILSSAMemoryVersionAtILInstruction = core.BNGetHighLevelILSSAMemoryVersionAtILInstruction
_BNGetHighLevelILSSAMemoryVersionAtILInstruction.restype = ctypes.c_ulonglong
_BNGetHighLevelILSSAMemoryVersionAtILInstruction.argtypes = [
		ctypes.POINTER(BNHighLevelILFunction),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetHighLevelILSSAMemoryVersionAtILInstruction(
		func: ctypes.POINTER(BNHighLevelILFunction), 
		instr: int
		) -> int:
	return _BNGetHighLevelILSSAMemoryVersionAtILInstruction(func, instr)


# -------------------------------------------------------
# _BNGetHighLevelILSSAVarDefinition

_BNGetHighLevelILSSAVarDefinition = core.BNGetHighLevelILSSAVarDefinition
_BNGetHighLevelILSSAVarDefinition.restype = ctypes.c_ulonglong
_BNGetHighLevelILSSAVarDefinition.argtypes = [
		ctypes.POINTER(BNHighLevelILFunction),
		ctypes.POINTER(BNVariable),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetHighLevelILSSAVarDefinition(
		func: ctypes.POINTER(BNHighLevelILFunction), 
		var: ctypes.POINTER(BNVariable), 
		version: int
		) -> int:
	return _BNGetHighLevelILSSAVarDefinition(func, var, version)


# -------------------------------------------------------
# _BNGetHighLevelILSSAVarUses

_BNGetHighLevelILSSAVarUses = core.BNGetHighLevelILSSAVarUses
_BNGetHighLevelILSSAVarUses.restype = ctypes.POINTER(ctypes.c_ulonglong)
_BNGetHighLevelILSSAVarUses.argtypes = [
		ctypes.POINTER(BNHighLevelILFunction),
		ctypes.POINTER(BNVariable),
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetHighLevelILSSAVarUses(
		func: ctypes.POINTER(BNHighLevelILFunction), 
		var: ctypes.POINTER(BNVariable), 
		version: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_ulonglong)]:
	result = _BNGetHighLevelILSSAVarUses(func, var, version, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetHighLevelILSSAVarVersionAtILInstruction

_BNGetHighLevelILSSAVarVersionAtILInstruction = core.BNGetHighLevelILSSAVarVersionAtILInstruction
_BNGetHighLevelILSSAVarVersionAtILInstruction.restype = ctypes.c_ulonglong
_BNGetHighLevelILSSAVarVersionAtILInstruction.argtypes = [
		ctypes.POINTER(BNHighLevelILFunction),
		ctypes.POINTER(BNVariable),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetHighLevelILSSAVarVersionAtILInstruction(
		func: ctypes.POINTER(BNHighLevelILFunction), 
		var: ctypes.POINTER(BNVariable), 
		instr: int
		) -> int:
	return _BNGetHighLevelILSSAVarVersionAtILInstruction(func, var, instr)


# -------------------------------------------------------
# _BNGetHighLevelILUsesForLabel

_BNGetHighLevelILUsesForLabel = core.BNGetHighLevelILUsesForLabel
_BNGetHighLevelILUsesForLabel.restype = ctypes.POINTER(ctypes.c_ulonglong)
_BNGetHighLevelILUsesForLabel.argtypes = [
		ctypes.POINTER(BNHighLevelILFunction),
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetHighLevelILUsesForLabel(
		func: ctypes.POINTER(BNHighLevelILFunction), 
		label: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_ulonglong)]:
	result = _BNGetHighLevelILUsesForLabel(func, label, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetHighLevelILVariableDefinitions

_BNGetHighLevelILVariableDefinitions = core.BNGetHighLevelILVariableDefinitions
_BNGetHighLevelILVariableDefinitions.restype = ctypes.POINTER(ctypes.c_ulonglong)
_BNGetHighLevelILVariableDefinitions.argtypes = [
		ctypes.POINTER(BNHighLevelILFunction),
		ctypes.POINTER(BNVariable),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetHighLevelILVariableDefinitions(
		func: ctypes.POINTER(BNHighLevelILFunction), 
		var: ctypes.POINTER(BNVariable), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_ulonglong)]:
	result = _BNGetHighLevelILVariableDefinitions(func, var, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetHighLevelILVariableReferences

_BNGetHighLevelILVariableReferences = core.BNGetHighLevelILVariableReferences
_BNGetHighLevelILVariableReferences.restype = ctypes.POINTER(BNILReferenceSource)
_BNGetHighLevelILVariableReferences.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNVariable),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetHighLevelILVariableReferences(
		func: ctypes.POINTER(BNFunction), 
		var: ctypes.POINTER(BNVariable), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNILReferenceSource)]:
	result = _BNGetHighLevelILVariableReferences(func, var, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetHighLevelILVariableReferencesFrom

_BNGetHighLevelILVariableReferencesFrom = core.BNGetHighLevelILVariableReferencesFrom
_BNGetHighLevelILVariableReferencesFrom.restype = ctypes.POINTER(BNVariableReferenceSource)
_BNGetHighLevelILVariableReferencesFrom.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNArchitecture),
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetHighLevelILVariableReferencesFrom(
		func: ctypes.POINTER(BNFunction), 
		arch: ctypes.POINTER(BNArchitecture), 
		address: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNVariableReferenceSource)]:
	result = _BNGetHighLevelILVariableReferencesFrom(func, arch, address, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetHighLevelILVariableReferencesFromIfAvailable

_BNGetHighLevelILVariableReferencesFromIfAvailable = core.BNGetHighLevelILVariableReferencesFromIfAvailable
_BNGetHighLevelILVariableReferencesFromIfAvailable.restype = ctypes.POINTER(BNVariableReferenceSource)
_BNGetHighLevelILVariableReferencesFromIfAvailable.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNArchitecture),
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetHighLevelILVariableReferencesFromIfAvailable(
		func: ctypes.POINTER(BNFunction), 
		arch: ctypes.POINTER(BNArchitecture), 
		address: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNVariableReferenceSource)]:
	result = _BNGetHighLevelILVariableReferencesFromIfAvailable(func, arch, address, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetHighLevelILVariableReferencesIfAvailable

_BNGetHighLevelILVariableReferencesIfAvailable = core.BNGetHighLevelILVariableReferencesIfAvailable
_BNGetHighLevelILVariableReferencesIfAvailable.restype = ctypes.POINTER(BNILReferenceSource)
_BNGetHighLevelILVariableReferencesIfAvailable.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNVariable),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetHighLevelILVariableReferencesIfAvailable(
		func: ctypes.POINTER(BNFunction), 
		var: ctypes.POINTER(BNVariable), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNILReferenceSource)]:
	result = _BNGetHighLevelILVariableReferencesIfAvailable(func, var, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetHighLevelILVariableReferencesInRange

_BNGetHighLevelILVariableReferencesInRange = core.BNGetHighLevelILVariableReferencesInRange
_BNGetHighLevelILVariableReferencesInRange.restype = ctypes.POINTER(BNVariableReferenceSource)
_BNGetHighLevelILVariableReferencesInRange.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNArchitecture),
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetHighLevelILVariableReferencesInRange(
		func: ctypes.POINTER(BNFunction), 
		arch: ctypes.POINTER(BNArchitecture), 
		address: int, 
		len: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNVariableReferenceSource)]:
	result = _BNGetHighLevelILVariableReferencesInRange(func, arch, address, len, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetHighLevelILVariableReferencesInRangeIfAvailable

_BNGetHighLevelILVariableReferencesInRangeIfAvailable = core.BNGetHighLevelILVariableReferencesInRangeIfAvailable
_BNGetHighLevelILVariableReferencesInRangeIfAvailable.restype = ctypes.POINTER(BNVariableReferenceSource)
_BNGetHighLevelILVariableReferencesInRangeIfAvailable.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNArchitecture),
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetHighLevelILVariableReferencesInRangeIfAvailable(
		func: ctypes.POINTER(BNFunction), 
		arch: ctypes.POINTER(BNArchitecture), 
		address: int, 
		len: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNVariableReferenceSource)]:
	result = _BNGetHighLevelILVariableReferencesInRangeIfAvailable(func, arch, address, len, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetHighLevelILVariableSSAVersions

_BNGetHighLevelILVariableSSAVersions = core.BNGetHighLevelILVariableSSAVersions
_BNGetHighLevelILVariableSSAVersions.restype = ctypes.POINTER(ctypes.c_ulonglong)
_BNGetHighLevelILVariableSSAVersions.argtypes = [
		ctypes.POINTER(BNHighLevelILFunction),
		ctypes.POINTER(BNVariable),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetHighLevelILVariableSSAVersions(
		func: ctypes.POINTER(BNHighLevelILFunction), 
		var: ctypes.POINTER(BNVariable), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_ulonglong)]:
	result = _BNGetHighLevelILVariableSSAVersions(func, var, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetHighLevelILVariableUses

_BNGetHighLevelILVariableUses = core.BNGetHighLevelILVariableUses
_BNGetHighLevelILVariableUses.restype = ctypes.POINTER(ctypes.c_ulonglong)
_BNGetHighLevelILVariableUses.argtypes = [
		ctypes.POINTER(BNHighLevelILFunction),
		ctypes.POINTER(BNVariable),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetHighLevelILVariableUses(
		func: ctypes.POINTER(BNHighLevelILFunction), 
		var: ctypes.POINTER(BNVariable), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_ulonglong)]:
	result = _BNGetHighLevelILVariableUses(func, var, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetHighLevelILVariables

_BNGetHighLevelILVariables = core.BNGetHighLevelILVariables
_BNGetHighLevelILVariables.restype = ctypes.POINTER(BNVariable)
_BNGetHighLevelILVariables.argtypes = [
		ctypes.POINTER(BNHighLevelILFunction),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetHighLevelILVariables(
		func: ctypes.POINTER(BNHighLevelILFunction), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNVariable)]:
	result = _BNGetHighLevelILVariables(func, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetHorizontalFlowGraphNodeMargin

_BNGetHorizontalFlowGraphNodeMargin = core.BNGetHorizontalFlowGraphNodeMargin
_BNGetHorizontalFlowGraphNodeMargin.restype = ctypes.c_int
_BNGetHorizontalFlowGraphNodeMargin.argtypes = [
		ctypes.POINTER(BNFlowGraph),
	]


# noinspection PyPep8Naming
def BNGetHorizontalFlowGraphNodeMargin(
		graph: ctypes.POINTER(BNFlowGraph)
		) -> int:
	return _BNGetHorizontalFlowGraphNodeMargin(graph)


# -------------------------------------------------------
# _BNGetImplicitlyDefinedRegisters

_BNGetImplicitlyDefinedRegisters = core.BNGetImplicitlyDefinedRegisters
_BNGetImplicitlyDefinedRegisters.restype = ctypes.POINTER(ctypes.c_uint)
_BNGetImplicitlyDefinedRegisters.argtypes = [
		ctypes.POINTER(BNCallingConvention),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetImplicitlyDefinedRegisters(
		cc: ctypes.POINTER(BNCallingConvention), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_uint)]:
	result = _BNGetImplicitlyDefinedRegisters(cc, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetIncomingDirectTypeReferences

_BNGetIncomingDirectTypeReferences = core.BNGetIncomingDirectTypeReferences
_BNGetIncomingDirectTypeReferences.restype = ctypes.POINTER(BNQualifiedName)
_BNGetIncomingDirectTypeReferences.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNQualifiedName),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetIncomingDirectTypeReferences(
		view: ctypes.POINTER(BNBinaryView), 
		type: ctypes.POINTER(BNQualifiedName), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNQualifiedName)]:
	result = _BNGetIncomingDirectTypeReferences(view, type, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetIncomingFlagValue

_BNGetIncomingFlagValue = core.BNGetIncomingFlagValue
_BNGetIncomingFlagValue.restype = BNRegisterValue
_BNGetIncomingFlagValue.argtypes = [
		ctypes.POINTER(BNCallingConvention),
		ctypes.c_uint,
		ctypes.POINTER(BNFunction),
	]


# noinspection PyPep8Naming
def BNGetIncomingFlagValue(
		cc: ctypes.POINTER(BNCallingConvention), 
		reg: int, 
		func: ctypes.POINTER(BNFunction)
		) -> BNRegisterValue:
	return _BNGetIncomingFlagValue(cc, reg, func)


# -------------------------------------------------------
# _BNGetIncomingRecursiveTypeReferences

_BNGetIncomingRecursiveTypeReferences = core.BNGetIncomingRecursiveTypeReferences
_BNGetIncomingRecursiveTypeReferences.restype = ctypes.POINTER(BNQualifiedName)
_BNGetIncomingRecursiveTypeReferences.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNQualifiedName),
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetIncomingRecursiveTypeReferences(
		view: ctypes.POINTER(BNBinaryView), 
		types: ctypes.POINTER(BNQualifiedName), 
		typeCount: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNQualifiedName)]:
	result = _BNGetIncomingRecursiveTypeReferences(view, types, typeCount, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetIncomingRegisterValue

_BNGetIncomingRegisterValue = core.BNGetIncomingRegisterValue
_BNGetIncomingRegisterValue.restype = BNRegisterValue
_BNGetIncomingRegisterValue.argtypes = [
		ctypes.POINTER(BNCallingConvention),
		ctypes.c_uint,
		ctypes.POINTER(BNFunction),
	]


# noinspection PyPep8Naming
def BNGetIncomingRegisterValue(
		cc: ctypes.POINTER(BNCallingConvention), 
		reg: int, 
		func: ctypes.POINTER(BNFunction)
		) -> BNRegisterValue:
	return _BNGetIncomingRegisterValue(cc, reg, func)


# -------------------------------------------------------
# _BNGetIncomingVariableForParameterVariable

_BNGetIncomingVariableForParameterVariable = core.BNGetIncomingVariableForParameterVariable
_BNGetIncomingVariableForParameterVariable.restype = BNVariable
_BNGetIncomingVariableForParameterVariable.argtypes = [
		ctypes.POINTER(BNCallingConvention),
		ctypes.POINTER(BNVariable),
		ctypes.POINTER(BNFunction),
	]


# noinspection PyPep8Naming
def BNGetIncomingVariableForParameterVariable(
		cc: ctypes.POINTER(BNCallingConvention), 
		var: ctypes.POINTER(BNVariable), 
		func: ctypes.POINTER(BNFunction)
		) -> BNVariable:
	return _BNGetIncomingVariableForParameterVariable(cc, var, func)


# -------------------------------------------------------
# _BNGetIndirectBranches

_BNGetIndirectBranches = core.BNGetIndirectBranches
_BNGetIndirectBranches.restype = ctypes.POINTER(BNIndirectBranchInfo)
_BNGetIndirectBranches.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetIndirectBranches(
		func: ctypes.POINTER(BNFunction), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNIndirectBranchInfo)]:
	result = _BNGetIndirectBranches(func, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetIndirectBranchesAt

_BNGetIndirectBranchesAt = core.BNGetIndirectBranchesAt
_BNGetIndirectBranchesAt.restype = ctypes.POINTER(BNIndirectBranchInfo)
_BNGetIndirectBranchesAt.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNArchitecture),
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetIndirectBranchesAt(
		func: ctypes.POINTER(BNFunction), 
		arch: ctypes.POINTER(BNArchitecture), 
		addr: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNIndirectBranchInfo)]:
	result = _BNGetIndirectBranchesAt(func, arch, addr, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetInstallDirectory

_BNGetInstallDirectory = core.BNGetInstallDirectory
_BNGetInstallDirectory.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetInstallDirectory.argtypes = [
	]


# noinspection PyPep8Naming
def BNGetInstallDirectory(
		) -> Optional[Optional[str]]:
	result = _BNGetInstallDirectory()
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetInstructionContainingAddress

_BNGetInstructionContainingAddress = core.BNGetInstructionContainingAddress
_BNGetInstructionContainingAddress.restype = ctypes.c_bool
_BNGetInstructionContainingAddress.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNArchitecture),
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetInstructionContainingAddress(
		func: ctypes.POINTER(BNFunction), 
		arch: ctypes.POINTER(BNArchitecture), 
		addr: int, 
		start: ctypes.POINTER(ctypes.c_ulonglong)
		) -> bool:
	return _BNGetInstructionContainingAddress(func, arch, addr, start)


# -------------------------------------------------------
# _BNGetInstructionHighlight

_BNGetInstructionHighlight = core.BNGetInstructionHighlight
_BNGetInstructionHighlight.restype = BNHighlightColor
_BNGetInstructionHighlight.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNArchitecture),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetInstructionHighlight(
		func: ctypes.POINTER(BNFunction), 
		arch: ctypes.POINTER(BNArchitecture), 
		addr: int
		) -> BNHighlightColor:
	return _BNGetInstructionHighlight(func, arch, addr)


# -------------------------------------------------------
# _BNGetInstructionInfo

_BNGetInstructionInfo = core.BNGetInstructionInfo
_BNGetInstructionInfo.restype = ctypes.c_bool
_BNGetInstructionInfo.argtypes = [
		ctypes.POINTER(BNArchitecture),
		ctypes.POINTER(ctypes.c_ubyte),
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
		ctypes.POINTER(BNInstructionInfo),
	]


# noinspection PyPep8Naming
def BNGetInstructionInfo(
		arch: ctypes.POINTER(BNArchitecture), 
		data: ctypes.POINTER(ctypes.c_ubyte), 
		addr: int, 
		maxLen: int, 
		result: ctypes.POINTER(BNInstructionInfo)
		) -> bool:
	return _BNGetInstructionInfo(arch, data, addr, maxLen, result)


# -------------------------------------------------------
# _BNGetInstructionLength

_BNGetInstructionLength = core.BNGetInstructionLength
_BNGetInstructionLength.restype = ctypes.c_ulonglong
_BNGetInstructionLength.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNArchitecture),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetInstructionLength(
		view: ctypes.POINTER(BNBinaryView), 
		arch: ctypes.POINTER(BNArchitecture), 
		addr: int
		) -> int:
	return _BNGetInstructionLength(view, arch, addr)


# -------------------------------------------------------
# _BNGetInstructionLowLevelIL

_BNGetInstructionLowLevelIL = core.BNGetInstructionLowLevelIL
_BNGetInstructionLowLevelIL.restype = ctypes.c_bool
_BNGetInstructionLowLevelIL.argtypes = [
		ctypes.POINTER(BNArchitecture),
		ctypes.POINTER(ctypes.c_ubyte),
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
		ctypes.POINTER(BNLowLevelILFunction),
	]


# noinspection PyPep8Naming
def BNGetInstructionLowLevelIL(
		arch: ctypes.POINTER(BNArchitecture), 
		data: ctypes.POINTER(ctypes.c_ubyte), 
		addr: int, 
		len: ctypes.POINTER(ctypes.c_ulonglong), 
		il: ctypes.POINTER(BNLowLevelILFunction)
		) -> bool:
	return _BNGetInstructionLowLevelIL(arch, data, addr, len, il)


# -------------------------------------------------------
# _BNGetInstructionText

_BNGetInstructionText = core.BNGetInstructionText
_BNGetInstructionText.restype = ctypes.c_bool
_BNGetInstructionText.argtypes = [
		ctypes.POINTER(BNArchitecture),
		ctypes.POINTER(ctypes.c_ubyte),
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
		ctypes.POINTER(ctypes.POINTER(BNInstructionTextToken)),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetInstructionText(
		arch: ctypes.POINTER(BNArchitecture), 
		data: ctypes.POINTER(ctypes.c_ubyte), 
		addr: int, 
		len: ctypes.POINTER(ctypes.c_ulonglong), 
		result: ctypes.POINTER(ctypes.POINTER(BNInstructionTextToken)), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> bool:
	return _BNGetInstructionText(arch, data, addr, len, result, count)


# -------------------------------------------------------
# _BNGetIntegerArgumentRegisters

_BNGetIntegerArgumentRegisters = core.BNGetIntegerArgumentRegisters
_BNGetIntegerArgumentRegisters.restype = ctypes.POINTER(ctypes.c_uint)
_BNGetIntegerArgumentRegisters.argtypes = [
		ctypes.POINTER(BNCallingConvention),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetIntegerArgumentRegisters(
		cc: ctypes.POINTER(BNCallingConvention), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_uint)]:
	result = _BNGetIntegerArgumentRegisters(cc, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetIntegerConstantDisplayType

_BNGetIntegerConstantDisplayType = core.BNGetIntegerConstantDisplayType
_BNGetIntegerConstantDisplayType.restype = IntegerDisplayTypeEnum
_BNGetIntegerConstantDisplayType.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNArchitecture),
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetIntegerConstantDisplayType(
		func: ctypes.POINTER(BNFunction), 
		arch: ctypes.POINTER(BNArchitecture), 
		instrAddr: int, 
		value: int, 
		operand: int
		) -> IntegerDisplayType:
	return _BNGetIntegerConstantDisplayType(func, arch, instrAddr, value, operand)


# -------------------------------------------------------
# _BNGetIntegerConstantDisplayTypeEnumerationType

_BNGetIntegerConstantDisplayTypeEnumerationType = core.BNGetIntegerConstantDisplayTypeEnumerationType
_BNGetIntegerConstantDisplayTypeEnumerationType.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetIntegerConstantDisplayTypeEnumerationType.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNArchitecture),
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetIntegerConstantDisplayTypeEnumerationType(
		func: ctypes.POINTER(BNFunction), 
		arch: ctypes.POINTER(BNArchitecture), 
		instrAddr: int, 
		value: int, 
		operand: int
		) -> Optional[Optional[str]]:
	result = _BNGetIntegerConstantDisplayTypeEnumerationType(func, arch, instrAddr, value, operand)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetIntegerInput

_BNGetIntegerInput = core.BNGetIntegerInput
_BNGetIntegerInput.restype = ctypes.c_bool
_BNGetIntegerInput.argtypes = [
		ctypes.POINTER(ctypes.c_longlong),
		ctypes.c_char_p,
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNGetIntegerInput(
		result: ctypes.POINTER(ctypes.c_longlong), 
		prompt: Optional[str], 
		title: Optional[str]
		) -> bool:
	return _BNGetIntegerInput(result, cstr(prompt), cstr(title))


# -------------------------------------------------------
# _BNGetIntegerReturnValueRegister

_BNGetIntegerReturnValueRegister = core.BNGetIntegerReturnValueRegister
_BNGetIntegerReturnValueRegister.restype = ctypes.c_uint
_BNGetIntegerReturnValueRegister.argtypes = [
		ctypes.POINTER(BNCallingConvention),
	]


# noinspection PyPep8Naming
def BNGetIntegerReturnValueRegister(
		cc: ctypes.POINTER(BNCallingConvention)
		) -> int:
	return _BNGetIntegerReturnValueRegister(cc)


# -------------------------------------------------------
# _BNGetIntegerTypeDisplayType

_BNGetIntegerTypeDisplayType = core.BNGetIntegerTypeDisplayType
_BNGetIntegerTypeDisplayType.restype = IntegerDisplayTypeEnum
_BNGetIntegerTypeDisplayType.argtypes = [
		ctypes.POINTER(BNType),
	]


# noinspection PyPep8Naming
def BNGetIntegerTypeDisplayType(
		type: ctypes.POINTER(BNType)
		) -> IntegerDisplayType:
	return _BNGetIntegerTypeDisplayType(type)


# -------------------------------------------------------
# _BNGetInternalNameSpace

_BNGetInternalNameSpace = core.BNGetInternalNameSpace
_BNGetInternalNameSpace.restype = BNNameSpace
_BNGetInternalNameSpace.argtypes = [
	]


# noinspection PyPep8Naming
def BNGetInternalNameSpace(
		) -> BNNameSpace:
	return _BNGetInternalNameSpace()


# -------------------------------------------------------
# _BNGetKeyValueStoreBuffer

_BNGetKeyValueStoreBuffer = core.BNGetKeyValueStoreBuffer
_BNGetKeyValueStoreBuffer.restype = ctypes.POINTER(BNDataBuffer)
_BNGetKeyValueStoreBuffer.argtypes = [
		ctypes.POINTER(BNKeyValueStore),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNGetKeyValueStoreBuffer(
		store: ctypes.POINTER(BNKeyValueStore), 
		name: Optional[str]
		) -> Optional[ctypes.POINTER(BNDataBuffer)]:
	result = _BNGetKeyValueStoreBuffer(store, cstr(name))
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetKeyValueStoreDataSize

_BNGetKeyValueStoreDataSize = core.BNGetKeyValueStoreDataSize
_BNGetKeyValueStoreDataSize.restype = ctypes.c_ulonglong
_BNGetKeyValueStoreDataSize.argtypes = [
		ctypes.POINTER(BNKeyValueStore),
	]


# noinspection PyPep8Naming
def BNGetKeyValueStoreDataSize(
		store: ctypes.POINTER(BNKeyValueStore)
		) -> int:
	return _BNGetKeyValueStoreDataSize(store)


# -------------------------------------------------------
# _BNGetKeyValueStoreKeys

_BNGetKeyValueStoreKeys = core.BNGetKeyValueStoreKeys
_BNGetKeyValueStoreKeys.restype = ctypes.POINTER(ctypes.c_char_p)
_BNGetKeyValueStoreKeys.argtypes = [
		ctypes.POINTER(BNKeyValueStore),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetKeyValueStoreKeys(
		store: ctypes.POINTER(BNKeyValueStore), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_char_p)]:
	result = _BNGetKeyValueStoreKeys(store, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetKeyValueStoreNamespaceSize

_BNGetKeyValueStoreNamespaceSize = core.BNGetKeyValueStoreNamespaceSize
_BNGetKeyValueStoreNamespaceSize.restype = ctypes.c_ulonglong
_BNGetKeyValueStoreNamespaceSize.argtypes = [
		ctypes.POINTER(BNKeyValueStore),
	]


# noinspection PyPep8Naming
def BNGetKeyValueStoreNamespaceSize(
		store: ctypes.POINTER(BNKeyValueStore)
		) -> int:
	return _BNGetKeyValueStoreNamespaceSize(store)


# -------------------------------------------------------
# _BNGetKeyValueStoreSerializedData

_BNGetKeyValueStoreSerializedData = core.BNGetKeyValueStoreSerializedData
_BNGetKeyValueStoreSerializedData.restype = ctypes.POINTER(BNDataBuffer)
_BNGetKeyValueStoreSerializedData.argtypes = [
		ctypes.POINTER(BNKeyValueStore),
	]


# noinspection PyPep8Naming
def BNGetKeyValueStoreSerializedData(
		store: ctypes.POINTER(BNKeyValueStore)
		) -> Optional[ctypes.POINTER(BNDataBuffer)]:
	result = _BNGetKeyValueStoreSerializedData(store)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetKeyValueStoreValue

_BNGetKeyValueStoreValue = core.BNGetKeyValueStoreValue
_BNGetKeyValueStoreValue.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetKeyValueStoreValue.argtypes = [
		ctypes.POINTER(BNKeyValueStore),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNGetKeyValueStoreValue(
		store: ctypes.POINTER(BNKeyValueStore), 
		name: Optional[str]
		) -> Optional[Optional[str]]:
	result = _BNGetKeyValueStoreValue(store, cstr(name))
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetKeyValueStoreValueHash

_BNGetKeyValueStoreValueHash = core.BNGetKeyValueStoreValueHash
_BNGetKeyValueStoreValueHash.restype = ctypes.POINTER(BNDataBuffer)
_BNGetKeyValueStoreValueHash.argtypes = [
		ctypes.POINTER(BNKeyValueStore),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNGetKeyValueStoreValueHash(
		store: ctypes.POINTER(BNKeyValueStore), 
		name: Optional[str]
		) -> Optional[ctypes.POINTER(BNDataBuffer)]:
	result = _BNGetKeyValueStoreValueHash(store, cstr(name))
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetKeyValueStoreValueSize

_BNGetKeyValueStoreValueSize = core.BNGetKeyValueStoreValueSize
_BNGetKeyValueStoreValueSize.restype = ctypes.c_ulonglong
_BNGetKeyValueStoreValueSize.argtypes = [
		ctypes.POINTER(BNKeyValueStore),
	]


# noinspection PyPep8Naming
def BNGetKeyValueStoreValueSize(
		store: ctypes.POINTER(BNKeyValueStore)
		) -> int:
	return _BNGetKeyValueStoreValueSize(store)


# -------------------------------------------------------
# _BNGetKeyValueStoreValueStorageSize

_BNGetKeyValueStoreValueStorageSize = core.BNGetKeyValueStoreValueStorageSize
_BNGetKeyValueStoreValueStorageSize.restype = ctypes.c_ulonglong
_BNGetKeyValueStoreValueStorageSize.argtypes = [
		ctypes.POINTER(BNKeyValueStore),
	]


# noinspection PyPep8Naming
def BNGetKeyValueStoreValueStorageSize(
		store: ctypes.POINTER(BNKeyValueStore)
		) -> int:
	return _BNGetKeyValueStoreValueStorageSize(store)


# -------------------------------------------------------
# _BNGetLabelForLowLevelILSourceInstruction

_BNGetLabelForLowLevelILSourceInstruction = core.BNGetLabelForLowLevelILSourceInstruction
_BNGetLabelForLowLevelILSourceInstruction.restype = ctypes.POINTER(BNLowLevelILLabel)
_BNGetLabelForLowLevelILSourceInstruction.argtypes = [
		ctypes.POINTER(BNLowLevelILFunction),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetLabelForLowLevelILSourceInstruction(
		func: ctypes.POINTER(BNLowLevelILFunction), 
		instr: int
		) -> Optional[ctypes.POINTER(BNLowLevelILLabel)]:
	result = _BNGetLabelForLowLevelILSourceInstruction(func, instr)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetLabelForMediumLevelILSourceInstruction

_BNGetLabelForMediumLevelILSourceInstruction = core.BNGetLabelForMediumLevelILSourceInstruction
_BNGetLabelForMediumLevelILSourceInstruction.restype = ctypes.POINTER(BNMediumLevelILLabel)
_BNGetLabelForMediumLevelILSourceInstruction.argtypes = [
		ctypes.POINTER(BNMediumLevelILFunction),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetLabelForMediumLevelILSourceInstruction(
		func: ctypes.POINTER(BNMediumLevelILFunction), 
		instr: int
		) -> Optional[ctypes.POINTER(BNMediumLevelILLabel)]:
	result = _BNGetLabelForMediumLevelILSourceInstruction(func, instr)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetLanguageRepresentationOwnerFunction

_BNGetLanguageRepresentationOwnerFunction = core.BNGetLanguageRepresentationOwnerFunction
_BNGetLanguageRepresentationOwnerFunction.restype = ctypes.POINTER(BNFunction)
_BNGetLanguageRepresentationOwnerFunction.argtypes = [
		ctypes.POINTER(BNLanguageRepresentationFunction),
	]


# noinspection PyPep8Naming
def BNGetLanguageRepresentationOwnerFunction(
		func: ctypes.POINTER(BNLanguageRepresentationFunction)
		) -> Optional[ctypes.POINTER(BNFunction)]:
	result = _BNGetLanguageRepresentationOwnerFunction(func)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetLargeChoiceInput

_BNGetLargeChoiceInput = core.BNGetLargeChoiceInput
_BNGetLargeChoiceInput.restype = ctypes.c_bool
_BNGetLargeChoiceInput.argtypes = [
		ctypes.POINTER(ctypes.c_ulonglong),
		ctypes.c_char_p,
		ctypes.c_char_p,
		ctypes.POINTER(ctypes.c_char_p),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetLargeChoiceInput(
		result: ctypes.POINTER(ctypes.c_ulonglong), 
		prompt: Optional[str], 
		title: Optional[str], 
		choices: ctypes.POINTER(ctypes.c_char_p), 
		count: int
		) -> bool:
	return _BNGetLargeChoiceInput(result, cstr(prompt), cstr(title), choices, count)


# -------------------------------------------------------
# _BNGetLastLinearViewObjectChild

_BNGetLastLinearViewObjectChild = core.BNGetLastLinearViewObjectChild
_BNGetLastLinearViewObjectChild.restype = ctypes.POINTER(BNLinearViewObject)
_BNGetLastLinearViewObjectChild.argtypes = [
		ctypes.POINTER(BNLinearViewObject),
	]


# noinspection PyPep8Naming
def BNGetLastLinearViewObjectChild(
		obj: ctypes.POINTER(BNLinearViewObject)
		) -> Optional[ctypes.POINTER(BNLinearViewObject)]:
	result = _BNGetLastLinearViewObjectChild(obj)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetLastRedoEntry

_BNGetLastRedoEntry = core.BNGetLastRedoEntry
_BNGetLastRedoEntry.restype = BNUndoEntry
_BNGetLastRedoEntry.argtypes = [
		ctypes.POINTER(BNFileMetadata),
	]


# noinspection PyPep8Naming
def BNGetLastRedoEntry(
		file: ctypes.POINTER(BNFileMetadata)
		) -> BNUndoEntry:
	return _BNGetLastRedoEntry(file)


# -------------------------------------------------------
# _BNGetLastRedoEntryTitle

_BNGetLastRedoEntryTitle = core.BNGetLastRedoEntryTitle
_BNGetLastRedoEntryTitle.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetLastRedoEntryTitle.argtypes = [
		ctypes.POINTER(BNFileMetadata),
	]


# noinspection PyPep8Naming
def BNGetLastRedoEntryTitle(
		file: ctypes.POINTER(BNFileMetadata)
		) -> Optional[Optional[str]]:
	result = _BNGetLastRedoEntryTitle(file)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetLastSeenVariableNameOrDefault

_BNGetLastSeenVariableNameOrDefault = core.BNGetLastSeenVariableNameOrDefault
_BNGetLastSeenVariableNameOrDefault.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetLastSeenVariableNameOrDefault.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNVariable),
	]


# noinspection PyPep8Naming
def BNGetLastSeenVariableNameOrDefault(
		func: ctypes.POINTER(BNFunction), 
		var: ctypes.POINTER(BNVariable)
		) -> Optional[Optional[str]]:
	result = _BNGetLastSeenVariableNameOrDefault(func, var)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetLastUndoEntry

_BNGetLastUndoEntry = core.BNGetLastUndoEntry
_BNGetLastUndoEntry.restype = BNUndoEntry
_BNGetLastUndoEntry.argtypes = [
		ctypes.POINTER(BNFileMetadata),
	]


# noinspection PyPep8Naming
def BNGetLastUndoEntry(
		file: ctypes.POINTER(BNFileMetadata)
		) -> BNUndoEntry:
	return _BNGetLastUndoEntry(file)


# -------------------------------------------------------
# _BNGetLastUndoEntryTitle

_BNGetLastUndoEntryTitle = core.BNGetLastUndoEntryTitle
_BNGetLastUndoEntryTitle.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetLastUndoEntryTitle.argtypes = [
		ctypes.POINTER(BNFileMetadata),
	]


# noinspection PyPep8Naming
def BNGetLastUndoEntryTitle(
		file: ctypes.POINTER(BNFileMetadata)
		) -> Optional[Optional[str]]:
	result = _BNGetLastUndoEntryTitle(file)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetLicenseCount

_BNGetLicenseCount = core.BNGetLicenseCount
_BNGetLicenseCount.restype = ctypes.c_int
_BNGetLicenseCount.argtypes = [
	]


# noinspection PyPep8Naming
def BNGetLicenseCount(
		) -> int:
	return _BNGetLicenseCount()


# -------------------------------------------------------
# _BNGetLicenseExpirationTime

_BNGetLicenseExpirationTime = core.BNGetLicenseExpirationTime
_BNGetLicenseExpirationTime.restype = ctypes.c_ulonglong
_BNGetLicenseExpirationTime.argtypes = [
	]


# noinspection PyPep8Naming
def BNGetLicenseExpirationTime(
		) -> int:
	return _BNGetLicenseExpirationTime()


# -------------------------------------------------------
# _BNGetLicensedUserEmail

_BNGetLicensedUserEmail = core.BNGetLicensedUserEmail
_BNGetLicensedUserEmail.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetLicensedUserEmail.argtypes = [
	]


# noinspection PyPep8Naming
def BNGetLicensedUserEmail(
		) -> Optional[Optional[str]]:
	result = _BNGetLicensedUserEmail()
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetLiftedILFlagDefinitionsForUse

_BNGetLiftedILFlagDefinitionsForUse = core.BNGetLiftedILFlagDefinitionsForUse
_BNGetLiftedILFlagDefinitionsForUse.restype = ctypes.POINTER(ctypes.c_ulonglong)
_BNGetLiftedILFlagDefinitionsForUse.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.c_ulonglong,
		ctypes.c_uint,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetLiftedILFlagDefinitionsForUse(
		func: ctypes.POINTER(BNFunction), 
		i: int, 
		flag: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_ulonglong)]:
	result = _BNGetLiftedILFlagDefinitionsForUse(func, i, flag, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetLiftedILFlagUsesForDefinition

_BNGetLiftedILFlagUsesForDefinition = core.BNGetLiftedILFlagUsesForDefinition
_BNGetLiftedILFlagUsesForDefinition.restype = ctypes.POINTER(ctypes.c_ulonglong)
_BNGetLiftedILFlagUsesForDefinition.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.c_ulonglong,
		ctypes.c_uint,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetLiftedILFlagUsesForDefinition(
		func: ctypes.POINTER(BNFunction), 
		i: int, 
		flag: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_ulonglong)]:
	result = _BNGetLiftedILFlagUsesForDefinition(func, i, flag, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetLiftedILForInstruction

_BNGetLiftedILForInstruction = core.BNGetLiftedILForInstruction
_BNGetLiftedILForInstruction.restype = ctypes.c_ulonglong
_BNGetLiftedILForInstruction.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNArchitecture),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetLiftedILForInstruction(
		func: ctypes.POINTER(BNFunction), 
		arch: ctypes.POINTER(BNArchitecture), 
		addr: int
		) -> int:
	return _BNGetLiftedILForInstruction(func, arch, addr)


# -------------------------------------------------------
# _BNGetLiftedILInstructionsForAddress

_BNGetLiftedILInstructionsForAddress = core.BNGetLiftedILInstructionsForAddress
_BNGetLiftedILInstructionsForAddress.restype = ctypes.POINTER(ctypes.c_ulonglong)
_BNGetLiftedILInstructionsForAddress.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNArchitecture),
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetLiftedILInstructionsForAddress(
		func: ctypes.POINTER(BNFunction), 
		arch: ctypes.POINTER(BNArchitecture), 
		addr: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_ulonglong)]:
	result = _BNGetLiftedILInstructionsForAddress(func, arch, addr, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetLinearViewCursorCurrentObject

_BNGetLinearViewCursorCurrentObject = core.BNGetLinearViewCursorCurrentObject
_BNGetLinearViewCursorCurrentObject.restype = ctypes.POINTER(BNLinearViewObject)
_BNGetLinearViewCursorCurrentObject.argtypes = [
		ctypes.POINTER(BNLinearViewCursor),
	]


# noinspection PyPep8Naming
def BNGetLinearViewCursorCurrentObject(
		cursor: ctypes.POINTER(BNLinearViewCursor)
		) -> Optional[ctypes.POINTER(BNLinearViewObject)]:
	result = _BNGetLinearViewCursorCurrentObject(cursor)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetLinearViewCursorLines

_BNGetLinearViewCursorLines = core.BNGetLinearViewCursorLines
_BNGetLinearViewCursorLines.restype = ctypes.POINTER(BNLinearDisassemblyLine)
_BNGetLinearViewCursorLines.argtypes = [
		ctypes.POINTER(BNLinearViewCursor),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetLinearViewCursorLines(
		cursor: ctypes.POINTER(BNLinearViewCursor), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNLinearDisassemblyLine)]:
	result = _BNGetLinearViewCursorLines(cursor, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetLinearViewCursorOrderingIndex

_BNGetLinearViewCursorOrderingIndex = core.BNGetLinearViewCursorOrderingIndex
_BNGetLinearViewCursorOrderingIndex.restype = BNAddressRange
_BNGetLinearViewCursorOrderingIndex.argtypes = [
		ctypes.POINTER(BNLinearViewCursor),
	]


# noinspection PyPep8Naming
def BNGetLinearViewCursorOrderingIndex(
		cursor: ctypes.POINTER(BNLinearViewCursor)
		) -> BNAddressRange:
	return _BNGetLinearViewCursorOrderingIndex(cursor)


# -------------------------------------------------------
# _BNGetLinearViewCursorOrderingIndexTotal

_BNGetLinearViewCursorOrderingIndexTotal = core.BNGetLinearViewCursorOrderingIndexTotal
_BNGetLinearViewCursorOrderingIndexTotal.restype = ctypes.c_ulonglong
_BNGetLinearViewCursorOrderingIndexTotal.argtypes = [
		ctypes.POINTER(BNLinearViewCursor),
	]


# noinspection PyPep8Naming
def BNGetLinearViewCursorOrderingIndexTotal(
		cursor: ctypes.POINTER(BNLinearViewCursor)
		) -> int:
	return _BNGetLinearViewCursorOrderingIndexTotal(cursor)


# -------------------------------------------------------
# _BNGetLinearViewCursorPath

_BNGetLinearViewCursorPath = core.BNGetLinearViewCursorPath
_BNGetLinearViewCursorPath.restype = ctypes.POINTER(BNLinearViewObjectIdentifier)
_BNGetLinearViewCursorPath.argtypes = [
		ctypes.POINTER(BNLinearViewCursor),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetLinearViewCursorPath(
		cursor: ctypes.POINTER(BNLinearViewCursor), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNLinearViewObjectIdentifier)]:
	result = _BNGetLinearViewCursorPath(cursor, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetLinearViewCursorPathObjects

_BNGetLinearViewCursorPathObjects = core.BNGetLinearViewCursorPathObjects
_BNGetLinearViewCursorPathObjects.restype = ctypes.POINTER(ctypes.POINTER(BNLinearViewObject))
_BNGetLinearViewCursorPathObjects.argtypes = [
		ctypes.POINTER(BNLinearViewCursor),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetLinearViewCursorPathObjects(
		cursor: ctypes.POINTER(BNLinearViewCursor), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.POINTER(BNLinearViewObject))]:
	result = _BNGetLinearViewCursorPathObjects(cursor, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetLinearViewObjectChildForAddress

_BNGetLinearViewObjectChildForAddress = core.BNGetLinearViewObjectChildForAddress
_BNGetLinearViewObjectChildForAddress.restype = ctypes.POINTER(BNLinearViewObject)
_BNGetLinearViewObjectChildForAddress.argtypes = [
		ctypes.POINTER(BNLinearViewObject),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetLinearViewObjectChildForAddress(
		parent: ctypes.POINTER(BNLinearViewObject), 
		addr: int
		) -> Optional[ctypes.POINTER(BNLinearViewObject)]:
	result = _BNGetLinearViewObjectChildForAddress(parent, addr)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetLinearViewObjectChildForIdentifier

_BNGetLinearViewObjectChildForIdentifier = core.BNGetLinearViewObjectChildForIdentifier
_BNGetLinearViewObjectChildForIdentifier.restype = ctypes.POINTER(BNLinearViewObject)
_BNGetLinearViewObjectChildForIdentifier.argtypes = [
		ctypes.POINTER(BNLinearViewObject),
		ctypes.POINTER(BNLinearViewObjectIdentifier),
	]


# noinspection PyPep8Naming
def BNGetLinearViewObjectChildForIdentifier(
		parent: ctypes.POINTER(BNLinearViewObject), 
		id: ctypes.POINTER(BNLinearViewObjectIdentifier)
		) -> Optional[ctypes.POINTER(BNLinearViewObject)]:
	result = _BNGetLinearViewObjectChildForIdentifier(parent, id)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetLinearViewObjectChildForOrderingIndex

_BNGetLinearViewObjectChildForOrderingIndex = core.BNGetLinearViewObjectChildForOrderingIndex
_BNGetLinearViewObjectChildForOrderingIndex.restype = ctypes.POINTER(BNLinearViewObject)
_BNGetLinearViewObjectChildForOrderingIndex.argtypes = [
		ctypes.POINTER(BNLinearViewObject),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetLinearViewObjectChildForOrderingIndex(
		parent: ctypes.POINTER(BNLinearViewObject), 
		idx: int
		) -> Optional[ctypes.POINTER(BNLinearViewObject)]:
	result = _BNGetLinearViewObjectChildForOrderingIndex(parent, idx)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetLinearViewObjectEnd

_BNGetLinearViewObjectEnd = core.BNGetLinearViewObjectEnd
_BNGetLinearViewObjectEnd.restype = ctypes.c_ulonglong
_BNGetLinearViewObjectEnd.argtypes = [
		ctypes.POINTER(BNLinearViewObject),
	]


# noinspection PyPep8Naming
def BNGetLinearViewObjectEnd(
		obj: ctypes.POINTER(BNLinearViewObject)
		) -> int:
	return _BNGetLinearViewObjectEnd(obj)


# -------------------------------------------------------
# _BNGetLinearViewObjectIdentifier

_BNGetLinearViewObjectIdentifier = core.BNGetLinearViewObjectIdentifier
_BNGetLinearViewObjectIdentifier.restype = BNLinearViewObjectIdentifier
_BNGetLinearViewObjectIdentifier.argtypes = [
		ctypes.POINTER(BNLinearViewObject),
	]


# noinspection PyPep8Naming
def BNGetLinearViewObjectIdentifier(
		obj: ctypes.POINTER(BNLinearViewObject)
		) -> BNLinearViewObjectIdentifier:
	return _BNGetLinearViewObjectIdentifier(obj)


# -------------------------------------------------------
# _BNGetLinearViewObjectLines

_BNGetLinearViewObjectLines = core.BNGetLinearViewObjectLines
_BNGetLinearViewObjectLines.restype = ctypes.POINTER(BNLinearDisassemblyLine)
_BNGetLinearViewObjectLines.argtypes = [
		ctypes.POINTER(BNLinearViewObject),
		ctypes.POINTER(BNLinearViewObject),
		ctypes.POINTER(BNLinearViewObject),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetLinearViewObjectLines(
		obj: ctypes.POINTER(BNLinearViewObject), 
		prev: ctypes.POINTER(BNLinearViewObject), 
		next: ctypes.POINTER(BNLinearViewObject), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNLinearDisassemblyLine)]:
	result = _BNGetLinearViewObjectLines(obj, prev, next, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetLinearViewObjectOrderingIndexForChild

_BNGetLinearViewObjectOrderingIndexForChild = core.BNGetLinearViewObjectOrderingIndexForChild
_BNGetLinearViewObjectOrderingIndexForChild.restype = ctypes.c_ulonglong
_BNGetLinearViewObjectOrderingIndexForChild.argtypes = [
		ctypes.POINTER(BNLinearViewObject),
		ctypes.POINTER(BNLinearViewObject),
	]


# noinspection PyPep8Naming
def BNGetLinearViewObjectOrderingIndexForChild(
		parent: ctypes.POINTER(BNLinearViewObject), 
		child: ctypes.POINTER(BNLinearViewObject)
		) -> int:
	return _BNGetLinearViewObjectOrderingIndexForChild(parent, child)


# -------------------------------------------------------
# _BNGetLinearViewObjectOrderingIndexTotal

_BNGetLinearViewObjectOrderingIndexTotal = core.BNGetLinearViewObjectOrderingIndexTotal
_BNGetLinearViewObjectOrderingIndexTotal.restype = ctypes.c_ulonglong
_BNGetLinearViewObjectOrderingIndexTotal.argtypes = [
		ctypes.POINTER(BNLinearViewObject),
	]


# noinspection PyPep8Naming
def BNGetLinearViewObjectOrderingIndexTotal(
		obj: ctypes.POINTER(BNLinearViewObject)
		) -> int:
	return _BNGetLinearViewObjectOrderingIndexTotal(obj)


# -------------------------------------------------------
# _BNGetLinearViewObjectStart

_BNGetLinearViewObjectStart = core.BNGetLinearViewObjectStart
_BNGetLinearViewObjectStart.restype = ctypes.c_ulonglong
_BNGetLinearViewObjectStart.argtypes = [
		ctypes.POINTER(BNLinearViewObject),
	]


# noinspection PyPep8Naming
def BNGetLinearViewObjectStart(
		obj: ctypes.POINTER(BNLinearViewObject)
		) -> int:
	return _BNGetLinearViewObjectStart(obj)


# -------------------------------------------------------
# _BNGetLinesForData

_BNGetLinesForData = core.BNGetLinesForData
_BNGetLinesForData.restype = ctypes.POINTER(BNDisassemblyTextLine)
_BNGetLinesForData.argtypes = [
		ctypes.c_void_p,
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
		ctypes.POINTER(BNType),
		ctypes.POINTER(BNInstructionTextToken),
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
		ctypes.POINTER(BNTypeContext),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetLinesForData(
		ctxt: Optional[ctypes.c_void_p], 
		view: ctypes.POINTER(BNBinaryView), 
		addr: int, 
		type: ctypes.POINTER(BNType), 
		prefix: ctypes.POINTER(BNInstructionTextToken), 
		prefixCount: int, 
		width: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong), 
		typeCtx: ctypes.POINTER(BNTypeContext), 
		ctxCount: int
		) -> Optional[ctypes.POINTER(BNDisassemblyTextLine)]:
	result = _BNGetLinesForData(ctxt, view, addr, type, prefix, prefixCount, width, count, typeCtx, ctxCount)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetLowLevelFlagSSAVersions

_BNGetLowLevelFlagSSAVersions = core.BNGetLowLevelFlagSSAVersions
_BNGetLowLevelFlagSSAVersions.restype = ctypes.POINTER(ctypes.c_ulonglong)
_BNGetLowLevelFlagSSAVersions.argtypes = [
		ctypes.POINTER(BNLowLevelILFunction),
		ctypes.c_uint,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetLowLevelFlagSSAVersions(
		func: ctypes.POINTER(BNLowLevelILFunction), 
		var: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_ulonglong)]:
	result = _BNGetLowLevelFlagSSAVersions(func, var, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetLowLevelFlags

_BNGetLowLevelFlags = core.BNGetLowLevelFlags
_BNGetLowLevelFlags.restype = ctypes.POINTER(ctypes.c_uint)
_BNGetLowLevelFlags.argtypes = [
		ctypes.POINTER(BNLowLevelILFunction),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetLowLevelFlags(
		func: ctypes.POINTER(BNLowLevelILFunction), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_uint)]:
	result = _BNGetLowLevelFlags(func, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetLowLevelILBasicBlockForInstruction

_BNGetLowLevelILBasicBlockForInstruction = core.BNGetLowLevelILBasicBlockForInstruction
_BNGetLowLevelILBasicBlockForInstruction.restype = ctypes.POINTER(BNBasicBlock)
_BNGetLowLevelILBasicBlockForInstruction.argtypes = [
		ctypes.POINTER(BNLowLevelILFunction),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetLowLevelILBasicBlockForInstruction(
		func: ctypes.POINTER(BNLowLevelILFunction), 
		i: int
		) -> Optional[ctypes.POINTER(BNBasicBlock)]:
	result = _BNGetLowLevelILBasicBlockForInstruction(func, i)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetLowLevelILBasicBlockList

_BNGetLowLevelILBasicBlockList = core.BNGetLowLevelILBasicBlockList
_BNGetLowLevelILBasicBlockList.restype = ctypes.POINTER(ctypes.POINTER(BNBasicBlock))
_BNGetLowLevelILBasicBlockList.argtypes = [
		ctypes.POINTER(BNLowLevelILFunction),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetLowLevelILBasicBlockList(
		func: ctypes.POINTER(BNLowLevelILFunction), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.POINTER(BNBasicBlock))]:
	result = _BNGetLowLevelILBasicBlockList(func, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetLowLevelILByIndex

_BNGetLowLevelILByIndex = core.BNGetLowLevelILByIndex
_BNGetLowLevelILByIndex.restype = BNLowLevelILInstruction
_BNGetLowLevelILByIndex.argtypes = [
		ctypes.POINTER(BNLowLevelILFunction),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetLowLevelILByIndex(
		func: ctypes.POINTER(BNLowLevelILFunction), 
		i: int
		) -> BNLowLevelILInstruction:
	return _BNGetLowLevelILByIndex(func, i)


# -------------------------------------------------------
# _BNGetLowLevelILExitsForInstruction

_BNGetLowLevelILExitsForInstruction = core.BNGetLowLevelILExitsForInstruction
_BNGetLowLevelILExitsForInstruction.restype = ctypes.POINTER(ctypes.c_ulonglong)
_BNGetLowLevelILExitsForInstruction.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNArchitecture),
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetLowLevelILExitsForInstruction(
		func: ctypes.POINTER(BNFunction), 
		arch: ctypes.POINTER(BNArchitecture), 
		addr: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_ulonglong)]:
	result = _BNGetLowLevelILExitsForInstruction(func, arch, addr, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetLowLevelILExprCount

_BNGetLowLevelILExprCount = core.BNGetLowLevelILExprCount
_BNGetLowLevelILExprCount.restype = ctypes.c_ulonglong
_BNGetLowLevelILExprCount.argtypes = [
		ctypes.POINTER(BNLowLevelILFunction),
	]


# noinspection PyPep8Naming
def BNGetLowLevelILExprCount(
		func: ctypes.POINTER(BNLowLevelILFunction)
		) -> int:
	return _BNGetLowLevelILExprCount(func)


# -------------------------------------------------------
# _BNGetLowLevelILExprIndex

_BNGetLowLevelILExprIndex = core.BNGetLowLevelILExprIndex
_BNGetLowLevelILExprIndex.restype = ctypes.c_ulonglong
_BNGetLowLevelILExprIndex.argtypes = [
		ctypes.POINTER(BNMediumLevelILFunction),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetLowLevelILExprIndex(
		func: ctypes.POINTER(BNMediumLevelILFunction), 
		expr: int
		) -> int:
	return _BNGetLowLevelILExprIndex(func, expr)


# -------------------------------------------------------
# _BNGetLowLevelILExprIndexes

_BNGetLowLevelILExprIndexes = core.BNGetLowLevelILExprIndexes
_BNGetLowLevelILExprIndexes.restype = ctypes.POINTER(ctypes.c_ulonglong)
_BNGetLowLevelILExprIndexes.argtypes = [
		ctypes.POINTER(BNMediumLevelILFunction),
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetLowLevelILExprIndexes(
		func: ctypes.POINTER(BNMediumLevelILFunction), 
		expr: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_ulonglong)]:
	result = _BNGetLowLevelILExprIndexes(func, expr, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetLowLevelILExprText

_BNGetLowLevelILExprText = core.BNGetLowLevelILExprText
_BNGetLowLevelILExprText.restype = ctypes.c_bool
_BNGetLowLevelILExprText.argtypes = [
		ctypes.POINTER(BNLowLevelILFunction),
		ctypes.POINTER(BNArchitecture),
		ctypes.c_ulonglong,
		ctypes.POINTER(BNDisassemblySettings),
		ctypes.POINTER(ctypes.POINTER(BNInstructionTextToken)),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetLowLevelILExprText(
		func: ctypes.POINTER(BNLowLevelILFunction), 
		arch: ctypes.POINTER(BNArchitecture), 
		i: int, 
		settings: ctypes.POINTER(BNDisassemblySettings), 
		tokens: ctypes.POINTER(ctypes.POINTER(BNInstructionTextToken)), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> bool:
	return _BNGetLowLevelILExprText(func, arch, i, settings, tokens, count)


# -------------------------------------------------------
# _BNGetLowLevelILExprValue

_BNGetLowLevelILExprValue = core.BNGetLowLevelILExprValue
_BNGetLowLevelILExprValue.restype = BNRegisterValue
_BNGetLowLevelILExprValue.argtypes = [
		ctypes.POINTER(BNLowLevelILFunction),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetLowLevelILExprValue(
		func: ctypes.POINTER(BNLowLevelILFunction), 
		expr: int
		) -> BNRegisterValue:
	return _BNGetLowLevelILExprValue(func, expr)


# -------------------------------------------------------
# _BNGetLowLevelILFlagValueAfterInstruction

_BNGetLowLevelILFlagValueAfterInstruction = core.BNGetLowLevelILFlagValueAfterInstruction
_BNGetLowLevelILFlagValueAfterInstruction.restype = BNRegisterValue
_BNGetLowLevelILFlagValueAfterInstruction.argtypes = [
		ctypes.POINTER(BNLowLevelILFunction),
		ctypes.c_uint,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetLowLevelILFlagValueAfterInstruction(
		func: ctypes.POINTER(BNLowLevelILFunction), 
		flag: int, 
		instr: int
		) -> BNRegisterValue:
	return _BNGetLowLevelILFlagValueAfterInstruction(func, flag, instr)


# -------------------------------------------------------
# _BNGetLowLevelILFlagValueAtInstruction

_BNGetLowLevelILFlagValueAtInstruction = core.BNGetLowLevelILFlagValueAtInstruction
_BNGetLowLevelILFlagValueAtInstruction.restype = BNRegisterValue
_BNGetLowLevelILFlagValueAtInstruction.argtypes = [
		ctypes.POINTER(BNLowLevelILFunction),
		ctypes.c_uint,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetLowLevelILFlagValueAtInstruction(
		func: ctypes.POINTER(BNLowLevelILFunction), 
		flag: int, 
		instr: int
		) -> BNRegisterValue:
	return _BNGetLowLevelILFlagValueAtInstruction(func, flag, instr)


# -------------------------------------------------------
# _BNGetLowLevelILForInstruction

_BNGetLowLevelILForInstruction = core.BNGetLowLevelILForInstruction
_BNGetLowLevelILForInstruction.restype = ctypes.c_ulonglong
_BNGetLowLevelILForInstruction.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNArchitecture),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetLowLevelILForInstruction(
		func: ctypes.POINTER(BNFunction), 
		arch: ctypes.POINTER(BNArchitecture), 
		addr: int
		) -> int:
	return _BNGetLowLevelILForInstruction(func, arch, addr)


# -------------------------------------------------------
# _BNGetLowLevelILForMediumLevelIL

_BNGetLowLevelILForMediumLevelIL = core.BNGetLowLevelILForMediumLevelIL
_BNGetLowLevelILForMediumLevelIL.restype = ctypes.POINTER(BNLowLevelILFunction)
_BNGetLowLevelILForMediumLevelIL.argtypes = [
		ctypes.POINTER(BNMediumLevelILFunction),
	]


# noinspection PyPep8Naming
def BNGetLowLevelILForMediumLevelIL(
		func: ctypes.POINTER(BNMediumLevelILFunction)
		) -> Optional[ctypes.POINTER(BNLowLevelILFunction)]:
	result = _BNGetLowLevelILForMediumLevelIL(func)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetLowLevelILIndexForInstruction

_BNGetLowLevelILIndexForInstruction = core.BNGetLowLevelILIndexForInstruction
_BNGetLowLevelILIndexForInstruction.restype = ctypes.c_ulonglong
_BNGetLowLevelILIndexForInstruction.argtypes = [
		ctypes.POINTER(BNLowLevelILFunction),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetLowLevelILIndexForInstruction(
		func: ctypes.POINTER(BNLowLevelILFunction), 
		i: int
		) -> int:
	return _BNGetLowLevelILIndexForInstruction(func, i)


# -------------------------------------------------------
# _BNGetLowLevelILInstructionCount

_BNGetLowLevelILInstructionCount = core.BNGetLowLevelILInstructionCount
_BNGetLowLevelILInstructionCount.restype = ctypes.c_ulonglong
_BNGetLowLevelILInstructionCount.argtypes = [
		ctypes.POINTER(BNLowLevelILFunction),
	]


# noinspection PyPep8Naming
def BNGetLowLevelILInstructionCount(
		func: ctypes.POINTER(BNLowLevelILFunction)
		) -> int:
	return _BNGetLowLevelILInstructionCount(func)


# -------------------------------------------------------
# _BNGetLowLevelILInstructionForExpr

_BNGetLowLevelILInstructionForExpr = core.BNGetLowLevelILInstructionForExpr
_BNGetLowLevelILInstructionForExpr.restype = ctypes.c_ulonglong
_BNGetLowLevelILInstructionForExpr.argtypes = [
		ctypes.POINTER(BNLowLevelILFunction),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetLowLevelILInstructionForExpr(
		func: ctypes.POINTER(BNLowLevelILFunction), 
		expr: int
		) -> int:
	return _BNGetLowLevelILInstructionForExpr(func, expr)


# -------------------------------------------------------
# _BNGetLowLevelILInstructionIndex

_BNGetLowLevelILInstructionIndex = core.BNGetLowLevelILInstructionIndex
_BNGetLowLevelILInstructionIndex.restype = ctypes.c_ulonglong
_BNGetLowLevelILInstructionIndex.argtypes = [
		ctypes.POINTER(BNMediumLevelILFunction),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetLowLevelILInstructionIndex(
		func: ctypes.POINTER(BNMediumLevelILFunction), 
		instr: int
		) -> int:
	return _BNGetLowLevelILInstructionIndex(func, instr)


# -------------------------------------------------------
# _BNGetLowLevelILInstructionText

_BNGetLowLevelILInstructionText = core.BNGetLowLevelILInstructionText
_BNGetLowLevelILInstructionText.restype = ctypes.c_bool
_BNGetLowLevelILInstructionText.argtypes = [
		ctypes.POINTER(BNLowLevelILFunction),
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNArchitecture),
		ctypes.c_ulonglong,
		ctypes.POINTER(BNDisassemblySettings),
		ctypes.POINTER(ctypes.POINTER(BNInstructionTextToken)),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetLowLevelILInstructionText(
		il: ctypes.POINTER(BNLowLevelILFunction), 
		func: ctypes.POINTER(BNFunction), 
		arch: ctypes.POINTER(BNArchitecture), 
		i: int, 
		settings: ctypes.POINTER(BNDisassemblySettings), 
		tokens: ctypes.POINTER(ctypes.POINTER(BNInstructionTextToken)), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> bool:
	return _BNGetLowLevelILInstructionText(il, func, arch, i, settings, tokens, count)


# -------------------------------------------------------
# _BNGetLowLevelILInstructionsForAddress

_BNGetLowLevelILInstructionsForAddress = core.BNGetLowLevelILInstructionsForAddress
_BNGetLowLevelILInstructionsForAddress.restype = ctypes.POINTER(ctypes.c_ulonglong)
_BNGetLowLevelILInstructionsForAddress.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNArchitecture),
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetLowLevelILInstructionsForAddress(
		func: ctypes.POINTER(BNFunction), 
		arch: ctypes.POINTER(BNArchitecture), 
		addr: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_ulonglong)]:
	result = _BNGetLowLevelILInstructionsForAddress(func, arch, addr, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetLowLevelILLabelForAddress

_BNGetLowLevelILLabelForAddress = core.BNGetLowLevelILLabelForAddress
_BNGetLowLevelILLabelForAddress.restype = ctypes.POINTER(BNLowLevelILLabel)
_BNGetLowLevelILLabelForAddress.argtypes = [
		ctypes.POINTER(BNLowLevelILFunction),
		ctypes.POINTER(BNArchitecture),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetLowLevelILLabelForAddress(
		func: ctypes.POINTER(BNLowLevelILFunction), 
		arch: ctypes.POINTER(BNArchitecture), 
		addr: int
		) -> Optional[ctypes.POINTER(BNLowLevelILLabel)]:
	result = _BNGetLowLevelILLabelForAddress(func, arch, addr)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetLowLevelILNonSSAExprIndex

_BNGetLowLevelILNonSSAExprIndex = core.BNGetLowLevelILNonSSAExprIndex
_BNGetLowLevelILNonSSAExprIndex.restype = ctypes.c_ulonglong
_BNGetLowLevelILNonSSAExprIndex.argtypes = [
		ctypes.POINTER(BNLowLevelILFunction),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetLowLevelILNonSSAExprIndex(
		func: ctypes.POINTER(BNLowLevelILFunction), 
		expr: int
		) -> int:
	return _BNGetLowLevelILNonSSAExprIndex(func, expr)


# -------------------------------------------------------
# _BNGetLowLevelILNonSSAForm

_BNGetLowLevelILNonSSAForm = core.BNGetLowLevelILNonSSAForm
_BNGetLowLevelILNonSSAForm.restype = ctypes.POINTER(BNLowLevelILFunction)
_BNGetLowLevelILNonSSAForm.argtypes = [
		ctypes.POINTER(BNLowLevelILFunction),
	]


# noinspection PyPep8Naming
def BNGetLowLevelILNonSSAForm(
		func: ctypes.POINTER(BNLowLevelILFunction)
		) -> Optional[ctypes.POINTER(BNLowLevelILFunction)]:
	result = _BNGetLowLevelILNonSSAForm(func)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetLowLevelILNonSSAInstructionIndex

_BNGetLowLevelILNonSSAInstructionIndex = core.BNGetLowLevelILNonSSAInstructionIndex
_BNGetLowLevelILNonSSAInstructionIndex.restype = ctypes.c_ulonglong
_BNGetLowLevelILNonSSAInstructionIndex.argtypes = [
		ctypes.POINTER(BNLowLevelILFunction),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetLowLevelILNonSSAInstructionIndex(
		func: ctypes.POINTER(BNLowLevelILFunction), 
		instr: int
		) -> int:
	return _BNGetLowLevelILNonSSAInstructionIndex(func, instr)


# -------------------------------------------------------
# _BNGetLowLevelILOwnerFunction

_BNGetLowLevelILOwnerFunction = core.BNGetLowLevelILOwnerFunction
_BNGetLowLevelILOwnerFunction.restype = ctypes.POINTER(BNFunction)
_BNGetLowLevelILOwnerFunction.argtypes = [
		ctypes.POINTER(BNLowLevelILFunction),
	]


# noinspection PyPep8Naming
def BNGetLowLevelILOwnerFunction(
		func: ctypes.POINTER(BNLowLevelILFunction)
		) -> Optional[ctypes.POINTER(BNFunction)]:
	result = _BNGetLowLevelILOwnerFunction(func)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetLowLevelILPossibleExprValues

_BNGetLowLevelILPossibleExprValues = core.BNGetLowLevelILPossibleExprValues
_BNGetLowLevelILPossibleExprValues.restype = BNPossibleValueSet
_BNGetLowLevelILPossibleExprValues.argtypes = [
		ctypes.POINTER(BNLowLevelILFunction),
		ctypes.c_ulonglong,
		ctypes.POINTER(DataFlowQueryOptionEnum),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetLowLevelILPossibleExprValues(
		func: ctypes.POINTER(BNLowLevelILFunction), 
		expr: int, 
		options: ctypes.POINTER(DataFlowQueryOptionEnum), 
		optionCount: int
		) -> BNPossibleValueSet:
	return _BNGetLowLevelILPossibleExprValues(func, expr, options, optionCount)


# -------------------------------------------------------
# _BNGetLowLevelILPossibleFlagValuesAfterInstruction

_BNGetLowLevelILPossibleFlagValuesAfterInstruction = core.BNGetLowLevelILPossibleFlagValuesAfterInstruction
_BNGetLowLevelILPossibleFlagValuesAfterInstruction.restype = BNPossibleValueSet
_BNGetLowLevelILPossibleFlagValuesAfterInstruction.argtypes = [
		ctypes.POINTER(BNLowLevelILFunction),
		ctypes.c_uint,
		ctypes.c_ulonglong,
		ctypes.POINTER(DataFlowQueryOptionEnum),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetLowLevelILPossibleFlagValuesAfterInstruction(
		func: ctypes.POINTER(BNLowLevelILFunction), 
		flag: int, 
		instr: int, 
		options: ctypes.POINTER(DataFlowQueryOptionEnum), 
		optionCount: int
		) -> BNPossibleValueSet:
	return _BNGetLowLevelILPossibleFlagValuesAfterInstruction(func, flag, instr, options, optionCount)


# -------------------------------------------------------
# _BNGetLowLevelILPossibleFlagValuesAtInstruction

_BNGetLowLevelILPossibleFlagValuesAtInstruction = core.BNGetLowLevelILPossibleFlagValuesAtInstruction
_BNGetLowLevelILPossibleFlagValuesAtInstruction.restype = BNPossibleValueSet
_BNGetLowLevelILPossibleFlagValuesAtInstruction.argtypes = [
		ctypes.POINTER(BNLowLevelILFunction),
		ctypes.c_uint,
		ctypes.c_ulonglong,
		ctypes.POINTER(DataFlowQueryOptionEnum),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetLowLevelILPossibleFlagValuesAtInstruction(
		func: ctypes.POINTER(BNLowLevelILFunction), 
		flag: int, 
		instr: int, 
		options: ctypes.POINTER(DataFlowQueryOptionEnum), 
		optionCount: int
		) -> BNPossibleValueSet:
	return _BNGetLowLevelILPossibleFlagValuesAtInstruction(func, flag, instr, options, optionCount)


# -------------------------------------------------------
# _BNGetLowLevelILPossibleRegisterValuesAfterInstruction

_BNGetLowLevelILPossibleRegisterValuesAfterInstruction = core.BNGetLowLevelILPossibleRegisterValuesAfterInstruction
_BNGetLowLevelILPossibleRegisterValuesAfterInstruction.restype = BNPossibleValueSet
_BNGetLowLevelILPossibleRegisterValuesAfterInstruction.argtypes = [
		ctypes.POINTER(BNLowLevelILFunction),
		ctypes.c_uint,
		ctypes.c_ulonglong,
		ctypes.POINTER(DataFlowQueryOptionEnum),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetLowLevelILPossibleRegisterValuesAfterInstruction(
		func: ctypes.POINTER(BNLowLevelILFunction), 
		reg: int, 
		instr: int, 
		options: ctypes.POINTER(DataFlowQueryOptionEnum), 
		optionCount: int
		) -> BNPossibleValueSet:
	return _BNGetLowLevelILPossibleRegisterValuesAfterInstruction(func, reg, instr, options, optionCount)


# -------------------------------------------------------
# _BNGetLowLevelILPossibleRegisterValuesAtInstruction

_BNGetLowLevelILPossibleRegisterValuesAtInstruction = core.BNGetLowLevelILPossibleRegisterValuesAtInstruction
_BNGetLowLevelILPossibleRegisterValuesAtInstruction.restype = BNPossibleValueSet
_BNGetLowLevelILPossibleRegisterValuesAtInstruction.argtypes = [
		ctypes.POINTER(BNLowLevelILFunction),
		ctypes.c_uint,
		ctypes.c_ulonglong,
		ctypes.POINTER(DataFlowQueryOptionEnum),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetLowLevelILPossibleRegisterValuesAtInstruction(
		func: ctypes.POINTER(BNLowLevelILFunction), 
		reg: int, 
		instr: int, 
		options: ctypes.POINTER(DataFlowQueryOptionEnum), 
		optionCount: int
		) -> BNPossibleValueSet:
	return _BNGetLowLevelILPossibleRegisterValuesAtInstruction(func, reg, instr, options, optionCount)


# -------------------------------------------------------
# _BNGetLowLevelILPossibleStackContentsAfterInstruction

_BNGetLowLevelILPossibleStackContentsAfterInstruction = core.BNGetLowLevelILPossibleStackContentsAfterInstruction
_BNGetLowLevelILPossibleStackContentsAfterInstruction.restype = BNPossibleValueSet
_BNGetLowLevelILPossibleStackContentsAfterInstruction.argtypes = [
		ctypes.POINTER(BNLowLevelILFunction),
		ctypes.c_longlong,
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
		ctypes.POINTER(DataFlowQueryOptionEnum),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetLowLevelILPossibleStackContentsAfterInstruction(
		func: ctypes.POINTER(BNLowLevelILFunction), 
		offset: int, 
		len: int, 
		instr: int, 
		options: ctypes.POINTER(DataFlowQueryOptionEnum), 
		optionCount: int
		) -> BNPossibleValueSet:
	return _BNGetLowLevelILPossibleStackContentsAfterInstruction(func, offset, len, instr, options, optionCount)


# -------------------------------------------------------
# _BNGetLowLevelILPossibleStackContentsAtInstruction

_BNGetLowLevelILPossibleStackContentsAtInstruction = core.BNGetLowLevelILPossibleStackContentsAtInstruction
_BNGetLowLevelILPossibleStackContentsAtInstruction.restype = BNPossibleValueSet
_BNGetLowLevelILPossibleStackContentsAtInstruction.argtypes = [
		ctypes.POINTER(BNLowLevelILFunction),
		ctypes.c_longlong,
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
		ctypes.POINTER(DataFlowQueryOptionEnum),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetLowLevelILPossibleStackContentsAtInstruction(
		func: ctypes.POINTER(BNLowLevelILFunction), 
		offset: int, 
		len: int, 
		instr: int, 
		options: ctypes.POINTER(DataFlowQueryOptionEnum), 
		optionCount: int
		) -> BNPossibleValueSet:
	return _BNGetLowLevelILPossibleStackContentsAtInstruction(func, offset, len, instr, options, optionCount)


# -------------------------------------------------------
# _BNGetLowLevelILRegisterValueAfterInstruction

_BNGetLowLevelILRegisterValueAfterInstruction = core.BNGetLowLevelILRegisterValueAfterInstruction
_BNGetLowLevelILRegisterValueAfterInstruction.restype = BNRegisterValue
_BNGetLowLevelILRegisterValueAfterInstruction.argtypes = [
		ctypes.POINTER(BNLowLevelILFunction),
		ctypes.c_uint,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetLowLevelILRegisterValueAfterInstruction(
		func: ctypes.POINTER(BNLowLevelILFunction), 
		reg: int, 
		instr: int
		) -> BNRegisterValue:
	return _BNGetLowLevelILRegisterValueAfterInstruction(func, reg, instr)


# -------------------------------------------------------
# _BNGetLowLevelILRegisterValueAtInstruction

_BNGetLowLevelILRegisterValueAtInstruction = core.BNGetLowLevelILRegisterValueAtInstruction
_BNGetLowLevelILRegisterValueAtInstruction.restype = BNRegisterValue
_BNGetLowLevelILRegisterValueAtInstruction.argtypes = [
		ctypes.POINTER(BNLowLevelILFunction),
		ctypes.c_uint,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetLowLevelILRegisterValueAtInstruction(
		func: ctypes.POINTER(BNLowLevelILFunction), 
		reg: int, 
		instr: int
		) -> BNRegisterValue:
	return _BNGetLowLevelILRegisterValueAtInstruction(func, reg, instr)


# -------------------------------------------------------
# _BNGetLowLevelILSSAExprIndex

_BNGetLowLevelILSSAExprIndex = core.BNGetLowLevelILSSAExprIndex
_BNGetLowLevelILSSAExprIndex.restype = ctypes.c_ulonglong
_BNGetLowLevelILSSAExprIndex.argtypes = [
		ctypes.POINTER(BNLowLevelILFunction),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetLowLevelILSSAExprIndex(
		func: ctypes.POINTER(BNLowLevelILFunction), 
		expr: int
		) -> int:
	return _BNGetLowLevelILSSAExprIndex(func, expr)


# -------------------------------------------------------
# _BNGetLowLevelILSSAFlagDefinition

_BNGetLowLevelILSSAFlagDefinition = core.BNGetLowLevelILSSAFlagDefinition
_BNGetLowLevelILSSAFlagDefinition.restype = ctypes.c_ulonglong
_BNGetLowLevelILSSAFlagDefinition.argtypes = [
		ctypes.POINTER(BNLowLevelILFunction),
		ctypes.c_uint,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetLowLevelILSSAFlagDefinition(
		func: ctypes.POINTER(BNLowLevelILFunction), 
		reg: int, 
		version: int
		) -> int:
	return _BNGetLowLevelILSSAFlagDefinition(func, reg, version)


# -------------------------------------------------------
# _BNGetLowLevelILSSAFlagUses

_BNGetLowLevelILSSAFlagUses = core.BNGetLowLevelILSSAFlagUses
_BNGetLowLevelILSSAFlagUses.restype = ctypes.POINTER(ctypes.c_ulonglong)
_BNGetLowLevelILSSAFlagUses.argtypes = [
		ctypes.POINTER(BNLowLevelILFunction),
		ctypes.c_uint,
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetLowLevelILSSAFlagUses(
		func: ctypes.POINTER(BNLowLevelILFunction), 
		reg: int, 
		version: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_ulonglong)]:
	result = _BNGetLowLevelILSSAFlagUses(func, reg, version, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetLowLevelILSSAFlagValue

_BNGetLowLevelILSSAFlagValue = core.BNGetLowLevelILSSAFlagValue
_BNGetLowLevelILSSAFlagValue.restype = BNRegisterValue
_BNGetLowLevelILSSAFlagValue.argtypes = [
		ctypes.POINTER(BNLowLevelILFunction),
		ctypes.c_uint,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetLowLevelILSSAFlagValue(
		func: ctypes.POINTER(BNLowLevelILFunction), 
		flag: int, 
		version: int
		) -> BNRegisterValue:
	return _BNGetLowLevelILSSAFlagValue(func, flag, version)


# -------------------------------------------------------
# _BNGetLowLevelILSSAForm

_BNGetLowLevelILSSAForm = core.BNGetLowLevelILSSAForm
_BNGetLowLevelILSSAForm.restype = ctypes.POINTER(BNLowLevelILFunction)
_BNGetLowLevelILSSAForm.argtypes = [
		ctypes.POINTER(BNLowLevelILFunction),
	]


# noinspection PyPep8Naming
def BNGetLowLevelILSSAForm(
		func: ctypes.POINTER(BNLowLevelILFunction)
		) -> Optional[ctypes.POINTER(BNLowLevelILFunction)]:
	result = _BNGetLowLevelILSSAForm(func)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetLowLevelILSSAInstructionIndex

_BNGetLowLevelILSSAInstructionIndex = core.BNGetLowLevelILSSAInstructionIndex
_BNGetLowLevelILSSAInstructionIndex.restype = ctypes.c_ulonglong
_BNGetLowLevelILSSAInstructionIndex.argtypes = [
		ctypes.POINTER(BNLowLevelILFunction),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetLowLevelILSSAInstructionIndex(
		func: ctypes.POINTER(BNLowLevelILFunction), 
		instr: int
		) -> int:
	return _BNGetLowLevelILSSAInstructionIndex(func, instr)


# -------------------------------------------------------
# _BNGetLowLevelILSSAMemoryDefinition

_BNGetLowLevelILSSAMemoryDefinition = core.BNGetLowLevelILSSAMemoryDefinition
_BNGetLowLevelILSSAMemoryDefinition.restype = ctypes.c_ulonglong
_BNGetLowLevelILSSAMemoryDefinition.argtypes = [
		ctypes.POINTER(BNLowLevelILFunction),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetLowLevelILSSAMemoryDefinition(
		func: ctypes.POINTER(BNLowLevelILFunction), 
		version: int
		) -> int:
	return _BNGetLowLevelILSSAMemoryDefinition(func, version)


# -------------------------------------------------------
# _BNGetLowLevelILSSAMemoryUses

_BNGetLowLevelILSSAMemoryUses = core.BNGetLowLevelILSSAMemoryUses
_BNGetLowLevelILSSAMemoryUses.restype = ctypes.POINTER(ctypes.c_ulonglong)
_BNGetLowLevelILSSAMemoryUses.argtypes = [
		ctypes.POINTER(BNLowLevelILFunction),
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetLowLevelILSSAMemoryUses(
		func: ctypes.POINTER(BNLowLevelILFunction), 
		version: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_ulonglong)]:
	result = _BNGetLowLevelILSSAMemoryUses(func, version, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetLowLevelILSSARegisterDefinition

_BNGetLowLevelILSSARegisterDefinition = core.BNGetLowLevelILSSARegisterDefinition
_BNGetLowLevelILSSARegisterDefinition.restype = ctypes.c_ulonglong
_BNGetLowLevelILSSARegisterDefinition.argtypes = [
		ctypes.POINTER(BNLowLevelILFunction),
		ctypes.c_uint,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetLowLevelILSSARegisterDefinition(
		func: ctypes.POINTER(BNLowLevelILFunction), 
		reg: int, 
		version: int
		) -> int:
	return _BNGetLowLevelILSSARegisterDefinition(func, reg, version)


# -------------------------------------------------------
# _BNGetLowLevelILSSARegisterUses

_BNGetLowLevelILSSARegisterUses = core.BNGetLowLevelILSSARegisterUses
_BNGetLowLevelILSSARegisterUses.restype = ctypes.POINTER(ctypes.c_ulonglong)
_BNGetLowLevelILSSARegisterUses.argtypes = [
		ctypes.POINTER(BNLowLevelILFunction),
		ctypes.c_uint,
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetLowLevelILSSARegisterUses(
		func: ctypes.POINTER(BNLowLevelILFunction), 
		reg: int, 
		version: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_ulonglong)]:
	result = _BNGetLowLevelILSSARegisterUses(func, reg, version, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetLowLevelILSSARegisterValue

_BNGetLowLevelILSSARegisterValue = core.BNGetLowLevelILSSARegisterValue
_BNGetLowLevelILSSARegisterValue.restype = BNRegisterValue
_BNGetLowLevelILSSARegisterValue.argtypes = [
		ctypes.POINTER(BNLowLevelILFunction),
		ctypes.c_uint,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetLowLevelILSSARegisterValue(
		func: ctypes.POINTER(BNLowLevelILFunction), 
		reg: int, 
		version: int
		) -> BNRegisterValue:
	return _BNGetLowLevelILSSARegisterValue(func, reg, version)


# -------------------------------------------------------
# _BNGetLowLevelILStackContentsAfterInstruction

_BNGetLowLevelILStackContentsAfterInstruction = core.BNGetLowLevelILStackContentsAfterInstruction
_BNGetLowLevelILStackContentsAfterInstruction.restype = BNRegisterValue
_BNGetLowLevelILStackContentsAfterInstruction.argtypes = [
		ctypes.POINTER(BNLowLevelILFunction),
		ctypes.c_longlong,
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetLowLevelILStackContentsAfterInstruction(
		func: ctypes.POINTER(BNLowLevelILFunction), 
		offset: int, 
		len: int, 
		instr: int
		) -> BNRegisterValue:
	return _BNGetLowLevelILStackContentsAfterInstruction(func, offset, len, instr)


# -------------------------------------------------------
# _BNGetLowLevelILStackContentsAtInstruction

_BNGetLowLevelILStackContentsAtInstruction = core.BNGetLowLevelILStackContentsAtInstruction
_BNGetLowLevelILStackContentsAtInstruction.restype = BNRegisterValue
_BNGetLowLevelILStackContentsAtInstruction.argtypes = [
		ctypes.POINTER(BNLowLevelILFunction),
		ctypes.c_longlong,
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetLowLevelILStackContentsAtInstruction(
		func: ctypes.POINTER(BNLowLevelILFunction), 
		offset: int, 
		len: int, 
		instr: int
		) -> BNRegisterValue:
	return _BNGetLowLevelILStackContentsAtInstruction(func, offset, len, instr)


# -------------------------------------------------------
# _BNGetLowLevelILTemporaryFlagCount

_BNGetLowLevelILTemporaryFlagCount = core.BNGetLowLevelILTemporaryFlagCount
_BNGetLowLevelILTemporaryFlagCount.restype = ctypes.c_uint
_BNGetLowLevelILTemporaryFlagCount.argtypes = [
		ctypes.POINTER(BNLowLevelILFunction),
	]


# noinspection PyPep8Naming
def BNGetLowLevelILTemporaryFlagCount(
		func: ctypes.POINTER(BNLowLevelILFunction)
		) -> int:
	return _BNGetLowLevelILTemporaryFlagCount(func)


# -------------------------------------------------------
# _BNGetLowLevelILTemporaryRegisterCount

_BNGetLowLevelILTemporaryRegisterCount = core.BNGetLowLevelILTemporaryRegisterCount
_BNGetLowLevelILTemporaryRegisterCount.restype = ctypes.c_uint
_BNGetLowLevelILTemporaryRegisterCount.argtypes = [
		ctypes.POINTER(BNLowLevelILFunction),
	]


# noinspection PyPep8Naming
def BNGetLowLevelILTemporaryRegisterCount(
		func: ctypes.POINTER(BNLowLevelILFunction)
		) -> int:
	return _BNGetLowLevelILTemporaryRegisterCount(func)


# -------------------------------------------------------
# _BNGetLowLevelMemoryVersions

_BNGetLowLevelMemoryVersions = core.BNGetLowLevelMemoryVersions
_BNGetLowLevelMemoryVersions.restype = ctypes.POINTER(ctypes.c_ulonglong)
_BNGetLowLevelMemoryVersions.argtypes = [
		ctypes.POINTER(BNLowLevelILFunction),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetLowLevelMemoryVersions(
		func: ctypes.POINTER(BNLowLevelILFunction), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_ulonglong)]:
	result = _BNGetLowLevelMemoryVersions(func, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetLowLevelRegisterSSAVersions

_BNGetLowLevelRegisterSSAVersions = core.BNGetLowLevelRegisterSSAVersions
_BNGetLowLevelRegisterSSAVersions.restype = ctypes.POINTER(ctypes.c_ulonglong)
_BNGetLowLevelRegisterSSAVersions.argtypes = [
		ctypes.POINTER(BNLowLevelILFunction),
		ctypes.c_uint,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetLowLevelRegisterSSAVersions(
		func: ctypes.POINTER(BNLowLevelILFunction), 
		var: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_ulonglong)]:
	result = _BNGetLowLevelRegisterSSAVersions(func, var, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetLowLevelRegisterStackSSAVersions

_BNGetLowLevelRegisterStackSSAVersions = core.BNGetLowLevelRegisterStackSSAVersions
_BNGetLowLevelRegisterStackSSAVersions.restype = ctypes.POINTER(ctypes.c_ulonglong)
_BNGetLowLevelRegisterStackSSAVersions.argtypes = [
		ctypes.POINTER(BNLowLevelILFunction),
		ctypes.c_uint,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetLowLevelRegisterStackSSAVersions(
		func: ctypes.POINTER(BNLowLevelILFunction), 
		var: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_ulonglong)]:
	result = _BNGetLowLevelRegisterStackSSAVersions(func, var, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetLowLevelRegisterStacks

_BNGetLowLevelRegisterStacks = core.BNGetLowLevelRegisterStacks
_BNGetLowLevelRegisterStacks.restype = ctypes.POINTER(ctypes.c_uint)
_BNGetLowLevelRegisterStacks.argtypes = [
		ctypes.POINTER(BNLowLevelILFunction),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetLowLevelRegisterStacks(
		func: ctypes.POINTER(BNLowLevelILFunction), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_uint)]:
	result = _BNGetLowLevelRegisterStacks(func, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetLowLevelRegisters

_BNGetLowLevelRegisters = core.BNGetLowLevelRegisters
_BNGetLowLevelRegisters.restype = ctypes.POINTER(ctypes.c_uint)
_BNGetLowLevelRegisters.argtypes = [
		ctypes.POINTER(BNLowLevelILFunction),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetLowLevelRegisters(
		func: ctypes.POINTER(BNLowLevelILFunction), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_uint)]:
	result = _BNGetLowLevelRegisters(func, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetLowLevelSSAFlagsWithoutVersions

_BNGetLowLevelSSAFlagsWithoutVersions = core.BNGetLowLevelSSAFlagsWithoutVersions
_BNGetLowLevelSSAFlagsWithoutVersions.restype = ctypes.POINTER(ctypes.c_uint)
_BNGetLowLevelSSAFlagsWithoutVersions.argtypes = [
		ctypes.POINTER(BNLowLevelILFunction),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetLowLevelSSAFlagsWithoutVersions(
		func: ctypes.POINTER(BNLowLevelILFunction), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_uint)]:
	result = _BNGetLowLevelSSAFlagsWithoutVersions(func, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetLowLevelSSARegisterStacksWithoutVersions

_BNGetLowLevelSSARegisterStacksWithoutVersions = core.BNGetLowLevelSSARegisterStacksWithoutVersions
_BNGetLowLevelSSARegisterStacksWithoutVersions.restype = ctypes.POINTER(ctypes.c_uint)
_BNGetLowLevelSSARegisterStacksWithoutVersions.argtypes = [
		ctypes.POINTER(BNLowLevelILFunction),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetLowLevelSSARegisterStacksWithoutVersions(
		func: ctypes.POINTER(BNLowLevelILFunction), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_uint)]:
	result = _BNGetLowLevelSSARegisterStacksWithoutVersions(func, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetLowLevelSSARegistersWithoutVersions

_BNGetLowLevelSSARegistersWithoutVersions = core.BNGetLowLevelSSARegistersWithoutVersions
_BNGetLowLevelSSARegistersWithoutVersions.restype = ctypes.POINTER(ctypes.c_uint)
_BNGetLowLevelSSARegistersWithoutVersions.argtypes = [
		ctypes.POINTER(BNLowLevelILFunction),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetLowLevelSSARegistersWithoutVersions(
		func: ctypes.POINTER(BNLowLevelILFunction), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_uint)]:
	result = _BNGetLowLevelSSARegistersWithoutVersions(func, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetMappedMediumLevelIL

_BNGetMappedMediumLevelIL = core.BNGetMappedMediumLevelIL
_BNGetMappedMediumLevelIL.restype = ctypes.POINTER(BNMediumLevelILFunction)
_BNGetMappedMediumLevelIL.argtypes = [
		ctypes.POINTER(BNLowLevelILFunction),
	]


# noinspection PyPep8Naming
def BNGetMappedMediumLevelIL(
		func: ctypes.POINTER(BNLowLevelILFunction)
		) -> Optional[ctypes.POINTER(BNMediumLevelILFunction)]:
	result = _BNGetMappedMediumLevelIL(func)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetMappedMediumLevelILExprIndex

_BNGetMappedMediumLevelILExprIndex = core.BNGetMappedMediumLevelILExprIndex
_BNGetMappedMediumLevelILExprIndex.restype = ctypes.c_ulonglong
_BNGetMappedMediumLevelILExprIndex.argtypes = [
		ctypes.POINTER(BNLowLevelILFunction),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetMappedMediumLevelILExprIndex(
		func: ctypes.POINTER(BNLowLevelILFunction), 
		expr: int
		) -> int:
	return _BNGetMappedMediumLevelILExprIndex(func, expr)


# -------------------------------------------------------
# _BNGetMappedMediumLevelILInstructionIndex

_BNGetMappedMediumLevelILInstructionIndex = core.BNGetMappedMediumLevelILInstructionIndex
_BNGetMappedMediumLevelILInstructionIndex.restype = ctypes.c_ulonglong
_BNGetMappedMediumLevelILInstructionIndex.argtypes = [
		ctypes.POINTER(BNLowLevelILFunction),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetMappedMediumLevelILInstructionIndex(
		func: ctypes.POINTER(BNLowLevelILFunction), 
		instr: int
		) -> int:
	return _BNGetMappedMediumLevelILInstructionIndex(func, instr)


# -------------------------------------------------------
# _BNGetMaxFunctionSizeForAnalysis

_BNGetMaxFunctionSizeForAnalysis = core.BNGetMaxFunctionSizeForAnalysis
_BNGetMaxFunctionSizeForAnalysis.restype = ctypes.c_ulonglong
_BNGetMaxFunctionSizeForAnalysis.argtypes = [
		ctypes.POINTER(BNBinaryView),
	]


# noinspection PyPep8Naming
def BNGetMaxFunctionSizeForAnalysis(
		view: ctypes.POINTER(BNBinaryView)
		) -> int:
	return _BNGetMaxFunctionSizeForAnalysis(view)


# -------------------------------------------------------
# _BNGetMediumLevelILAliasedVariables

_BNGetMediumLevelILAliasedVariables = core.BNGetMediumLevelILAliasedVariables
_BNGetMediumLevelILAliasedVariables.restype = ctypes.POINTER(BNVariable)
_BNGetMediumLevelILAliasedVariables.argtypes = [
		ctypes.POINTER(BNMediumLevelILFunction),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetMediumLevelILAliasedVariables(
		func: ctypes.POINTER(BNMediumLevelILFunction), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNVariable)]:
	result = _BNGetMediumLevelILAliasedVariables(func, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetMediumLevelILBasicBlockForInstruction

_BNGetMediumLevelILBasicBlockForInstruction = core.BNGetMediumLevelILBasicBlockForInstruction
_BNGetMediumLevelILBasicBlockForInstruction.restype = ctypes.POINTER(BNBasicBlock)
_BNGetMediumLevelILBasicBlockForInstruction.argtypes = [
		ctypes.POINTER(BNMediumLevelILFunction),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetMediumLevelILBasicBlockForInstruction(
		func: ctypes.POINTER(BNMediumLevelILFunction), 
		i: int
		) -> Optional[ctypes.POINTER(BNBasicBlock)]:
	result = _BNGetMediumLevelILBasicBlockForInstruction(func, i)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetMediumLevelILBasicBlockList

_BNGetMediumLevelILBasicBlockList = core.BNGetMediumLevelILBasicBlockList
_BNGetMediumLevelILBasicBlockList.restype = ctypes.POINTER(ctypes.POINTER(BNBasicBlock))
_BNGetMediumLevelILBasicBlockList.argtypes = [
		ctypes.POINTER(BNMediumLevelILFunction),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetMediumLevelILBasicBlockList(
		func: ctypes.POINTER(BNMediumLevelILFunction), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.POINTER(BNBasicBlock))]:
	result = _BNGetMediumLevelILBasicBlockList(func, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetMediumLevelILBranchDependence

_BNGetMediumLevelILBranchDependence = core.BNGetMediumLevelILBranchDependence
_BNGetMediumLevelILBranchDependence.restype = ILBranchDependenceEnum
_BNGetMediumLevelILBranchDependence.argtypes = [
		ctypes.POINTER(BNMediumLevelILFunction),
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetMediumLevelILBranchDependence(
		func: ctypes.POINTER(BNMediumLevelILFunction), 
		curInstr: int, 
		branchInstr: int
		) -> ILBranchDependence:
	return _BNGetMediumLevelILBranchDependence(func, curInstr, branchInstr)


# -------------------------------------------------------
# _BNGetMediumLevelILByIndex

_BNGetMediumLevelILByIndex = core.BNGetMediumLevelILByIndex
_BNGetMediumLevelILByIndex.restype = BNMediumLevelILInstruction
_BNGetMediumLevelILByIndex.argtypes = [
		ctypes.POINTER(BNMediumLevelILFunction),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetMediumLevelILByIndex(
		func: ctypes.POINTER(BNMediumLevelILFunction), 
		i: int
		) -> BNMediumLevelILInstruction:
	return _BNGetMediumLevelILByIndex(func, i)


# -------------------------------------------------------
# _BNGetMediumLevelILExprCount

_BNGetMediumLevelILExprCount = core.BNGetMediumLevelILExprCount
_BNGetMediumLevelILExprCount.restype = ctypes.c_ulonglong
_BNGetMediumLevelILExprCount.argtypes = [
		ctypes.POINTER(BNMediumLevelILFunction),
	]


# noinspection PyPep8Naming
def BNGetMediumLevelILExprCount(
		func: ctypes.POINTER(BNMediumLevelILFunction)
		) -> int:
	return _BNGetMediumLevelILExprCount(func)


# -------------------------------------------------------
# _BNGetMediumLevelILExprIndex

_BNGetMediumLevelILExprIndex = core.BNGetMediumLevelILExprIndex
_BNGetMediumLevelILExprIndex.restype = ctypes.c_ulonglong
_BNGetMediumLevelILExprIndex.argtypes = [
		ctypes.POINTER(BNLowLevelILFunction),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetMediumLevelILExprIndex(
		func: ctypes.POINTER(BNLowLevelILFunction), 
		expr: int
		) -> int:
	return _BNGetMediumLevelILExprIndex(func, expr)


# -------------------------------------------------------
# _BNGetMediumLevelILExprIndexFromHighLevelIL

_BNGetMediumLevelILExprIndexFromHighLevelIL = core.BNGetMediumLevelILExprIndexFromHighLevelIL
_BNGetMediumLevelILExprIndexFromHighLevelIL.restype = ctypes.c_ulonglong
_BNGetMediumLevelILExprIndexFromHighLevelIL.argtypes = [
		ctypes.POINTER(BNHighLevelILFunction),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetMediumLevelILExprIndexFromHighLevelIL(
		func: ctypes.POINTER(BNHighLevelILFunction), 
		expr: int
		) -> int:
	return _BNGetMediumLevelILExprIndexFromHighLevelIL(func, expr)


# -------------------------------------------------------
# _BNGetMediumLevelILExprIndexes

_BNGetMediumLevelILExprIndexes = core.BNGetMediumLevelILExprIndexes
_BNGetMediumLevelILExprIndexes.restype = ctypes.POINTER(ctypes.c_ulonglong)
_BNGetMediumLevelILExprIndexes.argtypes = [
		ctypes.POINTER(BNLowLevelILFunction),
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetMediumLevelILExprIndexes(
		func: ctypes.POINTER(BNLowLevelILFunction), 
		expr: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_ulonglong)]:
	result = _BNGetMediumLevelILExprIndexes(func, expr, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetMediumLevelILExprIndexesFromHighLevelIL

_BNGetMediumLevelILExprIndexesFromHighLevelIL = core.BNGetMediumLevelILExprIndexesFromHighLevelIL
_BNGetMediumLevelILExprIndexesFromHighLevelIL.restype = ctypes.POINTER(ctypes.c_ulonglong)
_BNGetMediumLevelILExprIndexesFromHighLevelIL.argtypes = [
		ctypes.POINTER(BNHighLevelILFunction),
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetMediumLevelILExprIndexesFromHighLevelIL(
		func: ctypes.POINTER(BNHighLevelILFunction), 
		expr: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_ulonglong)]:
	result = _BNGetMediumLevelILExprIndexesFromHighLevelIL(func, expr, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetMediumLevelILExprText

_BNGetMediumLevelILExprText = core.BNGetMediumLevelILExprText
_BNGetMediumLevelILExprText.restype = ctypes.c_bool
_BNGetMediumLevelILExprText.argtypes = [
		ctypes.POINTER(BNMediumLevelILFunction),
		ctypes.POINTER(BNArchitecture),
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.POINTER(BNInstructionTextToken)),
		ctypes.POINTER(ctypes.c_ulonglong),
		ctypes.POINTER(BNDisassemblySettings),
	]


# noinspection PyPep8Naming
def BNGetMediumLevelILExprText(
		func: ctypes.POINTER(BNMediumLevelILFunction), 
		arch: ctypes.POINTER(BNArchitecture), 
		i: int, 
		tokens: ctypes.POINTER(ctypes.POINTER(BNInstructionTextToken)), 
		count: ctypes.POINTER(ctypes.c_ulonglong), 
		settings: ctypes.POINTER(BNDisassemblySettings)
		) -> bool:
	return _BNGetMediumLevelILExprText(func, arch, i, tokens, count, settings)


# -------------------------------------------------------
# _BNGetMediumLevelILExprType

_BNGetMediumLevelILExprType = core.BNGetMediumLevelILExprType
_BNGetMediumLevelILExprType.restype = BNTypeWithConfidence
_BNGetMediumLevelILExprType.argtypes = [
		ctypes.POINTER(BNMediumLevelILFunction),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetMediumLevelILExprType(
		func: ctypes.POINTER(BNMediumLevelILFunction), 
		expr: int
		) -> BNTypeWithConfidence:
	return _BNGetMediumLevelILExprType(func, expr)


# -------------------------------------------------------
# _BNGetMediumLevelILExprValue

_BNGetMediumLevelILExprValue = core.BNGetMediumLevelILExprValue
_BNGetMediumLevelILExprValue.restype = BNRegisterValue
_BNGetMediumLevelILExprValue.argtypes = [
		ctypes.POINTER(BNMediumLevelILFunction),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetMediumLevelILExprValue(
		func: ctypes.POINTER(BNMediumLevelILFunction), 
		expr: int
		) -> BNRegisterValue:
	return _BNGetMediumLevelILExprValue(func, expr)


# -------------------------------------------------------
# _BNGetMediumLevelILFlagValueAfterInstruction

_BNGetMediumLevelILFlagValueAfterInstruction = core.BNGetMediumLevelILFlagValueAfterInstruction
_BNGetMediumLevelILFlagValueAfterInstruction.restype = BNRegisterValue
_BNGetMediumLevelILFlagValueAfterInstruction.argtypes = [
		ctypes.POINTER(BNMediumLevelILFunction),
		ctypes.c_uint,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetMediumLevelILFlagValueAfterInstruction(
		func: ctypes.POINTER(BNMediumLevelILFunction), 
		flag: int, 
		instr: int
		) -> BNRegisterValue:
	return _BNGetMediumLevelILFlagValueAfterInstruction(func, flag, instr)


# -------------------------------------------------------
# _BNGetMediumLevelILFlagValueAtInstruction

_BNGetMediumLevelILFlagValueAtInstruction = core.BNGetMediumLevelILFlagValueAtInstruction
_BNGetMediumLevelILFlagValueAtInstruction.restype = BNRegisterValue
_BNGetMediumLevelILFlagValueAtInstruction.argtypes = [
		ctypes.POINTER(BNMediumLevelILFunction),
		ctypes.c_uint,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetMediumLevelILFlagValueAtInstruction(
		func: ctypes.POINTER(BNMediumLevelILFunction), 
		flag: int, 
		instr: int
		) -> BNRegisterValue:
	return _BNGetMediumLevelILFlagValueAtInstruction(func, flag, instr)


# -------------------------------------------------------
# _BNGetMediumLevelILForHighLevelILFunction

_BNGetMediumLevelILForHighLevelILFunction = core.BNGetMediumLevelILForHighLevelILFunction
_BNGetMediumLevelILForHighLevelILFunction.restype = ctypes.POINTER(BNMediumLevelILFunction)
_BNGetMediumLevelILForHighLevelILFunction.argtypes = [
		ctypes.POINTER(BNHighLevelILFunction),
	]


# noinspection PyPep8Naming
def BNGetMediumLevelILForHighLevelILFunction(
		func: ctypes.POINTER(BNHighLevelILFunction)
		) -> Optional[ctypes.POINTER(BNMediumLevelILFunction)]:
	result = _BNGetMediumLevelILForHighLevelILFunction(func)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetMediumLevelILForLowLevelIL

_BNGetMediumLevelILForLowLevelIL = core.BNGetMediumLevelILForLowLevelIL
_BNGetMediumLevelILForLowLevelIL.restype = ctypes.POINTER(BNMediumLevelILFunction)
_BNGetMediumLevelILForLowLevelIL.argtypes = [
		ctypes.POINTER(BNLowLevelILFunction),
	]


# noinspection PyPep8Naming
def BNGetMediumLevelILForLowLevelIL(
		func: ctypes.POINTER(BNLowLevelILFunction)
		) -> Optional[ctypes.POINTER(BNMediumLevelILFunction)]:
	result = _BNGetMediumLevelILForLowLevelIL(func)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetMediumLevelILIndexForInstruction

_BNGetMediumLevelILIndexForInstruction = core.BNGetMediumLevelILIndexForInstruction
_BNGetMediumLevelILIndexForInstruction.restype = ctypes.c_ulonglong
_BNGetMediumLevelILIndexForInstruction.argtypes = [
		ctypes.POINTER(BNMediumLevelILFunction),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetMediumLevelILIndexForInstruction(
		func: ctypes.POINTER(BNMediumLevelILFunction), 
		i: int
		) -> int:
	return _BNGetMediumLevelILIndexForInstruction(func, i)


# -------------------------------------------------------
# _BNGetMediumLevelILInstructionCount

_BNGetMediumLevelILInstructionCount = core.BNGetMediumLevelILInstructionCount
_BNGetMediumLevelILInstructionCount.restype = ctypes.c_ulonglong
_BNGetMediumLevelILInstructionCount.argtypes = [
		ctypes.POINTER(BNMediumLevelILFunction),
	]


# noinspection PyPep8Naming
def BNGetMediumLevelILInstructionCount(
		func: ctypes.POINTER(BNMediumLevelILFunction)
		) -> int:
	return _BNGetMediumLevelILInstructionCount(func)


# -------------------------------------------------------
# _BNGetMediumLevelILInstructionForExpr

_BNGetMediumLevelILInstructionForExpr = core.BNGetMediumLevelILInstructionForExpr
_BNGetMediumLevelILInstructionForExpr.restype = ctypes.c_ulonglong
_BNGetMediumLevelILInstructionForExpr.argtypes = [
		ctypes.POINTER(BNMediumLevelILFunction),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetMediumLevelILInstructionForExpr(
		func: ctypes.POINTER(BNMediumLevelILFunction), 
		expr: int
		) -> int:
	return _BNGetMediumLevelILInstructionForExpr(func, expr)


# -------------------------------------------------------
# _BNGetMediumLevelILInstructionIndex

_BNGetMediumLevelILInstructionIndex = core.BNGetMediumLevelILInstructionIndex
_BNGetMediumLevelILInstructionIndex.restype = ctypes.c_ulonglong
_BNGetMediumLevelILInstructionIndex.argtypes = [
		ctypes.POINTER(BNLowLevelILFunction),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetMediumLevelILInstructionIndex(
		func: ctypes.POINTER(BNLowLevelILFunction), 
		instr: int
		) -> int:
	return _BNGetMediumLevelILInstructionIndex(func, instr)


# -------------------------------------------------------
# _BNGetMediumLevelILInstructionText

_BNGetMediumLevelILInstructionText = core.BNGetMediumLevelILInstructionText
_BNGetMediumLevelILInstructionText.restype = ctypes.c_bool
_BNGetMediumLevelILInstructionText.argtypes = [
		ctypes.POINTER(BNMediumLevelILFunction),
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNArchitecture),
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.POINTER(BNInstructionTextToken)),
		ctypes.POINTER(ctypes.c_ulonglong),
		ctypes.POINTER(BNDisassemblySettings),
	]


# noinspection PyPep8Naming
def BNGetMediumLevelILInstructionText(
		il: ctypes.POINTER(BNMediumLevelILFunction), 
		func: ctypes.POINTER(BNFunction), 
		arch: ctypes.POINTER(BNArchitecture), 
		i: int, 
		tokens: ctypes.POINTER(ctypes.POINTER(BNInstructionTextToken)), 
		count: ctypes.POINTER(ctypes.c_ulonglong), 
		settings: ctypes.POINTER(BNDisassemblySettings)
		) -> bool:
	return _BNGetMediumLevelILInstructionText(il, func, arch, i, tokens, count, settings)


# -------------------------------------------------------
# _BNGetMediumLevelILLiveInstructionsForVariable

_BNGetMediumLevelILLiveInstructionsForVariable = core.BNGetMediumLevelILLiveInstructionsForVariable
_BNGetMediumLevelILLiveInstructionsForVariable.restype = ctypes.POINTER(ctypes.c_ulonglong)
_BNGetMediumLevelILLiveInstructionsForVariable.argtypes = [
		ctypes.POINTER(BNMediumLevelILFunction),
		ctypes.POINTER(BNVariable),
		ctypes.c_bool,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetMediumLevelILLiveInstructionsForVariable(
		func: ctypes.POINTER(BNMediumLevelILFunction), 
		var: ctypes.POINTER(BNVariable), 
		includeLastUse: bool, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_ulonglong)]:
	result = _BNGetMediumLevelILLiveInstructionsForVariable(func, var, includeLastUse, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetMediumLevelILNonSSAExprIndex

_BNGetMediumLevelILNonSSAExprIndex = core.BNGetMediumLevelILNonSSAExprIndex
_BNGetMediumLevelILNonSSAExprIndex.restype = ctypes.c_ulonglong
_BNGetMediumLevelILNonSSAExprIndex.argtypes = [
		ctypes.POINTER(BNMediumLevelILFunction),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetMediumLevelILNonSSAExprIndex(
		func: ctypes.POINTER(BNMediumLevelILFunction), 
		expr: int
		) -> int:
	return _BNGetMediumLevelILNonSSAExprIndex(func, expr)


# -------------------------------------------------------
# _BNGetMediumLevelILNonSSAForm

_BNGetMediumLevelILNonSSAForm = core.BNGetMediumLevelILNonSSAForm
_BNGetMediumLevelILNonSSAForm.restype = ctypes.POINTER(BNMediumLevelILFunction)
_BNGetMediumLevelILNonSSAForm.argtypes = [
		ctypes.POINTER(BNMediumLevelILFunction),
	]


# noinspection PyPep8Naming
def BNGetMediumLevelILNonSSAForm(
		func: ctypes.POINTER(BNMediumLevelILFunction)
		) -> Optional[ctypes.POINTER(BNMediumLevelILFunction)]:
	result = _BNGetMediumLevelILNonSSAForm(func)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetMediumLevelILNonSSAInstructionIndex

_BNGetMediumLevelILNonSSAInstructionIndex = core.BNGetMediumLevelILNonSSAInstructionIndex
_BNGetMediumLevelILNonSSAInstructionIndex.restype = ctypes.c_ulonglong
_BNGetMediumLevelILNonSSAInstructionIndex.argtypes = [
		ctypes.POINTER(BNMediumLevelILFunction),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetMediumLevelILNonSSAInstructionIndex(
		func: ctypes.POINTER(BNMediumLevelILFunction), 
		instr: int
		) -> int:
	return _BNGetMediumLevelILNonSSAInstructionIndex(func, instr)


# -------------------------------------------------------
# _BNGetMediumLevelILOwnerFunction

_BNGetMediumLevelILOwnerFunction = core.BNGetMediumLevelILOwnerFunction
_BNGetMediumLevelILOwnerFunction.restype = ctypes.POINTER(BNFunction)
_BNGetMediumLevelILOwnerFunction.argtypes = [
		ctypes.POINTER(BNMediumLevelILFunction),
	]


# noinspection PyPep8Naming
def BNGetMediumLevelILOwnerFunction(
		func: ctypes.POINTER(BNMediumLevelILFunction)
		) -> Optional[ctypes.POINTER(BNFunction)]:
	result = _BNGetMediumLevelILOwnerFunction(func)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetMediumLevelILPossibleExprValues

_BNGetMediumLevelILPossibleExprValues = core.BNGetMediumLevelILPossibleExprValues
_BNGetMediumLevelILPossibleExprValues.restype = BNPossibleValueSet
_BNGetMediumLevelILPossibleExprValues.argtypes = [
		ctypes.POINTER(BNMediumLevelILFunction),
		ctypes.c_ulonglong,
		ctypes.POINTER(DataFlowQueryOptionEnum),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetMediumLevelILPossibleExprValues(
		func: ctypes.POINTER(BNMediumLevelILFunction), 
		expr: int, 
		options: ctypes.POINTER(DataFlowQueryOptionEnum), 
		optionCount: int
		) -> BNPossibleValueSet:
	return _BNGetMediumLevelILPossibleExprValues(func, expr, options, optionCount)


# -------------------------------------------------------
# _BNGetMediumLevelILPossibleFlagValuesAfterInstruction

_BNGetMediumLevelILPossibleFlagValuesAfterInstruction = core.BNGetMediumLevelILPossibleFlagValuesAfterInstruction
_BNGetMediumLevelILPossibleFlagValuesAfterInstruction.restype = BNPossibleValueSet
_BNGetMediumLevelILPossibleFlagValuesAfterInstruction.argtypes = [
		ctypes.POINTER(BNMediumLevelILFunction),
		ctypes.c_uint,
		ctypes.c_ulonglong,
		ctypes.POINTER(DataFlowQueryOptionEnum),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetMediumLevelILPossibleFlagValuesAfterInstruction(
		func: ctypes.POINTER(BNMediumLevelILFunction), 
		flag: int, 
		instr: int, 
		options: ctypes.POINTER(DataFlowQueryOptionEnum), 
		optionCount: int
		) -> BNPossibleValueSet:
	return _BNGetMediumLevelILPossibleFlagValuesAfterInstruction(func, flag, instr, options, optionCount)


# -------------------------------------------------------
# _BNGetMediumLevelILPossibleFlagValuesAtInstruction

_BNGetMediumLevelILPossibleFlagValuesAtInstruction = core.BNGetMediumLevelILPossibleFlagValuesAtInstruction
_BNGetMediumLevelILPossibleFlagValuesAtInstruction.restype = BNPossibleValueSet
_BNGetMediumLevelILPossibleFlagValuesAtInstruction.argtypes = [
		ctypes.POINTER(BNMediumLevelILFunction),
		ctypes.c_uint,
		ctypes.c_ulonglong,
		ctypes.POINTER(DataFlowQueryOptionEnum),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetMediumLevelILPossibleFlagValuesAtInstruction(
		func: ctypes.POINTER(BNMediumLevelILFunction), 
		flag: int, 
		instr: int, 
		options: ctypes.POINTER(DataFlowQueryOptionEnum), 
		optionCount: int
		) -> BNPossibleValueSet:
	return _BNGetMediumLevelILPossibleFlagValuesAtInstruction(func, flag, instr, options, optionCount)


# -------------------------------------------------------
# _BNGetMediumLevelILPossibleRegisterValuesAfterInstruction

_BNGetMediumLevelILPossibleRegisterValuesAfterInstruction = core.BNGetMediumLevelILPossibleRegisterValuesAfterInstruction
_BNGetMediumLevelILPossibleRegisterValuesAfterInstruction.restype = BNPossibleValueSet
_BNGetMediumLevelILPossibleRegisterValuesAfterInstruction.argtypes = [
		ctypes.POINTER(BNMediumLevelILFunction),
		ctypes.c_uint,
		ctypes.c_ulonglong,
		ctypes.POINTER(DataFlowQueryOptionEnum),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetMediumLevelILPossibleRegisterValuesAfterInstruction(
		func: ctypes.POINTER(BNMediumLevelILFunction), 
		reg: int, 
		instr: int, 
		options: ctypes.POINTER(DataFlowQueryOptionEnum), 
		optionCount: int
		) -> BNPossibleValueSet:
	return _BNGetMediumLevelILPossibleRegisterValuesAfterInstruction(func, reg, instr, options, optionCount)


# -------------------------------------------------------
# _BNGetMediumLevelILPossibleRegisterValuesAtInstruction

_BNGetMediumLevelILPossibleRegisterValuesAtInstruction = core.BNGetMediumLevelILPossibleRegisterValuesAtInstruction
_BNGetMediumLevelILPossibleRegisterValuesAtInstruction.restype = BNPossibleValueSet
_BNGetMediumLevelILPossibleRegisterValuesAtInstruction.argtypes = [
		ctypes.POINTER(BNMediumLevelILFunction),
		ctypes.c_uint,
		ctypes.c_ulonglong,
		ctypes.POINTER(DataFlowQueryOptionEnum),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetMediumLevelILPossibleRegisterValuesAtInstruction(
		func: ctypes.POINTER(BNMediumLevelILFunction), 
		reg: int, 
		instr: int, 
		options: ctypes.POINTER(DataFlowQueryOptionEnum), 
		optionCount: int
		) -> BNPossibleValueSet:
	return _BNGetMediumLevelILPossibleRegisterValuesAtInstruction(func, reg, instr, options, optionCount)


# -------------------------------------------------------
# _BNGetMediumLevelILPossibleSSAVarValues

_BNGetMediumLevelILPossibleSSAVarValues = core.BNGetMediumLevelILPossibleSSAVarValues
_BNGetMediumLevelILPossibleSSAVarValues.restype = BNPossibleValueSet
_BNGetMediumLevelILPossibleSSAVarValues.argtypes = [
		ctypes.POINTER(BNMediumLevelILFunction),
		ctypes.POINTER(BNVariable),
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
		ctypes.POINTER(DataFlowQueryOptionEnum),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetMediumLevelILPossibleSSAVarValues(
		func: ctypes.POINTER(BNMediumLevelILFunction), 
		var: ctypes.POINTER(BNVariable), 
		version: int, 
		instr: int, 
		options: ctypes.POINTER(DataFlowQueryOptionEnum), 
		optionCount: int
		) -> BNPossibleValueSet:
	return _BNGetMediumLevelILPossibleSSAVarValues(func, var, version, instr, options, optionCount)


# -------------------------------------------------------
# _BNGetMediumLevelILPossibleStackContentsAfterInstruction

_BNGetMediumLevelILPossibleStackContentsAfterInstruction = core.BNGetMediumLevelILPossibleStackContentsAfterInstruction
_BNGetMediumLevelILPossibleStackContentsAfterInstruction.restype = BNPossibleValueSet
_BNGetMediumLevelILPossibleStackContentsAfterInstruction.argtypes = [
		ctypes.POINTER(BNMediumLevelILFunction),
		ctypes.c_longlong,
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
		ctypes.POINTER(DataFlowQueryOptionEnum),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetMediumLevelILPossibleStackContentsAfterInstruction(
		func: ctypes.POINTER(BNMediumLevelILFunction), 
		offset: int, 
		len: int, 
		instr: int, 
		options: ctypes.POINTER(DataFlowQueryOptionEnum), 
		optionCount: int
		) -> BNPossibleValueSet:
	return _BNGetMediumLevelILPossibleStackContentsAfterInstruction(func, offset, len, instr, options, optionCount)


# -------------------------------------------------------
# _BNGetMediumLevelILPossibleStackContentsAtInstruction

_BNGetMediumLevelILPossibleStackContentsAtInstruction = core.BNGetMediumLevelILPossibleStackContentsAtInstruction
_BNGetMediumLevelILPossibleStackContentsAtInstruction.restype = BNPossibleValueSet
_BNGetMediumLevelILPossibleStackContentsAtInstruction.argtypes = [
		ctypes.POINTER(BNMediumLevelILFunction),
		ctypes.c_longlong,
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
		ctypes.POINTER(DataFlowQueryOptionEnum),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetMediumLevelILPossibleStackContentsAtInstruction(
		func: ctypes.POINTER(BNMediumLevelILFunction), 
		offset: int, 
		len: int, 
		instr: int, 
		options: ctypes.POINTER(DataFlowQueryOptionEnum), 
		optionCount: int
		) -> BNPossibleValueSet:
	return _BNGetMediumLevelILPossibleStackContentsAtInstruction(func, offset, len, instr, options, optionCount)


# -------------------------------------------------------
# _BNGetMediumLevelILRegisterValueAfterInstruction

_BNGetMediumLevelILRegisterValueAfterInstruction = core.BNGetMediumLevelILRegisterValueAfterInstruction
_BNGetMediumLevelILRegisterValueAfterInstruction.restype = BNRegisterValue
_BNGetMediumLevelILRegisterValueAfterInstruction.argtypes = [
		ctypes.POINTER(BNMediumLevelILFunction),
		ctypes.c_uint,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetMediumLevelILRegisterValueAfterInstruction(
		func: ctypes.POINTER(BNMediumLevelILFunction), 
		reg: int, 
		instr: int
		) -> BNRegisterValue:
	return _BNGetMediumLevelILRegisterValueAfterInstruction(func, reg, instr)


# -------------------------------------------------------
# _BNGetMediumLevelILRegisterValueAtInstruction

_BNGetMediumLevelILRegisterValueAtInstruction = core.BNGetMediumLevelILRegisterValueAtInstruction
_BNGetMediumLevelILRegisterValueAtInstruction.restype = BNRegisterValue
_BNGetMediumLevelILRegisterValueAtInstruction.argtypes = [
		ctypes.POINTER(BNMediumLevelILFunction),
		ctypes.c_uint,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetMediumLevelILRegisterValueAtInstruction(
		func: ctypes.POINTER(BNMediumLevelILFunction), 
		reg: int, 
		instr: int
		) -> BNRegisterValue:
	return _BNGetMediumLevelILRegisterValueAtInstruction(func, reg, instr)


# -------------------------------------------------------
# _BNGetMediumLevelILSSAExprIndex

_BNGetMediumLevelILSSAExprIndex = core.BNGetMediumLevelILSSAExprIndex
_BNGetMediumLevelILSSAExprIndex.restype = ctypes.c_ulonglong
_BNGetMediumLevelILSSAExprIndex.argtypes = [
		ctypes.POINTER(BNMediumLevelILFunction),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetMediumLevelILSSAExprIndex(
		func: ctypes.POINTER(BNMediumLevelILFunction), 
		expr: int
		) -> int:
	return _BNGetMediumLevelILSSAExprIndex(func, expr)


# -------------------------------------------------------
# _BNGetMediumLevelILSSAForm

_BNGetMediumLevelILSSAForm = core.BNGetMediumLevelILSSAForm
_BNGetMediumLevelILSSAForm.restype = ctypes.POINTER(BNMediumLevelILFunction)
_BNGetMediumLevelILSSAForm.argtypes = [
		ctypes.POINTER(BNMediumLevelILFunction),
	]


# noinspection PyPep8Naming
def BNGetMediumLevelILSSAForm(
		func: ctypes.POINTER(BNMediumLevelILFunction)
		) -> Optional[ctypes.POINTER(BNMediumLevelILFunction)]:
	result = _BNGetMediumLevelILSSAForm(func)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetMediumLevelILSSAInstructionIndex

_BNGetMediumLevelILSSAInstructionIndex = core.BNGetMediumLevelILSSAInstructionIndex
_BNGetMediumLevelILSSAInstructionIndex.restype = ctypes.c_ulonglong
_BNGetMediumLevelILSSAInstructionIndex.argtypes = [
		ctypes.POINTER(BNMediumLevelILFunction),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetMediumLevelILSSAInstructionIndex(
		func: ctypes.POINTER(BNMediumLevelILFunction), 
		instr: int
		) -> int:
	return _BNGetMediumLevelILSSAInstructionIndex(func, instr)


# -------------------------------------------------------
# _BNGetMediumLevelILSSAMemoryDefinition

_BNGetMediumLevelILSSAMemoryDefinition = core.BNGetMediumLevelILSSAMemoryDefinition
_BNGetMediumLevelILSSAMemoryDefinition.restype = ctypes.c_ulonglong
_BNGetMediumLevelILSSAMemoryDefinition.argtypes = [
		ctypes.POINTER(BNMediumLevelILFunction),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetMediumLevelILSSAMemoryDefinition(
		func: ctypes.POINTER(BNMediumLevelILFunction), 
		version: int
		) -> int:
	return _BNGetMediumLevelILSSAMemoryDefinition(func, version)


# -------------------------------------------------------
# _BNGetMediumLevelILSSAMemoryUses

_BNGetMediumLevelILSSAMemoryUses = core.BNGetMediumLevelILSSAMemoryUses
_BNGetMediumLevelILSSAMemoryUses.restype = ctypes.POINTER(ctypes.c_ulonglong)
_BNGetMediumLevelILSSAMemoryUses.argtypes = [
		ctypes.POINTER(BNMediumLevelILFunction),
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetMediumLevelILSSAMemoryUses(
		func: ctypes.POINTER(BNMediumLevelILFunction), 
		version: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_ulonglong)]:
	result = _BNGetMediumLevelILSSAMemoryUses(func, version, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetMediumLevelILSSAMemoryVersionAtILInstruction

_BNGetMediumLevelILSSAMemoryVersionAtILInstruction = core.BNGetMediumLevelILSSAMemoryVersionAtILInstruction
_BNGetMediumLevelILSSAMemoryVersionAtILInstruction.restype = ctypes.c_ulonglong
_BNGetMediumLevelILSSAMemoryVersionAtILInstruction.argtypes = [
		ctypes.POINTER(BNMediumLevelILFunction),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetMediumLevelILSSAMemoryVersionAtILInstruction(
		func: ctypes.POINTER(BNMediumLevelILFunction), 
		instr: int
		) -> int:
	return _BNGetMediumLevelILSSAMemoryVersionAtILInstruction(func, instr)


# -------------------------------------------------------
# _BNGetMediumLevelILSSAVarDefinition

_BNGetMediumLevelILSSAVarDefinition = core.BNGetMediumLevelILSSAVarDefinition
_BNGetMediumLevelILSSAVarDefinition.restype = ctypes.c_ulonglong
_BNGetMediumLevelILSSAVarDefinition.argtypes = [
		ctypes.POINTER(BNMediumLevelILFunction),
		ctypes.POINTER(BNVariable),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetMediumLevelILSSAVarDefinition(
		func: ctypes.POINTER(BNMediumLevelILFunction), 
		var: ctypes.POINTER(BNVariable), 
		version: int
		) -> int:
	return _BNGetMediumLevelILSSAVarDefinition(func, var, version)


# -------------------------------------------------------
# _BNGetMediumLevelILSSAVarUses

_BNGetMediumLevelILSSAVarUses = core.BNGetMediumLevelILSSAVarUses
_BNGetMediumLevelILSSAVarUses.restype = ctypes.POINTER(ctypes.c_ulonglong)
_BNGetMediumLevelILSSAVarUses.argtypes = [
		ctypes.POINTER(BNMediumLevelILFunction),
		ctypes.POINTER(BNVariable),
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetMediumLevelILSSAVarUses(
		func: ctypes.POINTER(BNMediumLevelILFunction), 
		var: ctypes.POINTER(BNVariable), 
		version: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_ulonglong)]:
	result = _BNGetMediumLevelILSSAVarUses(func, var, version, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetMediumLevelILSSAVarValue

_BNGetMediumLevelILSSAVarValue = core.BNGetMediumLevelILSSAVarValue
_BNGetMediumLevelILSSAVarValue.restype = BNRegisterValue
_BNGetMediumLevelILSSAVarValue.argtypes = [
		ctypes.POINTER(BNMediumLevelILFunction),
		ctypes.POINTER(BNVariable),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetMediumLevelILSSAVarValue(
		func: ctypes.POINTER(BNMediumLevelILFunction), 
		var: ctypes.POINTER(BNVariable), 
		version: int
		) -> BNRegisterValue:
	return _BNGetMediumLevelILSSAVarValue(func, var, version)


# -------------------------------------------------------
# _BNGetMediumLevelILSSAVarVersionAtILInstruction

_BNGetMediumLevelILSSAVarVersionAtILInstruction = core.BNGetMediumLevelILSSAVarVersionAtILInstruction
_BNGetMediumLevelILSSAVarVersionAtILInstruction.restype = ctypes.c_ulonglong
_BNGetMediumLevelILSSAVarVersionAtILInstruction.argtypes = [
		ctypes.POINTER(BNMediumLevelILFunction),
		ctypes.POINTER(BNVariable),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetMediumLevelILSSAVarVersionAtILInstruction(
		func: ctypes.POINTER(BNMediumLevelILFunction), 
		var: ctypes.POINTER(BNVariable), 
		instr: int
		) -> int:
	return _BNGetMediumLevelILSSAVarVersionAtILInstruction(func, var, instr)


# -------------------------------------------------------
# _BNGetMediumLevelILStackContentsAfterInstruction

_BNGetMediumLevelILStackContentsAfterInstruction = core.BNGetMediumLevelILStackContentsAfterInstruction
_BNGetMediumLevelILStackContentsAfterInstruction.restype = BNRegisterValue
_BNGetMediumLevelILStackContentsAfterInstruction.argtypes = [
		ctypes.POINTER(BNMediumLevelILFunction),
		ctypes.c_longlong,
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetMediumLevelILStackContentsAfterInstruction(
		func: ctypes.POINTER(BNMediumLevelILFunction), 
		offset: int, 
		len: int, 
		instr: int
		) -> BNRegisterValue:
	return _BNGetMediumLevelILStackContentsAfterInstruction(func, offset, len, instr)


# -------------------------------------------------------
# _BNGetMediumLevelILStackContentsAtInstruction

_BNGetMediumLevelILStackContentsAtInstruction = core.BNGetMediumLevelILStackContentsAtInstruction
_BNGetMediumLevelILStackContentsAtInstruction.restype = BNRegisterValue
_BNGetMediumLevelILStackContentsAtInstruction.argtypes = [
		ctypes.POINTER(BNMediumLevelILFunction),
		ctypes.c_longlong,
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetMediumLevelILStackContentsAtInstruction(
		func: ctypes.POINTER(BNMediumLevelILFunction), 
		offset: int, 
		len: int, 
		instr: int
		) -> BNRegisterValue:
	return _BNGetMediumLevelILStackContentsAtInstruction(func, offset, len, instr)


# -------------------------------------------------------
# _BNGetMediumLevelILVariableDefinitions

_BNGetMediumLevelILVariableDefinitions = core.BNGetMediumLevelILVariableDefinitions
_BNGetMediumLevelILVariableDefinitions.restype = ctypes.POINTER(ctypes.c_ulonglong)
_BNGetMediumLevelILVariableDefinitions.argtypes = [
		ctypes.POINTER(BNMediumLevelILFunction),
		ctypes.POINTER(BNVariable),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetMediumLevelILVariableDefinitions(
		func: ctypes.POINTER(BNMediumLevelILFunction), 
		var: ctypes.POINTER(BNVariable), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_ulonglong)]:
	result = _BNGetMediumLevelILVariableDefinitions(func, var, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetMediumLevelILVariableForFlagAtInstruction

_BNGetMediumLevelILVariableForFlagAtInstruction = core.BNGetMediumLevelILVariableForFlagAtInstruction
_BNGetMediumLevelILVariableForFlagAtInstruction.restype = BNVariable
_BNGetMediumLevelILVariableForFlagAtInstruction.argtypes = [
		ctypes.POINTER(BNMediumLevelILFunction),
		ctypes.c_uint,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetMediumLevelILVariableForFlagAtInstruction(
		func: ctypes.POINTER(BNMediumLevelILFunction), 
		flag: int, 
		instr: int
		) -> BNVariable:
	return _BNGetMediumLevelILVariableForFlagAtInstruction(func, flag, instr)


# -------------------------------------------------------
# _BNGetMediumLevelILVariableForRegisterAtInstruction

_BNGetMediumLevelILVariableForRegisterAtInstruction = core.BNGetMediumLevelILVariableForRegisterAtInstruction
_BNGetMediumLevelILVariableForRegisterAtInstruction.restype = BNVariable
_BNGetMediumLevelILVariableForRegisterAtInstruction.argtypes = [
		ctypes.POINTER(BNMediumLevelILFunction),
		ctypes.c_uint,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetMediumLevelILVariableForRegisterAtInstruction(
		func: ctypes.POINTER(BNMediumLevelILFunction), 
		reg: int, 
		instr: int
		) -> BNVariable:
	return _BNGetMediumLevelILVariableForRegisterAtInstruction(func, reg, instr)


# -------------------------------------------------------
# _BNGetMediumLevelILVariableForStackLocationAtInstruction

_BNGetMediumLevelILVariableForStackLocationAtInstruction = core.BNGetMediumLevelILVariableForStackLocationAtInstruction
_BNGetMediumLevelILVariableForStackLocationAtInstruction.restype = BNVariable
_BNGetMediumLevelILVariableForStackLocationAtInstruction.argtypes = [
		ctypes.POINTER(BNMediumLevelILFunction),
		ctypes.c_longlong,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetMediumLevelILVariableForStackLocationAtInstruction(
		func: ctypes.POINTER(BNMediumLevelILFunction), 
		offset: int, 
		instr: int
		) -> BNVariable:
	return _BNGetMediumLevelILVariableForStackLocationAtInstruction(func, offset, instr)


# -------------------------------------------------------
# _BNGetMediumLevelILVariableReferences

_BNGetMediumLevelILVariableReferences = core.BNGetMediumLevelILVariableReferences
_BNGetMediumLevelILVariableReferences.restype = ctypes.POINTER(BNILReferenceSource)
_BNGetMediumLevelILVariableReferences.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNVariable),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetMediumLevelILVariableReferences(
		func: ctypes.POINTER(BNFunction), 
		var: ctypes.POINTER(BNVariable), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNILReferenceSource)]:
	result = _BNGetMediumLevelILVariableReferences(func, var, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetMediumLevelILVariableReferencesFrom

_BNGetMediumLevelILVariableReferencesFrom = core.BNGetMediumLevelILVariableReferencesFrom
_BNGetMediumLevelILVariableReferencesFrom.restype = ctypes.POINTER(BNVariableReferenceSource)
_BNGetMediumLevelILVariableReferencesFrom.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNArchitecture),
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetMediumLevelILVariableReferencesFrom(
		func: ctypes.POINTER(BNFunction), 
		arch: ctypes.POINTER(BNArchitecture), 
		address: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNVariableReferenceSource)]:
	result = _BNGetMediumLevelILVariableReferencesFrom(func, arch, address, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetMediumLevelILVariableReferencesFromIfAvailable

_BNGetMediumLevelILVariableReferencesFromIfAvailable = core.BNGetMediumLevelILVariableReferencesFromIfAvailable
_BNGetMediumLevelILVariableReferencesFromIfAvailable.restype = ctypes.POINTER(BNVariableReferenceSource)
_BNGetMediumLevelILVariableReferencesFromIfAvailable.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNArchitecture),
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetMediumLevelILVariableReferencesFromIfAvailable(
		func: ctypes.POINTER(BNFunction), 
		arch: ctypes.POINTER(BNArchitecture), 
		address: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNVariableReferenceSource)]:
	result = _BNGetMediumLevelILVariableReferencesFromIfAvailable(func, arch, address, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetMediumLevelILVariableReferencesIfAvailable

_BNGetMediumLevelILVariableReferencesIfAvailable = core.BNGetMediumLevelILVariableReferencesIfAvailable
_BNGetMediumLevelILVariableReferencesIfAvailable.restype = ctypes.POINTER(BNILReferenceSource)
_BNGetMediumLevelILVariableReferencesIfAvailable.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNVariable),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetMediumLevelILVariableReferencesIfAvailable(
		func: ctypes.POINTER(BNFunction), 
		var: ctypes.POINTER(BNVariable), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNILReferenceSource)]:
	result = _BNGetMediumLevelILVariableReferencesIfAvailable(func, var, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetMediumLevelILVariableReferencesInRange

_BNGetMediumLevelILVariableReferencesInRange = core.BNGetMediumLevelILVariableReferencesInRange
_BNGetMediumLevelILVariableReferencesInRange.restype = ctypes.POINTER(BNVariableReferenceSource)
_BNGetMediumLevelILVariableReferencesInRange.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNArchitecture),
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetMediumLevelILVariableReferencesInRange(
		func: ctypes.POINTER(BNFunction), 
		arch: ctypes.POINTER(BNArchitecture), 
		address: int, 
		len: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNVariableReferenceSource)]:
	result = _BNGetMediumLevelILVariableReferencesInRange(func, arch, address, len, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetMediumLevelILVariableReferencesInRangeIfAvailable

_BNGetMediumLevelILVariableReferencesInRangeIfAvailable = core.BNGetMediumLevelILVariableReferencesInRangeIfAvailable
_BNGetMediumLevelILVariableReferencesInRangeIfAvailable.restype = ctypes.POINTER(BNVariableReferenceSource)
_BNGetMediumLevelILVariableReferencesInRangeIfAvailable.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNArchitecture),
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetMediumLevelILVariableReferencesInRangeIfAvailable(
		func: ctypes.POINTER(BNFunction), 
		arch: ctypes.POINTER(BNArchitecture), 
		address: int, 
		len: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNVariableReferenceSource)]:
	result = _BNGetMediumLevelILVariableReferencesInRangeIfAvailable(func, arch, address, len, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetMediumLevelILVariableSSAVersions

_BNGetMediumLevelILVariableSSAVersions = core.BNGetMediumLevelILVariableSSAVersions
_BNGetMediumLevelILVariableSSAVersions.restype = ctypes.POINTER(ctypes.c_ulonglong)
_BNGetMediumLevelILVariableSSAVersions.argtypes = [
		ctypes.POINTER(BNMediumLevelILFunction),
		ctypes.POINTER(BNVariable),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetMediumLevelILVariableSSAVersions(
		func: ctypes.POINTER(BNMediumLevelILFunction), 
		var: ctypes.POINTER(BNVariable), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_ulonglong)]:
	result = _BNGetMediumLevelILVariableSSAVersions(func, var, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetMediumLevelILVariableUses

_BNGetMediumLevelILVariableUses = core.BNGetMediumLevelILVariableUses
_BNGetMediumLevelILVariableUses.restype = ctypes.POINTER(ctypes.c_ulonglong)
_BNGetMediumLevelILVariableUses.argtypes = [
		ctypes.POINTER(BNMediumLevelILFunction),
		ctypes.POINTER(BNVariable),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetMediumLevelILVariableUses(
		func: ctypes.POINTER(BNMediumLevelILFunction), 
		var: ctypes.POINTER(BNVariable), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_ulonglong)]:
	result = _BNGetMediumLevelILVariableUses(func, var, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetMediumLevelILVariables

_BNGetMediumLevelILVariables = core.BNGetMediumLevelILVariables
_BNGetMediumLevelILVariables.restype = ctypes.POINTER(BNVariable)
_BNGetMediumLevelILVariables.argtypes = [
		ctypes.POINTER(BNMediumLevelILFunction),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetMediumLevelILVariables(
		func: ctypes.POINTER(BNMediumLevelILFunction), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNVariable)]:
	result = _BNGetMediumLevelILVariables(func, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetMemberIncludingInheritedAtOffset

_BNGetMemberIncludingInheritedAtOffset = core.BNGetMemberIncludingInheritedAtOffset
_BNGetMemberIncludingInheritedAtOffset.restype = ctypes.POINTER(BNInheritedStructureMember)
_BNGetMemberIncludingInheritedAtOffset.argtypes = [
		ctypes.POINTER(BNStructure),
		ctypes.POINTER(BNBinaryView),
		ctypes.c_longlong,
	]


# noinspection PyPep8Naming
def BNGetMemberIncludingInheritedAtOffset(
		s: ctypes.POINTER(BNStructure), 
		view: ctypes.POINTER(BNBinaryView), 
		offset: int
		) -> Optional[ctypes.POINTER(BNInheritedStructureMember)]:
	result = _BNGetMemberIncludingInheritedAtOffset(s, view, offset)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetMemoryUsageInfo

_BNGetMemoryUsageInfo = core.BNGetMemoryUsageInfo
_BNGetMemoryUsageInfo.restype = ctypes.POINTER(BNMemoryUsageInfo)
_BNGetMemoryUsageInfo.argtypes = [
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetMemoryUsageInfo(
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNMemoryUsageInfo)]:
	result = _BNGetMemoryUsageInfo(count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetMergedVariables

_BNGetMergedVariables = core.BNGetMergedVariables
_BNGetMergedVariables.restype = ctypes.POINTER(BNMergedVariable)
_BNGetMergedVariables.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetMergedVariables(
		func: ctypes.POINTER(BNFunction), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNMergedVariable)]:
	result = _BNGetMergedVariables(func, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetMinimumCoreABIVersion

_BNGetMinimumCoreABIVersion = core.BNGetMinimumCoreABIVersion
_BNGetMinimumCoreABIVersion.restype = ctypes.c_uint
_BNGetMinimumCoreABIVersion.argtypes = [
	]


# noinspection PyPep8Naming
def BNGetMinimumCoreABIVersion(
		) -> int:
	return _BNGetMinimumCoreABIVersion()


# -------------------------------------------------------
# _BNGetModification

_BNGetModification = core.BNGetModification
_BNGetModification.restype = ModificationStatusEnum
_BNGetModification.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetModification(
		view: ctypes.POINTER(BNBinaryView), 
		offset: int
		) -> ModificationStatus:
	return _BNGetModification(view, offset)


# -------------------------------------------------------
# _BNGetModificationArray

_BNGetModificationArray = core.BNGetModificationArray
_BNGetModificationArray.restype = ctypes.c_ulonglong
_BNGetModificationArray.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
		ctypes.POINTER(ModificationStatusEnum),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetModificationArray(
		view: ctypes.POINTER(BNBinaryView), 
		offset: int, 
		result: ctypes.POINTER(ModificationStatusEnum), 
		len: int
		) -> int:
	return _BNGetModificationArray(view, offset, result, len)


# -------------------------------------------------------
# _BNGetModifiedArchitectureRegistersOnWrite

_BNGetModifiedArchitectureRegistersOnWrite = core.BNGetModifiedArchitectureRegistersOnWrite
_BNGetModifiedArchitectureRegistersOnWrite.restype = ctypes.POINTER(ctypes.c_uint)
_BNGetModifiedArchitectureRegistersOnWrite.argtypes = [
		ctypes.POINTER(BNArchitecture),
		ctypes.c_uint,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetModifiedArchitectureRegistersOnWrite(
		arch: ctypes.POINTER(BNArchitecture), 
		reg: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_uint)]:
	result = _BNGetModifiedArchitectureRegistersOnWrite(arch, reg, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetNameSpaces

_BNGetNameSpaces = core.BNGetNameSpaces
_BNGetNameSpaces.restype = ctypes.POINTER(BNNameSpace)
_BNGetNameSpaces.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetNameSpaces(
		view: ctypes.POINTER(BNBinaryView), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNNameSpace)]:
	result = _BNGetNameSpaces(view, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetNativeTypeParserArchitecture

_BNGetNativeTypeParserArchitecture = core.BNGetNativeTypeParserArchitecture
_BNGetNativeTypeParserArchitecture.restype = ctypes.POINTER(BNArchitecture)
_BNGetNativeTypeParserArchitecture.argtypes = [
	]


# noinspection PyPep8Naming
def BNGetNativeTypeParserArchitecture(
		) -> Optional[ctypes.POINTER(BNArchitecture)]:
	result = _BNGetNativeTypeParserArchitecture()
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetNewAutoFunctionAnalysisSuppressed

_BNGetNewAutoFunctionAnalysisSuppressed = core.BNGetNewAutoFunctionAnalysisSuppressed
_BNGetNewAutoFunctionAnalysisSuppressed.restype = ctypes.c_bool
_BNGetNewAutoFunctionAnalysisSuppressed.argtypes = [
		ctypes.POINTER(BNBinaryView),
	]


# noinspection PyPep8Naming
def BNGetNewAutoFunctionAnalysisSuppressed(
		view: ctypes.POINTER(BNBinaryView)
		) -> bool:
	return _BNGetNewAutoFunctionAnalysisSuppressed(view)


# -------------------------------------------------------
# _BNGetNextBasicBlockStartAfterAddress

_BNGetNextBasicBlockStartAfterAddress = core.BNGetNextBasicBlockStartAfterAddress
_BNGetNextBasicBlockStartAfterAddress.restype = ctypes.c_ulonglong
_BNGetNextBasicBlockStartAfterAddress.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetNextBasicBlockStartAfterAddress(
		view: ctypes.POINTER(BNBinaryView), 
		addr: int
		) -> int:
	return _BNGetNextBasicBlockStartAfterAddress(view, addr)


# -------------------------------------------------------
# _BNGetNextDataAfterAddress

_BNGetNextDataAfterAddress = core.BNGetNextDataAfterAddress
_BNGetNextDataAfterAddress.restype = ctypes.c_ulonglong
_BNGetNextDataAfterAddress.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetNextDataAfterAddress(
		view: ctypes.POINTER(BNBinaryView), 
		addr: int
		) -> int:
	return _BNGetNextDataAfterAddress(view, addr)


# -------------------------------------------------------
# _BNGetNextDataVariableStartAfterAddress

_BNGetNextDataVariableStartAfterAddress = core.BNGetNextDataVariableStartAfterAddress
_BNGetNextDataVariableStartAfterAddress.restype = ctypes.c_ulonglong
_BNGetNextDataVariableStartAfterAddress.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetNextDataVariableStartAfterAddress(
		view: ctypes.POINTER(BNBinaryView), 
		addr: int
		) -> int:
	return _BNGetNextDataVariableStartAfterAddress(view, addr)


# -------------------------------------------------------
# _BNGetNextFunctionStartAfterAddress

_BNGetNextFunctionStartAfterAddress = core.BNGetNextFunctionStartAfterAddress
_BNGetNextFunctionStartAfterAddress.restype = ctypes.c_ulonglong
_BNGetNextFunctionStartAfterAddress.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetNextFunctionStartAfterAddress(
		view: ctypes.POINTER(BNBinaryView), 
		addr: int
		) -> int:
	return _BNGetNextFunctionStartAfterAddress(view, addr)


# -------------------------------------------------------
# _BNGetNextLinearViewObjectChild

_BNGetNextLinearViewObjectChild = core.BNGetNextLinearViewObjectChild
_BNGetNextLinearViewObjectChild.restype = ctypes.POINTER(BNLinearViewObject)
_BNGetNextLinearViewObjectChild.argtypes = [
		ctypes.POINTER(BNLinearViewObject),
		ctypes.POINTER(BNLinearViewObject),
	]


# noinspection PyPep8Naming
def BNGetNextLinearViewObjectChild(
		parent: ctypes.POINTER(BNLinearViewObject), 
		child: ctypes.POINTER(BNLinearViewObject)
		) -> Optional[ctypes.POINTER(BNLinearViewObject)]:
	result = _BNGetNextLinearViewObjectChild(parent, child)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetNextValidOffset

_BNGetNextValidOffset = core.BNGetNextValidOffset
_BNGetNextValidOffset.restype = ctypes.c_ulonglong
_BNGetNextValidOffset.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetNextValidOffset(
		view: ctypes.POINTER(BNBinaryView), 
		offset: int
		) -> int:
	return _BNGetNextValidOffset(view, offset)


# -------------------------------------------------------
# _BNGetOpenFileNameInput

_BNGetOpenFileNameInput = core.BNGetOpenFileNameInput
_BNGetOpenFileNameInput.restype = ctypes.c_bool
_BNGetOpenFileNameInput.argtypes = [
		ctypes.POINTER(ctypes.c_char_p),
		ctypes.c_char_p,
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNGetOpenFileNameInput(
		result: ctypes.POINTER(ctypes.c_char_p), 
		prompt: Optional[str], 
		ext: Optional[str]
		) -> bool:
	return _BNGetOpenFileNameInput(result, cstr(prompt), cstr(ext))


# -------------------------------------------------------
# _BNGetOpenProjects

_BNGetOpenProjects = core.BNGetOpenProjects
_BNGetOpenProjects.restype = ctypes.POINTER(ctypes.POINTER(BNProject))
_BNGetOpenProjects.argtypes = [
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetOpenProjects(
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.POINTER(BNProject))]:
	result = _BNGetOpenProjects(count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetOriginalBase

_BNGetOriginalBase = core.BNGetOriginalBase
_BNGetOriginalBase.restype = ctypes.c_ulonglong
_BNGetOriginalBase.argtypes = [
		ctypes.POINTER(BNBinaryView),
	]


# noinspection PyPep8Naming
def BNGetOriginalBase(
		view: ctypes.POINTER(BNBinaryView)
		) -> int:
	return _BNGetOriginalBase(view)


# -------------------------------------------------------
# _BNGetOriginalFilename

_BNGetOriginalFilename = core.BNGetOriginalFilename
_BNGetOriginalFilename.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetOriginalFilename.argtypes = [
		ctypes.POINTER(BNFileMetadata),
	]


# noinspection PyPep8Naming
def BNGetOriginalFilename(
		file: ctypes.POINTER(BNFileMetadata)
		) -> Optional[Optional[str]]:
	result = _BNGetOriginalFilename(file)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetOutgoingDirectTypeReferences

_BNGetOutgoingDirectTypeReferences = core.BNGetOutgoingDirectTypeReferences
_BNGetOutgoingDirectTypeReferences.restype = ctypes.POINTER(BNQualifiedName)
_BNGetOutgoingDirectTypeReferences.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNQualifiedName),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetOutgoingDirectTypeReferences(
		view: ctypes.POINTER(BNBinaryView), 
		type: ctypes.POINTER(BNQualifiedName), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNQualifiedName)]:
	result = _BNGetOutgoingDirectTypeReferences(view, type, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetOutgoingRecursiveTypeReferences

_BNGetOutgoingRecursiveTypeReferences = core.BNGetOutgoingRecursiveTypeReferences
_BNGetOutgoingRecursiveTypeReferences.restype = ctypes.POINTER(BNQualifiedName)
_BNGetOutgoingRecursiveTypeReferences.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNQualifiedName),
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetOutgoingRecursiveTypeReferences(
		view: ctypes.POINTER(BNBinaryView), 
		types: ctypes.POINTER(BNQualifiedName), 
		typeCount: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNQualifiedName)]:
	result = _BNGetOutgoingRecursiveTypeReferences(view, types, typeCount, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetParameterOrderingForVariables

_BNGetParameterOrderingForVariables = core.BNGetParameterOrderingForVariables
_BNGetParameterOrderingForVariables.restype = ctypes.POINTER(BNVariable)
_BNGetParameterOrderingForVariables.argtypes = [
		ctypes.POINTER(BNCallingConvention),
		ctypes.POINTER(BNVariable),
		ctypes.POINTER(ctypes.POINTER(BNType)),
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetParameterOrderingForVariables(
		cc: ctypes.POINTER(BNCallingConvention), 
		paramVars: ctypes.POINTER(BNVariable), 
		paramTypes: ctypes.POINTER(ctypes.POINTER(BNType)), 
		paramCount: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNVariable)]:
	result = _BNGetParameterOrderingForVariables(cc, paramVars, paramTypes, paramCount, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetParameterValueAtInstruction

_BNGetParameterValueAtInstruction = core.BNGetParameterValueAtInstruction
_BNGetParameterValueAtInstruction.restype = BNRegisterValue
_BNGetParameterValueAtInstruction.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNArchitecture),
		ctypes.c_ulonglong,
		ctypes.POINTER(BNType),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetParameterValueAtInstruction(
		func: ctypes.POINTER(BNFunction), 
		arch: ctypes.POINTER(BNArchitecture), 
		addr: int, 
		functionType: ctypes.POINTER(BNType), 
		i: int
		) -> BNRegisterValue:
	return _BNGetParameterValueAtInstruction(func, arch, addr, functionType, i)


# -------------------------------------------------------
# _BNGetParameterValueAtLowLevelILInstruction

_BNGetParameterValueAtLowLevelILInstruction = core.BNGetParameterValueAtLowLevelILInstruction
_BNGetParameterValueAtLowLevelILInstruction.restype = BNRegisterValue
_BNGetParameterValueAtLowLevelILInstruction.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.c_ulonglong,
		ctypes.POINTER(BNType),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetParameterValueAtLowLevelILInstruction(
		func: ctypes.POINTER(BNFunction), 
		instr: int, 
		functionType: ctypes.POINTER(BNType), 
		i: int
		) -> BNRegisterValue:
	return _BNGetParameterValueAtLowLevelILInstruction(func, instr, functionType, i)


# -------------------------------------------------------
# _BNGetParameterVariableForIncomingVariable

_BNGetParameterVariableForIncomingVariable = core.BNGetParameterVariableForIncomingVariable
_BNGetParameterVariableForIncomingVariable.restype = BNVariable
_BNGetParameterVariableForIncomingVariable.argtypes = [
		ctypes.POINTER(BNCallingConvention),
		ctypes.POINTER(BNVariable),
		ctypes.POINTER(BNFunction),
	]


# noinspection PyPep8Naming
def BNGetParameterVariableForIncomingVariable(
		cc: ctypes.POINTER(BNCallingConvention), 
		var: ctypes.POINTER(BNVariable), 
		func: ctypes.POINTER(BNFunction)
		) -> BNVariable:
	return _BNGetParameterVariableForIncomingVariable(cc, var, func)


# -------------------------------------------------------
# _BNGetParametersForAnalysis

_BNGetParametersForAnalysis = core.BNGetParametersForAnalysis
_BNGetParametersForAnalysis.restype = BNAnalysisParameters
_BNGetParametersForAnalysis.argtypes = [
		ctypes.POINTER(BNBinaryView),
	]


# noinspection PyPep8Naming
def BNGetParametersForAnalysis(
		view: ctypes.POINTER(BNBinaryView)
		) -> BNAnalysisParameters:
	return _BNGetParametersForAnalysis(view)


# -------------------------------------------------------
# _BNGetParentPath

_BNGetParentPath = core.BNGetParentPath
_BNGetParentPath.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetParentPath.argtypes = [
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNGetParentPath(
		path: Optional[str]
		) -> Optional[Optional[str]]:
	result = _BNGetParentPath(cstr(path))
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetParentView

_BNGetParentView = core.BNGetParentView
_BNGetParentView.restype = ctypes.POINTER(BNBinaryView)
_BNGetParentView.argtypes = [
		ctypes.POINTER(BNBinaryView),
	]


# noinspection PyPep8Naming
def BNGetParentView(
		view: ctypes.POINTER(BNBinaryView)
		) -> Optional[ctypes.POINTER(BNBinaryView)]:
	result = _BNGetParentView(view)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetPathRelativeToBundledPluginDirectory

_BNGetPathRelativeToBundledPluginDirectory = core.BNGetPathRelativeToBundledPluginDirectory
_BNGetPathRelativeToBundledPluginDirectory.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetPathRelativeToBundledPluginDirectory.argtypes = [
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNGetPathRelativeToBundledPluginDirectory(
		path: Optional[str]
		) -> Optional[Optional[str]]:
	result = _BNGetPathRelativeToBundledPluginDirectory(cstr(path))
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetPathRelativeToUserDirectory

_BNGetPathRelativeToUserDirectory = core.BNGetPathRelativeToUserDirectory
_BNGetPathRelativeToUserDirectory.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetPathRelativeToUserDirectory.argtypes = [
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNGetPathRelativeToUserDirectory(
		path: Optional[str]
		) -> Optional[Optional[str]]:
	result = _BNGetPathRelativeToUserDirectory(cstr(path))
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetPathRelativeToUserPluginDirectory

_BNGetPathRelativeToUserPluginDirectory = core.BNGetPathRelativeToUserPluginDirectory
_BNGetPathRelativeToUserPluginDirectory.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetPathRelativeToUserPluginDirectory.argtypes = [
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNGetPathRelativeToUserPluginDirectory(
		path: Optional[str]
		) -> Optional[Optional[str]]:
	result = _BNGetPathRelativeToUserPluginDirectory(cstr(path))
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetPlatformArchitecture

_BNGetPlatformArchitecture = core.BNGetPlatformArchitecture
_BNGetPlatformArchitecture.restype = ctypes.POINTER(BNArchitecture)
_BNGetPlatformArchitecture.argtypes = [
		ctypes.POINTER(BNPlatform),
	]


# noinspection PyPep8Naming
def BNGetPlatformArchitecture(
		platform: ctypes.POINTER(BNPlatform)
		) -> Optional[ctypes.POINTER(BNArchitecture)]:
	result = _BNGetPlatformArchitecture(platform)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetPlatformByName

_BNGetPlatformByName = core.BNGetPlatformByName
_BNGetPlatformByName.restype = ctypes.POINTER(BNPlatform)
_BNGetPlatformByName.argtypes = [
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNGetPlatformByName(
		name: Optional[str]
		) -> Optional[ctypes.POINTER(BNPlatform)]:
	result = _BNGetPlatformByName(cstr(name))
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetPlatformCallingConventions

_BNGetPlatformCallingConventions = core.BNGetPlatformCallingConventions
_BNGetPlatformCallingConventions.restype = ctypes.POINTER(ctypes.POINTER(BNCallingConvention))
_BNGetPlatformCallingConventions.argtypes = [
		ctypes.POINTER(BNPlatform),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetPlatformCallingConventions(
		platform: ctypes.POINTER(BNPlatform), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.POINTER(BNCallingConvention))]:
	result = _BNGetPlatformCallingConventions(platform, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetPlatformCdeclCallingConvention

_BNGetPlatformCdeclCallingConvention = core.BNGetPlatformCdeclCallingConvention
_BNGetPlatformCdeclCallingConvention.restype = ctypes.POINTER(BNCallingConvention)
_BNGetPlatformCdeclCallingConvention.argtypes = [
		ctypes.POINTER(BNPlatform),
	]


# noinspection PyPep8Naming
def BNGetPlatformCdeclCallingConvention(
		platform: ctypes.POINTER(BNPlatform)
		) -> Optional[ctypes.POINTER(BNCallingConvention)]:
	result = _BNGetPlatformCdeclCallingConvention(platform)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetPlatformDefaultCallingConvention

_BNGetPlatformDefaultCallingConvention = core.BNGetPlatformDefaultCallingConvention
_BNGetPlatformDefaultCallingConvention.restype = ctypes.POINTER(BNCallingConvention)
_BNGetPlatformDefaultCallingConvention.argtypes = [
		ctypes.POINTER(BNPlatform),
	]


# noinspection PyPep8Naming
def BNGetPlatformDefaultCallingConvention(
		platform: ctypes.POINTER(BNPlatform)
		) -> Optional[ctypes.POINTER(BNCallingConvention)]:
	result = _BNGetPlatformDefaultCallingConvention(platform)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetPlatformFastcallCallingConvention

_BNGetPlatformFastcallCallingConvention = core.BNGetPlatformFastcallCallingConvention
_BNGetPlatformFastcallCallingConvention.restype = ctypes.POINTER(BNCallingConvention)
_BNGetPlatformFastcallCallingConvention.argtypes = [
		ctypes.POINTER(BNPlatform),
	]


# noinspection PyPep8Naming
def BNGetPlatformFastcallCallingConvention(
		platform: ctypes.POINTER(BNPlatform)
		) -> Optional[ctypes.POINTER(BNCallingConvention)]:
	result = _BNGetPlatformFastcallCallingConvention(platform)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetPlatformForViewType

_BNGetPlatformForViewType = core.BNGetPlatformForViewType
_BNGetPlatformForViewType.restype = ctypes.POINTER(BNPlatform)
_BNGetPlatformForViewType.argtypes = [
		ctypes.POINTER(BNBinaryViewType),
		ctypes.c_uint,
		ctypes.POINTER(BNArchitecture),
	]


# noinspection PyPep8Naming
def BNGetPlatformForViewType(
		type: ctypes.POINTER(BNBinaryViewType), 
		id: int, 
		arch: ctypes.POINTER(BNArchitecture)
		) -> Optional[ctypes.POINTER(BNPlatform)]:
	result = _BNGetPlatformForViewType(type, id, arch)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetPlatformFunctionByName

_BNGetPlatformFunctionByName = core.BNGetPlatformFunctionByName
_BNGetPlatformFunctionByName.restype = ctypes.POINTER(BNType)
_BNGetPlatformFunctionByName.argtypes = [
		ctypes.POINTER(BNPlatform),
		ctypes.POINTER(BNQualifiedName),
		ctypes.c_bool,
	]


# noinspection PyPep8Naming
def BNGetPlatformFunctionByName(
		platform: ctypes.POINTER(BNPlatform), 
		name: ctypes.POINTER(BNQualifiedName), 
		exactMatch: bool
		) -> Optional[ctypes.POINTER(BNType)]:
	result = _BNGetPlatformFunctionByName(platform, name, exactMatch)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetPlatformFunctions

_BNGetPlatformFunctions = core.BNGetPlatformFunctions
_BNGetPlatformFunctions.restype = ctypes.POINTER(BNQualifiedNameAndType)
_BNGetPlatformFunctions.argtypes = [
		ctypes.POINTER(BNPlatform),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetPlatformFunctions(
		platform: ctypes.POINTER(BNPlatform), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNQualifiedNameAndType)]:
	result = _BNGetPlatformFunctions(platform, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetPlatformList

_BNGetPlatformList = core.BNGetPlatformList
_BNGetPlatformList.restype = ctypes.POINTER(ctypes.POINTER(BNPlatform))
_BNGetPlatformList.argtypes = [
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetPlatformList(
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.POINTER(BNPlatform))]:
	result = _BNGetPlatformList(count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetPlatformListByArchitecture

_BNGetPlatformListByArchitecture = core.BNGetPlatformListByArchitecture
_BNGetPlatformListByArchitecture.restype = ctypes.POINTER(ctypes.POINTER(BNPlatform))
_BNGetPlatformListByArchitecture.argtypes = [
		ctypes.POINTER(BNArchitecture),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetPlatformListByArchitecture(
		arch: ctypes.POINTER(BNArchitecture), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.POINTER(BNPlatform))]:
	result = _BNGetPlatformListByArchitecture(arch, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetPlatformListByOS

_BNGetPlatformListByOS = core.BNGetPlatformListByOS
_BNGetPlatformListByOS.restype = ctypes.POINTER(ctypes.POINTER(BNPlatform))
_BNGetPlatformListByOS.argtypes = [
		ctypes.c_char_p,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetPlatformListByOS(
		os: Optional[str], 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.POINTER(BNPlatform))]:
	result = _BNGetPlatformListByOS(cstr(os), count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetPlatformListByOSAndArchitecture

_BNGetPlatformListByOSAndArchitecture = core.BNGetPlatformListByOSAndArchitecture
_BNGetPlatformListByOSAndArchitecture.restype = ctypes.POINTER(ctypes.POINTER(BNPlatform))
_BNGetPlatformListByOSAndArchitecture.argtypes = [
		ctypes.c_char_p,
		ctypes.POINTER(BNArchitecture),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetPlatformListByOSAndArchitecture(
		os: Optional[str], 
		arch: ctypes.POINTER(BNArchitecture), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.POINTER(BNPlatform))]:
	result = _BNGetPlatformListByOSAndArchitecture(cstr(os), arch, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetPlatformName

_BNGetPlatformName = core.BNGetPlatformName
_BNGetPlatformName.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetPlatformName.argtypes = [
		ctypes.POINTER(BNPlatform),
	]


# noinspection PyPep8Naming
def BNGetPlatformName(
		platform: ctypes.POINTER(BNPlatform)
		) -> Optional[Optional[str]]:
	result = _BNGetPlatformName(platform)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetPlatformOSList

_BNGetPlatformOSList = core.BNGetPlatformOSList
_BNGetPlatformOSList.restype = ctypes.POINTER(ctypes.c_char_p)
_BNGetPlatformOSList.argtypes = [
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetPlatformOSList(
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_char_p)]:
	result = _BNGetPlatformOSList(count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetPlatformStdcallCallingConvention

_BNGetPlatformStdcallCallingConvention = core.BNGetPlatformStdcallCallingConvention
_BNGetPlatformStdcallCallingConvention.restype = ctypes.POINTER(BNCallingConvention)
_BNGetPlatformStdcallCallingConvention.argtypes = [
		ctypes.POINTER(BNPlatform),
	]


# noinspection PyPep8Naming
def BNGetPlatformStdcallCallingConvention(
		platform: ctypes.POINTER(BNPlatform)
		) -> Optional[ctypes.POINTER(BNCallingConvention)]:
	result = _BNGetPlatformStdcallCallingConvention(platform)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetPlatformSystemCallConvention

_BNGetPlatformSystemCallConvention = core.BNGetPlatformSystemCallConvention
_BNGetPlatformSystemCallConvention.restype = ctypes.POINTER(BNCallingConvention)
_BNGetPlatformSystemCallConvention.argtypes = [
		ctypes.POINTER(BNPlatform),
	]


# noinspection PyPep8Naming
def BNGetPlatformSystemCallConvention(
		platform: ctypes.POINTER(BNPlatform)
		) -> Optional[ctypes.POINTER(BNCallingConvention)]:
	result = _BNGetPlatformSystemCallConvention(platform)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetPlatformSystemCallName

_BNGetPlatformSystemCallName = core.BNGetPlatformSystemCallName
_BNGetPlatformSystemCallName.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetPlatformSystemCallName.argtypes = [
		ctypes.POINTER(BNPlatform),
		ctypes.c_uint,
	]


# noinspection PyPep8Naming
def BNGetPlatformSystemCallName(
		platform: ctypes.POINTER(BNPlatform), 
		number: int
		) -> Optional[Optional[str]]:
	result = _BNGetPlatformSystemCallName(platform, number)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetPlatformSystemCallType

_BNGetPlatformSystemCallType = core.BNGetPlatformSystemCallType
_BNGetPlatformSystemCallType.restype = ctypes.POINTER(BNType)
_BNGetPlatformSystemCallType.argtypes = [
		ctypes.POINTER(BNPlatform),
		ctypes.c_uint,
	]


# noinspection PyPep8Naming
def BNGetPlatformSystemCallType(
		platform: ctypes.POINTER(BNPlatform), 
		number: int
		) -> Optional[ctypes.POINTER(BNType)]:
	result = _BNGetPlatformSystemCallType(platform, number)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetPlatformSystemCalls

_BNGetPlatformSystemCalls = core.BNGetPlatformSystemCalls
_BNGetPlatformSystemCalls.restype = ctypes.POINTER(BNSystemCallInfo)
_BNGetPlatformSystemCalls.argtypes = [
		ctypes.POINTER(BNPlatform),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetPlatformSystemCalls(
		platform: ctypes.POINTER(BNPlatform), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNSystemCallInfo)]:
	result = _BNGetPlatformSystemCalls(platform, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetPlatformTypeByName

_BNGetPlatformTypeByName = core.BNGetPlatformTypeByName
_BNGetPlatformTypeByName.restype = ctypes.POINTER(BNType)
_BNGetPlatformTypeByName.argtypes = [
		ctypes.POINTER(BNPlatform),
		ctypes.POINTER(BNQualifiedName),
	]


# noinspection PyPep8Naming
def BNGetPlatformTypeByName(
		platform: ctypes.POINTER(BNPlatform), 
		name: ctypes.POINTER(BNQualifiedName)
		) -> Optional[ctypes.POINTER(BNType)]:
	result = _BNGetPlatformTypeByName(platform, name)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetPlatformTypeContainer

_BNGetPlatformTypeContainer = core.BNGetPlatformTypeContainer
_BNGetPlatformTypeContainer.restype = ctypes.POINTER(BNTypeContainer)
_BNGetPlatformTypeContainer.argtypes = [
		ctypes.POINTER(BNPlatform),
	]


# noinspection PyPep8Naming
def BNGetPlatformTypeContainer(
		platform: ctypes.POINTER(BNPlatform)
		) -> Optional[ctypes.POINTER(BNTypeContainer)]:
	result = _BNGetPlatformTypeContainer(platform)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetPlatformTypeLibraries

_BNGetPlatformTypeLibraries = core.BNGetPlatformTypeLibraries
_BNGetPlatformTypeLibraries.restype = ctypes.POINTER(ctypes.POINTER(BNTypeLibrary))
_BNGetPlatformTypeLibraries.argtypes = [
		ctypes.POINTER(BNPlatform),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetPlatformTypeLibraries(
		platform: ctypes.POINTER(BNPlatform), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.POINTER(BNTypeLibrary))]:
	result = _BNGetPlatformTypeLibraries(platform, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetPlatformTypeLibrariesByName

_BNGetPlatformTypeLibrariesByName = core.BNGetPlatformTypeLibrariesByName
_BNGetPlatformTypeLibrariesByName.restype = ctypes.POINTER(ctypes.POINTER(BNTypeLibrary))
_BNGetPlatformTypeLibrariesByName.argtypes = [
		ctypes.POINTER(BNPlatform),
		ctypes.c_char_p,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetPlatformTypeLibrariesByName(
		platform: ctypes.POINTER(BNPlatform), 
		depName: Optional[str], 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.POINTER(BNTypeLibrary))]:
	result = _BNGetPlatformTypeLibrariesByName(platform, cstr(depName), count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetPlatformTypes

_BNGetPlatformTypes = core.BNGetPlatformTypes
_BNGetPlatformTypes.restype = ctypes.POINTER(BNQualifiedNameAndType)
_BNGetPlatformTypes.argtypes = [
		ctypes.POINTER(BNPlatform),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetPlatformTypes(
		platform: ctypes.POINTER(BNPlatform), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNQualifiedNameAndType)]:
	result = _BNGetPlatformTypes(platform, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetPlatformVariableByName

_BNGetPlatformVariableByName = core.BNGetPlatformVariableByName
_BNGetPlatformVariableByName.restype = ctypes.POINTER(BNType)
_BNGetPlatformVariableByName.argtypes = [
		ctypes.POINTER(BNPlatform),
		ctypes.POINTER(BNQualifiedName),
	]


# noinspection PyPep8Naming
def BNGetPlatformVariableByName(
		platform: ctypes.POINTER(BNPlatform), 
		name: ctypes.POINTER(BNQualifiedName)
		) -> Optional[ctypes.POINTER(BNType)]:
	result = _BNGetPlatformVariableByName(platform, name)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetPlatformVariables

_BNGetPlatformVariables = core.BNGetPlatformVariables
_BNGetPlatformVariables.restype = ctypes.POINTER(BNQualifiedNameAndType)
_BNGetPlatformVariables.argtypes = [
		ctypes.POINTER(BNPlatform),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetPlatformVariables(
		platform: ctypes.POINTER(BNPlatform), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNQualifiedNameAndType)]:
	result = _BNGetPlatformVariables(platform, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetPreviousBasicBlockEndBeforeAddress

_BNGetPreviousBasicBlockEndBeforeAddress = core.BNGetPreviousBasicBlockEndBeforeAddress
_BNGetPreviousBasicBlockEndBeforeAddress.restype = ctypes.c_ulonglong
_BNGetPreviousBasicBlockEndBeforeAddress.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetPreviousBasicBlockEndBeforeAddress(
		view: ctypes.POINTER(BNBinaryView), 
		addr: int
		) -> int:
	return _BNGetPreviousBasicBlockEndBeforeAddress(view, addr)


# -------------------------------------------------------
# _BNGetPreviousBasicBlockStartBeforeAddress

_BNGetPreviousBasicBlockStartBeforeAddress = core.BNGetPreviousBasicBlockStartBeforeAddress
_BNGetPreviousBasicBlockStartBeforeAddress.restype = ctypes.c_ulonglong
_BNGetPreviousBasicBlockStartBeforeAddress.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetPreviousBasicBlockStartBeforeAddress(
		view: ctypes.POINTER(BNBinaryView), 
		addr: int
		) -> int:
	return _BNGetPreviousBasicBlockStartBeforeAddress(view, addr)


# -------------------------------------------------------
# _BNGetPreviousDataBeforeAddress

_BNGetPreviousDataBeforeAddress = core.BNGetPreviousDataBeforeAddress
_BNGetPreviousDataBeforeAddress.restype = ctypes.c_ulonglong
_BNGetPreviousDataBeforeAddress.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetPreviousDataBeforeAddress(
		view: ctypes.POINTER(BNBinaryView), 
		addr: int
		) -> int:
	return _BNGetPreviousDataBeforeAddress(view, addr)


# -------------------------------------------------------
# _BNGetPreviousDataVariableStartBeforeAddress

_BNGetPreviousDataVariableStartBeforeAddress = core.BNGetPreviousDataVariableStartBeforeAddress
_BNGetPreviousDataVariableStartBeforeAddress.restype = ctypes.c_ulonglong
_BNGetPreviousDataVariableStartBeforeAddress.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetPreviousDataVariableStartBeforeAddress(
		view: ctypes.POINTER(BNBinaryView), 
		addr: int
		) -> int:
	return _BNGetPreviousDataVariableStartBeforeAddress(view, addr)


# -------------------------------------------------------
# _BNGetPreviousFunctionStartBeforeAddress

_BNGetPreviousFunctionStartBeforeAddress = core.BNGetPreviousFunctionStartBeforeAddress
_BNGetPreviousFunctionStartBeforeAddress.restype = ctypes.c_ulonglong
_BNGetPreviousFunctionStartBeforeAddress.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetPreviousFunctionStartBeforeAddress(
		view: ctypes.POINTER(BNBinaryView), 
		addr: int
		) -> int:
	return _BNGetPreviousFunctionStartBeforeAddress(view, addr)


# -------------------------------------------------------
# _BNGetPreviousLinearViewObjectChild

_BNGetPreviousLinearViewObjectChild = core.BNGetPreviousLinearViewObjectChild
_BNGetPreviousLinearViewObjectChild.restype = ctypes.POINTER(BNLinearViewObject)
_BNGetPreviousLinearViewObjectChild.argtypes = [
		ctypes.POINTER(BNLinearViewObject),
		ctypes.POINTER(BNLinearViewObject),
	]


# noinspection PyPep8Naming
def BNGetPreviousLinearViewObjectChild(
		parent: ctypes.POINTER(BNLinearViewObject), 
		child: ctypes.POINTER(BNLinearViewObject)
		) -> Optional[ctypes.POINTER(BNLinearViewObject)]:
	result = _BNGetPreviousLinearViewObjectChild(parent, child)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetProduct

_BNGetProduct = core.BNGetProduct
_BNGetProduct.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetProduct.argtypes = [
	]


# noinspection PyPep8Naming
def BNGetProduct(
		) -> Optional[Optional[str]]:
	result = _BNGetProduct()
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetProductType

_BNGetProductType = core.BNGetProductType
_BNGetProductType.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetProductType.argtypes = [
	]


# noinspection PyPep8Naming
def BNGetProductType(
		) -> Optional[Optional[str]]:
	result = _BNGetProductType()
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetProjectFile

_BNGetProjectFile = core.BNGetProjectFile
_BNGetProjectFile.restype = ctypes.POINTER(BNProjectFile)
_BNGetProjectFile.argtypes = [
		ctypes.POINTER(BNFileMetadata),
	]


# noinspection PyPep8Naming
def BNGetProjectFile(
		file: ctypes.POINTER(BNFileMetadata)
		) -> Optional[ctypes.POINTER(BNProjectFile)]:
	result = _BNGetProjectFile(file)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetProvenanceString

_BNGetProvenanceString = core.BNGetProvenanceString
_BNGetProvenanceString.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetProvenanceString.argtypes = [
		ctypes.POINTER(BNFunction),
	]


# noinspection PyPep8Naming
def BNGetProvenanceString(
		func: ctypes.POINTER(BNFunction)
		) -> Optional[Optional[str]]:
	result = _BNGetProvenanceString(func)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetReaderPosition

_BNGetReaderPosition = core.BNGetReaderPosition
_BNGetReaderPosition.restype = ctypes.c_ulonglong
_BNGetReaderPosition.argtypes = [
		ctypes.POINTER(BNBinaryReader),
	]


# noinspection PyPep8Naming
def BNGetReaderPosition(
		stream: ctypes.POINTER(BNBinaryReader)
		) -> int:
	return _BNGetReaderPosition(stream)


# -------------------------------------------------------
# _BNGetRecentAnalysisFunctionForAddress

_BNGetRecentAnalysisFunctionForAddress = core.BNGetRecentAnalysisFunctionForAddress
_BNGetRecentAnalysisFunctionForAddress.restype = ctypes.POINTER(BNFunction)
_BNGetRecentAnalysisFunctionForAddress.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetRecentAnalysisFunctionForAddress(
		view: ctypes.POINTER(BNBinaryView), 
		addr: int
		) -> Optional[ctypes.POINTER(BNFunction)]:
	result = _BNGetRecentAnalysisFunctionForAddress(view, addr)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetRecentBasicBlockForAddress

_BNGetRecentBasicBlockForAddress = core.BNGetRecentBasicBlockForAddress
_BNGetRecentBasicBlockForAddress.restype = ctypes.POINTER(BNBasicBlock)
_BNGetRecentBasicBlockForAddress.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetRecentBasicBlockForAddress(
		view: ctypes.POINTER(BNBinaryView), 
		addr: int
		) -> Optional[ctypes.POINTER(BNBasicBlock)]:
	result = _BNGetRecentBasicBlockForAddress(view, addr)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetRedoEntries

_BNGetRedoEntries = core.BNGetRedoEntries
_BNGetRedoEntries.restype = ctypes.POINTER(BNUndoEntry)
_BNGetRedoEntries.argtypes = [
		ctypes.POINTER(BNFileMetadata),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetRedoEntries(
		file: ctypes.POINTER(BNFileMetadata), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNUndoEntry)]:
	result = _BNGetRedoEntries(file, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetRegisterStackAdjustments

_BNGetRegisterStackAdjustments = core.BNGetRegisterStackAdjustments
_BNGetRegisterStackAdjustments.restype = ctypes.c_ulonglong
_BNGetRegisterStackAdjustments.argtypes = [
		ctypes.POINTER(BNCallingConvention),
		ctypes.POINTER(ctypes.c_uint),
		ctypes.c_ulonglong,
		ctypes.POINTER(BNType),
		ctypes.POINTER(BNVariable),
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.POINTER(BNType)),
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.POINTER(ctypes.c_uint)),
		ctypes.POINTER(ctypes.POINTER(ctypes.c_uint)),
	]


# noinspection PyPep8Naming
def BNGetRegisterStackAdjustments(
		cc: ctypes.POINTER(BNCallingConvention), 
		returnRegs: ctypes.POINTER(ctypes.c_uint), 
		returnRegCount: int, 
		returnType: ctypes.POINTER(BNType), 
		params: ctypes.POINTER(BNVariable), 
		paramCount: int, 
		types: ctypes.POINTER(ctypes.POINTER(BNType)), 
		typeCount: int, 
		resultRegisters: ctypes.POINTER(ctypes.POINTER(ctypes.c_uint)), 
		resultAdjustments: ctypes.POINTER(ctypes.POINTER(ctypes.c_uint))
		) -> int:
	return _BNGetRegisterStackAdjustments(cc, returnRegs, returnRegCount, returnType, params, paramCount, types, typeCount, resultRegisters, resultAdjustments)


# -------------------------------------------------------
# _BNGetRegisterValueAfterInstruction

_BNGetRegisterValueAfterInstruction = core.BNGetRegisterValueAfterInstruction
_BNGetRegisterValueAfterInstruction.restype = BNRegisterValue
_BNGetRegisterValueAfterInstruction.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNArchitecture),
		ctypes.c_ulonglong,
		ctypes.c_uint,
	]


# noinspection PyPep8Naming
def BNGetRegisterValueAfterInstruction(
		func: ctypes.POINTER(BNFunction), 
		arch: ctypes.POINTER(BNArchitecture), 
		addr: int, 
		reg: int
		) -> BNRegisterValue:
	return _BNGetRegisterValueAfterInstruction(func, arch, addr, reg)


# -------------------------------------------------------
# _BNGetRegisterValueAtInstruction

_BNGetRegisterValueAtInstruction = core.BNGetRegisterValueAtInstruction
_BNGetRegisterValueAtInstruction.restype = BNRegisterValue
_BNGetRegisterValueAtInstruction.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNArchitecture),
		ctypes.c_ulonglong,
		ctypes.c_uint,
	]


# noinspection PyPep8Naming
def BNGetRegisterValueAtInstruction(
		func: ctypes.POINTER(BNFunction), 
		arch: ctypes.POINTER(BNArchitecture), 
		addr: int, 
		reg: int
		) -> BNRegisterValue:
	return _BNGetRegisterValueAtInstruction(func, arch, addr, reg)


# -------------------------------------------------------
# _BNGetRegisteredTypeName

_BNGetRegisteredTypeName = core.BNGetRegisteredTypeName
_BNGetRegisteredTypeName.restype = ctypes.POINTER(BNNamedTypeReference)
_BNGetRegisteredTypeName.argtypes = [
		ctypes.POINTER(BNType),
	]


# noinspection PyPep8Naming
def BNGetRegisteredTypeName(
		type: ctypes.POINTER(BNType)
		) -> Optional[ctypes.POINTER(BNNamedTypeReference)]:
	result = _BNGetRegisteredTypeName(type)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetRegistersReadByInstruction

_BNGetRegistersReadByInstruction = core.BNGetRegistersReadByInstruction
_BNGetRegistersReadByInstruction.restype = ctypes.POINTER(ctypes.c_uint)
_BNGetRegistersReadByInstruction.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNArchitecture),
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetRegistersReadByInstruction(
		func: ctypes.POINTER(BNFunction), 
		arch: ctypes.POINTER(BNArchitecture), 
		addr: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_uint)]:
	result = _BNGetRegistersReadByInstruction(func, arch, addr, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetRegistersWrittenByInstruction

_BNGetRegistersWrittenByInstruction = core.BNGetRegistersWrittenByInstruction
_BNGetRegistersWrittenByInstruction.restype = ctypes.POINTER(ctypes.c_uint)
_BNGetRegistersWrittenByInstruction.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNArchitecture),
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetRegistersWrittenByInstruction(
		func: ctypes.POINTER(BNFunction), 
		arch: ctypes.POINTER(BNArchitecture), 
		addr: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_uint)]:
	result = _BNGetRegistersWrittenByInstruction(func, arch, addr, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetRelatedPlatform

_BNGetRelatedPlatform = core.BNGetRelatedPlatform
_BNGetRelatedPlatform.restype = ctypes.POINTER(BNPlatform)
_BNGetRelatedPlatform.argtypes = [
		ctypes.POINTER(BNPlatform),
		ctypes.POINTER(BNArchitecture),
	]


# noinspection PyPep8Naming
def BNGetRelatedPlatform(
		platform: ctypes.POINTER(BNPlatform), 
		arch: ctypes.POINTER(BNArchitecture)
		) -> Optional[ctypes.POINTER(BNPlatform)]:
	result = _BNGetRelatedPlatform(platform, arch)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetRelocationRanges

_BNGetRelocationRanges = core.BNGetRelocationRanges
_BNGetRelocationRanges.restype = ctypes.POINTER(BNRange)
_BNGetRelocationRanges.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetRelocationRanges(
		view: ctypes.POINTER(BNBinaryView), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNRange)]:
	result = _BNGetRelocationRanges(view, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetRelocationRangesAtAddress

_BNGetRelocationRangesAtAddress = core.BNGetRelocationRangesAtAddress
_BNGetRelocationRangesAtAddress.restype = ctypes.POINTER(BNRange)
_BNGetRelocationRangesAtAddress.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetRelocationRangesAtAddress(
		view: ctypes.POINTER(BNBinaryView), 
		addr: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNRange)]:
	result = _BNGetRelocationRangesAtAddress(view, addr, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetRelocationsAt

_BNGetRelocationsAt = core.BNGetRelocationsAt
_BNGetRelocationsAt.restype = ctypes.POINTER(ctypes.POINTER(BNRelocation))
_BNGetRelocationsAt.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetRelocationsAt(
		view: ctypes.POINTER(BNBinaryView), 
		addr: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.POINTER(BNRelocation))]:
	result = _BNGetRelocationsAt(view, addr, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetReportCollectionCount

_BNGetReportCollectionCount = core.BNGetReportCollectionCount
_BNGetReportCollectionCount.restype = ctypes.c_ulonglong
_BNGetReportCollectionCount.argtypes = [
		ctypes.POINTER(BNReportCollection),
	]


# noinspection PyPep8Naming
def BNGetReportCollectionCount(
		reports: ctypes.POINTER(BNReportCollection)
		) -> int:
	return _BNGetReportCollectionCount(reports)


# -------------------------------------------------------
# _BNGetReportContents

_BNGetReportContents = core.BNGetReportContents
_BNGetReportContents.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetReportContents.argtypes = [
		ctypes.POINTER(BNReportCollection),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetReportContents(
		reports: ctypes.POINTER(BNReportCollection), 
		i: int
		) -> Optional[Optional[str]]:
	result = _BNGetReportContents(reports, i)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetReportFlowGraph

_BNGetReportFlowGraph = core.BNGetReportFlowGraph
_BNGetReportFlowGraph.restype = ctypes.POINTER(BNFlowGraph)
_BNGetReportFlowGraph.argtypes = [
		ctypes.POINTER(BNReportCollection),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetReportFlowGraph(
		reports: ctypes.POINTER(BNReportCollection), 
		i: int
		) -> Optional[ctypes.POINTER(BNFlowGraph)]:
	result = _BNGetReportFlowGraph(reports, i)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetReportPlainText

_BNGetReportPlainText = core.BNGetReportPlainText
_BNGetReportPlainText.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetReportPlainText.argtypes = [
		ctypes.POINTER(BNReportCollection),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetReportPlainText(
		reports: ctypes.POINTER(BNReportCollection), 
		i: int
		) -> Optional[Optional[str]]:
	result = _BNGetReportPlainText(reports, i)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetReportTitle

_BNGetReportTitle = core.BNGetReportTitle
_BNGetReportTitle.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetReportTitle.argtypes = [
		ctypes.POINTER(BNReportCollection),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetReportTitle(
		reports: ctypes.POINTER(BNReportCollection), 
		i: int
		) -> Optional[Optional[str]]:
	result = _BNGetReportTitle(reports, i)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetReportType

_BNGetReportType = core.BNGetReportType
_BNGetReportType.restype = ReportTypeEnum
_BNGetReportType.argtypes = [
		ctypes.POINTER(BNReportCollection),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetReportType(
		reports: ctypes.POINTER(BNReportCollection), 
		i: int
		) -> ReportType:
	return _BNGetReportType(reports, i)


# -------------------------------------------------------
# _BNGetReportView

_BNGetReportView = core.BNGetReportView
_BNGetReportView.restype = ctypes.POINTER(BNBinaryView)
_BNGetReportView.argtypes = [
		ctypes.POINTER(BNReportCollection),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetReportView(
		reports: ctypes.POINTER(BNReportCollection), 
		i: int
		) -> Optional[ctypes.POINTER(BNBinaryView)]:
	result = _BNGetReportView(reports, i)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetRepositoriesDirectory

_BNGetRepositoriesDirectory = core.BNGetRepositoriesDirectory
_BNGetRepositoriesDirectory.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetRepositoriesDirectory.argtypes = [
	]


# noinspection PyPep8Naming
def BNGetRepositoriesDirectory(
		) -> Optional[Optional[str]]:
	result = _BNGetRepositoriesDirectory()
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetRepositoryManager

_BNGetRepositoryManager = core.BNGetRepositoryManager
_BNGetRepositoryManager.restype = ctypes.POINTER(BNRepositoryManager)
_BNGetRepositoryManager.argtypes = [
	]


# noinspection PyPep8Naming
def BNGetRepositoryManager(
		) -> Optional[ctypes.POINTER(BNRepositoryManager)]:
	result = _BNGetRepositoryManager()
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetRootComponent

_BNGetRootComponent = core.BNGetRootComponent
_BNGetRootComponent.restype = ctypes.POINTER(BNComponent)
_BNGetRootComponent.argtypes = [
		ctypes.POINTER(BNBinaryView),
	]


# noinspection PyPep8Naming
def BNGetRootComponent(
		view: ctypes.POINTER(BNBinaryView)
		) -> Optional[ctypes.POINTER(BNComponent)]:
	result = _BNGetRootComponent(view)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetRunningBackgroundTasks

_BNGetRunningBackgroundTasks = core.BNGetRunningBackgroundTasks
_BNGetRunningBackgroundTasks.restype = ctypes.POINTER(ctypes.POINTER(BNBackgroundTask))
_BNGetRunningBackgroundTasks.argtypes = [
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetRunningBackgroundTasks(
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.POINTER(BNBackgroundTask))]:
	result = _BNGetRunningBackgroundTasks(count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetSaveFileNameInput

_BNGetSaveFileNameInput = core.BNGetSaveFileNameInput
_BNGetSaveFileNameInput.restype = ctypes.c_bool
_BNGetSaveFileNameInput.argtypes = [
		ctypes.POINTER(ctypes.c_char_p),
		ctypes.c_char_p,
		ctypes.c_char_p,
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNGetSaveFileNameInput(
		result: ctypes.POINTER(ctypes.c_char_p), 
		prompt: Optional[str], 
		ext: Optional[str], 
		defaultName: Optional[str]
		) -> bool:
	return _BNGetSaveFileNameInput(result, cstr(prompt), cstr(ext), cstr(defaultName))


# -------------------------------------------------------
# _BNGetSaveSettingsName

_BNGetSaveSettingsName = core.BNGetSaveSettingsName
_BNGetSaveSettingsName.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetSaveSettingsName.argtypes = [
		ctypes.POINTER(BNSaveSettings),
	]


# noinspection PyPep8Naming
def BNGetSaveSettingsName(
		settings: ctypes.POINTER(BNSaveSettings)
		) -> Optional[Optional[str]]:
	result = _BNGetSaveSettingsName(settings)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetScriptingInstanceDelimiters

_BNGetScriptingInstanceDelimiters = core.BNGetScriptingInstanceDelimiters
_BNGetScriptingInstanceDelimiters.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetScriptingInstanceDelimiters.argtypes = [
		ctypes.POINTER(BNScriptingInstance),
	]


# noinspection PyPep8Naming
def BNGetScriptingInstanceDelimiters(
		instance: ctypes.POINTER(BNScriptingInstance)
		) -> Optional[Optional[str]]:
	result = _BNGetScriptingInstanceDelimiters(instance)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetScriptingInstanceInputReadyState

_BNGetScriptingInstanceInputReadyState = core.BNGetScriptingInstanceInputReadyState
_BNGetScriptingInstanceInputReadyState.restype = ScriptingProviderInputReadyStateEnum
_BNGetScriptingInstanceInputReadyState.argtypes = [
		ctypes.POINTER(BNScriptingInstance),
	]


# noinspection PyPep8Naming
def BNGetScriptingInstanceInputReadyState(
		instance: ctypes.POINTER(BNScriptingInstance)
		) -> ScriptingProviderInputReadyState:
	return _BNGetScriptingInstanceInputReadyState(instance)


# -------------------------------------------------------
# _BNGetScriptingProviderAPIName

_BNGetScriptingProviderAPIName = core.BNGetScriptingProviderAPIName
_BNGetScriptingProviderAPIName.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetScriptingProviderAPIName.argtypes = [
		ctypes.POINTER(BNScriptingProvider),
	]


# noinspection PyPep8Naming
def BNGetScriptingProviderAPIName(
		provider: ctypes.POINTER(BNScriptingProvider)
		) -> Optional[Optional[str]]:
	result = _BNGetScriptingProviderAPIName(provider)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetScriptingProviderByAPIName

_BNGetScriptingProviderByAPIName = core.BNGetScriptingProviderByAPIName
_BNGetScriptingProviderByAPIName.restype = ctypes.POINTER(BNScriptingProvider)
_BNGetScriptingProviderByAPIName.argtypes = [
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNGetScriptingProviderByAPIName(
		name: Optional[str]
		) -> Optional[ctypes.POINTER(BNScriptingProvider)]:
	result = _BNGetScriptingProviderByAPIName(cstr(name))
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetScriptingProviderByName

_BNGetScriptingProviderByName = core.BNGetScriptingProviderByName
_BNGetScriptingProviderByName.restype = ctypes.POINTER(BNScriptingProvider)
_BNGetScriptingProviderByName.argtypes = [
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNGetScriptingProviderByName(
		name: Optional[str]
		) -> Optional[ctypes.POINTER(BNScriptingProvider)]:
	result = _BNGetScriptingProviderByName(cstr(name))
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetScriptingProviderList

_BNGetScriptingProviderList = core.BNGetScriptingProviderList
_BNGetScriptingProviderList.restype = ctypes.POINTER(ctypes.POINTER(BNScriptingProvider))
_BNGetScriptingProviderList.argtypes = [
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetScriptingProviderList(
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.POINTER(BNScriptingProvider))]:
	result = _BNGetScriptingProviderList(count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetScriptingProviderName

_BNGetScriptingProviderName = core.BNGetScriptingProviderName
_BNGetScriptingProviderName.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetScriptingProviderName.argtypes = [
		ctypes.POINTER(BNScriptingProvider),
	]


# noinspection PyPep8Naming
def BNGetScriptingProviderName(
		provider: ctypes.POINTER(BNScriptingProvider)
		) -> Optional[Optional[str]]:
	result = _BNGetScriptingProviderName(provider)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetSecretsProviderByName

_BNGetSecretsProviderByName = core.BNGetSecretsProviderByName
_BNGetSecretsProviderByName.restype = ctypes.POINTER(BNSecretsProvider)
_BNGetSecretsProviderByName.argtypes = [
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNGetSecretsProviderByName(
		name: Optional[str]
		) -> Optional[ctypes.POINTER(BNSecretsProvider)]:
	result = _BNGetSecretsProviderByName(cstr(name))
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetSecretsProviderData

_BNGetSecretsProviderData = core.BNGetSecretsProviderData
_BNGetSecretsProviderData.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetSecretsProviderData.argtypes = [
		ctypes.POINTER(BNSecretsProvider),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNGetSecretsProviderData(
		provider: ctypes.POINTER(BNSecretsProvider), 
		key: Optional[str]
		) -> Optional[Optional[str]]:
	result = _BNGetSecretsProviderData(provider, cstr(key))
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetSecretsProviderList

_BNGetSecretsProviderList = core.BNGetSecretsProviderList
_BNGetSecretsProviderList.restype = ctypes.POINTER(ctypes.POINTER(BNSecretsProvider))
_BNGetSecretsProviderList.argtypes = [
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetSecretsProviderList(
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.POINTER(BNSecretsProvider))]:
	result = _BNGetSecretsProviderList(count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetSecretsProviderName

_BNGetSecretsProviderName = core.BNGetSecretsProviderName
_BNGetSecretsProviderName.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetSecretsProviderName.argtypes = [
		ctypes.POINTER(BNSecretsProvider),
	]


# noinspection PyPep8Naming
def BNGetSecretsProviderName(
		provider: ctypes.POINTER(BNSecretsProvider)
		) -> Optional[Optional[str]]:
	result = _BNGetSecretsProviderName(provider)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetSectionByName

_BNGetSectionByName = core.BNGetSectionByName
_BNGetSectionByName.restype = ctypes.POINTER(BNSection)
_BNGetSectionByName.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNGetSectionByName(
		view: ctypes.POINTER(BNBinaryView), 
		name: Optional[str]
		) -> Optional[ctypes.POINTER(BNSection)]:
	result = _BNGetSectionByName(view, cstr(name))
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetSections

_BNGetSections = core.BNGetSections
_BNGetSections.restype = ctypes.POINTER(ctypes.POINTER(BNSection))
_BNGetSections.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetSections(
		view: ctypes.POINTER(BNBinaryView), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.POINTER(BNSection))]:
	result = _BNGetSections(view, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetSectionsAt

_BNGetSectionsAt = core.BNGetSectionsAt
_BNGetSectionsAt.restype = ctypes.POINTER(ctypes.POINTER(BNSection))
_BNGetSectionsAt.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetSectionsAt(
		view: ctypes.POINTER(BNBinaryView), 
		addr: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.POINTER(BNSection))]:
	result = _BNGetSectionsAt(view, addr, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetSegmentAt

_BNGetSegmentAt = core.BNGetSegmentAt
_BNGetSegmentAt.restype = ctypes.POINTER(BNSegment)
_BNGetSegmentAt.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetSegmentAt(
		view: ctypes.POINTER(BNBinaryView), 
		addr: int
		) -> Optional[ctypes.POINTER(BNSegment)]:
	result = _BNGetSegmentAt(view, addr)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetSegments

_BNGetSegments = core.BNGetSegments
_BNGetSegments.restype = ctypes.POINTER(ctypes.POINTER(BNSegment))
_BNGetSegments.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetSegments(
		view: ctypes.POINTER(BNBinaryView), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.POINTER(BNSegment))]:
	result = _BNGetSegments(view, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetSerialNumber

_BNGetSerialNumber = core.BNGetSerialNumber
_BNGetSerialNumber.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetSerialNumber.argtypes = [
	]


# noinspection PyPep8Naming
def BNGetSerialNumber(
		) -> Optional[Optional[str]]:
	result = _BNGetSerialNumber()
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetSettingsFileName

_BNGetSettingsFileName = core.BNGetSettingsFileName
_BNGetSettingsFileName.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetSettingsFileName.argtypes = [
	]


# noinspection PyPep8Naming
def BNGetSettingsFileName(
		) -> Optional[Optional[str]]:
	result = _BNGetSettingsFileName()
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetSizesReferenced

_BNGetSizesReferenced = core.BNGetSizesReferenced
_BNGetSizesReferenced.restype = ctypes.POINTER(ctypes.c_ulonglong)
_BNGetSizesReferenced.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNQualifiedName),
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetSizesReferenced(
		view: ctypes.POINTER(BNBinaryView), 
		type: ctypes.POINTER(BNQualifiedName), 
		offset: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_ulonglong)]:
	result = _BNGetSizesReferenced(view, type, offset, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetSnapshotChildren

_BNGetSnapshotChildren = core.BNGetSnapshotChildren
_BNGetSnapshotChildren.restype = ctypes.POINTER(ctypes.POINTER(BNSnapshot))
_BNGetSnapshotChildren.argtypes = [
		ctypes.POINTER(BNSnapshot),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetSnapshotChildren(
		snapshot: ctypes.POINTER(BNSnapshot), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.POINTER(BNSnapshot))]:
	result = _BNGetSnapshotChildren(snapshot, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetSnapshotData

_BNGetSnapshotData = core.BNGetSnapshotData
_BNGetSnapshotData.restype = None
_BNGetSnapshotData.argtypes = [
		ctypes.POINTER(BNFileMetadata),
		ctypes.POINTER(BNKeyValueStore),
		ctypes.POINTER(BNKeyValueStore),
		ctypes.c_void_p,
		ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetSnapshotData(
		file: ctypes.POINTER(BNFileMetadata), 
		data: ctypes.POINTER(BNKeyValueStore), 
		cache: ctypes.POINTER(BNKeyValueStore), 
		ctxt: Optional[ctypes.c_void_p], 
		progress: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong)
		) -> None:
	return _BNGetSnapshotData(file, data, cache, ctxt, progress)


# -------------------------------------------------------
# _BNGetSnapshotDatabase

_BNGetSnapshotDatabase = core.BNGetSnapshotDatabase
_BNGetSnapshotDatabase.restype = ctypes.POINTER(BNDatabase)
_BNGetSnapshotDatabase.argtypes = [
		ctypes.POINTER(BNSnapshot),
	]


# noinspection PyPep8Naming
def BNGetSnapshotDatabase(
		snapshot: ctypes.POINTER(BNSnapshot)
		) -> Optional[ctypes.POINTER(BNDatabase)]:
	result = _BNGetSnapshotDatabase(snapshot)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetSnapshotFileContents

_BNGetSnapshotFileContents = core.BNGetSnapshotFileContents
_BNGetSnapshotFileContents.restype = ctypes.POINTER(BNDataBuffer)
_BNGetSnapshotFileContents.argtypes = [
		ctypes.POINTER(BNSnapshot),
	]


# noinspection PyPep8Naming
def BNGetSnapshotFileContents(
		snapshot: ctypes.POINTER(BNSnapshot)
		) -> Optional[ctypes.POINTER(BNDataBuffer)]:
	result = _BNGetSnapshotFileContents(snapshot)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetSnapshotFileContentsHash

_BNGetSnapshotFileContentsHash = core.BNGetSnapshotFileContentsHash
_BNGetSnapshotFileContentsHash.restype = ctypes.POINTER(BNDataBuffer)
_BNGetSnapshotFileContentsHash.argtypes = [
		ctypes.POINTER(BNSnapshot),
	]


# noinspection PyPep8Naming
def BNGetSnapshotFileContentsHash(
		snapshot: ctypes.POINTER(BNSnapshot)
		) -> Optional[ctypes.POINTER(BNDataBuffer)]:
	result = _BNGetSnapshotFileContentsHash(snapshot)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetSnapshotFirstParent

_BNGetSnapshotFirstParent = core.BNGetSnapshotFirstParent
_BNGetSnapshotFirstParent.restype = ctypes.POINTER(BNSnapshot)
_BNGetSnapshotFirstParent.argtypes = [
		ctypes.POINTER(BNSnapshot),
	]


# noinspection PyPep8Naming
def BNGetSnapshotFirstParent(
		snapshot: ctypes.POINTER(BNSnapshot)
		) -> Optional[ctypes.POINTER(BNSnapshot)]:
	result = _BNGetSnapshotFirstParent(snapshot)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetSnapshotId

_BNGetSnapshotId = core.BNGetSnapshotId
_BNGetSnapshotId.restype = ctypes.c_longlong
_BNGetSnapshotId.argtypes = [
		ctypes.POINTER(BNSnapshot),
	]


# noinspection PyPep8Naming
def BNGetSnapshotId(
		snapshot: ctypes.POINTER(BNSnapshot)
		) -> int:
	return _BNGetSnapshotId(snapshot)


# -------------------------------------------------------
# _BNGetSnapshotName

_BNGetSnapshotName = core.BNGetSnapshotName
_BNGetSnapshotName.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetSnapshotName.argtypes = [
		ctypes.POINTER(BNSnapshot),
	]


# noinspection PyPep8Naming
def BNGetSnapshotName(
		snapshot: ctypes.POINTER(BNSnapshot)
		) -> Optional[Optional[str]]:
	result = _BNGetSnapshotName(snapshot)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetSnapshotParents

_BNGetSnapshotParents = core.BNGetSnapshotParents
_BNGetSnapshotParents.restype = ctypes.POINTER(ctypes.POINTER(BNSnapshot))
_BNGetSnapshotParents.argtypes = [
		ctypes.POINTER(BNSnapshot),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetSnapshotParents(
		snapshot: ctypes.POINTER(BNSnapshot), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.POINTER(BNSnapshot))]:
	result = _BNGetSnapshotParents(snapshot, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetSnapshotUndoData

_BNGetSnapshotUndoData = core.BNGetSnapshotUndoData
_BNGetSnapshotUndoData.restype = ctypes.POINTER(BNDataBuffer)
_BNGetSnapshotUndoData.argtypes = [
		ctypes.POINTER(BNSnapshot),
	]


# noinspection PyPep8Naming
def BNGetSnapshotUndoData(
		snapshot: ctypes.POINTER(BNSnapshot)
		) -> Optional[ctypes.POINTER(BNDataBuffer)]:
	result = _BNGetSnapshotUndoData(snapshot)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetSnapshotUndoEntries

_BNGetSnapshotUndoEntries = core.BNGetSnapshotUndoEntries
_BNGetSnapshotUndoEntries.restype = ctypes.POINTER(BNUndoEntry)
_BNGetSnapshotUndoEntries.argtypes = [
		ctypes.POINTER(BNSnapshot),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetSnapshotUndoEntries(
		snapshot: ctypes.POINTER(BNSnapshot), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNUndoEntry)]:
	result = _BNGetSnapshotUndoEntries(snapshot, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetSnapshotUndoEntriesWithProgress

_BNGetSnapshotUndoEntriesWithProgress = core.BNGetSnapshotUndoEntriesWithProgress
_BNGetSnapshotUndoEntriesWithProgress.restype = ctypes.POINTER(BNUndoEntry)
_BNGetSnapshotUndoEntriesWithProgress.argtypes = [
		ctypes.POINTER(BNSnapshot),
		ctypes.c_void_p,
		ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetSnapshotUndoEntriesWithProgress(
		snapshot: ctypes.POINTER(BNSnapshot), 
		ctxt: Optional[ctypes.c_void_p], 
		progress: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNUndoEntry)]:
	result = _BNGetSnapshotUndoEntriesWithProgress(snapshot, ctxt, progress, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetSplitVariables

_BNGetSplitVariables = core.BNGetSplitVariables
_BNGetSplitVariables.restype = ctypes.POINTER(BNVariable)
_BNGetSplitVariables.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetSplitVariables(
		func: ctypes.POINTER(BNFunction), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNVariable)]:
	result = _BNGetSplitVariables(func, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetStackAdjustmentForVariables

_BNGetStackAdjustmentForVariables = core.BNGetStackAdjustmentForVariables
_BNGetStackAdjustmentForVariables.restype = ctypes.c_longlong
_BNGetStackAdjustmentForVariables.argtypes = [
		ctypes.POINTER(BNCallingConvention),
		ctypes.POINTER(BNVariable),
		ctypes.POINTER(ctypes.POINTER(BNType)),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetStackAdjustmentForVariables(
		cc: ctypes.POINTER(BNCallingConvention), 
		paramVars: ctypes.POINTER(BNVariable), 
		paramTypes: ctypes.POINTER(ctypes.POINTER(BNType)), 
		paramCount: int
		) -> int:
	return _BNGetStackAdjustmentForVariables(cc, paramVars, paramTypes, paramCount)


# -------------------------------------------------------
# _BNGetStackContentsAfterInstruction

_BNGetStackContentsAfterInstruction = core.BNGetStackContentsAfterInstruction
_BNGetStackContentsAfterInstruction.restype = BNRegisterValue
_BNGetStackContentsAfterInstruction.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNArchitecture),
		ctypes.c_ulonglong,
		ctypes.c_longlong,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetStackContentsAfterInstruction(
		func: ctypes.POINTER(BNFunction), 
		arch: ctypes.POINTER(BNArchitecture), 
		addr: int, 
		offset: int, 
		size: int
		) -> BNRegisterValue:
	return _BNGetStackContentsAfterInstruction(func, arch, addr, offset, size)


# -------------------------------------------------------
# _BNGetStackContentsAtInstruction

_BNGetStackContentsAtInstruction = core.BNGetStackContentsAtInstruction
_BNGetStackContentsAtInstruction.restype = BNRegisterValue
_BNGetStackContentsAtInstruction.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNArchitecture),
		ctypes.c_ulonglong,
		ctypes.c_longlong,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetStackContentsAtInstruction(
		func: ctypes.POINTER(BNFunction), 
		arch: ctypes.POINTER(BNArchitecture), 
		addr: int, 
		offset: int, 
		size: int
		) -> BNRegisterValue:
	return _BNGetStackContentsAtInstruction(func, arch, addr, offset, size)


# -------------------------------------------------------
# _BNGetStackLayout

_BNGetStackLayout = core.BNGetStackLayout
_BNGetStackLayout.restype = ctypes.POINTER(BNVariableNameAndType)
_BNGetStackLayout.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetStackLayout(
		func: ctypes.POINTER(BNFunction), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNVariableNameAndType)]:
	result = _BNGetStackLayout(func, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetStackVariableAtFrameOffset

_BNGetStackVariableAtFrameOffset = core.BNGetStackVariableAtFrameOffset
_BNGetStackVariableAtFrameOffset.restype = ctypes.c_bool
_BNGetStackVariableAtFrameOffset.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNArchitecture),
		ctypes.c_ulonglong,
		ctypes.c_longlong,
		ctypes.POINTER(BNVariableNameAndType),
	]


# noinspection PyPep8Naming
def BNGetStackVariableAtFrameOffset(
		func: ctypes.POINTER(BNFunction), 
		arch: ctypes.POINTER(BNArchitecture), 
		addr: int, 
		offset: int, 
		var: ctypes.POINTER(BNVariableNameAndType)
		) -> bool:
	return _BNGetStackVariableAtFrameOffset(func, arch, addr, offset, var)


# -------------------------------------------------------
# _BNGetStackVariablesReferencedByInstruction

_BNGetStackVariablesReferencedByInstruction = core.BNGetStackVariablesReferencedByInstruction
_BNGetStackVariablesReferencedByInstruction.restype = ctypes.POINTER(BNStackVariableReference)
_BNGetStackVariablesReferencedByInstruction.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNArchitecture),
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetStackVariablesReferencedByInstruction(
		func: ctypes.POINTER(BNFunction), 
		arch: ctypes.POINTER(BNArchitecture), 
		addr: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNStackVariableReference)]:
	result = _BNGetStackVariablesReferencedByInstruction(func, arch, addr, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetStackVariablesReferencedByInstructionIfAvailable

_BNGetStackVariablesReferencedByInstructionIfAvailable = core.BNGetStackVariablesReferencedByInstructionIfAvailable
_BNGetStackVariablesReferencedByInstructionIfAvailable.restype = ctypes.POINTER(BNStackVariableReference)
_BNGetStackVariablesReferencedByInstructionIfAvailable.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNArchitecture),
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetStackVariablesReferencedByInstructionIfAvailable(
		func: ctypes.POINTER(BNFunction), 
		arch: ctypes.POINTER(BNArchitecture), 
		addr: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNStackVariableReference)]:
	result = _BNGetStackVariablesReferencedByInstructionIfAvailable(func, arch, addr, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetStartOffset

_BNGetStartOffset = core.BNGetStartOffset
_BNGetStartOffset.restype = ctypes.c_ulonglong
_BNGetStartOffset.argtypes = [
		ctypes.POINTER(BNBinaryView),
	]


# noinspection PyPep8Naming
def BNGetStartOffset(
		view: ctypes.POINTER(BNBinaryView)
		) -> int:
	return _BNGetStartOffset(view)


# -------------------------------------------------------
# _BNGetStringAtAddress

_BNGetStringAtAddress = core.BNGetStringAtAddress
_BNGetStringAtAddress.restype = ctypes.c_bool
_BNGetStringAtAddress.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
		ctypes.POINTER(BNStringReference),
	]


# noinspection PyPep8Naming
def BNGetStringAtAddress(
		view: ctypes.POINTER(BNBinaryView), 
		addr: int, 
		strRef: ctypes.POINTER(BNStringReference)
		) -> bool:
	return _BNGetStringAtAddress(view, addr, strRef)


# -------------------------------------------------------
# _BNGetStrings

_BNGetStrings = core.BNGetStrings
_BNGetStrings.restype = ctypes.POINTER(BNStringReference)
_BNGetStrings.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetStrings(
		view: ctypes.POINTER(BNBinaryView), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNStringReference)]:
	result = _BNGetStrings(view, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetStringsInRange

_BNGetStringsInRange = core.BNGetStringsInRange
_BNGetStringsInRange.restype = ctypes.POINTER(BNStringReference)
_BNGetStringsInRange.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetStringsInRange(
		view: ctypes.POINTER(BNBinaryView), 
		start: int, 
		len: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNStringReference)]:
	result = _BNGetStringsInRange(view, start, len, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetStructureAlignment

_BNGetStructureAlignment = core.BNGetStructureAlignment
_BNGetStructureAlignment.restype = ctypes.c_ulonglong
_BNGetStructureAlignment.argtypes = [
		ctypes.POINTER(BNStructure),
	]


# noinspection PyPep8Naming
def BNGetStructureAlignment(
		s: ctypes.POINTER(BNStructure)
		) -> int:
	return _BNGetStructureAlignment(s)


# -------------------------------------------------------
# _BNGetStructureBuilderAlignment

_BNGetStructureBuilderAlignment = core.BNGetStructureBuilderAlignment
_BNGetStructureBuilderAlignment.restype = ctypes.c_ulonglong
_BNGetStructureBuilderAlignment.argtypes = [
		ctypes.POINTER(BNStructureBuilder),
	]


# noinspection PyPep8Naming
def BNGetStructureBuilderAlignment(
		s: ctypes.POINTER(BNStructureBuilder)
		) -> int:
	return _BNGetStructureBuilderAlignment(s)


# -------------------------------------------------------
# _BNGetStructureBuilderMemberAtOffset

_BNGetStructureBuilderMemberAtOffset = core.BNGetStructureBuilderMemberAtOffset
_BNGetStructureBuilderMemberAtOffset.restype = ctypes.POINTER(BNStructureMember)
_BNGetStructureBuilderMemberAtOffset.argtypes = [
		ctypes.POINTER(BNStructureBuilder),
		ctypes.c_longlong,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetStructureBuilderMemberAtOffset(
		s: ctypes.POINTER(BNStructureBuilder), 
		offset: int, 
		idx: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNStructureMember)]:
	result = _BNGetStructureBuilderMemberAtOffset(s, offset, idx)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetStructureBuilderMemberByName

_BNGetStructureBuilderMemberByName = core.BNGetStructureBuilderMemberByName
_BNGetStructureBuilderMemberByName.restype = ctypes.POINTER(BNStructureMember)
_BNGetStructureBuilderMemberByName.argtypes = [
		ctypes.POINTER(BNStructureBuilder),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNGetStructureBuilderMemberByName(
		s: ctypes.POINTER(BNStructureBuilder), 
		name: Optional[str]
		) -> Optional[ctypes.POINTER(BNStructureMember)]:
	result = _BNGetStructureBuilderMemberByName(s, cstr(name))
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetStructureBuilderMembers

_BNGetStructureBuilderMembers = core.BNGetStructureBuilderMembers
_BNGetStructureBuilderMembers.restype = ctypes.POINTER(BNStructureMember)
_BNGetStructureBuilderMembers.argtypes = [
		ctypes.POINTER(BNStructureBuilder),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetStructureBuilderMembers(
		s: ctypes.POINTER(BNStructureBuilder), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNStructureMember)]:
	result = _BNGetStructureBuilderMembers(s, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetStructureBuilderPointerOffset

_BNGetStructureBuilderPointerOffset = core.BNGetStructureBuilderPointerOffset
_BNGetStructureBuilderPointerOffset.restype = ctypes.c_longlong
_BNGetStructureBuilderPointerOffset.argtypes = [
		ctypes.POINTER(BNStructureBuilder),
	]


# noinspection PyPep8Naming
def BNGetStructureBuilderPointerOffset(
		s: ctypes.POINTER(BNStructureBuilder)
		) -> int:
	return _BNGetStructureBuilderPointerOffset(s)


# -------------------------------------------------------
# _BNGetStructureBuilderType

_BNGetStructureBuilderType = core.BNGetStructureBuilderType
_BNGetStructureBuilderType.restype = StructureVariantEnum
_BNGetStructureBuilderType.argtypes = [
		ctypes.POINTER(BNStructureBuilder),
	]


# noinspection PyPep8Naming
def BNGetStructureBuilderType(
		s: ctypes.POINTER(BNStructureBuilder)
		) -> StructureVariant:
	return _BNGetStructureBuilderType(s)


# -------------------------------------------------------
# _BNGetStructureBuilderWidth

_BNGetStructureBuilderWidth = core.BNGetStructureBuilderWidth
_BNGetStructureBuilderWidth.restype = ctypes.c_ulonglong
_BNGetStructureBuilderWidth.argtypes = [
		ctypes.POINTER(BNStructureBuilder),
	]


# noinspection PyPep8Naming
def BNGetStructureBuilderWidth(
		s: ctypes.POINTER(BNStructureBuilder)
		) -> int:
	return _BNGetStructureBuilderWidth(s)


# -------------------------------------------------------
# _BNGetStructureMemberAtOffset

_BNGetStructureMemberAtOffset = core.BNGetStructureMemberAtOffset
_BNGetStructureMemberAtOffset.restype = ctypes.POINTER(BNStructureMember)
_BNGetStructureMemberAtOffset.argtypes = [
		ctypes.POINTER(BNStructure),
		ctypes.c_longlong,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetStructureMemberAtOffset(
		s: ctypes.POINTER(BNStructure), 
		offset: int, 
		idx: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNStructureMember)]:
	result = _BNGetStructureMemberAtOffset(s, offset, idx)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetStructureMemberByName

_BNGetStructureMemberByName = core.BNGetStructureMemberByName
_BNGetStructureMemberByName.restype = ctypes.POINTER(BNStructureMember)
_BNGetStructureMemberByName.argtypes = [
		ctypes.POINTER(BNStructure),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNGetStructureMemberByName(
		s: ctypes.POINTER(BNStructure), 
		name: Optional[str]
		) -> Optional[ctypes.POINTER(BNStructureMember)]:
	result = _BNGetStructureMemberByName(s, cstr(name))
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetStructureMembers

_BNGetStructureMembers = core.BNGetStructureMembers
_BNGetStructureMembers.restype = ctypes.POINTER(BNStructureMember)
_BNGetStructureMembers.argtypes = [
		ctypes.POINTER(BNStructure),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetStructureMembers(
		s: ctypes.POINTER(BNStructure), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNStructureMember)]:
	result = _BNGetStructureMembers(s, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetStructureMembersIncludingInherited

_BNGetStructureMembersIncludingInherited = core.BNGetStructureMembersIncludingInherited
_BNGetStructureMembersIncludingInherited.restype = ctypes.POINTER(BNInheritedStructureMember)
_BNGetStructureMembersIncludingInherited.argtypes = [
		ctypes.POINTER(BNStructure),
		ctypes.POINTER(BNTypeContainer),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetStructureMembersIncludingInherited(
		s: ctypes.POINTER(BNStructure), 
		types: ctypes.POINTER(BNTypeContainer), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNInheritedStructureMember)]:
	result = _BNGetStructureMembersIncludingInherited(s, types, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetStructurePointerOffset

_BNGetStructurePointerOffset = core.BNGetStructurePointerOffset
_BNGetStructurePointerOffset.restype = ctypes.c_longlong
_BNGetStructurePointerOffset.argtypes = [
		ctypes.POINTER(BNStructure),
	]


# noinspection PyPep8Naming
def BNGetStructurePointerOffset(
		s: ctypes.POINTER(BNStructure)
		) -> int:
	return _BNGetStructurePointerOffset(s)


# -------------------------------------------------------
# _BNGetStructureType

_BNGetStructureType = core.BNGetStructureType
_BNGetStructureType.restype = StructureVariantEnum
_BNGetStructureType.argtypes = [
		ctypes.POINTER(BNStructure),
	]


# noinspection PyPep8Naming
def BNGetStructureType(
		s: ctypes.POINTER(BNStructure)
		) -> StructureVariant:
	return _BNGetStructureType(s)


# -------------------------------------------------------
# _BNGetStructureWidth

_BNGetStructureWidth = core.BNGetStructureWidth
_BNGetStructureWidth.restype = ctypes.c_ulonglong
_BNGetStructureWidth.argtypes = [
		ctypes.POINTER(BNStructure),
	]


# noinspection PyPep8Naming
def BNGetStructureWidth(
		s: ctypes.POINTER(BNStructure)
		) -> int:
	return _BNGetStructureWidth(s)


# -------------------------------------------------------
# _BNGetSymbolAddress

_BNGetSymbolAddress = core.BNGetSymbolAddress
_BNGetSymbolAddress.restype = ctypes.c_ulonglong
_BNGetSymbolAddress.argtypes = [
		ctypes.POINTER(BNSymbol),
	]


# noinspection PyPep8Naming
def BNGetSymbolAddress(
		sym: ctypes.POINTER(BNSymbol)
		) -> int:
	return _BNGetSymbolAddress(sym)


# -------------------------------------------------------
# _BNGetSymbolBinding

_BNGetSymbolBinding = core.BNGetSymbolBinding
_BNGetSymbolBinding.restype = SymbolBindingEnum
_BNGetSymbolBinding.argtypes = [
		ctypes.POINTER(BNSymbol),
	]


# noinspection PyPep8Naming
def BNGetSymbolBinding(
		sym: ctypes.POINTER(BNSymbol)
		) -> SymbolBinding:
	return _BNGetSymbolBinding(sym)


# -------------------------------------------------------
# _BNGetSymbolByAddress

_BNGetSymbolByAddress = core.BNGetSymbolByAddress
_BNGetSymbolByAddress.restype = ctypes.POINTER(BNSymbol)
_BNGetSymbolByAddress.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
		ctypes.POINTER(BNNameSpace),
	]


# noinspection PyPep8Naming
def BNGetSymbolByAddress(
		view: ctypes.POINTER(BNBinaryView), 
		addr: int, 
		nameSpace: ctypes.POINTER(BNNameSpace)
		) -> Optional[ctypes.POINTER(BNSymbol)]:
	result = _BNGetSymbolByAddress(view, addr, nameSpace)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetSymbolByRawName

_BNGetSymbolByRawName = core.BNGetSymbolByRawName
_BNGetSymbolByRawName.restype = ctypes.POINTER(BNSymbol)
_BNGetSymbolByRawName.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_char_p,
		ctypes.POINTER(BNNameSpace),
	]


# noinspection PyPep8Naming
def BNGetSymbolByRawName(
		view: ctypes.POINTER(BNBinaryView), 
		name: Optional[str], 
		nameSpace: ctypes.POINTER(BNNameSpace)
		) -> Optional[ctypes.POINTER(BNSymbol)]:
	result = _BNGetSymbolByRawName(view, cstr(name), nameSpace)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetSymbolFullName

_BNGetSymbolFullName = core.BNGetSymbolFullName
_BNGetSymbolFullName.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetSymbolFullName.argtypes = [
		ctypes.POINTER(BNSymbol),
	]


# noinspection PyPep8Naming
def BNGetSymbolFullName(
		sym: ctypes.POINTER(BNSymbol)
		) -> Optional[Optional[str]]:
	result = _BNGetSymbolFullName(sym)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetSymbolNameSpace

_BNGetSymbolNameSpace = core.BNGetSymbolNameSpace
_BNGetSymbolNameSpace.restype = BNNameSpace
_BNGetSymbolNameSpace.argtypes = [
		ctypes.POINTER(BNSymbol),
	]


# noinspection PyPep8Naming
def BNGetSymbolNameSpace(
		sym: ctypes.POINTER(BNSymbol)
		) -> BNNameSpace:
	return _BNGetSymbolNameSpace(sym)


# -------------------------------------------------------
# _BNGetSymbolOrdinal

_BNGetSymbolOrdinal = core.BNGetSymbolOrdinal
_BNGetSymbolOrdinal.restype = ctypes.c_ulonglong
_BNGetSymbolOrdinal.argtypes = [
		ctypes.POINTER(BNSymbol),
	]


# noinspection PyPep8Naming
def BNGetSymbolOrdinal(
		sym: ctypes.POINTER(BNSymbol)
		) -> int:
	return _BNGetSymbolOrdinal(sym)


# -------------------------------------------------------
# _BNGetSymbolRawBytes

_BNGetSymbolRawBytes = core.BNGetSymbolRawBytes
_BNGetSymbolRawBytes.restype = ctypes.c_void_p
_BNGetSymbolRawBytes.argtypes = [
		ctypes.POINTER(BNSymbol),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetSymbolRawBytes(
		sym: ctypes.POINTER(BNSymbol), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[Optional[ctypes.c_void_p]]:
	result = _BNGetSymbolRawBytes(sym, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetSymbolRawName

_BNGetSymbolRawName = core.BNGetSymbolRawName
_BNGetSymbolRawName.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetSymbolRawName.argtypes = [
		ctypes.POINTER(BNSymbol),
	]


# noinspection PyPep8Naming
def BNGetSymbolRawName(
		sym: ctypes.POINTER(BNSymbol)
		) -> Optional[Optional[str]]:
	result = _BNGetSymbolRawName(sym)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetSymbolShortName

_BNGetSymbolShortName = core.BNGetSymbolShortName
_BNGetSymbolShortName.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetSymbolShortName.argtypes = [
		ctypes.POINTER(BNSymbol),
	]


# noinspection PyPep8Naming
def BNGetSymbolShortName(
		sym: ctypes.POINTER(BNSymbol)
		) -> Optional[Optional[str]]:
	result = _BNGetSymbolShortName(sym)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetSymbolType

_BNGetSymbolType = core.BNGetSymbolType
_BNGetSymbolType.restype = SymbolTypeEnum
_BNGetSymbolType.argtypes = [
		ctypes.POINTER(BNSymbol),
	]


# noinspection PyPep8Naming
def BNGetSymbolType(
		sym: ctypes.POINTER(BNSymbol)
		) -> SymbolType:
	return _BNGetSymbolType(sym)


# -------------------------------------------------------
# _BNGetSymbols

_BNGetSymbols = core.BNGetSymbols
_BNGetSymbols.restype = ctypes.POINTER(ctypes.POINTER(BNSymbol))
_BNGetSymbols.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(ctypes.c_ulonglong),
		ctypes.POINTER(BNNameSpace),
	]


# noinspection PyPep8Naming
def BNGetSymbols(
		view: ctypes.POINTER(BNBinaryView), 
		count: ctypes.POINTER(ctypes.c_ulonglong), 
		nameSpace: ctypes.POINTER(BNNameSpace)
		) -> Optional[ctypes.POINTER(ctypes.POINTER(BNSymbol))]:
	result = _BNGetSymbols(view, count, nameSpace)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetSymbolsByName

_BNGetSymbolsByName = core.BNGetSymbolsByName
_BNGetSymbolsByName.restype = ctypes.POINTER(ctypes.POINTER(BNSymbol))
_BNGetSymbolsByName.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_char_p,
		ctypes.POINTER(ctypes.c_ulonglong),
		ctypes.POINTER(BNNameSpace),
	]


# noinspection PyPep8Naming
def BNGetSymbolsByName(
		view: ctypes.POINTER(BNBinaryView), 
		name: Optional[str], 
		count: ctypes.POINTER(ctypes.c_ulonglong), 
		nameSpace: ctypes.POINTER(BNNameSpace)
		) -> Optional[ctypes.POINTER(ctypes.POINTER(BNSymbol))]:
	result = _BNGetSymbolsByName(view, cstr(name), count, nameSpace)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetSymbolsByRawName

_BNGetSymbolsByRawName = core.BNGetSymbolsByRawName
_BNGetSymbolsByRawName.restype = ctypes.POINTER(ctypes.POINTER(BNSymbol))
_BNGetSymbolsByRawName.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_char_p,
		ctypes.POINTER(ctypes.c_ulonglong),
		ctypes.POINTER(BNNameSpace),
	]


# noinspection PyPep8Naming
def BNGetSymbolsByRawName(
		view: ctypes.POINTER(BNBinaryView), 
		name: Optional[str], 
		count: ctypes.POINTER(ctypes.c_ulonglong), 
		nameSpace: ctypes.POINTER(BNNameSpace)
		) -> Optional[ctypes.POINTER(ctypes.POINTER(BNSymbol))]:
	result = _BNGetSymbolsByRawName(view, cstr(name), count, nameSpace)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetSymbolsInRange

_BNGetSymbolsInRange = core.BNGetSymbolsInRange
_BNGetSymbolsInRange.restype = ctypes.POINTER(ctypes.POINTER(BNSymbol))
_BNGetSymbolsInRange.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
		ctypes.POINTER(BNNameSpace),
	]


# noinspection PyPep8Naming
def BNGetSymbolsInRange(
		view: ctypes.POINTER(BNBinaryView), 
		start: int, 
		len: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong), 
		nameSpace: ctypes.POINTER(BNNameSpace)
		) -> Optional[ctypes.POINTER(ctypes.POINTER(BNSymbol))]:
	result = _BNGetSymbolsInRange(view, start, len, count, nameSpace)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetSymbolsOfType

_BNGetSymbolsOfType = core.BNGetSymbolsOfType
_BNGetSymbolsOfType.restype = ctypes.POINTER(ctypes.POINTER(BNSymbol))
_BNGetSymbolsOfType.argtypes = [
		ctypes.POINTER(BNBinaryView),
		SymbolTypeEnum,
		ctypes.POINTER(ctypes.c_ulonglong),
		ctypes.POINTER(BNNameSpace),
	]


# noinspection PyPep8Naming
def BNGetSymbolsOfType(
		view: ctypes.POINTER(BNBinaryView), 
		type: SymbolType, 
		count: ctypes.POINTER(ctypes.c_ulonglong), 
		nameSpace: ctypes.POINTER(BNNameSpace)
		) -> Optional[ctypes.POINTER(ctypes.POINTER(BNSymbol))]:
	result = _BNGetSymbolsOfType(view, type, count, nameSpace)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetSymbolsOfTypeInRange

_BNGetSymbolsOfTypeInRange = core.BNGetSymbolsOfTypeInRange
_BNGetSymbolsOfTypeInRange.restype = ctypes.POINTER(ctypes.POINTER(BNSymbol))
_BNGetSymbolsOfTypeInRange.argtypes = [
		ctypes.POINTER(BNBinaryView),
		SymbolTypeEnum,
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
		ctypes.POINTER(BNNameSpace),
	]


# noinspection PyPep8Naming
def BNGetSymbolsOfTypeInRange(
		view: ctypes.POINTER(BNBinaryView), 
		type: SymbolType, 
		start: int, 
		len: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong), 
		nameSpace: ctypes.POINTER(BNNameSpace)
		) -> Optional[ctypes.POINTER(ctypes.POINTER(BNSymbol))]:
	result = _BNGetSymbolsOfTypeInRange(view, type, start, len, count, nameSpace)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetTag

_BNGetTag = core.BNGetTag
_BNGetTag.restype = ctypes.POINTER(BNTag)
_BNGetTag.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNGetTag(
		view: ctypes.POINTER(BNBinaryView), 
		tagId: Optional[str]
		) -> Optional[ctypes.POINTER(BNTag)]:
	result = _BNGetTag(view, cstr(tagId))
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetTagReferencesOfType

_BNGetTagReferencesOfType = core.BNGetTagReferencesOfType
_BNGetTagReferencesOfType.restype = ctypes.POINTER(BNTagReference)
_BNGetTagReferencesOfType.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNTagType),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetTagReferencesOfType(
		view: ctypes.POINTER(BNBinaryView), 
		tagType: ctypes.POINTER(BNTagType), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNTagReference)]:
	result = _BNGetTagReferencesOfType(view, tagType, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetTagReferencesOfTypeCount

_BNGetTagReferencesOfTypeCount = core.BNGetTagReferencesOfTypeCount
_BNGetTagReferencesOfTypeCount.restype = ctypes.c_ulonglong
_BNGetTagReferencesOfTypeCount.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNTagType),
	]


# noinspection PyPep8Naming
def BNGetTagReferencesOfTypeCount(
		view: ctypes.POINTER(BNBinaryView), 
		tagType: ctypes.POINTER(BNTagType)
		) -> int:
	return _BNGetTagReferencesOfTypeCount(view, tagType)


# -------------------------------------------------------
# _BNGetTagType

_BNGetTagType = core.BNGetTagType
_BNGetTagType.restype = ctypes.POINTER(BNTagType)
_BNGetTagType.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNGetTagType(
		view: ctypes.POINTER(BNBinaryView), 
		name: Optional[str]
		) -> Optional[ctypes.POINTER(BNTagType)]:
	result = _BNGetTagType(view, cstr(name))
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetTagTypeById

_BNGetTagTypeById = core.BNGetTagTypeById
_BNGetTagTypeById.restype = ctypes.POINTER(BNTagType)
_BNGetTagTypeById.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNGetTagTypeById(
		view: ctypes.POINTER(BNBinaryView), 
		id: Optional[str]
		) -> Optional[ctypes.POINTER(BNTagType)]:
	result = _BNGetTagTypeById(view, cstr(id))
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetTagTypeByIdWithType

_BNGetTagTypeByIdWithType = core.BNGetTagTypeByIdWithType
_BNGetTagTypeByIdWithType.restype = ctypes.POINTER(BNTagType)
_BNGetTagTypeByIdWithType.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_char_p,
		TagTypeTypeEnum,
	]


# noinspection PyPep8Naming
def BNGetTagTypeByIdWithType(
		view: ctypes.POINTER(BNBinaryView), 
		id: Optional[str], 
		type: TagTypeType
		) -> Optional[ctypes.POINTER(BNTagType)]:
	result = _BNGetTagTypeByIdWithType(view, cstr(id), type)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetTagTypeWithType

_BNGetTagTypeWithType = core.BNGetTagTypeWithType
_BNGetTagTypeWithType.restype = ctypes.POINTER(BNTagType)
_BNGetTagTypeWithType.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_char_p,
		TagTypeTypeEnum,
	]


# noinspection PyPep8Naming
def BNGetTagTypeWithType(
		view: ctypes.POINTER(BNBinaryView), 
		name: Optional[str], 
		type: TagTypeType
		) -> Optional[ctypes.POINTER(BNTagType)]:
	result = _BNGetTagTypeWithType(view, cstr(name), type)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetTagTypes

_BNGetTagTypes = core.BNGetTagTypes
_BNGetTagTypes.restype = ctypes.POINTER(ctypes.POINTER(BNTagType))
_BNGetTagTypes.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetTagTypes(
		view: ctypes.POINTER(BNBinaryView), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.POINTER(BNTagType))]:
	result = _BNGetTagTypes(view, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetTemporaryFileContents

_BNGetTemporaryFileContents = core.BNGetTemporaryFileContents
_BNGetTemporaryFileContents.restype = ctypes.POINTER(BNDataBuffer)
_BNGetTemporaryFileContents.argtypes = [
		ctypes.POINTER(BNTemporaryFile),
	]


# noinspection PyPep8Naming
def BNGetTemporaryFileContents(
		file: ctypes.POINTER(BNTemporaryFile)
		) -> Optional[ctypes.POINTER(BNDataBuffer)]:
	result = _BNGetTemporaryFileContents(file)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetTemporaryFilePath

_BNGetTemporaryFilePath = core.BNGetTemporaryFilePath
_BNGetTemporaryFilePath.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetTemporaryFilePath.argtypes = [
		ctypes.POINTER(BNTemporaryFile),
	]


# noinspection PyPep8Naming
def BNGetTemporaryFilePath(
		file: ctypes.POINTER(BNTemporaryFile)
		) -> Optional[Optional[str]]:
	result = _BNGetTemporaryFilePath(file)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetTextLineInput

_BNGetTextLineInput = core.BNGetTextLineInput
_BNGetTextLineInput.restype = ctypes.c_bool
_BNGetTextLineInput.argtypes = [
		ctypes.POINTER(ctypes.c_char_p),
		ctypes.c_char_p,
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNGetTextLineInput(
		result: ctypes.POINTER(ctypes.c_char_p), 
		prompt: Optional[str], 
		title: Optional[str]
		) -> bool:
	return _BNGetTextLineInput(result, cstr(prompt), cstr(title))


# -------------------------------------------------------
# _BNGetTimeSinceLastUpdateCheck

_BNGetTimeSinceLastUpdateCheck = core.BNGetTimeSinceLastUpdateCheck
_BNGetTimeSinceLastUpdateCheck.restype = ctypes.c_ulonglong
_BNGetTimeSinceLastUpdateCheck.argtypes = [
	]


# noinspection PyPep8Naming
def BNGetTimeSinceLastUpdateCheck(
		) -> int:
	return _BNGetTimeSinceLastUpdateCheck()


# -------------------------------------------------------
# _BNGetTransformByName

_BNGetTransformByName = core.BNGetTransformByName
_BNGetTransformByName.restype = ctypes.POINTER(BNTransform)
_BNGetTransformByName.argtypes = [
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNGetTransformByName(
		name: Optional[str]
		) -> Optional[ctypes.POINTER(BNTransform)]:
	result = _BNGetTransformByName(cstr(name))
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetTransformGroup

_BNGetTransformGroup = core.BNGetTransformGroup
_BNGetTransformGroup.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetTransformGroup.argtypes = [
		ctypes.POINTER(BNTransform),
	]


# noinspection PyPep8Naming
def BNGetTransformGroup(
		xform: ctypes.POINTER(BNTransform)
		) -> Optional[Optional[str]]:
	result = _BNGetTransformGroup(xform)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetTransformLongName

_BNGetTransformLongName = core.BNGetTransformLongName
_BNGetTransformLongName.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetTransformLongName.argtypes = [
		ctypes.POINTER(BNTransform),
	]


# noinspection PyPep8Naming
def BNGetTransformLongName(
		xform: ctypes.POINTER(BNTransform)
		) -> Optional[Optional[str]]:
	result = _BNGetTransformLongName(xform)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetTransformName

_BNGetTransformName = core.BNGetTransformName
_BNGetTransformName.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetTransformName.argtypes = [
		ctypes.POINTER(BNTransform),
	]


# noinspection PyPep8Naming
def BNGetTransformName(
		xform: ctypes.POINTER(BNTransform)
		) -> Optional[Optional[str]]:
	result = _BNGetTransformName(xform)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetTransformParameterList

_BNGetTransformParameterList = core.BNGetTransformParameterList
_BNGetTransformParameterList.restype = ctypes.POINTER(BNTransformParameterInfo)
_BNGetTransformParameterList.argtypes = [
		ctypes.POINTER(BNTransform),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetTransformParameterList(
		xform: ctypes.POINTER(BNTransform), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNTransformParameterInfo)]:
	result = _BNGetTransformParameterList(xform, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetTransformType

_BNGetTransformType = core.BNGetTransformType
_BNGetTransformType.restype = TransformTypeEnum
_BNGetTransformType.argtypes = [
		ctypes.POINTER(BNTransform),
	]


# noinspection PyPep8Naming
def BNGetTransformType(
		xform: ctypes.POINTER(BNTransform)
		) -> TransformType:
	return _BNGetTransformType(xform)


# -------------------------------------------------------
# _BNGetTransformTypeList

_BNGetTransformTypeList = core.BNGetTransformTypeList
_BNGetTransformTypeList.restype = ctypes.POINTER(ctypes.POINTER(BNTransform))
_BNGetTransformTypeList.argtypes = [
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetTransformTypeList(
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.POINTER(BNTransform))]:
	result = _BNGetTransformTypeList(count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetTypeAlignment

_BNGetTypeAlignment = core.BNGetTypeAlignment
_BNGetTypeAlignment.restype = ctypes.c_ulonglong
_BNGetTypeAlignment.argtypes = [
		ctypes.POINTER(BNType),
	]


# noinspection PyPep8Naming
def BNGetTypeAlignment(
		type: ctypes.POINTER(BNType)
		) -> int:
	return _BNGetTypeAlignment(type)


# -------------------------------------------------------
# _BNGetTypeAlternateName

_BNGetTypeAlternateName = core.BNGetTypeAlternateName
_BNGetTypeAlternateName.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetTypeAlternateName.argtypes = [
		ctypes.POINTER(BNType),
	]


# noinspection PyPep8Naming
def BNGetTypeAlternateName(
		type: ctypes.POINTER(BNType)
		) -> Optional[Optional[str]]:
	result = _BNGetTypeAlternateName(type)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetTypeAndName

_BNGetTypeAndName = core.BNGetTypeAndName
_BNGetTypeAndName.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetTypeAndName.argtypes = [
		ctypes.POINTER(BNType),
		ctypes.POINTER(BNQualifiedName),
		TokenEscapingTypeEnum,
	]


# noinspection PyPep8Naming
def BNGetTypeAndName(
		type: ctypes.POINTER(BNType), 
		name: ctypes.POINTER(BNQualifiedName), 
		escaping: TokenEscapingType
		) -> Optional[Optional[str]]:
	result = _BNGetTypeAndName(type, name, escaping)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetTypeArchiveAllSnapshotIds

_BNGetTypeArchiveAllSnapshotIds = core.BNGetTypeArchiveAllSnapshotIds
_BNGetTypeArchiveAllSnapshotIds.restype = ctypes.POINTER(ctypes.c_char_p)
_BNGetTypeArchiveAllSnapshotIds.argtypes = [
		ctypes.POINTER(BNTypeArchive),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetTypeArchiveAllSnapshotIds(
		archive: ctypes.POINTER(BNTypeArchive), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_char_p)]:
	result = _BNGetTypeArchiveAllSnapshotIds(archive, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetTypeArchiveCurrentSnapshotId

_BNGetTypeArchiveCurrentSnapshotId = core.BNGetTypeArchiveCurrentSnapshotId
_BNGetTypeArchiveCurrentSnapshotId.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetTypeArchiveCurrentSnapshotId.argtypes = [
		ctypes.POINTER(BNTypeArchive),
	]


# noinspection PyPep8Naming
def BNGetTypeArchiveCurrentSnapshotId(
		archive: ctypes.POINTER(BNTypeArchive)
		) -> Optional[Optional[str]]:
	result = _BNGetTypeArchiveCurrentSnapshotId(archive)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetTypeArchiveId

_BNGetTypeArchiveId = core.BNGetTypeArchiveId
_BNGetTypeArchiveId.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetTypeArchiveId.argtypes = [
		ctypes.POINTER(BNTypeArchive),
	]


# noinspection PyPep8Naming
def BNGetTypeArchiveId(
		archive: ctypes.POINTER(BNTypeArchive)
		) -> Optional[Optional[str]]:
	result = _BNGetTypeArchiveId(archive)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetTypeArchiveIncomingDirectTypeReferences

_BNGetTypeArchiveIncomingDirectTypeReferences = core.BNGetTypeArchiveIncomingDirectTypeReferences
_BNGetTypeArchiveIncomingDirectTypeReferences.restype = ctypes.POINTER(ctypes.c_char_p)
_BNGetTypeArchiveIncomingDirectTypeReferences.argtypes = [
		ctypes.POINTER(BNTypeArchive),
		ctypes.c_char_p,
		ctypes.c_char_p,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetTypeArchiveIncomingDirectTypeReferences(
		archive: ctypes.POINTER(BNTypeArchive), 
		id: Optional[str], 
		snapshot: Optional[str], 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_char_p)]:
	result = _BNGetTypeArchiveIncomingDirectTypeReferences(archive, cstr(id), cstr(snapshot), count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetTypeArchiveIncomingRecursiveTypeReferences

_BNGetTypeArchiveIncomingRecursiveTypeReferences = core.BNGetTypeArchiveIncomingRecursiveTypeReferences
_BNGetTypeArchiveIncomingRecursiveTypeReferences.restype = ctypes.POINTER(ctypes.c_char_p)
_BNGetTypeArchiveIncomingRecursiveTypeReferences.argtypes = [
		ctypes.POINTER(BNTypeArchive),
		ctypes.c_char_p,
		ctypes.c_char_p,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetTypeArchiveIncomingRecursiveTypeReferences(
		archive: ctypes.POINTER(BNTypeArchive), 
		id: Optional[str], 
		snapshot: Optional[str], 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_char_p)]:
	result = _BNGetTypeArchiveIncomingRecursiveTypeReferences(archive, cstr(id), cstr(snapshot), count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetTypeArchiveOutgoingDirectTypeReferences

_BNGetTypeArchiveOutgoingDirectTypeReferences = core.BNGetTypeArchiveOutgoingDirectTypeReferences
_BNGetTypeArchiveOutgoingDirectTypeReferences.restype = ctypes.POINTER(ctypes.c_char_p)
_BNGetTypeArchiveOutgoingDirectTypeReferences.argtypes = [
		ctypes.POINTER(BNTypeArchive),
		ctypes.c_char_p,
		ctypes.c_char_p,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetTypeArchiveOutgoingDirectTypeReferences(
		archive: ctypes.POINTER(BNTypeArchive), 
		id: Optional[str], 
		snapshot: Optional[str], 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_char_p)]:
	result = _BNGetTypeArchiveOutgoingDirectTypeReferences(archive, cstr(id), cstr(snapshot), count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetTypeArchiveOutgoingRecursiveTypeReferences

_BNGetTypeArchiveOutgoingRecursiveTypeReferences = core.BNGetTypeArchiveOutgoingRecursiveTypeReferences
_BNGetTypeArchiveOutgoingRecursiveTypeReferences.restype = ctypes.POINTER(ctypes.c_char_p)
_BNGetTypeArchiveOutgoingRecursiveTypeReferences.argtypes = [
		ctypes.POINTER(BNTypeArchive),
		ctypes.c_char_p,
		ctypes.c_char_p,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetTypeArchiveOutgoingRecursiveTypeReferences(
		archive: ctypes.POINTER(BNTypeArchive), 
		id: Optional[str], 
		snapshot: Optional[str], 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_char_p)]:
	result = _BNGetTypeArchiveOutgoingRecursiveTypeReferences(archive, cstr(id), cstr(snapshot), count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetTypeArchivePath

_BNGetTypeArchivePath = core.BNGetTypeArchivePath
_BNGetTypeArchivePath.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetTypeArchivePath.argtypes = [
		ctypes.POINTER(BNTypeArchive),
	]


# noinspection PyPep8Naming
def BNGetTypeArchivePath(
		archive: ctypes.POINTER(BNTypeArchive)
		) -> Optional[Optional[str]]:
	result = _BNGetTypeArchivePath(archive)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetTypeArchivePlatform

_BNGetTypeArchivePlatform = core.BNGetTypeArchivePlatform
_BNGetTypeArchivePlatform.restype = ctypes.POINTER(BNPlatform)
_BNGetTypeArchivePlatform.argtypes = [
		ctypes.POINTER(BNTypeArchive),
	]


# noinspection PyPep8Naming
def BNGetTypeArchivePlatform(
		archive: ctypes.POINTER(BNTypeArchive)
		) -> Optional[ctypes.POINTER(BNPlatform)]:
	result = _BNGetTypeArchivePlatform(archive)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetTypeArchiveSnapshotChildIds

_BNGetTypeArchiveSnapshotChildIds = core.BNGetTypeArchiveSnapshotChildIds
_BNGetTypeArchiveSnapshotChildIds.restype = ctypes.POINTER(ctypes.c_char_p)
_BNGetTypeArchiveSnapshotChildIds.argtypes = [
		ctypes.POINTER(BNTypeArchive),
		ctypes.c_char_p,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetTypeArchiveSnapshotChildIds(
		archive: ctypes.POINTER(BNTypeArchive), 
		id: Optional[str], 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_char_p)]:
	result = _BNGetTypeArchiveSnapshotChildIds(archive, cstr(id), count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetTypeArchiveSnapshotParentIds

_BNGetTypeArchiveSnapshotParentIds = core.BNGetTypeArchiveSnapshotParentIds
_BNGetTypeArchiveSnapshotParentIds.restype = ctypes.POINTER(ctypes.c_char_p)
_BNGetTypeArchiveSnapshotParentIds.argtypes = [
		ctypes.POINTER(BNTypeArchive),
		ctypes.c_char_p,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetTypeArchiveSnapshotParentIds(
		archive: ctypes.POINTER(BNTypeArchive), 
		id: Optional[str], 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_char_p)]:
	result = _BNGetTypeArchiveSnapshotParentIds(archive, cstr(id), count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetTypeArchiveTypeById

_BNGetTypeArchiveTypeById = core.BNGetTypeArchiveTypeById
_BNGetTypeArchiveTypeById.restype = ctypes.POINTER(BNType)
_BNGetTypeArchiveTypeById.argtypes = [
		ctypes.POINTER(BNTypeArchive),
		ctypes.c_char_p,
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNGetTypeArchiveTypeById(
		archive: ctypes.POINTER(BNTypeArchive), 
		id: Optional[str], 
		snapshot: Optional[str]
		) -> Optional[ctypes.POINTER(BNType)]:
	result = _BNGetTypeArchiveTypeById(archive, cstr(id), cstr(snapshot))
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetTypeArchiveTypeByName

_BNGetTypeArchiveTypeByName = core.BNGetTypeArchiveTypeByName
_BNGetTypeArchiveTypeByName.restype = ctypes.POINTER(BNType)
_BNGetTypeArchiveTypeByName.argtypes = [
		ctypes.POINTER(BNTypeArchive),
		ctypes.POINTER(BNQualifiedName),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNGetTypeArchiveTypeByName(
		archive: ctypes.POINTER(BNTypeArchive), 
		name: ctypes.POINTER(BNQualifiedName), 
		snapshot: Optional[str]
		) -> Optional[ctypes.POINTER(BNType)]:
	result = _BNGetTypeArchiveTypeByName(archive, name, cstr(snapshot))
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetTypeArchiveTypeContainer

_BNGetTypeArchiveTypeContainer = core.BNGetTypeArchiveTypeContainer
_BNGetTypeArchiveTypeContainer.restype = ctypes.POINTER(BNTypeContainer)
_BNGetTypeArchiveTypeContainer.argtypes = [
		ctypes.POINTER(BNTypeArchive),
	]


# noinspection PyPep8Naming
def BNGetTypeArchiveTypeContainer(
		archive: ctypes.POINTER(BNTypeArchive)
		) -> Optional[ctypes.POINTER(BNTypeContainer)]:
	result = _BNGetTypeArchiveTypeContainer(archive)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetTypeArchiveTypeId

_BNGetTypeArchiveTypeId = core.BNGetTypeArchiveTypeId
_BNGetTypeArchiveTypeId.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetTypeArchiveTypeId.argtypes = [
		ctypes.POINTER(BNTypeArchive),
		ctypes.POINTER(BNQualifiedName),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNGetTypeArchiveTypeId(
		archive: ctypes.POINTER(BNTypeArchive), 
		name: ctypes.POINTER(BNQualifiedName), 
		snapshot: Optional[str]
		) -> Optional[Optional[str]]:
	result = _BNGetTypeArchiveTypeId(archive, name, cstr(snapshot))
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetTypeArchiveTypeIds

_BNGetTypeArchiveTypeIds = core.BNGetTypeArchiveTypeIds
_BNGetTypeArchiveTypeIds.restype = ctypes.POINTER(ctypes.c_char_p)
_BNGetTypeArchiveTypeIds.argtypes = [
		ctypes.POINTER(BNTypeArchive),
		ctypes.c_char_p,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetTypeArchiveTypeIds(
		archive: ctypes.POINTER(BNTypeArchive), 
		snapshot: Optional[str], 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_char_p)]:
	result = _BNGetTypeArchiveTypeIds(archive, cstr(snapshot), count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetTypeArchiveTypeName

_BNGetTypeArchiveTypeName = core.BNGetTypeArchiveTypeName
_BNGetTypeArchiveTypeName.restype = BNQualifiedName
_BNGetTypeArchiveTypeName.argtypes = [
		ctypes.POINTER(BNTypeArchive),
		ctypes.c_char_p,
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNGetTypeArchiveTypeName(
		archive: ctypes.POINTER(BNTypeArchive), 
		id: Optional[str], 
		snapshot: Optional[str]
		) -> BNQualifiedName:
	return _BNGetTypeArchiveTypeName(archive, cstr(id), cstr(snapshot))


# -------------------------------------------------------
# _BNGetTypeArchiveTypeNames

_BNGetTypeArchiveTypeNames = core.BNGetTypeArchiveTypeNames
_BNGetTypeArchiveTypeNames.restype = ctypes.POINTER(BNQualifiedName)
_BNGetTypeArchiveTypeNames.argtypes = [
		ctypes.POINTER(BNTypeArchive),
		ctypes.c_char_p,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetTypeArchiveTypeNames(
		archive: ctypes.POINTER(BNTypeArchive), 
		snapshot: Optional[str], 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNQualifiedName)]:
	result = _BNGetTypeArchiveTypeNames(archive, cstr(snapshot), count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetTypeArchiveTypeNamesAndIds

_BNGetTypeArchiveTypeNamesAndIds = core.BNGetTypeArchiveTypeNamesAndIds
_BNGetTypeArchiveTypeNamesAndIds.restype = ctypes.c_bool
_BNGetTypeArchiveTypeNamesAndIds.argtypes = [
		ctypes.POINTER(BNTypeArchive),
		ctypes.c_char_p,
		ctypes.POINTER(ctypes.POINTER(BNQualifiedName)),
		ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetTypeArchiveTypeNamesAndIds(
		archive: ctypes.POINTER(BNTypeArchive), 
		snapshot: Optional[str], 
		names: ctypes.POINTER(ctypes.POINTER(BNQualifiedName)), 
		ids: ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> bool:
	return _BNGetTypeArchiveTypeNamesAndIds(archive, cstr(snapshot), names, ids, count)


# -------------------------------------------------------
# _BNGetTypeArchiveTypes

_BNGetTypeArchiveTypes = core.BNGetTypeArchiveTypes
_BNGetTypeArchiveTypes.restype = ctypes.POINTER(BNQualifiedNameTypeAndId)
_BNGetTypeArchiveTypes.argtypes = [
		ctypes.POINTER(BNTypeArchive),
		ctypes.c_char_p,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetTypeArchiveTypes(
		archive: ctypes.POINTER(BNTypeArchive), 
		snapshot: Optional[str], 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNQualifiedNameTypeAndId)]:
	result = _BNGetTypeArchiveTypes(archive, cstr(snapshot), count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetTypeBuilderAlignment

_BNGetTypeBuilderAlignment = core.BNGetTypeBuilderAlignment
_BNGetTypeBuilderAlignment.restype = ctypes.c_ulonglong
_BNGetTypeBuilderAlignment.argtypes = [
		ctypes.POINTER(BNTypeBuilder),
	]


# noinspection PyPep8Naming
def BNGetTypeBuilderAlignment(
		type: ctypes.POINTER(BNTypeBuilder)
		) -> int:
	return _BNGetTypeBuilderAlignment(type)


# -------------------------------------------------------
# _BNGetTypeBuilderAlternateName

_BNGetTypeBuilderAlternateName = core.BNGetTypeBuilderAlternateName
_BNGetTypeBuilderAlternateName.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetTypeBuilderAlternateName.argtypes = [
		ctypes.POINTER(BNTypeBuilder),
	]


# noinspection PyPep8Naming
def BNGetTypeBuilderAlternateName(
		type: ctypes.POINTER(BNTypeBuilder)
		) -> Optional[Optional[str]]:
	result = _BNGetTypeBuilderAlternateName(type)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetTypeBuilderCallingConvention

_BNGetTypeBuilderCallingConvention = core.BNGetTypeBuilderCallingConvention
_BNGetTypeBuilderCallingConvention.restype = BNCallingConventionWithConfidence
_BNGetTypeBuilderCallingConvention.argtypes = [
		ctypes.POINTER(BNTypeBuilder),
	]


# noinspection PyPep8Naming
def BNGetTypeBuilderCallingConvention(
		type: ctypes.POINTER(BNTypeBuilder)
		) -> BNCallingConventionWithConfidence:
	return _BNGetTypeBuilderCallingConvention(type)


# -------------------------------------------------------
# _BNGetTypeBuilderChildType

_BNGetTypeBuilderChildType = core.BNGetTypeBuilderChildType
_BNGetTypeBuilderChildType.restype = BNTypeWithConfidence
_BNGetTypeBuilderChildType.argtypes = [
		ctypes.POINTER(BNTypeBuilder),
	]


# noinspection PyPep8Naming
def BNGetTypeBuilderChildType(
		type: ctypes.POINTER(BNTypeBuilder)
		) -> BNTypeWithConfidence:
	return _BNGetTypeBuilderChildType(type)


# -------------------------------------------------------
# _BNGetTypeBuilderClass

_BNGetTypeBuilderClass = core.BNGetTypeBuilderClass
_BNGetTypeBuilderClass.restype = TypeClassEnum
_BNGetTypeBuilderClass.argtypes = [
		ctypes.POINTER(BNTypeBuilder),
	]


# noinspection PyPep8Naming
def BNGetTypeBuilderClass(
		type: ctypes.POINTER(BNTypeBuilder)
		) -> TypeClass:
	return _BNGetTypeBuilderClass(type)


# -------------------------------------------------------
# _BNGetTypeBuilderElementCount

_BNGetTypeBuilderElementCount = core.BNGetTypeBuilderElementCount
_BNGetTypeBuilderElementCount.restype = ctypes.c_ulonglong
_BNGetTypeBuilderElementCount.argtypes = [
		ctypes.POINTER(BNTypeBuilder),
	]


# noinspection PyPep8Naming
def BNGetTypeBuilderElementCount(
		type: ctypes.POINTER(BNTypeBuilder)
		) -> int:
	return _BNGetTypeBuilderElementCount(type)


# -------------------------------------------------------
# _BNGetTypeBuilderEnumeration

_BNGetTypeBuilderEnumeration = core.BNGetTypeBuilderEnumeration
_BNGetTypeBuilderEnumeration.restype = ctypes.POINTER(BNEnumeration)
_BNGetTypeBuilderEnumeration.argtypes = [
		ctypes.POINTER(BNTypeBuilder),
	]


# noinspection PyPep8Naming
def BNGetTypeBuilderEnumeration(
		type: ctypes.POINTER(BNTypeBuilder)
		) -> Optional[ctypes.POINTER(BNEnumeration)]:
	result = _BNGetTypeBuilderEnumeration(type)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetTypeBuilderNamedTypeReference

_BNGetTypeBuilderNamedTypeReference = core.BNGetTypeBuilderNamedTypeReference
_BNGetTypeBuilderNamedTypeReference.restype = ctypes.POINTER(BNNamedTypeReference)
_BNGetTypeBuilderNamedTypeReference.argtypes = [
		ctypes.POINTER(BNTypeBuilder),
	]


# noinspection PyPep8Naming
def BNGetTypeBuilderNamedTypeReference(
		type: ctypes.POINTER(BNTypeBuilder)
		) -> Optional[ctypes.POINTER(BNNamedTypeReference)]:
	result = _BNGetTypeBuilderNamedTypeReference(type)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetTypeBuilderOffset

_BNGetTypeBuilderOffset = core.BNGetTypeBuilderOffset
_BNGetTypeBuilderOffset.restype = ctypes.c_ulonglong
_BNGetTypeBuilderOffset.argtypes = [
		ctypes.POINTER(BNTypeBuilder),
	]


# noinspection PyPep8Naming
def BNGetTypeBuilderOffset(
		type: ctypes.POINTER(BNTypeBuilder)
		) -> int:
	return _BNGetTypeBuilderOffset(type)


# -------------------------------------------------------
# _BNGetTypeBuilderParameters

_BNGetTypeBuilderParameters = core.BNGetTypeBuilderParameters
_BNGetTypeBuilderParameters.restype = ctypes.POINTER(BNFunctionParameter)
_BNGetTypeBuilderParameters.argtypes = [
		ctypes.POINTER(BNTypeBuilder),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetTypeBuilderParameters(
		type: ctypes.POINTER(BNTypeBuilder), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNFunctionParameter)]:
	result = _BNGetTypeBuilderParameters(type, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetTypeBuilderStackAdjustment

_BNGetTypeBuilderStackAdjustment = core.BNGetTypeBuilderStackAdjustment
_BNGetTypeBuilderStackAdjustment.restype = BNOffsetWithConfidence
_BNGetTypeBuilderStackAdjustment.argtypes = [
		ctypes.POINTER(BNTypeBuilder),
	]


# noinspection PyPep8Naming
def BNGetTypeBuilderStackAdjustment(
		type: ctypes.POINTER(BNTypeBuilder)
		) -> BNOffsetWithConfidence:
	return _BNGetTypeBuilderStackAdjustment(type)


# -------------------------------------------------------
# _BNGetTypeBuilderString

_BNGetTypeBuilderString = core.BNGetTypeBuilderString
_BNGetTypeBuilderString.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetTypeBuilderString.argtypes = [
		ctypes.POINTER(BNTypeBuilder),
		ctypes.POINTER(BNPlatform),
	]


# noinspection PyPep8Naming
def BNGetTypeBuilderString(
		type: ctypes.POINTER(BNTypeBuilder), 
		platform: ctypes.POINTER(BNPlatform)
		) -> Optional[Optional[str]]:
	result = _BNGetTypeBuilderString(type, platform)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetTypeBuilderStringAfterName

_BNGetTypeBuilderStringAfterName = core.BNGetTypeBuilderStringAfterName
_BNGetTypeBuilderStringAfterName.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetTypeBuilderStringAfterName.argtypes = [
		ctypes.POINTER(BNTypeBuilder),
		ctypes.POINTER(BNPlatform),
	]


# noinspection PyPep8Naming
def BNGetTypeBuilderStringAfterName(
		type: ctypes.POINTER(BNTypeBuilder), 
		platform: ctypes.POINTER(BNPlatform)
		) -> Optional[Optional[str]]:
	result = _BNGetTypeBuilderStringAfterName(type, platform)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetTypeBuilderStringBeforeName

_BNGetTypeBuilderStringBeforeName = core.BNGetTypeBuilderStringBeforeName
_BNGetTypeBuilderStringBeforeName.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetTypeBuilderStringBeforeName.argtypes = [
		ctypes.POINTER(BNTypeBuilder),
		ctypes.POINTER(BNPlatform),
	]


# noinspection PyPep8Naming
def BNGetTypeBuilderStringBeforeName(
		type: ctypes.POINTER(BNTypeBuilder), 
		platform: ctypes.POINTER(BNPlatform)
		) -> Optional[Optional[str]]:
	result = _BNGetTypeBuilderStringBeforeName(type, platform)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetTypeBuilderStructure

_BNGetTypeBuilderStructure = core.BNGetTypeBuilderStructure
_BNGetTypeBuilderStructure.restype = ctypes.POINTER(BNStructure)
_BNGetTypeBuilderStructure.argtypes = [
		ctypes.POINTER(BNTypeBuilder),
	]


# noinspection PyPep8Naming
def BNGetTypeBuilderStructure(
		type: ctypes.POINTER(BNTypeBuilder)
		) -> Optional[ctypes.POINTER(BNStructure)]:
	result = _BNGetTypeBuilderStructure(type)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetTypeBuilderTokens

_BNGetTypeBuilderTokens = core.BNGetTypeBuilderTokens
_BNGetTypeBuilderTokens.restype = ctypes.POINTER(BNInstructionTextToken)
_BNGetTypeBuilderTokens.argtypes = [
		ctypes.POINTER(BNTypeBuilder),
		ctypes.POINTER(BNPlatform),
		ctypes.c_ubyte,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetTypeBuilderTokens(
		type: ctypes.POINTER(BNTypeBuilder), 
		platform: ctypes.POINTER(BNPlatform), 
		baseConfidence: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNInstructionTextToken)]:
	result = _BNGetTypeBuilderTokens(type, platform, baseConfidence, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetTypeBuilderTokensAfterName

_BNGetTypeBuilderTokensAfterName = core.BNGetTypeBuilderTokensAfterName
_BNGetTypeBuilderTokensAfterName.restype = ctypes.POINTER(BNInstructionTextToken)
_BNGetTypeBuilderTokensAfterName.argtypes = [
		ctypes.POINTER(BNTypeBuilder),
		ctypes.POINTER(BNPlatform),
		ctypes.c_ubyte,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetTypeBuilderTokensAfterName(
		type: ctypes.POINTER(BNTypeBuilder), 
		platform: ctypes.POINTER(BNPlatform), 
		baseConfidence: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNInstructionTextToken)]:
	result = _BNGetTypeBuilderTokensAfterName(type, platform, baseConfidence, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetTypeBuilderTokensBeforeName

_BNGetTypeBuilderTokensBeforeName = core.BNGetTypeBuilderTokensBeforeName
_BNGetTypeBuilderTokensBeforeName.restype = ctypes.POINTER(BNInstructionTextToken)
_BNGetTypeBuilderTokensBeforeName.argtypes = [
		ctypes.POINTER(BNTypeBuilder),
		ctypes.POINTER(BNPlatform),
		ctypes.c_ubyte,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetTypeBuilderTokensBeforeName(
		type: ctypes.POINTER(BNTypeBuilder), 
		platform: ctypes.POINTER(BNPlatform), 
		baseConfidence: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNInstructionTextToken)]:
	result = _BNGetTypeBuilderTokensBeforeName(type, platform, baseConfidence, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetTypeBuilderTypeAndName

_BNGetTypeBuilderTypeAndName = core.BNGetTypeBuilderTypeAndName
_BNGetTypeBuilderTypeAndName.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetTypeBuilderTypeAndName.argtypes = [
		ctypes.POINTER(BNTypeBuilder),
		ctypes.POINTER(BNQualifiedName),
	]


# noinspection PyPep8Naming
def BNGetTypeBuilderTypeAndName(
		type: ctypes.POINTER(BNTypeBuilder), 
		name: ctypes.POINTER(BNQualifiedName)
		) -> Optional[Optional[str]]:
	result = _BNGetTypeBuilderTypeAndName(type, name)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetTypeBuilderWidth

_BNGetTypeBuilderWidth = core.BNGetTypeBuilderWidth
_BNGetTypeBuilderWidth.restype = ctypes.c_ulonglong
_BNGetTypeBuilderWidth.argtypes = [
		ctypes.POINTER(BNTypeBuilder),
	]


# noinspection PyPep8Naming
def BNGetTypeBuilderWidth(
		type: ctypes.POINTER(BNTypeBuilder)
		) -> int:
	return _BNGetTypeBuilderWidth(type)


# -------------------------------------------------------
# _BNGetTypeCallingConvention

_BNGetTypeCallingConvention = core.BNGetTypeCallingConvention
_BNGetTypeCallingConvention.restype = BNCallingConventionWithConfidence
_BNGetTypeCallingConvention.argtypes = [
		ctypes.POINTER(BNType),
	]


# noinspection PyPep8Naming
def BNGetTypeCallingConvention(
		type: ctypes.POINTER(BNType)
		) -> BNCallingConventionWithConfidence:
	return _BNGetTypeCallingConvention(type)


# -------------------------------------------------------
# _BNGetTypeClass

_BNGetTypeClass = core.BNGetTypeClass
_BNGetTypeClass.restype = TypeClassEnum
_BNGetTypeClass.argtypes = [
		ctypes.POINTER(BNType),
	]


# noinspection PyPep8Naming
def BNGetTypeClass(
		type: ctypes.POINTER(BNType)
		) -> TypeClass:
	return _BNGetTypeClass(type)


# -------------------------------------------------------
# _BNGetTypeElementCount

_BNGetTypeElementCount = core.BNGetTypeElementCount
_BNGetTypeElementCount.restype = ctypes.c_ulonglong
_BNGetTypeElementCount.argtypes = [
		ctypes.POINTER(BNType),
	]


# noinspection PyPep8Naming
def BNGetTypeElementCount(
		type: ctypes.POINTER(BNType)
		) -> int:
	return _BNGetTypeElementCount(type)


# -------------------------------------------------------
# _BNGetTypeEnumeration

_BNGetTypeEnumeration = core.BNGetTypeEnumeration
_BNGetTypeEnumeration.restype = ctypes.POINTER(BNEnumeration)
_BNGetTypeEnumeration.argtypes = [
		ctypes.POINTER(BNType),
	]


# noinspection PyPep8Naming
def BNGetTypeEnumeration(
		type: ctypes.POINTER(BNType)
		) -> Optional[ctypes.POINTER(BNEnumeration)]:
	result = _BNGetTypeEnumeration(type)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetTypeLibraryAlternateNames

_BNGetTypeLibraryAlternateNames = core.BNGetTypeLibraryAlternateNames
_BNGetTypeLibraryAlternateNames.restype = ctypes.POINTER(ctypes.c_char_p)
_BNGetTypeLibraryAlternateNames.argtypes = [
		ctypes.POINTER(BNTypeLibrary),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetTypeLibraryAlternateNames(
		lib: ctypes.POINTER(BNTypeLibrary), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_char_p)]:
	result = _BNGetTypeLibraryAlternateNames(lib, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetTypeLibraryArchitecture

_BNGetTypeLibraryArchitecture = core.BNGetTypeLibraryArchitecture
_BNGetTypeLibraryArchitecture.restype = ctypes.POINTER(BNArchitecture)
_BNGetTypeLibraryArchitecture.argtypes = [
		ctypes.POINTER(BNTypeLibrary),
	]


# noinspection PyPep8Naming
def BNGetTypeLibraryArchitecture(
		lib: ctypes.POINTER(BNTypeLibrary)
		) -> Optional[ctypes.POINTER(BNArchitecture)]:
	result = _BNGetTypeLibraryArchitecture(lib)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetTypeLibraryDependencyName

_BNGetTypeLibraryDependencyName = core.BNGetTypeLibraryDependencyName
_BNGetTypeLibraryDependencyName.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetTypeLibraryDependencyName.argtypes = [
		ctypes.POINTER(BNTypeLibrary),
	]


# noinspection PyPep8Naming
def BNGetTypeLibraryDependencyName(
		lib: ctypes.POINTER(BNTypeLibrary)
		) -> Optional[Optional[str]]:
	result = _BNGetTypeLibraryDependencyName(lib)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetTypeLibraryGuid

_BNGetTypeLibraryGuid = core.BNGetTypeLibraryGuid
_BNGetTypeLibraryGuid.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetTypeLibraryGuid.argtypes = [
		ctypes.POINTER(BNTypeLibrary),
	]


# noinspection PyPep8Naming
def BNGetTypeLibraryGuid(
		lib: ctypes.POINTER(BNTypeLibrary)
		) -> Optional[Optional[str]]:
	result = _BNGetTypeLibraryGuid(lib)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetTypeLibraryName

_BNGetTypeLibraryName = core.BNGetTypeLibraryName
_BNGetTypeLibraryName.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetTypeLibraryName.argtypes = [
		ctypes.POINTER(BNTypeLibrary),
	]


# noinspection PyPep8Naming
def BNGetTypeLibraryName(
		lib: ctypes.POINTER(BNTypeLibrary)
		) -> Optional[Optional[str]]:
	result = _BNGetTypeLibraryName(lib)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetTypeLibraryNamedObject

_BNGetTypeLibraryNamedObject = core.BNGetTypeLibraryNamedObject
_BNGetTypeLibraryNamedObject.restype = ctypes.POINTER(BNType)
_BNGetTypeLibraryNamedObject.argtypes = [
		ctypes.POINTER(BNTypeLibrary),
		ctypes.POINTER(BNQualifiedName),
	]


# noinspection PyPep8Naming
def BNGetTypeLibraryNamedObject(
		lib: ctypes.POINTER(BNTypeLibrary), 
		name: ctypes.POINTER(BNQualifiedName)
		) -> Optional[ctypes.POINTER(BNType)]:
	result = _BNGetTypeLibraryNamedObject(lib, name)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetTypeLibraryNamedObjects

_BNGetTypeLibraryNamedObjects = core.BNGetTypeLibraryNamedObjects
_BNGetTypeLibraryNamedObjects.restype = ctypes.POINTER(BNQualifiedNameAndType)
_BNGetTypeLibraryNamedObjects.argtypes = [
		ctypes.POINTER(BNTypeLibrary),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetTypeLibraryNamedObjects(
		lib: ctypes.POINTER(BNTypeLibrary), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNQualifiedNameAndType)]:
	result = _BNGetTypeLibraryNamedObjects(lib, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetTypeLibraryNamedType

_BNGetTypeLibraryNamedType = core.BNGetTypeLibraryNamedType
_BNGetTypeLibraryNamedType.restype = ctypes.POINTER(BNType)
_BNGetTypeLibraryNamedType.argtypes = [
		ctypes.POINTER(BNTypeLibrary),
		ctypes.POINTER(BNQualifiedName),
	]


# noinspection PyPep8Naming
def BNGetTypeLibraryNamedType(
		lib: ctypes.POINTER(BNTypeLibrary), 
		name: ctypes.POINTER(BNQualifiedName)
		) -> Optional[ctypes.POINTER(BNType)]:
	result = _BNGetTypeLibraryNamedType(lib, name)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetTypeLibraryNamedTypes

_BNGetTypeLibraryNamedTypes = core.BNGetTypeLibraryNamedTypes
_BNGetTypeLibraryNamedTypes.restype = ctypes.POINTER(BNQualifiedNameAndType)
_BNGetTypeLibraryNamedTypes.argtypes = [
		ctypes.POINTER(BNTypeLibrary),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetTypeLibraryNamedTypes(
		lib: ctypes.POINTER(BNTypeLibrary), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNQualifiedNameAndType)]:
	result = _BNGetTypeLibraryNamedTypes(lib, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetTypeLibraryPlatforms

_BNGetTypeLibraryPlatforms = core.BNGetTypeLibraryPlatforms
_BNGetTypeLibraryPlatforms.restype = ctypes.POINTER(ctypes.c_char_p)
_BNGetTypeLibraryPlatforms.argtypes = [
		ctypes.POINTER(BNTypeLibrary),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetTypeLibraryPlatforms(
		lib: ctypes.POINTER(BNTypeLibrary), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_char_p)]:
	result = _BNGetTypeLibraryPlatforms(lib, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetTypeLibraryTypeContainer

_BNGetTypeLibraryTypeContainer = core.BNGetTypeLibraryTypeContainer
_BNGetTypeLibraryTypeContainer.restype = ctypes.POINTER(BNTypeContainer)
_BNGetTypeLibraryTypeContainer.argtypes = [
		ctypes.POINTER(BNTypeLibrary),
	]


# noinspection PyPep8Naming
def BNGetTypeLibraryTypeContainer(
		lib: ctypes.POINTER(BNTypeLibrary)
		) -> Optional[ctypes.POINTER(BNTypeContainer)]:
	result = _BNGetTypeLibraryTypeContainer(lib)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetTypeLines

_BNGetTypeLines = core.BNGetTypeLines
_BNGetTypeLines.restype = ctypes.POINTER(BNTypeDefinitionLine)
_BNGetTypeLines.argtypes = [
		ctypes.POINTER(BNType),
		ctypes.POINTER(BNTypeContainer),
		ctypes.c_char_p,
		ctypes.c_int,
		ctypes.c_bool,
		TokenEscapingTypeEnum,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetTypeLines(
		type: ctypes.POINTER(BNType), 
		types: ctypes.POINTER(BNTypeContainer), 
		name: Optional[str], 
		lineWidth: int, 
		collapsed: bool, 
		escaping: TokenEscapingType, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNTypeDefinitionLine)]:
	result = _BNGetTypeLines(type, types, cstr(name), lineWidth, collapsed, escaping, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetTypeNamedTypeReference

_BNGetTypeNamedTypeReference = core.BNGetTypeNamedTypeReference
_BNGetTypeNamedTypeReference.restype = ctypes.POINTER(BNNamedTypeReference)
_BNGetTypeNamedTypeReference.argtypes = [
		ctypes.POINTER(BNType),
	]


# noinspection PyPep8Naming
def BNGetTypeNamedTypeReference(
		type: ctypes.POINTER(BNType)
		) -> Optional[ctypes.POINTER(BNNamedTypeReference)]:
	result = _BNGetTypeNamedTypeReference(type)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetTypeOffset

_BNGetTypeOffset = core.BNGetTypeOffset
_BNGetTypeOffset.restype = ctypes.c_ulonglong
_BNGetTypeOffset.argtypes = [
		ctypes.POINTER(BNType),
	]


# noinspection PyPep8Naming
def BNGetTypeOffset(
		type: ctypes.POINTER(BNType)
		) -> int:
	return _BNGetTypeOffset(type)


# -------------------------------------------------------
# _BNGetTypeParameters

_BNGetTypeParameters = core.BNGetTypeParameters
_BNGetTypeParameters.restype = ctypes.POINTER(BNFunctionParameter)
_BNGetTypeParameters.argtypes = [
		ctypes.POINTER(BNType),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetTypeParameters(
		type: ctypes.POINTER(BNType), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNFunctionParameter)]:
	result = _BNGetTypeParameters(type, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetTypeParserByName

_BNGetTypeParserByName = core.BNGetTypeParserByName
_BNGetTypeParserByName.restype = ctypes.POINTER(BNTypeParser)
_BNGetTypeParserByName.argtypes = [
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNGetTypeParserByName(
		name: Optional[str]
		) -> Optional[ctypes.POINTER(BNTypeParser)]:
	result = _BNGetTypeParserByName(cstr(name))
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetTypeParserList

_BNGetTypeParserList = core.BNGetTypeParserList
_BNGetTypeParserList.restype = ctypes.POINTER(ctypes.POINTER(BNTypeParser))
_BNGetTypeParserList.argtypes = [
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetTypeParserList(
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.POINTER(BNTypeParser))]:
	result = _BNGetTypeParserList(count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetTypeParserName

_BNGetTypeParserName = core.BNGetTypeParserName
_BNGetTypeParserName.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetTypeParserName.argtypes = [
		ctypes.POINTER(BNTypeParser),
	]


# noinspection PyPep8Naming
def BNGetTypeParserName(
		parser: ctypes.POINTER(BNTypeParser)
		) -> Optional[Optional[str]]:
	result = _BNGetTypeParserName(parser)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetTypeParserOptionText

_BNGetTypeParserOptionText = core.BNGetTypeParserOptionText
_BNGetTypeParserOptionText.restype = ctypes.c_bool
_BNGetTypeParserOptionText.argtypes = [
		ctypes.POINTER(BNTypeParser),
		TypeParserOptionEnum,
		ctypes.c_char_p,
		ctypes.POINTER(ctypes.c_char_p),
	]


# noinspection PyPep8Naming
def BNGetTypeParserOptionText(
		parser: ctypes.POINTER(BNTypeParser), 
		option: TypeParserOption, 
		value: Optional[str], 
		result: ctypes.POINTER(ctypes.c_char_p)
		) -> bool:
	return _BNGetTypeParserOptionText(parser, option, cstr(value), result)


# -------------------------------------------------------
# _BNGetTypePrinterByName

_BNGetTypePrinterByName = core.BNGetTypePrinterByName
_BNGetTypePrinterByName.restype = ctypes.POINTER(BNTypePrinter)
_BNGetTypePrinterByName.argtypes = [
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNGetTypePrinterByName(
		name: Optional[str]
		) -> Optional[ctypes.POINTER(BNTypePrinter)]:
	result = _BNGetTypePrinterByName(cstr(name))
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetTypePrinterList

_BNGetTypePrinterList = core.BNGetTypePrinterList
_BNGetTypePrinterList.restype = ctypes.POINTER(ctypes.POINTER(BNTypePrinter))
_BNGetTypePrinterList.argtypes = [
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetTypePrinterList(
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.POINTER(BNTypePrinter))]:
	result = _BNGetTypePrinterList(count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetTypePrinterName

_BNGetTypePrinterName = core.BNGetTypePrinterName
_BNGetTypePrinterName.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetTypePrinterName.argtypes = [
		ctypes.POINTER(BNTypePrinter),
	]


# noinspection PyPep8Naming
def BNGetTypePrinterName(
		printer: ctypes.POINTER(BNTypePrinter)
		) -> Optional[Optional[str]]:
	result = _BNGetTypePrinterName(printer)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetTypePrinterTypeLines

_BNGetTypePrinterTypeLines = core.BNGetTypePrinterTypeLines
_BNGetTypePrinterTypeLines.restype = ctypes.c_bool
_BNGetTypePrinterTypeLines.argtypes = [
		ctypes.POINTER(BNTypePrinter),
		ctypes.POINTER(BNType),
		ctypes.POINTER(BNTypeContainer),
		ctypes.POINTER(BNQualifiedName),
		ctypes.c_int,
		ctypes.c_bool,
		TokenEscapingTypeEnum,
		ctypes.POINTER(ctypes.POINTER(BNTypeDefinitionLine)),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetTypePrinterTypeLines(
		printer: ctypes.POINTER(BNTypePrinter), 
		type: ctypes.POINTER(BNType), 
		types: ctypes.POINTER(BNTypeContainer), 
		name: ctypes.POINTER(BNQualifiedName), 
		lineWidth: int, 
		collapsed: bool, 
		escaping: TokenEscapingType, 
		result: ctypes.POINTER(ctypes.POINTER(BNTypeDefinitionLine)), 
		resultCount: ctypes.POINTER(ctypes.c_ulonglong)
		) -> bool:
	return _BNGetTypePrinterTypeLines(printer, type, types, name, lineWidth, collapsed, escaping, result, resultCount)


# -------------------------------------------------------
# _BNGetTypePrinterTypeString

_BNGetTypePrinterTypeString = core.BNGetTypePrinterTypeString
_BNGetTypePrinterTypeString.restype = ctypes.c_bool
_BNGetTypePrinterTypeString.argtypes = [
		ctypes.POINTER(BNTypePrinter),
		ctypes.POINTER(BNType),
		ctypes.POINTER(BNPlatform),
		ctypes.POINTER(BNQualifiedName),
		TokenEscapingTypeEnum,
		ctypes.POINTER(ctypes.c_char_p),
	]


# noinspection PyPep8Naming
def BNGetTypePrinterTypeString(
		printer: ctypes.POINTER(BNTypePrinter), 
		type: ctypes.POINTER(BNType), 
		platform: ctypes.POINTER(BNPlatform), 
		name: ctypes.POINTER(BNQualifiedName), 
		escaping: TokenEscapingType, 
		result: ctypes.POINTER(ctypes.c_char_p)
		) -> bool:
	return _BNGetTypePrinterTypeString(printer, type, platform, name, escaping, result)


# -------------------------------------------------------
# _BNGetTypePrinterTypeStringAfterName

_BNGetTypePrinterTypeStringAfterName = core.BNGetTypePrinterTypeStringAfterName
_BNGetTypePrinterTypeStringAfterName.restype = ctypes.c_bool
_BNGetTypePrinterTypeStringAfterName.argtypes = [
		ctypes.POINTER(BNTypePrinter),
		ctypes.POINTER(BNType),
		ctypes.POINTER(BNPlatform),
		TokenEscapingTypeEnum,
		ctypes.POINTER(ctypes.c_char_p),
	]


# noinspection PyPep8Naming
def BNGetTypePrinterTypeStringAfterName(
		printer: ctypes.POINTER(BNTypePrinter), 
		type: ctypes.POINTER(BNType), 
		platform: ctypes.POINTER(BNPlatform), 
		escaping: TokenEscapingType, 
		result: ctypes.POINTER(ctypes.c_char_p)
		) -> bool:
	return _BNGetTypePrinterTypeStringAfterName(printer, type, platform, escaping, result)


# -------------------------------------------------------
# _BNGetTypePrinterTypeStringBeforeName

_BNGetTypePrinterTypeStringBeforeName = core.BNGetTypePrinterTypeStringBeforeName
_BNGetTypePrinterTypeStringBeforeName.restype = ctypes.c_bool
_BNGetTypePrinterTypeStringBeforeName.argtypes = [
		ctypes.POINTER(BNTypePrinter),
		ctypes.POINTER(BNType),
		ctypes.POINTER(BNPlatform),
		TokenEscapingTypeEnum,
		ctypes.POINTER(ctypes.c_char_p),
	]


# noinspection PyPep8Naming
def BNGetTypePrinterTypeStringBeforeName(
		printer: ctypes.POINTER(BNTypePrinter), 
		type: ctypes.POINTER(BNType), 
		platform: ctypes.POINTER(BNPlatform), 
		escaping: TokenEscapingType, 
		result: ctypes.POINTER(ctypes.c_char_p)
		) -> bool:
	return _BNGetTypePrinterTypeStringBeforeName(printer, type, platform, escaping, result)


# -------------------------------------------------------
# _BNGetTypePrinterTypeTokens

_BNGetTypePrinterTypeTokens = core.BNGetTypePrinterTypeTokens
_BNGetTypePrinterTypeTokens.restype = ctypes.c_bool
_BNGetTypePrinterTypeTokens.argtypes = [
		ctypes.POINTER(BNTypePrinter),
		ctypes.POINTER(BNType),
		ctypes.POINTER(BNPlatform),
		ctypes.POINTER(BNQualifiedName),
		ctypes.c_ubyte,
		TokenEscapingTypeEnum,
		ctypes.POINTER(ctypes.POINTER(BNInstructionTextToken)),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetTypePrinterTypeTokens(
		printer: ctypes.POINTER(BNTypePrinter), 
		type: ctypes.POINTER(BNType), 
		platform: ctypes.POINTER(BNPlatform), 
		name: ctypes.POINTER(BNQualifiedName), 
		baseConfidence: int, 
		escaping: TokenEscapingType, 
		result: ctypes.POINTER(ctypes.POINTER(BNInstructionTextToken)), 
		resultCount: ctypes.POINTER(ctypes.c_ulonglong)
		) -> bool:
	return _BNGetTypePrinterTypeTokens(printer, type, platform, name, baseConfidence, escaping, result, resultCount)


# -------------------------------------------------------
# _BNGetTypePrinterTypeTokensAfterName

_BNGetTypePrinterTypeTokensAfterName = core.BNGetTypePrinterTypeTokensAfterName
_BNGetTypePrinterTypeTokensAfterName.restype = ctypes.c_bool
_BNGetTypePrinterTypeTokensAfterName.argtypes = [
		ctypes.POINTER(BNTypePrinter),
		ctypes.POINTER(BNType),
		ctypes.POINTER(BNPlatform),
		ctypes.c_ubyte,
		ctypes.POINTER(BNType),
		TokenEscapingTypeEnum,
		ctypes.POINTER(ctypes.POINTER(BNInstructionTextToken)),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetTypePrinterTypeTokensAfterName(
		printer: ctypes.POINTER(BNTypePrinter), 
		type: ctypes.POINTER(BNType), 
		platform: ctypes.POINTER(BNPlatform), 
		baseConfidence: int, 
		parentType: ctypes.POINTER(BNType), 
		escaping: TokenEscapingType, 
		result: ctypes.POINTER(ctypes.POINTER(BNInstructionTextToken)), 
		resultCount: ctypes.POINTER(ctypes.c_ulonglong)
		) -> bool:
	return _BNGetTypePrinterTypeTokensAfterName(printer, type, platform, baseConfidence, parentType, escaping, result, resultCount)


# -------------------------------------------------------
# _BNGetTypePrinterTypeTokensBeforeName

_BNGetTypePrinterTypeTokensBeforeName = core.BNGetTypePrinterTypeTokensBeforeName
_BNGetTypePrinterTypeTokensBeforeName.restype = ctypes.c_bool
_BNGetTypePrinterTypeTokensBeforeName.argtypes = [
		ctypes.POINTER(BNTypePrinter),
		ctypes.POINTER(BNType),
		ctypes.POINTER(BNPlatform),
		ctypes.c_ubyte,
		ctypes.POINTER(BNType),
		TokenEscapingTypeEnum,
		ctypes.POINTER(ctypes.POINTER(BNInstructionTextToken)),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetTypePrinterTypeTokensBeforeName(
		printer: ctypes.POINTER(BNTypePrinter), 
		type: ctypes.POINTER(BNType), 
		platform: ctypes.POINTER(BNPlatform), 
		baseConfidence: int, 
		parentType: ctypes.POINTER(BNType), 
		escaping: TokenEscapingType, 
		result: ctypes.POINTER(ctypes.POINTER(BNInstructionTextToken)), 
		resultCount: ctypes.POINTER(ctypes.c_ulonglong)
		) -> bool:
	return _BNGetTypePrinterTypeTokensBeforeName(printer, type, platform, baseConfidence, parentType, escaping, result, resultCount)


# -------------------------------------------------------
# _BNGetTypeReferenceBuilderClass

_BNGetTypeReferenceBuilderClass = core.BNGetTypeReferenceBuilderClass
_BNGetTypeReferenceBuilderClass.restype = NamedTypeReferenceClassEnum
_BNGetTypeReferenceBuilderClass.argtypes = [
		ctypes.POINTER(BNNamedTypeReferenceBuilder),
	]


# noinspection PyPep8Naming
def BNGetTypeReferenceBuilderClass(
		nt: ctypes.POINTER(BNNamedTypeReferenceBuilder)
		) -> NamedTypeReferenceClass:
	return _BNGetTypeReferenceBuilderClass(nt)


# -------------------------------------------------------
# _BNGetTypeReferenceBuilderId

_BNGetTypeReferenceBuilderId = core.BNGetTypeReferenceBuilderId
_BNGetTypeReferenceBuilderId.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetTypeReferenceBuilderId.argtypes = [
		ctypes.POINTER(BNNamedTypeReferenceBuilder),
	]


# noinspection PyPep8Naming
def BNGetTypeReferenceBuilderId(
		nt: ctypes.POINTER(BNNamedTypeReferenceBuilder)
		) -> Optional[Optional[str]]:
	result = _BNGetTypeReferenceBuilderId(nt)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetTypeReferenceBuilderName

_BNGetTypeReferenceBuilderName = core.BNGetTypeReferenceBuilderName
_BNGetTypeReferenceBuilderName.restype = BNQualifiedName
_BNGetTypeReferenceBuilderName.argtypes = [
		ctypes.POINTER(BNNamedTypeReferenceBuilder),
	]


# noinspection PyPep8Naming
def BNGetTypeReferenceBuilderName(
		nt: ctypes.POINTER(BNNamedTypeReferenceBuilder)
		) -> BNQualifiedName:
	return _BNGetTypeReferenceBuilderName(nt)


# -------------------------------------------------------
# _BNGetTypeReferenceClass

_BNGetTypeReferenceClass = core.BNGetTypeReferenceClass
_BNGetTypeReferenceClass.restype = NamedTypeReferenceClassEnum
_BNGetTypeReferenceClass.argtypes = [
		ctypes.POINTER(BNNamedTypeReference),
	]


# noinspection PyPep8Naming
def BNGetTypeReferenceClass(
		nt: ctypes.POINTER(BNNamedTypeReference)
		) -> NamedTypeReferenceClass:
	return _BNGetTypeReferenceClass(nt)


# -------------------------------------------------------
# _BNGetTypeReferenceId

_BNGetTypeReferenceId = core.BNGetTypeReferenceId
_BNGetTypeReferenceId.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetTypeReferenceId.argtypes = [
		ctypes.POINTER(BNNamedTypeReference),
	]


# noinspection PyPep8Naming
def BNGetTypeReferenceId(
		nt: ctypes.POINTER(BNNamedTypeReference)
		) -> Optional[Optional[str]]:
	result = _BNGetTypeReferenceId(nt)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetTypeReferenceName

_BNGetTypeReferenceName = core.BNGetTypeReferenceName
_BNGetTypeReferenceName.restype = BNQualifiedName
_BNGetTypeReferenceName.argtypes = [
		ctypes.POINTER(BNNamedTypeReference),
	]


# noinspection PyPep8Naming
def BNGetTypeReferenceName(
		nt: ctypes.POINTER(BNNamedTypeReference)
		) -> BNQualifiedName:
	return _BNGetTypeReferenceName(nt)


# -------------------------------------------------------
# _BNGetTypeReferencesForType

_BNGetTypeReferencesForType = core.BNGetTypeReferencesForType
_BNGetTypeReferencesForType.restype = ctypes.POINTER(BNTypeReferenceSource)
_BNGetTypeReferencesForType.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNQualifiedName),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetTypeReferencesForType(
		view: ctypes.POINTER(BNBinaryView), 
		type: ctypes.POINTER(BNQualifiedName), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNTypeReferenceSource)]:
	result = _BNGetTypeReferencesForType(view, type, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetTypeReferencesForTypeField

_BNGetTypeReferencesForTypeField = core.BNGetTypeReferencesForTypeField
_BNGetTypeReferencesForTypeField.restype = ctypes.POINTER(BNTypeReferenceSource)
_BNGetTypeReferencesForTypeField.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNQualifiedName),
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetTypeReferencesForTypeField(
		view: ctypes.POINTER(BNBinaryView), 
		type: ctypes.POINTER(BNQualifiedName), 
		offset: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNTypeReferenceSource)]:
	result = _BNGetTypeReferencesForTypeField(view, type, offset, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetTypeStackAdjustment

_BNGetTypeStackAdjustment = core.BNGetTypeStackAdjustment
_BNGetTypeStackAdjustment.restype = BNOffsetWithConfidence
_BNGetTypeStackAdjustment.argtypes = [
		ctypes.POINTER(BNType),
	]


# noinspection PyPep8Naming
def BNGetTypeStackAdjustment(
		type: ctypes.POINTER(BNType)
		) -> BNOffsetWithConfidence:
	return _BNGetTypeStackAdjustment(type)


# -------------------------------------------------------
# _BNGetTypeString

_BNGetTypeString = core.BNGetTypeString
_BNGetTypeString.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetTypeString.argtypes = [
		ctypes.POINTER(BNType),
		ctypes.POINTER(BNPlatform),
		TokenEscapingTypeEnum,
	]


# noinspection PyPep8Naming
def BNGetTypeString(
		type: ctypes.POINTER(BNType), 
		platform: ctypes.POINTER(BNPlatform), 
		escaping: TokenEscapingType
		) -> Optional[Optional[str]]:
	result = _BNGetTypeString(type, platform, escaping)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetTypeStringAfterName

_BNGetTypeStringAfterName = core.BNGetTypeStringAfterName
_BNGetTypeStringAfterName.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetTypeStringAfterName.argtypes = [
		ctypes.POINTER(BNType),
		ctypes.POINTER(BNPlatform),
		TokenEscapingTypeEnum,
	]


# noinspection PyPep8Naming
def BNGetTypeStringAfterName(
		type: ctypes.POINTER(BNType), 
		platform: ctypes.POINTER(BNPlatform), 
		escaping: TokenEscapingType
		) -> Optional[Optional[str]]:
	result = _BNGetTypeStringAfterName(type, platform, escaping)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetTypeStringBeforeName

_BNGetTypeStringBeforeName = core.BNGetTypeStringBeforeName
_BNGetTypeStringBeforeName.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetTypeStringBeforeName.argtypes = [
		ctypes.POINTER(BNType),
		ctypes.POINTER(BNPlatform),
		TokenEscapingTypeEnum,
	]


# noinspection PyPep8Naming
def BNGetTypeStringBeforeName(
		type: ctypes.POINTER(BNType), 
		platform: ctypes.POINTER(BNPlatform), 
		escaping: TokenEscapingType
		) -> Optional[Optional[str]]:
	result = _BNGetTypeStringBeforeName(type, platform, escaping)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetTypeStructure

_BNGetTypeStructure = core.BNGetTypeStructure
_BNGetTypeStructure.restype = ctypes.POINTER(BNStructure)
_BNGetTypeStructure.argtypes = [
		ctypes.POINTER(BNType),
	]


# noinspection PyPep8Naming
def BNGetTypeStructure(
		type: ctypes.POINTER(BNType)
		) -> Optional[ctypes.POINTER(BNStructure)]:
	result = _BNGetTypeStructure(type)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetTypeTokens

_BNGetTypeTokens = core.BNGetTypeTokens
_BNGetTypeTokens.restype = ctypes.POINTER(BNInstructionTextToken)
_BNGetTypeTokens.argtypes = [
		ctypes.POINTER(BNType),
		ctypes.POINTER(BNPlatform),
		ctypes.c_ubyte,
		TokenEscapingTypeEnum,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetTypeTokens(
		type: ctypes.POINTER(BNType), 
		platform: ctypes.POINTER(BNPlatform), 
		baseConfidence: int, 
		escaping: TokenEscapingType, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNInstructionTextToken)]:
	result = _BNGetTypeTokens(type, platform, baseConfidence, escaping, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetTypeTokensAfterName

_BNGetTypeTokensAfterName = core.BNGetTypeTokensAfterName
_BNGetTypeTokensAfterName.restype = ctypes.POINTER(BNInstructionTextToken)
_BNGetTypeTokensAfterName.argtypes = [
		ctypes.POINTER(BNType),
		ctypes.POINTER(BNPlatform),
		ctypes.c_ubyte,
		TokenEscapingTypeEnum,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetTypeTokensAfterName(
		type: ctypes.POINTER(BNType), 
		platform: ctypes.POINTER(BNPlatform), 
		baseConfidence: int, 
		escaping: TokenEscapingType, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNInstructionTextToken)]:
	result = _BNGetTypeTokensAfterName(type, platform, baseConfidence, escaping, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetTypeTokensBeforeName

_BNGetTypeTokensBeforeName = core.BNGetTypeTokensBeforeName
_BNGetTypeTokensBeforeName.restype = ctypes.POINTER(BNInstructionTextToken)
_BNGetTypeTokensBeforeName.argtypes = [
		ctypes.POINTER(BNType),
		ctypes.POINTER(BNPlatform),
		ctypes.c_ubyte,
		TokenEscapingTypeEnum,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetTypeTokensBeforeName(
		type: ctypes.POINTER(BNType), 
		platform: ctypes.POINTER(BNPlatform), 
		baseConfidence: int, 
		escaping: TokenEscapingType, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNInstructionTextToken)]:
	result = _BNGetTypeTokensBeforeName(type, platform, baseConfidence, escaping, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetTypeWidth

_BNGetTypeWidth = core.BNGetTypeWidth
_BNGetTypeWidth.restype = ctypes.c_ulonglong
_BNGetTypeWidth.argtypes = [
		ctypes.POINTER(BNType),
	]


# noinspection PyPep8Naming
def BNGetTypeWidth(
		type: ctypes.POINTER(BNType)
		) -> int:
	return _BNGetTypeWidth(type)


# -------------------------------------------------------
# _BNGetTypesReferenced

_BNGetTypesReferenced = core.BNGetTypesReferenced
_BNGetTypesReferenced.restype = ctypes.POINTER(BNTypeWithConfidence)
_BNGetTypesReferenced.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNQualifiedName),
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetTypesReferenced(
		view: ctypes.POINTER(BNBinaryView), 
		type: ctypes.POINTER(BNQualifiedName), 
		offset: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNTypeWithConfidence)]:
	result = _BNGetTypesReferenced(view, type, offset, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetUndoEntries

_BNGetUndoEntries = core.BNGetUndoEntries
_BNGetUndoEntries.restype = ctypes.POINTER(BNUndoEntry)
_BNGetUndoEntries.argtypes = [
		ctypes.POINTER(BNFileMetadata),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetUndoEntries(
		file: ctypes.POINTER(BNFileMetadata), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNUndoEntry)]:
	result = _BNGetUndoEntries(file, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetUniqueIdentifierString

_BNGetUniqueIdentifierString = core.BNGetUniqueIdentifierString
_BNGetUniqueIdentifierString.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetUniqueIdentifierString.argtypes = [
	]


# noinspection PyPep8Naming
def BNGetUniqueIdentifierString(
		) -> Optional[Optional[str]]:
	result = _BNGetUniqueIdentifierString()
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetUniqueSectionNames

_BNGetUniqueSectionNames = core.BNGetUniqueSectionNames
_BNGetUniqueSectionNames.restype = ctypes.POINTER(ctypes.c_char_p)
_BNGetUniqueSectionNames.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(ctypes.c_char_p),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNGetUniqueSectionNames(
		view: ctypes.POINTER(BNBinaryView), 
		names: ctypes.POINTER(ctypes.c_char_p), 
		count: int
		) -> Optional[ctypes.POINTER(ctypes.c_char_p)]:
	result = _BNGetUniqueSectionNames(view, names, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetUnresolvedIndirectBranches

_BNGetUnresolvedIndirectBranches = core.BNGetUnresolvedIndirectBranches
_BNGetUnresolvedIndirectBranches.restype = ctypes.POINTER(ctypes.c_ulonglong)
_BNGetUnresolvedIndirectBranches.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetUnresolvedIndirectBranches(
		func: ctypes.POINTER(BNFunction), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_ulonglong)]:
	result = _BNGetUnresolvedIndirectBranches(func, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetUnresolvedStackAdjustmentGraph

_BNGetUnresolvedStackAdjustmentGraph = core.BNGetUnresolvedStackAdjustmentGraph
_BNGetUnresolvedStackAdjustmentGraph.restype = ctypes.POINTER(BNFlowGraph)
_BNGetUnresolvedStackAdjustmentGraph.argtypes = [
		ctypes.POINTER(BNFunction),
	]


# noinspection PyPep8Naming
def BNGetUnresolvedStackAdjustmentGraph(
		func: ctypes.POINTER(BNFunction)
		) -> Optional[ctypes.POINTER(BNFlowGraph)]:
	result = _BNGetUnresolvedStackAdjustmentGraph(func)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetUpdateChannelVersions

_BNGetUpdateChannelVersions = core.BNGetUpdateChannelVersions
_BNGetUpdateChannelVersions.restype = ctypes.POINTER(BNUpdateVersion)
_BNGetUpdateChannelVersions.argtypes = [
		ctypes.c_char_p,
		ctypes.POINTER(ctypes.c_ulonglong),
		ctypes.POINTER(ctypes.c_char_p),
	]


# noinspection PyPep8Naming
def BNGetUpdateChannelVersions(
		channel: Optional[str], 
		count: ctypes.POINTER(ctypes.c_ulonglong), 
		errors: ctypes.POINTER(ctypes.c_char_p)
		) -> Optional[ctypes.POINTER(BNUpdateVersion)]:
	result = _BNGetUpdateChannelVersions(cstr(channel), count, errors)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetUpdateChannels

_BNGetUpdateChannels = core.BNGetUpdateChannels
_BNGetUpdateChannels.restype = ctypes.POINTER(BNUpdateChannel)
_BNGetUpdateChannels.argtypes = [
		ctypes.POINTER(ctypes.c_ulonglong),
		ctypes.POINTER(ctypes.c_char_p),
	]


# noinspection PyPep8Naming
def BNGetUpdateChannels(
		count: ctypes.POINTER(ctypes.c_ulonglong), 
		errors: ctypes.POINTER(ctypes.c_char_p)
		) -> Optional[ctypes.POINTER(BNUpdateChannel)]:
	result = _BNGetUpdateChannels(count, errors)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetUserAddressTagReferences

_BNGetUserAddressTagReferences = core.BNGetUserAddressTagReferences
_BNGetUserAddressTagReferences.restype = ctypes.POINTER(BNTagReference)
_BNGetUserAddressTagReferences.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetUserAddressTagReferences(
		func: ctypes.POINTER(BNFunction), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNTagReference)]:
	result = _BNGetUserAddressTagReferences(func, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetUserAddressTags

_BNGetUserAddressTags = core.BNGetUserAddressTags
_BNGetUserAddressTags.restype = ctypes.POINTER(ctypes.POINTER(BNTag))
_BNGetUserAddressTags.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNArchitecture),
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetUserAddressTags(
		func: ctypes.POINTER(BNFunction), 
		arch: ctypes.POINTER(BNArchitecture), 
		addr: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.POINTER(BNTag))]:
	result = _BNGetUserAddressTags(func, arch, addr, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetUserAddressTagsInRange

_BNGetUserAddressTagsInRange = core.BNGetUserAddressTagsInRange
_BNGetUserAddressTagsInRange.restype = ctypes.POINTER(BNTagReference)
_BNGetUserAddressTagsInRange.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNArchitecture),
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetUserAddressTagsInRange(
		func: ctypes.POINTER(BNFunction), 
		arch: ctypes.POINTER(BNArchitecture), 
		start: int, 
		end: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNTagReference)]:
	result = _BNGetUserAddressTagsInRange(func, arch, start, end, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetUserAddressTagsOfType

_BNGetUserAddressTagsOfType = core.BNGetUserAddressTagsOfType
_BNGetUserAddressTagsOfType.restype = ctypes.POINTER(ctypes.POINTER(BNTag))
_BNGetUserAddressTagsOfType.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNArchitecture),
		ctypes.c_ulonglong,
		ctypes.POINTER(BNTagType),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetUserAddressTagsOfType(
		func: ctypes.POINTER(BNFunction), 
		arch: ctypes.POINTER(BNArchitecture), 
		addr: int, 
		tagType: ctypes.POINTER(BNTagType), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.POINTER(BNTag))]:
	result = _BNGetUserAddressTagsOfType(func, arch, addr, tagType, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetUserDataTagReferences

_BNGetUserDataTagReferences = core.BNGetUserDataTagReferences
_BNGetUserDataTagReferences.restype = ctypes.POINTER(BNTagReference)
_BNGetUserDataTagReferences.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetUserDataTagReferences(
		view: ctypes.POINTER(BNBinaryView), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNTagReference)]:
	result = _BNGetUserDataTagReferences(view, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetUserDataTags

_BNGetUserDataTags = core.BNGetUserDataTags
_BNGetUserDataTags.restype = ctypes.POINTER(ctypes.POINTER(BNTag))
_BNGetUserDataTags.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetUserDataTags(
		view: ctypes.POINTER(BNBinaryView), 
		addr: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.POINTER(BNTag))]:
	result = _BNGetUserDataTags(view, addr, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetUserDataTagsInRange

_BNGetUserDataTagsInRange = core.BNGetUserDataTagsInRange
_BNGetUserDataTagsInRange.restype = ctypes.POINTER(BNTagReference)
_BNGetUserDataTagsInRange.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetUserDataTagsInRange(
		view: ctypes.POINTER(BNBinaryView), 
		start: int, 
		end: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNTagReference)]:
	result = _BNGetUserDataTagsInRange(view, start, end, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetUserDataTagsOfType

_BNGetUserDataTagsOfType = core.BNGetUserDataTagsOfType
_BNGetUserDataTagsOfType.restype = ctypes.POINTER(ctypes.POINTER(BNTag))
_BNGetUserDataTagsOfType.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
		ctypes.POINTER(BNTagType),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetUserDataTagsOfType(
		view: ctypes.POINTER(BNBinaryView), 
		addr: int, 
		tagType: ctypes.POINTER(BNTagType), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.POINTER(BNTag))]:
	result = _BNGetUserDataTagsOfType(view, addr, tagType, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetUserDirectory

_BNGetUserDirectory = core.BNGetUserDirectory
_BNGetUserDirectory.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetUserDirectory.argtypes = [
	]


# noinspection PyPep8Naming
def BNGetUserDirectory(
		) -> Optional[Optional[str]]:
	result = _BNGetUserDirectory()
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetUserEmail

_BNGetUserEmail = core.BNGetUserEmail
_BNGetUserEmail.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetUserEmail.argtypes = [
		ctypes.POINTER(BNUser),
	]


# noinspection PyPep8Naming
def BNGetUserEmail(
		user: ctypes.POINTER(BNUser)
		) -> Optional[Optional[str]]:
	result = _BNGetUserEmail(user)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetUserFunctionTagReferences

_BNGetUserFunctionTagReferences = core.BNGetUserFunctionTagReferences
_BNGetUserFunctionTagReferences.restype = ctypes.POINTER(BNTagReference)
_BNGetUserFunctionTagReferences.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetUserFunctionTagReferences(
		func: ctypes.POINTER(BNFunction), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNTagReference)]:
	result = _BNGetUserFunctionTagReferences(func, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetUserFunctionTags

_BNGetUserFunctionTags = core.BNGetUserFunctionTags
_BNGetUserFunctionTags.restype = ctypes.POINTER(ctypes.POINTER(BNTag))
_BNGetUserFunctionTags.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetUserFunctionTags(
		func: ctypes.POINTER(BNFunction), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.POINTER(BNTag))]:
	result = _BNGetUserFunctionTags(func, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetUserFunctionTagsOfType

_BNGetUserFunctionTagsOfType = core.BNGetUserFunctionTagsOfType
_BNGetUserFunctionTagsOfType.restype = ctypes.POINTER(ctypes.POINTER(BNTag))
_BNGetUserFunctionTagsOfType.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNTagType),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetUserFunctionTagsOfType(
		func: ctypes.POINTER(BNFunction), 
		tagType: ctypes.POINTER(BNTagType), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.POINTER(BNTag))]:
	result = _BNGetUserFunctionTagsOfType(func, tagType, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetUserId

_BNGetUserId = core.BNGetUserId
_BNGetUserId.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetUserId.argtypes = [
		ctypes.POINTER(BNUser),
	]


# noinspection PyPep8Naming
def BNGetUserId(
		user: ctypes.POINTER(BNUser)
		) -> Optional[Optional[str]]:
	result = _BNGetUserId(user)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetUserName

_BNGetUserName = core.BNGetUserName
_BNGetUserName.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetUserName.argtypes = [
		ctypes.POINTER(BNUser),
	]


# noinspection PyPep8Naming
def BNGetUserName(
		user: ctypes.POINTER(BNUser)
		) -> Optional[Optional[str]]:
	result = _BNGetUserName(user)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetUserPluginDirectory

_BNGetUserPluginDirectory = core.BNGetUserPluginDirectory
_BNGetUserPluginDirectory.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetUserPluginDirectory.argtypes = [
	]


# noinspection PyPep8Naming
def BNGetUserPluginDirectory(
		) -> Optional[Optional[str]]:
	result = _BNGetUserPluginDirectory()
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetUsers

_BNGetUsers = core.BNGetUsers
_BNGetUsers.restype = ctypes.POINTER(ctypes.POINTER(BNUser))
_BNGetUsers.argtypes = [
		ctypes.POINTER(BNFileMetadata),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetUsers(
		file: ctypes.POINTER(BNFileMetadata), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.POINTER(BNUser))]:
	result = _BNGetUsers(file, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetValidPluginCommands

_BNGetValidPluginCommands = core.BNGetValidPluginCommands
_BNGetValidPluginCommands.restype = ctypes.POINTER(BNPluginCommand)
_BNGetValidPluginCommands.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetValidPluginCommands(
		view: ctypes.POINTER(BNBinaryView), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNPluginCommand)]:
	result = _BNGetValidPluginCommands(view, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetValidPluginCommandsForAddress

_BNGetValidPluginCommandsForAddress = core.BNGetValidPluginCommandsForAddress
_BNGetValidPluginCommandsForAddress.restype = ctypes.POINTER(BNPluginCommand)
_BNGetValidPluginCommandsForAddress.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetValidPluginCommandsForAddress(
		view: ctypes.POINTER(BNBinaryView), 
		addr: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNPluginCommand)]:
	result = _BNGetValidPluginCommandsForAddress(view, addr, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetValidPluginCommandsForFunction

_BNGetValidPluginCommandsForFunction = core.BNGetValidPluginCommandsForFunction
_BNGetValidPluginCommandsForFunction.restype = ctypes.POINTER(BNPluginCommand)
_BNGetValidPluginCommandsForFunction.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetValidPluginCommandsForFunction(
		view: ctypes.POINTER(BNBinaryView), 
		func: ctypes.POINTER(BNFunction), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNPluginCommand)]:
	result = _BNGetValidPluginCommandsForFunction(view, func, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetValidPluginCommandsForHighLevelILFunction

_BNGetValidPluginCommandsForHighLevelILFunction = core.BNGetValidPluginCommandsForHighLevelILFunction
_BNGetValidPluginCommandsForHighLevelILFunction.restype = ctypes.POINTER(BNPluginCommand)
_BNGetValidPluginCommandsForHighLevelILFunction.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNHighLevelILFunction),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetValidPluginCommandsForHighLevelILFunction(
		view: ctypes.POINTER(BNBinaryView), 
		func: ctypes.POINTER(BNHighLevelILFunction), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNPluginCommand)]:
	result = _BNGetValidPluginCommandsForHighLevelILFunction(view, func, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetValidPluginCommandsForHighLevelILInstruction

_BNGetValidPluginCommandsForHighLevelILInstruction = core.BNGetValidPluginCommandsForHighLevelILInstruction
_BNGetValidPluginCommandsForHighLevelILInstruction.restype = ctypes.POINTER(BNPluginCommand)
_BNGetValidPluginCommandsForHighLevelILInstruction.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNHighLevelILFunction),
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetValidPluginCommandsForHighLevelILInstruction(
		view: ctypes.POINTER(BNBinaryView), 
		func: ctypes.POINTER(BNHighLevelILFunction), 
		instr: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNPluginCommand)]:
	result = _BNGetValidPluginCommandsForHighLevelILInstruction(view, func, instr, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetValidPluginCommandsForLowLevelILFunction

_BNGetValidPluginCommandsForLowLevelILFunction = core.BNGetValidPluginCommandsForLowLevelILFunction
_BNGetValidPluginCommandsForLowLevelILFunction.restype = ctypes.POINTER(BNPluginCommand)
_BNGetValidPluginCommandsForLowLevelILFunction.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNLowLevelILFunction),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetValidPluginCommandsForLowLevelILFunction(
		view: ctypes.POINTER(BNBinaryView), 
		func: ctypes.POINTER(BNLowLevelILFunction), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNPluginCommand)]:
	result = _BNGetValidPluginCommandsForLowLevelILFunction(view, func, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetValidPluginCommandsForLowLevelILInstruction

_BNGetValidPluginCommandsForLowLevelILInstruction = core.BNGetValidPluginCommandsForLowLevelILInstruction
_BNGetValidPluginCommandsForLowLevelILInstruction.restype = ctypes.POINTER(BNPluginCommand)
_BNGetValidPluginCommandsForLowLevelILInstruction.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNLowLevelILFunction),
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetValidPluginCommandsForLowLevelILInstruction(
		view: ctypes.POINTER(BNBinaryView), 
		func: ctypes.POINTER(BNLowLevelILFunction), 
		instr: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNPluginCommand)]:
	result = _BNGetValidPluginCommandsForLowLevelILInstruction(view, func, instr, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetValidPluginCommandsForMediumLevelILFunction

_BNGetValidPluginCommandsForMediumLevelILFunction = core.BNGetValidPluginCommandsForMediumLevelILFunction
_BNGetValidPluginCommandsForMediumLevelILFunction.restype = ctypes.POINTER(BNPluginCommand)
_BNGetValidPluginCommandsForMediumLevelILFunction.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNMediumLevelILFunction),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetValidPluginCommandsForMediumLevelILFunction(
		view: ctypes.POINTER(BNBinaryView), 
		func: ctypes.POINTER(BNMediumLevelILFunction), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNPluginCommand)]:
	result = _BNGetValidPluginCommandsForMediumLevelILFunction(view, func, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetValidPluginCommandsForMediumLevelILInstruction

_BNGetValidPluginCommandsForMediumLevelILInstruction = core.BNGetValidPluginCommandsForMediumLevelILInstruction
_BNGetValidPluginCommandsForMediumLevelILInstruction.restype = ctypes.POINTER(BNPluginCommand)
_BNGetValidPluginCommandsForMediumLevelILInstruction.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNMediumLevelILFunction),
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetValidPluginCommandsForMediumLevelILInstruction(
		view: ctypes.POINTER(BNBinaryView), 
		func: ctypes.POINTER(BNMediumLevelILFunction), 
		instr: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNPluginCommand)]:
	result = _BNGetValidPluginCommandsForMediumLevelILInstruction(view, func, instr, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetValidPluginCommandsForRange

_BNGetValidPluginCommandsForRange = core.BNGetValidPluginCommandsForRange
_BNGetValidPluginCommandsForRange.restype = ctypes.POINTER(BNPluginCommand)
_BNGetValidPluginCommandsForRange.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetValidPluginCommandsForRange(
		view: ctypes.POINTER(BNBinaryView), 
		addr: int, 
		len: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNPluginCommand)]:
	result = _BNGetValidPluginCommandsForRange(view, addr, len, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetVariableName

_BNGetVariableName = core.BNGetVariableName
_BNGetVariableName.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetVariableName.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNVariable),
	]


# noinspection PyPep8Naming
def BNGetVariableName(
		func: ctypes.POINTER(BNFunction), 
		var: ctypes.POINTER(BNVariable)
		) -> Optional[Optional[str]]:
	result = _BNGetVariableName(func, var)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetVariableNameOrDefault

_BNGetVariableNameOrDefault = core.BNGetVariableNameOrDefault
_BNGetVariableNameOrDefault.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetVariableNameOrDefault.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNVariable),
	]


# noinspection PyPep8Naming
def BNGetVariableNameOrDefault(
		func: ctypes.POINTER(BNFunction), 
		var: ctypes.POINTER(BNVariable)
		) -> Optional[Optional[str]]:
	result = _BNGetVariableNameOrDefault(func, var)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetVariableType

_BNGetVariableType = core.BNGetVariableType
_BNGetVariableType.restype = BNTypeWithConfidence
_BNGetVariableType.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNVariable),
	]


# noinspection PyPep8Naming
def BNGetVariableType(
		func: ctypes.POINTER(BNFunction), 
		var: ctypes.POINTER(BNVariable)
		) -> BNTypeWithConfidence:
	return _BNGetVariableType(func, var)


# -------------------------------------------------------
# _BNGetVariablesForParameters

_BNGetVariablesForParameters = core.BNGetVariablesForParameters
_BNGetVariablesForParameters.restype = ctypes.POINTER(BNVariable)
_BNGetVariablesForParameters.argtypes = [
		ctypes.POINTER(BNCallingConvention),
		ctypes.POINTER(BNFunctionParameter),
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_uint),
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetVariablesForParameters(
		cc: ctypes.POINTER(BNCallingConvention), 
		params: ctypes.POINTER(BNFunctionParameter), 
		paramCount: int, 
		permittedArgs: ctypes.POINTER(ctypes.c_uint), 
		permittedArgCount: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNVariable)]:
	result = _BNGetVariablesForParameters(cc, params, paramCount, permittedArgs, permittedArgCount, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetVariablesForParametersDefaultPermittedArgs

_BNGetVariablesForParametersDefaultPermittedArgs = core.BNGetVariablesForParametersDefaultPermittedArgs
_BNGetVariablesForParametersDefaultPermittedArgs.restype = ctypes.POINTER(BNVariable)
_BNGetVariablesForParametersDefaultPermittedArgs.argtypes = [
		ctypes.POINTER(BNCallingConvention),
		ctypes.POINTER(BNFunctionParameter),
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetVariablesForParametersDefaultPermittedArgs(
		cc: ctypes.POINTER(BNCallingConvention), 
		params: ctypes.POINTER(BNFunctionParameter), 
		paramCount: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNVariable)]:
	result = _BNGetVariablesForParametersDefaultPermittedArgs(cc, params, paramCount, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetVersionInfo

_BNGetVersionInfo = core.BNGetVersionInfo
_BNGetVersionInfo.restype = BNVersionInfo
_BNGetVersionInfo.argtypes = [
	]


# noinspection PyPep8Naming
def BNGetVersionInfo(
		) -> BNVersionInfo:
	return _BNGetVersionInfo()


# -------------------------------------------------------
# _BNGetVersionString

_BNGetVersionString = core.BNGetVersionString
_BNGetVersionString.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetVersionString.argtypes = [
	]


# noinspection PyPep8Naming
def BNGetVersionString(
		) -> Optional[Optional[str]]:
	result = _BNGetVersionString()
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetVerticalFlowGraphNodeMargin

_BNGetVerticalFlowGraphNodeMargin = core.BNGetVerticalFlowGraphNodeMargin
_BNGetVerticalFlowGraphNodeMargin.restype = ctypes.c_int
_BNGetVerticalFlowGraphNodeMargin.argtypes = [
		ctypes.POINTER(BNFlowGraph),
	]


# noinspection PyPep8Naming
def BNGetVerticalFlowGraphNodeMargin(
		graph: ctypes.POINTER(BNFlowGraph)
		) -> int:
	return _BNGetVerticalFlowGraphNodeMargin(graph)


# -------------------------------------------------------
# _BNGetViewAddressSize

_BNGetViewAddressSize = core.BNGetViewAddressSize
_BNGetViewAddressSize.restype = ctypes.c_ulonglong
_BNGetViewAddressSize.argtypes = [
		ctypes.POINTER(BNBinaryView),
	]


# noinspection PyPep8Naming
def BNGetViewAddressSize(
		view: ctypes.POINTER(BNBinaryView)
		) -> int:
	return _BNGetViewAddressSize(view)


# -------------------------------------------------------
# _BNGetViewForFlowGraph

_BNGetViewForFlowGraph = core.BNGetViewForFlowGraph
_BNGetViewForFlowGraph.restype = ctypes.POINTER(BNBinaryView)
_BNGetViewForFlowGraph.argtypes = [
		ctypes.POINTER(BNFlowGraph),
	]


# noinspection PyPep8Naming
def BNGetViewForFlowGraph(
		graph: ctypes.POINTER(BNFlowGraph)
		) -> Optional[ctypes.POINTER(BNBinaryView)]:
	result = _BNGetViewForFlowGraph(graph)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetViewLength

_BNGetViewLength = core.BNGetViewLength
_BNGetViewLength.restype = ctypes.c_ulonglong
_BNGetViewLength.argtypes = [
		ctypes.POINTER(BNBinaryView),
	]


# noinspection PyPep8Naming
def BNGetViewLength(
		view: ctypes.POINTER(BNBinaryView)
		) -> int:
	return _BNGetViewLength(view)


# -------------------------------------------------------
# _BNGetViewType

_BNGetViewType = core.BNGetViewType
_BNGetViewType.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetViewType.argtypes = [
		ctypes.POINTER(BNBinaryView),
	]


# noinspection PyPep8Naming
def BNGetViewType(
		view: ctypes.POINTER(BNBinaryView)
		) -> Optional[Optional[str]]:
	result = _BNGetViewType(view)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetVisibleSymbols

_BNGetVisibleSymbols = core.BNGetVisibleSymbols
_BNGetVisibleSymbols.restype = ctypes.POINTER(ctypes.POINTER(BNSymbol))
_BNGetVisibleSymbols.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(ctypes.c_ulonglong),
		ctypes.POINTER(BNNameSpace),
	]


# noinspection PyPep8Naming
def BNGetVisibleSymbols(
		view: ctypes.POINTER(BNBinaryView), 
		count: ctypes.POINTER(ctypes.c_ulonglong), 
		nameSpace: ctypes.POINTER(BNNameSpace)
		) -> Optional[ctypes.POINTER(ctypes.POINTER(BNSymbol))]:
	result = _BNGetVisibleSymbols(view, count, nameSpace)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetWebsocketProviderByName

_BNGetWebsocketProviderByName = core.BNGetWebsocketProviderByName
_BNGetWebsocketProviderByName.restype = ctypes.POINTER(BNWebsocketProvider)
_BNGetWebsocketProviderByName.argtypes = [
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNGetWebsocketProviderByName(
		name: Optional[str]
		) -> Optional[ctypes.POINTER(BNWebsocketProvider)]:
	result = _BNGetWebsocketProviderByName(cstr(name))
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetWebsocketProviderList

_BNGetWebsocketProviderList = core.BNGetWebsocketProviderList
_BNGetWebsocketProviderList.restype = ctypes.POINTER(ctypes.POINTER(BNWebsocketProvider))
_BNGetWebsocketProviderList.argtypes = [
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetWebsocketProviderList(
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.POINTER(BNWebsocketProvider))]:
	result = _BNGetWebsocketProviderList(count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetWebsocketProviderName

_BNGetWebsocketProviderName = core.BNGetWebsocketProviderName
_BNGetWebsocketProviderName.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetWebsocketProviderName.argtypes = [
		ctypes.POINTER(BNWebsocketProvider),
	]


# noinspection PyPep8Naming
def BNGetWebsocketProviderName(
		provider: ctypes.POINTER(BNWebsocketProvider)
		) -> Optional[Optional[str]]:
	result = _BNGetWebsocketProviderName(provider)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetWorkerThreadCount

_BNGetWorkerThreadCount = core.BNGetWorkerThreadCount
_BNGetWorkerThreadCount.restype = ctypes.c_ulonglong
_BNGetWorkerThreadCount.argtypes = [
	]


# noinspection PyPep8Naming
def BNGetWorkerThreadCount(
		) -> int:
	return _BNGetWorkerThreadCount()


# -------------------------------------------------------
# _BNGetWorkflowForBinaryView

_BNGetWorkflowForBinaryView = core.BNGetWorkflowForBinaryView
_BNGetWorkflowForBinaryView.restype = ctypes.POINTER(BNWorkflow)
_BNGetWorkflowForBinaryView.argtypes = [
		ctypes.POINTER(BNBinaryView),
	]


# noinspection PyPep8Naming
def BNGetWorkflowForBinaryView(
		view: ctypes.POINTER(BNBinaryView)
		) -> Optional[ctypes.POINTER(BNWorkflow)]:
	result = _BNGetWorkflowForBinaryView(view)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetWorkflowForFunction

_BNGetWorkflowForFunction = core.BNGetWorkflowForFunction
_BNGetWorkflowForFunction.restype = ctypes.POINTER(BNWorkflow)
_BNGetWorkflowForFunction.argtypes = [
		ctypes.POINTER(BNFunction),
	]


# noinspection PyPep8Naming
def BNGetWorkflowForFunction(
		func: ctypes.POINTER(BNFunction)
		) -> Optional[ctypes.POINTER(BNWorkflow)]:
	result = _BNGetWorkflowForFunction(func)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetWorkflowList

_BNGetWorkflowList = core.BNGetWorkflowList
_BNGetWorkflowList.restype = ctypes.POINTER(ctypes.POINTER(BNWorkflow))
_BNGetWorkflowList.argtypes = [
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNGetWorkflowList(
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.POINTER(BNWorkflow))]:
	result = _BNGetWorkflowList(count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNGetWorkflowName

_BNGetWorkflowName = core.BNGetWorkflowName
_BNGetWorkflowName.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetWorkflowName.argtypes = [
		ctypes.POINTER(BNWorkflow),
	]


# noinspection PyPep8Naming
def BNGetWorkflowName(
		workflow: ctypes.POINTER(BNWorkflow)
		) -> Optional[Optional[str]]:
	result = _BNGetWorkflowName(workflow)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNGetWriterPosition

_BNGetWriterPosition = core.BNGetWriterPosition
_BNGetWriterPosition.restype = ctypes.c_ulonglong
_BNGetWriterPosition.argtypes = [
		ctypes.POINTER(BNBinaryWriter),
	]


# noinspection PyPep8Naming
def BNGetWriterPosition(
		stream: ctypes.POINTER(BNBinaryWriter)
		) -> int:
	return _BNGetWriterPosition(stream)


# -------------------------------------------------------
# _BNHasDataVariables

_BNHasDataVariables = core.BNHasDataVariables
_BNHasDataVariables.restype = ctypes.c_bool
_BNHasDataVariables.argtypes = [
		ctypes.POINTER(BNBinaryView),
	]


# noinspection PyPep8Naming
def BNHasDataVariables(
		view: ctypes.POINTER(BNBinaryView)
		) -> bool:
	return _BNHasDataVariables(view)


# -------------------------------------------------------
# _BNHasFunctions

_BNHasFunctions = core.BNHasFunctions
_BNHasFunctions.restype = ctypes.c_bool
_BNHasFunctions.argtypes = [
		ctypes.POINTER(BNBinaryView),
	]


# noinspection PyPep8Naming
def BNHasFunctions(
		view: ctypes.POINTER(BNBinaryView)
		) -> bool:
	return _BNHasFunctions(view)


# -------------------------------------------------------
# _BNHasInitialAnalysis

_BNHasInitialAnalysis = core.BNHasInitialAnalysis
_BNHasInitialAnalysis.restype = ctypes.c_bool
_BNHasInitialAnalysis.argtypes = [
		ctypes.POINTER(BNBinaryView),
	]


# noinspection PyPep8Naming
def BNHasInitialAnalysis(
		view: ctypes.POINTER(BNBinaryView)
		) -> bool:
	return _BNHasInitialAnalysis(view)


# -------------------------------------------------------
# _BNHasSymbols

_BNHasSymbols = core.BNHasSymbols
_BNHasSymbols.restype = ctypes.c_bool
_BNHasSymbols.argtypes = [
		ctypes.POINTER(BNBinaryView),
	]


# noinspection PyPep8Naming
def BNHasSymbols(
		view: ctypes.POINTER(BNBinaryView)
		) -> bool:
	return _BNHasSymbols(view)


# -------------------------------------------------------
# _BNHasUnresolvedIndirectBranches

_BNHasUnresolvedIndirectBranches = core.BNHasUnresolvedIndirectBranches
_BNHasUnresolvedIndirectBranches.restype = ctypes.c_bool
_BNHasUnresolvedIndirectBranches.argtypes = [
		ctypes.POINTER(BNFunction),
	]


# noinspection PyPep8Naming
def BNHasUnresolvedIndirectBranches(
		func: ctypes.POINTER(BNFunction)
		) -> bool:
	return _BNHasUnresolvedIndirectBranches(func)


# -------------------------------------------------------
# _BNHighLevelILAddExpr

_BNHighLevelILAddExpr = core.BNHighLevelILAddExpr
_BNHighLevelILAddExpr.restype = ctypes.c_ulonglong
_BNHighLevelILAddExpr.argtypes = [
		ctypes.POINTER(BNHighLevelILFunction),
		HighLevelILOperationEnum,
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNHighLevelILAddExpr(
		func: ctypes.POINTER(BNHighLevelILFunction), 
		operation: HighLevelILOperation, 
		size: int, 
		a: int, 
		b: int, 
		c: int, 
		d: int, 
		e: int
		) -> int:
	return _BNHighLevelILAddExpr(func, operation, size, a, b, c, d, e)


# -------------------------------------------------------
# _BNHighLevelILAddExprWithLocation

_BNHighLevelILAddExprWithLocation = core.BNHighLevelILAddExprWithLocation
_BNHighLevelILAddExprWithLocation.restype = ctypes.c_ulonglong
_BNHighLevelILAddExprWithLocation.argtypes = [
		ctypes.POINTER(BNHighLevelILFunction),
		HighLevelILOperationEnum,
		ctypes.c_ulonglong,
		ctypes.c_uint,
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNHighLevelILAddExprWithLocation(
		func: ctypes.POINTER(BNHighLevelILFunction), 
		operation: HighLevelILOperation, 
		addr: int, 
		sourceOperand: int, 
		size: int, 
		a: int, 
		b: int, 
		c: int, 
		d: int, 
		e: int
		) -> int:
	return _BNHighLevelILAddExprWithLocation(func, operation, addr, sourceOperand, size, a, b, c, d, e)


# -------------------------------------------------------
# _BNHighLevelILAddOperandList

_BNHighLevelILAddOperandList = core.BNHighLevelILAddOperandList
_BNHighLevelILAddOperandList.restype = ctypes.c_ulonglong
_BNHighLevelILAddOperandList.argtypes = [
		ctypes.POINTER(BNHighLevelILFunction),
		ctypes.POINTER(ctypes.c_ulonglong),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNHighLevelILAddOperandList(
		func: ctypes.POINTER(BNHighLevelILFunction), 
		operands: ctypes.POINTER(ctypes.c_ulonglong), 
		count: int
		) -> int:
	return _BNHighLevelILAddOperandList(func, operands, count)


# -------------------------------------------------------
# _BNHighLevelILExprEqual

_BNHighLevelILExprEqual = core.BNHighLevelILExprEqual
_BNHighLevelILExprEqual.restype = ctypes.c_bool
_BNHighLevelILExprEqual.argtypes = [
		ctypes.POINTER(BNHighLevelILFunction),
		ctypes.c_ulonglong,
		ctypes.POINTER(BNHighLevelILFunction),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNHighLevelILExprEqual(
		leftFunc: ctypes.POINTER(BNHighLevelILFunction), 
		leftExpr: int, 
		rightFunc: ctypes.POINTER(BNHighLevelILFunction), 
		rightExpr: int
		) -> bool:
	return _BNHighLevelILExprEqual(leftFunc, leftExpr, rightFunc, rightExpr)


# -------------------------------------------------------
# _BNHighLevelILExprLessThan

_BNHighLevelILExprLessThan = core.BNHighLevelILExprLessThan
_BNHighLevelILExprLessThan.restype = ctypes.c_bool
_BNHighLevelILExprLessThan.argtypes = [
		ctypes.POINTER(BNHighLevelILFunction),
		ctypes.c_ulonglong,
		ctypes.POINTER(BNHighLevelILFunction),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNHighLevelILExprLessThan(
		leftFunc: ctypes.POINTER(BNHighLevelILFunction), 
		leftExpr: int, 
		rightFunc: ctypes.POINTER(BNHighLevelILFunction), 
		rightExpr: int
		) -> bool:
	return _BNHighLevelILExprLessThan(leftFunc, leftExpr, rightFunc, rightExpr)


# -------------------------------------------------------
# _BNHighLevelILFreeOperandList

_BNHighLevelILFreeOperandList = core.BNHighLevelILFreeOperandList
_BNHighLevelILFreeOperandList.restype = None
_BNHighLevelILFreeOperandList.argtypes = [
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNHighLevelILFreeOperandList(
		operands: ctypes.POINTER(ctypes.c_ulonglong)
		) -> None:
	return _BNHighLevelILFreeOperandList(operands)


# -------------------------------------------------------
# _BNHighLevelILGetCurrentAddress

_BNHighLevelILGetCurrentAddress = core.BNHighLevelILGetCurrentAddress
_BNHighLevelILGetCurrentAddress.restype = ctypes.c_ulonglong
_BNHighLevelILGetCurrentAddress.argtypes = [
		ctypes.POINTER(BNHighLevelILFunction),
	]


# noinspection PyPep8Naming
def BNHighLevelILGetCurrentAddress(
		func: ctypes.POINTER(BNHighLevelILFunction)
		) -> int:
	return _BNHighLevelILGetCurrentAddress(func)


# -------------------------------------------------------
# _BNHighLevelILGetOperandList

_BNHighLevelILGetOperandList = core.BNHighLevelILGetOperandList
_BNHighLevelILGetOperandList.restype = ctypes.POINTER(ctypes.c_ulonglong)
_BNHighLevelILGetOperandList.argtypes = [
		ctypes.POINTER(BNHighLevelILFunction),
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNHighLevelILGetOperandList(
		func: ctypes.POINTER(BNHighLevelILFunction), 
		expr: int, 
		operand: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_ulonglong)]:
	result = _BNHighLevelILGetOperandList(func, expr, operand, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNHighLevelILSetCurrentAddress

_BNHighLevelILSetCurrentAddress = core.BNHighLevelILSetCurrentAddress
_BNHighLevelILSetCurrentAddress.restype = None
_BNHighLevelILSetCurrentAddress.argtypes = [
		ctypes.POINTER(BNHighLevelILFunction),
		ctypes.POINTER(BNArchitecture),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNHighLevelILSetCurrentAddress(
		func: ctypes.POINTER(BNHighLevelILFunction), 
		arch: ctypes.POINTER(BNArchitecture), 
		addr: int
		) -> None:
	return _BNHighLevelILSetCurrentAddress(func, arch, addr)


# -------------------------------------------------------
# _BNImportedFunctionFromImportAddressSymbol

_BNImportedFunctionFromImportAddressSymbol = core.BNImportedFunctionFromImportAddressSymbol
_BNImportedFunctionFromImportAddressSymbol.restype = ctypes.POINTER(BNSymbol)
_BNImportedFunctionFromImportAddressSymbol.argtypes = [
		ctypes.POINTER(BNSymbol),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNImportedFunctionFromImportAddressSymbol(
		sym: ctypes.POINTER(BNSymbol), 
		addr: int
		) -> Optional[ctypes.POINTER(BNSymbol)]:
	result = _BNImportedFunctionFromImportAddressSymbol(sym, addr)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNInitCorePlugins

_BNInitCorePlugins = core.BNInitCorePlugins
_BNInitCorePlugins.restype = ctypes.c_bool
_BNInitCorePlugins.argtypes = [
	]


# noinspection PyPep8Naming
def BNInitCorePlugins(
		) -> bool:
	return _BNInitCorePlugins()


# -------------------------------------------------------
# _BNInitDownloadInstance

_BNInitDownloadInstance = core.BNInitDownloadInstance
_BNInitDownloadInstance.restype = ctypes.POINTER(BNDownloadInstance)
_BNInitDownloadInstance.argtypes = [
		ctypes.POINTER(BNDownloadProvider),
		ctypes.POINTER(BNDownloadInstanceCallbacks),
	]


# noinspection PyPep8Naming
def BNInitDownloadInstance(
		provider: ctypes.POINTER(BNDownloadProvider), 
		callbacks: ctypes.POINTER(BNDownloadInstanceCallbacks)
		) -> Optional[ctypes.POINTER(BNDownloadInstance)]:
	result = _BNInitDownloadInstance(provider, callbacks)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNInitPlugins

_BNInitPlugins = core.BNInitPlugins
_BNInitPlugins.restype = ctypes.c_bool
_BNInitPlugins.argtypes = [
		ctypes.c_bool,
	]


# noinspection PyPep8Naming
def BNInitPlugins(
		allowUserPlugins: bool
		) -> bool:
	return _BNInitPlugins(allowUserPlugins)


# -------------------------------------------------------
# _BNInitRepoPlugins

_BNInitRepoPlugins = core.BNInitRepoPlugins
_BNInitRepoPlugins.restype = None
_BNInitRepoPlugins.argtypes = [
	]


# noinspection PyPep8Naming
def BNInitRepoPlugins(
		) -> None:
	return _BNInitRepoPlugins()


# -------------------------------------------------------
# _BNInitScriptingInstance

_BNInitScriptingInstance = core.BNInitScriptingInstance
_BNInitScriptingInstance.restype = ctypes.POINTER(BNScriptingInstance)
_BNInitScriptingInstance.argtypes = [
		ctypes.POINTER(BNScriptingProvider),
		ctypes.POINTER(BNScriptingInstanceCallbacks),
	]


# noinspection PyPep8Naming
def BNInitScriptingInstance(
		provider: ctypes.POINTER(BNScriptingProvider), 
		callbacks: ctypes.POINTER(BNScriptingInstanceCallbacks)
		) -> Optional[ctypes.POINTER(BNScriptingInstance)]:
	result = _BNInitScriptingInstance(provider, callbacks)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNInitUserPlugins

_BNInitUserPlugins = core.BNInitUserPlugins
_BNInitUserPlugins.restype = None
_BNInitUserPlugins.argtypes = [
	]


# noinspection PyPep8Naming
def BNInitUserPlugins(
		) -> None:
	return _BNInitUserPlugins()


# -------------------------------------------------------
# _BNInitWebsocketClient

_BNInitWebsocketClient = core.BNInitWebsocketClient
_BNInitWebsocketClient.restype = ctypes.POINTER(BNWebsocketClient)
_BNInitWebsocketClient.argtypes = [
		ctypes.POINTER(BNWebsocketProvider),
		ctypes.POINTER(BNWebsocketClientCallbacks),
	]


# noinspection PyPep8Naming
def BNInitWebsocketClient(
		provider: ctypes.POINTER(BNWebsocketProvider), 
		callbacks: ctypes.POINTER(BNWebsocketClientCallbacks)
		) -> Optional[ctypes.POINTER(BNWebsocketClient)]:
	result = _BNInitWebsocketClient(provider, callbacks)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNInsertViewBuffer

_BNInsertViewBuffer = core.BNInsertViewBuffer
_BNInsertViewBuffer.restype = ctypes.c_ulonglong
_BNInsertViewBuffer.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
		ctypes.POINTER(BNDataBuffer),
	]


# noinspection PyPep8Naming
def BNInsertViewBuffer(
		view: ctypes.POINTER(BNBinaryView), 
		offset: int, 
		data: ctypes.POINTER(BNDataBuffer)
		) -> int:
	return _BNInsertViewBuffer(view, offset, data)


# -------------------------------------------------------
# _BNInsertViewData

_BNInsertViewData = core.BNInsertViewData
_BNInsertViewData.restype = ctypes.c_ulonglong
_BNInsertViewData.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
		ctypes.c_void_p,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNInsertViewData(
		view: ctypes.POINTER(BNBinaryView), 
		offset: int, 
		data: Optional[ctypes.c_void_p], 
		len: int
		) -> int:
	return _BNInsertViewData(view, offset, data, len)


# -------------------------------------------------------
# _BNInstallPendingUpdate

_BNInstallPendingUpdate = core.BNInstallPendingUpdate
_BNInstallPendingUpdate.restype = None
_BNInstallPendingUpdate.argtypes = [
		ctypes.POINTER(ctypes.c_char_p),
	]


# noinspection PyPep8Naming
def BNInstallPendingUpdate(
		errors: ctypes.POINTER(ctypes.c_char_p)
		) -> None:
	return _BNInstallPendingUpdate(errors)


# -------------------------------------------------------
# _BNInstallScriptingProviderModules

_BNInstallScriptingProviderModules = core.BNInstallScriptingProviderModules
_BNInstallScriptingProviderModules.restype = ctypes.c_bool
_BNInstallScriptingProviderModules.argtypes = [
		ctypes.POINTER(BNScriptingProvider),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNInstallScriptingProviderModules(
		provider: ctypes.POINTER(BNScriptingProvider), 
		modules: Optional[str]
		) -> bool:
	return _BNInstallScriptingProviderModules(provider, cstr(modules))


# -------------------------------------------------------
# _BNInvertBranch

_BNInvertBranch = core.BNInvertBranch
_BNInvertBranch.restype = ctypes.c_bool
_BNInvertBranch.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNArchitecture),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNInvertBranch(
		view: ctypes.POINTER(BNBinaryView), 
		arch: ctypes.POINTER(BNArchitecture), 
		addr: int
		) -> bool:
	return _BNInvertBranch(view, arch, addr)


# -------------------------------------------------------
# _BNIsAlwaysBranchPatchAvailable

_BNIsAlwaysBranchPatchAvailable = core.BNIsAlwaysBranchPatchAvailable
_BNIsAlwaysBranchPatchAvailable.restype = ctypes.c_bool
_BNIsAlwaysBranchPatchAvailable.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNArchitecture),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNIsAlwaysBranchPatchAvailable(
		view: ctypes.POINTER(BNBinaryView), 
		arch: ctypes.POINTER(BNArchitecture), 
		addr: int
		) -> bool:
	return _BNIsAlwaysBranchPatchAvailable(view, arch, addr)


# -------------------------------------------------------
# _BNIsAnalysisChanged

_BNIsAnalysisChanged = core.BNIsAnalysisChanged
_BNIsAnalysisChanged.restype = ctypes.c_bool
_BNIsAnalysisChanged.argtypes = [
		ctypes.POINTER(BNFileMetadata),
	]


# noinspection PyPep8Naming
def BNIsAnalysisChanged(
		file: ctypes.POINTER(BNFileMetadata)
		) -> bool:
	return _BNIsAnalysisChanged(file)


# -------------------------------------------------------
# _BNIsAnalysisTypeAutoDefined

_BNIsAnalysisTypeAutoDefined = core.BNIsAnalysisTypeAutoDefined
_BNIsAnalysisTypeAutoDefined.restype = ctypes.c_bool
_BNIsAnalysisTypeAutoDefined.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNQualifiedName),
	]


# noinspection PyPep8Naming
def BNIsAnalysisTypeAutoDefined(
		view: ctypes.POINTER(BNBinaryView), 
		name: ctypes.POINTER(BNQualifiedName)
		) -> bool:
	return _BNIsAnalysisTypeAutoDefined(view, name)


# -------------------------------------------------------
# _BNIsApplyingDebugInfo

_BNIsApplyingDebugInfo = core.BNIsApplyingDebugInfo
_BNIsApplyingDebugInfo.restype = ctypes.c_bool
_BNIsApplyingDebugInfo.argtypes = [
		ctypes.POINTER(BNBinaryView),
	]


# noinspection PyPep8Naming
def BNIsApplyingDebugInfo(
		view: ctypes.POINTER(BNBinaryView)
		) -> bool:
	return _BNIsApplyingDebugInfo(view)


# -------------------------------------------------------
# _BNIsArchitectureAlwaysBranchPatchAvailable

_BNIsArchitectureAlwaysBranchPatchAvailable = core.BNIsArchitectureAlwaysBranchPatchAvailable
_BNIsArchitectureAlwaysBranchPatchAvailable.restype = ctypes.c_bool
_BNIsArchitectureAlwaysBranchPatchAvailable.argtypes = [
		ctypes.POINTER(BNArchitecture),
		ctypes.POINTER(ctypes.c_ubyte),
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNIsArchitectureAlwaysBranchPatchAvailable(
		arch: ctypes.POINTER(BNArchitecture), 
		data: ctypes.POINTER(ctypes.c_ubyte), 
		addr: int, 
		len: int
		) -> bool:
	return _BNIsArchitectureAlwaysBranchPatchAvailable(arch, data, addr, len)


# -------------------------------------------------------
# _BNIsArchitectureGlobalRegister

_BNIsArchitectureGlobalRegister = core.BNIsArchitectureGlobalRegister
_BNIsArchitectureGlobalRegister.restype = ctypes.c_bool
_BNIsArchitectureGlobalRegister.argtypes = [
		ctypes.POINTER(BNArchitecture),
		ctypes.c_uint,
	]


# noinspection PyPep8Naming
def BNIsArchitectureGlobalRegister(
		arch: ctypes.POINTER(BNArchitecture), 
		reg: int
		) -> bool:
	return _BNIsArchitectureGlobalRegister(arch, reg)


# -------------------------------------------------------
# _BNIsArchitectureInvertBranchPatchAvailable

_BNIsArchitectureInvertBranchPatchAvailable = core.BNIsArchitectureInvertBranchPatchAvailable
_BNIsArchitectureInvertBranchPatchAvailable.restype = ctypes.c_bool
_BNIsArchitectureInvertBranchPatchAvailable.argtypes = [
		ctypes.POINTER(BNArchitecture),
		ctypes.POINTER(ctypes.c_ubyte),
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNIsArchitectureInvertBranchPatchAvailable(
		arch: ctypes.POINTER(BNArchitecture), 
		data: ctypes.POINTER(ctypes.c_ubyte), 
		addr: int, 
		len: int
		) -> bool:
	return _BNIsArchitectureInvertBranchPatchAvailable(arch, data, addr, len)


# -------------------------------------------------------
# _BNIsArchitectureNeverBranchPatchAvailable

_BNIsArchitectureNeverBranchPatchAvailable = core.BNIsArchitectureNeverBranchPatchAvailable
_BNIsArchitectureNeverBranchPatchAvailable.restype = ctypes.c_bool
_BNIsArchitectureNeverBranchPatchAvailable.argtypes = [
		ctypes.POINTER(BNArchitecture),
		ctypes.POINTER(ctypes.c_ubyte),
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNIsArchitectureNeverBranchPatchAvailable(
		arch: ctypes.POINTER(BNArchitecture), 
		data: ctypes.POINTER(ctypes.c_ubyte), 
		addr: int, 
		len: int
		) -> bool:
	return _BNIsArchitectureNeverBranchPatchAvailable(arch, data, addr, len)


# -------------------------------------------------------
# _BNIsArchitectureSkipAndReturnValuePatchAvailable

_BNIsArchitectureSkipAndReturnValuePatchAvailable = core.BNIsArchitectureSkipAndReturnValuePatchAvailable
_BNIsArchitectureSkipAndReturnValuePatchAvailable.restype = ctypes.c_bool
_BNIsArchitectureSkipAndReturnValuePatchAvailable.argtypes = [
		ctypes.POINTER(BNArchitecture),
		ctypes.POINTER(ctypes.c_ubyte),
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNIsArchitectureSkipAndReturnValuePatchAvailable(
		arch: ctypes.POINTER(BNArchitecture), 
		data: ctypes.POINTER(ctypes.c_ubyte), 
		addr: int, 
		len: int
		) -> bool:
	return _BNIsArchitectureSkipAndReturnValuePatchAvailable(arch, data, addr, len)


# -------------------------------------------------------
# _BNIsArchitectureSkipAndReturnZeroPatchAvailable

_BNIsArchitectureSkipAndReturnZeroPatchAvailable = core.BNIsArchitectureSkipAndReturnZeroPatchAvailable
_BNIsArchitectureSkipAndReturnZeroPatchAvailable.restype = ctypes.c_bool
_BNIsArchitectureSkipAndReturnZeroPatchAvailable.argtypes = [
		ctypes.POINTER(BNArchitecture),
		ctypes.POINTER(ctypes.c_ubyte),
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNIsArchitectureSkipAndReturnZeroPatchAvailable(
		arch: ctypes.POINTER(BNArchitecture), 
		data: ctypes.POINTER(ctypes.c_ubyte), 
		addr: int, 
		len: int
		) -> bool:
	return _BNIsArchitectureSkipAndReturnZeroPatchAvailable(arch, data, addr, len)


# -------------------------------------------------------
# _BNIsArchitectureSystemRegister

_BNIsArchitectureSystemRegister = core.BNIsArchitectureSystemRegister
_BNIsArchitectureSystemRegister.restype = ctypes.c_bool
_BNIsArchitectureSystemRegister.argtypes = [
		ctypes.POINTER(BNArchitecture),
		ctypes.c_uint,
	]


# noinspection PyPep8Naming
def BNIsArchitectureSystemRegister(
		arch: ctypes.POINTER(BNArchitecture), 
		reg: int
		) -> bool:
	return _BNIsArchitectureSystemRegister(arch, reg)


# -------------------------------------------------------
# _BNIsBackedByDatabase

_BNIsBackedByDatabase = core.BNIsBackedByDatabase
_BNIsBackedByDatabase.restype = ctypes.c_bool
_BNIsBackedByDatabase.argtypes = [
		ctypes.POINTER(BNFileMetadata),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNIsBackedByDatabase(
		file: ctypes.POINTER(BNFileMetadata), 
		binaryViewType: Optional[str]
		) -> bool:
	return _BNIsBackedByDatabase(file, cstr(binaryViewType))


# -------------------------------------------------------
# _BNIsBackgroundTaskCancelled

_BNIsBackgroundTaskCancelled = core.BNIsBackgroundTaskCancelled
_BNIsBackgroundTaskCancelled.restype = ctypes.c_bool
_BNIsBackgroundTaskCancelled.argtypes = [
		ctypes.POINTER(BNBackgroundTask),
	]


# noinspection PyPep8Naming
def BNIsBackgroundTaskCancelled(
		task: ctypes.POINTER(BNBackgroundTask)
		) -> bool:
	return _BNIsBackgroundTaskCancelled(task)


# -------------------------------------------------------
# _BNIsBackgroundTaskFinished

_BNIsBackgroundTaskFinished = core.BNIsBackgroundTaskFinished
_BNIsBackgroundTaskFinished.restype = ctypes.c_bool
_BNIsBackgroundTaskFinished.argtypes = [
		ctypes.POINTER(BNBackgroundTask),
	]


# noinspection PyPep8Naming
def BNIsBackgroundTaskFinished(
		task: ctypes.POINTER(BNBackgroundTask)
		) -> bool:
	return _BNIsBackgroundTaskFinished(task)


# -------------------------------------------------------
# _BNIsBinaryViewTypeDeprecated

_BNIsBinaryViewTypeDeprecated = core.BNIsBinaryViewTypeDeprecated
_BNIsBinaryViewTypeDeprecated.restype = ctypes.c_bool
_BNIsBinaryViewTypeDeprecated.argtypes = [
		ctypes.POINTER(BNBinaryViewType),
	]


# noinspection PyPep8Naming
def BNIsBinaryViewTypeDeprecated(
		type: ctypes.POINTER(BNBinaryViewType)
		) -> bool:
	return _BNIsBinaryViewTypeDeprecated(type)


# -------------------------------------------------------
# _BNIsBinaryViewTypeValidForData

_BNIsBinaryViewTypeValidForData = core.BNIsBinaryViewTypeValidForData
_BNIsBinaryViewTypeValidForData.restype = ctypes.c_bool
_BNIsBinaryViewTypeValidForData.argtypes = [
		ctypes.POINTER(BNBinaryViewType),
		ctypes.POINTER(BNBinaryView),
	]


# noinspection PyPep8Naming
def BNIsBinaryViewTypeValidForData(
		type: ctypes.POINTER(BNBinaryViewType), 
		data: ctypes.POINTER(BNBinaryView)
		) -> bool:
	return _BNIsBinaryViewTypeValidForData(type, data)


# -------------------------------------------------------
# _BNIsCallInstruction

_BNIsCallInstruction = core.BNIsCallInstruction
_BNIsCallInstruction.restype = ctypes.c_bool
_BNIsCallInstruction.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNArchitecture),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNIsCallInstruction(
		func: ctypes.POINTER(BNFunction), 
		arch: ctypes.POINTER(BNArchitecture), 
		addr: int
		) -> bool:
	return _BNIsCallInstruction(func, arch, addr)


# -------------------------------------------------------
# _BNIsDatabase

_BNIsDatabase = core.BNIsDatabase
_BNIsDatabase.restype = ctypes.c_bool
_BNIsDatabase.argtypes = [
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNIsDatabase(
		filename: Optional[str]
		) -> bool:
	return _BNIsDatabase(cstr(filename))


# -------------------------------------------------------
# _BNIsDebugInfoParserValidForView

_BNIsDebugInfoParserValidForView = core.BNIsDebugInfoParserValidForView
_BNIsDebugInfoParserValidForView.restype = ctypes.c_bool
_BNIsDebugInfoParserValidForView.argtypes = [
		ctypes.POINTER(BNDebugInfoParser),
		ctypes.POINTER(BNBinaryView),
	]


# noinspection PyPep8Naming
def BNIsDebugInfoParserValidForView(
		parser: ctypes.POINTER(BNDebugInfoParser), 
		view: ctypes.POINTER(BNBinaryView)
		) -> bool:
	return _BNIsDebugInfoParserValidForView(parser, view)


# -------------------------------------------------------
# _BNIsDisassemblySettingsOptionSet

_BNIsDisassemblySettingsOptionSet = core.BNIsDisassemblySettingsOptionSet
_BNIsDisassemblySettingsOptionSet.restype = ctypes.c_bool
_BNIsDisassemblySettingsOptionSet.argtypes = [
		ctypes.POINTER(BNDisassemblySettings),
		DisassemblyOptionEnum,
	]


# noinspection PyPep8Naming
def BNIsDisassemblySettingsOptionSet(
		settings: ctypes.POINTER(BNDisassemblySettings), 
		option: DisassemblyOption
		) -> bool:
	return _BNIsDisassemblySettingsOptionSet(settings, option)


# -------------------------------------------------------
# _BNIsEligibleForHeuristics

_BNIsEligibleForHeuristics = core.BNIsEligibleForHeuristics
_BNIsEligibleForHeuristics.restype = ctypes.c_bool
_BNIsEligibleForHeuristics.argtypes = [
		ctypes.POINTER(BNCallingConvention),
	]


# noinspection PyPep8Naming
def BNIsEligibleForHeuristics(
		cc: ctypes.POINTER(BNCallingConvention)
		) -> bool:
	return _BNIsEligibleForHeuristics(cc)


# -------------------------------------------------------
# _BNIsEndOfFile

_BNIsEndOfFile = core.BNIsEndOfFile
_BNIsEndOfFile.restype = ctypes.c_bool
_BNIsEndOfFile.argtypes = [
		ctypes.POINTER(BNBinaryReader),
	]


# noinspection PyPep8Naming
def BNIsEndOfFile(
		stream: ctypes.POINTER(BNBinaryReader)
		) -> bool:
	return _BNIsEndOfFile(stream)


# -------------------------------------------------------
# _BNIsEnterpriseServerAuthenticated

_BNIsEnterpriseServerAuthenticated = core.BNIsEnterpriseServerAuthenticated
_BNIsEnterpriseServerAuthenticated.restype = ctypes.c_bool
_BNIsEnterpriseServerAuthenticated.argtypes = [
	]


# noinspection PyPep8Naming
def BNIsEnterpriseServerAuthenticated(
		) -> bool:
	return _BNIsEnterpriseServerAuthenticated()


# -------------------------------------------------------
# _BNIsEnterpriseServerConnected

_BNIsEnterpriseServerConnected = core.BNIsEnterpriseServerConnected
_BNIsEnterpriseServerConnected.restype = ctypes.c_bool
_BNIsEnterpriseServerConnected.argtypes = [
	]


# noinspection PyPep8Naming
def BNIsEnterpriseServerConnected(
		) -> bool:
	return _BNIsEnterpriseServerConnected()


# -------------------------------------------------------
# _BNIsEnterpriseServerFloatingLicense

_BNIsEnterpriseServerFloatingLicense = core.BNIsEnterpriseServerFloatingLicense
_BNIsEnterpriseServerFloatingLicense.restype = ctypes.c_bool
_BNIsEnterpriseServerFloatingLicense.argtypes = [
	]


# noinspection PyPep8Naming
def BNIsEnterpriseServerFloatingLicense(
		) -> bool:
	return _BNIsEnterpriseServerFloatingLicense()


# -------------------------------------------------------
# _BNIsEnterpriseServerInitialized

_BNIsEnterpriseServerInitialized = core.BNIsEnterpriseServerInitialized
_BNIsEnterpriseServerInitialized.restype = ctypes.c_bool
_BNIsEnterpriseServerInitialized.argtypes = [
	]


# noinspection PyPep8Naming
def BNIsEnterpriseServerInitialized(
		) -> bool:
	return _BNIsEnterpriseServerInitialized()


# -------------------------------------------------------
# _BNIsEnterpriseServerLicenseStillActivated

_BNIsEnterpriseServerLicenseStillActivated = core.BNIsEnterpriseServerLicenseStillActivated
_BNIsEnterpriseServerLicenseStillActivated.restype = ctypes.c_bool
_BNIsEnterpriseServerLicenseStillActivated.argtypes = [
	]


# noinspection PyPep8Naming
def BNIsEnterpriseServerLicenseStillActivated(
		) -> bool:
	return _BNIsEnterpriseServerLicenseStillActivated()


# -------------------------------------------------------
# _BNIsExecutableView

_BNIsExecutableView = core.BNIsExecutableView
_BNIsExecutableView.restype = ctypes.c_bool
_BNIsExecutableView.argtypes = [
		ctypes.POINTER(BNBinaryView),
	]


# noinspection PyPep8Naming
def BNIsExecutableView(
		view: ctypes.POINTER(BNBinaryView)
		) -> bool:
	return _BNIsExecutableView(view)


# -------------------------------------------------------
# _BNIsFileModified

_BNIsFileModified = core.BNIsFileModified
_BNIsFileModified.restype = ctypes.c_bool
_BNIsFileModified.argtypes = [
		ctypes.POINTER(BNFileMetadata),
	]


# noinspection PyPep8Naming
def BNIsFileModified(
		file: ctypes.POINTER(BNFileMetadata)
		) -> bool:
	return _BNIsFileModified(file)


# -------------------------------------------------------
# _BNIsFlowGraphLayoutComplete

_BNIsFlowGraphLayoutComplete = core.BNIsFlowGraphLayoutComplete
_BNIsFlowGraphLayoutComplete.restype = ctypes.c_bool
_BNIsFlowGraphLayoutComplete.argtypes = [
		ctypes.POINTER(BNFlowGraph),
	]


# noinspection PyPep8Naming
def BNIsFlowGraphLayoutComplete(
		graph: ctypes.POINTER(BNFlowGraph)
		) -> bool:
	return _BNIsFlowGraphLayoutComplete(graph)


# -------------------------------------------------------
# _BNIsFlowGraphLayoutRequestComplete

_BNIsFlowGraphLayoutRequestComplete = core.BNIsFlowGraphLayoutRequestComplete
_BNIsFlowGraphLayoutRequestComplete.restype = ctypes.c_bool
_BNIsFlowGraphLayoutRequestComplete.argtypes = [
		ctypes.POINTER(BNFlowGraphLayoutRequest),
	]


# noinspection PyPep8Naming
def BNIsFlowGraphLayoutRequestComplete(
		layout: ctypes.POINTER(BNFlowGraphLayoutRequest)
		) -> bool:
	return _BNIsFlowGraphLayoutRequestComplete(layout)


# -------------------------------------------------------
# _BNIsFlowGraphOptionSet

_BNIsFlowGraphOptionSet = core.BNIsFlowGraphOptionSet
_BNIsFlowGraphOptionSet.restype = ctypes.c_bool
_BNIsFlowGraphOptionSet.argtypes = [
		ctypes.POINTER(BNFlowGraph),
		FlowGraphOptionEnum,
	]


# noinspection PyPep8Naming
def BNIsFlowGraphOptionSet(
		graph: ctypes.POINTER(BNFlowGraph), 
		option: FlowGraphOption
		) -> bool:
	return _BNIsFlowGraphOptionSet(graph, option)


# -------------------------------------------------------
# _BNIsFunctionAnalysisSkipped

_BNIsFunctionAnalysisSkipped = core.BNIsFunctionAnalysisSkipped
_BNIsFunctionAnalysisSkipped.restype = ctypes.c_bool
_BNIsFunctionAnalysisSkipped.argtypes = [
		ctypes.POINTER(BNFunction),
	]


# noinspection PyPep8Naming
def BNIsFunctionAnalysisSkipped(
		func: ctypes.POINTER(BNFunction)
		) -> bool:
	return _BNIsFunctionAnalysisSkipped(func)


# -------------------------------------------------------
# _BNIsFunctionInlinedDuringAnalysis

_BNIsFunctionInlinedDuringAnalysis = core.BNIsFunctionInlinedDuringAnalysis
_BNIsFunctionInlinedDuringAnalysis.restype = BNBoolWithConfidence
_BNIsFunctionInlinedDuringAnalysis.argtypes = [
		ctypes.POINTER(BNFunction),
	]


# noinspection PyPep8Naming
def BNIsFunctionInlinedDuringAnalysis(
		func: ctypes.POINTER(BNFunction)
		) -> BNBoolWithConfidence:
	return _BNIsFunctionInlinedDuringAnalysis(func)


# -------------------------------------------------------
# _BNIsFunctionPure

_BNIsFunctionPure = core.BNIsFunctionPure
_BNIsFunctionPure.restype = BNBoolWithConfidence
_BNIsFunctionPure.argtypes = [
		ctypes.POINTER(BNFunction),
	]


# noinspection PyPep8Naming
def BNIsFunctionPure(
		func: ctypes.POINTER(BNFunction)
		) -> BNBoolWithConfidence:
	return _BNIsFunctionPure(func)


# -------------------------------------------------------
# _BNIsFunctionTooLarge

_BNIsFunctionTooLarge = core.BNIsFunctionTooLarge
_BNIsFunctionTooLarge.restype = ctypes.c_bool
_BNIsFunctionTooLarge.argtypes = [
		ctypes.POINTER(BNFunction),
	]


# noinspection PyPep8Naming
def BNIsFunctionTooLarge(
		func: ctypes.POINTER(BNFunction)
		) -> bool:
	return _BNIsFunctionTooLarge(func)


# -------------------------------------------------------
# _BNIsFunctionUpdateNeeded

_BNIsFunctionUpdateNeeded = core.BNIsFunctionUpdateNeeded
_BNIsFunctionUpdateNeeded.restype = ctypes.c_bool
_BNIsFunctionUpdateNeeded.argtypes = [
		ctypes.POINTER(BNFunction),
	]


# noinspection PyPep8Naming
def BNIsFunctionUpdateNeeded(
		func: ctypes.POINTER(BNFunction)
		) -> bool:
	return _BNIsFunctionUpdateNeeded(func)


# -------------------------------------------------------
# _BNIsGNU3MangledString

_BNIsGNU3MangledString = core.BNIsGNU3MangledString
_BNIsGNU3MangledString.restype = ctypes.c_bool
_BNIsGNU3MangledString.argtypes = [
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNIsGNU3MangledString(
		mangledName: Optional[str]
		) -> bool:
	return _BNIsGNU3MangledString(cstr(mangledName))


# -------------------------------------------------------
# _BNIsHighLevelILBasicBlock

_BNIsHighLevelILBasicBlock = core.BNIsHighLevelILBasicBlock
_BNIsHighLevelILBasicBlock.restype = ctypes.c_bool
_BNIsHighLevelILBasicBlock.argtypes = [
		ctypes.POINTER(BNBasicBlock),
	]


# noinspection PyPep8Naming
def BNIsHighLevelILBasicBlock(
		block: ctypes.POINTER(BNBasicBlock)
		) -> bool:
	return _BNIsHighLevelILBasicBlock(block)


# -------------------------------------------------------
# _BNIsHighLevelILFlowGraph

_BNIsHighLevelILFlowGraph = core.BNIsHighLevelILFlowGraph
_BNIsHighLevelILFlowGraph.restype = ctypes.c_bool
_BNIsHighLevelILFlowGraph.argtypes = [
		ctypes.POINTER(BNFlowGraph),
	]


# noinspection PyPep8Naming
def BNIsHighLevelILFlowGraph(
		graph: ctypes.POINTER(BNFlowGraph)
		) -> bool:
	return _BNIsHighLevelILFlowGraph(graph)


# -------------------------------------------------------
# _BNIsHighLevelILSSAVarLive

_BNIsHighLevelILSSAVarLive = core.BNIsHighLevelILSSAVarLive
_BNIsHighLevelILSSAVarLive.restype = ctypes.c_bool
_BNIsHighLevelILSSAVarLive.argtypes = [
		ctypes.POINTER(BNHighLevelILFunction),
		ctypes.POINTER(BNVariable),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNIsHighLevelILSSAVarLive(
		func: ctypes.POINTER(BNHighLevelILFunction), 
		var: ctypes.POINTER(BNVariable), 
		version: int
		) -> bool:
	return _BNIsHighLevelILSSAVarLive(func, var, version)


# -------------------------------------------------------
# _BNIsHighLevelILSSAVarLiveAt

_BNIsHighLevelILSSAVarLiveAt = core.BNIsHighLevelILSSAVarLiveAt
_BNIsHighLevelILSSAVarLiveAt.restype = ctypes.c_bool
_BNIsHighLevelILSSAVarLiveAt.argtypes = [
		ctypes.POINTER(BNHighLevelILFunction),
		ctypes.POINTER(BNVariable),
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNIsHighLevelILSSAVarLiveAt(
		func: ctypes.POINTER(BNHighLevelILFunction), 
		var: ctypes.POINTER(BNVariable), 
		version: int, 
		instr: int
		) -> bool:
	return _BNIsHighLevelILSSAVarLiveAt(func, var, version, instr)


# -------------------------------------------------------
# _BNIsHighLevelILVarLiveAt

_BNIsHighLevelILVarLiveAt = core.BNIsHighLevelILVarLiveAt
_BNIsHighLevelILVarLiveAt.restype = ctypes.c_bool
_BNIsHighLevelILVarLiveAt.argtypes = [
		ctypes.POINTER(BNHighLevelILFunction),
		ctypes.POINTER(BNVariable),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNIsHighLevelILVarLiveAt(
		func: ctypes.POINTER(BNHighLevelILFunction), 
		var: ctypes.POINTER(BNVariable), 
		instr: int
		) -> bool:
	return _BNIsHighLevelILVarLiveAt(func, var, instr)


# -------------------------------------------------------
# _BNIsILBasicBlock

_BNIsILBasicBlock = core.BNIsILBasicBlock
_BNIsILBasicBlock.restype = ctypes.c_bool
_BNIsILBasicBlock.argtypes = [
		ctypes.POINTER(BNBasicBlock),
	]


# noinspection PyPep8Naming
def BNIsILBasicBlock(
		block: ctypes.POINTER(BNBasicBlock)
		) -> bool:
	return _BNIsILBasicBlock(block)


# -------------------------------------------------------
# _BNIsILDisassemblyTextRenderer

_BNIsILDisassemblyTextRenderer = core.BNIsILDisassemblyTextRenderer
_BNIsILDisassemblyTextRenderer.restype = ctypes.c_bool
_BNIsILDisassemblyTextRenderer.argtypes = [
		ctypes.POINTER(BNDisassemblyTextRenderer),
	]


# noinspection PyPep8Naming
def BNIsILDisassemblyTextRenderer(
		renderer: ctypes.POINTER(BNDisassemblyTextRenderer)
		) -> bool:
	return _BNIsILDisassemblyTextRenderer(renderer)


# -------------------------------------------------------
# _BNIsILFlowGraph

_BNIsILFlowGraph = core.BNIsILFlowGraph
_BNIsILFlowGraph.restype = ctypes.c_bool
_BNIsILFlowGraph.argtypes = [
		ctypes.POINTER(BNFlowGraph),
	]


# noinspection PyPep8Naming
def BNIsILFlowGraph(
		graph: ctypes.POINTER(BNFlowGraph)
		) -> bool:
	return _BNIsILFlowGraph(graph)


# -------------------------------------------------------
# _BNIsIntegerToken

_BNIsIntegerToken = core.BNIsIntegerToken
_BNIsIntegerToken.restype = ctypes.c_bool
_BNIsIntegerToken.argtypes = [
		InstructionTextTokenTypeEnum,
	]


# noinspection PyPep8Naming
def BNIsIntegerToken(
		type: InstructionTextTokenType
		) -> bool:
	return _BNIsIntegerToken(type)


# -------------------------------------------------------
# _BNIsInvertBranchPatchAvailable

_BNIsInvertBranchPatchAvailable = core.BNIsInvertBranchPatchAvailable
_BNIsInvertBranchPatchAvailable.restype = ctypes.c_bool
_BNIsInvertBranchPatchAvailable.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNArchitecture),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNIsInvertBranchPatchAvailable(
		view: ctypes.POINTER(BNBinaryView), 
		arch: ctypes.POINTER(BNArchitecture), 
		addr: int
		) -> bool:
	return _BNIsInvertBranchPatchAvailable(view, arch, addr)


# -------------------------------------------------------
# _BNIsKeyValueStoreEmpty

_BNIsKeyValueStoreEmpty = core.BNIsKeyValueStoreEmpty
_BNIsKeyValueStoreEmpty.restype = ctypes.c_bool
_BNIsKeyValueStoreEmpty.argtypes = [
		ctypes.POINTER(BNKeyValueStore),
	]


# noinspection PyPep8Naming
def BNIsKeyValueStoreEmpty(
		store: ctypes.POINTER(BNKeyValueStore)
		) -> bool:
	return _BNIsKeyValueStoreEmpty(store)


# -------------------------------------------------------
# _BNIsLicenseValidated

_BNIsLicenseValidated = core.BNIsLicenseValidated
_BNIsLicenseValidated.restype = ctypes.c_bool
_BNIsLicenseValidated.argtypes = [
	]


# noinspection PyPep8Naming
def BNIsLicenseValidated(
		) -> bool:
	return _BNIsLicenseValidated()


# -------------------------------------------------------
# _BNIsLinearViewCursorAfterEnd

_BNIsLinearViewCursorAfterEnd = core.BNIsLinearViewCursorAfterEnd
_BNIsLinearViewCursorAfterEnd.restype = ctypes.c_bool
_BNIsLinearViewCursorAfterEnd.argtypes = [
		ctypes.POINTER(BNLinearViewCursor),
	]


# noinspection PyPep8Naming
def BNIsLinearViewCursorAfterEnd(
		cursor: ctypes.POINTER(BNLinearViewCursor)
		) -> bool:
	return _BNIsLinearViewCursorAfterEnd(cursor)


# -------------------------------------------------------
# _BNIsLinearViewCursorBeforeBegin

_BNIsLinearViewCursorBeforeBegin = core.BNIsLinearViewCursorBeforeBegin
_BNIsLinearViewCursorBeforeBegin.restype = ctypes.c_bool
_BNIsLinearViewCursorBeforeBegin.argtypes = [
		ctypes.POINTER(BNLinearViewCursor),
	]


# noinspection PyPep8Naming
def BNIsLinearViewCursorBeforeBegin(
		cursor: ctypes.POINTER(BNLinearViewCursor)
		) -> bool:
	return _BNIsLinearViewCursorBeforeBegin(cursor)


# -------------------------------------------------------
# _BNIsLowLevelILBasicBlock

_BNIsLowLevelILBasicBlock = core.BNIsLowLevelILBasicBlock
_BNIsLowLevelILBasicBlock.restype = ctypes.c_bool
_BNIsLowLevelILBasicBlock.argtypes = [
		ctypes.POINTER(BNBasicBlock),
	]


# noinspection PyPep8Naming
def BNIsLowLevelILBasicBlock(
		block: ctypes.POINTER(BNBasicBlock)
		) -> bool:
	return _BNIsLowLevelILBasicBlock(block)


# -------------------------------------------------------
# _BNIsLowLevelILFlowGraph

_BNIsLowLevelILFlowGraph = core.BNIsLowLevelILFlowGraph
_BNIsLowLevelILFlowGraph.restype = ctypes.c_bool
_BNIsLowLevelILFlowGraph.argtypes = [
		ctypes.POINTER(BNFlowGraph),
	]


# noinspection PyPep8Naming
def BNIsLowLevelILFlowGraph(
		graph: ctypes.POINTER(BNFlowGraph)
		) -> bool:
	return _BNIsLowLevelILFlowGraph(graph)


# -------------------------------------------------------
# _BNIsMainThread

_BNIsMainThread = core.BNIsMainThread
_BNIsMainThread.restype = ctypes.c_bool
_BNIsMainThread.argtypes = [
	]


# noinspection PyPep8Naming
def BNIsMainThread(
		) -> bool:
	return _BNIsMainThread()


# -------------------------------------------------------
# _BNIsMainThreadActionDone

_BNIsMainThreadActionDone = core.BNIsMainThreadActionDone
_BNIsMainThreadActionDone.restype = ctypes.c_bool
_BNIsMainThreadActionDone.argtypes = [
		ctypes.POINTER(BNMainThreadAction),
	]


# noinspection PyPep8Naming
def BNIsMainThreadActionDone(
		action: ctypes.POINTER(BNMainThreadAction)
		) -> bool:
	return _BNIsMainThreadActionDone(action)


# -------------------------------------------------------
# _BNIsMediumLevelILBasicBlock

_BNIsMediumLevelILBasicBlock = core.BNIsMediumLevelILBasicBlock
_BNIsMediumLevelILBasicBlock.restype = ctypes.c_bool
_BNIsMediumLevelILBasicBlock.argtypes = [
		ctypes.POINTER(BNBasicBlock),
	]


# noinspection PyPep8Naming
def BNIsMediumLevelILBasicBlock(
		block: ctypes.POINTER(BNBasicBlock)
		) -> bool:
	return _BNIsMediumLevelILBasicBlock(block)


# -------------------------------------------------------
# _BNIsMediumLevelILFlowGraph

_BNIsMediumLevelILFlowGraph = core.BNIsMediumLevelILFlowGraph
_BNIsMediumLevelILFlowGraph.restype = ctypes.c_bool
_BNIsMediumLevelILFlowGraph.argtypes = [
		ctypes.POINTER(BNFlowGraph),
	]


# noinspection PyPep8Naming
def BNIsMediumLevelILFlowGraph(
		graph: ctypes.POINTER(BNFlowGraph)
		) -> bool:
	return _BNIsMediumLevelILFlowGraph(graph)


# -------------------------------------------------------
# _BNIsMediumLevelILSSAVarLive

_BNIsMediumLevelILSSAVarLive = core.BNIsMediumLevelILSSAVarLive
_BNIsMediumLevelILSSAVarLive.restype = ctypes.c_bool
_BNIsMediumLevelILSSAVarLive.argtypes = [
		ctypes.POINTER(BNMediumLevelILFunction),
		ctypes.POINTER(BNVariable),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNIsMediumLevelILSSAVarLive(
		func: ctypes.POINTER(BNMediumLevelILFunction), 
		var: ctypes.POINTER(BNVariable), 
		version: int
		) -> bool:
	return _BNIsMediumLevelILSSAVarLive(func, var, version)


# -------------------------------------------------------
# _BNIsNeverBranchPatchAvailable

_BNIsNeverBranchPatchAvailable = core.BNIsNeverBranchPatchAvailable
_BNIsNeverBranchPatchAvailable.restype = ctypes.c_bool
_BNIsNeverBranchPatchAvailable.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNArchitecture),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNIsNeverBranchPatchAvailable(
		view: ctypes.POINTER(BNBinaryView), 
		arch: ctypes.POINTER(BNArchitecture), 
		addr: int
		) -> bool:
	return _BNIsNeverBranchPatchAvailable(view, arch, addr)


# -------------------------------------------------------
# _BNIsNodeValidForFlowGraph

_BNIsNodeValidForFlowGraph = core.BNIsNodeValidForFlowGraph
_BNIsNodeValidForFlowGraph.restype = ctypes.c_bool
_BNIsNodeValidForFlowGraph.argtypes = [
		ctypes.POINTER(BNFlowGraph),
		ctypes.POINTER(BNFlowGraphNode),
	]


# noinspection PyPep8Naming
def BNIsNodeValidForFlowGraph(
		graph: ctypes.POINTER(BNFlowGraph), 
		node: ctypes.POINTER(BNFlowGraphNode)
		) -> bool:
	return _BNIsNodeValidForFlowGraph(graph, node)


# -------------------------------------------------------
# _BNIsOffsetBackedByFile

_BNIsOffsetBackedByFile = core.BNIsOffsetBackedByFile
_BNIsOffsetBackedByFile.restype = ctypes.c_bool
_BNIsOffsetBackedByFile.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNIsOffsetBackedByFile(
		view: ctypes.POINTER(BNBinaryView), 
		offset: int
		) -> bool:
	return _BNIsOffsetBackedByFile(view, offset)


# -------------------------------------------------------
# _BNIsOffsetCodeSemantics

_BNIsOffsetCodeSemantics = core.BNIsOffsetCodeSemantics
_BNIsOffsetCodeSemantics.restype = ctypes.c_bool
_BNIsOffsetCodeSemantics.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNIsOffsetCodeSemantics(
		view: ctypes.POINTER(BNBinaryView), 
		offset: int
		) -> bool:
	return _BNIsOffsetCodeSemantics(view, offset)


# -------------------------------------------------------
# _BNIsOffsetExecutable

_BNIsOffsetExecutable = core.BNIsOffsetExecutable
_BNIsOffsetExecutable.restype = ctypes.c_bool
_BNIsOffsetExecutable.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNIsOffsetExecutable(
		view: ctypes.POINTER(BNBinaryView), 
		offset: int
		) -> bool:
	return _BNIsOffsetExecutable(view, offset)


# -------------------------------------------------------
# _BNIsOffsetExternSemantics

_BNIsOffsetExternSemantics = core.BNIsOffsetExternSemantics
_BNIsOffsetExternSemantics.restype = ctypes.c_bool
_BNIsOffsetExternSemantics.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNIsOffsetExternSemantics(
		view: ctypes.POINTER(BNBinaryView), 
		offset: int
		) -> bool:
	return _BNIsOffsetExternSemantics(view, offset)


# -------------------------------------------------------
# _BNIsOffsetReadable

_BNIsOffsetReadable = core.BNIsOffsetReadable
_BNIsOffsetReadable.restype = ctypes.c_bool
_BNIsOffsetReadable.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNIsOffsetReadable(
		view: ctypes.POINTER(BNBinaryView), 
		offset: int
		) -> bool:
	return _BNIsOffsetReadable(view, offset)


# -------------------------------------------------------
# _BNIsOffsetWritable

_BNIsOffsetWritable = core.BNIsOffsetWritable
_BNIsOffsetWritable.restype = ctypes.c_bool
_BNIsOffsetWritable.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNIsOffsetWritable(
		view: ctypes.POINTER(BNBinaryView), 
		offset: int
		) -> bool:
	return _BNIsOffsetWritable(view, offset)


# -------------------------------------------------------
# _BNIsOffsetWritableSemantics

_BNIsOffsetWritableSemantics = core.BNIsOffsetWritableSemantics
_BNIsOffsetWritableSemantics.restype = ctypes.c_bool
_BNIsOffsetWritableSemantics.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNIsOffsetWritableSemantics(
		view: ctypes.POINTER(BNBinaryView), 
		offset: int
		) -> bool:
	return _BNIsOffsetWritableSemantics(view, offset)


# -------------------------------------------------------
# _BNIsPathDirectory

_BNIsPathDirectory = core.BNIsPathDirectory
_BNIsPathDirectory.restype = ctypes.c_bool
_BNIsPathDirectory.argtypes = [
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNIsPathDirectory(
		path: Optional[str]
		) -> bool:
	return _BNIsPathDirectory(cstr(path))


# -------------------------------------------------------
# _BNIsPathRegularFile

_BNIsPathRegularFile = core.BNIsPathRegularFile
_BNIsPathRegularFile.restype = ctypes.c_bool
_BNIsPathRegularFile.argtypes = [
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNIsPathRegularFile(
		path: Optional[str]
		) -> bool:
	return _BNIsPathRegularFile(cstr(path))


# -------------------------------------------------------
# _BNIsPluginsEnabled

_BNIsPluginsEnabled = core.BNIsPluginsEnabled
_BNIsPluginsEnabled.restype = ctypes.c_bool
_BNIsPluginsEnabled.argtypes = [
	]


# noinspection PyPep8Naming
def BNIsPluginsEnabled(
		) -> bool:
	return _BNIsPluginsEnabled()


# -------------------------------------------------------
# _BNIsRelocatable

_BNIsRelocatable = core.BNIsRelocatable
_BNIsRelocatable.restype = ctypes.c_bool
_BNIsRelocatable.argtypes = [
		ctypes.POINTER(BNBinaryView),
	]


# noinspection PyPep8Naming
def BNIsRelocatable(
		view: ctypes.POINTER(BNBinaryView)
		) -> bool:
	return _BNIsRelocatable(view)


# -------------------------------------------------------
# _BNIsSaveSettingsOptionSet

_BNIsSaveSettingsOptionSet = core.BNIsSaveSettingsOptionSet
_BNIsSaveSettingsOptionSet.restype = ctypes.c_bool
_BNIsSaveSettingsOptionSet.argtypes = [
		ctypes.POINTER(BNSaveSettings),
		SaveOptionEnum,
	]


# noinspection PyPep8Naming
def BNIsSaveSettingsOptionSet(
		settings: ctypes.POINTER(BNSaveSettings), 
		option: SaveOption
		) -> bool:
	return _BNIsSaveSettingsOptionSet(settings, option)


# -------------------------------------------------------
# _BNIsShutdownRequested

_BNIsShutdownRequested = core.BNIsShutdownRequested
_BNIsShutdownRequested.restype = ctypes.c_bool
_BNIsShutdownRequested.argtypes = [
	]


# noinspection PyPep8Naming
def BNIsShutdownRequested(
		) -> bool:
	return _BNIsShutdownRequested()


# -------------------------------------------------------
# _BNIsSkipAndReturnValuePatchAvailable

_BNIsSkipAndReturnValuePatchAvailable = core.BNIsSkipAndReturnValuePatchAvailable
_BNIsSkipAndReturnValuePatchAvailable.restype = ctypes.c_bool
_BNIsSkipAndReturnValuePatchAvailable.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNArchitecture),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNIsSkipAndReturnValuePatchAvailable(
		view: ctypes.POINTER(BNBinaryView), 
		arch: ctypes.POINTER(BNArchitecture), 
		addr: int
		) -> bool:
	return _BNIsSkipAndReturnValuePatchAvailable(view, arch, addr)


# -------------------------------------------------------
# _BNIsSkipAndReturnZeroPatchAvailable

_BNIsSkipAndReturnZeroPatchAvailable = core.BNIsSkipAndReturnZeroPatchAvailable
_BNIsSkipAndReturnZeroPatchAvailable.restype = ctypes.c_bool
_BNIsSkipAndReturnZeroPatchAvailable.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNArchitecture),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNIsSkipAndReturnZeroPatchAvailable(
		view: ctypes.POINTER(BNBinaryView), 
		arch: ctypes.POINTER(BNArchitecture), 
		addr: int
		) -> bool:
	return _BNIsSkipAndReturnZeroPatchAvailable(view, arch, addr)


# -------------------------------------------------------
# _BNIsSnapshotAutoSave

_BNIsSnapshotAutoSave = core.BNIsSnapshotAutoSave
_BNIsSnapshotAutoSave.restype = ctypes.c_bool
_BNIsSnapshotAutoSave.argtypes = [
		ctypes.POINTER(BNSnapshot),
	]


# noinspection PyPep8Naming
def BNIsSnapshotAutoSave(
		snapshot: ctypes.POINTER(BNSnapshot)
		) -> bool:
	return _BNIsSnapshotAutoSave(snapshot)


# -------------------------------------------------------
# _BNIsSnapshotDataAppliedWithoutError

_BNIsSnapshotDataAppliedWithoutError = core.BNIsSnapshotDataAppliedWithoutError
_BNIsSnapshotDataAppliedWithoutError.restype = ctypes.c_bool
_BNIsSnapshotDataAppliedWithoutError.argtypes = [
		ctypes.POINTER(BNFileMetadata),
	]


# noinspection PyPep8Naming
def BNIsSnapshotDataAppliedWithoutError(
		view: ctypes.POINTER(BNFileMetadata)
		) -> bool:
	return _BNIsSnapshotDataAppliedWithoutError(view)


# -------------------------------------------------------
# _BNIsStackAdjustedOnReturn

_BNIsStackAdjustedOnReturn = core.BNIsStackAdjustedOnReturn
_BNIsStackAdjustedOnReturn.restype = ctypes.c_bool
_BNIsStackAdjustedOnReturn.argtypes = [
		ctypes.POINTER(BNCallingConvention),
	]


# noinspection PyPep8Naming
def BNIsStackAdjustedOnReturn(
		cc: ctypes.POINTER(BNCallingConvention)
		) -> bool:
	return _BNIsStackAdjustedOnReturn(cc)


# -------------------------------------------------------
# _BNIsStackReservedForArgumentRegisters

_BNIsStackReservedForArgumentRegisters = core.BNIsStackReservedForArgumentRegisters
_BNIsStackReservedForArgumentRegisters.restype = ctypes.c_bool
_BNIsStackReservedForArgumentRegisters.argtypes = [
		ctypes.POINTER(BNCallingConvention),
	]


# noinspection PyPep8Naming
def BNIsStackReservedForArgumentRegisters(
		cc: ctypes.POINTER(BNCallingConvention)
		) -> bool:
	return _BNIsStackReservedForArgumentRegisters(cc)


# -------------------------------------------------------
# _BNIsStructureBuilderPacked

_BNIsStructureBuilderPacked = core.BNIsStructureBuilderPacked
_BNIsStructureBuilderPacked.restype = ctypes.c_bool
_BNIsStructureBuilderPacked.argtypes = [
		ctypes.POINTER(BNStructureBuilder),
	]


# noinspection PyPep8Naming
def BNIsStructureBuilderPacked(
		s: ctypes.POINTER(BNStructureBuilder)
		) -> bool:
	return _BNIsStructureBuilderPacked(s)


# -------------------------------------------------------
# _BNIsStructureBuilderUnion

_BNIsStructureBuilderUnion = core.BNIsStructureBuilderUnion
_BNIsStructureBuilderUnion.restype = ctypes.c_bool
_BNIsStructureBuilderUnion.argtypes = [
		ctypes.POINTER(BNStructureBuilder),
	]


# noinspection PyPep8Naming
def BNIsStructureBuilderUnion(
		s: ctypes.POINTER(BNStructureBuilder)
		) -> bool:
	return _BNIsStructureBuilderUnion(s)


# -------------------------------------------------------
# _BNIsStructurePacked

_BNIsStructurePacked = core.BNIsStructurePacked
_BNIsStructurePacked.restype = ctypes.c_bool
_BNIsStructurePacked.argtypes = [
		ctypes.POINTER(BNStructure),
	]


# noinspection PyPep8Naming
def BNIsStructurePacked(
		s: ctypes.POINTER(BNStructure)
		) -> bool:
	return _BNIsStructurePacked(s)


# -------------------------------------------------------
# _BNIsStructureUnion

_BNIsStructureUnion = core.BNIsStructureUnion
_BNIsStructureUnion.restype = ctypes.c_bool
_BNIsStructureUnion.argtypes = [
		ctypes.POINTER(BNStructure),
	]


# noinspection PyPep8Naming
def BNIsStructureUnion(
		s: ctypes.POINTER(BNStructure)
		) -> bool:
	return _BNIsStructureUnion(s)


# -------------------------------------------------------
# _BNIsSymbolAutoDefined

_BNIsSymbolAutoDefined = core.BNIsSymbolAutoDefined
_BNIsSymbolAutoDefined.restype = ctypes.c_bool
_BNIsSymbolAutoDefined.argtypes = [
		ctypes.POINTER(BNSymbol),
	]


# noinspection PyPep8Naming
def BNIsSymbolAutoDefined(
		sym: ctypes.POINTER(BNSymbol)
		) -> bool:
	return _BNIsSymbolAutoDefined(sym)


# -------------------------------------------------------
# _BNIsTypeArchive

_BNIsTypeArchive = core.BNIsTypeArchive
_BNIsTypeArchive.restype = ctypes.c_bool
_BNIsTypeArchive.argtypes = [
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNIsTypeArchive(
		path: Optional[str]
		) -> bool:
	return _BNIsTypeArchive(cstr(path))


# -------------------------------------------------------
# _BNIsTypeBuilderConst

_BNIsTypeBuilderConst = core.BNIsTypeBuilderConst
_BNIsTypeBuilderConst.restype = BNBoolWithConfidence
_BNIsTypeBuilderConst.argtypes = [
		ctypes.POINTER(BNTypeBuilder),
	]


# noinspection PyPep8Naming
def BNIsTypeBuilderConst(
		type: ctypes.POINTER(BNTypeBuilder)
		) -> BNBoolWithConfidence:
	return _BNIsTypeBuilderConst(type)


# -------------------------------------------------------
# _BNIsTypeBuilderFloatingPoint

_BNIsTypeBuilderFloatingPoint = core.BNIsTypeBuilderFloatingPoint
_BNIsTypeBuilderFloatingPoint.restype = ctypes.c_bool
_BNIsTypeBuilderFloatingPoint.argtypes = [
		ctypes.POINTER(BNTypeBuilder),
	]


# noinspection PyPep8Naming
def BNIsTypeBuilderFloatingPoint(
		type: ctypes.POINTER(BNTypeBuilder)
		) -> bool:
	return _BNIsTypeBuilderFloatingPoint(type)


# -------------------------------------------------------
# _BNIsTypeBuilderPure

_BNIsTypeBuilderPure = core.BNIsTypeBuilderPure
_BNIsTypeBuilderPure.restype = BNBoolWithConfidence
_BNIsTypeBuilderPure.argtypes = [
		ctypes.POINTER(BNTypeBuilder),
	]


# noinspection PyPep8Naming
def BNIsTypeBuilderPure(
		type: ctypes.POINTER(BNTypeBuilder)
		) -> BNBoolWithConfidence:
	return _BNIsTypeBuilderPure(type)


# -------------------------------------------------------
# _BNIsTypeBuilderSigned

_BNIsTypeBuilderSigned = core.BNIsTypeBuilderSigned
_BNIsTypeBuilderSigned.restype = BNBoolWithConfidence
_BNIsTypeBuilderSigned.argtypes = [
		ctypes.POINTER(BNTypeBuilder),
	]


# noinspection PyPep8Naming
def BNIsTypeBuilderSigned(
		type: ctypes.POINTER(BNTypeBuilder)
		) -> BNBoolWithConfidence:
	return _BNIsTypeBuilderSigned(type)


# -------------------------------------------------------
# _BNIsTypeBuilderVolatile

_BNIsTypeBuilderVolatile = core.BNIsTypeBuilderVolatile
_BNIsTypeBuilderVolatile.restype = BNBoolWithConfidence
_BNIsTypeBuilderVolatile.argtypes = [
		ctypes.POINTER(BNTypeBuilder),
	]


# noinspection PyPep8Naming
def BNIsTypeBuilderVolatile(
		type: ctypes.POINTER(BNTypeBuilder)
		) -> BNBoolWithConfidence:
	return _BNIsTypeBuilderVolatile(type)


# -------------------------------------------------------
# _BNIsTypeConst

_BNIsTypeConst = core.BNIsTypeConst
_BNIsTypeConst.restype = BNBoolWithConfidence
_BNIsTypeConst.argtypes = [
		ctypes.POINTER(BNType),
	]


# noinspection PyPep8Naming
def BNIsTypeConst(
		type: ctypes.POINTER(BNType)
		) -> BNBoolWithConfidence:
	return _BNIsTypeConst(type)


# -------------------------------------------------------
# _BNIsTypeFloatingPoint

_BNIsTypeFloatingPoint = core.BNIsTypeFloatingPoint
_BNIsTypeFloatingPoint.restype = ctypes.c_bool
_BNIsTypeFloatingPoint.argtypes = [
		ctypes.POINTER(BNType),
	]


# noinspection PyPep8Naming
def BNIsTypeFloatingPoint(
		type: ctypes.POINTER(BNType)
		) -> bool:
	return _BNIsTypeFloatingPoint(type)


# -------------------------------------------------------
# _BNIsTypePure

_BNIsTypePure = core.BNIsTypePure
_BNIsTypePure.restype = BNBoolWithConfidence
_BNIsTypePure.argtypes = [
		ctypes.POINTER(BNType),
	]


# noinspection PyPep8Naming
def BNIsTypePure(
		type: ctypes.POINTER(BNType)
		) -> BNBoolWithConfidence:
	return _BNIsTypePure(type)


# -------------------------------------------------------
# _BNIsTypeSigned

_BNIsTypeSigned = core.BNIsTypeSigned
_BNIsTypeSigned.restype = BNBoolWithConfidence
_BNIsTypeSigned.argtypes = [
		ctypes.POINTER(BNType),
	]


# noinspection PyPep8Naming
def BNIsTypeSigned(
		type: ctypes.POINTER(BNType)
		) -> BNBoolWithConfidence:
	return _BNIsTypeSigned(type)


# -------------------------------------------------------
# _BNIsTypeVolatile

_BNIsTypeVolatile = core.BNIsTypeVolatile
_BNIsTypeVolatile.restype = BNBoolWithConfidence
_BNIsTypeVolatile.argtypes = [
		ctypes.POINTER(BNType),
	]


# noinspection PyPep8Naming
def BNIsTypeVolatile(
		type: ctypes.POINTER(BNType)
		) -> BNBoolWithConfidence:
	return _BNIsTypeVolatile(type)


# -------------------------------------------------------
# _BNIsUIEnabled

_BNIsUIEnabled = core.BNIsUIEnabled
_BNIsUIEnabled.restype = ctypes.c_bool
_BNIsUIEnabled.argtypes = [
	]


# noinspection PyPep8Naming
def BNIsUIEnabled(
		) -> bool:
	return _BNIsUIEnabled()


# -------------------------------------------------------
# _BNIsUpdateInstallationPending

_BNIsUpdateInstallationPending = core.BNIsUpdateInstallationPending
_BNIsUpdateInstallationPending.restype = ctypes.c_bool
_BNIsUpdateInstallationPending.argtypes = [
	]


# noinspection PyPep8Naming
def BNIsUpdateInstallationPending(
		) -> bool:
	return _BNIsUpdateInstallationPending()


# -------------------------------------------------------
# _BNIsValidForData

_BNIsValidForData = core.BNIsValidForData
_BNIsValidForData.restype = ctypes.c_bool
_BNIsValidForData.argtypes = [
		ctypes.c_void_p,
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
		ctypes.POINTER(BNType),
		ctypes.POINTER(BNTypeContext),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNIsValidForData(
		ctxt: Optional[ctypes.c_void_p], 
		view: ctypes.POINTER(BNBinaryView), 
		addr: int, 
		type: ctypes.POINTER(BNType), 
		typeCtx: ctypes.POINTER(BNTypeContext), 
		ctxCount: int
		) -> bool:
	return _BNIsValidForData(ctxt, view, addr, type, typeCtx, ctxCount)


# -------------------------------------------------------
# _BNIsValidOffset

_BNIsValidOffset = core.BNIsValidOffset
_BNIsValidOffset.restype = ctypes.c_bool
_BNIsValidOffset.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNIsValidOffset(
		view: ctypes.POINTER(BNBinaryView), 
		offset: int
		) -> bool:
	return _BNIsValidOffset(view, offset)


# -------------------------------------------------------
# _BNIsVariableUserDefined

_BNIsVariableUserDefined = core.BNIsVariableUserDefined
_BNIsVariableUserDefined.restype = ctypes.c_bool
_BNIsVariableUserDefined.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNVariable),
	]


# noinspection PyPep8Naming
def BNIsVariableUserDefined(
		func: ctypes.POINTER(BNFunction), 
		var: ctypes.POINTER(BNVariable)
		) -> bool:
	return _BNIsVariableUserDefined(func, var)


# -------------------------------------------------------
# _BNIsViewModified

_BNIsViewModified = core.BNIsViewModified
_BNIsViewModified.restype = ctypes.c_bool
_BNIsViewModified.argtypes = [
		ctypes.POINTER(BNBinaryView),
	]


# noinspection PyPep8Naming
def BNIsViewModified(
		view: ctypes.POINTER(BNBinaryView)
		) -> bool:
	return _BNIsViewModified(view)


# -------------------------------------------------------
# _BNKeyValueStoreHasValue

_BNKeyValueStoreHasValue = core.BNKeyValueStoreHasValue
_BNKeyValueStoreHasValue.restype = ctypes.c_bool
_BNKeyValueStoreHasValue.argtypes = [
		ctypes.POINTER(BNKeyValueStore),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNKeyValueStoreHasValue(
		store: ctypes.POINTER(BNKeyValueStore), 
		name: Optional[str]
		) -> bool:
	return _BNKeyValueStoreHasValue(store, cstr(name))


# -------------------------------------------------------
# _BNLinearViewCursorNext

_BNLinearViewCursorNext = core.BNLinearViewCursorNext
_BNLinearViewCursorNext.restype = ctypes.c_bool
_BNLinearViewCursorNext.argtypes = [
		ctypes.POINTER(BNLinearViewCursor),
	]


# noinspection PyPep8Naming
def BNLinearViewCursorNext(
		cursor: ctypes.POINTER(BNLinearViewCursor)
		) -> bool:
	return _BNLinearViewCursorNext(cursor)


# -------------------------------------------------------
# _BNLinearViewCursorPrevious

_BNLinearViewCursorPrevious = core.BNLinearViewCursorPrevious
_BNLinearViewCursorPrevious.restype = ctypes.c_bool
_BNLinearViewCursorPrevious.argtypes = [
		ctypes.POINTER(BNLinearViewCursor),
	]


# noinspection PyPep8Naming
def BNLinearViewCursorPrevious(
		cursor: ctypes.POINTER(BNLinearViewCursor)
		) -> bool:
	return _BNLinearViewCursorPrevious(cursor)


# -------------------------------------------------------
# _BNLlvmServicesAssemble

_BNLlvmServicesAssemble = core.BNLlvmServicesAssemble
_BNLlvmServicesAssemble.restype = ctypes.c_int
_BNLlvmServicesAssemble.argtypes = [
		ctypes.c_char_p,
		ctypes.c_int,
		ctypes.c_char_p,
		ctypes.c_int,
		ctypes.c_int,
		ctypes.POINTER(ctypes.c_char_p),
		ctypes.POINTER(ctypes.c_int),
		ctypes.POINTER(ctypes.c_char_p),
		ctypes.POINTER(ctypes.c_int),
	]


# noinspection PyPep8Naming
def BNLlvmServicesAssemble(
		src: Optional[str], 
		dialect: int, 
		triplet: Optional[str], 
		codeModel: int, 
		relocMode: int, 
		outBytes: ctypes.POINTER(ctypes.c_char_p), 
		outBytesLen: ctypes.POINTER(ctypes.c_int), 
		err: ctypes.POINTER(ctypes.c_char_p), 
		errLen: ctypes.POINTER(ctypes.c_int)
		) -> int:
	return _BNLlvmServicesAssemble(cstr(src), dialect, cstr(triplet), codeModel, relocMode, outBytes, outBytesLen, err, errLen)


# -------------------------------------------------------
# _BNLlvmServicesAssembleFree

_BNLlvmServicesAssembleFree = core.BNLlvmServicesAssembleFree
_BNLlvmServicesAssembleFree.restype = None
_BNLlvmServicesAssembleFree.argtypes = [
		ctypes.c_char_p,
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNLlvmServicesAssembleFree(
		outBytes: Optional[str], 
		err: Optional[str]
		) -> None:
	return _BNLlvmServicesAssembleFree(cstr(outBytes), cstr(err))


# -------------------------------------------------------
# _BNLlvmServicesInit

_BNLlvmServicesInit = core.BNLlvmServicesInit
_BNLlvmServicesInit.restype = None
_BNLlvmServicesInit.argtypes = [
	]


# noinspection PyPep8Naming
def BNLlvmServicesInit(
		) -> None:
	return _BNLlvmServicesInit()


# -------------------------------------------------------
# _BNLoadBinaryView

_BNLoadBinaryView = core.BNLoadBinaryView
_BNLoadBinaryView.restype = ctypes.POINTER(BNBinaryView)
_BNLoadBinaryView.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_bool,
		ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_ulonglong, ctypes.c_ulonglong),
		ctypes.POINTER(BNMetadata),
		ctypes.c_bool,
	]


# noinspection PyPep8Naming
def BNLoadBinaryView(
		view: ctypes.POINTER(BNBinaryView), 
		updateAnalysis: bool, 
		progress: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_ulonglong, ctypes.c_ulonglong), 
		options: ctypes.POINTER(BNMetadata), 
		isDatabase: bool
		) -> Optional[ctypes.POINTER(BNBinaryView)]:
	result = _BNLoadBinaryView(view, updateAnalysis, progress, options, isDatabase)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNLoadFilename

_BNLoadFilename = core.BNLoadFilename
_BNLoadFilename.restype = ctypes.POINTER(BNBinaryView)
_BNLoadFilename.argtypes = [
		ctypes.c_char_p,
		ctypes.c_bool,
		ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_ulonglong, ctypes.c_ulonglong),
		ctypes.POINTER(BNMetadata),
	]


# noinspection PyPep8Naming
def BNLoadFilename(
		filename: Optional[str], 
		updateAnalysis: bool, 
		progress: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_ulonglong, ctypes.c_ulonglong), 
		options: ctypes.POINTER(BNMetadata)
		) -> Optional[ctypes.POINTER(BNBinaryView)]:
	result = _BNLoadFilename(cstr(filename), updateAnalysis, progress, options)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNLoadProjectFile

_BNLoadProjectFile = core.BNLoadProjectFile
_BNLoadProjectFile.restype = ctypes.POINTER(BNBinaryView)
_BNLoadProjectFile.argtypes = [
		ctypes.POINTER(BNProjectFile),
		ctypes.c_bool,
		ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_ulonglong, ctypes.c_ulonglong),
		ctypes.POINTER(BNMetadata),
	]


# noinspection PyPep8Naming
def BNLoadProjectFile(
		projectFile: ctypes.POINTER(BNProjectFile), 
		updateAnalysis: bool, 
		progress: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_ulonglong, ctypes.c_ulonglong), 
		options: ctypes.POINTER(BNMetadata)
		) -> Optional[ctypes.POINTER(BNBinaryView)]:
	result = _BNLoadProjectFile(projectFile, updateAnalysis, progress, options)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNLoadScriptingProviderModule

_BNLoadScriptingProviderModule = core.BNLoadScriptingProviderModule
_BNLoadScriptingProviderModule.restype = ctypes.c_bool
_BNLoadScriptingProviderModule.argtypes = [
		ctypes.POINTER(BNScriptingProvider),
		ctypes.c_char_p,
		ctypes.c_char_p,
		ctypes.c_bool,
	]


# noinspection PyPep8Naming
def BNLoadScriptingProviderModule(
		provider: ctypes.POINTER(BNScriptingProvider), 
		repository: Optional[str], 
		module: Optional[str], 
		force: bool
		) -> bool:
	return _BNLoadScriptingProviderModule(provider, cstr(repository), cstr(module), force)


# -------------------------------------------------------
# _BNLoadSettingsFile

_BNLoadSettingsFile = core.BNLoadSettingsFile
_BNLoadSettingsFile.restype = ctypes.c_bool
_BNLoadSettingsFile.argtypes = [
		ctypes.POINTER(BNSettings),
		ctypes.c_char_p,
		SettingsScopeEnum,
		ctypes.POINTER(BNBinaryView),
	]


# noinspection PyPep8Naming
def BNLoadSettingsFile(
		settings: ctypes.POINTER(BNSettings), 
		fileName: Optional[str], 
		scope: SettingsScope, 
		view: ctypes.POINTER(BNBinaryView)
		) -> bool:
	return _BNLoadSettingsFile(settings, cstr(fileName), scope, view)


# -------------------------------------------------------
# _BNLoadTypeLibraryFromFile

_BNLoadTypeLibraryFromFile = core.BNLoadTypeLibraryFromFile
_BNLoadTypeLibraryFromFile.restype = ctypes.POINTER(BNTypeLibrary)
_BNLoadTypeLibraryFromFile.argtypes = [
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNLoadTypeLibraryFromFile(
		path: Optional[str]
		) -> Optional[ctypes.POINTER(BNTypeLibrary)]:
	result = _BNLoadTypeLibraryFromFile(cstr(path))
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNLog

_BNLog = core.BNLog
_BNLog.restype = None
def BNLog(level, *args):
	return _BNLog(level, *[cstr(arg) for arg in args])

# -------------------------------------------------------
# _BNLogAlert

_BNLogAlert = core.BNLogAlert
_BNLogAlert.restype = None
def BNLogAlert(*args):
	return _BNLogAlert(*[cstr(arg) for arg in args])

# -------------------------------------------------------
# _BNLogCreateLogger

_BNLogCreateLogger = core.BNLogCreateLogger
_BNLogCreateLogger.restype = ctypes.POINTER(BNLogger)
_BNLogCreateLogger.argtypes = [
		ctypes.c_char_p,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNLogCreateLogger(
		loggerName: Optional[str], 
		sessionId: int
		) -> Optional[ctypes.POINTER(BNLogger)]:
	result = _BNLogCreateLogger(cstr(loggerName), sessionId)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNLogDebug

_BNLogDebug = core.BNLogDebug
_BNLogDebug.restype = None
def BNLogDebug(*args):
	return _BNLogDebug(*[cstr(arg) for arg in args])

# -------------------------------------------------------
# _BNLogError

_BNLogError = core.BNLogError
_BNLogError.restype = None
def BNLogError(*args):
	return _BNLogError(*[cstr(arg) for arg in args])

# -------------------------------------------------------
# _BNLogGetLogger

_BNLogGetLogger = core.BNLogGetLogger
_BNLogGetLogger.restype = ctypes.POINTER(BNLogger)
_BNLogGetLogger.argtypes = [
		ctypes.c_char_p,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNLogGetLogger(
		loggerName: Optional[str], 
		sessionId: int
		) -> Optional[ctypes.POINTER(BNLogger)]:
	result = _BNLogGetLogger(cstr(loggerName), sessionId)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNLogGetLoggerNames

_BNLogGetLoggerNames = core.BNLogGetLoggerNames
_BNLogGetLoggerNames.restype = ctypes.POINTER(ctypes.c_char_p)
_BNLogGetLoggerNames.argtypes = [
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNLogGetLoggerNames(
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_char_p)]:
	result = _BNLogGetLoggerNames(count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNLogInfo

_BNLogInfo = core.BNLogInfo
_BNLogInfo.restype = None
def BNLogInfo(*args):
	return _BNLogInfo(*[cstr(arg) for arg in args])

# -------------------------------------------------------
# _BNLogRegisterLoggerCallback

_BNLogRegisterLoggerCallback = core.BNLogRegisterLoggerCallback
_BNLogRegisterLoggerCallback.restype = None
_BNLogRegisterLoggerCallback.argtypes = [
		ctypes.CFUNCTYPE(None, ctypes.c_char_p, ctypes.c_void_p),
		ctypes.c_void_p,
	]


# noinspection PyPep8Naming
def BNLogRegisterLoggerCallback(
		cb: ctypes.CFUNCTYPE(None, ctypes.c_char_p, ctypes.c_void_p), 
		ctxt: Optional[ctypes.c_void_p]
		) -> None:
	return _BNLogRegisterLoggerCallback(cb, ctxt)


# -------------------------------------------------------
# _BNLogString

_BNLogString = core.BNLogString
_BNLogString.restype = None
_BNLogString.argtypes = [
		ctypes.c_ulonglong,
		LogLevelEnum,
		ctypes.c_char_p,
		ctypes.c_ulonglong,
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNLogString(
		session: int, 
		level: LogLevel, 
		logger_name: Optional[str], 
		tid: int, 
		str: Optional[str]
		) -> None:
	return _BNLogString(session, level, cstr(logger_name), tid, cstr(str))


# -------------------------------------------------------
# _BNLogToFile

_BNLogToFile = core.BNLogToFile
_BNLogToFile.restype = ctypes.c_bool
_BNLogToFile.argtypes = [
		LogLevelEnum,
		ctypes.c_char_p,
		ctypes.c_bool,
	]


# noinspection PyPep8Naming
def BNLogToFile(
		minimumLevel: LogLevel, 
		path: Optional[str], 
		append: bool
		) -> bool:
	return _BNLogToFile(minimumLevel, cstr(path), append)


# -------------------------------------------------------
# _BNLogToStderr

_BNLogToStderr = core.BNLogToStderr
_BNLogToStderr.restype = None
_BNLogToStderr.argtypes = [
		LogLevelEnum,
	]


# noinspection PyPep8Naming
def BNLogToStderr(
		minimumLevel: LogLevel
		) -> None:
	return _BNLogToStderr(minimumLevel)


# -------------------------------------------------------
# _BNLogToStdout

_BNLogToStdout = core.BNLogToStdout
_BNLogToStdout.restype = None
_BNLogToStdout.argtypes = [
		LogLevelEnum,
	]


# noinspection PyPep8Naming
def BNLogToStdout(
		minimumLevel: LogLevel
		) -> None:
	return _BNLogToStdout(minimumLevel)


# -------------------------------------------------------
# _BNLogWarn

_BNLogWarn = core.BNLogWarn
_BNLogWarn.restype = None
def BNLogWarn(*args):
	return _BNLogWarn(*[cstr(arg) for arg in args])

# -------------------------------------------------------
# _BNLoggerGetName

_BNLoggerGetName = core.BNLoggerGetName
_BNLoggerGetName.restype = ctypes.POINTER(ctypes.c_byte)
_BNLoggerGetName.argtypes = [
		ctypes.POINTER(BNLogger),
	]


# noinspection PyPep8Naming
def BNLoggerGetName(
		logger: ctypes.POINTER(BNLogger)
		) -> Optional[Optional[str]]:
	result = _BNLoggerGetName(logger)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNLoggerGetSessionId

_BNLoggerGetSessionId = core.BNLoggerGetSessionId
_BNLoggerGetSessionId.restype = ctypes.c_ulonglong
_BNLoggerGetSessionId.argtypes = [
		ctypes.POINTER(BNLogger),
	]


# noinspection PyPep8Naming
def BNLoggerGetSessionId(
		logger: ctypes.POINTER(BNLogger)
		) -> int:
	return _BNLoggerGetSessionId(logger)


# -------------------------------------------------------
# _BNLoggerLog

_BNLoggerLog = core.BNLoggerLog
_BNLoggerLog.restype = None
def BNLoggerLog(*args):
	return _BNLoggerLog(*[cstr(arg) for arg in args])

# -------------------------------------------------------
# _BNLoggerLogString

_BNLoggerLogString = core.BNLoggerLogString
_BNLoggerLogString.restype = None
_BNLoggerLogString.argtypes = [
		ctypes.POINTER(BNLogger),
		LogLevelEnum,
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNLoggerLogString(
		logger: ctypes.POINTER(BNLogger), 
		level: LogLevel, 
		msg: Optional[str]
		) -> None:
	return _BNLoggerLogString(logger, level, cstr(msg))


# -------------------------------------------------------
# _BNLookupImportedTypePlatform

_BNLookupImportedTypePlatform = core.BNLookupImportedTypePlatform
_BNLookupImportedTypePlatform.restype = ctypes.c_bool
_BNLookupImportedTypePlatform.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNQualifiedName),
		ctypes.POINTER(ctypes.POINTER(BNPlatform)),
		ctypes.POINTER(BNQualifiedName),
	]


# noinspection PyPep8Naming
def BNLookupImportedTypePlatform(
		view: ctypes.POINTER(BNBinaryView), 
		typeName: ctypes.POINTER(BNQualifiedName), 
		platform: ctypes.POINTER(ctypes.POINTER(BNPlatform)), 
		resultName: ctypes.POINTER(BNQualifiedName)
		) -> bool:
	return _BNLookupImportedTypePlatform(view, typeName, platform, resultName)


# -------------------------------------------------------
# _BNLookupTypeArchiveById

_BNLookupTypeArchiveById = core.BNLookupTypeArchiveById
_BNLookupTypeArchiveById.restype = ctypes.POINTER(BNTypeArchive)
_BNLookupTypeArchiveById.argtypes = [
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNLookupTypeArchiveById(
		id: Optional[str]
		) -> Optional[ctypes.POINTER(BNTypeArchive)]:
	result = _BNLookupTypeArchiveById(cstr(id))
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNLookupTypeLibraryByGuid

_BNLookupTypeLibraryByGuid = core.BNLookupTypeLibraryByGuid
_BNLookupTypeLibraryByGuid.restype = ctypes.POINTER(BNTypeLibrary)
_BNLookupTypeLibraryByGuid.argtypes = [
		ctypes.POINTER(BNArchitecture),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNLookupTypeLibraryByGuid(
		arch: ctypes.POINTER(BNArchitecture), 
		guid: Optional[str]
		) -> Optional[ctypes.POINTER(BNTypeLibrary)]:
	result = _BNLookupTypeLibraryByGuid(arch, cstr(guid))
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNLookupTypeLibraryByName

_BNLookupTypeLibraryByName = core.BNLookupTypeLibraryByName
_BNLookupTypeLibraryByName.restype = ctypes.POINTER(BNTypeLibrary)
_BNLookupTypeLibraryByName.argtypes = [
		ctypes.POINTER(BNArchitecture),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNLookupTypeLibraryByName(
		arch: ctypes.POINTER(BNArchitecture), 
		name: Optional[str]
		) -> Optional[ctypes.POINTER(BNTypeLibrary)]:
	result = _BNLookupTypeLibraryByName(arch, cstr(name))
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNLowLevelILAddExpr

_BNLowLevelILAddExpr = core.BNLowLevelILAddExpr
_BNLowLevelILAddExpr.restype = ctypes.c_ulonglong
_BNLowLevelILAddExpr.argtypes = [
		ctypes.POINTER(BNLowLevelILFunction),
		LowLevelILOperationEnum,
		ctypes.c_ulonglong,
		ctypes.c_uint,
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNLowLevelILAddExpr(
		func: ctypes.POINTER(BNLowLevelILFunction), 
		operation: LowLevelILOperation, 
		size: int, 
		flags: int, 
		a: int, 
		b: int, 
		c: int, 
		d: int
		) -> int:
	return _BNLowLevelILAddExpr(func, operation, size, flags, a, b, c, d)


# -------------------------------------------------------
# _BNLowLevelILAddExprWithLocation

_BNLowLevelILAddExprWithLocation = core.BNLowLevelILAddExprWithLocation
_BNLowLevelILAddExprWithLocation.restype = ctypes.c_ulonglong
_BNLowLevelILAddExprWithLocation.argtypes = [
		ctypes.POINTER(BNLowLevelILFunction),
		ctypes.c_ulonglong,
		ctypes.c_uint,
		LowLevelILOperationEnum,
		ctypes.c_ulonglong,
		ctypes.c_uint,
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNLowLevelILAddExprWithLocation(
		func: ctypes.POINTER(BNLowLevelILFunction), 
		addr: int, 
		sourceOperand: int, 
		operation: LowLevelILOperation, 
		size: int, 
		flags: int, 
		a: int, 
		b: int, 
		c: int, 
		d: int
		) -> int:
	return _BNLowLevelILAddExprWithLocation(func, addr, sourceOperand, operation, size, flags, a, b, c, d)


# -------------------------------------------------------
# _BNLowLevelILAddInstruction

_BNLowLevelILAddInstruction = core.BNLowLevelILAddInstruction
_BNLowLevelILAddInstruction.restype = ctypes.c_ulonglong
_BNLowLevelILAddInstruction.argtypes = [
		ctypes.POINTER(BNLowLevelILFunction),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNLowLevelILAddInstruction(
		func: ctypes.POINTER(BNLowLevelILFunction), 
		expr: int
		) -> int:
	return _BNLowLevelILAddInstruction(func, expr)


# -------------------------------------------------------
# _BNLowLevelILAddLabelMap

_BNLowLevelILAddLabelMap = core.BNLowLevelILAddLabelMap
_BNLowLevelILAddLabelMap.restype = ctypes.c_ulonglong
_BNLowLevelILAddLabelMap.argtypes = [
		ctypes.POINTER(BNLowLevelILFunction),
		ctypes.POINTER(ctypes.c_ulonglong),
		ctypes.POINTER(ctypes.POINTER(BNLowLevelILLabel)),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNLowLevelILAddLabelMap(
		func: ctypes.POINTER(BNLowLevelILFunction), 
		values: ctypes.POINTER(ctypes.c_ulonglong), 
		labels: ctypes.POINTER(ctypes.POINTER(BNLowLevelILLabel)), 
		count: int
		) -> int:
	return _BNLowLevelILAddLabelMap(func, values, labels, count)


# -------------------------------------------------------
# _BNLowLevelILAddOperandList

_BNLowLevelILAddOperandList = core.BNLowLevelILAddOperandList
_BNLowLevelILAddOperandList.restype = ctypes.c_ulonglong
_BNLowLevelILAddOperandList.argtypes = [
		ctypes.POINTER(BNLowLevelILFunction),
		ctypes.POINTER(ctypes.c_ulonglong),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNLowLevelILAddOperandList(
		func: ctypes.POINTER(BNLowLevelILFunction), 
		operands: ctypes.POINTER(ctypes.c_ulonglong), 
		count: int
		) -> int:
	return _BNLowLevelILAddOperandList(func, operands, count)


# -------------------------------------------------------
# _BNLowLevelILClearIndirectBranches

_BNLowLevelILClearIndirectBranches = core.BNLowLevelILClearIndirectBranches
_BNLowLevelILClearIndirectBranches.restype = None
_BNLowLevelILClearIndirectBranches.argtypes = [
		ctypes.POINTER(BNLowLevelILFunction),
	]


# noinspection PyPep8Naming
def BNLowLevelILClearIndirectBranches(
		func: ctypes.POINTER(BNLowLevelILFunction)
		) -> None:
	return _BNLowLevelILClearIndirectBranches(func)


# -------------------------------------------------------
# _BNLowLevelILFreeOperandList

_BNLowLevelILFreeOperandList = core.BNLowLevelILFreeOperandList
_BNLowLevelILFreeOperandList.restype = None
_BNLowLevelILFreeOperandList.argtypes = [
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNLowLevelILFreeOperandList(
		operands: ctypes.POINTER(ctypes.c_ulonglong)
		) -> None:
	return _BNLowLevelILFreeOperandList(operands)


# -------------------------------------------------------
# _BNLowLevelILGetCurrentAddress

_BNLowLevelILGetCurrentAddress = core.BNLowLevelILGetCurrentAddress
_BNLowLevelILGetCurrentAddress.restype = ctypes.c_ulonglong
_BNLowLevelILGetCurrentAddress.argtypes = [
		ctypes.POINTER(BNLowLevelILFunction),
	]


# noinspection PyPep8Naming
def BNLowLevelILGetCurrentAddress(
		func: ctypes.POINTER(BNLowLevelILFunction)
		) -> int:
	return _BNLowLevelILGetCurrentAddress(func)


# -------------------------------------------------------
# _BNLowLevelILGetInstructionStart

_BNLowLevelILGetInstructionStart = core.BNLowLevelILGetInstructionStart
_BNLowLevelILGetInstructionStart.restype = ctypes.c_ulonglong
_BNLowLevelILGetInstructionStart.argtypes = [
		ctypes.POINTER(BNLowLevelILFunction),
		ctypes.POINTER(BNArchitecture),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNLowLevelILGetInstructionStart(
		func: ctypes.POINTER(BNLowLevelILFunction), 
		arch: ctypes.POINTER(BNArchitecture), 
		addr: int
		) -> int:
	return _BNLowLevelILGetInstructionStart(func, arch, addr)


# -------------------------------------------------------
# _BNLowLevelILGetOperandList

_BNLowLevelILGetOperandList = core.BNLowLevelILGetOperandList
_BNLowLevelILGetOperandList.restype = ctypes.POINTER(ctypes.c_ulonglong)
_BNLowLevelILGetOperandList.argtypes = [
		ctypes.POINTER(BNLowLevelILFunction),
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNLowLevelILGetOperandList(
		func: ctypes.POINTER(BNLowLevelILFunction), 
		expr: int, 
		operand: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_ulonglong)]:
	result = _BNLowLevelILGetOperandList(func, expr, operand, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNLowLevelILGoto

_BNLowLevelILGoto = core.BNLowLevelILGoto
_BNLowLevelILGoto.restype = ctypes.c_ulonglong
_BNLowLevelILGoto.argtypes = [
		ctypes.POINTER(BNLowLevelILFunction),
		ctypes.POINTER(BNLowLevelILLabel),
	]


# noinspection PyPep8Naming
def BNLowLevelILGoto(
		func: ctypes.POINTER(BNLowLevelILFunction), 
		label: ctypes.POINTER(BNLowLevelILLabel)
		) -> int:
	return _BNLowLevelILGoto(func, label)


# -------------------------------------------------------
# _BNLowLevelILGotoWithLocation

_BNLowLevelILGotoWithLocation = core.BNLowLevelILGotoWithLocation
_BNLowLevelILGotoWithLocation.restype = ctypes.c_ulonglong
_BNLowLevelILGotoWithLocation.argtypes = [
		ctypes.POINTER(BNLowLevelILFunction),
		ctypes.POINTER(BNLowLevelILLabel),
		ctypes.c_ulonglong,
		ctypes.c_uint,
	]


# noinspection PyPep8Naming
def BNLowLevelILGotoWithLocation(
		func: ctypes.POINTER(BNLowLevelILFunction), 
		label: ctypes.POINTER(BNLowLevelILLabel), 
		addr: int, 
		sourceOperand: int
		) -> int:
	return _BNLowLevelILGotoWithLocation(func, label, addr, sourceOperand)


# -------------------------------------------------------
# _BNLowLevelILIf

_BNLowLevelILIf = core.BNLowLevelILIf
_BNLowLevelILIf.restype = ctypes.c_ulonglong
_BNLowLevelILIf.argtypes = [
		ctypes.POINTER(BNLowLevelILFunction),
		ctypes.c_ulonglong,
		ctypes.POINTER(BNLowLevelILLabel),
		ctypes.POINTER(BNLowLevelILLabel),
	]


# noinspection PyPep8Naming
def BNLowLevelILIf(
		func: ctypes.POINTER(BNLowLevelILFunction), 
		op: int, 
		t: ctypes.POINTER(BNLowLevelILLabel), 
		f: ctypes.POINTER(BNLowLevelILLabel)
		) -> int:
	return _BNLowLevelILIf(func, op, t, f)


# -------------------------------------------------------
# _BNLowLevelILIfWithLocation

_BNLowLevelILIfWithLocation = core.BNLowLevelILIfWithLocation
_BNLowLevelILIfWithLocation.restype = ctypes.c_ulonglong
_BNLowLevelILIfWithLocation.argtypes = [
		ctypes.POINTER(BNLowLevelILFunction),
		ctypes.c_ulonglong,
		ctypes.POINTER(BNLowLevelILLabel),
		ctypes.POINTER(BNLowLevelILLabel),
		ctypes.c_ulonglong,
		ctypes.c_uint,
	]


# noinspection PyPep8Naming
def BNLowLevelILIfWithLocation(
		func: ctypes.POINTER(BNLowLevelILFunction), 
		op: int, 
		t: ctypes.POINTER(BNLowLevelILLabel), 
		f: ctypes.POINTER(BNLowLevelILLabel), 
		addr: int, 
		sourceOperand: int
		) -> int:
	return _BNLowLevelILIfWithLocation(func, op, t, f, addr, sourceOperand)


# -------------------------------------------------------
# _BNLowLevelILInitLabel

_BNLowLevelILInitLabel = core.BNLowLevelILInitLabel
_BNLowLevelILInitLabel.restype = None
_BNLowLevelILInitLabel.argtypes = [
		ctypes.POINTER(BNLowLevelILLabel),
	]


# noinspection PyPep8Naming
def BNLowLevelILInitLabel(
		label: ctypes.POINTER(BNLowLevelILLabel)
		) -> None:
	return _BNLowLevelILInitLabel(label)


# -------------------------------------------------------
# _BNLowLevelILMarkLabel

_BNLowLevelILMarkLabel = core.BNLowLevelILMarkLabel
_BNLowLevelILMarkLabel.restype = None
_BNLowLevelILMarkLabel.argtypes = [
		ctypes.POINTER(BNLowLevelILFunction),
		ctypes.POINTER(BNLowLevelILLabel),
	]


# noinspection PyPep8Naming
def BNLowLevelILMarkLabel(
		func: ctypes.POINTER(BNLowLevelILFunction), 
		label: ctypes.POINTER(BNLowLevelILLabel)
		) -> None:
	return _BNLowLevelILMarkLabel(func, label)


# -------------------------------------------------------
# _BNLowLevelILSetCurrentAddress

_BNLowLevelILSetCurrentAddress = core.BNLowLevelILSetCurrentAddress
_BNLowLevelILSetCurrentAddress.restype = None
_BNLowLevelILSetCurrentAddress.argtypes = [
		ctypes.POINTER(BNLowLevelILFunction),
		ctypes.POINTER(BNArchitecture),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNLowLevelILSetCurrentAddress(
		func: ctypes.POINTER(BNLowLevelILFunction), 
		arch: ctypes.POINTER(BNArchitecture), 
		addr: int
		) -> None:
	return _BNLowLevelILSetCurrentAddress(func, arch, addr)


# -------------------------------------------------------
# _BNLowLevelILSetCurrentSourceBlock

_BNLowLevelILSetCurrentSourceBlock = core.BNLowLevelILSetCurrentSourceBlock
_BNLowLevelILSetCurrentSourceBlock.restype = None
_BNLowLevelILSetCurrentSourceBlock.argtypes = [
		ctypes.POINTER(BNLowLevelILFunction),
		ctypes.POINTER(BNBasicBlock),
	]


# noinspection PyPep8Naming
def BNLowLevelILSetCurrentSourceBlock(
		func: ctypes.POINTER(BNLowLevelILFunction), 
		source: ctypes.POINTER(BNBasicBlock)
		) -> None:
	return _BNLowLevelILSetCurrentSourceBlock(func, source)


# -------------------------------------------------------
# _BNLowLevelILSetExprSourceOperand

_BNLowLevelILSetExprSourceOperand = core.BNLowLevelILSetExprSourceOperand
_BNLowLevelILSetExprSourceOperand.restype = None
_BNLowLevelILSetExprSourceOperand.argtypes = [
		ctypes.POINTER(BNLowLevelILFunction),
		ctypes.c_ulonglong,
		ctypes.c_uint,
	]


# noinspection PyPep8Naming
def BNLowLevelILSetExprSourceOperand(
		func: ctypes.POINTER(BNLowLevelILFunction), 
		expr: int, 
		operand: int
		) -> None:
	return _BNLowLevelILSetExprSourceOperand(func, expr, operand)


# -------------------------------------------------------
# _BNLowLevelILSetIndirectBranches

_BNLowLevelILSetIndirectBranches = core.BNLowLevelILSetIndirectBranches
_BNLowLevelILSetIndirectBranches.restype = None
_BNLowLevelILSetIndirectBranches.argtypes = [
		ctypes.POINTER(BNLowLevelILFunction),
		ctypes.POINTER(BNArchitectureAndAddress),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNLowLevelILSetIndirectBranches(
		func: ctypes.POINTER(BNLowLevelILFunction), 
		branches: ctypes.POINTER(BNArchitectureAndAddress), 
		count: int
		) -> None:
	return _BNLowLevelILSetIndirectBranches(func, branches, count)


# -------------------------------------------------------
# _BNMarkBasicBlockAsRecentlyUsed

_BNMarkBasicBlockAsRecentlyUsed = core.BNMarkBasicBlockAsRecentlyUsed
_BNMarkBasicBlockAsRecentlyUsed.restype = None
_BNMarkBasicBlockAsRecentlyUsed.argtypes = [
		ctypes.POINTER(BNBasicBlock),
	]


# noinspection PyPep8Naming
def BNMarkBasicBlockAsRecentlyUsed(
		block: ctypes.POINTER(BNBasicBlock)
		) -> None:
	return _BNMarkBasicBlockAsRecentlyUsed(block)


# -------------------------------------------------------
# _BNMarkCallerUpdatesRequired

_BNMarkCallerUpdatesRequired = core.BNMarkCallerUpdatesRequired
_BNMarkCallerUpdatesRequired.restype = None
_BNMarkCallerUpdatesRequired.argtypes = [
		ctypes.POINTER(BNFunction),
		FunctionUpdateTypeEnum,
	]


# noinspection PyPep8Naming
def BNMarkCallerUpdatesRequired(
		func: ctypes.POINTER(BNFunction), 
		type: FunctionUpdateType
		) -> None:
	return _BNMarkCallerUpdatesRequired(func, type)


# -------------------------------------------------------
# _BNMarkFileModified

_BNMarkFileModified = core.BNMarkFileModified
_BNMarkFileModified.restype = None
_BNMarkFileModified.argtypes = [
		ctypes.POINTER(BNFileMetadata),
	]


# noinspection PyPep8Naming
def BNMarkFileModified(
		file: ctypes.POINTER(BNFileMetadata)
		) -> None:
	return _BNMarkFileModified(file)


# -------------------------------------------------------
# _BNMarkFileSaved

_BNMarkFileSaved = core.BNMarkFileSaved
_BNMarkFileSaved.restype = None
_BNMarkFileSaved.argtypes = [
		ctypes.POINTER(BNFileMetadata),
	]


# noinspection PyPep8Naming
def BNMarkFileSaved(
		file: ctypes.POINTER(BNFileMetadata)
		) -> None:
	return _BNMarkFileSaved(file)


# -------------------------------------------------------
# _BNMarkFunctionAsRecentlyUsed

_BNMarkFunctionAsRecentlyUsed = core.BNMarkFunctionAsRecentlyUsed
_BNMarkFunctionAsRecentlyUsed.restype = None
_BNMarkFunctionAsRecentlyUsed.argtypes = [
		ctypes.POINTER(BNFunction),
	]


# noinspection PyPep8Naming
def BNMarkFunctionAsRecentlyUsed(
		func: ctypes.POINTER(BNFunction)
		) -> None:
	return _BNMarkFunctionAsRecentlyUsed(func)


# -------------------------------------------------------
# _BNMarkMediumLevelILInstructionForRemoval

_BNMarkMediumLevelILInstructionForRemoval = core.BNMarkMediumLevelILInstructionForRemoval
_BNMarkMediumLevelILInstructionForRemoval.restype = None
_BNMarkMediumLevelILInstructionForRemoval.argtypes = [
		ctypes.POINTER(BNMediumLevelILFunction),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNMarkMediumLevelILInstructionForRemoval(
		func: ctypes.POINTER(BNMediumLevelILFunction), 
		instr: int
		) -> None:
	return _BNMarkMediumLevelILInstructionForRemoval(func, instr)


# -------------------------------------------------------
# _BNMarkUpdatesRequired

_BNMarkUpdatesRequired = core.BNMarkUpdatesRequired
_BNMarkUpdatesRequired.restype = None
_BNMarkUpdatesRequired.argtypes = [
		ctypes.POINTER(BNFunction),
		FunctionUpdateTypeEnum,
	]


# noinspection PyPep8Naming
def BNMarkUpdatesRequired(
		func: ctypes.POINTER(BNFunction), 
		type: FunctionUpdateType
		) -> None:
	return _BNMarkUpdatesRequired(func, type)


# -------------------------------------------------------
# _BNMarkdownToHTML

_BNMarkdownToHTML = core.BNMarkdownToHTML
_BNMarkdownToHTML.restype = ctypes.POINTER(ctypes.c_byte)
_BNMarkdownToHTML.argtypes = [
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNMarkdownToHTML(
		contents: Optional[str]
		) -> Optional[Optional[str]]:
	result = _BNMarkdownToHTML(cstr(contents))
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNMediumLevelILAddExpr

_BNMediumLevelILAddExpr = core.BNMediumLevelILAddExpr
_BNMediumLevelILAddExpr.restype = ctypes.c_ulonglong
_BNMediumLevelILAddExpr.argtypes = [
		ctypes.POINTER(BNMediumLevelILFunction),
		MediumLevelILOperationEnum,
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNMediumLevelILAddExpr(
		func: ctypes.POINTER(BNMediumLevelILFunction), 
		operation: MediumLevelILOperation, 
		size: int, 
		a: int, 
		b: int, 
		c: int, 
		d: int, 
		e: int
		) -> int:
	return _BNMediumLevelILAddExpr(func, operation, size, a, b, c, d, e)


# -------------------------------------------------------
# _BNMediumLevelILAddExprWithLocation

_BNMediumLevelILAddExprWithLocation = core.BNMediumLevelILAddExprWithLocation
_BNMediumLevelILAddExprWithLocation.restype = ctypes.c_ulonglong
_BNMediumLevelILAddExprWithLocation.argtypes = [
		ctypes.POINTER(BNMediumLevelILFunction),
		MediumLevelILOperationEnum,
		ctypes.c_ulonglong,
		ctypes.c_uint,
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNMediumLevelILAddExprWithLocation(
		func: ctypes.POINTER(BNMediumLevelILFunction), 
		operation: MediumLevelILOperation, 
		addr: int, 
		sourceOperand: int, 
		size: int, 
		a: int, 
		b: int, 
		c: int, 
		d: int, 
		e: int
		) -> int:
	return _BNMediumLevelILAddExprWithLocation(func, operation, addr, sourceOperand, size, a, b, c, d, e)


# -------------------------------------------------------
# _BNMediumLevelILAddInstruction

_BNMediumLevelILAddInstruction = core.BNMediumLevelILAddInstruction
_BNMediumLevelILAddInstruction.restype = ctypes.c_ulonglong
_BNMediumLevelILAddInstruction.argtypes = [
		ctypes.POINTER(BNMediumLevelILFunction),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNMediumLevelILAddInstruction(
		func: ctypes.POINTER(BNMediumLevelILFunction), 
		expr: int
		) -> int:
	return _BNMediumLevelILAddInstruction(func, expr)


# -------------------------------------------------------
# _BNMediumLevelILAddLabelMap

_BNMediumLevelILAddLabelMap = core.BNMediumLevelILAddLabelMap
_BNMediumLevelILAddLabelMap.restype = ctypes.c_ulonglong
_BNMediumLevelILAddLabelMap.argtypes = [
		ctypes.POINTER(BNMediumLevelILFunction),
		ctypes.POINTER(ctypes.c_ulonglong),
		ctypes.POINTER(ctypes.POINTER(BNMediumLevelILLabel)),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNMediumLevelILAddLabelMap(
		func: ctypes.POINTER(BNMediumLevelILFunction), 
		values: ctypes.POINTER(ctypes.c_ulonglong), 
		labels: ctypes.POINTER(ctypes.POINTER(BNMediumLevelILLabel)), 
		count: int
		) -> int:
	return _BNMediumLevelILAddLabelMap(func, values, labels, count)


# -------------------------------------------------------
# _BNMediumLevelILAddOperandList

_BNMediumLevelILAddOperandList = core.BNMediumLevelILAddOperandList
_BNMediumLevelILAddOperandList.restype = ctypes.c_ulonglong
_BNMediumLevelILAddOperandList.argtypes = [
		ctypes.POINTER(BNMediumLevelILFunction),
		ctypes.POINTER(ctypes.c_ulonglong),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNMediumLevelILAddOperandList(
		func: ctypes.POINTER(BNMediumLevelILFunction), 
		operands: ctypes.POINTER(ctypes.c_ulonglong), 
		count: int
		) -> int:
	return _BNMediumLevelILAddOperandList(func, operands, count)


# -------------------------------------------------------
# _BNMediumLevelILFreeOperandList

_BNMediumLevelILFreeOperandList = core.BNMediumLevelILFreeOperandList
_BNMediumLevelILFreeOperandList.restype = None
_BNMediumLevelILFreeOperandList.argtypes = [
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNMediumLevelILFreeOperandList(
		operands: ctypes.POINTER(ctypes.c_ulonglong)
		) -> None:
	return _BNMediumLevelILFreeOperandList(operands)


# -------------------------------------------------------
# _BNMediumLevelILGetCurrentAddress

_BNMediumLevelILGetCurrentAddress = core.BNMediumLevelILGetCurrentAddress
_BNMediumLevelILGetCurrentAddress.restype = ctypes.c_ulonglong
_BNMediumLevelILGetCurrentAddress.argtypes = [
		ctypes.POINTER(BNMediumLevelILFunction),
	]


# noinspection PyPep8Naming
def BNMediumLevelILGetCurrentAddress(
		func: ctypes.POINTER(BNMediumLevelILFunction)
		) -> int:
	return _BNMediumLevelILGetCurrentAddress(func)


# -------------------------------------------------------
# _BNMediumLevelILGetInstructionStart

_BNMediumLevelILGetInstructionStart = core.BNMediumLevelILGetInstructionStart
_BNMediumLevelILGetInstructionStart.restype = ctypes.c_ulonglong
_BNMediumLevelILGetInstructionStart.argtypes = [
		ctypes.POINTER(BNMediumLevelILFunction),
		ctypes.POINTER(BNArchitecture),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNMediumLevelILGetInstructionStart(
		func: ctypes.POINTER(BNMediumLevelILFunction), 
		arch: ctypes.POINTER(BNArchitecture), 
		addr: int
		) -> int:
	return _BNMediumLevelILGetInstructionStart(func, arch, addr)


# -------------------------------------------------------
# _BNMediumLevelILGetOperandList

_BNMediumLevelILGetOperandList = core.BNMediumLevelILGetOperandList
_BNMediumLevelILGetOperandList.restype = ctypes.POINTER(ctypes.c_ulonglong)
_BNMediumLevelILGetOperandList.argtypes = [
		ctypes.POINTER(BNMediumLevelILFunction),
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNMediumLevelILGetOperandList(
		func: ctypes.POINTER(BNMediumLevelILFunction), 
		expr: int, 
		operand: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_ulonglong)]:
	result = _BNMediumLevelILGetOperandList(func, expr, operand, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNMediumLevelILGoto

_BNMediumLevelILGoto = core.BNMediumLevelILGoto
_BNMediumLevelILGoto.restype = ctypes.c_ulonglong
_BNMediumLevelILGoto.argtypes = [
		ctypes.POINTER(BNMediumLevelILFunction),
		ctypes.POINTER(BNMediumLevelILLabel),
	]


# noinspection PyPep8Naming
def BNMediumLevelILGoto(
		func: ctypes.POINTER(BNMediumLevelILFunction), 
		label: ctypes.POINTER(BNMediumLevelILLabel)
		) -> int:
	return _BNMediumLevelILGoto(func, label)


# -------------------------------------------------------
# _BNMediumLevelILGotoWithLocation

_BNMediumLevelILGotoWithLocation = core.BNMediumLevelILGotoWithLocation
_BNMediumLevelILGotoWithLocation.restype = ctypes.c_ulonglong
_BNMediumLevelILGotoWithLocation.argtypes = [
		ctypes.POINTER(BNMediumLevelILFunction),
		ctypes.POINTER(BNMediumLevelILLabel),
		ctypes.c_ulonglong,
		ctypes.c_uint,
	]


# noinspection PyPep8Naming
def BNMediumLevelILGotoWithLocation(
		func: ctypes.POINTER(BNMediumLevelILFunction), 
		label: ctypes.POINTER(BNMediumLevelILLabel), 
		addr: int, 
		sourceOperand: int
		) -> int:
	return _BNMediumLevelILGotoWithLocation(func, label, addr, sourceOperand)


# -------------------------------------------------------
# _BNMediumLevelILIf

_BNMediumLevelILIf = core.BNMediumLevelILIf
_BNMediumLevelILIf.restype = ctypes.c_ulonglong
_BNMediumLevelILIf.argtypes = [
		ctypes.POINTER(BNMediumLevelILFunction),
		ctypes.c_ulonglong,
		ctypes.POINTER(BNMediumLevelILLabel),
		ctypes.POINTER(BNMediumLevelILLabel),
	]


# noinspection PyPep8Naming
def BNMediumLevelILIf(
		func: ctypes.POINTER(BNMediumLevelILFunction), 
		op: int, 
		t: ctypes.POINTER(BNMediumLevelILLabel), 
		f: ctypes.POINTER(BNMediumLevelILLabel)
		) -> int:
	return _BNMediumLevelILIf(func, op, t, f)


# -------------------------------------------------------
# _BNMediumLevelILIfWithLocation

_BNMediumLevelILIfWithLocation = core.BNMediumLevelILIfWithLocation
_BNMediumLevelILIfWithLocation.restype = ctypes.c_ulonglong
_BNMediumLevelILIfWithLocation.argtypes = [
		ctypes.POINTER(BNMediumLevelILFunction),
		ctypes.c_ulonglong,
		ctypes.POINTER(BNMediumLevelILLabel),
		ctypes.POINTER(BNMediumLevelILLabel),
		ctypes.c_ulonglong,
		ctypes.c_uint,
	]


# noinspection PyPep8Naming
def BNMediumLevelILIfWithLocation(
		func: ctypes.POINTER(BNMediumLevelILFunction), 
		op: int, 
		t: ctypes.POINTER(BNMediumLevelILLabel), 
		f: ctypes.POINTER(BNMediumLevelILLabel), 
		addr: int, 
		sourceOperand: int
		) -> int:
	return _BNMediumLevelILIfWithLocation(func, op, t, f, addr, sourceOperand)


# -------------------------------------------------------
# _BNMediumLevelILInitLabel

_BNMediumLevelILInitLabel = core.BNMediumLevelILInitLabel
_BNMediumLevelILInitLabel.restype = None
_BNMediumLevelILInitLabel.argtypes = [
		ctypes.POINTER(BNMediumLevelILLabel),
	]


# noinspection PyPep8Naming
def BNMediumLevelILInitLabel(
		label: ctypes.POINTER(BNMediumLevelILLabel)
		) -> None:
	return _BNMediumLevelILInitLabel(label)


# -------------------------------------------------------
# _BNMediumLevelILMarkLabel

_BNMediumLevelILMarkLabel = core.BNMediumLevelILMarkLabel
_BNMediumLevelILMarkLabel.restype = None
_BNMediumLevelILMarkLabel.argtypes = [
		ctypes.POINTER(BNMediumLevelILFunction),
		ctypes.POINTER(BNMediumLevelILLabel),
	]


# noinspection PyPep8Naming
def BNMediumLevelILMarkLabel(
		func: ctypes.POINTER(BNMediumLevelILFunction), 
		label: ctypes.POINTER(BNMediumLevelILLabel)
		) -> None:
	return _BNMediumLevelILMarkLabel(func, label)


# -------------------------------------------------------
# _BNMediumLevelILSetCurrentAddress

_BNMediumLevelILSetCurrentAddress = core.BNMediumLevelILSetCurrentAddress
_BNMediumLevelILSetCurrentAddress.restype = None
_BNMediumLevelILSetCurrentAddress.argtypes = [
		ctypes.POINTER(BNMediumLevelILFunction),
		ctypes.POINTER(BNArchitecture),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNMediumLevelILSetCurrentAddress(
		func: ctypes.POINTER(BNMediumLevelILFunction), 
		arch: ctypes.POINTER(BNArchitecture), 
		addr: int
		) -> None:
	return _BNMediumLevelILSetCurrentAddress(func, arch, addr)


# -------------------------------------------------------
# _BNMergeVariables

_BNMergeVariables = core.BNMergeVariables
_BNMergeVariables.restype = None
_BNMergeVariables.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNVariable),
		ctypes.POINTER(BNVariable),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNMergeVariables(
		func: ctypes.POINTER(BNFunction), 
		target: ctypes.POINTER(BNVariable), 
		sources: ctypes.POINTER(BNVariable), 
		sourceCount: int
		) -> None:
	return _BNMergeVariables(func, target, sources, sourceCount)


# -------------------------------------------------------
# _BNMetadataArrayAppend

_BNMetadataArrayAppend = core.BNMetadataArrayAppend
_BNMetadataArrayAppend.restype = ctypes.c_bool
_BNMetadataArrayAppend.argtypes = [
		ctypes.POINTER(BNMetadata),
		ctypes.POINTER(BNMetadata),
	]


# noinspection PyPep8Naming
def BNMetadataArrayAppend(
		data: ctypes.POINTER(BNMetadata), 
		md: ctypes.POINTER(BNMetadata)
		) -> bool:
	return _BNMetadataArrayAppend(data, md)


# -------------------------------------------------------
# _BNMetadataGetArray

_BNMetadataGetArray = core.BNMetadataGetArray
_BNMetadataGetArray.restype = ctypes.POINTER(ctypes.POINTER(BNMetadata))
_BNMetadataGetArray.argtypes = [
		ctypes.POINTER(BNMetadata),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNMetadataGetArray(
		data: ctypes.POINTER(BNMetadata), 
		size: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.POINTER(BNMetadata))]:
	result = _BNMetadataGetArray(data, size)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNMetadataGetBoolean

_BNMetadataGetBoolean = core.BNMetadataGetBoolean
_BNMetadataGetBoolean.restype = ctypes.c_bool
_BNMetadataGetBoolean.argtypes = [
		ctypes.POINTER(BNMetadata),
	]


# noinspection PyPep8Naming
def BNMetadataGetBoolean(
		data: ctypes.POINTER(BNMetadata)
		) -> bool:
	return _BNMetadataGetBoolean(data)


# -------------------------------------------------------
# _BNMetadataGetBooleanList

_BNMetadataGetBooleanList = core.BNMetadataGetBooleanList
_BNMetadataGetBooleanList.restype = ctypes.POINTER(ctypes.c_bool)
_BNMetadataGetBooleanList.argtypes = [
		ctypes.POINTER(BNMetadata),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNMetadataGetBooleanList(
		data: ctypes.POINTER(BNMetadata), 
		arg1: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_bool)]:
	result = _BNMetadataGetBooleanList(data, arg1)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNMetadataGetDouble

_BNMetadataGetDouble = core.BNMetadataGetDouble
_BNMetadataGetDouble.restype = ctypes.c_double
_BNMetadataGetDouble.argtypes = [
		ctypes.POINTER(BNMetadata),
	]


# noinspection PyPep8Naming
def BNMetadataGetDouble(
		data: ctypes.POINTER(BNMetadata)
		) -> float:
	return _BNMetadataGetDouble(data)


# -------------------------------------------------------
# _BNMetadataGetDoubleList

_BNMetadataGetDoubleList = core.BNMetadataGetDoubleList
_BNMetadataGetDoubleList.restype = ctypes.POINTER(ctypes.c_double)
_BNMetadataGetDoubleList.argtypes = [
		ctypes.POINTER(BNMetadata),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNMetadataGetDoubleList(
		data: ctypes.POINTER(BNMetadata), 
		arg1: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_double)]:
	result = _BNMetadataGetDoubleList(data, arg1)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNMetadataGetForIndex

_BNMetadataGetForIndex = core.BNMetadataGetForIndex
_BNMetadataGetForIndex.restype = ctypes.POINTER(BNMetadata)
_BNMetadataGetForIndex.argtypes = [
		ctypes.POINTER(BNMetadata),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNMetadataGetForIndex(
		data: ctypes.POINTER(BNMetadata), 
		index: int
		) -> Optional[ctypes.POINTER(BNMetadata)]:
	result = _BNMetadataGetForIndex(data, index)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNMetadataGetForKey

_BNMetadataGetForKey = core.BNMetadataGetForKey
_BNMetadataGetForKey.restype = ctypes.POINTER(BNMetadata)
_BNMetadataGetForKey.argtypes = [
		ctypes.POINTER(BNMetadata),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNMetadataGetForKey(
		data: ctypes.POINTER(BNMetadata), 
		key: Optional[str]
		) -> Optional[ctypes.POINTER(BNMetadata)]:
	result = _BNMetadataGetForKey(data, cstr(key))
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNMetadataGetRaw

_BNMetadataGetRaw = core.BNMetadataGetRaw
_BNMetadataGetRaw.restype = ctypes.POINTER(ctypes.c_ubyte)
_BNMetadataGetRaw.argtypes = [
		ctypes.POINTER(BNMetadata),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNMetadataGetRaw(
		data: ctypes.POINTER(BNMetadata), 
		size: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_ubyte)]:
	result = _BNMetadataGetRaw(data, size)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNMetadataGetSignedInteger

_BNMetadataGetSignedInteger = core.BNMetadataGetSignedInteger
_BNMetadataGetSignedInteger.restype = ctypes.c_longlong
_BNMetadataGetSignedInteger.argtypes = [
		ctypes.POINTER(BNMetadata),
	]


# noinspection PyPep8Naming
def BNMetadataGetSignedInteger(
		data: ctypes.POINTER(BNMetadata)
		) -> int:
	return _BNMetadataGetSignedInteger(data)


# -------------------------------------------------------
# _BNMetadataGetSignedIntegerList

_BNMetadataGetSignedIntegerList = core.BNMetadataGetSignedIntegerList
_BNMetadataGetSignedIntegerList.restype = ctypes.POINTER(ctypes.c_longlong)
_BNMetadataGetSignedIntegerList.argtypes = [
		ctypes.POINTER(BNMetadata),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNMetadataGetSignedIntegerList(
		data: ctypes.POINTER(BNMetadata), 
		arg1: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_longlong)]:
	result = _BNMetadataGetSignedIntegerList(data, arg1)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNMetadataGetString

_BNMetadataGetString = core.BNMetadataGetString
_BNMetadataGetString.restype = ctypes.POINTER(ctypes.c_byte)
_BNMetadataGetString.argtypes = [
		ctypes.POINTER(BNMetadata),
	]


# noinspection PyPep8Naming
def BNMetadataGetString(
		data: ctypes.POINTER(BNMetadata)
		) -> Optional[Optional[str]]:
	result = _BNMetadataGetString(data)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNMetadataGetStringList

_BNMetadataGetStringList = core.BNMetadataGetStringList
_BNMetadataGetStringList.restype = ctypes.POINTER(ctypes.c_char_p)
_BNMetadataGetStringList.argtypes = [
		ctypes.POINTER(BNMetadata),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNMetadataGetStringList(
		data: ctypes.POINTER(BNMetadata), 
		arg1: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_char_p)]:
	result = _BNMetadataGetStringList(data, arg1)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNMetadataGetType

_BNMetadataGetType = core.BNMetadataGetType
_BNMetadataGetType.restype = MetadataTypeEnum
_BNMetadataGetType.argtypes = [
		ctypes.POINTER(BNMetadata),
	]


# noinspection PyPep8Naming
def BNMetadataGetType(
		data: ctypes.POINTER(BNMetadata)
		) -> MetadataType:
	return _BNMetadataGetType(data)


# -------------------------------------------------------
# _BNMetadataGetUnsignedInteger

_BNMetadataGetUnsignedInteger = core.BNMetadataGetUnsignedInteger
_BNMetadataGetUnsignedInteger.restype = ctypes.c_ulonglong
_BNMetadataGetUnsignedInteger.argtypes = [
		ctypes.POINTER(BNMetadata),
	]


# noinspection PyPep8Naming
def BNMetadataGetUnsignedInteger(
		data: ctypes.POINTER(BNMetadata)
		) -> int:
	return _BNMetadataGetUnsignedInteger(data)


# -------------------------------------------------------
# _BNMetadataGetUnsignedIntegerList

_BNMetadataGetUnsignedIntegerList = core.BNMetadataGetUnsignedIntegerList
_BNMetadataGetUnsignedIntegerList.restype = ctypes.POINTER(ctypes.c_ulonglong)
_BNMetadataGetUnsignedIntegerList.argtypes = [
		ctypes.POINTER(BNMetadata),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNMetadataGetUnsignedIntegerList(
		data: ctypes.POINTER(BNMetadata), 
		arg1: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_ulonglong)]:
	result = _BNMetadataGetUnsignedIntegerList(data, arg1)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNMetadataGetValueStore

_BNMetadataGetValueStore = core.BNMetadataGetValueStore
_BNMetadataGetValueStore.restype = ctypes.POINTER(BNMetadataValueStore)
_BNMetadataGetValueStore.argtypes = [
		ctypes.POINTER(BNMetadata),
	]


# noinspection PyPep8Naming
def BNMetadataGetValueStore(
		data: ctypes.POINTER(BNMetadata)
		) -> Optional[ctypes.POINTER(BNMetadataValueStore)]:
	result = _BNMetadataGetValueStore(data)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNMetadataIsArray

_BNMetadataIsArray = core.BNMetadataIsArray
_BNMetadataIsArray.restype = ctypes.c_bool
_BNMetadataIsArray.argtypes = [
		ctypes.POINTER(BNMetadata),
	]


# noinspection PyPep8Naming
def BNMetadataIsArray(
		data: ctypes.POINTER(BNMetadata)
		) -> bool:
	return _BNMetadataIsArray(data)


# -------------------------------------------------------
# _BNMetadataIsBoolean

_BNMetadataIsBoolean = core.BNMetadataIsBoolean
_BNMetadataIsBoolean.restype = ctypes.c_bool
_BNMetadataIsBoolean.argtypes = [
		ctypes.POINTER(BNMetadata),
	]


# noinspection PyPep8Naming
def BNMetadataIsBoolean(
		data: ctypes.POINTER(BNMetadata)
		) -> bool:
	return _BNMetadataIsBoolean(data)


# -------------------------------------------------------
# _BNMetadataIsBooleanList

_BNMetadataIsBooleanList = core.BNMetadataIsBooleanList
_BNMetadataIsBooleanList.restype = ctypes.c_bool
_BNMetadataIsBooleanList.argtypes = [
		ctypes.POINTER(BNMetadata),
	]


# noinspection PyPep8Naming
def BNMetadataIsBooleanList(
		data: ctypes.POINTER(BNMetadata)
		) -> bool:
	return _BNMetadataIsBooleanList(data)


# -------------------------------------------------------
# _BNMetadataIsDouble

_BNMetadataIsDouble = core.BNMetadataIsDouble
_BNMetadataIsDouble.restype = ctypes.c_bool
_BNMetadataIsDouble.argtypes = [
		ctypes.POINTER(BNMetadata),
	]


# noinspection PyPep8Naming
def BNMetadataIsDouble(
		data: ctypes.POINTER(BNMetadata)
		) -> bool:
	return _BNMetadataIsDouble(data)


# -------------------------------------------------------
# _BNMetadataIsDoubleList

_BNMetadataIsDoubleList = core.BNMetadataIsDoubleList
_BNMetadataIsDoubleList.restype = ctypes.c_bool
_BNMetadataIsDoubleList.argtypes = [
		ctypes.POINTER(BNMetadata),
	]


# noinspection PyPep8Naming
def BNMetadataIsDoubleList(
		data: ctypes.POINTER(BNMetadata)
		) -> bool:
	return _BNMetadataIsDoubleList(data)


# -------------------------------------------------------
# _BNMetadataIsEqual

_BNMetadataIsEqual = core.BNMetadataIsEqual
_BNMetadataIsEqual.restype = ctypes.c_bool
_BNMetadataIsEqual.argtypes = [
		ctypes.POINTER(BNMetadata),
		ctypes.POINTER(BNMetadata),
	]


# noinspection PyPep8Naming
def BNMetadataIsEqual(
		lhs: ctypes.POINTER(BNMetadata), 
		rhs: ctypes.POINTER(BNMetadata)
		) -> bool:
	return _BNMetadataIsEqual(lhs, rhs)


# -------------------------------------------------------
# _BNMetadataIsKeyValueStore

_BNMetadataIsKeyValueStore = core.BNMetadataIsKeyValueStore
_BNMetadataIsKeyValueStore.restype = ctypes.c_bool
_BNMetadataIsKeyValueStore.argtypes = [
		ctypes.POINTER(BNMetadata),
	]


# noinspection PyPep8Naming
def BNMetadataIsKeyValueStore(
		data: ctypes.POINTER(BNMetadata)
		) -> bool:
	return _BNMetadataIsKeyValueStore(data)


# -------------------------------------------------------
# _BNMetadataIsRaw

_BNMetadataIsRaw = core.BNMetadataIsRaw
_BNMetadataIsRaw.restype = ctypes.c_bool
_BNMetadataIsRaw.argtypes = [
		ctypes.POINTER(BNMetadata),
	]


# noinspection PyPep8Naming
def BNMetadataIsRaw(
		data: ctypes.POINTER(BNMetadata)
		) -> bool:
	return _BNMetadataIsRaw(data)


# -------------------------------------------------------
# _BNMetadataIsSignedInteger

_BNMetadataIsSignedInteger = core.BNMetadataIsSignedInteger
_BNMetadataIsSignedInteger.restype = ctypes.c_bool
_BNMetadataIsSignedInteger.argtypes = [
		ctypes.POINTER(BNMetadata),
	]


# noinspection PyPep8Naming
def BNMetadataIsSignedInteger(
		data: ctypes.POINTER(BNMetadata)
		) -> bool:
	return _BNMetadataIsSignedInteger(data)


# -------------------------------------------------------
# _BNMetadataIsSignedIntegerList

_BNMetadataIsSignedIntegerList = core.BNMetadataIsSignedIntegerList
_BNMetadataIsSignedIntegerList.restype = ctypes.c_bool
_BNMetadataIsSignedIntegerList.argtypes = [
		ctypes.POINTER(BNMetadata),
	]


# noinspection PyPep8Naming
def BNMetadataIsSignedIntegerList(
		data: ctypes.POINTER(BNMetadata)
		) -> bool:
	return _BNMetadataIsSignedIntegerList(data)


# -------------------------------------------------------
# _BNMetadataIsString

_BNMetadataIsString = core.BNMetadataIsString
_BNMetadataIsString.restype = ctypes.c_bool
_BNMetadataIsString.argtypes = [
		ctypes.POINTER(BNMetadata),
	]


# noinspection PyPep8Naming
def BNMetadataIsString(
		data: ctypes.POINTER(BNMetadata)
		) -> bool:
	return _BNMetadataIsString(data)


# -------------------------------------------------------
# _BNMetadataIsStringList

_BNMetadataIsStringList = core.BNMetadataIsStringList
_BNMetadataIsStringList.restype = ctypes.c_bool
_BNMetadataIsStringList.argtypes = [
		ctypes.POINTER(BNMetadata),
	]


# noinspection PyPep8Naming
def BNMetadataIsStringList(
		data: ctypes.POINTER(BNMetadata)
		) -> bool:
	return _BNMetadataIsStringList(data)


# -------------------------------------------------------
# _BNMetadataIsUnsignedInteger

_BNMetadataIsUnsignedInteger = core.BNMetadataIsUnsignedInteger
_BNMetadataIsUnsignedInteger.restype = ctypes.c_bool
_BNMetadataIsUnsignedInteger.argtypes = [
		ctypes.POINTER(BNMetadata),
	]


# noinspection PyPep8Naming
def BNMetadataIsUnsignedInteger(
		data: ctypes.POINTER(BNMetadata)
		) -> bool:
	return _BNMetadataIsUnsignedInteger(data)


# -------------------------------------------------------
# _BNMetadataIsUnsignedIntegerList

_BNMetadataIsUnsignedIntegerList = core.BNMetadataIsUnsignedIntegerList
_BNMetadataIsUnsignedIntegerList.restype = ctypes.c_bool
_BNMetadataIsUnsignedIntegerList.argtypes = [
		ctypes.POINTER(BNMetadata),
	]


# noinspection PyPep8Naming
def BNMetadataIsUnsignedIntegerList(
		data: ctypes.POINTER(BNMetadata)
		) -> bool:
	return _BNMetadataIsUnsignedIntegerList(data)


# -------------------------------------------------------
# _BNMetadataRemoveIndex

_BNMetadataRemoveIndex = core.BNMetadataRemoveIndex
_BNMetadataRemoveIndex.restype = None
_BNMetadataRemoveIndex.argtypes = [
		ctypes.POINTER(BNMetadata),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNMetadataRemoveIndex(
		data: ctypes.POINTER(BNMetadata), 
		index: int
		) -> None:
	return _BNMetadataRemoveIndex(data, index)


# -------------------------------------------------------
# _BNMetadataRemoveKey

_BNMetadataRemoveKey = core.BNMetadataRemoveKey
_BNMetadataRemoveKey.restype = None
_BNMetadataRemoveKey.argtypes = [
		ctypes.POINTER(BNMetadata),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNMetadataRemoveKey(
		data: ctypes.POINTER(BNMetadata), 
		key: Optional[str]
		) -> None:
	return _BNMetadataRemoveKey(data, cstr(key))


# -------------------------------------------------------
# _BNMetadataSetValueForKey

_BNMetadataSetValueForKey = core.BNMetadataSetValueForKey
_BNMetadataSetValueForKey.restype = ctypes.c_bool
_BNMetadataSetValueForKey.argtypes = [
		ctypes.POINTER(BNMetadata),
		ctypes.c_char_p,
		ctypes.POINTER(BNMetadata),
	]


# noinspection PyPep8Naming
def BNMetadataSetValueForKey(
		data: ctypes.POINTER(BNMetadata), 
		key: Optional[str], 
		md: ctypes.POINTER(BNMetadata)
		) -> bool:
	return _BNMetadataSetValueForKey(data, cstr(key), md)


# -------------------------------------------------------
# _BNMetadataSize

_BNMetadataSize = core.BNMetadataSize
_BNMetadataSize.restype = ctypes.c_ulonglong
_BNMetadataSize.argtypes = [
		ctypes.POINTER(BNMetadata),
	]


# noinspection PyPep8Naming
def BNMetadataSize(
		data: ctypes.POINTER(BNMetadata)
		) -> int:
	return _BNMetadataSize(data)


# -------------------------------------------------------
# _BNNavigate

_BNNavigate = core.BNNavigate
_BNNavigate.restype = ctypes.c_bool
_BNNavigate.argtypes = [
		ctypes.POINTER(BNFileMetadata),
		ctypes.c_char_p,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNNavigate(
		file: ctypes.POINTER(BNFileMetadata), 
		view: Optional[str], 
		offset: int
		) -> bool:
	return _BNNavigate(file, cstr(view), offset)


# -------------------------------------------------------
# _BNNewActivityReference

_BNNewActivityReference = core.BNNewActivityReference
_BNNewActivityReference.restype = ctypes.POINTER(BNActivity)
_BNNewActivityReference.argtypes = [
		ctypes.POINTER(BNActivity),
	]


# noinspection PyPep8Naming
def BNNewActivityReference(
		activity: ctypes.POINTER(BNActivity)
		) -> Optional[ctypes.POINTER(BNActivity)]:
	result = _BNNewActivityReference(activity)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNNewAnalysisCompletionEventReference

_BNNewAnalysisCompletionEventReference = core.BNNewAnalysisCompletionEventReference
_BNNewAnalysisCompletionEventReference.restype = ctypes.POINTER(BNAnalysisCompletionEvent)
_BNNewAnalysisCompletionEventReference.argtypes = [
		ctypes.POINTER(BNAnalysisCompletionEvent),
	]


# noinspection PyPep8Naming
def BNNewAnalysisCompletionEventReference(
		event: ctypes.POINTER(BNAnalysisCompletionEvent)
		) -> Optional[ctypes.POINTER(BNAnalysisCompletionEvent)]:
	result = _BNNewAnalysisCompletionEventReference(event)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNNewAnalysisContextReference

_BNNewAnalysisContextReference = core.BNNewAnalysisContextReference
_BNNewAnalysisContextReference.restype = ctypes.POINTER(BNAnalysisContext)
_BNNewAnalysisContextReference.argtypes = [
		ctypes.POINTER(BNAnalysisContext),
	]


# noinspection PyPep8Naming
def BNNewAnalysisContextReference(
		analysisContext: ctypes.POINTER(BNAnalysisContext)
		) -> Optional[ctypes.POINTER(BNAnalysisContext)]:
	result = _BNNewAnalysisContextReference(analysisContext)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNNewBackgroundTaskReference

_BNNewBackgroundTaskReference = core.BNNewBackgroundTaskReference
_BNNewBackgroundTaskReference.restype = ctypes.POINTER(BNBackgroundTask)
_BNNewBackgroundTaskReference.argtypes = [
		ctypes.POINTER(BNBackgroundTask),
	]


# noinspection PyPep8Naming
def BNNewBackgroundTaskReference(
		task: ctypes.POINTER(BNBackgroundTask)
		) -> Optional[ctypes.POINTER(BNBackgroundTask)]:
	result = _BNNewBackgroundTaskReference(task)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNNewBasicBlockReference

_BNNewBasicBlockReference = core.BNNewBasicBlockReference
_BNNewBasicBlockReference.restype = ctypes.POINTER(BNBasicBlock)
_BNNewBasicBlockReference.argtypes = [
		ctypes.POINTER(BNBasicBlock),
	]


# noinspection PyPep8Naming
def BNNewBasicBlockReference(
		block: ctypes.POINTER(BNBasicBlock)
		) -> Optional[ctypes.POINTER(BNBasicBlock)]:
	result = _BNNewBasicBlockReference(block)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNNewCallingConventionReference

_BNNewCallingConventionReference = core.BNNewCallingConventionReference
_BNNewCallingConventionReference.restype = ctypes.POINTER(BNCallingConvention)
_BNNewCallingConventionReference.argtypes = [
		ctypes.POINTER(BNCallingConvention),
	]


# noinspection PyPep8Naming
def BNNewCallingConventionReference(
		cc: ctypes.POINTER(BNCallingConvention)
		) -> Optional[ctypes.POINTER(BNCallingConvention)]:
	result = _BNNewCallingConventionReference(cc)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNNewComponentReference

_BNNewComponentReference = core.BNNewComponentReference
_BNNewComponentReference.restype = ctypes.POINTER(BNComponent)
_BNNewComponentReference.argtypes = [
		ctypes.POINTER(BNComponent),
	]


# noinspection PyPep8Naming
def BNNewComponentReference(
		component: ctypes.POINTER(BNComponent)
		) -> Optional[ctypes.POINTER(BNComponent)]:
	result = _BNNewComponentReference(component)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNNewDataRendererReference

_BNNewDataRendererReference = core.BNNewDataRendererReference
_BNNewDataRendererReference.restype = ctypes.POINTER(BNDataRenderer)
_BNNewDataRendererReference.argtypes = [
		ctypes.POINTER(BNDataRenderer),
	]


# noinspection PyPep8Naming
def BNNewDataRendererReference(
		renderer: ctypes.POINTER(BNDataRenderer)
		) -> Optional[ctypes.POINTER(BNDataRenderer)]:
	result = _BNNewDataRendererReference(renderer)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNNewDatabaseReference

_BNNewDatabaseReference = core.BNNewDatabaseReference
_BNNewDatabaseReference.restype = ctypes.POINTER(BNDatabase)
_BNNewDatabaseReference.argtypes = [
		ctypes.POINTER(BNDatabase),
	]


# noinspection PyPep8Naming
def BNNewDatabaseReference(
		database: ctypes.POINTER(BNDatabase)
		) -> Optional[ctypes.POINTER(BNDatabase)]:
	result = _BNNewDatabaseReference(database)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNNewDebugInfoParserReference

_BNNewDebugInfoParserReference = core.BNNewDebugInfoParserReference
_BNNewDebugInfoParserReference.restype = ctypes.POINTER(BNDebugInfoParser)
_BNNewDebugInfoParserReference.argtypes = [
		ctypes.POINTER(BNDebugInfoParser),
	]


# noinspection PyPep8Naming
def BNNewDebugInfoParserReference(
		parser: ctypes.POINTER(BNDebugInfoParser)
		) -> Optional[ctypes.POINTER(BNDebugInfoParser)]:
	result = _BNNewDebugInfoParserReference(parser)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNNewDebugInfoReference

_BNNewDebugInfoReference = core.BNNewDebugInfoReference
_BNNewDebugInfoReference.restype = ctypes.POINTER(BNDebugInfo)
_BNNewDebugInfoReference.argtypes = [
		ctypes.POINTER(BNDebugInfo),
	]


# noinspection PyPep8Naming
def BNNewDebugInfoReference(
		debugInfo: ctypes.POINTER(BNDebugInfo)
		) -> Optional[ctypes.POINTER(BNDebugInfo)]:
	result = _BNNewDebugInfoReference(debugInfo)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNNewDisassemblySettingsReference

_BNNewDisassemblySettingsReference = core.BNNewDisassemblySettingsReference
_BNNewDisassemblySettingsReference.restype = ctypes.POINTER(BNDisassemblySettings)
_BNNewDisassemblySettingsReference.argtypes = [
		ctypes.POINTER(BNDisassemblySettings),
	]


# noinspection PyPep8Naming
def BNNewDisassemblySettingsReference(
		settings: ctypes.POINTER(BNDisassemblySettings)
		) -> Optional[ctypes.POINTER(BNDisassemblySettings)]:
	result = _BNNewDisassemblySettingsReference(settings)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNNewDisassemblyTextRendererReference

_BNNewDisassemblyTextRendererReference = core.BNNewDisassemblyTextRendererReference
_BNNewDisassemblyTextRendererReference.restype = ctypes.POINTER(BNDisassemblyTextRenderer)
_BNNewDisassemblyTextRendererReference.argtypes = [
		ctypes.POINTER(BNDisassemblyTextRenderer),
	]


# noinspection PyPep8Naming
def BNNewDisassemblyTextRendererReference(
		renderer: ctypes.POINTER(BNDisassemblyTextRenderer)
		) -> Optional[ctypes.POINTER(BNDisassemblyTextRenderer)]:
	result = _BNNewDisassemblyTextRendererReference(renderer)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNNewDownloadInstanceReference

_BNNewDownloadInstanceReference = core.BNNewDownloadInstanceReference
_BNNewDownloadInstanceReference.restype = ctypes.POINTER(BNDownloadInstance)
_BNNewDownloadInstanceReference.argtypes = [
		ctypes.POINTER(BNDownloadInstance),
	]


# noinspection PyPep8Naming
def BNNewDownloadInstanceReference(
		instance: ctypes.POINTER(BNDownloadInstance)
		) -> Optional[ctypes.POINTER(BNDownloadInstance)]:
	result = _BNNewDownloadInstanceReference(instance)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNNewEnumerationReference

_BNNewEnumerationReference = core.BNNewEnumerationReference
_BNNewEnumerationReference.restype = ctypes.POINTER(BNEnumeration)
_BNNewEnumerationReference.argtypes = [
		ctypes.POINTER(BNEnumeration),
	]


# noinspection PyPep8Naming
def BNNewEnumerationReference(
		e: ctypes.POINTER(BNEnumeration)
		) -> Optional[ctypes.POINTER(BNEnumeration)]:
	result = _BNNewEnumerationReference(e)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNNewExternalLibraryReference

_BNNewExternalLibraryReference = core.BNNewExternalLibraryReference
_BNNewExternalLibraryReference.restype = ctypes.POINTER(BNExternalLibrary)
_BNNewExternalLibraryReference.argtypes = [
		ctypes.POINTER(BNExternalLibrary),
	]


# noinspection PyPep8Naming
def BNNewExternalLibraryReference(
		lib: ctypes.POINTER(BNExternalLibrary)
		) -> Optional[ctypes.POINTER(BNExternalLibrary)]:
	result = _BNNewExternalLibraryReference(lib)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNNewExternalLocationReference

_BNNewExternalLocationReference = core.BNNewExternalLocationReference
_BNNewExternalLocationReference.restype = ctypes.POINTER(BNExternalLocation)
_BNNewExternalLocationReference.argtypes = [
		ctypes.POINTER(BNExternalLocation),
	]


# noinspection PyPep8Naming
def BNNewExternalLocationReference(
		loc: ctypes.POINTER(BNExternalLocation)
		) -> Optional[ctypes.POINTER(BNExternalLocation)]:
	result = _BNNewExternalLocationReference(loc)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNNewFileReference

_BNNewFileReference = core.BNNewFileReference
_BNNewFileReference.restype = ctypes.POINTER(BNFileMetadata)
_BNNewFileReference.argtypes = [
		ctypes.POINTER(BNFileMetadata),
	]


# noinspection PyPep8Naming
def BNNewFileReference(
		file: ctypes.POINTER(BNFileMetadata)
		) -> Optional[ctypes.POINTER(BNFileMetadata)]:
	result = _BNNewFileReference(file)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNNewFlowGraphLayoutRequestReference

_BNNewFlowGraphLayoutRequestReference = core.BNNewFlowGraphLayoutRequestReference
_BNNewFlowGraphLayoutRequestReference.restype = ctypes.POINTER(BNFlowGraphLayoutRequest)
_BNNewFlowGraphLayoutRequestReference.argtypes = [
		ctypes.POINTER(BNFlowGraphLayoutRequest),
	]


# noinspection PyPep8Naming
def BNNewFlowGraphLayoutRequestReference(
		layout: ctypes.POINTER(BNFlowGraphLayoutRequest)
		) -> Optional[ctypes.POINTER(BNFlowGraphLayoutRequest)]:
	result = _BNNewFlowGraphLayoutRequestReference(layout)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNNewFlowGraphNodeReference

_BNNewFlowGraphNodeReference = core.BNNewFlowGraphNodeReference
_BNNewFlowGraphNodeReference.restype = ctypes.POINTER(BNFlowGraphNode)
_BNNewFlowGraphNodeReference.argtypes = [
		ctypes.POINTER(BNFlowGraphNode),
	]


# noinspection PyPep8Naming
def BNNewFlowGraphNodeReference(
		node: ctypes.POINTER(BNFlowGraphNode)
		) -> Optional[ctypes.POINTER(BNFlowGraphNode)]:
	result = _BNNewFlowGraphNodeReference(node)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNNewFlowGraphReference

_BNNewFlowGraphReference = core.BNNewFlowGraphReference
_BNNewFlowGraphReference.restype = ctypes.POINTER(BNFlowGraph)
_BNNewFlowGraphReference.argtypes = [
		ctypes.POINTER(BNFlowGraph),
	]


# noinspection PyPep8Naming
def BNNewFlowGraphReference(
		graph: ctypes.POINTER(BNFlowGraph)
		) -> Optional[ctypes.POINTER(BNFlowGraph)]:
	result = _BNNewFlowGraphReference(graph)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNNewFunctionReference

_BNNewFunctionReference = core.BNNewFunctionReference
_BNNewFunctionReference.restype = ctypes.POINTER(BNFunction)
_BNNewFunctionReference.argtypes = [
		ctypes.POINTER(BNFunction),
	]


# noinspection PyPep8Naming
def BNNewFunctionReference(
		func: ctypes.POINTER(BNFunction)
		) -> Optional[ctypes.POINTER(BNFunction)]:
	result = _BNNewFunctionReference(func)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNNewHighLevelILFunctionReference

_BNNewHighLevelILFunctionReference = core.BNNewHighLevelILFunctionReference
_BNNewHighLevelILFunctionReference.restype = ctypes.POINTER(BNHighLevelILFunction)
_BNNewHighLevelILFunctionReference.argtypes = [
		ctypes.POINTER(BNHighLevelILFunction),
	]


# noinspection PyPep8Naming
def BNNewHighLevelILFunctionReference(
		func: ctypes.POINTER(BNHighLevelILFunction)
		) -> Optional[ctypes.POINTER(BNHighLevelILFunction)]:
	result = _BNNewHighLevelILFunctionReference(func)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNNewKeyValueStoreReference

_BNNewKeyValueStoreReference = core.BNNewKeyValueStoreReference
_BNNewKeyValueStoreReference.restype = ctypes.POINTER(BNKeyValueStore)
_BNNewKeyValueStoreReference.argtypes = [
		ctypes.POINTER(BNKeyValueStore),
	]


# noinspection PyPep8Naming
def BNNewKeyValueStoreReference(
		store: ctypes.POINTER(BNKeyValueStore)
		) -> Optional[ctypes.POINTER(BNKeyValueStore)]:
	result = _BNNewKeyValueStoreReference(store)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNNewLanguageRepresentationFunctionReference

_BNNewLanguageRepresentationFunctionReference = core.BNNewLanguageRepresentationFunctionReference
_BNNewLanguageRepresentationFunctionReference.restype = ctypes.POINTER(BNLanguageRepresentationFunction)
_BNNewLanguageRepresentationFunctionReference.argtypes = [
		ctypes.POINTER(BNLanguageRepresentationFunction),
	]


# noinspection PyPep8Naming
def BNNewLanguageRepresentationFunctionReference(
		func: ctypes.POINTER(BNLanguageRepresentationFunction)
		) -> Optional[ctypes.POINTER(BNLanguageRepresentationFunction)]:
	result = _BNNewLanguageRepresentationFunctionReference(func)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNNewLinearViewCursorReference

_BNNewLinearViewCursorReference = core.BNNewLinearViewCursorReference
_BNNewLinearViewCursorReference.restype = ctypes.POINTER(BNLinearViewCursor)
_BNNewLinearViewCursorReference.argtypes = [
		ctypes.POINTER(BNLinearViewCursor),
	]


# noinspection PyPep8Naming
def BNNewLinearViewCursorReference(
		cursor: ctypes.POINTER(BNLinearViewCursor)
		) -> Optional[ctypes.POINTER(BNLinearViewCursor)]:
	result = _BNNewLinearViewCursorReference(cursor)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNNewLinearViewObjectReference

_BNNewLinearViewObjectReference = core.BNNewLinearViewObjectReference
_BNNewLinearViewObjectReference.restype = ctypes.POINTER(BNLinearViewObject)
_BNNewLinearViewObjectReference.argtypes = [
		ctypes.POINTER(BNLinearViewObject),
	]


# noinspection PyPep8Naming
def BNNewLinearViewObjectReference(
		obj: ctypes.POINTER(BNLinearViewObject)
		) -> Optional[ctypes.POINTER(BNLinearViewObject)]:
	result = _BNNewLinearViewObjectReference(obj)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNNewLoggerReference

_BNNewLoggerReference = core.BNNewLoggerReference
_BNNewLoggerReference.restype = ctypes.POINTER(BNLogger)
_BNNewLoggerReference.argtypes = [
		ctypes.POINTER(BNLogger),
	]


# noinspection PyPep8Naming
def BNNewLoggerReference(
		logger: ctypes.POINTER(BNLogger)
		) -> Optional[ctypes.POINTER(BNLogger)]:
	result = _BNNewLoggerReference(logger)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNNewLowLevelILFunctionReference

_BNNewLowLevelILFunctionReference = core.BNNewLowLevelILFunctionReference
_BNNewLowLevelILFunctionReference.restype = ctypes.POINTER(BNLowLevelILFunction)
_BNNewLowLevelILFunctionReference.argtypes = [
		ctypes.POINTER(BNLowLevelILFunction),
	]


# noinspection PyPep8Naming
def BNNewLowLevelILFunctionReference(
		func: ctypes.POINTER(BNLowLevelILFunction)
		) -> Optional[ctypes.POINTER(BNLowLevelILFunction)]:
	result = _BNNewLowLevelILFunctionReference(func)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNNewMainThreadActionReference

_BNNewMainThreadActionReference = core.BNNewMainThreadActionReference
_BNNewMainThreadActionReference.restype = ctypes.POINTER(BNMainThreadAction)
_BNNewMainThreadActionReference.argtypes = [
		ctypes.POINTER(BNMainThreadAction),
	]


# noinspection PyPep8Naming
def BNNewMainThreadActionReference(
		action: ctypes.POINTER(BNMainThreadAction)
		) -> Optional[ctypes.POINTER(BNMainThreadAction)]:
	result = _BNNewMainThreadActionReference(action)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNNewMediumLevelILFunctionReference

_BNNewMediumLevelILFunctionReference = core.BNNewMediumLevelILFunctionReference
_BNNewMediumLevelILFunctionReference.restype = ctypes.POINTER(BNMediumLevelILFunction)
_BNNewMediumLevelILFunctionReference.argtypes = [
		ctypes.POINTER(BNMediumLevelILFunction),
	]


# noinspection PyPep8Naming
def BNNewMediumLevelILFunctionReference(
		func: ctypes.POINTER(BNMediumLevelILFunction)
		) -> Optional[ctypes.POINTER(BNMediumLevelILFunction)]:
	result = _BNNewMediumLevelILFunctionReference(func)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNNewMetadataReference

_BNNewMetadataReference = core.BNNewMetadataReference
_BNNewMetadataReference.restype = ctypes.POINTER(BNMetadata)
_BNNewMetadataReference.argtypes = [
		ctypes.POINTER(BNMetadata),
	]


# noinspection PyPep8Naming
def BNNewMetadataReference(
		data: ctypes.POINTER(BNMetadata)
		) -> Optional[ctypes.POINTER(BNMetadata)]:
	result = _BNNewMetadataReference(data)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNNewNamedTypeReference

_BNNewNamedTypeReference = core.BNNewNamedTypeReference
_BNNewNamedTypeReference.restype = ctypes.POINTER(BNNamedTypeReference)
_BNNewNamedTypeReference.argtypes = [
		ctypes.POINTER(BNNamedTypeReference),
	]


# noinspection PyPep8Naming
def BNNewNamedTypeReference(
		nt: ctypes.POINTER(BNNamedTypeReference)
		) -> Optional[ctypes.POINTER(BNNamedTypeReference)]:
	result = _BNNewNamedTypeReference(nt)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNNewPlatformReference

_BNNewPlatformReference = core.BNNewPlatformReference
_BNNewPlatformReference.restype = ctypes.POINTER(BNPlatform)
_BNNewPlatformReference.argtypes = [
		ctypes.POINTER(BNPlatform),
	]


# noinspection PyPep8Naming
def BNNewPlatformReference(
		platform: ctypes.POINTER(BNPlatform)
		) -> Optional[ctypes.POINTER(BNPlatform)]:
	result = _BNNewPlatformReference(platform)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNNewPluginReference

_BNNewPluginReference = core.BNNewPluginReference
_BNNewPluginReference.restype = ctypes.POINTER(BNRepoPlugin)
_BNNewPluginReference.argtypes = [
		ctypes.POINTER(BNRepoPlugin),
	]


# noinspection PyPep8Naming
def BNNewPluginReference(
		r: ctypes.POINTER(BNRepoPlugin)
		) -> Optional[ctypes.POINTER(BNRepoPlugin)]:
	result = _BNNewPluginReference(r)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNNewProjectFileReference

_BNNewProjectFileReference = core.BNNewProjectFileReference
_BNNewProjectFileReference.restype = ctypes.POINTER(BNProjectFile)
_BNNewProjectFileReference.argtypes = [
		ctypes.POINTER(BNProjectFile),
	]


# noinspection PyPep8Naming
def BNNewProjectFileReference(
		file: ctypes.POINTER(BNProjectFile)
		) -> Optional[ctypes.POINTER(BNProjectFile)]:
	result = _BNNewProjectFileReference(file)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNNewProjectFolderReference

_BNNewProjectFolderReference = core.BNNewProjectFolderReference
_BNNewProjectFolderReference.restype = ctypes.POINTER(BNProjectFolder)
_BNNewProjectFolderReference.argtypes = [
		ctypes.POINTER(BNProjectFolder),
	]


# noinspection PyPep8Naming
def BNNewProjectFolderReference(
		folder: ctypes.POINTER(BNProjectFolder)
		) -> Optional[ctypes.POINTER(BNProjectFolder)]:
	result = _BNNewProjectFolderReference(folder)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNNewProjectReference

_BNNewProjectReference = core.BNNewProjectReference
_BNNewProjectReference.restype = ctypes.POINTER(BNProject)
_BNNewProjectReference.argtypes = [
		ctypes.POINTER(BNProject),
	]


# noinspection PyPep8Naming
def BNNewProjectReference(
		project: ctypes.POINTER(BNProject)
		) -> Optional[ctypes.POINTER(BNProject)]:
	result = _BNNewProjectReference(project)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNNewRelocationHandlerReference

_BNNewRelocationHandlerReference = core.BNNewRelocationHandlerReference
_BNNewRelocationHandlerReference.restype = ctypes.POINTER(BNRelocationHandler)
_BNNewRelocationHandlerReference.argtypes = [
		ctypes.POINTER(BNRelocationHandler),
	]


# noinspection PyPep8Naming
def BNNewRelocationHandlerReference(
		handler: ctypes.POINTER(BNRelocationHandler)
		) -> Optional[ctypes.POINTER(BNRelocationHandler)]:
	result = _BNNewRelocationHandlerReference(handler)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNNewRelocationReference

_BNNewRelocationReference = core.BNNewRelocationReference
_BNNewRelocationReference.restype = ctypes.POINTER(BNRelocation)
_BNNewRelocationReference.argtypes = [
		ctypes.POINTER(BNRelocation),
	]


# noinspection PyPep8Naming
def BNNewRelocationReference(
		reloc: ctypes.POINTER(BNRelocation)
		) -> Optional[ctypes.POINTER(BNRelocation)]:
	result = _BNNewRelocationReference(reloc)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNNewReportCollectionReference

_BNNewReportCollectionReference = core.BNNewReportCollectionReference
_BNNewReportCollectionReference.restype = ctypes.POINTER(BNReportCollection)
_BNNewReportCollectionReference.argtypes = [
		ctypes.POINTER(BNReportCollection),
	]


# noinspection PyPep8Naming
def BNNewReportCollectionReference(
		reports: ctypes.POINTER(BNReportCollection)
		) -> Optional[ctypes.POINTER(BNReportCollection)]:
	result = _BNNewReportCollectionReference(reports)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNNewRepositoryManagerReference

_BNNewRepositoryManagerReference = core.BNNewRepositoryManagerReference
_BNNewRepositoryManagerReference.restype = ctypes.POINTER(BNRepositoryManager)
_BNNewRepositoryManagerReference.argtypes = [
		ctypes.POINTER(BNRepositoryManager),
	]


# noinspection PyPep8Naming
def BNNewRepositoryManagerReference(
		r: ctypes.POINTER(BNRepositoryManager)
		) -> Optional[ctypes.POINTER(BNRepositoryManager)]:
	result = _BNNewRepositoryManagerReference(r)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNNewRepositoryReference

_BNNewRepositoryReference = core.BNNewRepositoryReference
_BNNewRepositoryReference.restype = ctypes.POINTER(BNRepository)
_BNNewRepositoryReference.argtypes = [
		ctypes.POINTER(BNRepository),
	]


# noinspection PyPep8Naming
def BNNewRepositoryReference(
		r: ctypes.POINTER(BNRepository)
		) -> Optional[ctypes.POINTER(BNRepository)]:
	result = _BNNewRepositoryReference(r)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNNewSaveSettingsReference

_BNNewSaveSettingsReference = core.BNNewSaveSettingsReference
_BNNewSaveSettingsReference.restype = ctypes.POINTER(BNSaveSettings)
_BNNewSaveSettingsReference.argtypes = [
		ctypes.POINTER(BNSaveSettings),
	]


# noinspection PyPep8Naming
def BNNewSaveSettingsReference(
		settings: ctypes.POINTER(BNSaveSettings)
		) -> Optional[ctypes.POINTER(BNSaveSettings)]:
	result = _BNNewSaveSettingsReference(settings)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNNewScriptingInstanceReference

_BNNewScriptingInstanceReference = core.BNNewScriptingInstanceReference
_BNNewScriptingInstanceReference.restype = ctypes.POINTER(BNScriptingInstance)
_BNNewScriptingInstanceReference.argtypes = [
		ctypes.POINTER(BNScriptingInstance),
	]


# noinspection PyPep8Naming
def BNNewScriptingInstanceReference(
		instance: ctypes.POINTER(BNScriptingInstance)
		) -> Optional[ctypes.POINTER(BNScriptingInstance)]:
	result = _BNNewScriptingInstanceReference(instance)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNNewSectionReference

_BNNewSectionReference = core.BNNewSectionReference
_BNNewSectionReference.restype = ctypes.POINTER(BNSection)
_BNNewSectionReference.argtypes = [
		ctypes.POINTER(BNSection),
	]


# noinspection PyPep8Naming
def BNNewSectionReference(
		section: ctypes.POINTER(BNSection)
		) -> Optional[ctypes.POINTER(BNSection)]:
	result = _BNNewSectionReference(section)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNNewSegmentReference

_BNNewSegmentReference = core.BNNewSegmentReference
_BNNewSegmentReference.restype = ctypes.POINTER(BNSegment)
_BNNewSegmentReference.argtypes = [
		ctypes.POINTER(BNSegment),
	]


# noinspection PyPep8Naming
def BNNewSegmentReference(
		seg: ctypes.POINTER(BNSegment)
		) -> Optional[ctypes.POINTER(BNSegment)]:
	result = _BNNewSegmentReference(seg)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNNewSettingsReference

_BNNewSettingsReference = core.BNNewSettingsReference
_BNNewSettingsReference.restype = ctypes.POINTER(BNSettings)
_BNNewSettingsReference.argtypes = [
		ctypes.POINTER(BNSettings),
	]


# noinspection PyPep8Naming
def BNNewSettingsReference(
		settings: ctypes.POINTER(BNSettings)
		) -> Optional[ctypes.POINTER(BNSettings)]:
	result = _BNNewSettingsReference(settings)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNNewSnapshotReference

_BNNewSnapshotReference = core.BNNewSnapshotReference
_BNNewSnapshotReference.restype = ctypes.POINTER(BNSnapshot)
_BNNewSnapshotReference.argtypes = [
		ctypes.POINTER(BNSnapshot),
	]


# noinspection PyPep8Naming
def BNNewSnapshotReference(
		snapshot: ctypes.POINTER(BNSnapshot)
		) -> Optional[ctypes.POINTER(BNSnapshot)]:
	result = _BNNewSnapshotReference(snapshot)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNNewStructureReference

_BNNewStructureReference = core.BNNewStructureReference
_BNNewStructureReference.restype = ctypes.POINTER(BNStructure)
_BNNewStructureReference.argtypes = [
		ctypes.POINTER(BNStructure),
	]


# noinspection PyPep8Naming
def BNNewStructureReference(
		s: ctypes.POINTER(BNStructure)
		) -> Optional[ctypes.POINTER(BNStructure)]:
	result = _BNNewStructureReference(s)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNNewSymbolReference

_BNNewSymbolReference = core.BNNewSymbolReference
_BNNewSymbolReference.restype = ctypes.POINTER(BNSymbol)
_BNNewSymbolReference.argtypes = [
		ctypes.POINTER(BNSymbol),
	]


# noinspection PyPep8Naming
def BNNewSymbolReference(
		sym: ctypes.POINTER(BNSymbol)
		) -> Optional[ctypes.POINTER(BNSymbol)]:
	result = _BNNewSymbolReference(sym)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNNewTagReference

_BNNewTagReference = core.BNNewTagReference
_BNNewTagReference.restype = ctypes.POINTER(BNTag)
_BNNewTagReference.argtypes = [
		ctypes.POINTER(BNTag),
	]


# noinspection PyPep8Naming
def BNNewTagReference(
		tag: ctypes.POINTER(BNTag)
		) -> Optional[ctypes.POINTER(BNTag)]:
	result = _BNNewTagReference(tag)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNNewTagTypeReference

_BNNewTagTypeReference = core.BNNewTagTypeReference
_BNNewTagTypeReference.restype = ctypes.POINTER(BNTagType)
_BNNewTagTypeReference.argtypes = [
		ctypes.POINTER(BNTagType),
	]


# noinspection PyPep8Naming
def BNNewTagTypeReference(
		tagType: ctypes.POINTER(BNTagType)
		) -> Optional[ctypes.POINTER(BNTagType)]:
	result = _BNNewTagTypeReference(tagType)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNNewTemporaryFileReference

_BNNewTemporaryFileReference = core.BNNewTemporaryFileReference
_BNNewTemporaryFileReference.restype = ctypes.POINTER(BNTemporaryFile)
_BNNewTemporaryFileReference.argtypes = [
		ctypes.POINTER(BNTemporaryFile),
	]


# noinspection PyPep8Naming
def BNNewTemporaryFileReference(
		file: ctypes.POINTER(BNTemporaryFile)
		) -> Optional[ctypes.POINTER(BNTemporaryFile)]:
	result = _BNNewTemporaryFileReference(file)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNNewTypeArchiveReference

_BNNewTypeArchiveReference = core.BNNewTypeArchiveReference
_BNNewTypeArchiveReference.restype = ctypes.POINTER(BNTypeArchive)
_BNNewTypeArchiveReference.argtypes = [
		ctypes.POINTER(BNTypeArchive),
	]


# noinspection PyPep8Naming
def BNNewTypeArchiveReference(
		archive: ctypes.POINTER(BNTypeArchive)
		) -> Optional[ctypes.POINTER(BNTypeArchive)]:
	result = _BNNewTypeArchiveReference(archive)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNNewTypeLibrary

_BNNewTypeLibrary = core.BNNewTypeLibrary
_BNNewTypeLibrary.restype = ctypes.POINTER(BNTypeLibrary)
_BNNewTypeLibrary.argtypes = [
		ctypes.POINTER(BNArchitecture),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNNewTypeLibrary(
		arch: ctypes.POINTER(BNArchitecture), 
		name: Optional[str]
		) -> Optional[ctypes.POINTER(BNTypeLibrary)]:
	result = _BNNewTypeLibrary(arch, cstr(name))
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNNewTypeLibraryReference

_BNNewTypeLibraryReference = core.BNNewTypeLibraryReference
_BNNewTypeLibraryReference.restype = ctypes.POINTER(BNTypeLibrary)
_BNNewTypeLibraryReference.argtypes = [
		ctypes.POINTER(BNTypeLibrary),
	]


# noinspection PyPep8Naming
def BNNewTypeLibraryReference(
		lib: ctypes.POINTER(BNTypeLibrary)
		) -> Optional[ctypes.POINTER(BNTypeLibrary)]:
	result = _BNNewTypeLibraryReference(lib)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNNewTypeReference

_BNNewTypeReference = core.BNNewTypeReference
_BNNewTypeReference.restype = ctypes.POINTER(BNType)
_BNNewTypeReference.argtypes = [
		ctypes.POINTER(BNType),
	]


# noinspection PyPep8Naming
def BNNewTypeReference(
		type: ctypes.POINTER(BNType)
		) -> Optional[ctypes.POINTER(BNType)]:
	result = _BNNewTypeReference(type)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNNewUserReference

_BNNewUserReference = core.BNNewUserReference
_BNNewUserReference.restype = ctypes.POINTER(BNUser)
_BNNewUserReference.argtypes = [
		ctypes.POINTER(BNUser),
	]


# noinspection PyPep8Naming
def BNNewUserReference(
		user: ctypes.POINTER(BNUser)
		) -> Optional[ctypes.POINTER(BNUser)]:
	result = _BNNewUserReference(user)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNNewViewReference

_BNNewViewReference = core.BNNewViewReference
_BNNewViewReference.restype = ctypes.POINTER(BNBinaryView)
_BNNewViewReference.argtypes = [
		ctypes.POINTER(BNBinaryView),
	]


# noinspection PyPep8Naming
def BNNewViewReference(
		view: ctypes.POINTER(BNBinaryView)
		) -> Optional[ctypes.POINTER(BNBinaryView)]:
	result = _BNNewViewReference(view)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNNewWebsocketClientReference

_BNNewWebsocketClientReference = core.BNNewWebsocketClientReference
_BNNewWebsocketClientReference.restype = ctypes.POINTER(BNWebsocketClient)
_BNNewWebsocketClientReference.argtypes = [
		ctypes.POINTER(BNWebsocketClient),
	]


# noinspection PyPep8Naming
def BNNewWebsocketClientReference(
		client: ctypes.POINTER(BNWebsocketClient)
		) -> Optional[ctypes.POINTER(BNWebsocketClient)]:
	result = _BNNewWebsocketClientReference(client)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNNewWorkflowReference

_BNNewWorkflowReference = core.BNNewWorkflowReference
_BNNewWorkflowReference.restype = ctypes.POINTER(BNWorkflow)
_BNNewWorkflowReference.argtypes = [
		ctypes.POINTER(BNWorkflow),
	]


# noinspection PyPep8Naming
def BNNewWorkflowReference(
		workflow: ctypes.POINTER(BNWorkflow)
		) -> Optional[ctypes.POINTER(BNWorkflow)]:
	result = _BNNewWorkflowReference(workflow)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNNotifyDataInserted

_BNNotifyDataInserted = core.BNNotifyDataInserted
_BNNotifyDataInserted.restype = None
_BNNotifyDataInserted.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNNotifyDataInserted(
		view: ctypes.POINTER(BNBinaryView), 
		offset: int, 
		len: int
		) -> None:
	return _BNNotifyDataInserted(view, offset, len)


# -------------------------------------------------------
# _BNNotifyDataRemoved

_BNNotifyDataRemoved = core.BNNotifyDataRemoved
_BNNotifyDataRemoved.restype = None
_BNNotifyDataRemoved.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNNotifyDataRemoved(
		view: ctypes.POINTER(BNBinaryView), 
		offset: int, 
		len: int
		) -> None:
	return _BNNotifyDataRemoved(view, offset, len)


# -------------------------------------------------------
# _BNNotifyDataWritten

_BNNotifyDataWritten = core.BNNotifyDataWritten
_BNNotifyDataWritten.restype = None
_BNNotifyDataWritten.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNNotifyDataWritten(
		view: ctypes.POINTER(BNBinaryView), 
		offset: int, 
		len: int
		) -> None:
	return _BNNotifyDataWritten(view, offset, len)


# -------------------------------------------------------
# _BNNotifyErrorForScriptingInstance

_BNNotifyErrorForScriptingInstance = core.BNNotifyErrorForScriptingInstance
_BNNotifyErrorForScriptingInstance.restype = None
_BNNotifyErrorForScriptingInstance.argtypes = [
		ctypes.POINTER(BNScriptingInstance),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNNotifyErrorForScriptingInstance(
		instance: ctypes.POINTER(BNScriptingInstance), 
		text: Optional[str]
		) -> None:
	return _BNNotifyErrorForScriptingInstance(instance, cstr(text))


# -------------------------------------------------------
# _BNNotifyInputReadyStateForScriptingInstance

_BNNotifyInputReadyStateForScriptingInstance = core.BNNotifyInputReadyStateForScriptingInstance
_BNNotifyInputReadyStateForScriptingInstance.restype = None
_BNNotifyInputReadyStateForScriptingInstance.argtypes = [
		ctypes.POINTER(BNScriptingInstance),
		ScriptingProviderInputReadyStateEnum,
	]


# noinspection PyPep8Naming
def BNNotifyInputReadyStateForScriptingInstance(
		instance: ctypes.POINTER(BNScriptingInstance), 
		state: ScriptingProviderInputReadyState
		) -> None:
	return _BNNotifyInputReadyStateForScriptingInstance(instance, state)


# -------------------------------------------------------
# _BNNotifyOutputForScriptingInstance

_BNNotifyOutputForScriptingInstance = core.BNNotifyOutputForScriptingInstance
_BNNotifyOutputForScriptingInstance.restype = None
_BNNotifyOutputForScriptingInstance.argtypes = [
		ctypes.POINTER(BNScriptingInstance),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNNotifyOutputForScriptingInstance(
		instance: ctypes.POINTER(BNScriptingInstance), 
		text: Optional[str]
		) -> None:
	return _BNNotifyOutputForScriptingInstance(instance, cstr(text))


# -------------------------------------------------------
# _BNNotifyProgressForDownloadInstance

_BNNotifyProgressForDownloadInstance = core.BNNotifyProgressForDownloadInstance
_BNNotifyProgressForDownloadInstance.restype = ctypes.c_bool
_BNNotifyProgressForDownloadInstance.argtypes = [
		ctypes.POINTER(BNDownloadInstance),
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNNotifyProgressForDownloadInstance(
		instance: ctypes.POINTER(BNDownloadInstance), 
		progress: int, 
		total: int
		) -> bool:
	return _BNNotifyProgressForDownloadInstance(instance, progress, total)


# -------------------------------------------------------
# _BNNotifyWarningForScriptingInstance

_BNNotifyWarningForScriptingInstance = core.BNNotifyWarningForScriptingInstance
_BNNotifyWarningForScriptingInstance.restype = None
_BNNotifyWarningForScriptingInstance.argtypes = [
		ctypes.POINTER(BNScriptingInstance),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNNotifyWarningForScriptingInstance(
		instance: ctypes.POINTER(BNScriptingInstance), 
		text: Optional[str]
		) -> None:
	return _BNNotifyWarningForScriptingInstance(instance, cstr(text))


# -------------------------------------------------------
# _BNNotifyWebsocketClientConnect

_BNNotifyWebsocketClientConnect = core.BNNotifyWebsocketClientConnect
_BNNotifyWebsocketClientConnect.restype = ctypes.c_bool
_BNNotifyWebsocketClientConnect.argtypes = [
		ctypes.POINTER(BNWebsocketClient),
	]


# noinspection PyPep8Naming
def BNNotifyWebsocketClientConnect(
		client: ctypes.POINTER(BNWebsocketClient)
		) -> bool:
	return _BNNotifyWebsocketClientConnect(client)


# -------------------------------------------------------
# _BNNotifyWebsocketClientDisconnect

_BNNotifyWebsocketClientDisconnect = core.BNNotifyWebsocketClientDisconnect
_BNNotifyWebsocketClientDisconnect.restype = None
_BNNotifyWebsocketClientDisconnect.argtypes = [
		ctypes.POINTER(BNWebsocketClient),
	]


# noinspection PyPep8Naming
def BNNotifyWebsocketClientDisconnect(
		client: ctypes.POINTER(BNWebsocketClient)
		) -> None:
	return _BNNotifyWebsocketClientDisconnect(client)


# -------------------------------------------------------
# _BNNotifyWebsocketClientError

_BNNotifyWebsocketClientError = core.BNNotifyWebsocketClientError
_BNNotifyWebsocketClientError.restype = None
_BNNotifyWebsocketClientError.argtypes = [
		ctypes.POINTER(BNWebsocketClient),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNNotifyWebsocketClientError(
		client: ctypes.POINTER(BNWebsocketClient), 
		msg: Optional[str]
		) -> None:
	return _BNNotifyWebsocketClientError(client, cstr(msg))


# -------------------------------------------------------
# _BNNotifyWebsocketClientReadData

_BNNotifyWebsocketClientReadData = core.BNNotifyWebsocketClientReadData
_BNNotifyWebsocketClientReadData.restype = ctypes.c_bool
_BNNotifyWebsocketClientReadData.argtypes = [
		ctypes.POINTER(BNWebsocketClient),
		ctypes.POINTER(ctypes.c_ubyte),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNNotifyWebsocketClientReadData(
		client: ctypes.POINTER(BNWebsocketClient), 
		data: ctypes.POINTER(ctypes.c_ubyte), 
		len: int
		) -> bool:
	return _BNNotifyWebsocketClientReadData(client, data, len)


# -------------------------------------------------------
# _BNOpenDatabaseForConfiguration

_BNOpenDatabaseForConfiguration = core.BNOpenDatabaseForConfiguration
_BNOpenDatabaseForConfiguration.restype = ctypes.POINTER(BNBinaryView)
_BNOpenDatabaseForConfiguration.argtypes = [
		ctypes.POINTER(BNFileMetadata),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNOpenDatabaseForConfiguration(
		file: ctypes.POINTER(BNFileMetadata), 
		path: Optional[str]
		) -> Optional[ctypes.POINTER(BNBinaryView)]:
	result = _BNOpenDatabaseForConfiguration(file, cstr(path))
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNOpenExistingDatabase

_BNOpenExistingDatabase = core.BNOpenExistingDatabase
_BNOpenExistingDatabase.restype = ctypes.POINTER(BNBinaryView)
_BNOpenExistingDatabase.argtypes = [
		ctypes.POINTER(BNFileMetadata),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNOpenExistingDatabase(
		file: ctypes.POINTER(BNFileMetadata), 
		path: Optional[str]
		) -> Optional[ctypes.POINTER(BNBinaryView)]:
	result = _BNOpenExistingDatabase(file, cstr(path))
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNOpenExistingDatabaseWithProgress

_BNOpenExistingDatabaseWithProgress = core.BNOpenExistingDatabaseWithProgress
_BNOpenExistingDatabaseWithProgress.restype = ctypes.POINTER(BNBinaryView)
_BNOpenExistingDatabaseWithProgress.argtypes = [
		ctypes.POINTER(BNFileMetadata),
		ctypes.c_char_p,
		ctypes.c_void_p,
		ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNOpenExistingDatabaseWithProgress(
		file: ctypes.POINTER(BNFileMetadata), 
		path: Optional[str], 
		ctxt: Optional[ctypes.c_void_p], 
		progress: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNBinaryView)]:
	result = _BNOpenExistingDatabaseWithProgress(file, cstr(path), ctxt, progress)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNOpenProject

_BNOpenProject = core.BNOpenProject
_BNOpenProject.restype = ctypes.POINTER(BNProject)
_BNOpenProject.argtypes = [
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNOpenProject(
		path: Optional[str]
		) -> Optional[ctypes.POINTER(BNProject)]:
	result = _BNOpenProject(cstr(path))
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNOpenTypeArchive

_BNOpenTypeArchive = core.BNOpenTypeArchive
_BNOpenTypeArchive.restype = ctypes.POINTER(BNTypeArchive)
_BNOpenTypeArchive.argtypes = [
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNOpenTypeArchive(
		path: Optional[str]
		) -> Optional[ctypes.POINTER(BNTypeArchive)]:
	result = _BNOpenTypeArchive(cstr(path))
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNOpenUrl

_BNOpenUrl = core.BNOpenUrl
_BNOpenUrl.restype = ctypes.c_bool
_BNOpenUrl.argtypes = [
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNOpenUrl(
		url: Optional[str]
		) -> bool:
	return _BNOpenUrl(cstr(url))


# -------------------------------------------------------
# _BNParseBinaryViewOfType

_BNParseBinaryViewOfType = core.BNParseBinaryViewOfType
_BNParseBinaryViewOfType.restype = ctypes.POINTER(BNBinaryView)
_BNParseBinaryViewOfType.argtypes = [
		ctypes.POINTER(BNBinaryViewType),
		ctypes.POINTER(BNBinaryView),
	]


# noinspection PyPep8Naming
def BNParseBinaryViewOfType(
		type: ctypes.POINTER(BNBinaryViewType), 
		data: ctypes.POINTER(BNBinaryView)
		) -> Optional[ctypes.POINTER(BNBinaryView)]:
	result = _BNParseBinaryViewOfType(type, data)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNParseDebugInfo

_BNParseDebugInfo = core.BNParseDebugInfo
_BNParseDebugInfo.restype = ctypes.POINTER(BNDebugInfo)
_BNParseDebugInfo.argtypes = [
		ctypes.POINTER(BNDebugInfoParser),
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNDebugInfo),
		ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong),
		ctypes.c_void_p,
	]


# noinspection PyPep8Naming
def BNParseDebugInfo(
		parser: ctypes.POINTER(BNDebugInfoParser), 
		view: ctypes.POINTER(BNBinaryView), 
		debugFile: ctypes.POINTER(BNBinaryView), 
		existingDebugInfo: ctypes.POINTER(BNDebugInfo), 
		progress: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong), 
		progressCtxt: Optional[ctypes.c_void_p]
		) -> Optional[ctypes.POINTER(BNDebugInfo)]:
	result = _BNParseDebugInfo(parser, view, debugFile, existingDebugInfo, progress, progressCtxt)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNParseExpression

_BNParseExpression = core.BNParseExpression
_BNParseExpression.restype = ctypes.c_bool
_BNParseExpression.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_char_p,
		ctypes.POINTER(ctypes.c_ulonglong),
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_char_p),
	]


# noinspection PyPep8Naming
def BNParseExpression(
		view: ctypes.POINTER(BNBinaryView), 
		expression: Optional[str], 
		offset: ctypes.POINTER(ctypes.c_ulonglong), 
		here: int, 
		errorString: ctypes.POINTER(ctypes.c_char_p)
		) -> bool:
	return _BNParseExpression(view, cstr(expression), offset, here, errorString)


# -------------------------------------------------------
# _BNParsePossibleValueSet

_BNParsePossibleValueSet = core.BNParsePossibleValueSet
_BNParsePossibleValueSet.restype = ctypes.c_bool
_BNParsePossibleValueSet.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_char_p,
		RegisterValueTypeEnum,
		ctypes.POINTER(BNPossibleValueSet),
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_char_p),
	]


# noinspection PyPep8Naming
def BNParsePossibleValueSet(
		view: ctypes.POINTER(BNBinaryView), 
		valueText: Optional[str], 
		state: RegisterValueType, 
		result: ctypes.POINTER(BNPossibleValueSet), 
		here: int, 
		errors: ctypes.POINTER(ctypes.c_char_p)
		) -> bool:
	return _BNParsePossibleValueSet(view, cstr(valueText), state, result, here, errors)


# -------------------------------------------------------
# _BNParseTypeParserOptionsText

_BNParseTypeParserOptionsText = core.BNParseTypeParserOptionsText
_BNParseTypeParserOptionsText.restype = ctypes.POINTER(ctypes.c_char_p)
_BNParseTypeParserOptionsText.argtypes = [
		ctypes.c_char_p,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNParseTypeParserOptionsText(
		optionsText: Optional[str], 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_char_p)]:
	result = _BNParseTypeParserOptionsText(cstr(optionsText), count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNParseTypeString

_BNParseTypeString = core.BNParseTypeString
_BNParseTypeString.restype = ctypes.c_bool
_BNParseTypeString.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_char_p,
		ctypes.POINTER(BNQualifiedNameAndType),
		ctypes.POINTER(ctypes.c_char_p),
		ctypes.POINTER(BNQualifiedNameList),
	]


# noinspection PyPep8Naming
def BNParseTypeString(
		view: ctypes.POINTER(BNBinaryView), 
		text: Optional[str], 
		result: ctypes.POINTER(BNQualifiedNameAndType), 
		errors: ctypes.POINTER(ctypes.c_char_p), 
		typesAllowRedefinition: ctypes.POINTER(BNQualifiedNameList)
		) -> bool:
	return _BNParseTypeString(view, cstr(text), result, errors, typesAllowRedefinition)


# -------------------------------------------------------
# _BNParseTypesFromSource

_BNParseTypesFromSource = core.BNParseTypesFromSource
_BNParseTypesFromSource.restype = ctypes.c_bool
_BNParseTypesFromSource.argtypes = [
		ctypes.POINTER(BNPlatform),
		ctypes.c_char_p,
		ctypes.c_char_p,
		ctypes.POINTER(BNTypeParserResult),
		ctypes.POINTER(ctypes.c_char_p),
		ctypes.POINTER(ctypes.c_char_p),
		ctypes.c_ulonglong,
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNParseTypesFromSource(
		platform: ctypes.POINTER(BNPlatform), 
		source: Optional[str], 
		fileName: Optional[str], 
		result: ctypes.POINTER(BNTypeParserResult), 
		errors: ctypes.POINTER(ctypes.c_char_p), 
		includeDirs: ctypes.POINTER(ctypes.c_char_p), 
		includeDirCount: int, 
		autoTypeSource: Optional[str]
		) -> bool:
	return _BNParseTypesFromSource(platform, cstr(source), cstr(fileName), result, errors, includeDirs, includeDirCount, cstr(autoTypeSource))


# -------------------------------------------------------
# _BNParseTypesFromSourceFile

_BNParseTypesFromSourceFile = core.BNParseTypesFromSourceFile
_BNParseTypesFromSourceFile.restype = ctypes.c_bool
_BNParseTypesFromSourceFile.argtypes = [
		ctypes.POINTER(BNPlatform),
		ctypes.c_char_p,
		ctypes.POINTER(BNTypeParserResult),
		ctypes.POINTER(ctypes.c_char_p),
		ctypes.POINTER(ctypes.c_char_p),
		ctypes.c_ulonglong,
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNParseTypesFromSourceFile(
		platform: ctypes.POINTER(BNPlatform), 
		fileName: Optional[str], 
		result: ctypes.POINTER(BNTypeParserResult), 
		errors: ctypes.POINTER(ctypes.c_char_p), 
		includeDirs: ctypes.POINTER(ctypes.c_char_p), 
		includeDirCount: int, 
		autoTypeSource: Optional[str]
		) -> bool:
	return _BNParseTypesFromSourceFile(platform, cstr(fileName), result, errors, includeDirs, includeDirCount, cstr(autoTypeSource))


# -------------------------------------------------------
# _BNParseTypesString

_BNParseTypesString = core.BNParseTypesString
_BNParseTypesString.restype = ctypes.c_bool
_BNParseTypesString.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_char_p,
		ctypes.POINTER(ctypes.c_char_p),
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_char_p),
		ctypes.c_ulonglong,
		ctypes.POINTER(BNTypeParserResult),
		ctypes.POINTER(ctypes.c_char_p),
		ctypes.POINTER(BNQualifiedNameList),
	]


# noinspection PyPep8Naming
def BNParseTypesString(
		view: ctypes.POINTER(BNBinaryView), 
		text: Optional[str], 
		options: ctypes.POINTER(ctypes.c_char_p), 
		optionCount: int, 
		includeDirs: ctypes.POINTER(ctypes.c_char_p), 
		includeDirCount: int, 
		result: ctypes.POINTER(BNTypeParserResult), 
		errors: ctypes.POINTER(ctypes.c_char_p), 
		typesAllowRedefinition: ctypes.POINTER(BNQualifiedNameList)
		) -> bool:
	return _BNParseTypesString(view, cstr(text), options, optionCount, includeDirs, includeDirCount, result, errors, typesAllowRedefinition)


# -------------------------------------------------------
# _BNPathExists

_BNPathExists = core.BNPathExists
_BNPathExists.restype = ctypes.c_bool
_BNPathExists.argtypes = [
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNPathExists(
		path: Optional[str]
		) -> bool:
	return _BNPathExists(cstr(path))


# -------------------------------------------------------
# _BNPerformCustomRequest

_BNPerformCustomRequest = core.BNPerformCustomRequest
_BNPerformCustomRequest.restype = ctypes.c_int
_BNPerformCustomRequest.argtypes = [
		ctypes.POINTER(BNDownloadInstance),
		ctypes.c_char_p,
		ctypes.c_char_p,
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_char_p),
		ctypes.POINTER(ctypes.c_char_p),
		ctypes.POINTER(ctypes.POINTER(BNDownloadInstanceResponse)),
		ctypes.POINTER(BNDownloadInstanceInputOutputCallbacks),
	]


# noinspection PyPep8Naming
def BNPerformCustomRequest(
		instance: ctypes.POINTER(BNDownloadInstance), 
		method: Optional[str], 
		url: Optional[str], 
		headerCount: int, 
		headerKeys: ctypes.POINTER(ctypes.c_char_p), 
		headerValues: ctypes.POINTER(ctypes.c_char_p), 
		response: ctypes.POINTER(ctypes.POINTER(BNDownloadInstanceResponse)), 
		callbacks: ctypes.POINTER(BNDownloadInstanceInputOutputCallbacks)
		) -> int:
	return _BNPerformCustomRequest(instance, cstr(method), cstr(url), headerCount, headerKeys, headerValues, response, callbacks)


# -------------------------------------------------------
# _BNPerformDownloadRequest

_BNPerformDownloadRequest = core.BNPerformDownloadRequest
_BNPerformDownloadRequest.restype = ctypes.c_int
_BNPerformDownloadRequest.argtypes = [
		ctypes.POINTER(BNDownloadInstance),
		ctypes.c_char_p,
		ctypes.POINTER(BNDownloadInstanceOutputCallbacks),
	]


# noinspection PyPep8Naming
def BNPerformDownloadRequest(
		instance: ctypes.POINTER(BNDownloadInstance), 
		url: Optional[str], 
		callbacks: ctypes.POINTER(BNDownloadInstanceOutputCallbacks)
		) -> int:
	return _BNPerformDownloadRequest(instance, cstr(url), callbacks)


# -------------------------------------------------------
# _BNPerformSearch

_BNPerformSearch = core.BNPerformSearch
_BNPerformSearch.restype = ctypes.c_bool
_BNPerformSearch.argtypes = [
		ctypes.c_char_p,
		ctypes.POINTER(ctypes.c_ubyte),
		ctypes.c_ulonglong,
		ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong),
		ctypes.c_void_p,
	]


# noinspection PyPep8Naming
def BNPerformSearch(
		query: Optional[str], 
		buffer: ctypes.POINTER(ctypes.c_ubyte), 
		size: int, 
		callback: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong), 
		context: Optional[ctypes.c_void_p]
		) -> bool:
	return _BNPerformSearch(cstr(query), buffer, size, callback, context)


# -------------------------------------------------------
# _BNPluginAreDependenciesBeingInstalled

_BNPluginAreDependenciesBeingInstalled = core.BNPluginAreDependenciesBeingInstalled
_BNPluginAreDependenciesBeingInstalled.restype = ctypes.c_bool
_BNPluginAreDependenciesBeingInstalled.argtypes = [
		ctypes.POINTER(BNRepoPlugin),
	]


# noinspection PyPep8Naming
def BNPluginAreDependenciesBeingInstalled(
		p: ctypes.POINTER(BNRepoPlugin)
		) -> bool:
	return _BNPluginAreDependenciesBeingInstalled(p)


# -------------------------------------------------------
# _BNPluginDisable

_BNPluginDisable = core.BNPluginDisable
_BNPluginDisable.restype = ctypes.c_bool
_BNPluginDisable.argtypes = [
		ctypes.POINTER(BNRepoPlugin),
	]


# noinspection PyPep8Naming
def BNPluginDisable(
		p: ctypes.POINTER(BNRepoPlugin)
		) -> bool:
	return _BNPluginDisable(p)


# -------------------------------------------------------
# _BNPluginEnable

_BNPluginEnable = core.BNPluginEnable
_BNPluginEnable.restype = ctypes.c_bool
_BNPluginEnable.argtypes = [
		ctypes.POINTER(BNRepoPlugin),
		ctypes.c_bool,
	]


# noinspection PyPep8Naming
def BNPluginEnable(
		p: ctypes.POINTER(BNRepoPlugin), 
		force: bool
		) -> bool:
	return _BNPluginEnable(p, force)


# -------------------------------------------------------
# _BNPluginGetApis

_BNPluginGetApis = core.BNPluginGetApis
_BNPluginGetApis.restype = ctypes.POINTER(ctypes.c_char_p)
_BNPluginGetApis.argtypes = [
		ctypes.POINTER(BNRepoPlugin),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNPluginGetApis(
		p: ctypes.POINTER(BNRepoPlugin), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_char_p)]:
	result = _BNPluginGetApis(p, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNPluginGetAuthor

_BNPluginGetAuthor = core.BNPluginGetAuthor
_BNPluginGetAuthor.restype = ctypes.POINTER(ctypes.c_byte)
_BNPluginGetAuthor.argtypes = [
		ctypes.POINTER(BNRepoPlugin),
	]


# noinspection PyPep8Naming
def BNPluginGetAuthor(
		p: ctypes.POINTER(BNRepoPlugin)
		) -> Optional[Optional[str]]:
	result = _BNPluginGetAuthor(p)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNPluginGetAuthorUrl

_BNPluginGetAuthorUrl = core.BNPluginGetAuthorUrl
_BNPluginGetAuthorUrl.restype = ctypes.POINTER(ctypes.c_byte)
_BNPluginGetAuthorUrl.argtypes = [
		ctypes.POINTER(BNRepoPlugin),
	]


# noinspection PyPep8Naming
def BNPluginGetAuthorUrl(
		p: ctypes.POINTER(BNRepoPlugin)
		) -> Optional[Optional[str]]:
	result = _BNPluginGetAuthorUrl(p)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNPluginGetCommit

_BNPluginGetCommit = core.BNPluginGetCommit
_BNPluginGetCommit.restype = ctypes.POINTER(ctypes.c_byte)
_BNPluginGetCommit.argtypes = [
		ctypes.POINTER(BNRepoPlugin),
	]


# noinspection PyPep8Naming
def BNPluginGetCommit(
		p: ctypes.POINTER(BNRepoPlugin)
		) -> Optional[Optional[str]]:
	result = _BNPluginGetCommit(p)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNPluginGetDependencies

_BNPluginGetDependencies = core.BNPluginGetDependencies
_BNPluginGetDependencies.restype = ctypes.POINTER(ctypes.c_byte)
_BNPluginGetDependencies.argtypes = [
		ctypes.POINTER(BNRepoPlugin),
	]


# noinspection PyPep8Naming
def BNPluginGetDependencies(
		p: ctypes.POINTER(BNRepoPlugin)
		) -> Optional[Optional[str]]:
	result = _BNPluginGetDependencies(p)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNPluginGetDescription

_BNPluginGetDescription = core.BNPluginGetDescription
_BNPluginGetDescription.restype = ctypes.POINTER(ctypes.c_byte)
_BNPluginGetDescription.argtypes = [
		ctypes.POINTER(BNRepoPlugin),
	]


# noinspection PyPep8Naming
def BNPluginGetDescription(
		p: ctypes.POINTER(BNRepoPlugin)
		) -> Optional[Optional[str]]:
	result = _BNPluginGetDescription(p)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNPluginGetInstallInstructions

_BNPluginGetInstallInstructions = core.BNPluginGetInstallInstructions
_BNPluginGetInstallInstructions.restype = ctypes.POINTER(ctypes.c_byte)
_BNPluginGetInstallInstructions.argtypes = [
		ctypes.POINTER(BNRepoPlugin),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNPluginGetInstallInstructions(
		p: ctypes.POINTER(BNRepoPlugin), 
		platform: Optional[str]
		) -> Optional[Optional[str]]:
	result = _BNPluginGetInstallInstructions(p, cstr(platform))
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNPluginGetLastUpdate

_BNPluginGetLastUpdate = core.BNPluginGetLastUpdate
_BNPluginGetLastUpdate.restype = ctypes.c_ulonglong
_BNPluginGetLastUpdate.argtypes = [
		ctypes.POINTER(BNRepoPlugin),
	]


# noinspection PyPep8Naming
def BNPluginGetLastUpdate(
		p: ctypes.POINTER(BNRepoPlugin)
		) -> int:
	return _BNPluginGetLastUpdate(p)


# -------------------------------------------------------
# _BNPluginGetLicense

_BNPluginGetLicense = core.BNPluginGetLicense
_BNPluginGetLicense.restype = ctypes.POINTER(ctypes.c_byte)
_BNPluginGetLicense.argtypes = [
		ctypes.POINTER(BNRepoPlugin),
	]


# noinspection PyPep8Naming
def BNPluginGetLicense(
		p: ctypes.POINTER(BNRepoPlugin)
		) -> Optional[Optional[str]]:
	result = _BNPluginGetLicense(p)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNPluginGetLicenseText

_BNPluginGetLicenseText = core.BNPluginGetLicenseText
_BNPluginGetLicenseText.restype = ctypes.POINTER(ctypes.c_byte)
_BNPluginGetLicenseText.argtypes = [
		ctypes.POINTER(BNRepoPlugin),
	]


# noinspection PyPep8Naming
def BNPluginGetLicenseText(
		p: ctypes.POINTER(BNRepoPlugin)
		) -> Optional[Optional[str]]:
	result = _BNPluginGetLicenseText(p)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNPluginGetLongdescription

_BNPluginGetLongdescription = core.BNPluginGetLongdescription
_BNPluginGetLongdescription.restype = ctypes.POINTER(ctypes.c_byte)
_BNPluginGetLongdescription.argtypes = [
		ctypes.POINTER(BNRepoPlugin),
	]


# noinspection PyPep8Naming
def BNPluginGetLongdescription(
		p: ctypes.POINTER(BNRepoPlugin)
		) -> Optional[Optional[str]]:
	result = _BNPluginGetLongdescription(p)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNPluginGetMinimumVersion

_BNPluginGetMinimumVersion = core.BNPluginGetMinimumVersion
_BNPluginGetMinimumVersion.restype = ctypes.c_ulonglong
_BNPluginGetMinimumVersion.argtypes = [
		ctypes.POINTER(BNRepoPlugin),
	]


# noinspection PyPep8Naming
def BNPluginGetMinimumVersion(
		p: ctypes.POINTER(BNRepoPlugin)
		) -> int:
	return _BNPluginGetMinimumVersion(p)


# -------------------------------------------------------
# _BNPluginGetName

_BNPluginGetName = core.BNPluginGetName
_BNPluginGetName.restype = ctypes.POINTER(ctypes.c_byte)
_BNPluginGetName.argtypes = [
		ctypes.POINTER(BNRepoPlugin),
	]


# noinspection PyPep8Naming
def BNPluginGetName(
		p: ctypes.POINTER(BNRepoPlugin)
		) -> Optional[Optional[str]]:
	result = _BNPluginGetName(p)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNPluginGetPackageUrl

_BNPluginGetPackageUrl = core.BNPluginGetPackageUrl
_BNPluginGetPackageUrl.restype = ctypes.POINTER(ctypes.c_byte)
_BNPluginGetPackageUrl.argtypes = [
		ctypes.POINTER(BNRepoPlugin),
	]


# noinspection PyPep8Naming
def BNPluginGetPackageUrl(
		p: ctypes.POINTER(BNRepoPlugin)
		) -> Optional[Optional[str]]:
	result = _BNPluginGetPackageUrl(p)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNPluginGetPath

_BNPluginGetPath = core.BNPluginGetPath
_BNPluginGetPath.restype = ctypes.POINTER(ctypes.c_byte)
_BNPluginGetPath.argtypes = [
		ctypes.POINTER(BNRepoPlugin),
	]


# noinspection PyPep8Naming
def BNPluginGetPath(
		p: ctypes.POINTER(BNRepoPlugin)
		) -> Optional[Optional[str]]:
	result = _BNPluginGetPath(p)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNPluginGetPlatforms

_BNPluginGetPlatforms = core.BNPluginGetPlatforms
_BNPluginGetPlatforms.restype = ctypes.POINTER(ctypes.c_char_p)
_BNPluginGetPlatforms.argtypes = [
		ctypes.POINTER(BNRepoPlugin),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNPluginGetPlatforms(
		p: ctypes.POINTER(BNRepoPlugin), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_char_p)]:
	result = _BNPluginGetPlatforms(p, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNPluginGetPluginStatus

_BNPluginGetPluginStatus = core.BNPluginGetPluginStatus
_BNPluginGetPluginStatus.restype = PluginStatusEnum
_BNPluginGetPluginStatus.argtypes = [
		ctypes.POINTER(BNRepoPlugin),
	]


# noinspection PyPep8Naming
def BNPluginGetPluginStatus(
		p: ctypes.POINTER(BNRepoPlugin)
		) -> PluginStatus:
	return _BNPluginGetPluginStatus(p)


# -------------------------------------------------------
# _BNPluginGetPluginTypes

_BNPluginGetPluginTypes = core.BNPluginGetPluginTypes
_BNPluginGetPluginTypes.restype = ctypes.POINTER(PluginTypeEnum)
_BNPluginGetPluginTypes.argtypes = [
		ctypes.POINTER(BNRepoPlugin),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNPluginGetPluginTypes(
		p: ctypes.POINTER(BNRepoPlugin), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(PluginTypeEnum)]:
	result = _BNPluginGetPluginTypes(p, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNPluginGetProjectData

_BNPluginGetProjectData = core.BNPluginGetProjectData
_BNPluginGetProjectData.restype = ctypes.POINTER(ctypes.c_byte)
_BNPluginGetProjectData.argtypes = [
		ctypes.POINTER(BNRepoPlugin),
	]


# noinspection PyPep8Naming
def BNPluginGetProjectData(
		p: ctypes.POINTER(BNRepoPlugin)
		) -> Optional[Optional[str]]:
	result = _BNPluginGetProjectData(p)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNPluginGetProjectUrl

_BNPluginGetProjectUrl = core.BNPluginGetProjectUrl
_BNPluginGetProjectUrl.restype = ctypes.POINTER(ctypes.c_byte)
_BNPluginGetProjectUrl.argtypes = [
		ctypes.POINTER(BNRepoPlugin),
	]


# noinspection PyPep8Naming
def BNPluginGetProjectUrl(
		p: ctypes.POINTER(BNRepoPlugin)
		) -> Optional[Optional[str]]:
	result = _BNPluginGetProjectUrl(p)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNPluginGetRepository

_BNPluginGetRepository = core.BNPluginGetRepository
_BNPluginGetRepository.restype = ctypes.POINTER(ctypes.c_byte)
_BNPluginGetRepository.argtypes = [
		ctypes.POINTER(BNRepoPlugin),
	]


# noinspection PyPep8Naming
def BNPluginGetRepository(
		p: ctypes.POINTER(BNRepoPlugin)
		) -> Optional[Optional[str]]:
	result = _BNPluginGetRepository(p)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNPluginGetSubdir

_BNPluginGetSubdir = core.BNPluginGetSubdir
_BNPluginGetSubdir.restype = ctypes.POINTER(ctypes.c_byte)
_BNPluginGetSubdir.argtypes = [
		ctypes.POINTER(BNRepoPlugin),
	]


# noinspection PyPep8Naming
def BNPluginGetSubdir(
		p: ctypes.POINTER(BNRepoPlugin)
		) -> Optional[Optional[str]]:
	result = _BNPluginGetSubdir(p)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNPluginGetVersion

_BNPluginGetVersion = core.BNPluginGetVersion
_BNPluginGetVersion.restype = ctypes.POINTER(ctypes.c_byte)
_BNPluginGetVersion.argtypes = [
		ctypes.POINTER(BNRepoPlugin),
	]


# noinspection PyPep8Naming
def BNPluginGetVersion(
		p: ctypes.POINTER(BNRepoPlugin)
		) -> Optional[Optional[str]]:
	result = _BNPluginGetVersion(p)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNPluginInstall

_BNPluginInstall = core.BNPluginInstall
_BNPluginInstall.restype = ctypes.c_bool
_BNPluginInstall.argtypes = [
		ctypes.POINTER(BNRepoPlugin),
	]


# noinspection PyPep8Naming
def BNPluginInstall(
		p: ctypes.POINTER(BNRepoPlugin)
		) -> bool:
	return _BNPluginInstall(p)


# -------------------------------------------------------
# _BNPluginInstallDependencies

_BNPluginInstallDependencies = core.BNPluginInstallDependencies
_BNPluginInstallDependencies.restype = ctypes.c_bool
_BNPluginInstallDependencies.argtypes = [
		ctypes.POINTER(BNRepoPlugin),
	]


# noinspection PyPep8Naming
def BNPluginInstallDependencies(
		p: ctypes.POINTER(BNRepoPlugin)
		) -> bool:
	return _BNPluginInstallDependencies(p)


# -------------------------------------------------------
# _BNPluginIsBeingDeleted

_BNPluginIsBeingDeleted = core.BNPluginIsBeingDeleted
_BNPluginIsBeingDeleted.restype = ctypes.c_bool
_BNPluginIsBeingDeleted.argtypes = [
		ctypes.POINTER(BNRepoPlugin),
	]


# noinspection PyPep8Naming
def BNPluginIsBeingDeleted(
		p: ctypes.POINTER(BNRepoPlugin)
		) -> bool:
	return _BNPluginIsBeingDeleted(p)


# -------------------------------------------------------
# _BNPluginIsBeingUpdated

_BNPluginIsBeingUpdated = core.BNPluginIsBeingUpdated
_BNPluginIsBeingUpdated.restype = ctypes.c_bool
_BNPluginIsBeingUpdated.argtypes = [
		ctypes.POINTER(BNRepoPlugin),
	]


# noinspection PyPep8Naming
def BNPluginIsBeingUpdated(
		p: ctypes.POINTER(BNRepoPlugin)
		) -> bool:
	return _BNPluginIsBeingUpdated(p)


# -------------------------------------------------------
# _BNPluginIsDeletePending

_BNPluginIsDeletePending = core.BNPluginIsDeletePending
_BNPluginIsDeletePending.restype = ctypes.c_bool
_BNPluginIsDeletePending.argtypes = [
		ctypes.POINTER(BNRepoPlugin),
	]


# noinspection PyPep8Naming
def BNPluginIsDeletePending(
		p: ctypes.POINTER(BNRepoPlugin)
		) -> bool:
	return _BNPluginIsDeletePending(p)


# -------------------------------------------------------
# _BNPluginIsDisablePending

_BNPluginIsDisablePending = core.BNPluginIsDisablePending
_BNPluginIsDisablePending.restype = ctypes.c_bool
_BNPluginIsDisablePending.argtypes = [
		ctypes.POINTER(BNRepoPlugin),
	]


# noinspection PyPep8Naming
def BNPluginIsDisablePending(
		p: ctypes.POINTER(BNRepoPlugin)
		) -> bool:
	return _BNPluginIsDisablePending(p)


# -------------------------------------------------------
# _BNPluginIsEnabled

_BNPluginIsEnabled = core.BNPluginIsEnabled
_BNPluginIsEnabled.restype = ctypes.c_bool
_BNPluginIsEnabled.argtypes = [
		ctypes.POINTER(BNRepoPlugin),
	]


# noinspection PyPep8Naming
def BNPluginIsEnabled(
		p: ctypes.POINTER(BNRepoPlugin)
		) -> bool:
	return _BNPluginIsEnabled(p)


# -------------------------------------------------------
# _BNPluginIsInstalled

_BNPluginIsInstalled = core.BNPluginIsInstalled
_BNPluginIsInstalled.restype = ctypes.c_bool
_BNPluginIsInstalled.argtypes = [
		ctypes.POINTER(BNRepoPlugin),
	]


# noinspection PyPep8Naming
def BNPluginIsInstalled(
		p: ctypes.POINTER(BNRepoPlugin)
		) -> bool:
	return _BNPluginIsInstalled(p)


# -------------------------------------------------------
# _BNPluginIsRunning

_BNPluginIsRunning = core.BNPluginIsRunning
_BNPluginIsRunning.restype = ctypes.c_bool
_BNPluginIsRunning.argtypes = [
		ctypes.POINTER(BNRepoPlugin),
	]


# noinspection PyPep8Naming
def BNPluginIsRunning(
		p: ctypes.POINTER(BNRepoPlugin)
		) -> bool:
	return _BNPluginIsRunning(p)


# -------------------------------------------------------
# _BNPluginIsUpdateAvailable

_BNPluginIsUpdateAvailable = core.BNPluginIsUpdateAvailable
_BNPluginIsUpdateAvailable.restype = ctypes.c_bool
_BNPluginIsUpdateAvailable.argtypes = [
		ctypes.POINTER(BNRepoPlugin),
	]


# noinspection PyPep8Naming
def BNPluginIsUpdateAvailable(
		p: ctypes.POINTER(BNRepoPlugin)
		) -> bool:
	return _BNPluginIsUpdateAvailable(p)


# -------------------------------------------------------
# _BNPluginIsUpdatePending

_BNPluginIsUpdatePending = core.BNPluginIsUpdatePending
_BNPluginIsUpdatePending.restype = ctypes.c_bool
_BNPluginIsUpdatePending.argtypes = [
		ctypes.POINTER(BNRepoPlugin),
	]


# noinspection PyPep8Naming
def BNPluginIsUpdatePending(
		p: ctypes.POINTER(BNRepoPlugin)
		) -> bool:
	return _BNPluginIsUpdatePending(p)


# -------------------------------------------------------
# _BNPluginUninstall

_BNPluginUninstall = core.BNPluginUninstall
_BNPluginUninstall.restype = ctypes.c_bool
_BNPluginUninstall.argtypes = [
		ctypes.POINTER(BNRepoPlugin),
	]


# noinspection PyPep8Naming
def BNPluginUninstall(
		p: ctypes.POINTER(BNRepoPlugin)
		) -> bool:
	return _BNPluginUninstall(p)


# -------------------------------------------------------
# _BNPluginUpdate

_BNPluginUpdate = core.BNPluginUpdate
_BNPluginUpdate.restype = ctypes.c_bool
_BNPluginUpdate.argtypes = [
		ctypes.POINTER(BNRepoPlugin),
	]


# noinspection PyPep8Naming
def BNPluginUpdate(
		p: ctypes.POINTER(BNRepoPlugin)
		) -> bool:
	return _BNPluginUpdate(p)


# -------------------------------------------------------
# _BNPostProcessDisassemblyTextRendererLines

_BNPostProcessDisassemblyTextRendererLines = core.BNPostProcessDisassemblyTextRendererLines
_BNPostProcessDisassemblyTextRendererLines.restype = ctypes.POINTER(BNDisassemblyTextLine)
_BNPostProcessDisassemblyTextRendererLines.argtypes = [
		ctypes.POINTER(BNDisassemblyTextRenderer),
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
		ctypes.POINTER(BNDisassemblyTextLine),
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNPostProcessDisassemblyTextRendererLines(
		renderer: ctypes.POINTER(BNDisassemblyTextRenderer), 
		addr: int, 
		len: int, 
		inLines: ctypes.POINTER(BNDisassemblyTextLine), 
		inCount: int, 
		outCount: ctypes.POINTER(ctypes.c_ulonglong), 
		indentSpaces: Optional[str]
		) -> Optional[ctypes.POINTER(BNDisassemblyTextLine)]:
	result = _BNPostProcessDisassemblyTextRendererLines(renderer, addr, len, inLines, inCount, outCount, cstr(indentSpaces))
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNPostWorkflowRequestForFunction

_BNPostWorkflowRequestForFunction = core.BNPostWorkflowRequestForFunction
_BNPostWorkflowRequestForFunction.restype = ctypes.POINTER(ctypes.c_byte)
_BNPostWorkflowRequestForFunction.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNPostWorkflowRequestForFunction(
		func: ctypes.POINTER(BNFunction), 
		request: Optional[str]
		) -> Optional[Optional[str]]:
	result = _BNPostWorkflowRequestForFunction(func, cstr(request))
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNPrepareToCopyLowLevelILBasicBlock

_BNPrepareToCopyLowLevelILBasicBlock = core.BNPrepareToCopyLowLevelILBasicBlock
_BNPrepareToCopyLowLevelILBasicBlock.restype = None
_BNPrepareToCopyLowLevelILBasicBlock.argtypes = [
		ctypes.POINTER(BNLowLevelILFunction),
		ctypes.POINTER(BNBasicBlock),
	]


# noinspection PyPep8Naming
def BNPrepareToCopyLowLevelILBasicBlock(
		func: ctypes.POINTER(BNLowLevelILFunction), 
		block: ctypes.POINTER(BNBasicBlock)
		) -> None:
	return _BNPrepareToCopyLowLevelILBasicBlock(func, block)


# -------------------------------------------------------
# _BNPrepareToCopyLowLevelILFunction

_BNPrepareToCopyLowLevelILFunction = core.BNPrepareToCopyLowLevelILFunction
_BNPrepareToCopyLowLevelILFunction.restype = None
_BNPrepareToCopyLowLevelILFunction.argtypes = [
		ctypes.POINTER(BNLowLevelILFunction),
		ctypes.POINTER(BNLowLevelILFunction),
	]


# noinspection PyPep8Naming
def BNPrepareToCopyLowLevelILFunction(
		func: ctypes.POINTER(BNLowLevelILFunction), 
		src: ctypes.POINTER(BNLowLevelILFunction)
		) -> None:
	return _BNPrepareToCopyLowLevelILFunction(func, src)


# -------------------------------------------------------
# _BNPrepareToCopyMediumLevelILBasicBlock

_BNPrepareToCopyMediumLevelILBasicBlock = core.BNPrepareToCopyMediumLevelILBasicBlock
_BNPrepareToCopyMediumLevelILBasicBlock.restype = None
_BNPrepareToCopyMediumLevelILBasicBlock.argtypes = [
		ctypes.POINTER(BNMediumLevelILFunction),
		ctypes.POINTER(BNBasicBlock),
	]


# noinspection PyPep8Naming
def BNPrepareToCopyMediumLevelILBasicBlock(
		func: ctypes.POINTER(BNMediumLevelILFunction), 
		block: ctypes.POINTER(BNBasicBlock)
		) -> None:
	return _BNPrepareToCopyMediumLevelILBasicBlock(func, block)


# -------------------------------------------------------
# _BNPrepareToCopyMediumLevelILFunction

_BNPrepareToCopyMediumLevelILFunction = core.BNPrepareToCopyMediumLevelILFunction
_BNPrepareToCopyMediumLevelILFunction.restype = None
_BNPrepareToCopyMediumLevelILFunction.argtypes = [
		ctypes.POINTER(BNMediumLevelILFunction),
		ctypes.POINTER(BNMediumLevelILFunction),
	]


# noinspection PyPep8Naming
def BNPrepareToCopyMediumLevelILFunction(
		func: ctypes.POINTER(BNMediumLevelILFunction), 
		src: ctypes.POINTER(BNMediumLevelILFunction)
		) -> None:
	return _BNPrepareToCopyMediumLevelILFunction(func, src)


# -------------------------------------------------------
# _BNPreprocessSource

_BNPreprocessSource = core.BNPreprocessSource
_BNPreprocessSource.restype = ctypes.c_bool
_BNPreprocessSource.argtypes = [
		ctypes.c_char_p,
		ctypes.c_char_p,
		ctypes.POINTER(ctypes.c_char_p),
		ctypes.POINTER(ctypes.c_char_p),
		ctypes.POINTER(ctypes.c_char_p),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNPreprocessSource(
		source: Optional[str], 
		fileName: Optional[str], 
		output: ctypes.POINTER(ctypes.c_char_p), 
		errors: ctypes.POINTER(ctypes.c_char_p), 
		includeDirs: ctypes.POINTER(ctypes.c_char_p), 
		includeDirCount: int
		) -> bool:
	return _BNPreprocessSource(cstr(source), cstr(fileName), output, errors, includeDirs, includeDirCount)


# -------------------------------------------------------
# _BNProcessSymbolQueue

_BNProcessSymbolQueue = core.BNProcessSymbolQueue
_BNProcessSymbolQueue.restype = None
_BNProcessSymbolQueue.argtypes = [
		ctypes.POINTER(BNSymbolQueue),
	]


# noinspection PyPep8Naming
def BNProcessSymbolQueue(
		queue: ctypes.POINTER(BNSymbolQueue)
		) -> None:
	return _BNProcessSymbolQueue(queue)


# -------------------------------------------------------
# _BNProjectBeginBulkOperation

_BNProjectBeginBulkOperation = core.BNProjectBeginBulkOperation
_BNProjectBeginBulkOperation.restype = None
_BNProjectBeginBulkOperation.argtypes = [
		ctypes.POINTER(BNProject),
	]


# noinspection PyPep8Naming
def BNProjectBeginBulkOperation(
		project: ctypes.POINTER(BNProject)
		) -> None:
	return _BNProjectBeginBulkOperation(project)


# -------------------------------------------------------
# _BNProjectClose

_BNProjectClose = core.BNProjectClose
_BNProjectClose.restype = ctypes.c_bool
_BNProjectClose.argtypes = [
		ctypes.POINTER(BNProject),
	]


# noinspection PyPep8Naming
def BNProjectClose(
		project: ctypes.POINTER(BNProject)
		) -> bool:
	return _BNProjectClose(project)


# -------------------------------------------------------
# _BNProjectCreateFile

_BNProjectCreateFile = core.BNProjectCreateFile
_BNProjectCreateFile.restype = ctypes.POINTER(BNProjectFile)
_BNProjectCreateFile.argtypes = [
		ctypes.POINTER(BNProject),
		ctypes.POINTER(ctypes.c_ubyte),
		ctypes.c_ulonglong,
		ctypes.POINTER(BNProjectFolder),
		ctypes.c_char_p,
		ctypes.c_char_p,
		ctypes.c_void_p,
		ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNProjectCreateFile(
		project: ctypes.POINTER(BNProject), 
		contents: ctypes.POINTER(ctypes.c_ubyte), 
		contentsSize: int, 
		folder: ctypes.POINTER(BNProjectFolder), 
		name: Optional[str], 
		description: Optional[str], 
		ctxt: Optional[ctypes.c_void_p], 
		progress: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNProjectFile)]:
	result = _BNProjectCreateFile(project, contents, contentsSize, folder, cstr(name), cstr(description), ctxt, progress)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNProjectCreateFileFromPath

_BNProjectCreateFileFromPath = core.BNProjectCreateFileFromPath
_BNProjectCreateFileFromPath.restype = ctypes.POINTER(BNProjectFile)
_BNProjectCreateFileFromPath.argtypes = [
		ctypes.POINTER(BNProject),
		ctypes.c_char_p,
		ctypes.POINTER(BNProjectFolder),
		ctypes.c_char_p,
		ctypes.c_char_p,
		ctypes.c_void_p,
		ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNProjectCreateFileFromPath(
		project: ctypes.POINTER(BNProject), 
		path: Optional[str], 
		folder: ctypes.POINTER(BNProjectFolder), 
		name: Optional[str], 
		description: Optional[str], 
		ctxt: Optional[ctypes.c_void_p], 
		progress: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNProjectFile)]:
	result = _BNProjectCreateFileFromPath(project, cstr(path), folder, cstr(name), cstr(description), ctxt, progress)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNProjectCreateFileFromPathUnsafe

_BNProjectCreateFileFromPathUnsafe = core.BNProjectCreateFileFromPathUnsafe
_BNProjectCreateFileFromPathUnsafe.restype = ctypes.POINTER(BNProjectFile)
_BNProjectCreateFileFromPathUnsafe.argtypes = [
		ctypes.POINTER(BNProject),
		ctypes.c_char_p,
		ctypes.POINTER(BNProjectFolder),
		ctypes.c_char_p,
		ctypes.c_char_p,
		ctypes.c_char_p,
		ctypes.c_longlong,
		ctypes.c_void_p,
		ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNProjectCreateFileFromPathUnsafe(
		project: ctypes.POINTER(BNProject), 
		path: Optional[str], 
		folder: ctypes.POINTER(BNProjectFolder), 
		name: Optional[str], 
		description: Optional[str], 
		id: Optional[str], 
		creationTimestamp: int, 
		ctxt: Optional[ctypes.c_void_p], 
		progress: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNProjectFile)]:
	result = _BNProjectCreateFileFromPathUnsafe(project, cstr(path), folder, cstr(name), cstr(description), cstr(id), creationTimestamp, ctxt, progress)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNProjectCreateFileUnsafe

_BNProjectCreateFileUnsafe = core.BNProjectCreateFileUnsafe
_BNProjectCreateFileUnsafe.restype = ctypes.POINTER(BNProjectFile)
_BNProjectCreateFileUnsafe.argtypes = [
		ctypes.POINTER(BNProject),
		ctypes.POINTER(ctypes.c_ubyte),
		ctypes.c_ulonglong,
		ctypes.POINTER(BNProjectFolder),
		ctypes.c_char_p,
		ctypes.c_char_p,
		ctypes.c_char_p,
		ctypes.c_longlong,
		ctypes.c_void_p,
		ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNProjectCreateFileUnsafe(
		project: ctypes.POINTER(BNProject), 
		contents: ctypes.POINTER(ctypes.c_ubyte), 
		contentsSize: int, 
		folder: ctypes.POINTER(BNProjectFolder), 
		name: Optional[str], 
		description: Optional[str], 
		id: Optional[str], 
		creationTimestamp: int, 
		ctxt: Optional[ctypes.c_void_p], 
		progress: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNProjectFile)]:
	result = _BNProjectCreateFileUnsafe(project, contents, contentsSize, folder, cstr(name), cstr(description), cstr(id), creationTimestamp, ctxt, progress)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNProjectCreateFolder

_BNProjectCreateFolder = core.BNProjectCreateFolder
_BNProjectCreateFolder.restype = ctypes.POINTER(BNProjectFolder)
_BNProjectCreateFolder.argtypes = [
		ctypes.POINTER(BNProject),
		ctypes.POINTER(BNProjectFolder),
		ctypes.c_char_p,
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNProjectCreateFolder(
		project: ctypes.POINTER(BNProject), 
		parent: ctypes.POINTER(BNProjectFolder), 
		name: Optional[str], 
		description: Optional[str]
		) -> Optional[ctypes.POINTER(BNProjectFolder)]:
	result = _BNProjectCreateFolder(project, parent, cstr(name), cstr(description))
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNProjectCreateFolderFromPath

_BNProjectCreateFolderFromPath = core.BNProjectCreateFolderFromPath
_BNProjectCreateFolderFromPath.restype = ctypes.POINTER(BNProjectFolder)
_BNProjectCreateFolderFromPath.argtypes = [
		ctypes.POINTER(BNProject),
		ctypes.c_char_p,
		ctypes.POINTER(BNProjectFolder),
		ctypes.c_char_p,
		ctypes.c_void_p,
		ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNProjectCreateFolderFromPath(
		project: ctypes.POINTER(BNProject), 
		path: Optional[str], 
		parent: ctypes.POINTER(BNProjectFolder), 
		description: Optional[str], 
		ctxt: Optional[ctypes.c_void_p], 
		progress: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNProjectFolder)]:
	result = _BNProjectCreateFolderFromPath(project, cstr(path), parent, cstr(description), ctxt, progress)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNProjectCreateFolderUnsafe

_BNProjectCreateFolderUnsafe = core.BNProjectCreateFolderUnsafe
_BNProjectCreateFolderUnsafe.restype = ctypes.POINTER(BNProjectFolder)
_BNProjectCreateFolderUnsafe.argtypes = [
		ctypes.POINTER(BNProject),
		ctypes.POINTER(BNProjectFolder),
		ctypes.c_char_p,
		ctypes.c_char_p,
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNProjectCreateFolderUnsafe(
		project: ctypes.POINTER(BNProject), 
		parent: ctypes.POINTER(BNProjectFolder), 
		name: Optional[str], 
		description: Optional[str], 
		id: Optional[str]
		) -> Optional[ctypes.POINTER(BNProjectFolder)]:
	result = _BNProjectCreateFolderUnsafe(project, parent, cstr(name), cstr(description), cstr(id))
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNProjectDeleteFile

_BNProjectDeleteFile = core.BNProjectDeleteFile
_BNProjectDeleteFile.restype = ctypes.c_bool
_BNProjectDeleteFile.argtypes = [
		ctypes.POINTER(BNProject),
		ctypes.POINTER(BNProjectFile),
	]


# noinspection PyPep8Naming
def BNProjectDeleteFile(
		project: ctypes.POINTER(BNProject), 
		file: ctypes.POINTER(BNProjectFile)
		) -> bool:
	return _BNProjectDeleteFile(project, file)


# -------------------------------------------------------
# _BNProjectDeleteFolder

_BNProjectDeleteFolder = core.BNProjectDeleteFolder
_BNProjectDeleteFolder.restype = ctypes.c_bool
_BNProjectDeleteFolder.argtypes = [
		ctypes.POINTER(BNProject),
		ctypes.POINTER(BNProjectFolder),
		ctypes.c_void_p,
		ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNProjectDeleteFolder(
		project: ctypes.POINTER(BNProject), 
		folder: ctypes.POINTER(BNProjectFolder), 
		ctxt: Optional[ctypes.c_void_p], 
		progress: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong)
		) -> bool:
	return _BNProjectDeleteFolder(project, folder, ctxt, progress)


# -------------------------------------------------------
# _BNProjectEndBulkOperation

_BNProjectEndBulkOperation = core.BNProjectEndBulkOperation
_BNProjectEndBulkOperation.restype = None
_BNProjectEndBulkOperation.argtypes = [
		ctypes.POINTER(BNProject),
	]


# noinspection PyPep8Naming
def BNProjectEndBulkOperation(
		project: ctypes.POINTER(BNProject)
		) -> None:
	return _BNProjectEndBulkOperation(project)


# -------------------------------------------------------
# _BNProjectFileExistsOnDisk

_BNProjectFileExistsOnDisk = core.BNProjectFileExistsOnDisk
_BNProjectFileExistsOnDisk.restype = ctypes.c_bool
_BNProjectFileExistsOnDisk.argtypes = [
		ctypes.POINTER(BNProjectFile),
	]


# noinspection PyPep8Naming
def BNProjectFileExistsOnDisk(
		file: ctypes.POINTER(BNProjectFile)
		) -> bool:
	return _BNProjectFileExistsOnDisk(file)


# -------------------------------------------------------
# _BNProjectFileExport

_BNProjectFileExport = core.BNProjectFileExport
_BNProjectFileExport.restype = ctypes.c_bool
_BNProjectFileExport.argtypes = [
		ctypes.POINTER(BNProjectFile),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNProjectFileExport(
		file: ctypes.POINTER(BNProjectFile), 
		destination: Optional[str]
		) -> bool:
	return _BNProjectFileExport(file, cstr(destination))


# -------------------------------------------------------
# _BNProjectFileGetCreationTimestamp

_BNProjectFileGetCreationTimestamp = core.BNProjectFileGetCreationTimestamp
_BNProjectFileGetCreationTimestamp.restype = ctypes.c_longlong
_BNProjectFileGetCreationTimestamp.argtypes = [
		ctypes.POINTER(BNProjectFile),
	]


# noinspection PyPep8Naming
def BNProjectFileGetCreationTimestamp(
		file: ctypes.POINTER(BNProjectFile)
		) -> int:
	return _BNProjectFileGetCreationTimestamp(file)


# -------------------------------------------------------
# _BNProjectFileGetDescription

_BNProjectFileGetDescription = core.BNProjectFileGetDescription
_BNProjectFileGetDescription.restype = ctypes.POINTER(ctypes.c_byte)
_BNProjectFileGetDescription.argtypes = [
		ctypes.POINTER(BNProjectFile),
	]


# noinspection PyPep8Naming
def BNProjectFileGetDescription(
		file: ctypes.POINTER(BNProjectFile)
		) -> Optional[Optional[str]]:
	result = _BNProjectFileGetDescription(file)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNProjectFileGetFolder

_BNProjectFileGetFolder = core.BNProjectFileGetFolder
_BNProjectFileGetFolder.restype = ctypes.POINTER(BNProjectFolder)
_BNProjectFileGetFolder.argtypes = [
		ctypes.POINTER(BNProjectFile),
	]


# noinspection PyPep8Naming
def BNProjectFileGetFolder(
		file: ctypes.POINTER(BNProjectFile)
		) -> Optional[ctypes.POINTER(BNProjectFolder)]:
	result = _BNProjectFileGetFolder(file)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNProjectFileGetId

_BNProjectFileGetId = core.BNProjectFileGetId
_BNProjectFileGetId.restype = ctypes.POINTER(ctypes.c_byte)
_BNProjectFileGetId.argtypes = [
		ctypes.POINTER(BNProjectFile),
	]


# noinspection PyPep8Naming
def BNProjectFileGetId(
		file: ctypes.POINTER(BNProjectFile)
		) -> Optional[Optional[str]]:
	result = _BNProjectFileGetId(file)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNProjectFileGetName

_BNProjectFileGetName = core.BNProjectFileGetName
_BNProjectFileGetName.restype = ctypes.POINTER(ctypes.c_byte)
_BNProjectFileGetName.argtypes = [
		ctypes.POINTER(BNProjectFile),
	]


# noinspection PyPep8Naming
def BNProjectFileGetName(
		file: ctypes.POINTER(BNProjectFile)
		) -> Optional[Optional[str]]:
	result = _BNProjectFileGetName(file)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNProjectFileGetPathOnDisk

_BNProjectFileGetPathOnDisk = core.BNProjectFileGetPathOnDisk
_BNProjectFileGetPathOnDisk.restype = ctypes.POINTER(ctypes.c_byte)
_BNProjectFileGetPathOnDisk.argtypes = [
		ctypes.POINTER(BNProjectFile),
	]


# noinspection PyPep8Naming
def BNProjectFileGetPathOnDisk(
		file: ctypes.POINTER(BNProjectFile)
		) -> Optional[Optional[str]]:
	result = _BNProjectFileGetPathOnDisk(file)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNProjectFileGetProject

_BNProjectFileGetProject = core.BNProjectFileGetProject
_BNProjectFileGetProject.restype = ctypes.POINTER(BNProject)
_BNProjectFileGetProject.argtypes = [
		ctypes.POINTER(BNProjectFile),
	]


# noinspection PyPep8Naming
def BNProjectFileGetProject(
		file: ctypes.POINTER(BNProjectFile)
		) -> Optional[ctypes.POINTER(BNProject)]:
	result = _BNProjectFileGetProject(file)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNProjectFileSetDescription

_BNProjectFileSetDescription = core.BNProjectFileSetDescription
_BNProjectFileSetDescription.restype = None
_BNProjectFileSetDescription.argtypes = [
		ctypes.POINTER(BNProjectFile),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNProjectFileSetDescription(
		file: ctypes.POINTER(BNProjectFile), 
		description: Optional[str]
		) -> None:
	return _BNProjectFileSetDescription(file, cstr(description))


# -------------------------------------------------------
# _BNProjectFileSetFolder

_BNProjectFileSetFolder = core.BNProjectFileSetFolder
_BNProjectFileSetFolder.restype = None
_BNProjectFileSetFolder.argtypes = [
		ctypes.POINTER(BNProjectFile),
		ctypes.POINTER(BNProjectFolder),
	]


# noinspection PyPep8Naming
def BNProjectFileSetFolder(
		file: ctypes.POINTER(BNProjectFile), 
		folder: ctypes.POINTER(BNProjectFolder)
		) -> None:
	return _BNProjectFileSetFolder(file, folder)


# -------------------------------------------------------
# _BNProjectFileSetName

_BNProjectFileSetName = core.BNProjectFileSetName
_BNProjectFileSetName.restype = None
_BNProjectFileSetName.argtypes = [
		ctypes.POINTER(BNProjectFile),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNProjectFileSetName(
		file: ctypes.POINTER(BNProjectFile), 
		name: Optional[str]
		) -> None:
	return _BNProjectFileSetName(file, cstr(name))


# -------------------------------------------------------
# _BNProjectFolderExport

_BNProjectFolderExport = core.BNProjectFolderExport
_BNProjectFolderExport.restype = ctypes.c_bool
_BNProjectFolderExport.argtypes = [
		ctypes.POINTER(BNProjectFolder),
		ctypes.c_char_p,
		ctypes.c_void_p,
		ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNProjectFolderExport(
		folder: ctypes.POINTER(BNProjectFolder), 
		destination: Optional[str], 
		ctxt: Optional[ctypes.c_void_p], 
		progress: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong)
		) -> bool:
	return _BNProjectFolderExport(folder, cstr(destination), ctxt, progress)


# -------------------------------------------------------
# _BNProjectFolderGetDescription

_BNProjectFolderGetDescription = core.BNProjectFolderGetDescription
_BNProjectFolderGetDescription.restype = ctypes.POINTER(ctypes.c_byte)
_BNProjectFolderGetDescription.argtypes = [
		ctypes.POINTER(BNProjectFolder),
	]


# noinspection PyPep8Naming
def BNProjectFolderGetDescription(
		folder: ctypes.POINTER(BNProjectFolder)
		) -> Optional[Optional[str]]:
	result = _BNProjectFolderGetDescription(folder)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNProjectFolderGetId

_BNProjectFolderGetId = core.BNProjectFolderGetId
_BNProjectFolderGetId.restype = ctypes.POINTER(ctypes.c_byte)
_BNProjectFolderGetId.argtypes = [
		ctypes.POINTER(BNProjectFolder),
	]


# noinspection PyPep8Naming
def BNProjectFolderGetId(
		folder: ctypes.POINTER(BNProjectFolder)
		) -> Optional[Optional[str]]:
	result = _BNProjectFolderGetId(folder)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNProjectFolderGetName

_BNProjectFolderGetName = core.BNProjectFolderGetName
_BNProjectFolderGetName.restype = ctypes.POINTER(ctypes.c_byte)
_BNProjectFolderGetName.argtypes = [
		ctypes.POINTER(BNProjectFolder),
	]


# noinspection PyPep8Naming
def BNProjectFolderGetName(
		folder: ctypes.POINTER(BNProjectFolder)
		) -> Optional[Optional[str]]:
	result = _BNProjectFolderGetName(folder)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNProjectFolderGetParent

_BNProjectFolderGetParent = core.BNProjectFolderGetParent
_BNProjectFolderGetParent.restype = ctypes.POINTER(BNProjectFolder)
_BNProjectFolderGetParent.argtypes = [
		ctypes.POINTER(BNProjectFolder),
	]


# noinspection PyPep8Naming
def BNProjectFolderGetParent(
		folder: ctypes.POINTER(BNProjectFolder)
		) -> Optional[ctypes.POINTER(BNProjectFolder)]:
	result = _BNProjectFolderGetParent(folder)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNProjectFolderGetProject

_BNProjectFolderGetProject = core.BNProjectFolderGetProject
_BNProjectFolderGetProject.restype = ctypes.POINTER(BNProject)
_BNProjectFolderGetProject.argtypes = [
		ctypes.POINTER(BNProjectFolder),
	]


# noinspection PyPep8Naming
def BNProjectFolderGetProject(
		folder: ctypes.POINTER(BNProjectFolder)
		) -> Optional[ctypes.POINTER(BNProject)]:
	result = _BNProjectFolderGetProject(folder)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNProjectFolderSetDescription

_BNProjectFolderSetDescription = core.BNProjectFolderSetDescription
_BNProjectFolderSetDescription.restype = None
_BNProjectFolderSetDescription.argtypes = [
		ctypes.POINTER(BNProjectFolder),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNProjectFolderSetDescription(
		folder: ctypes.POINTER(BNProjectFolder), 
		description: Optional[str]
		) -> None:
	return _BNProjectFolderSetDescription(folder, cstr(description))


# -------------------------------------------------------
# _BNProjectFolderSetName

_BNProjectFolderSetName = core.BNProjectFolderSetName
_BNProjectFolderSetName.restype = None
_BNProjectFolderSetName.argtypes = [
		ctypes.POINTER(BNProjectFolder),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNProjectFolderSetName(
		folder: ctypes.POINTER(BNProjectFolder), 
		name: Optional[str]
		) -> None:
	return _BNProjectFolderSetName(folder, cstr(name))


# -------------------------------------------------------
# _BNProjectFolderSetParent

_BNProjectFolderSetParent = core.BNProjectFolderSetParent
_BNProjectFolderSetParent.restype = None
_BNProjectFolderSetParent.argtypes = [
		ctypes.POINTER(BNProjectFolder),
		ctypes.POINTER(BNProjectFolder),
	]


# noinspection PyPep8Naming
def BNProjectFolderSetParent(
		folder: ctypes.POINTER(BNProjectFolder), 
		parent: ctypes.POINTER(BNProjectFolder)
		) -> None:
	return _BNProjectFolderSetParent(folder, parent)


# -------------------------------------------------------
# _BNProjectGetDescription

_BNProjectGetDescription = core.BNProjectGetDescription
_BNProjectGetDescription.restype = ctypes.POINTER(ctypes.c_byte)
_BNProjectGetDescription.argtypes = [
		ctypes.POINTER(BNProject),
	]


# noinspection PyPep8Naming
def BNProjectGetDescription(
		project: ctypes.POINTER(BNProject)
		) -> Optional[Optional[str]]:
	result = _BNProjectGetDescription(project)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNProjectGetFileById

_BNProjectGetFileById = core.BNProjectGetFileById
_BNProjectGetFileById.restype = ctypes.POINTER(BNProjectFile)
_BNProjectGetFileById.argtypes = [
		ctypes.POINTER(BNProject),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNProjectGetFileById(
		project: ctypes.POINTER(BNProject), 
		id: Optional[str]
		) -> Optional[ctypes.POINTER(BNProjectFile)]:
	result = _BNProjectGetFileById(project, cstr(id))
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNProjectGetFileByPathOnDisk

_BNProjectGetFileByPathOnDisk = core.BNProjectGetFileByPathOnDisk
_BNProjectGetFileByPathOnDisk.restype = ctypes.POINTER(BNProjectFile)
_BNProjectGetFileByPathOnDisk.argtypes = [
		ctypes.POINTER(BNProject),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNProjectGetFileByPathOnDisk(
		project: ctypes.POINTER(BNProject), 
		path: Optional[str]
		) -> Optional[ctypes.POINTER(BNProjectFile)]:
	result = _BNProjectGetFileByPathOnDisk(project, cstr(path))
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNProjectGetFiles

_BNProjectGetFiles = core.BNProjectGetFiles
_BNProjectGetFiles.restype = ctypes.POINTER(ctypes.POINTER(BNProjectFile))
_BNProjectGetFiles.argtypes = [
		ctypes.POINTER(BNProject),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNProjectGetFiles(
		project: ctypes.POINTER(BNProject), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.POINTER(BNProjectFile))]:
	result = _BNProjectGetFiles(project, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNProjectGetFolderById

_BNProjectGetFolderById = core.BNProjectGetFolderById
_BNProjectGetFolderById.restype = ctypes.POINTER(BNProjectFolder)
_BNProjectGetFolderById.argtypes = [
		ctypes.POINTER(BNProject),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNProjectGetFolderById(
		project: ctypes.POINTER(BNProject), 
		id: Optional[str]
		) -> Optional[ctypes.POINTER(BNProjectFolder)]:
	result = _BNProjectGetFolderById(project, cstr(id))
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNProjectGetFolders

_BNProjectGetFolders = core.BNProjectGetFolders
_BNProjectGetFolders.restype = ctypes.POINTER(ctypes.POINTER(BNProjectFolder))
_BNProjectGetFolders.argtypes = [
		ctypes.POINTER(BNProject),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNProjectGetFolders(
		project: ctypes.POINTER(BNProject), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.POINTER(BNProjectFolder))]:
	result = _BNProjectGetFolders(project, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNProjectGetId

_BNProjectGetId = core.BNProjectGetId
_BNProjectGetId.restype = ctypes.POINTER(ctypes.c_byte)
_BNProjectGetId.argtypes = [
		ctypes.POINTER(BNProject),
	]


# noinspection PyPep8Naming
def BNProjectGetId(
		project: ctypes.POINTER(BNProject)
		) -> Optional[Optional[str]]:
	result = _BNProjectGetId(project)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNProjectGetName

_BNProjectGetName = core.BNProjectGetName
_BNProjectGetName.restype = ctypes.POINTER(ctypes.c_byte)
_BNProjectGetName.argtypes = [
		ctypes.POINTER(BNProject),
	]


# noinspection PyPep8Naming
def BNProjectGetName(
		project: ctypes.POINTER(BNProject)
		) -> Optional[Optional[str]]:
	result = _BNProjectGetName(project)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNProjectGetPath

_BNProjectGetPath = core.BNProjectGetPath
_BNProjectGetPath.restype = ctypes.POINTER(ctypes.c_byte)
_BNProjectGetPath.argtypes = [
		ctypes.POINTER(BNProject),
	]


# noinspection PyPep8Naming
def BNProjectGetPath(
		project: ctypes.POINTER(BNProject)
		) -> Optional[Optional[str]]:
	result = _BNProjectGetPath(project)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNProjectIsOpen

_BNProjectIsOpen = core.BNProjectIsOpen
_BNProjectIsOpen.restype = ctypes.c_bool
_BNProjectIsOpen.argtypes = [
		ctypes.POINTER(BNProject),
	]


# noinspection PyPep8Naming
def BNProjectIsOpen(
		project: ctypes.POINTER(BNProject)
		) -> bool:
	return _BNProjectIsOpen(project)


# -------------------------------------------------------
# _BNProjectOpen

_BNProjectOpen = core.BNProjectOpen
_BNProjectOpen.restype = ctypes.c_bool
_BNProjectOpen.argtypes = [
		ctypes.POINTER(BNProject),
	]


# noinspection PyPep8Naming
def BNProjectOpen(
		project: ctypes.POINTER(BNProject)
		) -> bool:
	return _BNProjectOpen(project)


# -------------------------------------------------------
# _BNProjectPushFile

_BNProjectPushFile = core.BNProjectPushFile
_BNProjectPushFile.restype = None
_BNProjectPushFile.argtypes = [
		ctypes.POINTER(BNProject),
		ctypes.POINTER(BNProjectFile),
	]


# noinspection PyPep8Naming
def BNProjectPushFile(
		project: ctypes.POINTER(BNProject), 
		file: ctypes.POINTER(BNProjectFile)
		) -> None:
	return _BNProjectPushFile(project, file)


# -------------------------------------------------------
# _BNProjectPushFolder

_BNProjectPushFolder = core.BNProjectPushFolder
_BNProjectPushFolder.restype = None
_BNProjectPushFolder.argtypes = [
		ctypes.POINTER(BNProject),
		ctypes.POINTER(BNProjectFolder),
	]


# noinspection PyPep8Naming
def BNProjectPushFolder(
		project: ctypes.POINTER(BNProject), 
		folder: ctypes.POINTER(BNProjectFolder)
		) -> None:
	return _BNProjectPushFolder(project, folder)


# -------------------------------------------------------
# _BNProjectQueryMetadata

_BNProjectQueryMetadata = core.BNProjectQueryMetadata
_BNProjectQueryMetadata.restype = ctypes.POINTER(BNMetadata)
_BNProjectQueryMetadata.argtypes = [
		ctypes.POINTER(BNProject),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNProjectQueryMetadata(
		project: ctypes.POINTER(BNProject), 
		key: Optional[str]
		) -> Optional[ctypes.POINTER(BNMetadata)]:
	result = _BNProjectQueryMetadata(project, cstr(key))
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNProjectRemoveMetadata

_BNProjectRemoveMetadata = core.BNProjectRemoveMetadata
_BNProjectRemoveMetadata.restype = None
_BNProjectRemoveMetadata.argtypes = [
		ctypes.POINTER(BNProject),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNProjectRemoveMetadata(
		project: ctypes.POINTER(BNProject), 
		key: Optional[str]
		) -> None:
	return _BNProjectRemoveMetadata(project, cstr(key))


# -------------------------------------------------------
# _BNProjectSetDescription

_BNProjectSetDescription = core.BNProjectSetDescription
_BNProjectSetDescription.restype = None
_BNProjectSetDescription.argtypes = [
		ctypes.POINTER(BNProject),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNProjectSetDescription(
		project: ctypes.POINTER(BNProject), 
		description: Optional[str]
		) -> None:
	return _BNProjectSetDescription(project, cstr(description))


# -------------------------------------------------------
# _BNProjectSetName

_BNProjectSetName = core.BNProjectSetName
_BNProjectSetName.restype = None
_BNProjectSetName.argtypes = [
		ctypes.POINTER(BNProject),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNProjectSetName(
		project: ctypes.POINTER(BNProject), 
		name: Optional[str]
		) -> None:
	return _BNProjectSetName(project, cstr(name))


# -------------------------------------------------------
# _BNProjectStoreMetadata

_BNProjectStoreMetadata = core.BNProjectStoreMetadata
_BNProjectStoreMetadata.restype = ctypes.c_bool
_BNProjectStoreMetadata.argtypes = [
		ctypes.POINTER(BNProject),
		ctypes.c_char_p,
		ctypes.POINTER(BNMetadata),
	]


# noinspection PyPep8Naming
def BNProjectStoreMetadata(
		project: ctypes.POINTER(BNProject), 
		key: Optional[str], 
		value: ctypes.POINTER(BNMetadata)
		) -> bool:
	return _BNProjectStoreMetadata(project, cstr(key), value)


# -------------------------------------------------------
# _BNRangeContainsRelocation

_BNRangeContainsRelocation = core.BNRangeContainsRelocation
_BNRangeContainsRelocation.restype = ctypes.c_bool
_BNRangeContainsRelocation.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNRangeContainsRelocation(
		view: ctypes.POINTER(BNBinaryView), 
		addr: int, 
		size: int
		) -> bool:
	return _BNRangeContainsRelocation(view, addr, size)


# -------------------------------------------------------
# _BNRead16

_BNRead16 = core.BNRead16
_BNRead16.restype = ctypes.c_bool
_BNRead16.argtypes = [
		ctypes.POINTER(BNBinaryReader),
		ctypes.POINTER(ctypes.c_ushort),
	]


# noinspection PyPep8Naming
def BNRead16(
		stream: ctypes.POINTER(BNBinaryReader), 
		result: ctypes.POINTER(ctypes.c_ushort)
		) -> bool:
	return _BNRead16(stream, result)


# -------------------------------------------------------
# _BNRead32

_BNRead32 = core.BNRead32
_BNRead32.restype = ctypes.c_bool
_BNRead32.argtypes = [
		ctypes.POINTER(BNBinaryReader),
		ctypes.POINTER(ctypes.c_uint),
	]


# noinspection PyPep8Naming
def BNRead32(
		stream: ctypes.POINTER(BNBinaryReader), 
		result: ctypes.POINTER(ctypes.c_uint)
		) -> bool:
	return _BNRead32(stream, result)


# -------------------------------------------------------
# _BNRead64

_BNRead64 = core.BNRead64
_BNRead64.restype = ctypes.c_bool
_BNRead64.argtypes = [
		ctypes.POINTER(BNBinaryReader),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNRead64(
		stream: ctypes.POINTER(BNBinaryReader), 
		result: ctypes.POINTER(ctypes.c_ulonglong)
		) -> bool:
	return _BNRead64(stream, result)


# -------------------------------------------------------
# _BNRead8

_BNRead8 = core.BNRead8
_BNRead8.restype = ctypes.c_bool
_BNRead8.argtypes = [
		ctypes.POINTER(BNBinaryReader),
		ctypes.POINTER(ctypes.c_ubyte),
	]


# noinspection PyPep8Naming
def BNRead8(
		stream: ctypes.POINTER(BNBinaryReader), 
		result: ctypes.POINTER(ctypes.c_ubyte)
		) -> bool:
	return _BNRead8(stream, result)


# -------------------------------------------------------
# _BNReadBE16

_BNReadBE16 = core.BNReadBE16
_BNReadBE16.restype = ctypes.c_bool
_BNReadBE16.argtypes = [
		ctypes.POINTER(BNBinaryReader),
		ctypes.POINTER(ctypes.c_ushort),
	]


# noinspection PyPep8Naming
def BNReadBE16(
		stream: ctypes.POINTER(BNBinaryReader), 
		result: ctypes.POINTER(ctypes.c_ushort)
		) -> bool:
	return _BNReadBE16(stream, result)


# -------------------------------------------------------
# _BNReadBE32

_BNReadBE32 = core.BNReadBE32
_BNReadBE32.restype = ctypes.c_bool
_BNReadBE32.argtypes = [
		ctypes.POINTER(BNBinaryReader),
		ctypes.POINTER(ctypes.c_uint),
	]


# noinspection PyPep8Naming
def BNReadBE32(
		stream: ctypes.POINTER(BNBinaryReader), 
		result: ctypes.POINTER(ctypes.c_uint)
		) -> bool:
	return _BNReadBE32(stream, result)


# -------------------------------------------------------
# _BNReadBE64

_BNReadBE64 = core.BNReadBE64
_BNReadBE64.restype = ctypes.c_bool
_BNReadBE64.argtypes = [
		ctypes.POINTER(BNBinaryReader),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNReadBE64(
		stream: ctypes.POINTER(BNBinaryReader), 
		result: ctypes.POINTER(ctypes.c_ulonglong)
		) -> bool:
	return _BNReadBE64(stream, result)


# -------------------------------------------------------
# _BNReadData

_BNReadData = core.BNReadData
_BNReadData.restype = ctypes.c_bool
_BNReadData.argtypes = [
		ctypes.POINTER(BNBinaryReader),
		ctypes.c_void_p,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNReadData(
		stream: ctypes.POINTER(BNBinaryReader), 
		dest: Optional[ctypes.c_void_p], 
		len: int
		) -> bool:
	return _BNReadData(stream, dest, len)


# -------------------------------------------------------
# _BNReadDataForDownloadInstance

_BNReadDataForDownloadInstance = core.BNReadDataForDownloadInstance
_BNReadDataForDownloadInstance.restype = ctypes.c_longlong
_BNReadDataForDownloadInstance.argtypes = [
		ctypes.POINTER(BNDownloadInstance),
		ctypes.POINTER(ctypes.c_ubyte),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNReadDataForDownloadInstance(
		instance: ctypes.POINTER(BNDownloadInstance), 
		data: ctypes.POINTER(ctypes.c_ubyte), 
		len: int
		) -> int:
	return _BNReadDataForDownloadInstance(instance, data, len)


# -------------------------------------------------------
# _BNReadDatabaseAnalysisCache

_BNReadDatabaseAnalysisCache = core.BNReadDatabaseAnalysisCache
_BNReadDatabaseAnalysisCache.restype = ctypes.POINTER(BNKeyValueStore)
_BNReadDatabaseAnalysisCache.argtypes = [
		ctypes.POINTER(BNDatabase),
	]


# noinspection PyPep8Naming
def BNReadDatabaseAnalysisCache(
		database: ctypes.POINTER(BNDatabase)
		) -> Optional[ctypes.POINTER(BNKeyValueStore)]:
	result = _BNReadDatabaseAnalysisCache(database)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNReadDatabaseGlobal

_BNReadDatabaseGlobal = core.BNReadDatabaseGlobal
_BNReadDatabaseGlobal.restype = ctypes.POINTER(ctypes.c_byte)
_BNReadDatabaseGlobal.argtypes = [
		ctypes.POINTER(BNDatabase),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNReadDatabaseGlobal(
		database: ctypes.POINTER(BNDatabase), 
		key: Optional[str]
		) -> Optional[Optional[str]]:
	result = _BNReadDatabaseGlobal(database, cstr(key))
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNReadDatabaseGlobalData

_BNReadDatabaseGlobalData = core.BNReadDatabaseGlobalData
_BNReadDatabaseGlobalData.restype = ctypes.POINTER(BNDataBuffer)
_BNReadDatabaseGlobalData.argtypes = [
		ctypes.POINTER(BNDatabase),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNReadDatabaseGlobalData(
		database: ctypes.POINTER(BNDatabase), 
		key: Optional[str]
		) -> Optional[ctypes.POINTER(BNDataBuffer)]:
	result = _BNReadDatabaseGlobalData(database, cstr(key))
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNReadLE16

_BNReadLE16 = core.BNReadLE16
_BNReadLE16.restype = ctypes.c_bool
_BNReadLE16.argtypes = [
		ctypes.POINTER(BNBinaryReader),
		ctypes.POINTER(ctypes.c_ushort),
	]


# noinspection PyPep8Naming
def BNReadLE16(
		stream: ctypes.POINTER(BNBinaryReader), 
		result: ctypes.POINTER(ctypes.c_ushort)
		) -> bool:
	return _BNReadLE16(stream, result)


# -------------------------------------------------------
# _BNReadLE32

_BNReadLE32 = core.BNReadLE32
_BNReadLE32.restype = ctypes.c_bool
_BNReadLE32.argtypes = [
		ctypes.POINTER(BNBinaryReader),
		ctypes.POINTER(ctypes.c_uint),
	]


# noinspection PyPep8Naming
def BNReadLE32(
		stream: ctypes.POINTER(BNBinaryReader), 
		result: ctypes.POINTER(ctypes.c_uint)
		) -> bool:
	return _BNReadLE32(stream, result)


# -------------------------------------------------------
# _BNReadLE64

_BNReadLE64 = core.BNReadLE64
_BNReadLE64.restype = ctypes.c_bool
_BNReadLE64.argtypes = [
		ctypes.POINTER(BNBinaryReader),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNReadLE64(
		stream: ctypes.POINTER(BNBinaryReader), 
		result: ctypes.POINTER(ctypes.c_ulonglong)
		) -> bool:
	return _BNReadLE64(stream, result)


# -------------------------------------------------------
# _BNReadSnapshotData

_BNReadSnapshotData = core.BNReadSnapshotData
_BNReadSnapshotData.restype = ctypes.POINTER(BNKeyValueStore)
_BNReadSnapshotData.argtypes = [
		ctypes.POINTER(BNSnapshot),
	]


# noinspection PyPep8Naming
def BNReadSnapshotData(
		snapshot: ctypes.POINTER(BNSnapshot)
		) -> Optional[ctypes.POINTER(BNKeyValueStore)]:
	result = _BNReadSnapshotData(snapshot)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNReadSnapshotDataWithProgress

_BNReadSnapshotDataWithProgress = core.BNReadSnapshotDataWithProgress
_BNReadSnapshotDataWithProgress.restype = ctypes.POINTER(BNKeyValueStore)
_BNReadSnapshotDataWithProgress.argtypes = [
		ctypes.POINTER(BNSnapshot),
		ctypes.c_void_p,
		ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNReadSnapshotDataWithProgress(
		snapshot: ctypes.POINTER(BNSnapshot), 
		ctxt: Optional[ctypes.c_void_p], 
		progress: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNKeyValueStore)]:
	result = _BNReadSnapshotDataWithProgress(snapshot, ctxt, progress)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNReadViewBuffer

_BNReadViewBuffer = core.BNReadViewBuffer
_BNReadViewBuffer.restype = ctypes.POINTER(BNDataBuffer)
_BNReadViewBuffer.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNReadViewBuffer(
		view: ctypes.POINTER(BNBinaryView), 
		offset: int, 
		len: int
		) -> Optional[ctypes.POINTER(BNDataBuffer)]:
	result = _BNReadViewBuffer(view, offset, len)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNReadViewData

_BNReadViewData = core.BNReadViewData
_BNReadViewData.restype = ctypes.c_ulonglong
_BNReadViewData.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_void_p,
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNReadViewData(
		view: ctypes.POINTER(BNBinaryView), 
		dest: Optional[ctypes.c_void_p], 
		offset: int, 
		len: int
		) -> int:
	return _BNReadViewData(view, dest, offset, len)


# -------------------------------------------------------
# _BNReanalyzeAllFunctions

_BNReanalyzeAllFunctions = core.BNReanalyzeAllFunctions
_BNReanalyzeAllFunctions.restype = None
_BNReanalyzeAllFunctions.argtypes = [
		ctypes.POINTER(BNBinaryView),
	]


# noinspection PyPep8Naming
def BNReanalyzeAllFunctions(
		view: ctypes.POINTER(BNBinaryView)
		) -> None:
	return _BNReanalyzeAllFunctions(view)


# -------------------------------------------------------
# _BNReanalyzeFunction

_BNReanalyzeFunction = core.BNReanalyzeFunction
_BNReanalyzeFunction.restype = None
_BNReanalyzeFunction.argtypes = [
		ctypes.POINTER(BNFunction),
		FunctionUpdateTypeEnum,
	]


# noinspection PyPep8Naming
def BNReanalyzeFunction(
		func: ctypes.POINTER(BNFunction), 
		type: FunctionUpdateType
		) -> None:
	return _BNReanalyzeFunction(func, type)


# -------------------------------------------------------
# _BNRebase

_BNRebase = core.BNRebase
_BNRebase.restype = ctypes.c_bool
_BNRebase.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNRebase(
		data: ctypes.POINTER(BNBinaryView), 
		address: int
		) -> bool:
	return _BNRebase(data, address)


# -------------------------------------------------------
# _BNRebaseWithProgress

_BNRebaseWithProgress = core.BNRebaseWithProgress
_BNRebaseWithProgress.restype = ctypes.c_bool
_BNRebaseWithProgress.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
		ctypes.c_void_p,
		ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNRebaseWithProgress(
		data: ctypes.POINTER(BNBinaryView), 
		address: int, 
		ctxt: Optional[ctypes.c_void_p], 
		progress: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong)
		) -> bool:
	return _BNRebaseWithProgress(data, address, ctxt, progress)


# -------------------------------------------------------
# _BNRecognizePlatformForViewType

_BNRecognizePlatformForViewType = core.BNRecognizePlatformForViewType
_BNRecognizePlatformForViewType.restype = ctypes.POINTER(BNPlatform)
_BNRecognizePlatformForViewType.argtypes = [
		ctypes.POINTER(BNBinaryViewType),
		ctypes.c_ulonglong,
		EndiannessEnum,
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNMetadata),
	]


# noinspection PyPep8Naming
def BNRecognizePlatformForViewType(
		type: ctypes.POINTER(BNBinaryViewType), 
		id: int, 
		endian: Endianness, 
		view: ctypes.POINTER(BNBinaryView), 
		metadata: ctypes.POINTER(BNMetadata)
		) -> Optional[ctypes.POINTER(BNPlatform)]:
	result = _BNRecognizePlatformForViewType(type, id, endian, view, metadata)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNRedo

_BNRedo = core.BNRedo
_BNRedo.restype = ctypes.c_bool
_BNRedo.argtypes = [
		ctypes.POINTER(BNFileMetadata),
	]


# noinspection PyPep8Naming
def BNRedo(
		file: ctypes.POINTER(BNFileMetadata)
		) -> bool:
	return _BNRedo(file)


# -------------------------------------------------------
# _BNRegisterArchitecture

_BNRegisterArchitecture = core.BNRegisterArchitecture
_BNRegisterArchitecture.restype = ctypes.POINTER(BNArchitecture)
_BNRegisterArchitecture.argtypes = [
		ctypes.c_char_p,
		ctypes.POINTER(BNCustomArchitecture),
	]


# noinspection PyPep8Naming
def BNRegisterArchitecture(
		name: Optional[str], 
		arch: ctypes.POINTER(BNCustomArchitecture)
		) -> Optional[ctypes.POINTER(BNArchitecture)]:
	result = _BNRegisterArchitecture(cstr(name), arch)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNRegisterArchitectureExtension

_BNRegisterArchitectureExtension = core.BNRegisterArchitectureExtension
_BNRegisterArchitectureExtension.restype = ctypes.POINTER(BNArchitecture)
_BNRegisterArchitectureExtension.argtypes = [
		ctypes.c_char_p,
		ctypes.POINTER(BNArchitecture),
		ctypes.POINTER(BNCustomArchitecture),
	]


# noinspection PyPep8Naming
def BNRegisterArchitectureExtension(
		name: Optional[str], 
		base: ctypes.POINTER(BNArchitecture), 
		arch: ctypes.POINTER(BNCustomArchitecture)
		) -> Optional[ctypes.POINTER(BNArchitecture)]:
	result = _BNRegisterArchitectureExtension(cstr(name), base, arch)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNRegisterArchitectureForViewType

_BNRegisterArchitectureForViewType = core.BNRegisterArchitectureForViewType
_BNRegisterArchitectureForViewType.restype = None
_BNRegisterArchitectureForViewType.argtypes = [
		ctypes.POINTER(BNBinaryViewType),
		ctypes.c_uint,
		EndiannessEnum,
		ctypes.POINTER(BNArchitecture),
	]


# noinspection PyPep8Naming
def BNRegisterArchitectureForViewType(
		type: ctypes.POINTER(BNBinaryViewType), 
		id: int, 
		endian: Endianness, 
		arch: ctypes.POINTER(BNArchitecture)
		) -> None:
	return _BNRegisterArchitectureForViewType(type, id, endian, arch)


# -------------------------------------------------------
# _BNRegisterArchitectureFunctionRecognizer

_BNRegisterArchitectureFunctionRecognizer = core.BNRegisterArchitectureFunctionRecognizer
_BNRegisterArchitectureFunctionRecognizer.restype = None
_BNRegisterArchitectureFunctionRecognizer.argtypes = [
		ctypes.POINTER(BNArchitecture),
		ctypes.POINTER(BNFunctionRecognizer),
	]


# noinspection PyPep8Naming
def BNRegisterArchitectureFunctionRecognizer(
		arch: ctypes.POINTER(BNArchitecture), 
		rec: ctypes.POINTER(BNFunctionRecognizer)
		) -> None:
	return _BNRegisterArchitectureFunctionRecognizer(arch, rec)


# -------------------------------------------------------
# _BNRegisterArchitectureHook

_BNRegisterArchitectureHook = core.BNRegisterArchitectureHook
_BNRegisterArchitectureHook.restype = ctypes.POINTER(BNArchitecture)
_BNRegisterArchitectureHook.argtypes = [
		ctypes.POINTER(BNArchitecture),
		ctypes.POINTER(BNCustomArchitecture),
	]


# noinspection PyPep8Naming
def BNRegisterArchitectureHook(
		base: ctypes.POINTER(BNArchitecture), 
		arch: ctypes.POINTER(BNCustomArchitecture)
		) -> Optional[ctypes.POINTER(BNArchitecture)]:
	result = _BNRegisterArchitectureHook(base, arch)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNRegisterBinaryViewEvent

_BNRegisterBinaryViewEvent = core.BNRegisterBinaryViewEvent
_BNRegisterBinaryViewEvent.restype = None
_BNRegisterBinaryViewEvent.argtypes = [
		BinaryViewEventTypeEnum,
		ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView)),
		ctypes.c_void_p,
	]


# noinspection PyPep8Naming
def BNRegisterBinaryViewEvent(
		type: BinaryViewEventType, 
		callback: ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView)), 
		ctx: Optional[ctypes.c_void_p]
		) -> None:
	return _BNRegisterBinaryViewEvent(type, callback, ctx)


# -------------------------------------------------------
# _BNRegisterBinaryViewType

_BNRegisterBinaryViewType = core.BNRegisterBinaryViewType
_BNRegisterBinaryViewType.restype = ctypes.POINTER(BNBinaryViewType)
_BNRegisterBinaryViewType.argtypes = [
		ctypes.c_char_p,
		ctypes.c_char_p,
		ctypes.POINTER(BNCustomBinaryViewType),
	]


# noinspection PyPep8Naming
def BNRegisterBinaryViewType(
		name: Optional[str], 
		longName: Optional[str], 
		type: ctypes.POINTER(BNCustomBinaryViewType)
		) -> Optional[ctypes.POINTER(BNBinaryViewType)]:
	result = _BNRegisterBinaryViewType(cstr(name), cstr(longName), type)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNRegisterCallingConvention

_BNRegisterCallingConvention = core.BNRegisterCallingConvention
_BNRegisterCallingConvention.restype = None
_BNRegisterCallingConvention.argtypes = [
		ctypes.POINTER(BNArchitecture),
		ctypes.POINTER(BNCallingConvention),
	]


# noinspection PyPep8Naming
def BNRegisterCallingConvention(
		arch: ctypes.POINTER(BNArchitecture), 
		cc: ctypes.POINTER(BNCallingConvention)
		) -> None:
	return _BNRegisterCallingConvention(arch, cc)


# -------------------------------------------------------
# _BNRegisterDataNotification

_BNRegisterDataNotification = core.BNRegisterDataNotification
_BNRegisterDataNotification.restype = None
_BNRegisterDataNotification.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNBinaryDataNotification),
	]


# noinspection PyPep8Naming
def BNRegisterDataNotification(
		view: ctypes.POINTER(BNBinaryView), 
		notify: ctypes.POINTER(BNBinaryDataNotification)
		) -> None:
	return _BNRegisterDataNotification(view, notify)


# -------------------------------------------------------
# _BNRegisterDebugInfoParser

_BNRegisterDebugInfoParser = core.BNRegisterDebugInfoParser
_BNRegisterDebugInfoParser.restype = ctypes.POINTER(BNDebugInfoParser)
_BNRegisterDebugInfoParser.argtypes = [
		ctypes.c_char_p,
		ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNBinaryView)),
		ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNDebugInfo), ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNBinaryView), ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong), ctypes.c_void_p),
		ctypes.c_void_p,
	]


# noinspection PyPep8Naming
def BNRegisterDebugInfoParser(
		name: Optional[str], 
		isValid: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNBinaryView)), 
		parseInfo: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNDebugInfo), ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNBinaryView), ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong), ctypes.c_void_p), 
		context: Optional[ctypes.c_void_p]
		) -> Optional[ctypes.POINTER(BNDebugInfoParser)]:
	result = _BNRegisterDebugInfoParser(cstr(name), isValid, parseInfo, context)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNRegisterDefaultPlatformForViewType

_BNRegisterDefaultPlatformForViewType = core.BNRegisterDefaultPlatformForViewType
_BNRegisterDefaultPlatformForViewType.restype = None
_BNRegisterDefaultPlatformForViewType.argtypes = [
		ctypes.POINTER(BNBinaryViewType),
		ctypes.POINTER(BNArchitecture),
		ctypes.POINTER(BNPlatform),
	]


# noinspection PyPep8Naming
def BNRegisterDefaultPlatformForViewType(
		type: ctypes.POINTER(BNBinaryViewType), 
		arch: ctypes.POINTER(BNArchitecture), 
		platform: ctypes.POINTER(BNPlatform)
		) -> None:
	return _BNRegisterDefaultPlatformForViewType(type, arch, platform)


# -------------------------------------------------------
# _BNRegisterDownloadProvider

_BNRegisterDownloadProvider = core.BNRegisterDownloadProvider
_BNRegisterDownloadProvider.restype = ctypes.POINTER(BNDownloadProvider)
_BNRegisterDownloadProvider.argtypes = [
		ctypes.c_char_p,
		ctypes.POINTER(BNDownloadProviderCallbacks),
	]


# noinspection PyPep8Naming
def BNRegisterDownloadProvider(
		name: Optional[str], 
		callbacks: ctypes.POINTER(BNDownloadProviderCallbacks)
		) -> Optional[ctypes.POINTER(BNDownloadProvider)]:
	result = _BNRegisterDownloadProvider(cstr(name), callbacks)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNRegisterEnterpriseServerNotification

_BNRegisterEnterpriseServerNotification = core.BNRegisterEnterpriseServerNotification
_BNRegisterEnterpriseServerNotification.restype = None
_BNRegisterEnterpriseServerNotification.argtypes = [
		ctypes.POINTER(BNEnterpriseServerCallbacks),
	]


# noinspection PyPep8Naming
def BNRegisterEnterpriseServerNotification(
		notify: ctypes.POINTER(BNEnterpriseServerCallbacks)
		) -> None:
	return _BNRegisterEnterpriseServerNotification(notify)


# -------------------------------------------------------
# _BNRegisterGenericDataRenderer

_BNRegisterGenericDataRenderer = core.BNRegisterGenericDataRenderer
_BNRegisterGenericDataRenderer.restype = None
_BNRegisterGenericDataRenderer.argtypes = [
		ctypes.POINTER(BNDataRendererContainer),
		ctypes.POINTER(BNDataRenderer),
	]


# noinspection PyPep8Naming
def BNRegisterGenericDataRenderer(
		container: ctypes.POINTER(BNDataRendererContainer), 
		renderer: ctypes.POINTER(BNDataRenderer)
		) -> None:
	return _BNRegisterGenericDataRenderer(container, renderer)


# -------------------------------------------------------
# _BNRegisterGlobalFunctionRecognizer

_BNRegisterGlobalFunctionRecognizer = core.BNRegisterGlobalFunctionRecognizer
_BNRegisterGlobalFunctionRecognizer.restype = None
_BNRegisterGlobalFunctionRecognizer.argtypes = [
		ctypes.POINTER(BNFunctionRecognizer),
	]


# noinspection PyPep8Naming
def BNRegisterGlobalFunctionRecognizer(
		rec: ctypes.POINTER(BNFunctionRecognizer)
		) -> None:
	return _BNRegisterGlobalFunctionRecognizer(rec)


# -------------------------------------------------------
# _BNRegisterInteractionHandler

_BNRegisterInteractionHandler = core.BNRegisterInteractionHandler
_BNRegisterInteractionHandler.restype = None
_BNRegisterInteractionHandler.argtypes = [
		ctypes.POINTER(BNInteractionHandlerCallbacks),
	]


# noinspection PyPep8Naming
def BNRegisterInteractionHandler(
		callbacks: ctypes.POINTER(BNInteractionHandlerCallbacks)
		) -> None:
	return _BNRegisterInteractionHandler(callbacks)


# -------------------------------------------------------
# _BNRegisterLogListener

_BNRegisterLogListener = core.BNRegisterLogListener
_BNRegisterLogListener.restype = None
_BNRegisterLogListener.argtypes = [
		ctypes.POINTER(BNLogListener),
	]


# noinspection PyPep8Naming
def BNRegisterLogListener(
		listener: ctypes.POINTER(BNLogListener)
		) -> None:
	return _BNRegisterLogListener(listener)


# -------------------------------------------------------
# _BNRegisterMainThread

_BNRegisterMainThread = core.BNRegisterMainThread
_BNRegisterMainThread.restype = None
_BNRegisterMainThread.argtypes = [
		ctypes.POINTER(BNMainThreadCallbacks),
	]


# noinspection PyPep8Naming
def BNRegisterMainThread(
		callbacks: ctypes.POINTER(BNMainThreadCallbacks)
		) -> None:
	return _BNRegisterMainThread(callbacks)


# -------------------------------------------------------
# _BNRegisterObjectDestructionCallbacks

_BNRegisterObjectDestructionCallbacks = core.BNRegisterObjectDestructionCallbacks
_BNRegisterObjectDestructionCallbacks.restype = None
_BNRegisterObjectDestructionCallbacks.argtypes = [
		ctypes.POINTER(BNObjectDestructionCallbacks),
	]


# noinspection PyPep8Naming
def BNRegisterObjectDestructionCallbacks(
		callbacks: ctypes.POINTER(BNObjectDestructionCallbacks)
		) -> None:
	return _BNRegisterObjectDestructionCallbacks(callbacks)


# -------------------------------------------------------
# _BNRegisterObjectRefDebugTrace

_BNRegisterObjectRefDebugTrace = core.BNRegisterObjectRefDebugTrace
_BNRegisterObjectRefDebugTrace.restype = ctypes.c_void_p
_BNRegisterObjectRefDebugTrace.argtypes = [
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNRegisterObjectRefDebugTrace(
		typeName: Optional[str]
		) -> Optional[Optional[ctypes.c_void_p]]:
	result = _BNRegisterObjectRefDebugTrace(cstr(typeName))
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNRegisterPlatform

_BNRegisterPlatform = core.BNRegisterPlatform
_BNRegisterPlatform.restype = None
_BNRegisterPlatform.argtypes = [
		ctypes.c_char_p,
		ctypes.POINTER(BNPlatform),
	]


# noinspection PyPep8Naming
def BNRegisterPlatform(
		os: Optional[str], 
		platform: ctypes.POINTER(BNPlatform)
		) -> None:
	return _BNRegisterPlatform(cstr(os), platform)


# -------------------------------------------------------
# _BNRegisterPlatformCallingConvention

_BNRegisterPlatformCallingConvention = core.BNRegisterPlatformCallingConvention
_BNRegisterPlatformCallingConvention.restype = None
_BNRegisterPlatformCallingConvention.argtypes = [
		ctypes.POINTER(BNPlatform),
		ctypes.POINTER(BNCallingConvention),
	]


# noinspection PyPep8Naming
def BNRegisterPlatformCallingConvention(
		platform: ctypes.POINTER(BNPlatform), 
		cc: ctypes.POINTER(BNCallingConvention)
		) -> None:
	return _BNRegisterPlatformCallingConvention(platform, cc)


# -------------------------------------------------------
# _BNRegisterPlatformCdeclCallingConvention

_BNRegisterPlatformCdeclCallingConvention = core.BNRegisterPlatformCdeclCallingConvention
_BNRegisterPlatformCdeclCallingConvention.restype = None
_BNRegisterPlatformCdeclCallingConvention.argtypes = [
		ctypes.POINTER(BNPlatform),
		ctypes.POINTER(BNCallingConvention),
	]


# noinspection PyPep8Naming
def BNRegisterPlatformCdeclCallingConvention(
		platform: ctypes.POINTER(BNPlatform), 
		cc: ctypes.POINTER(BNCallingConvention)
		) -> None:
	return _BNRegisterPlatformCdeclCallingConvention(platform, cc)


# -------------------------------------------------------
# _BNRegisterPlatformDefaultCallingConvention

_BNRegisterPlatformDefaultCallingConvention = core.BNRegisterPlatformDefaultCallingConvention
_BNRegisterPlatformDefaultCallingConvention.restype = None
_BNRegisterPlatformDefaultCallingConvention.argtypes = [
		ctypes.POINTER(BNPlatform),
		ctypes.POINTER(BNCallingConvention),
	]


# noinspection PyPep8Naming
def BNRegisterPlatformDefaultCallingConvention(
		platform: ctypes.POINTER(BNPlatform), 
		cc: ctypes.POINTER(BNCallingConvention)
		) -> None:
	return _BNRegisterPlatformDefaultCallingConvention(platform, cc)


# -------------------------------------------------------
# _BNRegisterPlatformFastcallCallingConvention

_BNRegisterPlatformFastcallCallingConvention = core.BNRegisterPlatformFastcallCallingConvention
_BNRegisterPlatformFastcallCallingConvention.restype = None
_BNRegisterPlatformFastcallCallingConvention.argtypes = [
		ctypes.POINTER(BNPlatform),
		ctypes.POINTER(BNCallingConvention),
	]


# noinspection PyPep8Naming
def BNRegisterPlatformFastcallCallingConvention(
		platform: ctypes.POINTER(BNPlatform), 
		cc: ctypes.POINTER(BNCallingConvention)
		) -> None:
	return _BNRegisterPlatformFastcallCallingConvention(platform, cc)


# -------------------------------------------------------
# _BNRegisterPlatformForViewType

_BNRegisterPlatformForViewType = core.BNRegisterPlatformForViewType
_BNRegisterPlatformForViewType.restype = None
_BNRegisterPlatformForViewType.argtypes = [
		ctypes.POINTER(BNBinaryViewType),
		ctypes.c_uint,
		ctypes.POINTER(BNArchitecture),
		ctypes.POINTER(BNPlatform),
	]


# noinspection PyPep8Naming
def BNRegisterPlatformForViewType(
		type: ctypes.POINTER(BNBinaryViewType), 
		id: int, 
		arch: ctypes.POINTER(BNArchitecture), 
		platform: ctypes.POINTER(BNPlatform)
		) -> None:
	return _BNRegisterPlatformForViewType(type, id, arch, platform)


# -------------------------------------------------------
# _BNRegisterPlatformRecognizerForViewType

_BNRegisterPlatformRecognizerForViewType = core.BNRegisterPlatformRecognizerForViewType
_BNRegisterPlatformRecognizerForViewType.restype = None
_BNRegisterPlatformRecognizerForViewType.argtypes = [
		ctypes.POINTER(BNBinaryViewType),
		ctypes.c_ulonglong,
		EndiannessEnum,
		ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNMetadata)),
		ctypes.c_void_p,
	]


# noinspection PyPep8Naming
def BNRegisterPlatformRecognizerForViewType(
		type: ctypes.POINTER(BNBinaryViewType), 
		id: int, 
		endian: Endianness, 
		callback: ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNMetadata)), 
		ctx: Optional[ctypes.c_void_p]
		) -> None:
	return _BNRegisterPlatformRecognizerForViewType(type, id, endian, callback, ctx)


# -------------------------------------------------------
# _BNRegisterPlatformStdcallCallingConvention

_BNRegisterPlatformStdcallCallingConvention = core.BNRegisterPlatformStdcallCallingConvention
_BNRegisterPlatformStdcallCallingConvention.restype = None
_BNRegisterPlatformStdcallCallingConvention.argtypes = [
		ctypes.POINTER(BNPlatform),
		ctypes.POINTER(BNCallingConvention),
	]


# noinspection PyPep8Naming
def BNRegisterPlatformStdcallCallingConvention(
		platform: ctypes.POINTER(BNPlatform), 
		cc: ctypes.POINTER(BNCallingConvention)
		) -> None:
	return _BNRegisterPlatformStdcallCallingConvention(platform, cc)


# -------------------------------------------------------
# _BNRegisterPlatformTypes

_BNRegisterPlatformTypes = core.BNRegisterPlatformTypes
_BNRegisterPlatformTypes.restype = None
_BNRegisterPlatformTypes.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNPlatform),
	]


# noinspection PyPep8Naming
def BNRegisterPlatformTypes(
		view: ctypes.POINTER(BNBinaryView), 
		platform: ctypes.POINTER(BNPlatform)
		) -> None:
	return _BNRegisterPlatformTypes(view, platform)


# -------------------------------------------------------
# _BNRegisterPluginCommand

_BNRegisterPluginCommand = core.BNRegisterPluginCommand
_BNRegisterPluginCommand.restype = None
_BNRegisterPluginCommand.argtypes = [
		ctypes.c_char_p,
		ctypes.c_char_p,
		ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView)),
		ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNBinaryView)),
		ctypes.c_void_p,
	]


# noinspection PyPep8Naming
def BNRegisterPluginCommand(
		name: Optional[str], 
		description: Optional[str], 
		action: ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView)), 
		isValid: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNBinaryView)), 
		context: Optional[ctypes.c_void_p]
		) -> None:
	return _BNRegisterPluginCommand(cstr(name), cstr(description), action, isValid, context)


# -------------------------------------------------------
# _BNRegisterPluginCommandForAddress

_BNRegisterPluginCommandForAddress = core.BNRegisterPluginCommandForAddress
_BNRegisterPluginCommandForAddress.restype = None
_BNRegisterPluginCommandForAddress.argtypes = [
		ctypes.c_char_p,
		ctypes.c_char_p,
		ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.c_ulonglong),
		ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.c_ulonglong),
		ctypes.c_void_p,
	]


# noinspection PyPep8Naming
def BNRegisterPluginCommandForAddress(
		name: Optional[str], 
		description: Optional[str], 
		action: ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.c_ulonglong), 
		isValid: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.c_ulonglong), 
		context: Optional[ctypes.c_void_p]
		) -> None:
	return _BNRegisterPluginCommandForAddress(cstr(name), cstr(description), action, isValid, context)


# -------------------------------------------------------
# _BNRegisterPluginCommandForFunction

_BNRegisterPluginCommandForFunction = core.BNRegisterPluginCommandForFunction
_BNRegisterPluginCommandForFunction.restype = None
_BNRegisterPluginCommandForFunction.argtypes = [
		ctypes.c_char_p,
		ctypes.c_char_p,
		ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNFunction)),
		ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNFunction)),
		ctypes.c_void_p,
	]


# noinspection PyPep8Naming
def BNRegisterPluginCommandForFunction(
		name: Optional[str], 
		description: Optional[str], 
		action: ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNFunction)), 
		isValid: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNFunction)), 
		context: Optional[ctypes.c_void_p]
		) -> None:
	return _BNRegisterPluginCommandForFunction(cstr(name), cstr(description), action, isValid, context)


# -------------------------------------------------------
# _BNRegisterPluginCommandForHighLevelILFunction

_BNRegisterPluginCommandForHighLevelILFunction = core.BNRegisterPluginCommandForHighLevelILFunction
_BNRegisterPluginCommandForHighLevelILFunction.restype = None
_BNRegisterPluginCommandForHighLevelILFunction.argtypes = [
		ctypes.c_char_p,
		ctypes.c_char_p,
		ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNHighLevelILFunction)),
		ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNHighLevelILFunction)),
		ctypes.c_void_p,
	]


# noinspection PyPep8Naming
def BNRegisterPluginCommandForHighLevelILFunction(
		name: Optional[str], 
		description: Optional[str], 
		action: ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNHighLevelILFunction)), 
		isValid: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNHighLevelILFunction)), 
		context: Optional[ctypes.c_void_p]
		) -> None:
	return _BNRegisterPluginCommandForHighLevelILFunction(cstr(name), cstr(description), action, isValid, context)


# -------------------------------------------------------
# _BNRegisterPluginCommandForHighLevelILInstruction

_BNRegisterPluginCommandForHighLevelILInstruction = core.BNRegisterPluginCommandForHighLevelILInstruction
_BNRegisterPluginCommandForHighLevelILInstruction.restype = None
_BNRegisterPluginCommandForHighLevelILInstruction.argtypes = [
		ctypes.c_char_p,
		ctypes.c_char_p,
		ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNHighLevelILFunction), ctypes.c_ulonglong),
		ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNHighLevelILFunction), ctypes.c_ulonglong),
		ctypes.c_void_p,
	]


# noinspection PyPep8Naming
def BNRegisterPluginCommandForHighLevelILInstruction(
		name: Optional[str], 
		description: Optional[str], 
		action: ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNHighLevelILFunction), ctypes.c_ulonglong), 
		isValid: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNHighLevelILFunction), ctypes.c_ulonglong), 
		context: Optional[ctypes.c_void_p]
		) -> None:
	return _BNRegisterPluginCommandForHighLevelILInstruction(cstr(name), cstr(description), action, isValid, context)


# -------------------------------------------------------
# _BNRegisterPluginCommandForLowLevelILFunction

_BNRegisterPluginCommandForLowLevelILFunction = core.BNRegisterPluginCommandForLowLevelILFunction
_BNRegisterPluginCommandForLowLevelILFunction.restype = None
_BNRegisterPluginCommandForLowLevelILFunction.argtypes = [
		ctypes.c_char_p,
		ctypes.c_char_p,
		ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNLowLevelILFunction)),
		ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNLowLevelILFunction)),
		ctypes.c_void_p,
	]


# noinspection PyPep8Naming
def BNRegisterPluginCommandForLowLevelILFunction(
		name: Optional[str], 
		description: Optional[str], 
		action: ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNLowLevelILFunction)), 
		isValid: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNLowLevelILFunction)), 
		context: Optional[ctypes.c_void_p]
		) -> None:
	return _BNRegisterPluginCommandForLowLevelILFunction(cstr(name), cstr(description), action, isValid, context)


# -------------------------------------------------------
# _BNRegisterPluginCommandForLowLevelILInstruction

_BNRegisterPluginCommandForLowLevelILInstruction = core.BNRegisterPluginCommandForLowLevelILInstruction
_BNRegisterPluginCommandForLowLevelILInstruction.restype = None
_BNRegisterPluginCommandForLowLevelILInstruction.argtypes = [
		ctypes.c_char_p,
		ctypes.c_char_p,
		ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNLowLevelILFunction), ctypes.c_ulonglong),
		ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNLowLevelILFunction), ctypes.c_ulonglong),
		ctypes.c_void_p,
	]


# noinspection PyPep8Naming
def BNRegisterPluginCommandForLowLevelILInstruction(
		name: Optional[str], 
		description: Optional[str], 
		action: ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNLowLevelILFunction), ctypes.c_ulonglong), 
		isValid: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNLowLevelILFunction), ctypes.c_ulonglong), 
		context: Optional[ctypes.c_void_p]
		) -> None:
	return _BNRegisterPluginCommandForLowLevelILInstruction(cstr(name), cstr(description), action, isValid, context)


# -------------------------------------------------------
# _BNRegisterPluginCommandForMediumLevelILFunction

_BNRegisterPluginCommandForMediumLevelILFunction = core.BNRegisterPluginCommandForMediumLevelILFunction
_BNRegisterPluginCommandForMediumLevelILFunction.restype = None
_BNRegisterPluginCommandForMediumLevelILFunction.argtypes = [
		ctypes.c_char_p,
		ctypes.c_char_p,
		ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNMediumLevelILFunction)),
		ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNMediumLevelILFunction)),
		ctypes.c_void_p,
	]


# noinspection PyPep8Naming
def BNRegisterPluginCommandForMediumLevelILFunction(
		name: Optional[str], 
		description: Optional[str], 
		action: ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNMediumLevelILFunction)), 
		isValid: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNMediumLevelILFunction)), 
		context: Optional[ctypes.c_void_p]
		) -> None:
	return _BNRegisterPluginCommandForMediumLevelILFunction(cstr(name), cstr(description), action, isValid, context)


# -------------------------------------------------------
# _BNRegisterPluginCommandForMediumLevelILInstruction

_BNRegisterPluginCommandForMediumLevelILInstruction = core.BNRegisterPluginCommandForMediumLevelILInstruction
_BNRegisterPluginCommandForMediumLevelILInstruction.restype = None
_BNRegisterPluginCommandForMediumLevelILInstruction.argtypes = [
		ctypes.c_char_p,
		ctypes.c_char_p,
		ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNMediumLevelILFunction), ctypes.c_ulonglong),
		ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNMediumLevelILFunction), ctypes.c_ulonglong),
		ctypes.c_void_p,
	]


# noinspection PyPep8Naming
def BNRegisterPluginCommandForMediumLevelILInstruction(
		name: Optional[str], 
		description: Optional[str], 
		action: ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNMediumLevelILFunction), ctypes.c_ulonglong), 
		isValid: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNMediumLevelILFunction), ctypes.c_ulonglong), 
		context: Optional[ctypes.c_void_p]
		) -> None:
	return _BNRegisterPluginCommandForMediumLevelILInstruction(cstr(name), cstr(description), action, isValid, context)


# -------------------------------------------------------
# _BNRegisterPluginCommandForRange

_BNRegisterPluginCommandForRange = core.BNRegisterPluginCommandForRange
_BNRegisterPluginCommandForRange.restype = None
_BNRegisterPluginCommandForRange.argtypes = [
		ctypes.c_char_p,
		ctypes.c_char_p,
		ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.c_ulonglong, ctypes.c_ulonglong),
		ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.c_ulonglong, ctypes.c_ulonglong),
		ctypes.c_void_p,
	]


# noinspection PyPep8Naming
def BNRegisterPluginCommandForRange(
		name: Optional[str], 
		description: Optional[str], 
		action: ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.c_ulonglong, ctypes.c_ulonglong), 
		isValid: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.c_ulonglong, ctypes.c_ulonglong), 
		context: Optional[ctypes.c_void_p]
		) -> None:
	return _BNRegisterPluginCommandForRange(cstr(name), cstr(description), action, isValid, context)


# -------------------------------------------------------
# _BNRegisterProjectNotification

_BNRegisterProjectNotification = core.BNRegisterProjectNotification
_BNRegisterProjectNotification.restype = None
_BNRegisterProjectNotification.argtypes = [
		ctypes.POINTER(BNProject),
		ctypes.POINTER(BNProjectNotification),
	]


# noinspection PyPep8Naming
def BNRegisterProjectNotification(
		project: ctypes.POINTER(BNProject), 
		notify: ctypes.POINTER(BNProjectNotification)
		) -> None:
	return _BNRegisterProjectNotification(project, notify)


# -------------------------------------------------------
# _BNRegisterScriptingInstanceOutputListener

_BNRegisterScriptingInstanceOutputListener = core.BNRegisterScriptingInstanceOutputListener
_BNRegisterScriptingInstanceOutputListener.restype = None
_BNRegisterScriptingInstanceOutputListener.argtypes = [
		ctypes.POINTER(BNScriptingInstance),
		ctypes.POINTER(BNScriptingOutputListener),
	]


# noinspection PyPep8Naming
def BNRegisterScriptingInstanceOutputListener(
		instance: ctypes.POINTER(BNScriptingInstance), 
		callbacks: ctypes.POINTER(BNScriptingOutputListener)
		) -> None:
	return _BNRegisterScriptingInstanceOutputListener(instance, callbacks)


# -------------------------------------------------------
# _BNRegisterScriptingProvider

_BNRegisterScriptingProvider = core.BNRegisterScriptingProvider
_BNRegisterScriptingProvider.restype = ctypes.POINTER(BNScriptingProvider)
_BNRegisterScriptingProvider.argtypes = [
		ctypes.c_char_p,
		ctypes.c_char_p,
		ctypes.POINTER(BNScriptingProviderCallbacks),
	]


# noinspection PyPep8Naming
def BNRegisterScriptingProvider(
		name: Optional[str], 
		apiName: Optional[str], 
		callbacks: ctypes.POINTER(BNScriptingProviderCallbacks)
		) -> Optional[ctypes.POINTER(BNScriptingProvider)]:
	result = _BNRegisterScriptingProvider(cstr(name), cstr(apiName), callbacks)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNRegisterSecretsProvider

_BNRegisterSecretsProvider = core.BNRegisterSecretsProvider
_BNRegisterSecretsProvider.restype = ctypes.POINTER(BNSecretsProvider)
_BNRegisterSecretsProvider.argtypes = [
		ctypes.c_char_p,
		ctypes.POINTER(BNSecretsProviderCallbacks),
	]


# noinspection PyPep8Naming
def BNRegisterSecretsProvider(
		name: Optional[str], 
		callbacks: ctypes.POINTER(BNSecretsProviderCallbacks)
		) -> Optional[ctypes.POINTER(BNSecretsProvider)]:
	result = _BNRegisterSecretsProvider(cstr(name), callbacks)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNRegisterTransformType

_BNRegisterTransformType = core.BNRegisterTransformType
_BNRegisterTransformType.restype = ctypes.POINTER(BNTransform)
_BNRegisterTransformType.argtypes = [
		TransformTypeEnum,
		ctypes.c_char_p,
		ctypes.c_char_p,
		ctypes.c_char_p,
		ctypes.POINTER(BNCustomTransform),
	]


# noinspection PyPep8Naming
def BNRegisterTransformType(
		type: TransformType, 
		name: Optional[str], 
		longName: Optional[str], 
		group: Optional[str], 
		xform: ctypes.POINTER(BNCustomTransform)
		) -> Optional[ctypes.POINTER(BNTransform)]:
	result = _BNRegisterTransformType(type, cstr(name), cstr(longName), cstr(group), xform)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNRegisterTypeArchiveNotification

_BNRegisterTypeArchiveNotification = core.BNRegisterTypeArchiveNotification
_BNRegisterTypeArchiveNotification.restype = None
_BNRegisterTypeArchiveNotification.argtypes = [
		ctypes.POINTER(BNTypeArchive),
		ctypes.POINTER(BNTypeArchiveNotification),
	]


# noinspection PyPep8Naming
def BNRegisterTypeArchiveNotification(
		archive: ctypes.POINTER(BNTypeArchive), 
		notification: ctypes.POINTER(BNTypeArchiveNotification)
		) -> None:
	return _BNRegisterTypeArchiveNotification(archive, notification)


# -------------------------------------------------------
# _BNRegisterTypeParser

_BNRegisterTypeParser = core.BNRegisterTypeParser
_BNRegisterTypeParser.restype = ctypes.POINTER(BNTypeParser)
_BNRegisterTypeParser.argtypes = [
		ctypes.c_char_p,
		ctypes.POINTER(BNTypeParserCallbacks),
	]


# noinspection PyPep8Naming
def BNRegisterTypeParser(
		name: Optional[str], 
		callbacks: ctypes.POINTER(BNTypeParserCallbacks)
		) -> Optional[ctypes.POINTER(BNTypeParser)]:
	result = _BNRegisterTypeParser(cstr(name), callbacks)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNRegisterTypePrinter

_BNRegisterTypePrinter = core.BNRegisterTypePrinter
_BNRegisterTypePrinter.restype = ctypes.POINTER(BNTypePrinter)
_BNRegisterTypePrinter.argtypes = [
		ctypes.c_char_p,
		ctypes.POINTER(BNTypePrinterCallbacks),
	]


# noinspection PyPep8Naming
def BNRegisterTypePrinter(
		name: Optional[str], 
		callbacks: ctypes.POINTER(BNTypePrinterCallbacks)
		) -> Optional[ctypes.POINTER(BNTypePrinter)]:
	result = _BNRegisterTypePrinter(cstr(name), callbacks)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNRegisterTypeSpecificDataRenderer

_BNRegisterTypeSpecificDataRenderer = core.BNRegisterTypeSpecificDataRenderer
_BNRegisterTypeSpecificDataRenderer.restype = None
_BNRegisterTypeSpecificDataRenderer.argtypes = [
		ctypes.POINTER(BNDataRendererContainer),
		ctypes.POINTER(BNDataRenderer),
	]


# noinspection PyPep8Naming
def BNRegisterTypeSpecificDataRenderer(
		container: ctypes.POINTER(BNDataRendererContainer), 
		renderer: ctypes.POINTER(BNDataRenderer)
		) -> None:
	return _BNRegisterTypeSpecificDataRenderer(container, renderer)


# -------------------------------------------------------
# _BNRegisterWebsocketProvider

_BNRegisterWebsocketProvider = core.BNRegisterWebsocketProvider
_BNRegisterWebsocketProvider.restype = ctypes.POINTER(BNWebsocketProvider)
_BNRegisterWebsocketProvider.argtypes = [
		ctypes.c_char_p,
		ctypes.POINTER(BNWebsocketProviderCallbacks),
	]


# noinspection PyPep8Naming
def BNRegisterWebsocketProvider(
		name: Optional[str], 
		callbacks: ctypes.POINTER(BNWebsocketProviderCallbacks)
		) -> Optional[ctypes.POINTER(BNWebsocketProvider)]:
	result = _BNRegisterWebsocketProvider(cstr(name), callbacks)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNRegisterWorkflow

_BNRegisterWorkflow = core.BNRegisterWorkflow
_BNRegisterWorkflow.restype = ctypes.c_bool
_BNRegisterWorkflow.argtypes = [
		ctypes.POINTER(BNWorkflow),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNRegisterWorkflow(
		workflow: ctypes.POINTER(BNWorkflow), 
		configuration: Optional[str]
		) -> bool:
	return _BNRegisterWorkflow(workflow, cstr(configuration))


# -------------------------------------------------------
# _BNReleaseAdvancedFunctionAnalysisData

_BNReleaseAdvancedFunctionAnalysisData = core.BNReleaseAdvancedFunctionAnalysisData
_BNReleaseAdvancedFunctionAnalysisData.restype = None
_BNReleaseAdvancedFunctionAnalysisData.argtypes = [
		ctypes.POINTER(BNFunction),
	]


# noinspection PyPep8Naming
def BNReleaseAdvancedFunctionAnalysisData(
		func: ctypes.POINTER(BNFunction)
		) -> None:
	return _BNReleaseAdvancedFunctionAnalysisData(func)


# -------------------------------------------------------
# _BNReleaseAdvancedFunctionAnalysisDataMultiple

_BNReleaseAdvancedFunctionAnalysisDataMultiple = core.BNReleaseAdvancedFunctionAnalysisDataMultiple
_BNReleaseAdvancedFunctionAnalysisDataMultiple.restype = None
_BNReleaseAdvancedFunctionAnalysisDataMultiple.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNReleaseAdvancedFunctionAnalysisDataMultiple(
		func: ctypes.POINTER(BNFunction), 
		count: int
		) -> None:
	return _BNReleaseAdvancedFunctionAnalysisDataMultiple(func, count)


# -------------------------------------------------------
# _BNReleaseEnterpriseServerLicense

_BNReleaseEnterpriseServerLicense = core.BNReleaseEnterpriseServerLicense
_BNReleaseEnterpriseServerLicense.restype = ctypes.c_bool
_BNReleaseEnterpriseServerLicense.argtypes = [
	]


# noinspection PyPep8Naming
def BNReleaseEnterpriseServerLicense(
		) -> bool:
	return _BNReleaseEnterpriseServerLicense()


# -------------------------------------------------------
# _BNRelocationGetArchitecture

_BNRelocationGetArchitecture = core.BNRelocationGetArchitecture
_BNRelocationGetArchitecture.restype = ctypes.POINTER(BNArchitecture)
_BNRelocationGetArchitecture.argtypes = [
		ctypes.POINTER(BNRelocation),
	]


# noinspection PyPep8Naming
def BNRelocationGetArchitecture(
		reloc: ctypes.POINTER(BNRelocation)
		) -> Optional[ctypes.POINTER(BNArchitecture)]:
	result = _BNRelocationGetArchitecture(reloc)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNRelocationGetInfo

_BNRelocationGetInfo = core.BNRelocationGetInfo
_BNRelocationGetInfo.restype = BNRelocationInfo
_BNRelocationGetInfo.argtypes = [
		ctypes.POINTER(BNRelocation),
	]


# noinspection PyPep8Naming
def BNRelocationGetInfo(
		reloc: ctypes.POINTER(BNRelocation)
		) -> BNRelocationInfo:
	return _BNRelocationGetInfo(reloc)


# -------------------------------------------------------
# _BNRelocationGetReloc

_BNRelocationGetReloc = core.BNRelocationGetReloc
_BNRelocationGetReloc.restype = ctypes.c_ulonglong
_BNRelocationGetReloc.argtypes = [
		ctypes.POINTER(BNRelocation),
	]


# noinspection PyPep8Naming
def BNRelocationGetReloc(
		reloc: ctypes.POINTER(BNRelocation)
		) -> int:
	return _BNRelocationGetReloc(reloc)


# -------------------------------------------------------
# _BNRelocationGetSymbol

_BNRelocationGetSymbol = core.BNRelocationGetSymbol
_BNRelocationGetSymbol.restype = ctypes.POINTER(BNSymbol)
_BNRelocationGetSymbol.argtypes = [
		ctypes.POINTER(BNRelocation),
	]


# noinspection PyPep8Naming
def BNRelocationGetSymbol(
		reloc: ctypes.POINTER(BNRelocation)
		) -> Optional[ctypes.POINTER(BNSymbol)]:
	result = _BNRelocationGetSymbol(reloc)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNRelocationGetTarget

_BNRelocationGetTarget = core.BNRelocationGetTarget
_BNRelocationGetTarget.restype = ctypes.c_ulonglong
_BNRelocationGetTarget.argtypes = [
		ctypes.POINTER(BNRelocation),
	]


# noinspection PyPep8Naming
def BNRelocationGetTarget(
		reloc: ctypes.POINTER(BNRelocation)
		) -> int:
	return _BNRelocationGetTarget(reloc)


# -------------------------------------------------------
# _BNRelocationHandlerApplyRelocation

_BNRelocationHandlerApplyRelocation = core.BNRelocationHandlerApplyRelocation
_BNRelocationHandlerApplyRelocation.restype = ctypes.c_bool
_BNRelocationHandlerApplyRelocation.argtypes = [
		ctypes.POINTER(BNRelocationHandler),
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNArchitecture),
		ctypes.POINTER(BNRelocation),
		ctypes.POINTER(ctypes.c_ubyte),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNRelocationHandlerApplyRelocation(
		handler: ctypes.POINTER(BNRelocationHandler), 
		view: ctypes.POINTER(BNBinaryView), 
		arch: ctypes.POINTER(BNArchitecture), 
		reloc: ctypes.POINTER(BNRelocation), 
		dest: ctypes.POINTER(ctypes.c_ubyte), 
		len: int
		) -> bool:
	return _BNRelocationHandlerApplyRelocation(handler, view, arch, reloc, dest, len)


# -------------------------------------------------------
# _BNRelocationHandlerDefaultApplyRelocation

_BNRelocationHandlerDefaultApplyRelocation = core.BNRelocationHandlerDefaultApplyRelocation
_BNRelocationHandlerDefaultApplyRelocation.restype = ctypes.c_bool
_BNRelocationHandlerDefaultApplyRelocation.argtypes = [
		ctypes.POINTER(BNRelocationHandler),
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNArchitecture),
		ctypes.POINTER(BNRelocation),
		ctypes.POINTER(ctypes.c_ubyte),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNRelocationHandlerDefaultApplyRelocation(
		handler: ctypes.POINTER(BNRelocationHandler), 
		view: ctypes.POINTER(BNBinaryView), 
		arch: ctypes.POINTER(BNArchitecture), 
		reloc: ctypes.POINTER(BNRelocation), 
		dest: ctypes.POINTER(ctypes.c_ubyte), 
		len: int
		) -> bool:
	return _BNRelocationHandlerDefaultApplyRelocation(handler, view, arch, reloc, dest, len)


# -------------------------------------------------------
# _BNRelocationHandlerGetOperandForExternalRelocation

_BNRelocationHandlerGetOperandForExternalRelocation = core.BNRelocationHandlerGetOperandForExternalRelocation
_BNRelocationHandlerGetOperandForExternalRelocation.restype = ctypes.c_ulonglong
_BNRelocationHandlerGetOperandForExternalRelocation.argtypes = [
		ctypes.POINTER(BNRelocationHandler),
		ctypes.POINTER(ctypes.c_ubyte),
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
		ctypes.POINTER(BNLowLevelILFunction),
		ctypes.POINTER(BNRelocation),
	]


# noinspection PyPep8Naming
def BNRelocationHandlerGetOperandForExternalRelocation(
		handler: ctypes.POINTER(BNRelocationHandler), 
		data: ctypes.POINTER(ctypes.c_ubyte), 
		addr: int, 
		length: int, 
		il: ctypes.POINTER(BNLowLevelILFunction), 
		relocation: ctypes.POINTER(BNRelocation)
		) -> int:
	return _BNRelocationHandlerGetOperandForExternalRelocation(handler, data, addr, length, il, relocation)


# -------------------------------------------------------
# _BNRelocationHandlerGetRelocationInfo

_BNRelocationHandlerGetRelocationInfo = core.BNRelocationHandlerGetRelocationInfo
_BNRelocationHandlerGetRelocationInfo.restype = ctypes.c_bool
_BNRelocationHandlerGetRelocationInfo.argtypes = [
		ctypes.POINTER(BNRelocationHandler),
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNArchitecture),
		ctypes.POINTER(BNRelocationInfo),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNRelocationHandlerGetRelocationInfo(
		handler: ctypes.POINTER(BNRelocationHandler), 
		data: ctypes.POINTER(BNBinaryView), 
		arch: ctypes.POINTER(BNArchitecture), 
		info: ctypes.POINTER(BNRelocationInfo), 
		infoCount: int
		) -> bool:
	return _BNRelocationHandlerGetRelocationInfo(handler, data, arch, info, infoCount)


# -------------------------------------------------------
# _BNRemoveAnalysisFunction

_BNRemoveAnalysisFunction = core.BNRemoveAnalysisFunction
_BNRemoveAnalysisFunction.restype = None
_BNRemoveAnalysisFunction.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNFunction),
		ctypes.c_bool,
	]


# noinspection PyPep8Naming
def BNRemoveAnalysisFunction(
		view: ctypes.POINTER(BNBinaryView), 
		func: ctypes.POINTER(BNFunction), 
		updateRefs: bool
		) -> None:
	return _BNRemoveAnalysisFunction(view, func, updateRefs)


# -------------------------------------------------------
# _BNRemoveAutoAddressTag

_BNRemoveAutoAddressTag = core.BNRemoveAutoAddressTag
_BNRemoveAutoAddressTag.restype = None
_BNRemoveAutoAddressTag.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNArchitecture),
		ctypes.c_ulonglong,
		ctypes.POINTER(BNTag),
	]


# noinspection PyPep8Naming
def BNRemoveAutoAddressTag(
		func: ctypes.POINTER(BNFunction), 
		arch: ctypes.POINTER(BNArchitecture), 
		addr: int, 
		tag: ctypes.POINTER(BNTag)
		) -> None:
	return _BNRemoveAutoAddressTag(func, arch, addr, tag)


# -------------------------------------------------------
# _BNRemoveAutoAddressTagsOfType

_BNRemoveAutoAddressTagsOfType = core.BNRemoveAutoAddressTagsOfType
_BNRemoveAutoAddressTagsOfType.restype = None
_BNRemoveAutoAddressTagsOfType.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNArchitecture),
		ctypes.c_ulonglong,
		ctypes.POINTER(BNTagType),
	]


# noinspection PyPep8Naming
def BNRemoveAutoAddressTagsOfType(
		func: ctypes.POINTER(BNFunction), 
		arch: ctypes.POINTER(BNArchitecture), 
		addr: int, 
		tagType: ctypes.POINTER(BNTagType)
		) -> None:
	return _BNRemoveAutoAddressTagsOfType(func, arch, addr, tagType)


# -------------------------------------------------------
# _BNRemoveAutoDataTag

_BNRemoveAutoDataTag = core.BNRemoveAutoDataTag
_BNRemoveAutoDataTag.restype = None
_BNRemoveAutoDataTag.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
		ctypes.POINTER(BNTag),
	]


# noinspection PyPep8Naming
def BNRemoveAutoDataTag(
		view: ctypes.POINTER(BNBinaryView), 
		addr: int, 
		tag: ctypes.POINTER(BNTag)
		) -> None:
	return _BNRemoveAutoDataTag(view, addr, tag)


# -------------------------------------------------------
# _BNRemoveAutoDataTagsOfType

_BNRemoveAutoDataTagsOfType = core.BNRemoveAutoDataTagsOfType
_BNRemoveAutoDataTagsOfType.restype = None
_BNRemoveAutoDataTagsOfType.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
		ctypes.POINTER(BNTagType),
	]


# noinspection PyPep8Naming
def BNRemoveAutoDataTagsOfType(
		view: ctypes.POINTER(BNBinaryView), 
		addr: int, 
		tagType: ctypes.POINTER(BNTagType)
		) -> None:
	return _BNRemoveAutoDataTagsOfType(view, addr, tagType)


# -------------------------------------------------------
# _BNRemoveAutoFunctionTag

_BNRemoveAutoFunctionTag = core.BNRemoveAutoFunctionTag
_BNRemoveAutoFunctionTag.restype = None
_BNRemoveAutoFunctionTag.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNTag),
	]


# noinspection PyPep8Naming
def BNRemoveAutoFunctionTag(
		func: ctypes.POINTER(BNFunction), 
		tag: ctypes.POINTER(BNTag)
		) -> None:
	return _BNRemoveAutoFunctionTag(func, tag)


# -------------------------------------------------------
# _BNRemoveAutoFunctionTagsOfType

_BNRemoveAutoFunctionTagsOfType = core.BNRemoveAutoFunctionTagsOfType
_BNRemoveAutoFunctionTagsOfType.restype = None
_BNRemoveAutoFunctionTagsOfType.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNTagType),
	]


# noinspection PyPep8Naming
def BNRemoveAutoFunctionTagsOfType(
		func: ctypes.POINTER(BNFunction), 
		tagType: ctypes.POINTER(BNTagType)
		) -> None:
	return _BNRemoveAutoFunctionTagsOfType(func, tagType)


# -------------------------------------------------------
# _BNRemoveAutoSection

_BNRemoveAutoSection = core.BNRemoveAutoSection
_BNRemoveAutoSection.restype = None
_BNRemoveAutoSection.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNRemoveAutoSection(
		view: ctypes.POINTER(BNBinaryView), 
		name: Optional[str]
		) -> None:
	return _BNRemoveAutoSection(view, cstr(name))


# -------------------------------------------------------
# _BNRemoveAutoSegment

_BNRemoveAutoSegment = core.BNRemoveAutoSegment
_BNRemoveAutoSegment.restype = None
_BNRemoveAutoSegment.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNRemoveAutoSegment(
		view: ctypes.POINTER(BNBinaryView), 
		start: int, 
		length: int
		) -> None:
	return _BNRemoveAutoSegment(view, start, length)


# -------------------------------------------------------
# _BNRemoveComponent

_BNRemoveComponent = core.BNRemoveComponent
_BNRemoveComponent.restype = ctypes.c_bool
_BNRemoveComponent.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNComponent),
	]


# noinspection PyPep8Naming
def BNRemoveComponent(
		view: ctypes.POINTER(BNBinaryView), 
		component: ctypes.POINTER(BNComponent)
		) -> bool:
	return _BNRemoveComponent(view, component)


# -------------------------------------------------------
# _BNRemoveComponentByGuid

_BNRemoveComponentByGuid = core.BNRemoveComponentByGuid
_BNRemoveComponentByGuid.restype = ctypes.c_bool
_BNRemoveComponentByGuid.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNRemoveComponentByGuid(
		view: ctypes.POINTER(BNBinaryView), 
		guid: Optional[str]
		) -> bool:
	return _BNRemoveComponentByGuid(view, cstr(guid))


# -------------------------------------------------------
# _BNRemoveDatabaseSnapshot

_BNRemoveDatabaseSnapshot = core.BNRemoveDatabaseSnapshot
_BNRemoveDatabaseSnapshot.restype = ctypes.c_bool
_BNRemoveDatabaseSnapshot.argtypes = [
		ctypes.POINTER(BNDatabase),
		ctypes.c_longlong,
	]


# noinspection PyPep8Naming
def BNRemoveDatabaseSnapshot(
		database: ctypes.POINTER(BNDatabase), 
		id: int
		) -> bool:
	return _BNRemoveDatabaseSnapshot(database, id)


# -------------------------------------------------------
# _BNRemoveDebugDataVariableByAddress

_BNRemoveDebugDataVariableByAddress = core.BNRemoveDebugDataVariableByAddress
_BNRemoveDebugDataVariableByAddress.restype = ctypes.c_bool
_BNRemoveDebugDataVariableByAddress.argtypes = [
		ctypes.POINTER(BNDebugInfo),
		ctypes.c_char_p,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNRemoveDebugDataVariableByAddress(
		debugInfo: ctypes.POINTER(BNDebugInfo), 
		parserName: Optional[str], 
		address: int
		) -> bool:
	return _BNRemoveDebugDataVariableByAddress(debugInfo, cstr(parserName), address)


# -------------------------------------------------------
# _BNRemoveDebugFunctionByIndex

_BNRemoveDebugFunctionByIndex = core.BNRemoveDebugFunctionByIndex
_BNRemoveDebugFunctionByIndex.restype = ctypes.c_bool
_BNRemoveDebugFunctionByIndex.argtypes = [
		ctypes.POINTER(BNDebugInfo),
		ctypes.c_char_p,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNRemoveDebugFunctionByIndex(
		debugInfo: ctypes.POINTER(BNDebugInfo), 
		parserName: Optional[str], 
		index: int
		) -> bool:
	return _BNRemoveDebugFunctionByIndex(debugInfo, cstr(parserName), index)


# -------------------------------------------------------
# _BNRemoveDebugParserDataVariables

_BNRemoveDebugParserDataVariables = core.BNRemoveDebugParserDataVariables
_BNRemoveDebugParserDataVariables.restype = ctypes.c_bool
_BNRemoveDebugParserDataVariables.argtypes = [
		ctypes.POINTER(BNDebugInfo),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNRemoveDebugParserDataVariables(
		debugInfo: ctypes.POINTER(BNDebugInfo), 
		parserName: Optional[str]
		) -> bool:
	return _BNRemoveDebugParserDataVariables(debugInfo, cstr(parserName))


# -------------------------------------------------------
# _BNRemoveDebugParserFunctions

_BNRemoveDebugParserFunctions = core.BNRemoveDebugParserFunctions
_BNRemoveDebugParserFunctions.restype = ctypes.c_bool
_BNRemoveDebugParserFunctions.argtypes = [
		ctypes.POINTER(BNDebugInfo),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNRemoveDebugParserFunctions(
		debugInfo: ctypes.POINTER(BNDebugInfo), 
		parserName: Optional[str]
		) -> bool:
	return _BNRemoveDebugParserFunctions(debugInfo, cstr(parserName))


# -------------------------------------------------------
# _BNRemoveDebugParserInfo

_BNRemoveDebugParserInfo = core.BNRemoveDebugParserInfo
_BNRemoveDebugParserInfo.restype = ctypes.c_bool
_BNRemoveDebugParserInfo.argtypes = [
		ctypes.POINTER(BNDebugInfo),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNRemoveDebugParserInfo(
		debugInfo: ctypes.POINTER(BNDebugInfo), 
		parserName: Optional[str]
		) -> bool:
	return _BNRemoveDebugParserInfo(debugInfo, cstr(parserName))


# -------------------------------------------------------
# _BNRemoveDebugParserTypes

_BNRemoveDebugParserTypes = core.BNRemoveDebugParserTypes
_BNRemoveDebugParserTypes.restype = ctypes.c_bool
_BNRemoveDebugParserTypes.argtypes = [
		ctypes.POINTER(BNDebugInfo),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNRemoveDebugParserTypes(
		debugInfo: ctypes.POINTER(BNDebugInfo), 
		parserName: Optional[str]
		) -> bool:
	return _BNRemoveDebugParserTypes(debugInfo, cstr(parserName))


# -------------------------------------------------------
# _BNRemoveDebugTypeByName

_BNRemoveDebugTypeByName = core.BNRemoveDebugTypeByName
_BNRemoveDebugTypeByName.restype = ctypes.c_bool
_BNRemoveDebugTypeByName.argtypes = [
		ctypes.POINTER(BNDebugInfo),
		ctypes.c_char_p,
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNRemoveDebugTypeByName(
		debugInfo: ctypes.POINTER(BNDebugInfo), 
		parserName: Optional[str], 
		typeName: Optional[str]
		) -> bool:
	return _BNRemoveDebugTypeByName(debugInfo, cstr(parserName), cstr(typeName))


# -------------------------------------------------------
# _BNRemoveEnumerationBuilderMember

_BNRemoveEnumerationBuilderMember = core.BNRemoveEnumerationBuilderMember
_BNRemoveEnumerationBuilderMember.restype = None
_BNRemoveEnumerationBuilderMember.argtypes = [
		ctypes.POINTER(BNEnumerationBuilder),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNRemoveEnumerationBuilderMember(
		e: ctypes.POINTER(BNEnumerationBuilder), 
		idx: int
		) -> None:
	return _BNRemoveEnumerationBuilderMember(e, idx)


# -------------------------------------------------------
# _BNRemoveExpressionParserMagicValue

_BNRemoveExpressionParserMagicValue = core.BNRemoveExpressionParserMagicValue
_BNRemoveExpressionParserMagicValue.restype = None
_BNRemoveExpressionParserMagicValue.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNRemoveExpressionParserMagicValue(
		view: ctypes.POINTER(BNBinaryView), 
		name: Optional[str]
		) -> None:
	return _BNRemoveExpressionParserMagicValue(view, cstr(name))


# -------------------------------------------------------
# _BNRemoveExpressionParserMagicValues

_BNRemoveExpressionParserMagicValues = core.BNRemoveExpressionParserMagicValues
_BNRemoveExpressionParserMagicValues.restype = None
_BNRemoveExpressionParserMagicValues.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(ctypes.c_char_p),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNRemoveExpressionParserMagicValues(
		view: ctypes.POINTER(BNBinaryView), 
		names: ctypes.POINTER(ctypes.c_char_p), 
		count: int
		) -> None:
	return _BNRemoveExpressionParserMagicValues(view, names, count)


# -------------------------------------------------------
# _BNRemoveStructureBuilderMember

_BNRemoveStructureBuilderMember = core.BNRemoveStructureBuilderMember
_BNRemoveStructureBuilderMember.restype = None
_BNRemoveStructureBuilderMember.argtypes = [
		ctypes.POINTER(BNStructureBuilder),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNRemoveStructureBuilderMember(
		s: ctypes.POINTER(BNStructureBuilder), 
		idx: int
		) -> None:
	return _BNRemoveStructureBuilderMember(s, idx)


# -------------------------------------------------------
# _BNRemoveTag

_BNRemoveTag = core.BNRemoveTag
_BNRemoveTag.restype = None
_BNRemoveTag.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNTag),
		ctypes.c_bool,
	]


# noinspection PyPep8Naming
def BNRemoveTag(
		view: ctypes.POINTER(BNBinaryView), 
		tag: ctypes.POINTER(BNTag), 
		user: bool
		) -> None:
	return _BNRemoveTag(view, tag, user)


# -------------------------------------------------------
# _BNRemoveTagReference

_BNRemoveTagReference = core.BNRemoveTagReference
_BNRemoveTagReference.restype = None
_BNRemoveTagReference.argtypes = [
		ctypes.POINTER(BNBinaryView),
		BNTagReference,
	]


# noinspection PyPep8Naming
def BNRemoveTagReference(
		view: ctypes.POINTER(BNBinaryView), 
		ref: BNTagReference
		) -> None:
	return _BNRemoveTagReference(view, ref)


# -------------------------------------------------------
# _BNRemoveTagType

_BNRemoveTagType = core.BNRemoveTagType
_BNRemoveTagType.restype = None
_BNRemoveTagType.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNTagType),
	]


# noinspection PyPep8Naming
def BNRemoveTagType(
		view: ctypes.POINTER(BNBinaryView), 
		tagType: ctypes.POINTER(BNTagType)
		) -> None:
	return _BNRemoveTagType(view, tagType)


# -------------------------------------------------------
# _BNRemoveUserAddressTag

_BNRemoveUserAddressTag = core.BNRemoveUserAddressTag
_BNRemoveUserAddressTag.restype = None
_BNRemoveUserAddressTag.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNArchitecture),
		ctypes.c_ulonglong,
		ctypes.POINTER(BNTag),
	]


# noinspection PyPep8Naming
def BNRemoveUserAddressTag(
		func: ctypes.POINTER(BNFunction), 
		arch: ctypes.POINTER(BNArchitecture), 
		addr: int, 
		tag: ctypes.POINTER(BNTag)
		) -> None:
	return _BNRemoveUserAddressTag(func, arch, addr, tag)


# -------------------------------------------------------
# _BNRemoveUserAddressTagsOfType

_BNRemoveUserAddressTagsOfType = core.BNRemoveUserAddressTagsOfType
_BNRemoveUserAddressTagsOfType.restype = None
_BNRemoveUserAddressTagsOfType.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNArchitecture),
		ctypes.c_ulonglong,
		ctypes.POINTER(BNTagType),
	]


# noinspection PyPep8Naming
def BNRemoveUserAddressTagsOfType(
		func: ctypes.POINTER(BNFunction), 
		arch: ctypes.POINTER(BNArchitecture), 
		addr: int, 
		tagType: ctypes.POINTER(BNTagType)
		) -> None:
	return _BNRemoveUserAddressTagsOfType(func, arch, addr, tagType)


# -------------------------------------------------------
# _BNRemoveUserCodeReference

_BNRemoveUserCodeReference = core.BNRemoveUserCodeReference
_BNRemoveUserCodeReference.restype = None
_BNRemoveUserCodeReference.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNArchitecture),
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNRemoveUserCodeReference(
		func: ctypes.POINTER(BNFunction), 
		fromArch: ctypes.POINTER(BNArchitecture), 
		fromAddr: int, 
		toAddr: int
		) -> None:
	return _BNRemoveUserCodeReference(func, fromArch, fromAddr, toAddr)


# -------------------------------------------------------
# _BNRemoveUserDataReference

_BNRemoveUserDataReference = core.BNRemoveUserDataReference
_BNRemoveUserDataReference.restype = None
_BNRemoveUserDataReference.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNRemoveUserDataReference(
		view: ctypes.POINTER(BNBinaryView), 
		fromAddr: int, 
		toAddr: int
		) -> None:
	return _BNRemoveUserDataReference(view, fromAddr, toAddr)


# -------------------------------------------------------
# _BNRemoveUserDataTag

_BNRemoveUserDataTag = core.BNRemoveUserDataTag
_BNRemoveUserDataTag.restype = None
_BNRemoveUserDataTag.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
		ctypes.POINTER(BNTag),
	]


# noinspection PyPep8Naming
def BNRemoveUserDataTag(
		view: ctypes.POINTER(BNBinaryView), 
		addr: int, 
		tag: ctypes.POINTER(BNTag)
		) -> None:
	return _BNRemoveUserDataTag(view, addr, tag)


# -------------------------------------------------------
# _BNRemoveUserDataTagsOfType

_BNRemoveUserDataTagsOfType = core.BNRemoveUserDataTagsOfType
_BNRemoveUserDataTagsOfType.restype = None
_BNRemoveUserDataTagsOfType.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
		ctypes.POINTER(BNTagType),
	]


# noinspection PyPep8Naming
def BNRemoveUserDataTagsOfType(
		view: ctypes.POINTER(BNBinaryView), 
		addr: int, 
		tagType: ctypes.POINTER(BNTagType)
		) -> None:
	return _BNRemoveUserDataTagsOfType(view, addr, tagType)


# -------------------------------------------------------
# _BNRemoveUserFunction

_BNRemoveUserFunction = core.BNRemoveUserFunction
_BNRemoveUserFunction.restype = None
_BNRemoveUserFunction.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNFunction),
	]


# noinspection PyPep8Naming
def BNRemoveUserFunction(
		view: ctypes.POINTER(BNBinaryView), 
		func: ctypes.POINTER(BNFunction)
		) -> None:
	return _BNRemoveUserFunction(view, func)


# -------------------------------------------------------
# _BNRemoveUserFunctionTag

_BNRemoveUserFunctionTag = core.BNRemoveUserFunctionTag
_BNRemoveUserFunctionTag.restype = None
_BNRemoveUserFunctionTag.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNTag),
	]


# noinspection PyPep8Naming
def BNRemoveUserFunctionTag(
		func: ctypes.POINTER(BNFunction), 
		tag: ctypes.POINTER(BNTag)
		) -> None:
	return _BNRemoveUserFunctionTag(func, tag)


# -------------------------------------------------------
# _BNRemoveUserFunctionTagsOfType

_BNRemoveUserFunctionTagsOfType = core.BNRemoveUserFunctionTagsOfType
_BNRemoveUserFunctionTagsOfType.restype = None
_BNRemoveUserFunctionTagsOfType.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNTagType),
	]


# noinspection PyPep8Naming
def BNRemoveUserFunctionTagsOfType(
		func: ctypes.POINTER(BNFunction), 
		tagType: ctypes.POINTER(BNTagType)
		) -> None:
	return _BNRemoveUserFunctionTagsOfType(func, tagType)


# -------------------------------------------------------
# _BNRemoveUserSection

_BNRemoveUserSection = core.BNRemoveUserSection
_BNRemoveUserSection.restype = None
_BNRemoveUserSection.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNRemoveUserSection(
		view: ctypes.POINTER(BNBinaryView), 
		name: Optional[str]
		) -> None:
	return _BNRemoveUserSection(view, cstr(name))


# -------------------------------------------------------
# _BNRemoveUserSegment

_BNRemoveUserSegment = core.BNRemoveUserSegment
_BNRemoveUserSegment.restype = None
_BNRemoveUserSegment.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNRemoveUserSegment(
		view: ctypes.POINTER(BNBinaryView), 
		start: int, 
		length: int
		) -> None:
	return _BNRemoveUserSegment(view, start, length)


# -------------------------------------------------------
# _BNRemoveUserTypeFieldReference

_BNRemoveUserTypeFieldReference = core.BNRemoveUserTypeFieldReference
_BNRemoveUserTypeFieldReference.restype = None
_BNRemoveUserTypeFieldReference.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNArchitecture),
		ctypes.c_ulonglong,
		ctypes.POINTER(BNQualifiedName),
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNRemoveUserTypeFieldReference(
		func: ctypes.POINTER(BNFunction), 
		fromArch: ctypes.POINTER(BNArchitecture), 
		fromAddr: int, 
		name: ctypes.POINTER(BNQualifiedName), 
		offset: int, 
		size: int
		) -> None:
	return _BNRemoveUserTypeFieldReference(func, fromArch, fromAddr, name, offset, size)


# -------------------------------------------------------
# _BNRemoveUserTypeReference

_BNRemoveUserTypeReference = core.BNRemoveUserTypeReference
_BNRemoveUserTypeReference.restype = None
_BNRemoveUserTypeReference.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNArchitecture),
		ctypes.c_ulonglong,
		ctypes.POINTER(BNQualifiedName),
	]


# noinspection PyPep8Naming
def BNRemoveUserTypeReference(
		func: ctypes.POINTER(BNFunction), 
		fromArch: ctypes.POINTER(BNArchitecture), 
		fromAddr: int, 
		name: ctypes.POINTER(BNQualifiedName)
		) -> None:
	return _BNRemoveUserTypeReference(func, fromArch, fromAddr, name)


# -------------------------------------------------------
# _BNRemoveViewData

_BNRemoveViewData = core.BNRemoveViewData
_BNRemoveViewData.restype = ctypes.c_ulonglong
_BNRemoveViewData.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNRemoveViewData(
		view: ctypes.POINTER(BNBinaryView), 
		offset: int, 
		len: int
		) -> int:
	return _BNRemoveViewData(view, offset, len)


# -------------------------------------------------------
# _BNRenameAnalysisType

_BNRenameAnalysisType = core.BNRenameAnalysisType
_BNRenameAnalysisType.restype = None
_BNRenameAnalysisType.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNQualifiedName),
		ctypes.POINTER(BNQualifiedName),
	]


# noinspection PyPep8Naming
def BNRenameAnalysisType(
		view: ctypes.POINTER(BNBinaryView), 
		oldName: ctypes.POINTER(BNQualifiedName), 
		newName: ctypes.POINTER(BNQualifiedName)
		) -> None:
	return _BNRenameAnalysisType(view, oldName, newName)


# -------------------------------------------------------
# _BNRenameFile

_BNRenameFile = core.BNRenameFile
_BNRenameFile.restype = ctypes.c_bool
_BNRenameFile.argtypes = [
		ctypes.c_char_p,
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNRenameFile(
		source: Optional[str], 
		dest: Optional[str]
		) -> bool:
	return _BNRenameFile(cstr(source), cstr(dest))


# -------------------------------------------------------
# _BNRenameTypeArchiveType

_BNRenameTypeArchiveType = core.BNRenameTypeArchiveType
_BNRenameTypeArchiveType.restype = ctypes.c_bool
_BNRenameTypeArchiveType.argtypes = [
		ctypes.POINTER(BNTypeArchive),
		ctypes.c_char_p,
		ctypes.POINTER(BNQualifiedName),
	]


# noinspection PyPep8Naming
def BNRenameTypeArchiveType(
		archive: ctypes.POINTER(BNTypeArchive), 
		id: Optional[str], 
		newName: ctypes.POINTER(BNQualifiedName)
		) -> bool:
	return _BNRenameTypeArchiveType(archive, cstr(id), newName)


# -------------------------------------------------------
# _BNRenderLinesForData

_BNRenderLinesForData = core.BNRenderLinesForData
_BNRenderLinesForData.restype = ctypes.POINTER(BNDisassemblyTextLine)
_BNRenderLinesForData.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
		ctypes.POINTER(BNType),
		ctypes.POINTER(BNInstructionTextToken),
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
		ctypes.POINTER(BNTypeContext),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNRenderLinesForData(
		data: ctypes.POINTER(BNBinaryView), 
		addr: int, 
		type: ctypes.POINTER(BNType), 
		prefix: ctypes.POINTER(BNInstructionTextToken), 
		prefixCount: int, 
		width: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong), 
		typeCtx: ctypes.POINTER(BNTypeContext), 
		ctxCount: int
		) -> Optional[ctypes.POINTER(BNDisassemblyTextLine)]:
	result = _BNRenderLinesForData(data, addr, type, prefix, prefixCount, width, count, typeCtx, ctxCount)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNReplaceEnumerationBuilderMember

_BNReplaceEnumerationBuilderMember = core.BNReplaceEnumerationBuilderMember
_BNReplaceEnumerationBuilderMember.restype = None
_BNReplaceEnumerationBuilderMember.argtypes = [
		ctypes.POINTER(BNEnumerationBuilder),
		ctypes.c_ulonglong,
		ctypes.c_char_p,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNReplaceEnumerationBuilderMember(
		e: ctypes.POINTER(BNEnumerationBuilder), 
		idx: int, 
		name: Optional[str], 
		value: int
		) -> None:
	return _BNReplaceEnumerationBuilderMember(e, idx, cstr(name), value)


# -------------------------------------------------------
# _BNReplaceHighLevelILExpr

_BNReplaceHighLevelILExpr = core.BNReplaceHighLevelILExpr
_BNReplaceHighLevelILExpr.restype = None
_BNReplaceHighLevelILExpr.argtypes = [
		ctypes.POINTER(BNHighLevelILFunction),
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNReplaceHighLevelILExpr(
		func: ctypes.POINTER(BNHighLevelILFunction), 
		expr: int, 
		newExpr: int
		) -> None:
	return _BNReplaceHighLevelILExpr(func, expr, newExpr)


# -------------------------------------------------------
# _BNReplaceLowLevelILExpr

_BNReplaceLowLevelILExpr = core.BNReplaceLowLevelILExpr
_BNReplaceLowLevelILExpr.restype = None
_BNReplaceLowLevelILExpr.argtypes = [
		ctypes.POINTER(BNLowLevelILFunction),
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNReplaceLowLevelILExpr(
		func: ctypes.POINTER(BNLowLevelILFunction), 
		expr: int, 
		newExpr: int
		) -> None:
	return _BNReplaceLowLevelILExpr(func, expr, newExpr)


# -------------------------------------------------------
# _BNReplaceMediumLevelILExpr

_BNReplaceMediumLevelILExpr = core.BNReplaceMediumLevelILExpr
_BNReplaceMediumLevelILExpr.restype = None
_BNReplaceMediumLevelILExpr.argtypes = [
		ctypes.POINTER(BNMediumLevelILFunction),
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNReplaceMediumLevelILExpr(
		func: ctypes.POINTER(BNMediumLevelILFunction), 
		expr: int, 
		newExpr: int
		) -> None:
	return _BNReplaceMediumLevelILExpr(func, expr, newExpr)


# -------------------------------------------------------
# _BNReplaceMediumLevelILInstruction

_BNReplaceMediumLevelILInstruction = core.BNReplaceMediumLevelILInstruction
_BNReplaceMediumLevelILInstruction.restype = None
_BNReplaceMediumLevelILInstruction.argtypes = [
		ctypes.POINTER(BNMediumLevelILFunction),
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNReplaceMediumLevelILInstruction(
		func: ctypes.POINTER(BNMediumLevelILFunction), 
		instr: int, 
		expr: int
		) -> None:
	return _BNReplaceMediumLevelILInstruction(func, instr, expr)


# -------------------------------------------------------
# _BNReplaceStructureBuilderMember

_BNReplaceStructureBuilderMember = core.BNReplaceStructureBuilderMember
_BNReplaceStructureBuilderMember.restype = None
_BNReplaceStructureBuilderMember.argtypes = [
		ctypes.POINTER(BNStructureBuilder),
		ctypes.c_ulonglong,
		ctypes.POINTER(BNTypeWithConfidence),
		ctypes.c_char_p,
		ctypes.c_bool,
	]


# noinspection PyPep8Naming
def BNReplaceStructureBuilderMember(
		s: ctypes.POINTER(BNStructureBuilder), 
		idx: int, 
		type: ctypes.POINTER(BNTypeWithConfidence), 
		name: Optional[str], 
		overwriteExisting: bool
		) -> None:
	return _BNReplaceStructureBuilderMember(s, idx, type, cstr(name), overwriteExisting)


# -------------------------------------------------------
# _BNRepositoryFreePluginDirectoryList

_BNRepositoryFreePluginDirectoryList = core.BNRepositoryFreePluginDirectoryList
_BNRepositoryFreePluginDirectoryList.restype = None
_BNRepositoryFreePluginDirectoryList.argtypes = [
		ctypes.POINTER(ctypes.c_char_p),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNRepositoryFreePluginDirectoryList(
		list: ctypes.POINTER(ctypes.c_char_p), 
		count: int
		) -> None:
	return _BNRepositoryFreePluginDirectoryList(list, count)


# -------------------------------------------------------
# _BNRepositoryGetPluginByPath

_BNRepositoryGetPluginByPath = core.BNRepositoryGetPluginByPath
_BNRepositoryGetPluginByPath.restype = ctypes.POINTER(BNRepoPlugin)
_BNRepositoryGetPluginByPath.argtypes = [
		ctypes.POINTER(BNRepository),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNRepositoryGetPluginByPath(
		r: ctypes.POINTER(BNRepository), 
		pluginPath: Optional[str]
		) -> Optional[ctypes.POINTER(BNRepoPlugin)]:
	result = _BNRepositoryGetPluginByPath(r, cstr(pluginPath))
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNRepositoryGetPlugins

_BNRepositoryGetPlugins = core.BNRepositoryGetPlugins
_BNRepositoryGetPlugins.restype = ctypes.POINTER(ctypes.POINTER(BNRepoPlugin))
_BNRepositoryGetPlugins.argtypes = [
		ctypes.POINTER(BNRepository),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNRepositoryGetPlugins(
		r: ctypes.POINTER(BNRepository), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.POINTER(BNRepoPlugin))]:
	result = _BNRepositoryGetPlugins(r, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNRepositoryGetPluginsPath

_BNRepositoryGetPluginsPath = core.BNRepositoryGetPluginsPath
_BNRepositoryGetPluginsPath.restype = ctypes.POINTER(ctypes.c_byte)
_BNRepositoryGetPluginsPath.argtypes = [
		ctypes.POINTER(BNRepository),
	]


# noinspection PyPep8Naming
def BNRepositoryGetPluginsPath(
		r: ctypes.POINTER(BNRepository)
		) -> Optional[Optional[str]]:
	result = _BNRepositoryGetPluginsPath(r)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNRepositoryGetRepoPath

_BNRepositoryGetRepoPath = core.BNRepositoryGetRepoPath
_BNRepositoryGetRepoPath.restype = ctypes.POINTER(ctypes.c_byte)
_BNRepositoryGetRepoPath.argtypes = [
		ctypes.POINTER(BNRepository),
	]


# noinspection PyPep8Naming
def BNRepositoryGetRepoPath(
		r: ctypes.POINTER(BNRepository)
		) -> Optional[Optional[str]]:
	result = _BNRepositoryGetRepoPath(r)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNRepositoryGetRepositoryByPath

_BNRepositoryGetRepositoryByPath = core.BNRepositoryGetRepositoryByPath
_BNRepositoryGetRepositoryByPath.restype = ctypes.POINTER(BNRepository)
_BNRepositoryGetRepositoryByPath.argtypes = [
		ctypes.POINTER(BNRepositoryManager),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNRepositoryGetRepositoryByPath(
		r: ctypes.POINTER(BNRepositoryManager), 
		repoPath: Optional[str]
		) -> Optional[ctypes.POINTER(BNRepository)]:
	result = _BNRepositoryGetRepositoryByPath(r, cstr(repoPath))
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNRepositoryGetUrl

_BNRepositoryGetUrl = core.BNRepositoryGetUrl
_BNRepositoryGetUrl.restype = ctypes.POINTER(ctypes.c_byte)
_BNRepositoryGetUrl.argtypes = [
		ctypes.POINTER(BNRepository),
	]


# noinspection PyPep8Naming
def BNRepositoryGetUrl(
		r: ctypes.POINTER(BNRepository)
		) -> Optional[Optional[str]]:
	result = _BNRepositoryGetUrl(r)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNRepositoryManagerAddRepository

_BNRepositoryManagerAddRepository = core.BNRepositoryManagerAddRepository
_BNRepositoryManagerAddRepository.restype = ctypes.c_bool
_BNRepositoryManagerAddRepository.argtypes = [
		ctypes.POINTER(BNRepositoryManager),
		ctypes.c_char_p,
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNRepositoryManagerAddRepository(
		r: ctypes.POINTER(BNRepositoryManager), 
		url: Optional[str], 
		repoPath: Optional[str]
		) -> bool:
	return _BNRepositoryManagerAddRepository(r, cstr(url), cstr(repoPath))


# -------------------------------------------------------
# _BNRepositoryManagerCheckForUpdates

_BNRepositoryManagerCheckForUpdates = core.BNRepositoryManagerCheckForUpdates
_BNRepositoryManagerCheckForUpdates.restype = ctypes.c_bool
_BNRepositoryManagerCheckForUpdates.argtypes = [
		ctypes.POINTER(BNRepositoryManager),
	]


# noinspection PyPep8Naming
def BNRepositoryManagerCheckForUpdates(
		r: ctypes.POINTER(BNRepositoryManager)
		) -> bool:
	return _BNRepositoryManagerCheckForUpdates(r)


# -------------------------------------------------------
# _BNRepositoryManagerGetDefaultRepository

_BNRepositoryManagerGetDefaultRepository = core.BNRepositoryManagerGetDefaultRepository
_BNRepositoryManagerGetDefaultRepository.restype = ctypes.POINTER(BNRepository)
_BNRepositoryManagerGetDefaultRepository.argtypes = [
		ctypes.POINTER(BNRepositoryManager),
	]


# noinspection PyPep8Naming
def BNRepositoryManagerGetDefaultRepository(
		r: ctypes.POINTER(BNRepositoryManager)
		) -> Optional[ctypes.POINTER(BNRepository)]:
	result = _BNRepositoryManagerGetDefaultRepository(r)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNRepositoryManagerGetRepositories

_BNRepositoryManagerGetRepositories = core.BNRepositoryManagerGetRepositories
_BNRepositoryManagerGetRepositories.restype = ctypes.POINTER(ctypes.POINTER(BNRepository))
_BNRepositoryManagerGetRepositories.argtypes = [
		ctypes.POINTER(BNRepositoryManager),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNRepositoryManagerGetRepositories(
		r: ctypes.POINTER(BNRepositoryManager), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.POINTER(BNRepository))]:
	result = _BNRepositoryManagerGetRepositories(r, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNRequestAdvancedFunctionAnalysisData

_BNRequestAdvancedFunctionAnalysisData = core.BNRequestAdvancedFunctionAnalysisData
_BNRequestAdvancedFunctionAnalysisData.restype = None
_BNRequestAdvancedFunctionAnalysisData.argtypes = [
		ctypes.POINTER(BNFunction),
	]


# noinspection PyPep8Naming
def BNRequestAdvancedFunctionAnalysisData(
		func: ctypes.POINTER(BNFunction)
		) -> None:
	return _BNRequestAdvancedFunctionAnalysisData(func)


# -------------------------------------------------------
# _BNRequestFunctionDebugReport

_BNRequestFunctionDebugReport = core.BNRequestFunctionDebugReport
_BNRequestFunctionDebugReport.restype = None
_BNRequestFunctionDebugReport.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNRequestFunctionDebugReport(
		func: ctypes.POINTER(BNFunction), 
		name: Optional[str]
		) -> None:
	return _BNRequestFunctionDebugReport(func, cstr(name))


# -------------------------------------------------------
# _BNResetDisassemblyTextRendererDeduplicatedComments

_BNResetDisassemblyTextRendererDeduplicatedComments = core.BNResetDisassemblyTextRendererDeduplicatedComments
_BNResetDisassemblyTextRendererDeduplicatedComments.restype = None
_BNResetDisassemblyTextRendererDeduplicatedComments.argtypes = [
		ctypes.POINTER(BNDisassemblyTextRenderer),
	]


# noinspection PyPep8Naming
def BNResetDisassemblyTextRendererDeduplicatedComments(
		renderer: ctypes.POINTER(BNDisassemblyTextRenderer)
		) -> None:
	return _BNResetDisassemblyTextRendererDeduplicatedComments(renderer)


# -------------------------------------------------------
# _BNRevertUndoActions

_BNRevertUndoActions = core.BNRevertUndoActions
_BNRevertUndoActions.restype = None
_BNRevertUndoActions.argtypes = [
		ctypes.POINTER(BNFileMetadata),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNRevertUndoActions(
		file: ctypes.POINTER(BNFileMetadata), 
		id: Optional[str]
		) -> None:
	return _BNRevertUndoActions(file, cstr(id))


# -------------------------------------------------------
# _BNRunProgressDialog

_BNRunProgressDialog = core.BNRunProgressDialog
_BNRunProgressDialog.restype = ctypes.c_bool
_BNRunProgressDialog.argtypes = [
		ctypes.c_char_p,
		ctypes.c_bool,
		ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong), ctypes.c_void_p),
		ctypes.c_void_p,
	]


# noinspection PyPep8Naming
def BNRunProgressDialog(
		title: Optional[str], 
		canCancel: bool, 
		task: ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong), ctypes.c_void_p), 
		taskCtxt: Optional[ctypes.c_void_p]
		) -> bool:
	return _BNRunProgressDialog(cstr(title), canCancel, task, taskCtxt)


# -------------------------------------------------------
# _BNRustSimplifyStrToFQN

_BNRustSimplifyStrToFQN = core.BNRustSimplifyStrToFQN
_BNRustSimplifyStrToFQN.restype = BNQualifiedName
_BNRustSimplifyStrToFQN.argtypes = [
		ctypes.c_char_p,
		ctypes.c_bool,
	]


# noinspection PyPep8Naming
def BNRustSimplifyStrToFQN(
		arg0: Optional[str], 
		arg1: bool
		) -> BNQualifiedName:
	return _BNRustSimplifyStrToFQN(cstr(arg0), arg1)


# -------------------------------------------------------
# _BNRustSimplifyStrToStr

_BNRustSimplifyStrToStr = core.BNRustSimplifyStrToStr
_BNRustSimplifyStrToStr.restype = ctypes.POINTER(ctypes.c_byte)
_BNRustSimplifyStrToStr.argtypes = [
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNRustSimplifyStrToStr(
		arg0: Optional[str]
		) -> Optional[Optional[str]]:
	result = _BNRustSimplifyStrToStr(cstr(arg0))
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNSaveAutoSnapshot

_BNSaveAutoSnapshot = core.BNSaveAutoSnapshot
_BNSaveAutoSnapshot.restype = ctypes.c_bool
_BNSaveAutoSnapshot.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNSaveSettings),
	]


# noinspection PyPep8Naming
def BNSaveAutoSnapshot(
		data: ctypes.POINTER(BNBinaryView), 
		settings: ctypes.POINTER(BNSaveSettings)
		) -> bool:
	return _BNSaveAutoSnapshot(data, settings)


# -------------------------------------------------------
# _BNSaveAutoSnapshotWithProgress

_BNSaveAutoSnapshotWithProgress = core.BNSaveAutoSnapshotWithProgress
_BNSaveAutoSnapshotWithProgress.restype = ctypes.c_bool
_BNSaveAutoSnapshotWithProgress.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_void_p,
		ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong),
		ctypes.POINTER(BNSaveSettings),
	]


# noinspection PyPep8Naming
def BNSaveAutoSnapshotWithProgress(
		data: ctypes.POINTER(BNBinaryView), 
		ctxt: Optional[ctypes.c_void_p], 
		progress: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong), 
		settings: ctypes.POINTER(BNSaveSettings)
		) -> bool:
	return _BNSaveAutoSnapshotWithProgress(data, ctxt, progress, settings)


# -------------------------------------------------------
# _BNSaveLastRun

_BNSaveLastRun = core.BNSaveLastRun
_BNSaveLastRun.restype = None
_BNSaveLastRun.argtypes = [
	]


# noinspection PyPep8Naming
def BNSaveLastRun(
		) -> None:
	return _BNSaveLastRun()


# -------------------------------------------------------
# _BNSaveToFile

_BNSaveToFile = core.BNSaveToFile
_BNSaveToFile.restype = ctypes.c_bool
_BNSaveToFile.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNFileAccessor),
	]


# noinspection PyPep8Naming
def BNSaveToFile(
		view: ctypes.POINTER(BNBinaryView), 
		file: ctypes.POINTER(BNFileAccessor)
		) -> bool:
	return _BNSaveToFile(view, file)


# -------------------------------------------------------
# _BNSaveToFilename

_BNSaveToFilename = core.BNSaveToFilename
_BNSaveToFilename.restype = ctypes.c_bool
_BNSaveToFilename.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNSaveToFilename(
		view: ctypes.POINTER(BNBinaryView), 
		filename: Optional[str]
		) -> bool:
	return _BNSaveToFilename(view, cstr(filename))


# -------------------------------------------------------
# _BNScriptingInstanceCompleteInput

_BNScriptingInstanceCompleteInput = core.BNScriptingInstanceCompleteInput
_BNScriptingInstanceCompleteInput.restype = ctypes.POINTER(ctypes.c_byte)
_BNScriptingInstanceCompleteInput.argtypes = [
		ctypes.POINTER(BNScriptingInstance),
		ctypes.c_char_p,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNScriptingInstanceCompleteInput(
		instance: ctypes.POINTER(BNScriptingInstance), 
		text: Optional[str], 
		state: int
		) -> Optional[Optional[str]]:
	result = _BNScriptingInstanceCompleteInput(instance, cstr(text), state)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNScriptingInstanceReleaseBinaryView

_BNScriptingInstanceReleaseBinaryView = core.BNScriptingInstanceReleaseBinaryView
_BNScriptingInstanceReleaseBinaryView.restype = None
_BNScriptingInstanceReleaseBinaryView.argtypes = [
		ctypes.POINTER(BNScriptingInstance),
		ctypes.POINTER(BNBinaryView),
	]


# noinspection PyPep8Naming
def BNScriptingInstanceReleaseBinaryView(
		instance: ctypes.POINTER(BNScriptingInstance), 
		view: ctypes.POINTER(BNBinaryView)
		) -> None:
	return _BNScriptingInstanceReleaseBinaryView(instance, view)


# -------------------------------------------------------
# _BNSearch

_BNSearch = core.BNSearch
_BNSearch.restype = ctypes.c_bool
_BNSearch.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_char_p,
		ctypes.c_void_p,
		ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.POINTER(BNDataBuffer)),
	]


# noinspection PyPep8Naming
def BNSearch(
		view: ctypes.POINTER(BNBinaryView), 
		query: Optional[str], 
		context: Optional[ctypes.c_void_p], 
		callback: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.POINTER(BNDataBuffer))
		) -> bool:
	return _BNSearch(view, cstr(query), context, callback)


# -------------------------------------------------------
# _BNSecretsProviderHasData

_BNSecretsProviderHasData = core.BNSecretsProviderHasData
_BNSecretsProviderHasData.restype = ctypes.c_bool
_BNSecretsProviderHasData.argtypes = [
		ctypes.POINTER(BNSecretsProvider),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNSecretsProviderHasData(
		provider: ctypes.POINTER(BNSecretsProvider), 
		key: Optional[str]
		) -> bool:
	return _BNSecretsProviderHasData(provider, cstr(key))


# -------------------------------------------------------
# _BNSectionGetAlign

_BNSectionGetAlign = core.BNSectionGetAlign
_BNSectionGetAlign.restype = ctypes.c_ulonglong
_BNSectionGetAlign.argtypes = [
		ctypes.POINTER(BNSection),
	]


# noinspection PyPep8Naming
def BNSectionGetAlign(
		section: ctypes.POINTER(BNSection)
		) -> int:
	return _BNSectionGetAlign(section)


# -------------------------------------------------------
# _BNSectionGetEnd

_BNSectionGetEnd = core.BNSectionGetEnd
_BNSectionGetEnd.restype = ctypes.c_ulonglong
_BNSectionGetEnd.argtypes = [
		ctypes.POINTER(BNSection),
	]


# noinspection PyPep8Naming
def BNSectionGetEnd(
		section: ctypes.POINTER(BNSection)
		) -> int:
	return _BNSectionGetEnd(section)


# -------------------------------------------------------
# _BNSectionGetEntrySize

_BNSectionGetEntrySize = core.BNSectionGetEntrySize
_BNSectionGetEntrySize.restype = ctypes.c_ulonglong
_BNSectionGetEntrySize.argtypes = [
		ctypes.POINTER(BNSection),
	]


# noinspection PyPep8Naming
def BNSectionGetEntrySize(
		section: ctypes.POINTER(BNSection)
		) -> int:
	return _BNSectionGetEntrySize(section)


# -------------------------------------------------------
# _BNSectionGetInfoData

_BNSectionGetInfoData = core.BNSectionGetInfoData
_BNSectionGetInfoData.restype = ctypes.c_ulonglong
_BNSectionGetInfoData.argtypes = [
		ctypes.POINTER(BNSection),
	]


# noinspection PyPep8Naming
def BNSectionGetInfoData(
		section: ctypes.POINTER(BNSection)
		) -> int:
	return _BNSectionGetInfoData(section)


# -------------------------------------------------------
# _BNSectionGetInfoSection

_BNSectionGetInfoSection = core.BNSectionGetInfoSection
_BNSectionGetInfoSection.restype = ctypes.POINTER(ctypes.c_byte)
_BNSectionGetInfoSection.argtypes = [
		ctypes.POINTER(BNSection),
	]


# noinspection PyPep8Naming
def BNSectionGetInfoSection(
		section: ctypes.POINTER(BNSection)
		) -> Optional[Optional[str]]:
	result = _BNSectionGetInfoSection(section)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNSectionGetLength

_BNSectionGetLength = core.BNSectionGetLength
_BNSectionGetLength.restype = ctypes.c_ulonglong
_BNSectionGetLength.argtypes = [
		ctypes.POINTER(BNSection),
	]


# noinspection PyPep8Naming
def BNSectionGetLength(
		section: ctypes.POINTER(BNSection)
		) -> int:
	return _BNSectionGetLength(section)


# -------------------------------------------------------
# _BNSectionGetLinkedSection

_BNSectionGetLinkedSection = core.BNSectionGetLinkedSection
_BNSectionGetLinkedSection.restype = ctypes.POINTER(ctypes.c_byte)
_BNSectionGetLinkedSection.argtypes = [
		ctypes.POINTER(BNSection),
	]


# noinspection PyPep8Naming
def BNSectionGetLinkedSection(
		section: ctypes.POINTER(BNSection)
		) -> Optional[Optional[str]]:
	result = _BNSectionGetLinkedSection(section)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNSectionGetName

_BNSectionGetName = core.BNSectionGetName
_BNSectionGetName.restype = ctypes.POINTER(ctypes.c_byte)
_BNSectionGetName.argtypes = [
		ctypes.POINTER(BNSection),
	]


# noinspection PyPep8Naming
def BNSectionGetName(
		section: ctypes.POINTER(BNSection)
		) -> Optional[Optional[str]]:
	result = _BNSectionGetName(section)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNSectionGetSemantics

_BNSectionGetSemantics = core.BNSectionGetSemantics
_BNSectionGetSemantics.restype = SectionSemanticsEnum
_BNSectionGetSemantics.argtypes = [
		ctypes.POINTER(BNSection),
	]


# noinspection PyPep8Naming
def BNSectionGetSemantics(
		section: ctypes.POINTER(BNSection)
		) -> SectionSemantics:
	return _BNSectionGetSemantics(section)


# -------------------------------------------------------
# _BNSectionGetStart

_BNSectionGetStart = core.BNSectionGetStart
_BNSectionGetStart.restype = ctypes.c_ulonglong
_BNSectionGetStart.argtypes = [
		ctypes.POINTER(BNSection),
	]


# noinspection PyPep8Naming
def BNSectionGetStart(
		section: ctypes.POINTER(BNSection)
		) -> int:
	return _BNSectionGetStart(section)


# -------------------------------------------------------
# _BNSectionGetType

_BNSectionGetType = core.BNSectionGetType
_BNSectionGetType.restype = ctypes.POINTER(ctypes.c_byte)
_BNSectionGetType.argtypes = [
		ctypes.POINTER(BNSection),
	]


# noinspection PyPep8Naming
def BNSectionGetType(
		section: ctypes.POINTER(BNSection)
		) -> Optional[Optional[str]]:
	result = _BNSectionGetType(section)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNSectionIsAutoDefined

_BNSectionIsAutoDefined = core.BNSectionIsAutoDefined
_BNSectionIsAutoDefined.restype = ctypes.c_bool
_BNSectionIsAutoDefined.argtypes = [
		ctypes.POINTER(BNSection),
	]


# noinspection PyPep8Naming
def BNSectionIsAutoDefined(
		section: ctypes.POINTER(BNSection)
		) -> bool:
	return _BNSectionIsAutoDefined(section)


# -------------------------------------------------------
# _BNSeekBinaryReader

_BNSeekBinaryReader = core.BNSeekBinaryReader
_BNSeekBinaryReader.restype = None
_BNSeekBinaryReader.argtypes = [
		ctypes.POINTER(BNBinaryReader),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNSeekBinaryReader(
		stream: ctypes.POINTER(BNBinaryReader), 
		offset: int
		) -> None:
	return _BNSeekBinaryReader(stream, offset)


# -------------------------------------------------------
# _BNSeekBinaryReaderRelative

_BNSeekBinaryReaderRelative = core.BNSeekBinaryReaderRelative
_BNSeekBinaryReaderRelative.restype = None
_BNSeekBinaryReaderRelative.argtypes = [
		ctypes.POINTER(BNBinaryReader),
		ctypes.c_longlong,
	]


# noinspection PyPep8Naming
def BNSeekBinaryReaderRelative(
		stream: ctypes.POINTER(BNBinaryReader), 
		offset: int
		) -> None:
	return _BNSeekBinaryReaderRelative(stream, offset)


# -------------------------------------------------------
# _BNSeekBinaryWriter

_BNSeekBinaryWriter = core.BNSeekBinaryWriter
_BNSeekBinaryWriter.restype = None
_BNSeekBinaryWriter.argtypes = [
		ctypes.POINTER(BNBinaryWriter),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNSeekBinaryWriter(
		stream: ctypes.POINTER(BNBinaryWriter), 
		offset: int
		) -> None:
	return _BNSeekBinaryWriter(stream, offset)


# -------------------------------------------------------
# _BNSeekBinaryWriterRelative

_BNSeekBinaryWriterRelative = core.BNSeekBinaryWriterRelative
_BNSeekBinaryWriterRelative.restype = None
_BNSeekBinaryWriterRelative.argtypes = [
		ctypes.POINTER(BNBinaryWriter),
		ctypes.c_longlong,
	]


# noinspection PyPep8Naming
def BNSeekBinaryWriterRelative(
		stream: ctypes.POINTER(BNBinaryWriter), 
		offset: int
		) -> None:
	return _BNSeekBinaryWriterRelative(stream, offset)


# -------------------------------------------------------
# _BNSeekLinearViewCursorToAddress

_BNSeekLinearViewCursorToAddress = core.BNSeekLinearViewCursorToAddress
_BNSeekLinearViewCursorToAddress.restype = None
_BNSeekLinearViewCursorToAddress.argtypes = [
		ctypes.POINTER(BNLinearViewCursor),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNSeekLinearViewCursorToAddress(
		cursor: ctypes.POINTER(BNLinearViewCursor), 
		addr: int
		) -> None:
	return _BNSeekLinearViewCursorToAddress(cursor, addr)


# -------------------------------------------------------
# _BNSeekLinearViewCursorToBegin

_BNSeekLinearViewCursorToBegin = core.BNSeekLinearViewCursorToBegin
_BNSeekLinearViewCursorToBegin.restype = None
_BNSeekLinearViewCursorToBegin.argtypes = [
		ctypes.POINTER(BNLinearViewCursor),
	]


# noinspection PyPep8Naming
def BNSeekLinearViewCursorToBegin(
		cursor: ctypes.POINTER(BNLinearViewCursor)
		) -> None:
	return _BNSeekLinearViewCursorToBegin(cursor)


# -------------------------------------------------------
# _BNSeekLinearViewCursorToCursorPath

_BNSeekLinearViewCursorToCursorPath = core.BNSeekLinearViewCursorToCursorPath
_BNSeekLinearViewCursorToCursorPath.restype = ctypes.c_bool
_BNSeekLinearViewCursorToCursorPath.argtypes = [
		ctypes.POINTER(BNLinearViewCursor),
		ctypes.POINTER(BNLinearViewCursor),
	]


# noinspection PyPep8Naming
def BNSeekLinearViewCursorToCursorPath(
		cursor: ctypes.POINTER(BNLinearViewCursor), 
		path: ctypes.POINTER(BNLinearViewCursor)
		) -> bool:
	return _BNSeekLinearViewCursorToCursorPath(cursor, path)


# -------------------------------------------------------
# _BNSeekLinearViewCursorToCursorPathAndAddress

_BNSeekLinearViewCursorToCursorPathAndAddress = core.BNSeekLinearViewCursorToCursorPathAndAddress
_BNSeekLinearViewCursorToCursorPathAndAddress.restype = ctypes.c_bool
_BNSeekLinearViewCursorToCursorPathAndAddress.argtypes = [
		ctypes.POINTER(BNLinearViewCursor),
		ctypes.POINTER(BNLinearViewCursor),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNSeekLinearViewCursorToCursorPathAndAddress(
		cursor: ctypes.POINTER(BNLinearViewCursor), 
		path: ctypes.POINTER(BNLinearViewCursor), 
		addr: int
		) -> bool:
	return _BNSeekLinearViewCursorToCursorPathAndAddress(cursor, path, addr)


# -------------------------------------------------------
# _BNSeekLinearViewCursorToEnd

_BNSeekLinearViewCursorToEnd = core.BNSeekLinearViewCursorToEnd
_BNSeekLinearViewCursorToEnd.restype = None
_BNSeekLinearViewCursorToEnd.argtypes = [
		ctypes.POINTER(BNLinearViewCursor),
	]


# noinspection PyPep8Naming
def BNSeekLinearViewCursorToEnd(
		cursor: ctypes.POINTER(BNLinearViewCursor)
		) -> None:
	return _BNSeekLinearViewCursorToEnd(cursor)


# -------------------------------------------------------
# _BNSeekLinearViewCursorToOrderingIndex

_BNSeekLinearViewCursorToOrderingIndex = core.BNSeekLinearViewCursorToOrderingIndex
_BNSeekLinearViewCursorToOrderingIndex.restype = None
_BNSeekLinearViewCursorToOrderingIndex.argtypes = [
		ctypes.POINTER(BNLinearViewCursor),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNSeekLinearViewCursorToOrderingIndex(
		cursor: ctypes.POINTER(BNLinearViewCursor), 
		idx: int
		) -> None:
	return _BNSeekLinearViewCursorToOrderingIndex(cursor, idx)


# -------------------------------------------------------
# _BNSeekLinearViewCursorToPath

_BNSeekLinearViewCursorToPath = core.BNSeekLinearViewCursorToPath
_BNSeekLinearViewCursorToPath.restype = ctypes.c_bool
_BNSeekLinearViewCursorToPath.argtypes = [
		ctypes.POINTER(BNLinearViewCursor),
		ctypes.POINTER(BNLinearViewObjectIdentifier),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNSeekLinearViewCursorToPath(
		cursor: ctypes.POINTER(BNLinearViewCursor), 
		ids: ctypes.POINTER(BNLinearViewObjectIdentifier), 
		count: int
		) -> bool:
	return _BNSeekLinearViewCursorToPath(cursor, ids, count)


# -------------------------------------------------------
# _BNSeekLinearViewCursorToPathAndAddress

_BNSeekLinearViewCursorToPathAndAddress = core.BNSeekLinearViewCursorToPathAndAddress
_BNSeekLinearViewCursorToPathAndAddress.restype = ctypes.c_bool
_BNSeekLinearViewCursorToPathAndAddress.argtypes = [
		ctypes.POINTER(BNLinearViewCursor),
		ctypes.POINTER(BNLinearViewObjectIdentifier),
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNSeekLinearViewCursorToPathAndAddress(
		cursor: ctypes.POINTER(BNLinearViewCursor), 
		ids: ctypes.POINTER(BNLinearViewObjectIdentifier), 
		count: int, 
		addr: int
		) -> bool:
	return _BNSeekLinearViewCursorToPathAndAddress(cursor, ids, count, addr)


# -------------------------------------------------------
# _BNSegmentGetDataEnd

_BNSegmentGetDataEnd = core.BNSegmentGetDataEnd
_BNSegmentGetDataEnd.restype = ctypes.c_ulonglong
_BNSegmentGetDataEnd.argtypes = [
		ctypes.POINTER(BNSegment),
	]


# noinspection PyPep8Naming
def BNSegmentGetDataEnd(
		segment: ctypes.POINTER(BNSegment)
		) -> int:
	return _BNSegmentGetDataEnd(segment)


# -------------------------------------------------------
# _BNSegmentGetDataLength

_BNSegmentGetDataLength = core.BNSegmentGetDataLength
_BNSegmentGetDataLength.restype = ctypes.c_ulonglong
_BNSegmentGetDataLength.argtypes = [
		ctypes.POINTER(BNSegment),
	]


# noinspection PyPep8Naming
def BNSegmentGetDataLength(
		segment: ctypes.POINTER(BNSegment)
		) -> int:
	return _BNSegmentGetDataLength(segment)


# -------------------------------------------------------
# _BNSegmentGetDataOffset

_BNSegmentGetDataOffset = core.BNSegmentGetDataOffset
_BNSegmentGetDataOffset.restype = ctypes.c_ulonglong
_BNSegmentGetDataOffset.argtypes = [
		ctypes.POINTER(BNSegment),
	]


# noinspection PyPep8Naming
def BNSegmentGetDataOffset(
		segment: ctypes.POINTER(BNSegment)
		) -> int:
	return _BNSegmentGetDataOffset(segment)


# -------------------------------------------------------
# _BNSegmentGetEnd

_BNSegmentGetEnd = core.BNSegmentGetEnd
_BNSegmentGetEnd.restype = ctypes.c_ulonglong
_BNSegmentGetEnd.argtypes = [
		ctypes.POINTER(BNSegment),
	]


# noinspection PyPep8Naming
def BNSegmentGetEnd(
		segment: ctypes.POINTER(BNSegment)
		) -> int:
	return _BNSegmentGetEnd(segment)


# -------------------------------------------------------
# _BNSegmentGetFlags

_BNSegmentGetFlags = core.BNSegmentGetFlags
_BNSegmentGetFlags.restype = ctypes.c_uint
_BNSegmentGetFlags.argtypes = [
		ctypes.POINTER(BNSegment),
	]


# noinspection PyPep8Naming
def BNSegmentGetFlags(
		segment: ctypes.POINTER(BNSegment)
		) -> int:
	return _BNSegmentGetFlags(segment)


# -------------------------------------------------------
# _BNSegmentGetLength

_BNSegmentGetLength = core.BNSegmentGetLength
_BNSegmentGetLength.restype = ctypes.c_ulonglong
_BNSegmentGetLength.argtypes = [
		ctypes.POINTER(BNSegment),
	]


# noinspection PyPep8Naming
def BNSegmentGetLength(
		segment: ctypes.POINTER(BNSegment)
		) -> int:
	return _BNSegmentGetLength(segment)


# -------------------------------------------------------
# _BNSegmentGetRelocationRanges

_BNSegmentGetRelocationRanges = core.BNSegmentGetRelocationRanges
_BNSegmentGetRelocationRanges.restype = ctypes.POINTER(BNRange)
_BNSegmentGetRelocationRanges.argtypes = [
		ctypes.POINTER(BNSegment),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNSegmentGetRelocationRanges(
		segment: ctypes.POINTER(BNSegment), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNRange)]:
	result = _BNSegmentGetRelocationRanges(segment, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNSegmentGetRelocationRangesAtAddress

_BNSegmentGetRelocationRangesAtAddress = core.BNSegmentGetRelocationRangesAtAddress
_BNSegmentGetRelocationRangesAtAddress.restype = ctypes.POINTER(BNRange)
_BNSegmentGetRelocationRangesAtAddress.argtypes = [
		ctypes.POINTER(BNSegment),
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNSegmentGetRelocationRangesAtAddress(
		segment: ctypes.POINTER(BNSegment), 
		addr: int, 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNRange)]:
	result = _BNSegmentGetRelocationRangesAtAddress(segment, addr, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNSegmentGetRelocationsCount

_BNSegmentGetRelocationsCount = core.BNSegmentGetRelocationsCount
_BNSegmentGetRelocationsCount.restype = ctypes.c_ulonglong
_BNSegmentGetRelocationsCount.argtypes = [
		ctypes.POINTER(BNSegment),
	]


# noinspection PyPep8Naming
def BNSegmentGetRelocationsCount(
		segment: ctypes.POINTER(BNSegment)
		) -> int:
	return _BNSegmentGetRelocationsCount(segment)


# -------------------------------------------------------
# _BNSegmentGetStart

_BNSegmentGetStart = core.BNSegmentGetStart
_BNSegmentGetStart.restype = ctypes.c_ulonglong
_BNSegmentGetStart.argtypes = [
		ctypes.POINTER(BNSegment),
	]


# noinspection PyPep8Naming
def BNSegmentGetStart(
		segment: ctypes.POINTER(BNSegment)
		) -> int:
	return _BNSegmentGetStart(segment)


# -------------------------------------------------------
# _BNSegmentIsAutoDefined

_BNSegmentIsAutoDefined = core.BNSegmentIsAutoDefined
_BNSegmentIsAutoDefined.restype = ctypes.c_bool
_BNSegmentIsAutoDefined.argtypes = [
		ctypes.POINTER(BNSegment),
	]


# noinspection PyPep8Naming
def BNSegmentIsAutoDefined(
		segment: ctypes.POINTER(BNSegment)
		) -> bool:
	return _BNSegmentIsAutoDefined(segment)


# -------------------------------------------------------
# _BNSegmentRangeContainsRelocation

_BNSegmentRangeContainsRelocation = core.BNSegmentRangeContainsRelocation
_BNSegmentRangeContainsRelocation.restype = ctypes.c_bool
_BNSegmentRangeContainsRelocation.argtypes = [
		ctypes.POINTER(BNSegment),
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNSegmentRangeContainsRelocation(
		segment: ctypes.POINTER(BNSegment), 
		addr: int, 
		size: int
		) -> bool:
	return _BNSegmentRangeContainsRelocation(segment, addr, size)


# -------------------------------------------------------
# _BNSegmentSetDataLength

_BNSegmentSetDataLength = core.BNSegmentSetDataLength
_BNSegmentSetDataLength.restype = None
_BNSegmentSetDataLength.argtypes = [
		ctypes.POINTER(BNSegment),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNSegmentSetDataLength(
		segment: ctypes.POINTER(BNSegment), 
		dataLength: int
		) -> None:
	return _BNSegmentSetDataLength(segment, dataLength)


# -------------------------------------------------------
# _BNSegmentSetDataOffset

_BNSegmentSetDataOffset = core.BNSegmentSetDataOffset
_BNSegmentSetDataOffset.restype = None
_BNSegmentSetDataOffset.argtypes = [
		ctypes.POINTER(BNSegment),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNSegmentSetDataOffset(
		segment: ctypes.POINTER(BNSegment), 
		dataOffset: int
		) -> None:
	return _BNSegmentSetDataOffset(segment, dataOffset)


# -------------------------------------------------------
# _BNSegmentSetFlags

_BNSegmentSetFlags = core.BNSegmentSetFlags
_BNSegmentSetFlags.restype = None
_BNSegmentSetFlags.argtypes = [
		ctypes.POINTER(BNSegment),
		ctypes.c_uint,
	]


# noinspection PyPep8Naming
def BNSegmentSetFlags(
		segment: ctypes.POINTER(BNSegment), 
		flags: int
		) -> None:
	return _BNSegmentSetFlags(segment, flags)


# -------------------------------------------------------
# _BNSegmentSetLength

_BNSegmentSetLength = core.BNSegmentSetLength
_BNSegmentSetLength.restype = None
_BNSegmentSetLength.argtypes = [
		ctypes.POINTER(BNSegment),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNSegmentSetLength(
		segment: ctypes.POINTER(BNSegment), 
		length: int
		) -> None:
	return _BNSegmentSetLength(segment, length)


# -------------------------------------------------------
# _BNSerializeSettings

_BNSerializeSettings = core.BNSerializeSettings
_BNSerializeSettings.restype = ctypes.POINTER(ctypes.c_byte)
_BNSerializeSettings.argtypes = [
		ctypes.POINTER(BNSettings),
		ctypes.POINTER(BNBinaryView),
		SettingsScopeEnum,
	]


# noinspection PyPep8Naming
def BNSerializeSettings(
		settings: ctypes.POINTER(BNSettings), 
		view: ctypes.POINTER(BNBinaryView), 
		scope: SettingsScope
		) -> Optional[Optional[str]]:
	result = _BNSerializeSettings(settings, view, scope)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNSetActiveUpdateChannel

_BNSetActiveUpdateChannel = core.BNSetActiveUpdateChannel
_BNSetActiveUpdateChannel.restype = None
_BNSetActiveUpdateChannel.argtypes = [
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNSetActiveUpdateChannel(
		channel: Optional[str]
		) -> None:
	return _BNSetActiveUpdateChannel(cstr(channel))


# -------------------------------------------------------
# _BNSetAnalysisHold

_BNSetAnalysisHold = core.BNSetAnalysisHold
_BNSetAnalysisHold.restype = None
_BNSetAnalysisHold.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_bool,
	]


# noinspection PyPep8Naming
def BNSetAnalysisHold(
		view: ctypes.POINTER(BNBinaryView), 
		enable: bool
		) -> None:
	return _BNSetAnalysisHold(view, enable)


# -------------------------------------------------------
# _BNSetArchitectureCdeclCallingConvention

_BNSetArchitectureCdeclCallingConvention = core.BNSetArchitectureCdeclCallingConvention
_BNSetArchitectureCdeclCallingConvention.restype = None
_BNSetArchitectureCdeclCallingConvention.argtypes = [
		ctypes.POINTER(BNArchitecture),
		ctypes.POINTER(BNCallingConvention),
	]


# noinspection PyPep8Naming
def BNSetArchitectureCdeclCallingConvention(
		arch: ctypes.POINTER(BNArchitecture), 
		cc: ctypes.POINTER(BNCallingConvention)
		) -> None:
	return _BNSetArchitectureCdeclCallingConvention(arch, cc)


# -------------------------------------------------------
# _BNSetArchitectureDefaultCallingConvention

_BNSetArchitectureDefaultCallingConvention = core.BNSetArchitectureDefaultCallingConvention
_BNSetArchitectureDefaultCallingConvention.restype = None
_BNSetArchitectureDefaultCallingConvention.argtypes = [
		ctypes.POINTER(BNArchitecture),
		ctypes.POINTER(BNCallingConvention),
	]


# noinspection PyPep8Naming
def BNSetArchitectureDefaultCallingConvention(
		arch: ctypes.POINTER(BNArchitecture), 
		cc: ctypes.POINTER(BNCallingConvention)
		) -> None:
	return _BNSetArchitectureDefaultCallingConvention(arch, cc)


# -------------------------------------------------------
# _BNSetArchitectureFastcallCallingConvention

_BNSetArchitectureFastcallCallingConvention = core.BNSetArchitectureFastcallCallingConvention
_BNSetArchitectureFastcallCallingConvention.restype = None
_BNSetArchitectureFastcallCallingConvention.argtypes = [
		ctypes.POINTER(BNArchitecture),
		ctypes.POINTER(BNCallingConvention),
	]


# noinspection PyPep8Naming
def BNSetArchitectureFastcallCallingConvention(
		arch: ctypes.POINTER(BNArchitecture), 
		cc: ctypes.POINTER(BNCallingConvention)
		) -> None:
	return _BNSetArchitectureFastcallCallingConvention(arch, cc)


# -------------------------------------------------------
# _BNSetArchitectureStdcallCallingConvention

_BNSetArchitectureStdcallCallingConvention = core.BNSetArchitectureStdcallCallingConvention
_BNSetArchitectureStdcallCallingConvention.restype = None
_BNSetArchitectureStdcallCallingConvention.argtypes = [
		ctypes.POINTER(BNArchitecture),
		ctypes.POINTER(BNCallingConvention),
	]


# noinspection PyPep8Naming
def BNSetArchitectureStdcallCallingConvention(
		arch: ctypes.POINTER(BNArchitecture), 
		cc: ctypes.POINTER(BNCallingConvention)
		) -> None:
	return _BNSetArchitectureStdcallCallingConvention(arch, cc)


# -------------------------------------------------------
# _BNSetAutoBasicBlockHighlight

_BNSetAutoBasicBlockHighlight = core.BNSetAutoBasicBlockHighlight
_BNSetAutoBasicBlockHighlight.restype = None
_BNSetAutoBasicBlockHighlight.argtypes = [
		ctypes.POINTER(BNBasicBlock),
		BNHighlightColor,
	]


# noinspection PyPep8Naming
def BNSetAutoBasicBlockHighlight(
		block: ctypes.POINTER(BNBasicBlock), 
		color: BNHighlightColor
		) -> None:
	return _BNSetAutoBasicBlockHighlight(block, color)


# -------------------------------------------------------
# _BNSetAutoCallRegisterStackAdjustment

_BNSetAutoCallRegisterStackAdjustment = core.BNSetAutoCallRegisterStackAdjustment
_BNSetAutoCallRegisterStackAdjustment.restype = None
_BNSetAutoCallRegisterStackAdjustment.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNArchitecture),
		ctypes.c_ulonglong,
		ctypes.POINTER(BNRegisterStackAdjustment),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNSetAutoCallRegisterStackAdjustment(
		func: ctypes.POINTER(BNFunction), 
		arch: ctypes.POINTER(BNArchitecture), 
		addr: int, 
		adjust: ctypes.POINTER(BNRegisterStackAdjustment), 
		count: int
		) -> None:
	return _BNSetAutoCallRegisterStackAdjustment(func, arch, addr, adjust, count)


# -------------------------------------------------------
# _BNSetAutoCallRegisterStackAdjustmentForRegisterStack

_BNSetAutoCallRegisterStackAdjustmentForRegisterStack = core.BNSetAutoCallRegisterStackAdjustmentForRegisterStack
_BNSetAutoCallRegisterStackAdjustmentForRegisterStack.restype = None
_BNSetAutoCallRegisterStackAdjustmentForRegisterStack.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNArchitecture),
		ctypes.c_ulonglong,
		ctypes.c_uint,
		ctypes.c_int,
		ctypes.c_ubyte,
	]


# noinspection PyPep8Naming
def BNSetAutoCallRegisterStackAdjustmentForRegisterStack(
		func: ctypes.POINTER(BNFunction), 
		arch: ctypes.POINTER(BNArchitecture), 
		addr: int, 
		regStack: int, 
		adjust: int, 
		confidence: int
		) -> None:
	return _BNSetAutoCallRegisterStackAdjustmentForRegisterStack(func, arch, addr, regStack, adjust, confidence)


# -------------------------------------------------------
# _BNSetAutoCallStackAdjustment

_BNSetAutoCallStackAdjustment = core.BNSetAutoCallStackAdjustment
_BNSetAutoCallStackAdjustment.restype = None
_BNSetAutoCallStackAdjustment.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNArchitecture),
		ctypes.c_ulonglong,
		ctypes.c_longlong,
		ctypes.c_ubyte,
	]


# noinspection PyPep8Naming
def BNSetAutoCallStackAdjustment(
		func: ctypes.POINTER(BNFunction), 
		arch: ctypes.POINTER(BNArchitecture), 
		addr: int, 
		adjust: int, 
		confidence: int
		) -> None:
	return _BNSetAutoCallStackAdjustment(func, arch, addr, adjust, confidence)


# -------------------------------------------------------
# _BNSetAutoCallTypeAdjustment

_BNSetAutoCallTypeAdjustment = core.BNSetAutoCallTypeAdjustment
_BNSetAutoCallTypeAdjustment.restype = None
_BNSetAutoCallTypeAdjustment.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNArchitecture),
		ctypes.c_ulonglong,
		ctypes.POINTER(BNTypeWithConfidence),
	]


# noinspection PyPep8Naming
def BNSetAutoCallTypeAdjustment(
		func: ctypes.POINTER(BNFunction), 
		arch: ctypes.POINTER(BNArchitecture), 
		addr: int, 
		type: ctypes.POINTER(BNTypeWithConfidence)
		) -> None:
	return _BNSetAutoCallTypeAdjustment(func, arch, addr, type)


# -------------------------------------------------------
# _BNSetAutoFunctionCallingConvention

_BNSetAutoFunctionCallingConvention = core.BNSetAutoFunctionCallingConvention
_BNSetAutoFunctionCallingConvention.restype = None
_BNSetAutoFunctionCallingConvention.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNCallingConventionWithConfidence),
	]


# noinspection PyPep8Naming
def BNSetAutoFunctionCallingConvention(
		func: ctypes.POINTER(BNFunction), 
		convention: ctypes.POINTER(BNCallingConventionWithConfidence)
		) -> None:
	return _BNSetAutoFunctionCallingConvention(func, convention)


# -------------------------------------------------------
# _BNSetAutoFunctionCanReturn

_BNSetAutoFunctionCanReturn = core.BNSetAutoFunctionCanReturn
_BNSetAutoFunctionCanReturn.restype = None
_BNSetAutoFunctionCanReturn.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNBoolWithConfidence),
	]


# noinspection PyPep8Naming
def BNSetAutoFunctionCanReturn(
		func: ctypes.POINTER(BNFunction), 
		returns: ctypes.POINTER(BNBoolWithConfidence)
		) -> None:
	return _BNSetAutoFunctionCanReturn(func, returns)


# -------------------------------------------------------
# _BNSetAutoFunctionClobberedRegisters

_BNSetAutoFunctionClobberedRegisters = core.BNSetAutoFunctionClobberedRegisters
_BNSetAutoFunctionClobberedRegisters.restype = None
_BNSetAutoFunctionClobberedRegisters.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNRegisterSetWithConfidence),
	]


# noinspection PyPep8Naming
def BNSetAutoFunctionClobberedRegisters(
		func: ctypes.POINTER(BNFunction), 
		regs: ctypes.POINTER(BNRegisterSetWithConfidence)
		) -> None:
	return _BNSetAutoFunctionClobberedRegisters(func, regs)


# -------------------------------------------------------
# _BNSetAutoFunctionHasVariableArguments

_BNSetAutoFunctionHasVariableArguments = core.BNSetAutoFunctionHasVariableArguments
_BNSetAutoFunctionHasVariableArguments.restype = None
_BNSetAutoFunctionHasVariableArguments.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNBoolWithConfidence),
	]


# noinspection PyPep8Naming
def BNSetAutoFunctionHasVariableArguments(
		func: ctypes.POINTER(BNFunction), 
		varArgs: ctypes.POINTER(BNBoolWithConfidence)
		) -> None:
	return _BNSetAutoFunctionHasVariableArguments(func, varArgs)


# -------------------------------------------------------
# _BNSetAutoFunctionInlinedDuringAnalysis

_BNSetAutoFunctionInlinedDuringAnalysis = core.BNSetAutoFunctionInlinedDuringAnalysis
_BNSetAutoFunctionInlinedDuringAnalysis.restype = None
_BNSetAutoFunctionInlinedDuringAnalysis.argtypes = [
		ctypes.POINTER(BNFunction),
		BNBoolWithConfidence,
	]


# noinspection PyPep8Naming
def BNSetAutoFunctionInlinedDuringAnalysis(
		func: ctypes.POINTER(BNFunction), 
		inlined: BNBoolWithConfidence
		) -> None:
	return _BNSetAutoFunctionInlinedDuringAnalysis(func, inlined)


# -------------------------------------------------------
# _BNSetAutoFunctionParameterVariables

_BNSetAutoFunctionParameterVariables = core.BNSetAutoFunctionParameterVariables
_BNSetAutoFunctionParameterVariables.restype = None
_BNSetAutoFunctionParameterVariables.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNParameterVariablesWithConfidence),
	]


# noinspection PyPep8Naming
def BNSetAutoFunctionParameterVariables(
		func: ctypes.POINTER(BNFunction), 
		vars: ctypes.POINTER(BNParameterVariablesWithConfidence)
		) -> None:
	return _BNSetAutoFunctionParameterVariables(func, vars)


# -------------------------------------------------------
# _BNSetAutoFunctionPure

_BNSetAutoFunctionPure = core.BNSetAutoFunctionPure
_BNSetAutoFunctionPure.restype = None
_BNSetAutoFunctionPure.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNBoolWithConfidence),
	]


# noinspection PyPep8Naming
def BNSetAutoFunctionPure(
		func: ctypes.POINTER(BNFunction), 
		pure: ctypes.POINTER(BNBoolWithConfidence)
		) -> None:
	return _BNSetAutoFunctionPure(func, pure)


# -------------------------------------------------------
# _BNSetAutoFunctionRegisterStackAdjustments

_BNSetAutoFunctionRegisterStackAdjustments = core.BNSetAutoFunctionRegisterStackAdjustments
_BNSetAutoFunctionRegisterStackAdjustments.restype = None
_BNSetAutoFunctionRegisterStackAdjustments.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNRegisterStackAdjustment),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNSetAutoFunctionRegisterStackAdjustments(
		func: ctypes.POINTER(BNFunction), 
		adjustments: ctypes.POINTER(BNRegisterStackAdjustment), 
		count: int
		) -> None:
	return _BNSetAutoFunctionRegisterStackAdjustments(func, adjustments, count)


# -------------------------------------------------------
# _BNSetAutoFunctionReturnRegisters

_BNSetAutoFunctionReturnRegisters = core.BNSetAutoFunctionReturnRegisters
_BNSetAutoFunctionReturnRegisters.restype = None
_BNSetAutoFunctionReturnRegisters.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNRegisterSetWithConfidence),
	]


# noinspection PyPep8Naming
def BNSetAutoFunctionReturnRegisters(
		func: ctypes.POINTER(BNFunction), 
		regs: ctypes.POINTER(BNRegisterSetWithConfidence)
		) -> None:
	return _BNSetAutoFunctionReturnRegisters(func, regs)


# -------------------------------------------------------
# _BNSetAutoFunctionReturnType

_BNSetAutoFunctionReturnType = core.BNSetAutoFunctionReturnType
_BNSetAutoFunctionReturnType.restype = None
_BNSetAutoFunctionReturnType.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNTypeWithConfidence),
	]


# noinspection PyPep8Naming
def BNSetAutoFunctionReturnType(
		func: ctypes.POINTER(BNFunction), 
		type: ctypes.POINTER(BNTypeWithConfidence)
		) -> None:
	return _BNSetAutoFunctionReturnType(func, type)


# -------------------------------------------------------
# _BNSetAutoFunctionStackAdjustment

_BNSetAutoFunctionStackAdjustment = core.BNSetAutoFunctionStackAdjustment
_BNSetAutoFunctionStackAdjustment.restype = None
_BNSetAutoFunctionStackAdjustment.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNOffsetWithConfidence),
	]


# noinspection PyPep8Naming
def BNSetAutoFunctionStackAdjustment(
		func: ctypes.POINTER(BNFunction), 
		stackAdjust: ctypes.POINTER(BNOffsetWithConfidence)
		) -> None:
	return _BNSetAutoFunctionStackAdjustment(func, stackAdjust)


# -------------------------------------------------------
# _BNSetAutoIndirectBranches

_BNSetAutoIndirectBranches = core.BNSetAutoIndirectBranches
_BNSetAutoIndirectBranches.restype = None
_BNSetAutoIndirectBranches.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNArchitecture),
		ctypes.c_ulonglong,
		ctypes.POINTER(BNArchitectureAndAddress),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNSetAutoIndirectBranches(
		func: ctypes.POINTER(BNFunction), 
		sourceArch: ctypes.POINTER(BNArchitecture), 
		source: int, 
		branches: ctypes.POINTER(BNArchitectureAndAddress), 
		count: int
		) -> None:
	return _BNSetAutoIndirectBranches(func, sourceArch, source, branches, count)


# -------------------------------------------------------
# _BNSetAutoInstructionHighlight

_BNSetAutoInstructionHighlight = core.BNSetAutoInstructionHighlight
_BNSetAutoInstructionHighlight.restype = None
_BNSetAutoInstructionHighlight.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNArchitecture),
		ctypes.c_ulonglong,
		BNHighlightColor,
	]


# noinspection PyPep8Naming
def BNSetAutoInstructionHighlight(
		func: ctypes.POINTER(BNFunction), 
		arch: ctypes.POINTER(BNArchitecture), 
		addr: int, 
		color: BNHighlightColor
		) -> None:
	return _BNSetAutoInstructionHighlight(func, arch, addr, color)


# -------------------------------------------------------
# _BNSetAutoUpdatesEnabled

_BNSetAutoUpdatesEnabled = core.BNSetAutoUpdatesEnabled
_BNSetAutoUpdatesEnabled.restype = None
_BNSetAutoUpdatesEnabled.argtypes = [
		ctypes.c_bool,
	]


# noinspection PyPep8Naming
def BNSetAutoUpdatesEnabled(
		enabled: bool
		) -> None:
	return _BNSetAutoUpdatesEnabled(enabled)


# -------------------------------------------------------
# _BNSetBackgroundTaskProgressText

_BNSetBackgroundTaskProgressText = core.BNSetBackgroundTaskProgressText
_BNSetBackgroundTaskProgressText.restype = None
_BNSetBackgroundTaskProgressText.argtypes = [
		ctypes.POINTER(BNBackgroundTask),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNSetBackgroundTaskProgressText(
		task: ctypes.POINTER(BNBackgroundTask), 
		text: Optional[str]
		) -> None:
	return _BNSetBackgroundTaskProgressText(task, cstr(text))


# -------------------------------------------------------
# _BNSetBaseStructuresForStructureBuilder

_BNSetBaseStructuresForStructureBuilder = core.BNSetBaseStructuresForStructureBuilder
_BNSetBaseStructuresForStructureBuilder.restype = None
_BNSetBaseStructuresForStructureBuilder.argtypes = [
		ctypes.POINTER(BNStructureBuilder),
		ctypes.POINTER(BNBaseStructure),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNSetBaseStructuresForStructureBuilder(
		s: ctypes.POINTER(BNStructureBuilder), 
		bases: ctypes.POINTER(BNBaseStructure), 
		count: int
		) -> None:
	return _BNSetBaseStructuresForStructureBuilder(s, bases, count)


# -------------------------------------------------------
# _BNSetBasicBlockList

_BNSetBasicBlockList = core.BNSetBasicBlockList
_BNSetBasicBlockList.restype = None
_BNSetBasicBlockList.argtypes = [
		ctypes.POINTER(BNAnalysisContext),
		ctypes.POINTER(ctypes.POINTER(BNBasicBlock)),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNSetBasicBlockList(
		analysisContext: ctypes.POINTER(BNAnalysisContext), 
		basicBlocks: ctypes.POINTER(ctypes.POINTER(BNBasicBlock)), 
		count: int
		) -> None:
	return _BNSetBasicBlockList(analysisContext, basicBlocks, count)


# -------------------------------------------------------
# _BNSetBinaryReaderEndianness

_BNSetBinaryReaderEndianness = core.BNSetBinaryReaderEndianness
_BNSetBinaryReaderEndianness.restype = None
_BNSetBinaryReaderEndianness.argtypes = [
		ctypes.POINTER(BNBinaryReader),
		EndiannessEnum,
	]


# noinspection PyPep8Naming
def BNSetBinaryReaderEndianness(
		stream: ctypes.POINTER(BNBinaryReader), 
		endian: Endianness
		) -> None:
	return _BNSetBinaryReaderEndianness(stream, endian)


# -------------------------------------------------------
# _BNSetBinaryReaderVirtualBase

_BNSetBinaryReaderVirtualBase = core.BNSetBinaryReaderVirtualBase
_BNSetBinaryReaderVirtualBase.restype = None
_BNSetBinaryReaderVirtualBase.argtypes = [
		ctypes.POINTER(BNBinaryReader),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNSetBinaryReaderVirtualBase(
		stream: ctypes.POINTER(BNBinaryReader), 
		base: int
		) -> None:
	return _BNSetBinaryReaderVirtualBase(stream, base)


# -------------------------------------------------------
# _BNSetBinaryWriterEndianness

_BNSetBinaryWriterEndianness = core.BNSetBinaryWriterEndianness
_BNSetBinaryWriterEndianness.restype = None
_BNSetBinaryWriterEndianness.argtypes = [
		ctypes.POINTER(BNBinaryWriter),
		EndiannessEnum,
	]


# noinspection PyPep8Naming
def BNSetBinaryWriterEndianness(
		stream: ctypes.POINTER(BNBinaryWriter), 
		endian: Endianness
		) -> None:
	return _BNSetBinaryWriterEndianness(stream, endian)


# -------------------------------------------------------
# _BNSetBundledPluginDirectory

_BNSetBundledPluginDirectory = core.BNSetBundledPluginDirectory
_BNSetBundledPluginDirectory.restype = None
_BNSetBundledPluginDirectory.argtypes = [
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNSetBundledPluginDirectory(
		path: Optional[str]
		) -> None:
	return _BNSetBundledPluginDirectory(cstr(path))


# -------------------------------------------------------
# _BNSetCommentForAddress

_BNSetCommentForAddress = core.BNSetCommentForAddress
_BNSetCommentForAddress.restype = None
_BNSetCommentForAddress.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.c_ulonglong,
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNSetCommentForAddress(
		func: ctypes.POINTER(BNFunction), 
		addr: int, 
		comment: Optional[str]
		) -> None:
	return _BNSetCommentForAddress(func, addr, cstr(comment))


# -------------------------------------------------------
# _BNSetCurrentPluginLoadOrder

_BNSetCurrentPluginLoadOrder = core.BNSetCurrentPluginLoadOrder
_BNSetCurrentPluginLoadOrder.restype = None
_BNSetCurrentPluginLoadOrder.argtypes = [
		PluginLoadOrderEnum,
	]


# noinspection PyPep8Naming
def BNSetCurrentPluginLoadOrder(
		order: PluginLoadOrder
		) -> None:
	return _BNSetCurrentPluginLoadOrder(order)


# -------------------------------------------------------
# _BNSetDataBufferByte

_BNSetDataBufferByte = core.BNSetDataBufferByte
_BNSetDataBufferByte.restype = None
_BNSetDataBufferByte.argtypes = [
		ctypes.POINTER(BNDataBuffer),
		ctypes.c_ulonglong,
		ctypes.c_ubyte,
	]


# noinspection PyPep8Naming
def BNSetDataBufferByte(
		buf: ctypes.POINTER(BNDataBuffer), 
		offset: int, 
		val: int
		) -> None:
	return _BNSetDataBufferByte(buf, offset, val)


# -------------------------------------------------------
# _BNSetDataBufferContents

_BNSetDataBufferContents = core.BNSetDataBufferContents
_BNSetDataBufferContents.restype = None
_BNSetDataBufferContents.argtypes = [
		ctypes.POINTER(BNDataBuffer),
		ctypes.c_void_p,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNSetDataBufferContents(
		buf: ctypes.POINTER(BNDataBuffer), 
		data: Optional[ctypes.c_void_p], 
		len: int
		) -> None:
	return _BNSetDataBufferContents(buf, data, len)


# -------------------------------------------------------
# _BNSetDataBufferLength

_BNSetDataBufferLength = core.BNSetDataBufferLength
_BNSetDataBufferLength.restype = None
_BNSetDataBufferLength.argtypes = [
		ctypes.POINTER(BNDataBuffer),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNSetDataBufferLength(
		buf: ctypes.POINTER(BNDataBuffer), 
		len: int
		) -> None:
	return _BNSetDataBufferLength(buf, len)


# -------------------------------------------------------
# _BNSetDatabaseCurrentSnapshot

_BNSetDatabaseCurrentSnapshot = core.BNSetDatabaseCurrentSnapshot
_BNSetDatabaseCurrentSnapshot.restype = None
_BNSetDatabaseCurrentSnapshot.argtypes = [
		ctypes.POINTER(BNDatabase),
		ctypes.c_longlong,
	]


# noinspection PyPep8Naming
def BNSetDatabaseCurrentSnapshot(
		database: ctypes.POINTER(BNDatabase), 
		id: int
		) -> None:
	return _BNSetDatabaseCurrentSnapshot(database, id)


# -------------------------------------------------------
# _BNSetDebugInfo

_BNSetDebugInfo = core.BNSetDebugInfo
_BNSetDebugInfo.restype = None
_BNSetDebugInfo.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNDebugInfo),
	]


# noinspection PyPep8Naming
def BNSetDebugInfo(
		view: ctypes.POINTER(BNBinaryView), 
		newDebugInfo: ctypes.POINTER(BNDebugInfo)
		) -> None:
	return _BNSetDebugInfo(view, newDebugInfo)


# -------------------------------------------------------
# _BNSetDefaultArchitecture

_BNSetDefaultArchitecture = core.BNSetDefaultArchitecture
_BNSetDefaultArchitecture.restype = None
_BNSetDefaultArchitecture.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNArchitecture),
	]


# noinspection PyPep8Naming
def BNSetDefaultArchitecture(
		view: ctypes.POINTER(BNBinaryView), 
		arch: ctypes.POINTER(BNArchitecture)
		) -> None:
	return _BNSetDefaultArchitecture(view, arch)


# -------------------------------------------------------
# _BNSetDefaultPlatform

_BNSetDefaultPlatform = core.BNSetDefaultPlatform
_BNSetDefaultPlatform.restype = None
_BNSetDefaultPlatform.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNPlatform),
	]


# noinspection PyPep8Naming
def BNSetDefaultPlatform(
		view: ctypes.POINTER(BNBinaryView), 
		platform: ctypes.POINTER(BNPlatform)
		) -> None:
	return _BNSetDefaultPlatform(view, platform)


# -------------------------------------------------------
# _BNSetDisassemblyGutterWidth

_BNSetDisassemblyGutterWidth = core.BNSetDisassemblyGutterWidth
_BNSetDisassemblyGutterWidth.restype = None
_BNSetDisassemblyGutterWidth.argtypes = [
		ctypes.POINTER(BNDisassemblySettings),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNSetDisassemblyGutterWidth(
		settings: ctypes.POINTER(BNDisassemblySettings), 
		width: int
		) -> None:
	return _BNSetDisassemblyGutterWidth(settings, width)


# -------------------------------------------------------
# _BNSetDisassemblyMaximumSymbolWidth

_BNSetDisassemblyMaximumSymbolWidth = core.BNSetDisassemblyMaximumSymbolWidth
_BNSetDisassemblyMaximumSymbolWidth.restype = None
_BNSetDisassemblyMaximumSymbolWidth.argtypes = [
		ctypes.POINTER(BNDisassemblySettings),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNSetDisassemblyMaximumSymbolWidth(
		settings: ctypes.POINTER(BNDisassemblySettings), 
		width: int
		) -> None:
	return _BNSetDisassemblyMaximumSymbolWidth(settings, width)


# -------------------------------------------------------
# _BNSetDisassemblySettingsOption

_BNSetDisassemblySettingsOption = core.BNSetDisassemblySettingsOption
_BNSetDisassemblySettingsOption.restype = None
_BNSetDisassemblySettingsOption.argtypes = [
		ctypes.POINTER(BNDisassemblySettings),
		DisassemblyOptionEnum,
		ctypes.c_bool,
	]


# noinspection PyPep8Naming
def BNSetDisassemblySettingsOption(
		settings: ctypes.POINTER(BNDisassemblySettings), 
		option: DisassemblyOption, 
		state: bool
		) -> None:
	return _BNSetDisassemblySettingsOption(settings, option, state)


# -------------------------------------------------------
# _BNSetDisassemblyTextRendererArchitecture

_BNSetDisassemblyTextRendererArchitecture = core.BNSetDisassemblyTextRendererArchitecture
_BNSetDisassemblyTextRendererArchitecture.restype = None
_BNSetDisassemblyTextRendererArchitecture.argtypes = [
		ctypes.POINTER(BNDisassemblyTextRenderer),
		ctypes.POINTER(BNArchitecture),
	]


# noinspection PyPep8Naming
def BNSetDisassemblyTextRendererArchitecture(
		renderer: ctypes.POINTER(BNDisassemblyTextRenderer), 
		arch: ctypes.POINTER(BNArchitecture)
		) -> None:
	return _BNSetDisassemblyTextRendererArchitecture(renderer, arch)


# -------------------------------------------------------
# _BNSetDisassemblyTextRendererBasicBlock

_BNSetDisassemblyTextRendererBasicBlock = core.BNSetDisassemblyTextRendererBasicBlock
_BNSetDisassemblyTextRendererBasicBlock.restype = None
_BNSetDisassemblyTextRendererBasicBlock.argtypes = [
		ctypes.POINTER(BNDisassemblyTextRenderer),
		ctypes.POINTER(BNBasicBlock),
	]


# noinspection PyPep8Naming
def BNSetDisassemblyTextRendererBasicBlock(
		renderer: ctypes.POINTER(BNDisassemblyTextRenderer), 
		block: ctypes.POINTER(BNBasicBlock)
		) -> None:
	return _BNSetDisassemblyTextRendererBasicBlock(renderer, block)


# -------------------------------------------------------
# _BNSetDisassemblyTextRendererSettings

_BNSetDisassemblyTextRendererSettings = core.BNSetDisassemblyTextRendererSettings
_BNSetDisassemblyTextRendererSettings.restype = None
_BNSetDisassemblyTextRendererSettings.argtypes = [
		ctypes.POINTER(BNDisassemblyTextRenderer),
		ctypes.POINTER(BNDisassemblySettings),
	]


# noinspection PyPep8Naming
def BNSetDisassemblyTextRendererSettings(
		renderer: ctypes.POINTER(BNDisassemblyTextRenderer), 
		settings: ctypes.POINTER(BNDisassemblySettings)
		) -> None:
	return _BNSetDisassemblyTextRendererSettings(renderer, settings)


# -------------------------------------------------------
# _BNSetDisassemblyWidth

_BNSetDisassemblyWidth = core.BNSetDisassemblyWidth
_BNSetDisassemblyWidth.restype = None
_BNSetDisassemblyWidth.argtypes = [
		ctypes.POINTER(BNDisassemblySettings),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNSetDisassemblyWidth(
		settings: ctypes.POINTER(BNDisassemblySettings), 
		width: int
		) -> None:
	return _BNSetDisassemblyWidth(settings, width)


# -------------------------------------------------------
# _BNSetEnterpriseServerUrl

_BNSetEnterpriseServerUrl = core.BNSetEnterpriseServerUrl
_BNSetEnterpriseServerUrl.restype = ctypes.c_bool
_BNSetEnterpriseServerUrl.argtypes = [
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNSetEnterpriseServerUrl(
		url: Optional[str]
		) -> bool:
	return _BNSetEnterpriseServerUrl(cstr(url))


# -------------------------------------------------------
# _BNSetErrorForDownloadInstance

_BNSetErrorForDownloadInstance = core.BNSetErrorForDownloadInstance
_BNSetErrorForDownloadInstance.restype = None
_BNSetErrorForDownloadInstance.argtypes = [
		ctypes.POINTER(BNDownloadInstance),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNSetErrorForDownloadInstance(
		instance: ctypes.POINTER(BNDownloadInstance), 
		error: Optional[str]
		) -> None:
	return _BNSetErrorForDownloadInstance(instance, cstr(error))


# -------------------------------------------------------
# _BNSetFileMetadataNavigationHandler

_BNSetFileMetadataNavigationHandler = core.BNSetFileMetadataNavigationHandler
_BNSetFileMetadataNavigationHandler.restype = None
_BNSetFileMetadataNavigationHandler.argtypes = [
		ctypes.POINTER(BNFileMetadata),
		ctypes.POINTER(BNNavigationHandler),
	]


# noinspection PyPep8Naming
def BNSetFileMetadataNavigationHandler(
		file: ctypes.POINTER(BNFileMetadata), 
		handler: ctypes.POINTER(BNNavigationHandler)
		) -> None:
	return _BNSetFileMetadataNavigationHandler(file, handler)


# -------------------------------------------------------
# _BNSetFilename

_BNSetFilename = core.BNSetFilename
_BNSetFilename.restype = None
_BNSetFilename.argtypes = [
		ctypes.POINTER(BNFileMetadata),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNSetFilename(
		file: ctypes.POINTER(BNFileMetadata), 
		name: Optional[str]
		) -> None:
	return _BNSetFilename(file, cstr(name))


# -------------------------------------------------------
# _BNSetFlowGraphBasicBlock

_BNSetFlowGraphBasicBlock = core.BNSetFlowGraphBasicBlock
_BNSetFlowGraphBasicBlock.restype = None
_BNSetFlowGraphBasicBlock.argtypes = [
		ctypes.POINTER(BNFlowGraphNode),
		ctypes.POINTER(BNBasicBlock),
	]


# noinspection PyPep8Naming
def BNSetFlowGraphBasicBlock(
		node: ctypes.POINTER(BNFlowGraphNode), 
		block: ctypes.POINTER(BNBasicBlock)
		) -> None:
	return _BNSetFlowGraphBasicBlock(node, block)


# -------------------------------------------------------
# _BNSetFlowGraphHighLevelILFunction

_BNSetFlowGraphHighLevelILFunction = core.BNSetFlowGraphHighLevelILFunction
_BNSetFlowGraphHighLevelILFunction.restype = None
_BNSetFlowGraphHighLevelILFunction.argtypes = [
		ctypes.POINTER(BNFlowGraph),
		ctypes.POINTER(BNHighLevelILFunction),
	]


# noinspection PyPep8Naming
def BNSetFlowGraphHighLevelILFunction(
		graph: ctypes.POINTER(BNFlowGraph), 
		func: ctypes.POINTER(BNHighLevelILFunction)
		) -> None:
	return _BNSetFlowGraphHighLevelILFunction(graph, func)


# -------------------------------------------------------
# _BNSetFlowGraphLowLevelILFunction

_BNSetFlowGraphLowLevelILFunction = core.BNSetFlowGraphLowLevelILFunction
_BNSetFlowGraphLowLevelILFunction.restype = None
_BNSetFlowGraphLowLevelILFunction.argtypes = [
		ctypes.POINTER(BNFlowGraph),
		ctypes.POINTER(BNLowLevelILFunction),
	]


# noinspection PyPep8Naming
def BNSetFlowGraphLowLevelILFunction(
		graph: ctypes.POINTER(BNFlowGraph), 
		func: ctypes.POINTER(BNLowLevelILFunction)
		) -> None:
	return _BNSetFlowGraphLowLevelILFunction(graph, func)


# -------------------------------------------------------
# _BNSetFlowGraphMediumLevelILFunction

_BNSetFlowGraphMediumLevelILFunction = core.BNSetFlowGraphMediumLevelILFunction
_BNSetFlowGraphMediumLevelILFunction.restype = None
_BNSetFlowGraphMediumLevelILFunction.argtypes = [
		ctypes.POINTER(BNFlowGraph),
		ctypes.POINTER(BNMediumLevelILFunction),
	]


# noinspection PyPep8Naming
def BNSetFlowGraphMediumLevelILFunction(
		graph: ctypes.POINTER(BNFlowGraph), 
		func: ctypes.POINTER(BNMediumLevelILFunction)
		) -> None:
	return _BNSetFlowGraphMediumLevelILFunction(graph, func)


# -------------------------------------------------------
# _BNSetFlowGraphNodeHighlight

_BNSetFlowGraphNodeHighlight = core.BNSetFlowGraphNodeHighlight
_BNSetFlowGraphNodeHighlight.restype = None
_BNSetFlowGraphNodeHighlight.argtypes = [
		ctypes.POINTER(BNFlowGraphNode),
		BNHighlightColor,
	]


# noinspection PyPep8Naming
def BNSetFlowGraphNodeHighlight(
		node: ctypes.POINTER(BNFlowGraphNode), 
		color: BNHighlightColor
		) -> None:
	return _BNSetFlowGraphNodeHighlight(node, color)


# -------------------------------------------------------
# _BNSetFlowGraphNodeLines

_BNSetFlowGraphNodeLines = core.BNSetFlowGraphNodeLines
_BNSetFlowGraphNodeLines.restype = None
_BNSetFlowGraphNodeLines.argtypes = [
		ctypes.POINTER(BNFlowGraphNode),
		ctypes.POINTER(BNDisassemblyTextLine),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNSetFlowGraphNodeLines(
		node: ctypes.POINTER(BNFlowGraphNode), 
		lines: ctypes.POINTER(BNDisassemblyTextLine), 
		count: int
		) -> None:
	return _BNSetFlowGraphNodeLines(node, lines, count)


# -------------------------------------------------------
# _BNSetFlowGraphNodeMargins

_BNSetFlowGraphNodeMargins = core.BNSetFlowGraphNodeMargins
_BNSetFlowGraphNodeMargins.restype = None
_BNSetFlowGraphNodeMargins.argtypes = [
		ctypes.POINTER(BNFlowGraph),
		ctypes.c_int,
		ctypes.c_int,
	]


# noinspection PyPep8Naming
def BNSetFlowGraphNodeMargins(
		graph: ctypes.POINTER(BNFlowGraph), 
		horiz: int, 
		vert: int
		) -> None:
	return _BNSetFlowGraphNodeMargins(graph, horiz, vert)


# -------------------------------------------------------
# _BNSetFlowGraphOption

_BNSetFlowGraphOption = core.BNSetFlowGraphOption
_BNSetFlowGraphOption.restype = None
_BNSetFlowGraphOption.argtypes = [
		ctypes.POINTER(BNFlowGraph),
		FlowGraphOptionEnum,
		ctypes.c_bool,
	]


# noinspection PyPep8Naming
def BNSetFlowGraphOption(
		graph: ctypes.POINTER(BNFlowGraph), 
		option: FlowGraphOption, 
		value: bool
		) -> None:
	return _BNSetFlowGraphOption(graph, option, value)


# -------------------------------------------------------
# _BNSetFunctionAnalysisSkipOverride

_BNSetFunctionAnalysisSkipOverride = core.BNSetFunctionAnalysisSkipOverride
_BNSetFunctionAnalysisSkipOverride.restype = None
_BNSetFunctionAnalysisSkipOverride.argtypes = [
		ctypes.POINTER(BNFunction),
		FunctionAnalysisSkipOverrideEnum,
	]


# noinspection PyPep8Naming
def BNSetFunctionAnalysisSkipOverride(
		func: ctypes.POINTER(BNFunction), 
		skip: FunctionAnalysisSkipOverride
		) -> None:
	return _BNSetFunctionAnalysisSkipOverride(func, skip)


# -------------------------------------------------------
# _BNSetFunctionAutoType

_BNSetFunctionAutoType = core.BNSetFunctionAutoType
_BNSetFunctionAutoType.restype = None
_BNSetFunctionAutoType.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNType),
	]


# noinspection PyPep8Naming
def BNSetFunctionAutoType(
		func: ctypes.POINTER(BNFunction), 
		type: ctypes.POINTER(BNType)
		) -> None:
	return _BNSetFunctionAutoType(func, type)


# -------------------------------------------------------
# _BNSetFunctionComment

_BNSetFunctionComment = core.BNSetFunctionComment
_BNSetFunctionComment.restype = None
_BNSetFunctionComment.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNSetFunctionComment(
		func: ctypes.POINTER(BNFunction), 
		comment: Optional[str]
		) -> None:
	return _BNSetFunctionComment(func, cstr(comment))


# -------------------------------------------------------
# _BNSetFunctionForFlowGraph

_BNSetFunctionForFlowGraph = core.BNSetFunctionForFlowGraph
_BNSetFunctionForFlowGraph.restype = None
_BNSetFunctionForFlowGraph.argtypes = [
		ctypes.POINTER(BNFlowGraph),
		ctypes.POINTER(BNFunction),
	]


# noinspection PyPep8Naming
def BNSetFunctionForFlowGraph(
		graph: ctypes.POINTER(BNFlowGraph), 
		func: ctypes.POINTER(BNFunction)
		) -> None:
	return _BNSetFunctionForFlowGraph(graph, func)


# -------------------------------------------------------
# _BNSetFunctionTypeBuilderCanReturn

_BNSetFunctionTypeBuilderCanReturn = core.BNSetFunctionTypeBuilderCanReturn
_BNSetFunctionTypeBuilderCanReturn.restype = None
_BNSetFunctionTypeBuilderCanReturn.argtypes = [
		ctypes.POINTER(BNTypeBuilder),
		ctypes.POINTER(BNBoolWithConfidence),
	]


# noinspection PyPep8Naming
def BNSetFunctionTypeBuilderCanReturn(
		type: ctypes.POINTER(BNTypeBuilder), 
		canReturn: ctypes.POINTER(BNBoolWithConfidence)
		) -> None:
	return _BNSetFunctionTypeBuilderCanReturn(type, canReturn)


# -------------------------------------------------------
# _BNSetFunctionTypeBuilderParameters

_BNSetFunctionTypeBuilderParameters = core.BNSetFunctionTypeBuilderParameters
_BNSetFunctionTypeBuilderParameters.restype = None
_BNSetFunctionTypeBuilderParameters.argtypes = [
		ctypes.POINTER(BNTypeBuilder),
		ctypes.POINTER(BNFunctionParameter),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNSetFunctionTypeBuilderParameters(
		type: ctypes.POINTER(BNTypeBuilder), 
		params: ctypes.POINTER(BNFunctionParameter), 
		paramCount: int
		) -> None:
	return _BNSetFunctionTypeBuilderParameters(type, params, paramCount)


# -------------------------------------------------------
# _BNSetFunctionUserType

_BNSetFunctionUserType = core.BNSetFunctionUserType
_BNSetFunctionUserType.restype = None
_BNSetFunctionUserType.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNType),
	]


# noinspection PyPep8Naming
def BNSetFunctionUserType(
		func: ctypes.POINTER(BNFunction), 
		type: ctypes.POINTER(BNType)
		) -> None:
	return _BNSetFunctionUserType(func, type)


# -------------------------------------------------------
# _BNSetFunctionVariableDeadStoreElimination

_BNSetFunctionVariableDeadStoreElimination = core.BNSetFunctionVariableDeadStoreElimination
_BNSetFunctionVariableDeadStoreElimination.restype = None
_BNSetFunctionVariableDeadStoreElimination.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNVariable),
		DeadStoreEliminationEnum,
	]


# noinspection PyPep8Naming
def BNSetFunctionVariableDeadStoreElimination(
		func: ctypes.POINTER(BNFunction), 
		var: ctypes.POINTER(BNVariable), 
		mode: DeadStoreElimination
		) -> None:
	return _BNSetFunctionVariableDeadStoreElimination(func, var, mode)


# -------------------------------------------------------
# _BNSetGlobalCommentForAddress

_BNSetGlobalCommentForAddress = core.BNSetGlobalCommentForAddress
_BNSetGlobalCommentForAddress.restype = None
_BNSetGlobalCommentForAddress.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNSetGlobalCommentForAddress(
		view: ctypes.POINTER(BNBinaryView), 
		addr: int, 
		comment: Optional[str]
		) -> None:
	return _BNSetGlobalCommentForAddress(view, addr, cstr(comment))


# -------------------------------------------------------
# _BNSetHighLevelILExprAttributes

_BNSetHighLevelILExprAttributes = core.BNSetHighLevelILExprAttributes
_BNSetHighLevelILExprAttributes.restype = None
_BNSetHighLevelILExprAttributes.argtypes = [
		ctypes.POINTER(BNHighLevelILFunction),
		ctypes.c_ulonglong,
		ctypes.c_uint,
	]


# noinspection PyPep8Naming
def BNSetHighLevelILExprAttributes(
		func: ctypes.POINTER(BNHighLevelILFunction), 
		expr: int, 
		attributes: int
		) -> None:
	return _BNSetHighLevelILExprAttributes(func, expr, attributes)


# -------------------------------------------------------
# _BNSetHighLevelILExprType

_BNSetHighLevelILExprType = core.BNSetHighLevelILExprType
_BNSetHighLevelILExprType.restype = None
_BNSetHighLevelILExprType.argtypes = [
		ctypes.POINTER(BNHighLevelILFunction),
		ctypes.c_ulonglong,
		ctypes.POINTER(BNTypeWithConfidence),
	]


# noinspection PyPep8Naming
def BNSetHighLevelILExprType(
		func: ctypes.POINTER(BNHighLevelILFunction), 
		expr: int, 
		type: ctypes.POINTER(BNTypeWithConfidence)
		) -> None:
	return _BNSetHighLevelILExprType(func, expr, type)


# -------------------------------------------------------
# _BNSetHighLevelILFunction

_BNSetHighLevelILFunction = core.BNSetHighLevelILFunction
_BNSetHighLevelILFunction.restype = None
_BNSetHighLevelILFunction.argtypes = [
		ctypes.POINTER(BNAnalysisContext),
		ctypes.POINTER(BNHighLevelILFunction),
	]


# noinspection PyPep8Naming
def BNSetHighLevelILFunction(
		analysisContext: ctypes.POINTER(BNAnalysisContext), 
		highLevelIL: ctypes.POINTER(BNHighLevelILFunction)
		) -> None:
	return _BNSetHighLevelILFunction(analysisContext, highLevelIL)


# -------------------------------------------------------
# _BNSetHighLevelILRootExpr

_BNSetHighLevelILRootExpr = core.BNSetHighLevelILRootExpr
_BNSetHighLevelILRootExpr.restype = None
_BNSetHighLevelILRootExpr.argtypes = [
		ctypes.POINTER(BNHighLevelILFunction),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNSetHighLevelILRootExpr(
		func: ctypes.POINTER(BNHighLevelILFunction), 
		expr: int
		) -> None:
	return _BNSetHighLevelILRootExpr(func, expr)


# -------------------------------------------------------
# _BNSetIntegerConstantDisplayType

_BNSetIntegerConstantDisplayType = core.BNSetIntegerConstantDisplayType
_BNSetIntegerConstantDisplayType.restype = None
_BNSetIntegerConstantDisplayType.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNArchitecture),
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
		IntegerDisplayTypeEnum,
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNSetIntegerConstantDisplayType(
		func: ctypes.POINTER(BNFunction), 
		arch: ctypes.POINTER(BNArchitecture), 
		instrAddr: int, 
		value: int, 
		operand: int, 
		type: IntegerDisplayType, 
		typeID: Optional[str]
		) -> None:
	return _BNSetIntegerConstantDisplayType(func, arch, instrAddr, value, operand, type, cstr(typeID))


# -------------------------------------------------------
# _BNSetIntegerTypeDisplayType

_BNSetIntegerTypeDisplayType = core.BNSetIntegerTypeDisplayType
_BNSetIntegerTypeDisplayType.restype = None
_BNSetIntegerTypeDisplayType.argtypes = [
		ctypes.POINTER(BNTypeBuilder),
		IntegerDisplayTypeEnum,
	]


# noinspection PyPep8Naming
def BNSetIntegerTypeDisplayType(
		type: ctypes.POINTER(BNTypeBuilder), 
		displayType: IntegerDisplayType
		) -> None:
	return _BNSetIntegerTypeDisplayType(type, displayType)


# -------------------------------------------------------
# _BNSetKeyValueStoreBuffer

_BNSetKeyValueStoreBuffer = core.BNSetKeyValueStoreBuffer
_BNSetKeyValueStoreBuffer.restype = ctypes.c_bool
_BNSetKeyValueStoreBuffer.argtypes = [
		ctypes.POINTER(BNKeyValueStore),
		ctypes.c_char_p,
		ctypes.POINTER(BNDataBuffer),
	]


# noinspection PyPep8Naming
def BNSetKeyValueStoreBuffer(
		store: ctypes.POINTER(BNKeyValueStore), 
		name: Optional[str], 
		value: ctypes.POINTER(BNDataBuffer)
		) -> bool:
	return _BNSetKeyValueStoreBuffer(store, cstr(name), value)


# -------------------------------------------------------
# _BNSetKeyValueStoreValue

_BNSetKeyValueStoreValue = core.BNSetKeyValueStoreValue
_BNSetKeyValueStoreValue.restype = ctypes.c_bool
_BNSetKeyValueStoreValue.argtypes = [
		ctypes.POINTER(BNKeyValueStore),
		ctypes.c_char_p,
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNSetKeyValueStoreValue(
		store: ctypes.POINTER(BNKeyValueStore), 
		name: Optional[str], 
		value: Optional[str]
		) -> bool:
	return _BNSetKeyValueStoreValue(store, cstr(name), cstr(value))


# -------------------------------------------------------
# _BNSetLicense

_BNSetLicense = core.BNSetLicense
_BNSetLicense.restype = None
_BNSetLicense.argtypes = [
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNSetLicense(
		licenseData: Optional[str]
		) -> None:
	return _BNSetLicense(cstr(licenseData))


# -------------------------------------------------------
# _BNSetLiftedILFunction

_BNSetLiftedILFunction = core.BNSetLiftedILFunction
_BNSetLiftedILFunction.restype = None
_BNSetLiftedILFunction.argtypes = [
		ctypes.POINTER(BNAnalysisContext),
		ctypes.POINTER(BNLowLevelILFunction),
	]


# noinspection PyPep8Naming
def BNSetLiftedILFunction(
		analysisContext: ctypes.POINTER(BNAnalysisContext), 
		liftedIL: ctypes.POINTER(BNLowLevelILFunction)
		) -> None:
	return _BNSetLiftedILFunction(analysisContext, liftedIL)


# -------------------------------------------------------
# _BNSetLowLevelILExprAttributes

_BNSetLowLevelILExprAttributes = core.BNSetLowLevelILExprAttributes
_BNSetLowLevelILExprAttributes.restype = None
_BNSetLowLevelILExprAttributes.argtypes = [
		ctypes.POINTER(BNLowLevelILFunction),
		ctypes.c_ulonglong,
		ctypes.c_uint,
	]


# noinspection PyPep8Naming
def BNSetLowLevelILExprAttributes(
		func: ctypes.POINTER(BNLowLevelILFunction), 
		expr: int, 
		attributes: int
		) -> None:
	return _BNSetLowLevelILExprAttributes(func, expr, attributes)


# -------------------------------------------------------
# _BNSetLowLevelILFunction

_BNSetLowLevelILFunction = core.BNSetLowLevelILFunction
_BNSetLowLevelILFunction.restype = None
_BNSetLowLevelILFunction.argtypes = [
		ctypes.POINTER(BNAnalysisContext),
		ctypes.POINTER(BNLowLevelILFunction),
	]


# noinspection PyPep8Naming
def BNSetLowLevelILFunction(
		analysisContext: ctypes.POINTER(BNAnalysisContext), 
		lowLevelIL: ctypes.POINTER(BNLowLevelILFunction)
		) -> None:
	return _BNSetLowLevelILFunction(analysisContext, lowLevelIL)


# -------------------------------------------------------
# _BNSetMaxFunctionSizeForAnalysis

_BNSetMaxFunctionSizeForAnalysis = core.BNSetMaxFunctionSizeForAnalysis
_BNSetMaxFunctionSizeForAnalysis.restype = None
_BNSetMaxFunctionSizeForAnalysis.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNSetMaxFunctionSizeForAnalysis(
		view: ctypes.POINTER(BNBinaryView), 
		size: int
		) -> None:
	return _BNSetMaxFunctionSizeForAnalysis(view, size)


# -------------------------------------------------------
# _BNSetMediumLevelILExprAttributes

_BNSetMediumLevelILExprAttributes = core.BNSetMediumLevelILExprAttributes
_BNSetMediumLevelILExprAttributes.restype = None
_BNSetMediumLevelILExprAttributes.argtypes = [
		ctypes.POINTER(BNMediumLevelILFunction),
		ctypes.c_ulonglong,
		ctypes.c_uint,
	]


# noinspection PyPep8Naming
def BNSetMediumLevelILExprAttributes(
		func: ctypes.POINTER(BNMediumLevelILFunction), 
		expr: int, 
		attributes: int
		) -> None:
	return _BNSetMediumLevelILExprAttributes(func, expr, attributes)


# -------------------------------------------------------
# _BNSetMediumLevelILExprType

_BNSetMediumLevelILExprType = core.BNSetMediumLevelILExprType
_BNSetMediumLevelILExprType.restype = None
_BNSetMediumLevelILExprType.argtypes = [
		ctypes.POINTER(BNMediumLevelILFunction),
		ctypes.c_ulonglong,
		ctypes.POINTER(BNTypeWithConfidence),
	]


# noinspection PyPep8Naming
def BNSetMediumLevelILExprType(
		func: ctypes.POINTER(BNMediumLevelILFunction), 
		expr: int, 
		type: ctypes.POINTER(BNTypeWithConfidence)
		) -> None:
	return _BNSetMediumLevelILExprType(func, expr, type)


# -------------------------------------------------------
# _BNSetMediumLevelILFunction

_BNSetMediumLevelILFunction = core.BNSetMediumLevelILFunction
_BNSetMediumLevelILFunction.restype = None
_BNSetMediumLevelILFunction.argtypes = [
		ctypes.POINTER(BNAnalysisContext),
		ctypes.POINTER(BNMediumLevelILFunction),
	]


# noinspection PyPep8Naming
def BNSetMediumLevelILFunction(
		analysisContext: ctypes.POINTER(BNAnalysisContext), 
		mediumLevelIL: ctypes.POINTER(BNMediumLevelILFunction)
		) -> None:
	return _BNSetMediumLevelILFunction(analysisContext, mediumLevelIL)


# -------------------------------------------------------
# _BNSetNamedTypeReferenceBuilderName

_BNSetNamedTypeReferenceBuilderName = core.BNSetNamedTypeReferenceBuilderName
_BNSetNamedTypeReferenceBuilderName.restype = None
_BNSetNamedTypeReferenceBuilderName.argtypes = [
		ctypes.POINTER(BNNamedTypeReferenceBuilder),
		ctypes.POINTER(BNQualifiedName),
	]


# noinspection PyPep8Naming
def BNSetNamedTypeReferenceBuilderName(
		s: ctypes.POINTER(BNNamedTypeReferenceBuilder), 
		name: ctypes.POINTER(BNQualifiedName)
		) -> None:
	return _BNSetNamedTypeReferenceBuilderName(s, name)


# -------------------------------------------------------
# _BNSetNamedTypeReferenceBuilderTypeClass

_BNSetNamedTypeReferenceBuilderTypeClass = core.BNSetNamedTypeReferenceBuilderTypeClass
_BNSetNamedTypeReferenceBuilderTypeClass.restype = None
_BNSetNamedTypeReferenceBuilderTypeClass.argtypes = [
		ctypes.POINTER(BNNamedTypeReferenceBuilder),
		NamedTypeReferenceClassEnum,
	]


# noinspection PyPep8Naming
def BNSetNamedTypeReferenceBuilderTypeClass(
		s: ctypes.POINTER(BNNamedTypeReferenceBuilder), 
		type: NamedTypeReferenceClass
		) -> None:
	return _BNSetNamedTypeReferenceBuilderTypeClass(s, type)


# -------------------------------------------------------
# _BNSetNamedTypeReferenceBuilderTypeId

_BNSetNamedTypeReferenceBuilderTypeId = core.BNSetNamedTypeReferenceBuilderTypeId
_BNSetNamedTypeReferenceBuilderTypeId.restype = None
_BNSetNamedTypeReferenceBuilderTypeId.argtypes = [
		ctypes.POINTER(BNNamedTypeReferenceBuilder),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNSetNamedTypeReferenceBuilderTypeId(
		s: ctypes.POINTER(BNNamedTypeReferenceBuilder), 
		id: Optional[str]
		) -> None:
	return _BNSetNamedTypeReferenceBuilderTypeId(s, cstr(id))


# -------------------------------------------------------
# _BNSetNewAutoFunctionAnalysisSuppressed

_BNSetNewAutoFunctionAnalysisSuppressed = core.BNSetNewAutoFunctionAnalysisSuppressed
_BNSetNewAutoFunctionAnalysisSuppressed.restype = None
_BNSetNewAutoFunctionAnalysisSuppressed.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_bool,
	]


# noinspection PyPep8Naming
def BNSetNewAutoFunctionAnalysisSuppressed(
		view: ctypes.POINTER(BNBinaryView), 
		suppress: bool
		) -> None:
	return _BNSetNewAutoFunctionAnalysisSuppressed(view, suppress)


# -------------------------------------------------------
# _BNSetOriginalBase

_BNSetOriginalBase = core.BNSetOriginalBase
_BNSetOriginalBase.restype = None
_BNSetOriginalBase.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNSetOriginalBase(
		view: ctypes.POINTER(BNBinaryView), 
		base: int
		) -> None:
	return _BNSetOriginalBase(view, base)


# -------------------------------------------------------
# _BNSetOriginalFilename

_BNSetOriginalFilename = core.BNSetOriginalFilename
_BNSetOriginalFilename.restype = None
_BNSetOriginalFilename.argtypes = [
		ctypes.POINTER(BNFileMetadata),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNSetOriginalFilename(
		file: ctypes.POINTER(BNFileMetadata), 
		name: Optional[str]
		) -> None:
	return _BNSetOriginalFilename(file, cstr(name))


# -------------------------------------------------------
# _BNSetParametersForAnalysis

_BNSetParametersForAnalysis = core.BNSetParametersForAnalysis
_BNSetParametersForAnalysis.restype = None
_BNSetParametersForAnalysis.argtypes = [
		ctypes.POINTER(BNBinaryView),
		BNAnalysisParameters,
	]


# noinspection PyPep8Naming
def BNSetParametersForAnalysis(
		view: ctypes.POINTER(BNBinaryView), 
		params: BNAnalysisParameters
		) -> None:
	return _BNSetParametersForAnalysis(view, params)


# -------------------------------------------------------
# _BNSetPlatformSystemCallConvention

_BNSetPlatformSystemCallConvention = core.BNSetPlatformSystemCallConvention
_BNSetPlatformSystemCallConvention.restype = None
_BNSetPlatformSystemCallConvention.argtypes = [
		ctypes.POINTER(BNPlatform),
		ctypes.POINTER(BNCallingConvention),
	]


# noinspection PyPep8Naming
def BNSetPlatformSystemCallConvention(
		platform: ctypes.POINTER(BNPlatform), 
		cc: ctypes.POINTER(BNCallingConvention)
		) -> None:
	return _BNSetPlatformSystemCallConvention(platform, cc)


# -------------------------------------------------------
# _BNSetProjectFile

_BNSetProjectFile = core.BNSetProjectFile
_BNSetProjectFile.restype = None
_BNSetProjectFile.argtypes = [
		ctypes.POINTER(BNFileMetadata),
		ctypes.POINTER(BNProjectFile),
	]


# noinspection PyPep8Naming
def BNSetProjectFile(
		file: ctypes.POINTER(BNFileMetadata), 
		pfile: ctypes.POINTER(BNProjectFile)
		) -> None:
	return _BNSetProjectFile(file, pfile)


# -------------------------------------------------------
# _BNSetSaveSettingsName

_BNSetSaveSettingsName = core.BNSetSaveSettingsName
_BNSetSaveSettingsName.restype = None
_BNSetSaveSettingsName.argtypes = [
		ctypes.POINTER(BNSaveSettings),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNSetSaveSettingsName(
		settings: ctypes.POINTER(BNSaveSettings), 
		name: Optional[str]
		) -> None:
	return _BNSetSaveSettingsName(settings, cstr(name))


# -------------------------------------------------------
# _BNSetSaveSettingsOption

_BNSetSaveSettingsOption = core.BNSetSaveSettingsOption
_BNSetSaveSettingsOption.restype = None
_BNSetSaveSettingsOption.argtypes = [
		ctypes.POINTER(BNSaveSettings),
		SaveOptionEnum,
		ctypes.c_bool,
	]


# noinspection PyPep8Naming
def BNSetSaveSettingsOption(
		settings: ctypes.POINTER(BNSaveSettings), 
		option: SaveOption, 
		state: bool
		) -> None:
	return _BNSetSaveSettingsOption(settings, option, state)


# -------------------------------------------------------
# _BNSetScriptingInstanceCurrentAddress

_BNSetScriptingInstanceCurrentAddress = core.BNSetScriptingInstanceCurrentAddress
_BNSetScriptingInstanceCurrentAddress.restype = None
_BNSetScriptingInstanceCurrentAddress.argtypes = [
		ctypes.POINTER(BNScriptingInstance),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNSetScriptingInstanceCurrentAddress(
		instance: ctypes.POINTER(BNScriptingInstance), 
		addr: int
		) -> None:
	return _BNSetScriptingInstanceCurrentAddress(instance, addr)


# -------------------------------------------------------
# _BNSetScriptingInstanceCurrentBasicBlock

_BNSetScriptingInstanceCurrentBasicBlock = core.BNSetScriptingInstanceCurrentBasicBlock
_BNSetScriptingInstanceCurrentBasicBlock.restype = None
_BNSetScriptingInstanceCurrentBasicBlock.argtypes = [
		ctypes.POINTER(BNScriptingInstance),
		ctypes.POINTER(BNBasicBlock),
	]


# noinspection PyPep8Naming
def BNSetScriptingInstanceCurrentBasicBlock(
		instance: ctypes.POINTER(BNScriptingInstance), 
		block: ctypes.POINTER(BNBasicBlock)
		) -> None:
	return _BNSetScriptingInstanceCurrentBasicBlock(instance, block)


# -------------------------------------------------------
# _BNSetScriptingInstanceCurrentBinaryView

_BNSetScriptingInstanceCurrentBinaryView = core.BNSetScriptingInstanceCurrentBinaryView
_BNSetScriptingInstanceCurrentBinaryView.restype = None
_BNSetScriptingInstanceCurrentBinaryView.argtypes = [
		ctypes.POINTER(BNScriptingInstance),
		ctypes.POINTER(BNBinaryView),
	]


# noinspection PyPep8Naming
def BNSetScriptingInstanceCurrentBinaryView(
		instance: ctypes.POINTER(BNScriptingInstance), 
		view: ctypes.POINTER(BNBinaryView)
		) -> None:
	return _BNSetScriptingInstanceCurrentBinaryView(instance, view)


# -------------------------------------------------------
# _BNSetScriptingInstanceCurrentFunction

_BNSetScriptingInstanceCurrentFunction = core.BNSetScriptingInstanceCurrentFunction
_BNSetScriptingInstanceCurrentFunction.restype = None
_BNSetScriptingInstanceCurrentFunction.argtypes = [
		ctypes.POINTER(BNScriptingInstance),
		ctypes.POINTER(BNFunction),
	]


# noinspection PyPep8Naming
def BNSetScriptingInstanceCurrentFunction(
		instance: ctypes.POINTER(BNScriptingInstance), 
		func: ctypes.POINTER(BNFunction)
		) -> None:
	return _BNSetScriptingInstanceCurrentFunction(instance, func)


# -------------------------------------------------------
# _BNSetScriptingInstanceCurrentSelection

_BNSetScriptingInstanceCurrentSelection = core.BNSetScriptingInstanceCurrentSelection
_BNSetScriptingInstanceCurrentSelection.restype = None
_BNSetScriptingInstanceCurrentSelection.argtypes = [
		ctypes.POINTER(BNScriptingInstance),
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNSetScriptingInstanceCurrentSelection(
		instance: ctypes.POINTER(BNScriptingInstance), 
		begin: int, 
		end: int
		) -> None:
	return _BNSetScriptingInstanceCurrentSelection(instance, begin, end)


# -------------------------------------------------------
# _BNSetScriptingInstanceDelimiters

_BNSetScriptingInstanceDelimiters = core.BNSetScriptingInstanceDelimiters
_BNSetScriptingInstanceDelimiters.restype = None
_BNSetScriptingInstanceDelimiters.argtypes = [
		ctypes.POINTER(BNScriptingInstance),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNSetScriptingInstanceDelimiters(
		instance: ctypes.POINTER(BNScriptingInstance), 
		delimiters: Optional[str]
		) -> None:
	return _BNSetScriptingInstanceDelimiters(instance, cstr(delimiters))


# -------------------------------------------------------
# _BNSetSnapshotName

_BNSetSnapshotName = core.BNSetSnapshotName
_BNSetSnapshotName.restype = None
_BNSetSnapshotName.argtypes = [
		ctypes.POINTER(BNSnapshot),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNSetSnapshotName(
		snapshot: ctypes.POINTER(BNSnapshot), 
		name: Optional[str]
		) -> None:
	return _BNSetSnapshotName(snapshot, cstr(name))


# -------------------------------------------------------
# _BNSetStructureBuilderAlignment

_BNSetStructureBuilderAlignment = core.BNSetStructureBuilderAlignment
_BNSetStructureBuilderAlignment.restype = None
_BNSetStructureBuilderAlignment.argtypes = [
		ctypes.POINTER(BNStructureBuilder),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNSetStructureBuilderAlignment(
		s: ctypes.POINTER(BNStructureBuilder), 
		align: int
		) -> None:
	return _BNSetStructureBuilderAlignment(s, align)


# -------------------------------------------------------
# _BNSetStructureBuilderPacked

_BNSetStructureBuilderPacked = core.BNSetStructureBuilderPacked
_BNSetStructureBuilderPacked.restype = None
_BNSetStructureBuilderPacked.argtypes = [
		ctypes.POINTER(BNStructureBuilder),
		ctypes.c_bool,
	]


# noinspection PyPep8Naming
def BNSetStructureBuilderPacked(
		s: ctypes.POINTER(BNStructureBuilder), 
		packed: bool
		) -> None:
	return _BNSetStructureBuilderPacked(s, packed)


# -------------------------------------------------------
# _BNSetStructureBuilderPointerOffset

_BNSetStructureBuilderPointerOffset = core.BNSetStructureBuilderPointerOffset
_BNSetStructureBuilderPointerOffset.restype = None
_BNSetStructureBuilderPointerOffset.argtypes = [
		ctypes.POINTER(BNStructureBuilder),
		ctypes.c_longlong,
	]


# noinspection PyPep8Naming
def BNSetStructureBuilderPointerOffset(
		s: ctypes.POINTER(BNStructureBuilder), 
		offset: int
		) -> None:
	return _BNSetStructureBuilderPointerOffset(s, offset)


# -------------------------------------------------------
# _BNSetStructureBuilderPropagatesDataVariableReferences

_BNSetStructureBuilderPropagatesDataVariableReferences = core.BNSetStructureBuilderPropagatesDataVariableReferences
_BNSetStructureBuilderPropagatesDataVariableReferences.restype = None
_BNSetStructureBuilderPropagatesDataVariableReferences.argtypes = [
		ctypes.POINTER(BNStructureBuilder),
		ctypes.c_bool,
	]


# noinspection PyPep8Naming
def BNSetStructureBuilderPropagatesDataVariableReferences(
		s: ctypes.POINTER(BNStructureBuilder), 
		value: bool
		) -> None:
	return _BNSetStructureBuilderPropagatesDataVariableReferences(s, value)


# -------------------------------------------------------
# _BNSetStructureBuilderType

_BNSetStructureBuilderType = core.BNSetStructureBuilderType
_BNSetStructureBuilderType.restype = None
_BNSetStructureBuilderType.argtypes = [
		ctypes.POINTER(BNStructureBuilder),
		StructureVariantEnum,
	]


# noinspection PyPep8Naming
def BNSetStructureBuilderType(
		s: ctypes.POINTER(BNStructureBuilder), 
		type: StructureVariant
		) -> None:
	return _BNSetStructureBuilderType(s, type)


# -------------------------------------------------------
# _BNSetStructureBuilderWidth

_BNSetStructureBuilderWidth = core.BNSetStructureBuilderWidth
_BNSetStructureBuilderWidth.restype = None
_BNSetStructureBuilderWidth.argtypes = [
		ctypes.POINTER(BNStructureBuilder),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNSetStructureBuilderWidth(
		s: ctypes.POINTER(BNStructureBuilder), 
		width: int
		) -> None:
	return _BNSetStructureBuilderWidth(s, width)


# -------------------------------------------------------
# _BNSetTypeArchiveCurrentSnapshot

_BNSetTypeArchiveCurrentSnapshot = core.BNSetTypeArchiveCurrentSnapshot
_BNSetTypeArchiveCurrentSnapshot.restype = None
_BNSetTypeArchiveCurrentSnapshot.argtypes = [
		ctypes.POINTER(BNTypeArchive),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNSetTypeArchiveCurrentSnapshot(
		archive: ctypes.POINTER(BNTypeArchive), 
		id: Optional[str]
		) -> None:
	return _BNSetTypeArchiveCurrentSnapshot(archive, cstr(id))


# -------------------------------------------------------
# _BNSetTypeBuilderNamedTypeReference

_BNSetTypeBuilderNamedTypeReference = core.BNSetTypeBuilderNamedTypeReference
_BNSetTypeBuilderNamedTypeReference.restype = None
_BNSetTypeBuilderNamedTypeReference.argtypes = [
		ctypes.POINTER(BNTypeBuilder),
		ctypes.POINTER(BNNamedTypeReference),
	]


# noinspection PyPep8Naming
def BNSetTypeBuilderNamedTypeReference(
		type: ctypes.POINTER(BNTypeBuilder), 
		ntr: ctypes.POINTER(BNNamedTypeReference)
		) -> None:
	return _BNSetTypeBuilderNamedTypeReference(type, ntr)


# -------------------------------------------------------
# _BNSetTypeBuilderOffset

_BNSetTypeBuilderOffset = core.BNSetTypeBuilderOffset
_BNSetTypeBuilderOffset.restype = None
_BNSetTypeBuilderOffset.argtypes = [
		ctypes.POINTER(BNTypeBuilder),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNSetTypeBuilderOffset(
		type: ctypes.POINTER(BNTypeBuilder), 
		offset: int
		) -> None:
	return _BNSetTypeBuilderOffset(type, offset)


# -------------------------------------------------------
# _BNSetTypeBuilderPure

_BNSetTypeBuilderPure = core.BNSetTypeBuilderPure
_BNSetTypeBuilderPure.restype = None
_BNSetTypeBuilderPure.argtypes = [
		ctypes.POINTER(BNTypeBuilder),
		ctypes.POINTER(BNBoolWithConfidence),
	]


# noinspection PyPep8Naming
def BNSetTypeBuilderPure(
		type: ctypes.POINTER(BNTypeBuilder), 
		pure: ctypes.POINTER(BNBoolWithConfidence)
		) -> None:
	return _BNSetTypeBuilderPure(type, pure)


# -------------------------------------------------------
# _BNSetTypeLibraryDependencyName

_BNSetTypeLibraryDependencyName = core.BNSetTypeLibraryDependencyName
_BNSetTypeLibraryDependencyName.restype = None
_BNSetTypeLibraryDependencyName.argtypes = [
		ctypes.POINTER(BNTypeLibrary),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNSetTypeLibraryDependencyName(
		lib: ctypes.POINTER(BNTypeLibrary), 
		name: Optional[str]
		) -> None:
	return _BNSetTypeLibraryDependencyName(lib, cstr(name))


# -------------------------------------------------------
# _BNSetTypeLibraryGuid

_BNSetTypeLibraryGuid = core.BNSetTypeLibraryGuid
_BNSetTypeLibraryGuid.restype = None
_BNSetTypeLibraryGuid.argtypes = [
		ctypes.POINTER(BNTypeLibrary),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNSetTypeLibraryGuid(
		lib: ctypes.POINTER(BNTypeLibrary), 
		name: Optional[str]
		) -> None:
	return _BNSetTypeLibraryGuid(lib, cstr(name))


# -------------------------------------------------------
# _BNSetTypeLibraryName

_BNSetTypeLibraryName = core.BNSetTypeLibraryName
_BNSetTypeLibraryName.restype = None
_BNSetTypeLibraryName.argtypes = [
		ctypes.POINTER(BNTypeLibrary),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNSetTypeLibraryName(
		lib: ctypes.POINTER(BNTypeLibrary), 
		name: Optional[str]
		) -> None:
	return _BNSetTypeLibraryName(lib, cstr(name))


# -------------------------------------------------------
# _BNSetUserBasicBlockHighlight

_BNSetUserBasicBlockHighlight = core.BNSetUserBasicBlockHighlight
_BNSetUserBasicBlockHighlight.restype = None
_BNSetUserBasicBlockHighlight.argtypes = [
		ctypes.POINTER(BNBasicBlock),
		BNHighlightColor,
	]


# noinspection PyPep8Naming
def BNSetUserBasicBlockHighlight(
		block: ctypes.POINTER(BNBasicBlock), 
		color: BNHighlightColor
		) -> None:
	return _BNSetUserBasicBlockHighlight(block, color)


# -------------------------------------------------------
# _BNSetUserCallRegisterStackAdjustment

_BNSetUserCallRegisterStackAdjustment = core.BNSetUserCallRegisterStackAdjustment
_BNSetUserCallRegisterStackAdjustment.restype = None
_BNSetUserCallRegisterStackAdjustment.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNArchitecture),
		ctypes.c_ulonglong,
		ctypes.POINTER(BNRegisterStackAdjustment),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNSetUserCallRegisterStackAdjustment(
		func: ctypes.POINTER(BNFunction), 
		arch: ctypes.POINTER(BNArchitecture), 
		addr: int, 
		adjust: ctypes.POINTER(BNRegisterStackAdjustment), 
		count: int
		) -> None:
	return _BNSetUserCallRegisterStackAdjustment(func, arch, addr, adjust, count)


# -------------------------------------------------------
# _BNSetUserCallRegisterStackAdjustmentForRegisterStack

_BNSetUserCallRegisterStackAdjustmentForRegisterStack = core.BNSetUserCallRegisterStackAdjustmentForRegisterStack
_BNSetUserCallRegisterStackAdjustmentForRegisterStack.restype = None
_BNSetUserCallRegisterStackAdjustmentForRegisterStack.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNArchitecture),
		ctypes.c_ulonglong,
		ctypes.c_uint,
		ctypes.c_int,
		ctypes.c_ubyte,
	]


# noinspection PyPep8Naming
def BNSetUserCallRegisterStackAdjustmentForRegisterStack(
		func: ctypes.POINTER(BNFunction), 
		arch: ctypes.POINTER(BNArchitecture), 
		addr: int, 
		regStack: int, 
		adjust: int, 
		confidence: int
		) -> None:
	return _BNSetUserCallRegisterStackAdjustmentForRegisterStack(func, arch, addr, regStack, adjust, confidence)


# -------------------------------------------------------
# _BNSetUserCallStackAdjustment

_BNSetUserCallStackAdjustment = core.BNSetUserCallStackAdjustment
_BNSetUserCallStackAdjustment.restype = None
_BNSetUserCallStackAdjustment.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNArchitecture),
		ctypes.c_ulonglong,
		ctypes.c_longlong,
		ctypes.c_ubyte,
	]


# noinspection PyPep8Naming
def BNSetUserCallStackAdjustment(
		func: ctypes.POINTER(BNFunction), 
		arch: ctypes.POINTER(BNArchitecture), 
		addr: int, 
		adjust: int, 
		confidence: int
		) -> None:
	return _BNSetUserCallStackAdjustment(func, arch, addr, adjust, confidence)


# -------------------------------------------------------
# _BNSetUserCallTypeAdjustment

_BNSetUserCallTypeAdjustment = core.BNSetUserCallTypeAdjustment
_BNSetUserCallTypeAdjustment.restype = None
_BNSetUserCallTypeAdjustment.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNArchitecture),
		ctypes.c_ulonglong,
		ctypes.POINTER(BNTypeWithConfidence),
	]


# noinspection PyPep8Naming
def BNSetUserCallTypeAdjustment(
		func: ctypes.POINTER(BNFunction), 
		arch: ctypes.POINTER(BNArchitecture), 
		addr: int, 
		type: ctypes.POINTER(BNTypeWithConfidence)
		) -> None:
	return _BNSetUserCallTypeAdjustment(func, arch, addr, type)


# -------------------------------------------------------
# _BNSetUserFunctionCallingConvention

_BNSetUserFunctionCallingConvention = core.BNSetUserFunctionCallingConvention
_BNSetUserFunctionCallingConvention.restype = None
_BNSetUserFunctionCallingConvention.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNCallingConventionWithConfidence),
	]


# noinspection PyPep8Naming
def BNSetUserFunctionCallingConvention(
		func: ctypes.POINTER(BNFunction), 
		convention: ctypes.POINTER(BNCallingConventionWithConfidence)
		) -> None:
	return _BNSetUserFunctionCallingConvention(func, convention)


# -------------------------------------------------------
# _BNSetUserFunctionCanReturn

_BNSetUserFunctionCanReturn = core.BNSetUserFunctionCanReturn
_BNSetUserFunctionCanReturn.restype = None
_BNSetUserFunctionCanReturn.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNBoolWithConfidence),
	]


# noinspection PyPep8Naming
def BNSetUserFunctionCanReturn(
		func: ctypes.POINTER(BNFunction), 
		returns: ctypes.POINTER(BNBoolWithConfidence)
		) -> None:
	return _BNSetUserFunctionCanReturn(func, returns)


# -------------------------------------------------------
# _BNSetUserFunctionClobberedRegisters

_BNSetUserFunctionClobberedRegisters = core.BNSetUserFunctionClobberedRegisters
_BNSetUserFunctionClobberedRegisters.restype = None
_BNSetUserFunctionClobberedRegisters.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNRegisterSetWithConfidence),
	]


# noinspection PyPep8Naming
def BNSetUserFunctionClobberedRegisters(
		func: ctypes.POINTER(BNFunction), 
		regs: ctypes.POINTER(BNRegisterSetWithConfidence)
		) -> None:
	return _BNSetUserFunctionClobberedRegisters(func, regs)


# -------------------------------------------------------
# _BNSetUserFunctionHasVariableArguments

_BNSetUserFunctionHasVariableArguments = core.BNSetUserFunctionHasVariableArguments
_BNSetUserFunctionHasVariableArguments.restype = None
_BNSetUserFunctionHasVariableArguments.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNBoolWithConfidence),
	]


# noinspection PyPep8Naming
def BNSetUserFunctionHasVariableArguments(
		func: ctypes.POINTER(BNFunction), 
		varArgs: ctypes.POINTER(BNBoolWithConfidence)
		) -> None:
	return _BNSetUserFunctionHasVariableArguments(func, varArgs)


# -------------------------------------------------------
# _BNSetUserFunctionInlinedDuringAnalysis

_BNSetUserFunctionInlinedDuringAnalysis = core.BNSetUserFunctionInlinedDuringAnalysis
_BNSetUserFunctionInlinedDuringAnalysis.restype = None
_BNSetUserFunctionInlinedDuringAnalysis.argtypes = [
		ctypes.POINTER(BNFunction),
		BNBoolWithConfidence,
	]


# noinspection PyPep8Naming
def BNSetUserFunctionInlinedDuringAnalysis(
		func: ctypes.POINTER(BNFunction), 
		inlined: BNBoolWithConfidence
		) -> None:
	return _BNSetUserFunctionInlinedDuringAnalysis(func, inlined)


# -------------------------------------------------------
# _BNSetUserFunctionParameterVariables

_BNSetUserFunctionParameterVariables = core.BNSetUserFunctionParameterVariables
_BNSetUserFunctionParameterVariables.restype = None
_BNSetUserFunctionParameterVariables.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNParameterVariablesWithConfidence),
	]


# noinspection PyPep8Naming
def BNSetUserFunctionParameterVariables(
		func: ctypes.POINTER(BNFunction), 
		vars: ctypes.POINTER(BNParameterVariablesWithConfidence)
		) -> None:
	return _BNSetUserFunctionParameterVariables(func, vars)


# -------------------------------------------------------
# _BNSetUserFunctionPure

_BNSetUserFunctionPure = core.BNSetUserFunctionPure
_BNSetUserFunctionPure.restype = None
_BNSetUserFunctionPure.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNBoolWithConfidence),
	]


# noinspection PyPep8Naming
def BNSetUserFunctionPure(
		func: ctypes.POINTER(BNFunction), 
		pure: ctypes.POINTER(BNBoolWithConfidence)
		) -> None:
	return _BNSetUserFunctionPure(func, pure)


# -------------------------------------------------------
# _BNSetUserFunctionRegisterStackAdjustments

_BNSetUserFunctionRegisterStackAdjustments = core.BNSetUserFunctionRegisterStackAdjustments
_BNSetUserFunctionRegisterStackAdjustments.restype = None
_BNSetUserFunctionRegisterStackAdjustments.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNRegisterStackAdjustment),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNSetUserFunctionRegisterStackAdjustments(
		func: ctypes.POINTER(BNFunction), 
		adjustments: ctypes.POINTER(BNRegisterStackAdjustment), 
		count: int
		) -> None:
	return _BNSetUserFunctionRegisterStackAdjustments(func, adjustments, count)


# -------------------------------------------------------
# _BNSetUserFunctionReturnRegisters

_BNSetUserFunctionReturnRegisters = core.BNSetUserFunctionReturnRegisters
_BNSetUserFunctionReturnRegisters.restype = None
_BNSetUserFunctionReturnRegisters.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNRegisterSetWithConfidence),
	]


# noinspection PyPep8Naming
def BNSetUserFunctionReturnRegisters(
		func: ctypes.POINTER(BNFunction), 
		regs: ctypes.POINTER(BNRegisterSetWithConfidence)
		) -> None:
	return _BNSetUserFunctionReturnRegisters(func, regs)


# -------------------------------------------------------
# _BNSetUserFunctionReturnType

_BNSetUserFunctionReturnType = core.BNSetUserFunctionReturnType
_BNSetUserFunctionReturnType.restype = None
_BNSetUserFunctionReturnType.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNTypeWithConfidence),
	]


# noinspection PyPep8Naming
def BNSetUserFunctionReturnType(
		func: ctypes.POINTER(BNFunction), 
		type: ctypes.POINTER(BNTypeWithConfidence)
		) -> None:
	return _BNSetUserFunctionReturnType(func, type)


# -------------------------------------------------------
# _BNSetUserFunctionStackAdjustment

_BNSetUserFunctionStackAdjustment = core.BNSetUserFunctionStackAdjustment
_BNSetUserFunctionStackAdjustment.restype = None
_BNSetUserFunctionStackAdjustment.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNOffsetWithConfidence),
	]


# noinspection PyPep8Naming
def BNSetUserFunctionStackAdjustment(
		func: ctypes.POINTER(BNFunction), 
		stackAdjust: ctypes.POINTER(BNOffsetWithConfidence)
		) -> None:
	return _BNSetUserFunctionStackAdjustment(func, stackAdjust)


# -------------------------------------------------------
# _BNSetUserGotoLabelName

_BNSetUserGotoLabelName = core.BNSetUserGotoLabelName
_BNSetUserGotoLabelName.restype = None
_BNSetUserGotoLabelName.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.c_ulonglong,
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNSetUserGotoLabelName(
		func: ctypes.POINTER(BNFunction), 
		labelId: int, 
		name: Optional[str]
		) -> None:
	return _BNSetUserGotoLabelName(func, labelId, cstr(name))


# -------------------------------------------------------
# _BNSetUserIndirectBranches

_BNSetUserIndirectBranches = core.BNSetUserIndirectBranches
_BNSetUserIndirectBranches.restype = None
_BNSetUserIndirectBranches.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNArchitecture),
		ctypes.c_ulonglong,
		ctypes.POINTER(BNArchitectureAndAddress),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNSetUserIndirectBranches(
		func: ctypes.POINTER(BNFunction), 
		sourceArch: ctypes.POINTER(BNArchitecture), 
		source: int, 
		branches: ctypes.POINTER(BNArchitectureAndAddress), 
		count: int
		) -> None:
	return _BNSetUserIndirectBranches(func, sourceArch, source, branches, count)


# -------------------------------------------------------
# _BNSetUserInstructionHighlight

_BNSetUserInstructionHighlight = core.BNSetUserInstructionHighlight
_BNSetUserInstructionHighlight.restype = None
_BNSetUserInstructionHighlight.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNArchitecture),
		ctypes.c_ulonglong,
		BNHighlightColor,
	]


# noinspection PyPep8Naming
def BNSetUserInstructionHighlight(
		func: ctypes.POINTER(BNFunction), 
		arch: ctypes.POINTER(BNArchitecture), 
		addr: int, 
		color: BNHighlightColor
		) -> None:
	return _BNSetUserInstructionHighlight(func, arch, addr, color)


# -------------------------------------------------------
# _BNSetUserVariableValue

_BNSetUserVariableValue = core.BNSetUserVariableValue
_BNSetUserVariableValue.restype = None
_BNSetUserVariableValue.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNVariable),
		ctypes.POINTER(BNArchitectureAndAddress),
		ctypes.POINTER(BNPossibleValueSet),
	]


# noinspection PyPep8Naming
def BNSetUserVariableValue(
		func: ctypes.POINTER(BNFunction), 
		var: ctypes.POINTER(BNVariable), 
		defSite: ctypes.POINTER(BNArchitectureAndAddress), 
		value: ctypes.POINTER(BNPossibleValueSet)
		) -> None:
	return _BNSetUserVariableValue(func, var, defSite, value)


# -------------------------------------------------------
# _BNSetViewForFlowGraph

_BNSetViewForFlowGraph = core.BNSetViewForFlowGraph
_BNSetViewForFlowGraph.restype = None
_BNSetViewForFlowGraph.argtypes = [
		ctypes.POINTER(BNFlowGraph),
		ctypes.POINTER(BNBinaryView),
	]


# noinspection PyPep8Naming
def BNSetViewForFlowGraph(
		graph: ctypes.POINTER(BNFlowGraph), 
		view: ctypes.POINTER(BNBinaryView)
		) -> None:
	return _BNSetViewForFlowGraph(graph, view)


# -------------------------------------------------------
# _BNSetWorkerThreadCount

_BNSetWorkerThreadCount = core.BNSetWorkerThreadCount
_BNSetWorkerThreadCount.restype = None
_BNSetWorkerThreadCount.argtypes = [
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNSetWorkerThreadCount(
		count: int
		) -> None:
	return _BNSetWorkerThreadCount(count)


# -------------------------------------------------------
# _BNSettingsContains

_BNSettingsContains = core.BNSettingsContains
_BNSettingsContains.restype = ctypes.c_bool
_BNSettingsContains.argtypes = [
		ctypes.POINTER(BNSettings),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNSettingsContains(
		settings: ctypes.POINTER(BNSettings), 
		key: Optional[str]
		) -> bool:
	return _BNSettingsContains(settings, cstr(key))


# -------------------------------------------------------
# _BNSettingsDeserializeSchema

_BNSettingsDeserializeSchema = core.BNSettingsDeserializeSchema
_BNSettingsDeserializeSchema.restype = ctypes.c_bool
_BNSettingsDeserializeSchema.argtypes = [
		ctypes.POINTER(BNSettings),
		ctypes.c_char_p,
		SettingsScopeEnum,
		ctypes.c_bool,
	]


# noinspection PyPep8Naming
def BNSettingsDeserializeSchema(
		settings: ctypes.POINTER(BNSettings), 
		schema: Optional[str], 
		scope: SettingsScope, 
		merge: bool
		) -> bool:
	return _BNSettingsDeserializeSchema(settings, cstr(schema), scope, merge)


# -------------------------------------------------------
# _BNSettingsGetBool

_BNSettingsGetBool = core.BNSettingsGetBool
_BNSettingsGetBool.restype = ctypes.c_bool
_BNSettingsGetBool.argtypes = [
		ctypes.POINTER(BNSettings),
		ctypes.c_char_p,
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(SettingsScopeEnum),
	]


# noinspection PyPep8Naming
def BNSettingsGetBool(
		settings: ctypes.POINTER(BNSettings), 
		key: Optional[str], 
		view: ctypes.POINTER(BNBinaryView), 
		scope: ctypes.POINTER(SettingsScopeEnum)
		) -> bool:
	return _BNSettingsGetBool(settings, cstr(key), view, scope)


# -------------------------------------------------------
# _BNSettingsGetDouble

_BNSettingsGetDouble = core.BNSettingsGetDouble
_BNSettingsGetDouble.restype = ctypes.c_double
_BNSettingsGetDouble.argtypes = [
		ctypes.POINTER(BNSettings),
		ctypes.c_char_p,
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(SettingsScopeEnum),
	]


# noinspection PyPep8Naming
def BNSettingsGetDouble(
		settings: ctypes.POINTER(BNSettings), 
		key: Optional[str], 
		view: ctypes.POINTER(BNBinaryView), 
		scope: ctypes.POINTER(SettingsScopeEnum)
		) -> float:
	return _BNSettingsGetDouble(settings, cstr(key), view, scope)


# -------------------------------------------------------
# _BNSettingsGetInt64

_BNSettingsGetInt64 = core.BNSettingsGetInt64
_BNSettingsGetInt64.restype = ctypes.c_longlong
_BNSettingsGetInt64.argtypes = [
		ctypes.POINTER(BNSettings),
		ctypes.c_char_p,
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(SettingsScopeEnum),
	]


# noinspection PyPep8Naming
def BNSettingsGetInt64(
		settings: ctypes.POINTER(BNSettings), 
		key: Optional[str], 
		view: ctypes.POINTER(BNBinaryView), 
		scope: ctypes.POINTER(SettingsScopeEnum)
		) -> int:
	return _BNSettingsGetInt64(settings, cstr(key), view, scope)


# -------------------------------------------------------
# _BNSettingsGetJson

_BNSettingsGetJson = core.BNSettingsGetJson
_BNSettingsGetJson.restype = ctypes.POINTER(ctypes.c_byte)
_BNSettingsGetJson.argtypes = [
		ctypes.POINTER(BNSettings),
		ctypes.c_char_p,
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(SettingsScopeEnum),
	]


# noinspection PyPep8Naming
def BNSettingsGetJson(
		settings: ctypes.POINTER(BNSettings), 
		key: Optional[str], 
		view: ctypes.POINTER(BNBinaryView), 
		scope: ctypes.POINTER(SettingsScopeEnum)
		) -> Optional[Optional[str]]:
	result = _BNSettingsGetJson(settings, cstr(key), view, scope)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNSettingsGetString

_BNSettingsGetString = core.BNSettingsGetString
_BNSettingsGetString.restype = ctypes.POINTER(ctypes.c_byte)
_BNSettingsGetString.argtypes = [
		ctypes.POINTER(BNSettings),
		ctypes.c_char_p,
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(SettingsScopeEnum),
	]


# noinspection PyPep8Naming
def BNSettingsGetString(
		settings: ctypes.POINTER(BNSettings), 
		key: Optional[str], 
		view: ctypes.POINTER(BNBinaryView), 
		scope: ctypes.POINTER(SettingsScopeEnum)
		) -> Optional[Optional[str]]:
	result = _BNSettingsGetString(settings, cstr(key), view, scope)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNSettingsGetStringList

_BNSettingsGetStringList = core.BNSettingsGetStringList
_BNSettingsGetStringList.restype = ctypes.POINTER(ctypes.c_char_p)
_BNSettingsGetStringList.argtypes = [
		ctypes.POINTER(BNSettings),
		ctypes.c_char_p,
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(SettingsScopeEnum),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNSettingsGetStringList(
		settings: ctypes.POINTER(BNSettings), 
		key: Optional[str], 
		view: ctypes.POINTER(BNBinaryView), 
		scope: ctypes.POINTER(SettingsScopeEnum), 
		inoutSize: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_char_p)]:
	result = _BNSettingsGetStringList(settings, cstr(key), view, scope, inoutSize)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNSettingsGetUInt64

_BNSettingsGetUInt64 = core.BNSettingsGetUInt64
_BNSettingsGetUInt64.restype = ctypes.c_ulonglong
_BNSettingsGetUInt64.argtypes = [
		ctypes.POINTER(BNSettings),
		ctypes.c_char_p,
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(SettingsScopeEnum),
	]


# noinspection PyPep8Naming
def BNSettingsGetUInt64(
		settings: ctypes.POINTER(BNSettings), 
		key: Optional[str], 
		view: ctypes.POINTER(BNBinaryView), 
		scope: ctypes.POINTER(SettingsScopeEnum)
		) -> int:
	return _BNSettingsGetUInt64(settings, cstr(key), view, scope)


# -------------------------------------------------------
# _BNSettingsIsEmpty

_BNSettingsIsEmpty = core.BNSettingsIsEmpty
_BNSettingsIsEmpty.restype = ctypes.c_bool
_BNSettingsIsEmpty.argtypes = [
		ctypes.POINTER(BNSettings),
	]


# noinspection PyPep8Naming
def BNSettingsIsEmpty(
		settings: ctypes.POINTER(BNSettings)
		) -> bool:
	return _BNSettingsIsEmpty(settings)


# -------------------------------------------------------
# _BNSettingsKeysList

_BNSettingsKeysList = core.BNSettingsKeysList
_BNSettingsKeysList.restype = ctypes.POINTER(ctypes.c_char_p)
_BNSettingsKeysList.argtypes = [
		ctypes.POINTER(BNSettings),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNSettingsKeysList(
		settings: ctypes.POINTER(BNSettings), 
		inoutSize: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_char_p)]:
	result = _BNSettingsKeysList(settings, inoutSize)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNSettingsQueryPropertyStringList

_BNSettingsQueryPropertyStringList = core.BNSettingsQueryPropertyStringList
_BNSettingsQueryPropertyStringList.restype = ctypes.POINTER(ctypes.c_char_p)
_BNSettingsQueryPropertyStringList.argtypes = [
		ctypes.POINTER(BNSettings),
		ctypes.c_char_p,
		ctypes.c_char_p,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNSettingsQueryPropertyStringList(
		settings: ctypes.POINTER(BNSettings), 
		key: Optional[str], 
		property: Optional[str], 
		inoutSize: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_char_p)]:
	result = _BNSettingsQueryPropertyStringList(settings, cstr(key), cstr(property), inoutSize)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNSettingsRegisterGroup

_BNSettingsRegisterGroup = core.BNSettingsRegisterGroup
_BNSettingsRegisterGroup.restype = ctypes.c_bool
_BNSettingsRegisterGroup.argtypes = [
		ctypes.POINTER(BNSettings),
		ctypes.c_char_p,
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNSettingsRegisterGroup(
		settings: ctypes.POINTER(BNSettings), 
		group: Optional[str], 
		title: Optional[str]
		) -> bool:
	return _BNSettingsRegisterGroup(settings, cstr(group), cstr(title))


# -------------------------------------------------------
# _BNSettingsRegisterSetting

_BNSettingsRegisterSetting = core.BNSettingsRegisterSetting
_BNSettingsRegisterSetting.restype = ctypes.c_bool
_BNSettingsRegisterSetting.argtypes = [
		ctypes.POINTER(BNSettings),
		ctypes.c_char_p,
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNSettingsRegisterSetting(
		settings: ctypes.POINTER(BNSettings), 
		key: Optional[str], 
		properties: Optional[str]
		) -> bool:
	return _BNSettingsRegisterSetting(settings, cstr(key), cstr(properties))


# -------------------------------------------------------
# _BNSettingsReset

_BNSettingsReset = core.BNSettingsReset
_BNSettingsReset.restype = ctypes.c_bool
_BNSettingsReset.argtypes = [
		ctypes.POINTER(BNSettings),
		ctypes.c_char_p,
		ctypes.POINTER(BNBinaryView),
		SettingsScopeEnum,
	]


# noinspection PyPep8Naming
def BNSettingsReset(
		settings: ctypes.POINTER(BNSettings), 
		key: Optional[str], 
		view: ctypes.POINTER(BNBinaryView), 
		scope: SettingsScope
		) -> bool:
	return _BNSettingsReset(settings, cstr(key), view, scope)


# -------------------------------------------------------
# _BNSettingsResetAll

_BNSettingsResetAll = core.BNSettingsResetAll
_BNSettingsResetAll.restype = ctypes.c_bool
_BNSettingsResetAll.argtypes = [
		ctypes.POINTER(BNSettings),
		ctypes.POINTER(BNBinaryView),
		SettingsScopeEnum,
		ctypes.c_bool,
	]


# noinspection PyPep8Naming
def BNSettingsResetAll(
		settings: ctypes.POINTER(BNSettings), 
		view: ctypes.POINTER(BNBinaryView), 
		scope: SettingsScope, 
		schemaOnly: bool
		) -> bool:
	return _BNSettingsResetAll(settings, view, scope, schemaOnly)


# -------------------------------------------------------
# _BNSettingsSerializeSchema

_BNSettingsSerializeSchema = core.BNSettingsSerializeSchema
_BNSettingsSerializeSchema.restype = ctypes.POINTER(ctypes.c_byte)
_BNSettingsSerializeSchema.argtypes = [
		ctypes.POINTER(BNSettings),
	]


# noinspection PyPep8Naming
def BNSettingsSerializeSchema(
		settings: ctypes.POINTER(BNSettings)
		) -> Optional[Optional[str]]:
	result = _BNSettingsSerializeSchema(settings)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNSettingsSetBool

_BNSettingsSetBool = core.BNSettingsSetBool
_BNSettingsSetBool.restype = ctypes.c_bool
_BNSettingsSetBool.argtypes = [
		ctypes.POINTER(BNSettings),
		ctypes.POINTER(BNBinaryView),
		SettingsScopeEnum,
		ctypes.c_char_p,
		ctypes.c_bool,
	]


# noinspection PyPep8Naming
def BNSettingsSetBool(
		settings: ctypes.POINTER(BNSettings), 
		view: ctypes.POINTER(BNBinaryView), 
		scope: SettingsScope, 
		key: Optional[str], 
		value: bool
		) -> bool:
	return _BNSettingsSetBool(settings, view, scope, cstr(key), value)


# -------------------------------------------------------
# _BNSettingsSetDouble

_BNSettingsSetDouble = core.BNSettingsSetDouble
_BNSettingsSetDouble.restype = ctypes.c_bool
_BNSettingsSetDouble.argtypes = [
		ctypes.POINTER(BNSettings),
		ctypes.POINTER(BNBinaryView),
		SettingsScopeEnum,
		ctypes.c_char_p,
		ctypes.c_double,
	]


# noinspection PyPep8Naming
def BNSettingsSetDouble(
		settings: ctypes.POINTER(BNSettings), 
		view: ctypes.POINTER(BNBinaryView), 
		scope: SettingsScope, 
		key: Optional[str], 
		value: float
		) -> bool:
	return _BNSettingsSetDouble(settings, view, scope, cstr(key), value)


# -------------------------------------------------------
# _BNSettingsSetInt64

_BNSettingsSetInt64 = core.BNSettingsSetInt64
_BNSettingsSetInt64.restype = ctypes.c_bool
_BNSettingsSetInt64.argtypes = [
		ctypes.POINTER(BNSettings),
		ctypes.POINTER(BNBinaryView),
		SettingsScopeEnum,
		ctypes.c_char_p,
		ctypes.c_longlong,
	]


# noinspection PyPep8Naming
def BNSettingsSetInt64(
		settings: ctypes.POINTER(BNSettings), 
		view: ctypes.POINTER(BNBinaryView), 
		scope: SettingsScope, 
		key: Optional[str], 
		value: int
		) -> bool:
	return _BNSettingsSetInt64(settings, view, scope, cstr(key), value)


# -------------------------------------------------------
# _BNSettingsSetJson

_BNSettingsSetJson = core.BNSettingsSetJson
_BNSettingsSetJson.restype = ctypes.c_bool
_BNSettingsSetJson.argtypes = [
		ctypes.POINTER(BNSettings),
		ctypes.POINTER(BNBinaryView),
		SettingsScopeEnum,
		ctypes.c_char_p,
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNSettingsSetJson(
		settings: ctypes.POINTER(BNSettings), 
		view: ctypes.POINTER(BNBinaryView), 
		scope: SettingsScope, 
		key: Optional[str], 
		value: Optional[str]
		) -> bool:
	return _BNSettingsSetJson(settings, view, scope, cstr(key), cstr(value))


# -------------------------------------------------------
# _BNSettingsSetResourceId

_BNSettingsSetResourceId = core.BNSettingsSetResourceId
_BNSettingsSetResourceId.restype = None
_BNSettingsSetResourceId.argtypes = [
		ctypes.POINTER(BNSettings),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNSettingsSetResourceId(
		settings: ctypes.POINTER(BNSettings), 
		resourceId: Optional[str]
		) -> None:
	return _BNSettingsSetResourceId(settings, cstr(resourceId))


# -------------------------------------------------------
# _BNSettingsSetString

_BNSettingsSetString = core.BNSettingsSetString
_BNSettingsSetString.restype = ctypes.c_bool
_BNSettingsSetString.argtypes = [
		ctypes.POINTER(BNSettings),
		ctypes.POINTER(BNBinaryView),
		SettingsScopeEnum,
		ctypes.c_char_p,
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNSettingsSetString(
		settings: ctypes.POINTER(BNSettings), 
		view: ctypes.POINTER(BNBinaryView), 
		scope: SettingsScope, 
		key: Optional[str], 
		value: Optional[str]
		) -> bool:
	return _BNSettingsSetString(settings, view, scope, cstr(key), cstr(value))


# -------------------------------------------------------
# _BNSettingsSetStringList

_BNSettingsSetStringList = core.BNSettingsSetStringList
_BNSettingsSetStringList.restype = ctypes.c_bool
_BNSettingsSetStringList.argtypes = [
		ctypes.POINTER(BNSettings),
		ctypes.POINTER(BNBinaryView),
		SettingsScopeEnum,
		ctypes.c_char_p,
		ctypes.POINTER(ctypes.c_char_p),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNSettingsSetStringList(
		settings: ctypes.POINTER(BNSettings), 
		view: ctypes.POINTER(BNBinaryView), 
		scope: SettingsScope, 
		key: Optional[str], 
		value: ctypes.POINTER(ctypes.c_char_p), 
		size: int
		) -> bool:
	return _BNSettingsSetStringList(settings, view, scope, cstr(key), value, size)


# -------------------------------------------------------
# _BNSettingsSetUInt64

_BNSettingsSetUInt64 = core.BNSettingsSetUInt64
_BNSettingsSetUInt64.restype = ctypes.c_bool
_BNSettingsSetUInt64.argtypes = [
		ctypes.POINTER(BNSettings),
		ctypes.POINTER(BNBinaryView),
		SettingsScopeEnum,
		ctypes.c_char_p,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNSettingsSetUInt64(
		settings: ctypes.POINTER(BNSettings), 
		view: ctypes.POINTER(BNBinaryView), 
		scope: SettingsScope, 
		key: Optional[str], 
		value: int
		) -> bool:
	return _BNSettingsSetUInt64(settings, view, scope, cstr(key), value)


# -------------------------------------------------------
# _BNSettingsUpdateBoolProperty

_BNSettingsUpdateBoolProperty = core.BNSettingsUpdateBoolProperty
_BNSettingsUpdateBoolProperty.restype = ctypes.c_bool
_BNSettingsUpdateBoolProperty.argtypes = [
		ctypes.POINTER(BNSettings),
		ctypes.c_char_p,
		ctypes.c_char_p,
		ctypes.c_bool,
	]


# noinspection PyPep8Naming
def BNSettingsUpdateBoolProperty(
		settings: ctypes.POINTER(BNSettings), 
		key: Optional[str], 
		property: Optional[str], 
		value: bool
		) -> bool:
	return _BNSettingsUpdateBoolProperty(settings, cstr(key), cstr(property), value)


# -------------------------------------------------------
# _BNSettingsUpdateDoubleProperty

_BNSettingsUpdateDoubleProperty = core.BNSettingsUpdateDoubleProperty
_BNSettingsUpdateDoubleProperty.restype = ctypes.c_bool
_BNSettingsUpdateDoubleProperty.argtypes = [
		ctypes.POINTER(BNSettings),
		ctypes.c_char_p,
		ctypes.c_char_p,
		ctypes.c_double,
	]


# noinspection PyPep8Naming
def BNSettingsUpdateDoubleProperty(
		settings: ctypes.POINTER(BNSettings), 
		key: Optional[str], 
		property: Optional[str], 
		value: float
		) -> bool:
	return _BNSettingsUpdateDoubleProperty(settings, cstr(key), cstr(property), value)


# -------------------------------------------------------
# _BNSettingsUpdateInt64Property

_BNSettingsUpdateInt64Property = core.BNSettingsUpdateInt64Property
_BNSettingsUpdateInt64Property.restype = ctypes.c_bool
_BNSettingsUpdateInt64Property.argtypes = [
		ctypes.POINTER(BNSettings),
		ctypes.c_char_p,
		ctypes.c_char_p,
		ctypes.c_longlong,
	]


# noinspection PyPep8Naming
def BNSettingsUpdateInt64Property(
		settings: ctypes.POINTER(BNSettings), 
		key: Optional[str], 
		property: Optional[str], 
		value: int
		) -> bool:
	return _BNSettingsUpdateInt64Property(settings, cstr(key), cstr(property), value)


# -------------------------------------------------------
# _BNSettingsUpdateProperty

_BNSettingsUpdateProperty = core.BNSettingsUpdateProperty
_BNSettingsUpdateProperty.restype = ctypes.c_bool
_BNSettingsUpdateProperty.argtypes = [
		ctypes.POINTER(BNSettings),
		ctypes.c_char_p,
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNSettingsUpdateProperty(
		settings: ctypes.POINTER(BNSettings), 
		key: Optional[str], 
		property: Optional[str]
		) -> bool:
	return _BNSettingsUpdateProperty(settings, cstr(key), cstr(property))


# -------------------------------------------------------
# _BNSettingsUpdateStringListProperty

_BNSettingsUpdateStringListProperty = core.BNSettingsUpdateStringListProperty
_BNSettingsUpdateStringListProperty.restype = ctypes.c_bool
_BNSettingsUpdateStringListProperty.argtypes = [
		ctypes.POINTER(BNSettings),
		ctypes.c_char_p,
		ctypes.c_char_p,
		ctypes.POINTER(ctypes.c_char_p),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNSettingsUpdateStringListProperty(
		settings: ctypes.POINTER(BNSettings), 
		key: Optional[str], 
		property: Optional[str], 
		value: ctypes.POINTER(ctypes.c_char_p), 
		size: int
		) -> bool:
	return _BNSettingsUpdateStringListProperty(settings, cstr(key), cstr(property), value, size)


# -------------------------------------------------------
# _BNSettingsUpdateStringProperty

_BNSettingsUpdateStringProperty = core.BNSettingsUpdateStringProperty
_BNSettingsUpdateStringProperty.restype = ctypes.c_bool
_BNSettingsUpdateStringProperty.argtypes = [
		ctypes.POINTER(BNSettings),
		ctypes.c_char_p,
		ctypes.c_char_p,
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNSettingsUpdateStringProperty(
		settings: ctypes.POINTER(BNSettings), 
		key: Optional[str], 
		property: Optional[str], 
		value: Optional[str]
		) -> bool:
	return _BNSettingsUpdateStringProperty(settings, cstr(key), cstr(property), cstr(value))


# -------------------------------------------------------
# _BNSettingsUpdateUInt64Property

_BNSettingsUpdateUInt64Property = core.BNSettingsUpdateUInt64Property
_BNSettingsUpdateUInt64Property.restype = ctypes.c_bool
_BNSettingsUpdateUInt64Property.argtypes = [
		ctypes.POINTER(BNSettings),
		ctypes.c_char_p,
		ctypes.c_char_p,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNSettingsUpdateUInt64Property(
		settings: ctypes.POINTER(BNSettings), 
		key: Optional[str], 
		property: Optional[str], 
		value: int
		) -> bool:
	return _BNSettingsUpdateUInt64Property(settings, cstr(key), cstr(property), value)


# -------------------------------------------------------
# _BNShowGraphReport

_BNShowGraphReport = core.BNShowGraphReport
_BNShowGraphReport.restype = None
_BNShowGraphReport.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_char_p,
		ctypes.POINTER(BNFlowGraph),
	]


# noinspection PyPep8Naming
def BNShowGraphReport(
		view: ctypes.POINTER(BNBinaryView), 
		title: Optional[str], 
		graph: ctypes.POINTER(BNFlowGraph)
		) -> None:
	return _BNShowGraphReport(view, cstr(title), graph)


# -------------------------------------------------------
# _BNShowHTMLReport

_BNShowHTMLReport = core.BNShowHTMLReport
_BNShowHTMLReport.restype = None
_BNShowHTMLReport.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_char_p,
		ctypes.c_char_p,
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNShowHTMLReport(
		view: ctypes.POINTER(BNBinaryView), 
		title: Optional[str], 
		contents: Optional[str], 
		plaintext: Optional[str]
		) -> None:
	return _BNShowHTMLReport(view, cstr(title), cstr(contents), cstr(plaintext))


# -------------------------------------------------------
# _BNShowMarkdownReport

_BNShowMarkdownReport = core.BNShowMarkdownReport
_BNShowMarkdownReport.restype = None
_BNShowMarkdownReport.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_char_p,
		ctypes.c_char_p,
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNShowMarkdownReport(
		view: ctypes.POINTER(BNBinaryView), 
		title: Optional[str], 
		contents: Optional[str], 
		plaintext: Optional[str]
		) -> None:
	return _BNShowMarkdownReport(view, cstr(title), cstr(contents), cstr(plaintext))


# -------------------------------------------------------
# _BNShowMessageBox

_BNShowMessageBox = core.BNShowMessageBox
_BNShowMessageBox.restype = MessageBoxButtonResultEnum
_BNShowMessageBox.argtypes = [
		ctypes.c_char_p,
		ctypes.c_char_p,
		MessageBoxButtonSetEnum,
		MessageBoxIconEnum,
	]


# noinspection PyPep8Naming
def BNShowMessageBox(
		title: Optional[str], 
		text: Optional[str], 
		buttons: MessageBoxButtonSet, 
		icon: MessageBoxIcon
		) -> MessageBoxButtonResult:
	return _BNShowMessageBox(cstr(title), cstr(text), buttons, icon)


# -------------------------------------------------------
# _BNShowPlainTextReport

_BNShowPlainTextReport = core.BNShowPlainTextReport
_BNShowPlainTextReport.restype = None
_BNShowPlainTextReport.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_char_p,
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNShowPlainTextReport(
		view: ctypes.POINTER(BNBinaryView), 
		title: Optional[str], 
		contents: Optional[str]
		) -> None:
	return _BNShowPlainTextReport(view, cstr(title), cstr(contents))


# -------------------------------------------------------
# _BNShowReportCollection

_BNShowReportCollection = core.BNShowReportCollection
_BNShowReportCollection.restype = None
_BNShowReportCollection.argtypes = [
		ctypes.c_char_p,
		ctypes.POINTER(BNReportCollection),
	]


# noinspection PyPep8Naming
def BNShowReportCollection(
		title: Optional[str], 
		reports: ctypes.POINTER(BNReportCollection)
		) -> None:
	return _BNShowReportCollection(cstr(title), reports)


# -------------------------------------------------------
# _BNShutdown

_BNShutdown = core.BNShutdown
_BNShutdown.restype = None
_BNShutdown.argtypes = [
	]


# noinspection PyPep8Naming
def BNShutdown(
		) -> None:
	return _BNShutdown()


# -------------------------------------------------------
# _BNSkipAndReturnValue

_BNSkipAndReturnValue = core.BNSkipAndReturnValue
_BNSkipAndReturnValue.restype = ctypes.c_bool
_BNSkipAndReturnValue.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNArchitecture),
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNSkipAndReturnValue(
		view: ctypes.POINTER(BNBinaryView), 
		arch: ctypes.POINTER(BNArchitecture), 
		addr: int, 
		value: int
		) -> bool:
	return _BNSkipAndReturnValue(view, arch, addr, value)


# -------------------------------------------------------
# _BNSnapshotHasAncestor

_BNSnapshotHasAncestor = core.BNSnapshotHasAncestor
_BNSnapshotHasAncestor.restype = ctypes.c_bool
_BNSnapshotHasAncestor.argtypes = [
		ctypes.POINTER(BNSnapshot),
		ctypes.POINTER(BNSnapshot),
	]


# noinspection PyPep8Naming
def BNSnapshotHasAncestor(
		snapshot: ctypes.POINTER(BNSnapshot), 
		other: ctypes.POINTER(BNSnapshot)
		) -> bool:
	return _BNSnapshotHasAncestor(snapshot, other)


# -------------------------------------------------------
# _BNSnapshotHasContents

_BNSnapshotHasContents = core.BNSnapshotHasContents
_BNSnapshotHasContents.restype = ctypes.c_bool
_BNSnapshotHasContents.argtypes = [
		ctypes.POINTER(BNSnapshot),
	]


# noinspection PyPep8Naming
def BNSnapshotHasContents(
		snapshot: ctypes.POINTER(BNSnapshot)
		) -> bool:
	return _BNSnapshotHasContents(snapshot)


# -------------------------------------------------------
# _BNSnapshotHasData

_BNSnapshotHasData = core.BNSnapshotHasData
_BNSnapshotHasData.restype = ctypes.c_bool
_BNSnapshotHasData.argtypes = [
		ctypes.POINTER(BNDatabase),
		ctypes.c_longlong,
	]


# noinspection PyPep8Naming
def BNSnapshotHasData(
		db: ctypes.POINTER(BNDatabase), 
		id: int
		) -> bool:
	return _BNSnapshotHasData(db, id)


# -------------------------------------------------------
# _BNSnapshotHasUndo

_BNSnapshotHasUndo = core.BNSnapshotHasUndo
_BNSnapshotHasUndo.restype = ctypes.c_bool
_BNSnapshotHasUndo.argtypes = [
		ctypes.POINTER(BNSnapshot),
	]


# noinspection PyPep8Naming
def BNSnapshotHasUndo(
		snapshot: ctypes.POINTER(BNSnapshot)
		) -> bool:
	return _BNSnapshotHasUndo(snapshot)


# -------------------------------------------------------
# _BNSnapshotStoreData

_BNSnapshotStoreData = core.BNSnapshotStoreData
_BNSnapshotStoreData.restype = ctypes.c_bool
_BNSnapshotStoreData.argtypes = [
		ctypes.POINTER(BNSnapshot),
		ctypes.POINTER(BNKeyValueStore),
		ctypes.c_void_p,
		ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNSnapshotStoreData(
		snapshot: ctypes.POINTER(BNSnapshot), 
		data: ctypes.POINTER(BNKeyValueStore), 
		ctxt: Optional[ctypes.c_void_p], 
		progress: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong)
		) -> bool:
	return _BNSnapshotStoreData(snapshot, data, ctxt, progress)


# -------------------------------------------------------
# _BNSplitVariable

_BNSplitVariable = core.BNSplitVariable
_BNSplitVariable.restype = None
_BNSplitVariable.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNVariable),
	]


# noinspection PyPep8Naming
def BNSplitVariable(
		func: ctypes.POINTER(BNFunction), 
		var: ctypes.POINTER(BNVariable)
		) -> None:
	return _BNSplitVariable(func, var)


# -------------------------------------------------------
# _BNStartFlowGraphLayout

_BNStartFlowGraphLayout = core.BNStartFlowGraphLayout
_BNStartFlowGraphLayout.restype = ctypes.POINTER(BNFlowGraphLayoutRequest)
_BNStartFlowGraphLayout.argtypes = [
		ctypes.POINTER(BNFlowGraph),
		ctypes.c_void_p,
		ctypes.CFUNCTYPE(None, ctypes.c_void_p),
	]


# noinspection PyPep8Naming
def BNStartFlowGraphLayout(
		graph: ctypes.POINTER(BNFlowGraph), 
		ctxt: Optional[ctypes.c_void_p], 
		func: ctypes.CFUNCTYPE(None, ctypes.c_void_p)
		) -> Optional[ctypes.POINTER(BNFlowGraphLayoutRequest)]:
	result = _BNStartFlowGraphLayout(graph, ctxt, func)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNStopScriptingInstance

_BNStopScriptingInstance = core.BNStopScriptingInstance
_BNStopScriptingInstance.restype = None
_BNStopScriptingInstance.argtypes = [
		ctypes.POINTER(BNScriptingInstance),
	]


# noinspection PyPep8Naming
def BNStopScriptingInstance(
		instance: ctypes.POINTER(BNScriptingInstance)
		) -> None:
	return _BNStopScriptingInstance(instance)


# -------------------------------------------------------
# _BNStoreSecretsProviderData

_BNStoreSecretsProviderData = core.BNStoreSecretsProviderData
_BNStoreSecretsProviderData.restype = ctypes.c_bool
_BNStoreSecretsProviderData.argtypes = [
		ctypes.POINTER(BNSecretsProvider),
		ctypes.c_char_p,
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNStoreSecretsProviderData(
		provider: ctypes.POINTER(BNSecretsProvider), 
		key: Optional[str], 
		data: Optional[str]
		) -> bool:
	return _BNStoreSecretsProviderData(provider, cstr(key), cstr(data))


# -------------------------------------------------------
# _BNStructureBuilderPropagatesDataVariableReferences

_BNStructureBuilderPropagatesDataVariableReferences = core.BNStructureBuilderPropagatesDataVariableReferences
_BNStructureBuilderPropagatesDataVariableReferences.restype = ctypes.c_bool
_BNStructureBuilderPropagatesDataVariableReferences.argtypes = [
		ctypes.POINTER(BNStructureBuilder),
	]


# noinspection PyPep8Naming
def BNStructureBuilderPropagatesDataVariableReferences(
		s: ctypes.POINTER(BNStructureBuilder)
		) -> bool:
	return _BNStructureBuilderPropagatesDataVariableReferences(s)


# -------------------------------------------------------
# _BNStructurePropagatesDataVariableReferences

_BNStructurePropagatesDataVariableReferences = core.BNStructurePropagatesDataVariableReferences
_BNStructurePropagatesDataVariableReferences.restype = ctypes.c_bool
_BNStructurePropagatesDataVariableReferences.argtypes = [
		ctypes.POINTER(BNStructure),
	]


# noinspection PyPep8Naming
def BNStructurePropagatesDataVariableReferences(
		s: ctypes.POINTER(BNStructure)
		) -> bool:
	return _BNStructurePropagatesDataVariableReferences(s)


# -------------------------------------------------------
# _BNStructureWithReplacedEnumeration

_BNStructureWithReplacedEnumeration = core.BNStructureWithReplacedEnumeration
_BNStructureWithReplacedEnumeration.restype = ctypes.POINTER(BNStructure)
_BNStructureWithReplacedEnumeration.argtypes = [
		ctypes.POINTER(BNStructure),
		ctypes.POINTER(BNEnumeration),
		ctypes.POINTER(BNEnumeration),
	]


# noinspection PyPep8Naming
def BNStructureWithReplacedEnumeration(
		s: ctypes.POINTER(BNStructure), 
		from_: ctypes.POINTER(BNEnumeration), 
		to: ctypes.POINTER(BNEnumeration)
		) -> Optional[ctypes.POINTER(BNStructure)]:
	result = _BNStructureWithReplacedEnumeration(s, from_, to)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNStructureWithReplacedNamedTypeReference

_BNStructureWithReplacedNamedTypeReference = core.BNStructureWithReplacedNamedTypeReference
_BNStructureWithReplacedNamedTypeReference.restype = ctypes.POINTER(BNStructure)
_BNStructureWithReplacedNamedTypeReference.argtypes = [
		ctypes.POINTER(BNStructure),
		ctypes.POINTER(BNNamedTypeReference),
		ctypes.POINTER(BNNamedTypeReference),
	]


# noinspection PyPep8Naming
def BNStructureWithReplacedNamedTypeReference(
		s: ctypes.POINTER(BNStructure), 
		from_: ctypes.POINTER(BNNamedTypeReference), 
		to: ctypes.POINTER(BNNamedTypeReference)
		) -> Optional[ctypes.POINTER(BNStructure)]:
	result = _BNStructureWithReplacedNamedTypeReference(s, from_, to)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNStructureWithReplacedStructure

_BNStructureWithReplacedStructure = core.BNStructureWithReplacedStructure
_BNStructureWithReplacedStructure.restype = ctypes.POINTER(BNStructure)
_BNStructureWithReplacedStructure.argtypes = [
		ctypes.POINTER(BNStructure),
		ctypes.POINTER(BNStructure),
		ctypes.POINTER(BNStructure),
	]


# noinspection PyPep8Naming
def BNStructureWithReplacedStructure(
		s: ctypes.POINTER(BNStructure), 
		from_: ctypes.POINTER(BNStructure), 
		to: ctypes.POINTER(BNStructure)
		) -> Optional[ctypes.POINTER(BNStructure)]:
	result = _BNStructureWithReplacedStructure(s, from_, to)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNTagGetData

_BNTagGetData = core.BNTagGetData
_BNTagGetData.restype = ctypes.POINTER(ctypes.c_byte)
_BNTagGetData.argtypes = [
		ctypes.POINTER(BNTag),
	]


# noinspection PyPep8Naming
def BNTagGetData(
		tag: ctypes.POINTER(BNTag)
		) -> Optional[Optional[str]]:
	result = _BNTagGetData(tag)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNTagGetId

_BNTagGetId = core.BNTagGetId
_BNTagGetId.restype = ctypes.POINTER(ctypes.c_byte)
_BNTagGetId.argtypes = [
		ctypes.POINTER(BNTag),
	]


# noinspection PyPep8Naming
def BNTagGetId(
		tag: ctypes.POINTER(BNTag)
		) -> Optional[Optional[str]]:
	result = _BNTagGetId(tag)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNTagGetType

_BNTagGetType = core.BNTagGetType
_BNTagGetType.restype = ctypes.POINTER(BNTagType)
_BNTagGetType.argtypes = [
		ctypes.POINTER(BNTag),
	]


# noinspection PyPep8Naming
def BNTagGetType(
		tag: ctypes.POINTER(BNTag)
		) -> Optional[ctypes.POINTER(BNTagType)]:
	result = _BNTagGetType(tag)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNTagSetData

_BNTagSetData = core.BNTagSetData
_BNTagSetData.restype = None
_BNTagSetData.argtypes = [
		ctypes.POINTER(BNTag),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNTagSetData(
		tag: ctypes.POINTER(BNTag), 
		data: Optional[str]
		) -> None:
	return _BNTagSetData(tag, cstr(data))


# -------------------------------------------------------
# _BNTagTypeGetIcon

_BNTagTypeGetIcon = core.BNTagTypeGetIcon
_BNTagTypeGetIcon.restype = ctypes.POINTER(ctypes.c_byte)
_BNTagTypeGetIcon.argtypes = [
		ctypes.POINTER(BNTagType),
	]


# noinspection PyPep8Naming
def BNTagTypeGetIcon(
		tagType: ctypes.POINTER(BNTagType)
		) -> Optional[Optional[str]]:
	result = _BNTagTypeGetIcon(tagType)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNTagTypeGetId

_BNTagTypeGetId = core.BNTagTypeGetId
_BNTagTypeGetId.restype = ctypes.POINTER(ctypes.c_byte)
_BNTagTypeGetId.argtypes = [
		ctypes.POINTER(BNTagType),
	]


# noinspection PyPep8Naming
def BNTagTypeGetId(
		tagType: ctypes.POINTER(BNTagType)
		) -> Optional[Optional[str]]:
	result = _BNTagTypeGetId(tagType)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNTagTypeGetName

_BNTagTypeGetName = core.BNTagTypeGetName
_BNTagTypeGetName.restype = ctypes.POINTER(ctypes.c_byte)
_BNTagTypeGetName.argtypes = [
		ctypes.POINTER(BNTagType),
	]


# noinspection PyPep8Naming
def BNTagTypeGetName(
		tagType: ctypes.POINTER(BNTagType)
		) -> Optional[Optional[str]]:
	result = _BNTagTypeGetName(tagType)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNTagTypeGetType

_BNTagTypeGetType = core.BNTagTypeGetType
_BNTagTypeGetType.restype = TagTypeTypeEnum
_BNTagTypeGetType.argtypes = [
		ctypes.POINTER(BNTagType),
	]


# noinspection PyPep8Naming
def BNTagTypeGetType(
		tagType: ctypes.POINTER(BNTagType)
		) -> TagTypeType:
	return _BNTagTypeGetType(tagType)


# -------------------------------------------------------
# _BNTagTypeGetView

_BNTagTypeGetView = core.BNTagTypeGetView
_BNTagTypeGetView.restype = ctypes.POINTER(BNBinaryView)
_BNTagTypeGetView.argtypes = [
		ctypes.POINTER(BNTagType),
	]


# noinspection PyPep8Naming
def BNTagTypeGetView(
		tagType: ctypes.POINTER(BNTagType)
		) -> Optional[ctypes.POINTER(BNBinaryView)]:
	result = _BNTagTypeGetView(tagType)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNTagTypeGetVisible

_BNTagTypeGetVisible = core.BNTagTypeGetVisible
_BNTagTypeGetVisible.restype = ctypes.c_bool
_BNTagTypeGetVisible.argtypes = [
		ctypes.POINTER(BNTagType),
	]


# noinspection PyPep8Naming
def BNTagTypeGetVisible(
		tagType: ctypes.POINTER(BNTagType)
		) -> bool:
	return _BNTagTypeGetVisible(tagType)


# -------------------------------------------------------
# _BNTagTypeSetIcon

_BNTagTypeSetIcon = core.BNTagTypeSetIcon
_BNTagTypeSetIcon.restype = None
_BNTagTypeSetIcon.argtypes = [
		ctypes.POINTER(BNTagType),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNTagTypeSetIcon(
		tagType: ctypes.POINTER(BNTagType), 
		icon: Optional[str]
		) -> None:
	return _BNTagTypeSetIcon(tagType, cstr(icon))


# -------------------------------------------------------
# _BNTagTypeSetName

_BNTagTypeSetName = core.BNTagTypeSetName
_BNTagTypeSetName.restype = None
_BNTagTypeSetName.argtypes = [
		ctypes.POINTER(BNTagType),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNTagTypeSetName(
		tagType: ctypes.POINTER(BNTagType), 
		name: Optional[str]
		) -> None:
	return _BNTagTypeSetName(tagType, cstr(name))


# -------------------------------------------------------
# _BNTagTypeSetType

_BNTagTypeSetType = core.BNTagTypeSetType
_BNTagTypeSetType.restype = None
_BNTagTypeSetType.argtypes = [
		ctypes.POINTER(BNTagType),
		TagTypeTypeEnum,
	]


# noinspection PyPep8Naming
def BNTagTypeSetType(
		tagType: ctypes.POINTER(BNTagType), 
		type: TagTypeType
		) -> None:
	return _BNTagTypeSetType(tagType, type)


# -------------------------------------------------------
# _BNTagTypeSetVisible

_BNTagTypeSetVisible = core.BNTagTypeSetVisible
_BNTagTypeSetVisible.restype = None
_BNTagTypeSetVisible.argtypes = [
		ctypes.POINTER(BNTagType),
		ctypes.c_bool,
	]


# noinspection PyPep8Naming
def BNTagTypeSetVisible(
		tagType: ctypes.POINTER(BNTagType), 
		visible: bool
		) -> None:
	return _BNTagTypeSetVisible(tagType, visible)


# -------------------------------------------------------
# _BNToVariableIdentifier

_BNToVariableIdentifier = core.BNToVariableIdentifier
_BNToVariableIdentifier.restype = ctypes.c_ulonglong
_BNToVariableIdentifier.argtypes = [
		ctypes.POINTER(BNVariable),
	]


# noinspection PyPep8Naming
def BNToVariableIdentifier(
		var: ctypes.POINTER(BNVariable)
		) -> int:
	return _BNToVariableIdentifier(var)


# -------------------------------------------------------
# _BNTrimDatabaseSnapshot

_BNTrimDatabaseSnapshot = core.BNTrimDatabaseSnapshot
_BNTrimDatabaseSnapshot.restype = ctypes.c_bool
_BNTrimDatabaseSnapshot.argtypes = [
		ctypes.POINTER(BNDatabase),
		ctypes.c_longlong,
	]


# noinspection PyPep8Naming
def BNTrimDatabaseSnapshot(
		database: ctypes.POINTER(BNDatabase), 
		id: int
		) -> bool:
	return _BNTrimDatabaseSnapshot(database, id)


# -------------------------------------------------------
# _BNTypeArchiveDeserializeSnapshot

_BNTypeArchiveDeserializeSnapshot = core.BNTypeArchiveDeserializeSnapshot
_BNTypeArchiveDeserializeSnapshot.restype = ctypes.POINTER(ctypes.c_byte)
_BNTypeArchiveDeserializeSnapshot.argtypes = [
		ctypes.POINTER(BNTypeArchive),
		ctypes.POINTER(BNDataBuffer),
	]


# noinspection PyPep8Naming
def BNTypeArchiveDeserializeSnapshot(
		archive: ctypes.POINTER(BNTypeArchive), 
		buffer: ctypes.POINTER(BNDataBuffer)
		) -> Optional[Optional[str]]:
	result = _BNTypeArchiveDeserializeSnapshot(archive, buffer)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNTypeArchiveMergeSnapshots

_BNTypeArchiveMergeSnapshots = core.BNTypeArchiveMergeSnapshots
_BNTypeArchiveMergeSnapshots.restype = ctypes.c_bool
_BNTypeArchiveMergeSnapshots.argtypes = [
		ctypes.POINTER(BNTypeArchive),
		ctypes.c_char_p,
		ctypes.c_char_p,
		ctypes.c_char_p,
		ctypes.POINTER(ctypes.c_char_p),
		ctypes.POINTER(ctypes.c_char_p),
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)),
		ctypes.POINTER(ctypes.c_ulonglong),
		ctypes.POINTER(ctypes.c_char_p),
		ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong),
		ctypes.c_void_p,
	]


# noinspection PyPep8Naming
def BNTypeArchiveMergeSnapshots(
		archive: ctypes.POINTER(BNTypeArchive), 
		baseSnapshot: Optional[str], 
		firstSnapshot: Optional[str], 
		secondSnapshot: Optional[str], 
		mergeConflictKeysIn: ctypes.POINTER(ctypes.c_char_p), 
		mergeConflictValuesIn: ctypes.POINTER(ctypes.c_char_p), 
		mergeConflictCountIn: int, 
		mergeConflictsOut: ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)), 
		mergeConflictCountOut: ctypes.POINTER(ctypes.c_ulonglong), 
		result: ctypes.POINTER(ctypes.c_char_p), 
		progress: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong), 
		context: Optional[ctypes.c_void_p]
		) -> bool:
	return _BNTypeArchiveMergeSnapshots(archive, cstr(baseSnapshot), cstr(firstSnapshot), cstr(secondSnapshot), mergeConflictKeysIn, mergeConflictValuesIn, mergeConflictCountIn, mergeConflictsOut, mergeConflictCountOut, result, progress, context)


# -------------------------------------------------------
# _BNTypeArchiveNewSnapshotTransaction

_BNTypeArchiveNewSnapshotTransaction = core.BNTypeArchiveNewSnapshotTransaction
_BNTypeArchiveNewSnapshotTransaction.restype = ctypes.POINTER(ctypes.c_byte)
_BNTypeArchiveNewSnapshotTransaction.argtypes = [
		ctypes.POINTER(BNTypeArchive),
		ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_char_p),
		ctypes.c_void_p,
		ctypes.POINTER(ctypes.c_char_p),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNTypeArchiveNewSnapshotTransaction(
		archive: ctypes.POINTER(BNTypeArchive), 
		func: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_char_p), 
		context: Optional[ctypes.c_void_p], 
		parents: ctypes.POINTER(ctypes.c_char_p), 
		parentCount: int
		) -> Optional[Optional[str]]:
	result = _BNTypeArchiveNewSnapshotTransaction(archive, func, context, parents, parentCount)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNTypeArchiveQueryMetadata

_BNTypeArchiveQueryMetadata = core.BNTypeArchiveQueryMetadata
_BNTypeArchiveQueryMetadata.restype = ctypes.POINTER(BNMetadata)
_BNTypeArchiveQueryMetadata.argtypes = [
		ctypes.POINTER(BNTypeArchive),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNTypeArchiveQueryMetadata(
		archive: ctypes.POINTER(BNTypeArchive), 
		key: Optional[str]
		) -> Optional[ctypes.POINTER(BNMetadata)]:
	result = _BNTypeArchiveQueryMetadata(archive, cstr(key))
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNTypeArchiveRemoveMetadata

_BNTypeArchiveRemoveMetadata = core.BNTypeArchiveRemoveMetadata
_BNTypeArchiveRemoveMetadata.restype = ctypes.c_bool
_BNTypeArchiveRemoveMetadata.argtypes = [
		ctypes.POINTER(BNTypeArchive),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNTypeArchiveRemoveMetadata(
		archive: ctypes.POINTER(BNTypeArchive), 
		key: Optional[str]
		) -> bool:
	return _BNTypeArchiveRemoveMetadata(archive, cstr(key))


# -------------------------------------------------------
# _BNTypeArchiveSerializeSnapshot

_BNTypeArchiveSerializeSnapshot = core.BNTypeArchiveSerializeSnapshot
_BNTypeArchiveSerializeSnapshot.restype = ctypes.POINTER(BNDataBuffer)
_BNTypeArchiveSerializeSnapshot.argtypes = [
		ctypes.POINTER(BNTypeArchive),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNTypeArchiveSerializeSnapshot(
		archive: ctypes.POINTER(BNTypeArchive), 
		snapshot: Optional[str]
		) -> Optional[ctypes.POINTER(BNDataBuffer)]:
	result = _BNTypeArchiveSerializeSnapshot(archive, cstr(snapshot))
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNTypeArchiveStoreMetadata

_BNTypeArchiveStoreMetadata = core.BNTypeArchiveStoreMetadata
_BNTypeArchiveStoreMetadata.restype = ctypes.c_bool
_BNTypeArchiveStoreMetadata.argtypes = [
		ctypes.POINTER(BNTypeArchive),
		ctypes.c_char_p,
		ctypes.POINTER(BNMetadata),
	]


# noinspection PyPep8Naming
def BNTypeArchiveStoreMetadata(
		archive: ctypes.POINTER(BNTypeArchive), 
		key: Optional[str], 
		value: ctypes.POINTER(BNMetadata)
		) -> bool:
	return _BNTypeArchiveStoreMetadata(archive, cstr(key), value)


# -------------------------------------------------------
# _BNTypeBuilderGetReferenceType

_BNTypeBuilderGetReferenceType = core.BNTypeBuilderGetReferenceType
_BNTypeBuilderGetReferenceType.restype = ReferenceTypeEnum
_BNTypeBuilderGetReferenceType.argtypes = [
		ctypes.POINTER(BNTypeBuilder),
	]


# noinspection PyPep8Naming
def BNTypeBuilderGetReferenceType(
		type: ctypes.POINTER(BNTypeBuilder)
		) -> ReferenceType:
	return _BNTypeBuilderGetReferenceType(type)


# -------------------------------------------------------
# _BNTypeBuilderGetStructureName

_BNTypeBuilderGetStructureName = core.BNTypeBuilderGetStructureName
_BNTypeBuilderGetStructureName.restype = BNQualifiedName
_BNTypeBuilderGetStructureName.argtypes = [
		ctypes.POINTER(BNTypeBuilder),
	]


# noinspection PyPep8Naming
def BNTypeBuilderGetStructureName(
		type: ctypes.POINTER(BNTypeBuilder)
		) -> BNQualifiedName:
	return _BNTypeBuilderGetStructureName(type)


# -------------------------------------------------------
# _BNTypeBuilderGetSystemCallNumber

_BNTypeBuilderGetSystemCallNumber = core.BNTypeBuilderGetSystemCallNumber
_BNTypeBuilderGetSystemCallNumber.restype = ctypes.c_uint
_BNTypeBuilderGetSystemCallNumber.argtypes = [
		ctypes.POINTER(BNTypeBuilder),
	]


# noinspection PyPep8Naming
def BNTypeBuilderGetSystemCallNumber(
		type: ctypes.POINTER(BNTypeBuilder)
		) -> int:
	return _BNTypeBuilderGetSystemCallNumber(type)


# -------------------------------------------------------
# _BNTypeBuilderGetTypeName

_BNTypeBuilderGetTypeName = core.BNTypeBuilderGetTypeName
_BNTypeBuilderGetTypeName.restype = BNQualifiedName
_BNTypeBuilderGetTypeName.argtypes = [
		ctypes.POINTER(BNTypeBuilder),
	]


# noinspection PyPep8Naming
def BNTypeBuilderGetTypeName(
		nt: ctypes.POINTER(BNTypeBuilder)
		) -> BNQualifiedName:
	return _BNTypeBuilderGetTypeName(nt)


# -------------------------------------------------------
# _BNTypeBuilderHasVariableArguments

_BNTypeBuilderHasVariableArguments = core.BNTypeBuilderHasVariableArguments
_BNTypeBuilderHasVariableArguments.restype = BNBoolWithConfidence
_BNTypeBuilderHasVariableArguments.argtypes = [
		ctypes.POINTER(BNTypeBuilder),
	]


# noinspection PyPep8Naming
def BNTypeBuilderHasVariableArguments(
		type: ctypes.POINTER(BNTypeBuilder)
		) -> BNBoolWithConfidence:
	return _BNTypeBuilderHasVariableArguments(type)


# -------------------------------------------------------
# _BNTypeBuilderIsSystemCall

_BNTypeBuilderIsSystemCall = core.BNTypeBuilderIsSystemCall
_BNTypeBuilderIsSystemCall.restype = ctypes.c_bool
_BNTypeBuilderIsSystemCall.argtypes = [
		ctypes.POINTER(BNTypeBuilder),
	]


# noinspection PyPep8Naming
def BNTypeBuilderIsSystemCall(
		type: ctypes.POINTER(BNTypeBuilder)
		) -> bool:
	return _BNTypeBuilderIsSystemCall(type)


# -------------------------------------------------------
# _BNTypeBuilderSetAlternateName

_BNTypeBuilderSetAlternateName = core.BNTypeBuilderSetAlternateName
_BNTypeBuilderSetAlternateName.restype = None
_BNTypeBuilderSetAlternateName.argtypes = [
		ctypes.POINTER(BNTypeBuilder),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNTypeBuilderSetAlternateName(
		type: ctypes.POINTER(BNTypeBuilder), 
		name: Optional[str]
		) -> None:
	return _BNTypeBuilderSetAlternateName(type, cstr(name))


# -------------------------------------------------------
# _BNTypeBuilderSetChildType

_BNTypeBuilderSetChildType = core.BNTypeBuilderSetChildType
_BNTypeBuilderSetChildType.restype = None
_BNTypeBuilderSetChildType.argtypes = [
		ctypes.POINTER(BNTypeBuilder),
		ctypes.POINTER(BNTypeWithConfidence),
	]


# noinspection PyPep8Naming
def BNTypeBuilderSetChildType(
		type: ctypes.POINTER(BNTypeBuilder), 
		child: ctypes.POINTER(BNTypeWithConfidence)
		) -> None:
	return _BNTypeBuilderSetChildType(type, child)


# -------------------------------------------------------
# _BNTypeBuilderSetConst

_BNTypeBuilderSetConst = core.BNTypeBuilderSetConst
_BNTypeBuilderSetConst.restype = None
_BNTypeBuilderSetConst.argtypes = [
		ctypes.POINTER(BNTypeBuilder),
		ctypes.POINTER(BNBoolWithConfidence),
	]


# noinspection PyPep8Naming
def BNTypeBuilderSetConst(
		type: ctypes.POINTER(BNTypeBuilder), 
		cnst: ctypes.POINTER(BNBoolWithConfidence)
		) -> None:
	return _BNTypeBuilderSetConst(type, cnst)


# -------------------------------------------------------
# _BNTypeBuilderSetSigned

_BNTypeBuilderSetSigned = core.BNTypeBuilderSetSigned
_BNTypeBuilderSetSigned.restype = None
_BNTypeBuilderSetSigned.argtypes = [
		ctypes.POINTER(BNTypeBuilder),
		ctypes.POINTER(BNBoolWithConfidence),
	]


# noinspection PyPep8Naming
def BNTypeBuilderSetSigned(
		type: ctypes.POINTER(BNTypeBuilder), 
		sign: ctypes.POINTER(BNBoolWithConfidence)
		) -> None:
	return _BNTypeBuilderSetSigned(type, sign)


# -------------------------------------------------------
# _BNTypeBuilderSetStackAdjustment

_BNTypeBuilderSetStackAdjustment = core.BNTypeBuilderSetStackAdjustment
_BNTypeBuilderSetStackAdjustment.restype = None
_BNTypeBuilderSetStackAdjustment.argtypes = [
		ctypes.POINTER(BNTypeBuilder),
		ctypes.POINTER(BNOffsetWithConfidence),
	]


# noinspection PyPep8Naming
def BNTypeBuilderSetStackAdjustment(
		type: ctypes.POINTER(BNTypeBuilder), 
		adjust: ctypes.POINTER(BNOffsetWithConfidence)
		) -> None:
	return _BNTypeBuilderSetStackAdjustment(type, adjust)


# -------------------------------------------------------
# _BNTypeBuilderSetSystemCallNumber

_BNTypeBuilderSetSystemCallNumber = core.BNTypeBuilderSetSystemCallNumber
_BNTypeBuilderSetSystemCallNumber.restype = None
_BNTypeBuilderSetSystemCallNumber.argtypes = [
		ctypes.POINTER(BNTypeBuilder),
		ctypes.c_bool,
		ctypes.c_uint,
	]


# noinspection PyPep8Naming
def BNTypeBuilderSetSystemCallNumber(
		type: ctypes.POINTER(BNTypeBuilder), 
		v: bool, 
		n: int
		) -> None:
	return _BNTypeBuilderSetSystemCallNumber(type, v, n)


# -------------------------------------------------------
# _BNTypeBuilderSetTypeName

_BNTypeBuilderSetTypeName = core.BNTypeBuilderSetTypeName
_BNTypeBuilderSetTypeName.restype = None
_BNTypeBuilderSetTypeName.argtypes = [
		ctypes.POINTER(BNTypeBuilder),
		ctypes.POINTER(BNQualifiedName),
	]


# noinspection PyPep8Naming
def BNTypeBuilderSetTypeName(
		type: ctypes.POINTER(BNTypeBuilder), 
		name: ctypes.POINTER(BNQualifiedName)
		) -> None:
	return _BNTypeBuilderSetTypeName(type, name)


# -------------------------------------------------------
# _BNTypeBuilderSetVolatile

_BNTypeBuilderSetVolatile = core.BNTypeBuilderSetVolatile
_BNTypeBuilderSetVolatile.restype = None
_BNTypeBuilderSetVolatile.argtypes = [
		ctypes.POINTER(BNTypeBuilder),
		ctypes.POINTER(BNBoolWithConfidence),
	]


# noinspection PyPep8Naming
def BNTypeBuilderSetVolatile(
		type: ctypes.POINTER(BNTypeBuilder), 
		vltl: ctypes.POINTER(BNBoolWithConfidence)
		) -> None:
	return _BNTypeBuilderSetVolatile(type, vltl)


# -------------------------------------------------------
# _BNTypeContainerAddTypes

_BNTypeContainerAddTypes = core.BNTypeContainerAddTypes
_BNTypeContainerAddTypes.restype = ctypes.c_bool
_BNTypeContainerAddTypes.argtypes = [
		ctypes.POINTER(BNTypeContainer),
		ctypes.POINTER(BNQualifiedName),
		ctypes.POINTER(ctypes.POINTER(BNType)),
		ctypes.c_ulonglong,
		ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong),
		ctypes.c_void_p,
		ctypes.POINTER(ctypes.POINTER(BNQualifiedName)),
		ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNTypeContainerAddTypes(
		container: ctypes.POINTER(BNTypeContainer), 
		typeNames: ctypes.POINTER(BNQualifiedName), 
		types: ctypes.POINTER(ctypes.POINTER(BNType)), 
		typeCount: int, 
		progress: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong), 
		progressContext: Optional[ctypes.c_void_p], 
		resultNames: ctypes.POINTER(ctypes.POINTER(BNQualifiedName)), 
		resultIds: ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)), 
		resultCount: ctypes.POINTER(ctypes.c_ulonglong)
		) -> bool:
	return _BNTypeContainerAddTypes(container, typeNames, types, typeCount, progress, progressContext, resultNames, resultIds, resultCount)


# -------------------------------------------------------
# _BNTypeContainerDeleteType

_BNTypeContainerDeleteType = core.BNTypeContainerDeleteType
_BNTypeContainerDeleteType.restype = ctypes.c_bool
_BNTypeContainerDeleteType.argtypes = [
		ctypes.POINTER(BNTypeContainer),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNTypeContainerDeleteType(
		container: ctypes.POINTER(BNTypeContainer), 
		typeId: Optional[str]
		) -> bool:
	return _BNTypeContainerDeleteType(container, cstr(typeId))


# -------------------------------------------------------
# _BNTypeContainerGetId

_BNTypeContainerGetId = core.BNTypeContainerGetId
_BNTypeContainerGetId.restype = ctypes.POINTER(ctypes.c_byte)
_BNTypeContainerGetId.argtypes = [
		ctypes.POINTER(BNTypeContainer),
	]


# noinspection PyPep8Naming
def BNTypeContainerGetId(
		container: ctypes.POINTER(BNTypeContainer)
		) -> Optional[Optional[str]]:
	result = _BNTypeContainerGetId(container)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNTypeContainerGetName

_BNTypeContainerGetName = core.BNTypeContainerGetName
_BNTypeContainerGetName.restype = ctypes.POINTER(ctypes.c_byte)
_BNTypeContainerGetName.argtypes = [
		ctypes.POINTER(BNTypeContainer),
	]


# noinspection PyPep8Naming
def BNTypeContainerGetName(
		container: ctypes.POINTER(BNTypeContainer)
		) -> Optional[Optional[str]]:
	result = _BNTypeContainerGetName(container)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNTypeContainerGetPlatform

_BNTypeContainerGetPlatform = core.BNTypeContainerGetPlatform
_BNTypeContainerGetPlatform.restype = ctypes.POINTER(BNPlatform)
_BNTypeContainerGetPlatform.argtypes = [
		ctypes.POINTER(BNTypeContainer),
	]


# noinspection PyPep8Naming
def BNTypeContainerGetPlatform(
		container: ctypes.POINTER(BNTypeContainer)
		) -> Optional[ctypes.POINTER(BNPlatform)]:
	result = _BNTypeContainerGetPlatform(container)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNTypeContainerGetType

_BNTypeContainerGetType = core.BNTypeContainerGetType
_BNTypeContainerGetType.restype = TypeContainerTypeEnum
_BNTypeContainerGetType.argtypes = [
		ctypes.POINTER(BNTypeContainer),
	]


# noinspection PyPep8Naming
def BNTypeContainerGetType(
		container: ctypes.POINTER(BNTypeContainer)
		) -> TypeContainerType:
	return _BNTypeContainerGetType(container)


# -------------------------------------------------------
# _BNTypeContainerGetTypeById

_BNTypeContainerGetTypeById = core.BNTypeContainerGetTypeById
_BNTypeContainerGetTypeById.restype = ctypes.c_bool
_BNTypeContainerGetTypeById.argtypes = [
		ctypes.POINTER(BNTypeContainer),
		ctypes.c_char_p,
		ctypes.POINTER(ctypes.POINTER(BNType)),
	]


# noinspection PyPep8Naming
def BNTypeContainerGetTypeById(
		container: ctypes.POINTER(BNTypeContainer), 
		typeId: Optional[str], 
		result: ctypes.POINTER(ctypes.POINTER(BNType))
		) -> bool:
	return _BNTypeContainerGetTypeById(container, cstr(typeId), result)


# -------------------------------------------------------
# _BNTypeContainerGetTypeByName

_BNTypeContainerGetTypeByName = core.BNTypeContainerGetTypeByName
_BNTypeContainerGetTypeByName.restype = ctypes.c_bool
_BNTypeContainerGetTypeByName.argtypes = [
		ctypes.POINTER(BNTypeContainer),
		ctypes.POINTER(BNQualifiedName),
		ctypes.POINTER(ctypes.POINTER(BNType)),
	]


# noinspection PyPep8Naming
def BNTypeContainerGetTypeByName(
		container: ctypes.POINTER(BNTypeContainer), 
		typeName: ctypes.POINTER(BNQualifiedName), 
		result: ctypes.POINTER(ctypes.POINTER(BNType))
		) -> bool:
	return _BNTypeContainerGetTypeByName(container, typeName, result)


# -------------------------------------------------------
# _BNTypeContainerGetTypeId

_BNTypeContainerGetTypeId = core.BNTypeContainerGetTypeId
_BNTypeContainerGetTypeId.restype = ctypes.c_bool
_BNTypeContainerGetTypeId.argtypes = [
		ctypes.POINTER(BNTypeContainer),
		ctypes.POINTER(BNQualifiedName),
		ctypes.POINTER(ctypes.c_char_p),
	]


# noinspection PyPep8Naming
def BNTypeContainerGetTypeId(
		container: ctypes.POINTER(BNTypeContainer), 
		typeName: ctypes.POINTER(BNQualifiedName), 
		result: ctypes.POINTER(ctypes.c_char_p)
		) -> bool:
	return _BNTypeContainerGetTypeId(container, typeName, result)


# -------------------------------------------------------
# _BNTypeContainerGetTypeIds

_BNTypeContainerGetTypeIds = core.BNTypeContainerGetTypeIds
_BNTypeContainerGetTypeIds.restype = ctypes.c_bool
_BNTypeContainerGetTypeIds.argtypes = [
		ctypes.POINTER(BNTypeContainer),
		ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNTypeContainerGetTypeIds(
		container: ctypes.POINTER(BNTypeContainer), 
		typeIds: ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> bool:
	return _BNTypeContainerGetTypeIds(container, typeIds, count)


# -------------------------------------------------------
# _BNTypeContainerGetTypeName

_BNTypeContainerGetTypeName = core.BNTypeContainerGetTypeName
_BNTypeContainerGetTypeName.restype = ctypes.c_bool
_BNTypeContainerGetTypeName.argtypes = [
		ctypes.POINTER(BNTypeContainer),
		ctypes.c_char_p,
		ctypes.POINTER(BNQualifiedName),
	]


# noinspection PyPep8Naming
def BNTypeContainerGetTypeName(
		container: ctypes.POINTER(BNTypeContainer), 
		typeId: Optional[str], 
		result: ctypes.POINTER(BNQualifiedName)
		) -> bool:
	return _BNTypeContainerGetTypeName(container, cstr(typeId), result)


# -------------------------------------------------------
# _BNTypeContainerGetTypeNames

_BNTypeContainerGetTypeNames = core.BNTypeContainerGetTypeNames
_BNTypeContainerGetTypeNames.restype = ctypes.c_bool
_BNTypeContainerGetTypeNames.argtypes = [
		ctypes.POINTER(BNTypeContainer),
		ctypes.POINTER(ctypes.POINTER(BNQualifiedName)),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNTypeContainerGetTypeNames(
		container: ctypes.POINTER(BNTypeContainer), 
		typeNames: ctypes.POINTER(ctypes.POINTER(BNQualifiedName)), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> bool:
	return _BNTypeContainerGetTypeNames(container, typeNames, count)


# -------------------------------------------------------
# _BNTypeContainerGetTypeNamesAndIds

_BNTypeContainerGetTypeNamesAndIds = core.BNTypeContainerGetTypeNamesAndIds
_BNTypeContainerGetTypeNamesAndIds.restype = ctypes.c_bool
_BNTypeContainerGetTypeNamesAndIds.argtypes = [
		ctypes.POINTER(BNTypeContainer),
		ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)),
		ctypes.POINTER(ctypes.POINTER(BNQualifiedName)),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNTypeContainerGetTypeNamesAndIds(
		container: ctypes.POINTER(BNTypeContainer), 
		typeIds: ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)), 
		typeNames: ctypes.POINTER(ctypes.POINTER(BNQualifiedName)), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> bool:
	return _BNTypeContainerGetTypeNamesAndIds(container, typeIds, typeNames, count)


# -------------------------------------------------------
# _BNTypeContainerGetTypes

_BNTypeContainerGetTypes = core.BNTypeContainerGetTypes
_BNTypeContainerGetTypes.restype = ctypes.c_bool
_BNTypeContainerGetTypes.argtypes = [
		ctypes.POINTER(BNTypeContainer),
		ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)),
		ctypes.POINTER(ctypes.POINTER(BNQualifiedName)),
		ctypes.POINTER(ctypes.POINTER(ctypes.POINTER(BNType))),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNTypeContainerGetTypes(
		container: ctypes.POINTER(BNTypeContainer), 
		typeIds: ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)), 
		typeNames: ctypes.POINTER(ctypes.POINTER(BNQualifiedName)), 
		types: ctypes.POINTER(ctypes.POINTER(ctypes.POINTER(BNType))), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> bool:
	return _BNTypeContainerGetTypes(container, typeIds, typeNames, types, count)


# -------------------------------------------------------
# _BNTypeContainerIsMutable

_BNTypeContainerIsMutable = core.BNTypeContainerIsMutable
_BNTypeContainerIsMutable.restype = ctypes.c_bool
_BNTypeContainerIsMutable.argtypes = [
		ctypes.POINTER(BNTypeContainer),
	]


# noinspection PyPep8Naming
def BNTypeContainerIsMutable(
		container: ctypes.POINTER(BNTypeContainer)
		) -> bool:
	return _BNTypeContainerIsMutable(container)


# -------------------------------------------------------
# _BNTypeContainerParseTypeString

_BNTypeContainerParseTypeString = core.BNTypeContainerParseTypeString
_BNTypeContainerParseTypeString.restype = ctypes.c_bool
_BNTypeContainerParseTypeString.argtypes = [
		ctypes.POINTER(BNTypeContainer),
		ctypes.c_char_p,
		ctypes.POINTER(BNQualifiedNameAndType),
		ctypes.POINTER(ctypes.POINTER(BNTypeParserError)),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNTypeContainerParseTypeString(
		container: ctypes.POINTER(BNTypeContainer), 
		source: Optional[str], 
		result: ctypes.POINTER(BNQualifiedNameAndType), 
		errors: ctypes.POINTER(ctypes.POINTER(BNTypeParserError)), 
		errorCount: ctypes.POINTER(ctypes.c_ulonglong)
		) -> bool:
	return _BNTypeContainerParseTypeString(container, cstr(source), result, errors, errorCount)


# -------------------------------------------------------
# _BNTypeContainerParseTypesFromSource

_BNTypeContainerParseTypesFromSource = core.BNTypeContainerParseTypesFromSource
_BNTypeContainerParseTypesFromSource.restype = ctypes.c_bool
_BNTypeContainerParseTypesFromSource.argtypes = [
		ctypes.POINTER(BNTypeContainer),
		ctypes.c_char_p,
		ctypes.c_char_p,
		ctypes.POINTER(ctypes.c_char_p),
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_char_p),
		ctypes.c_ulonglong,
		ctypes.c_char_p,
		ctypes.POINTER(BNTypeParserResult),
		ctypes.POINTER(ctypes.POINTER(BNTypeParserError)),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNTypeContainerParseTypesFromSource(
		container: ctypes.POINTER(BNTypeContainer), 
		source: Optional[str], 
		fileName: Optional[str], 
		options: ctypes.POINTER(ctypes.c_char_p), 
		optionCount: int, 
		includeDirs: ctypes.POINTER(ctypes.c_char_p), 
		includeDirCount: int, 
		autoTypeSource: Optional[str], 
		result: ctypes.POINTER(BNTypeParserResult), 
		errors: ctypes.POINTER(ctypes.POINTER(BNTypeParserError)), 
		errorCount: ctypes.POINTER(ctypes.c_ulonglong)
		) -> bool:
	return _BNTypeContainerParseTypesFromSource(container, cstr(source), cstr(fileName), options, optionCount, includeDirs, includeDirCount, cstr(autoTypeSource), result, errors, errorCount)


# -------------------------------------------------------
# _BNTypeContainerRenameType

_BNTypeContainerRenameType = core.BNTypeContainerRenameType
_BNTypeContainerRenameType.restype = ctypes.c_bool
_BNTypeContainerRenameType.argtypes = [
		ctypes.POINTER(BNTypeContainer),
		ctypes.c_char_p,
		ctypes.POINTER(BNQualifiedName),
	]


# noinspection PyPep8Naming
def BNTypeContainerRenameType(
		container: ctypes.POINTER(BNTypeContainer), 
		typeId: Optional[str], 
		newName: ctypes.POINTER(BNQualifiedName)
		) -> bool:
	return _BNTypeContainerRenameType(container, cstr(typeId), newName)


# -------------------------------------------------------
# _BNTypeGetReferenceType

_BNTypeGetReferenceType = core.BNTypeGetReferenceType
_BNTypeGetReferenceType.restype = ReferenceTypeEnum
_BNTypeGetReferenceType.argtypes = [
		ctypes.POINTER(BNType),
	]


# noinspection PyPep8Naming
def BNTypeGetReferenceType(
		type: ctypes.POINTER(BNType)
		) -> ReferenceType:
	return _BNTypeGetReferenceType(type)


# -------------------------------------------------------
# _BNTypeGetStructureName

_BNTypeGetStructureName = core.BNTypeGetStructureName
_BNTypeGetStructureName.restype = BNQualifiedName
_BNTypeGetStructureName.argtypes = [
		ctypes.POINTER(BNType),
	]


# noinspection PyPep8Naming
def BNTypeGetStructureName(
		type: ctypes.POINTER(BNType)
		) -> BNQualifiedName:
	return _BNTypeGetStructureName(type)


# -------------------------------------------------------
# _BNTypeGetSystemCallNumber

_BNTypeGetSystemCallNumber = core.BNTypeGetSystemCallNumber
_BNTypeGetSystemCallNumber.restype = ctypes.c_uint
_BNTypeGetSystemCallNumber.argtypes = [
		ctypes.POINTER(BNType),
	]


# noinspection PyPep8Naming
def BNTypeGetSystemCallNumber(
		type: ctypes.POINTER(BNType)
		) -> int:
	return _BNTypeGetSystemCallNumber(type)


# -------------------------------------------------------
# _BNTypeGetTypeName

_BNTypeGetTypeName = core.BNTypeGetTypeName
_BNTypeGetTypeName.restype = BNQualifiedName
_BNTypeGetTypeName.argtypes = [
		ctypes.POINTER(BNType),
	]


# noinspection PyPep8Naming
def BNTypeGetTypeName(
		nt: ctypes.POINTER(BNType)
		) -> BNQualifiedName:
	return _BNTypeGetTypeName(nt)


# -------------------------------------------------------
# _BNTypeHasVariableArguments

_BNTypeHasVariableArguments = core.BNTypeHasVariableArguments
_BNTypeHasVariableArguments.restype = BNBoolWithConfidence
_BNTypeHasVariableArguments.argtypes = [
		ctypes.POINTER(BNType),
	]


# noinspection PyPep8Naming
def BNTypeHasVariableArguments(
		type: ctypes.POINTER(BNType)
		) -> BNBoolWithConfidence:
	return _BNTypeHasVariableArguments(type)


# -------------------------------------------------------
# _BNTypeIsSystemCall

_BNTypeIsSystemCall = core.BNTypeIsSystemCall
_BNTypeIsSystemCall.restype = ctypes.c_bool
_BNTypeIsSystemCall.argtypes = [
		ctypes.POINTER(BNType),
	]


# noinspection PyPep8Naming
def BNTypeIsSystemCall(
		type: ctypes.POINTER(BNType)
		) -> bool:
	return _BNTypeIsSystemCall(type)


# -------------------------------------------------------
# _BNTypeLibraryDecompressToFile

_BNTypeLibraryDecompressToFile = core.BNTypeLibraryDecompressToFile
_BNTypeLibraryDecompressToFile.restype = ctypes.c_bool
_BNTypeLibraryDecompressToFile.argtypes = [
		ctypes.c_char_p,
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNTypeLibraryDecompressToFile(
		file: Optional[str], 
		output: Optional[str]
		) -> bool:
	return _BNTypeLibraryDecompressToFile(cstr(file), cstr(output))


# -------------------------------------------------------
# _BNTypeLibraryGetMetadata

_BNTypeLibraryGetMetadata = core.BNTypeLibraryGetMetadata
_BNTypeLibraryGetMetadata.restype = ctypes.POINTER(BNMetadata)
_BNTypeLibraryGetMetadata.argtypes = [
		ctypes.POINTER(BNTypeLibrary),
	]


# noinspection PyPep8Naming
def BNTypeLibraryGetMetadata(
		lib: ctypes.POINTER(BNTypeLibrary)
		) -> Optional[ctypes.POINTER(BNMetadata)]:
	result = _BNTypeLibraryGetMetadata(lib)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNTypeLibraryQueryMetadata

_BNTypeLibraryQueryMetadata = core.BNTypeLibraryQueryMetadata
_BNTypeLibraryQueryMetadata.restype = ctypes.POINTER(BNMetadata)
_BNTypeLibraryQueryMetadata.argtypes = [
		ctypes.POINTER(BNTypeLibrary),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNTypeLibraryQueryMetadata(
		lib: ctypes.POINTER(BNTypeLibrary), 
		key: Optional[str]
		) -> Optional[ctypes.POINTER(BNMetadata)]:
	result = _BNTypeLibraryQueryMetadata(lib, cstr(key))
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNTypeLibraryRemoveMetadata

_BNTypeLibraryRemoveMetadata = core.BNTypeLibraryRemoveMetadata
_BNTypeLibraryRemoveMetadata.restype = None
_BNTypeLibraryRemoveMetadata.argtypes = [
		ctypes.POINTER(BNTypeLibrary),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNTypeLibraryRemoveMetadata(
		lib: ctypes.POINTER(BNTypeLibrary), 
		key: Optional[str]
		) -> None:
	return _BNTypeLibraryRemoveMetadata(lib, cstr(key))


# -------------------------------------------------------
# _BNTypeLibraryStoreMetadata

_BNTypeLibraryStoreMetadata = core.BNTypeLibraryStoreMetadata
_BNTypeLibraryStoreMetadata.restype = None
_BNTypeLibraryStoreMetadata.argtypes = [
		ctypes.POINTER(BNTypeLibrary),
		ctypes.c_char_p,
		ctypes.POINTER(BNMetadata),
	]


# noinspection PyPep8Naming
def BNTypeLibraryStoreMetadata(
		lib: ctypes.POINTER(BNTypeLibrary), 
		key: Optional[str], 
		value: ctypes.POINTER(BNMetadata)
		) -> None:
	return _BNTypeLibraryStoreMetadata(lib, cstr(key), value)


# -------------------------------------------------------
# _BNTypeParserParseTypeString

_BNTypeParserParseTypeString = core.BNTypeParserParseTypeString
_BNTypeParserParseTypeString.restype = ctypes.c_bool
_BNTypeParserParseTypeString.argtypes = [
		ctypes.POINTER(BNTypeParser),
		ctypes.c_char_p,
		ctypes.POINTER(BNPlatform),
		ctypes.POINTER(BNQualifiedNameTypeAndId),
		ctypes.c_ulonglong,
		ctypes.POINTER(BNQualifiedNameAndType),
		ctypes.POINTER(ctypes.POINTER(BNTypeParserError)),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNTypeParserParseTypeString(
		parser: ctypes.POINTER(BNTypeParser), 
		source: Optional[str], 
		platform: ctypes.POINTER(BNPlatform), 
		existingTypes: ctypes.POINTER(BNQualifiedNameTypeAndId), 
		existingTypeCount: int, 
		result: ctypes.POINTER(BNQualifiedNameAndType), 
		errors: ctypes.POINTER(ctypes.POINTER(BNTypeParserError)), 
		errorCount: ctypes.POINTER(ctypes.c_ulonglong)
		) -> bool:
	return _BNTypeParserParseTypeString(parser, cstr(source), platform, existingTypes, existingTypeCount, result, errors, errorCount)


# -------------------------------------------------------
# _BNTypeParserParseTypesFromSource

_BNTypeParserParseTypesFromSource = core.BNTypeParserParseTypesFromSource
_BNTypeParserParseTypesFromSource.restype = ctypes.c_bool
_BNTypeParserParseTypesFromSource.argtypes = [
		ctypes.POINTER(BNTypeParser),
		ctypes.c_char_p,
		ctypes.c_char_p,
		ctypes.POINTER(BNPlatform),
		ctypes.POINTER(BNQualifiedNameTypeAndId),
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_char_p),
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_char_p),
		ctypes.c_ulonglong,
		ctypes.c_char_p,
		ctypes.POINTER(BNTypeParserResult),
		ctypes.POINTER(ctypes.POINTER(BNTypeParserError)),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNTypeParserParseTypesFromSource(
		parser: ctypes.POINTER(BNTypeParser), 
		source: Optional[str], 
		fileName: Optional[str], 
		platform: ctypes.POINTER(BNPlatform), 
		existingTypes: ctypes.POINTER(BNQualifiedNameTypeAndId), 
		existingTypeCount: int, 
		options: ctypes.POINTER(ctypes.c_char_p), 
		optionCount: int, 
		includeDirs: ctypes.POINTER(ctypes.c_char_p), 
		includeDirCount: int, 
		autoTypeSource: Optional[str], 
		result: ctypes.POINTER(BNTypeParserResult), 
		errors: ctypes.POINTER(ctypes.POINTER(BNTypeParserError)), 
		errorCount: ctypes.POINTER(ctypes.c_ulonglong)
		) -> bool:
	return _BNTypeParserParseTypesFromSource(parser, cstr(source), cstr(fileName), platform, existingTypes, existingTypeCount, options, optionCount, includeDirs, includeDirCount, cstr(autoTypeSource), result, errors, errorCount)


# -------------------------------------------------------
# _BNTypeParserPreprocessSource

_BNTypeParserPreprocessSource = core.BNTypeParserPreprocessSource
_BNTypeParserPreprocessSource.restype = ctypes.c_bool
_BNTypeParserPreprocessSource.argtypes = [
		ctypes.POINTER(BNTypeParser),
		ctypes.c_char_p,
		ctypes.c_char_p,
		ctypes.POINTER(BNPlatform),
		ctypes.POINTER(BNQualifiedNameTypeAndId),
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_char_p),
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_char_p),
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_char_p),
		ctypes.POINTER(ctypes.POINTER(BNTypeParserError)),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNTypeParserPreprocessSource(
		parser: ctypes.POINTER(BNTypeParser), 
		source: Optional[str], 
		fileName: Optional[str], 
		platform: ctypes.POINTER(BNPlatform), 
		existingTypes: ctypes.POINTER(BNQualifiedNameTypeAndId), 
		existingTypeCount: int, 
		options: ctypes.POINTER(ctypes.c_char_p), 
		optionCount: int, 
		includeDirs: ctypes.POINTER(ctypes.c_char_p), 
		includeDirCount: int, 
		output: ctypes.POINTER(ctypes.c_char_p), 
		errors: ctypes.POINTER(ctypes.POINTER(BNTypeParserError)), 
		errorCount: ctypes.POINTER(ctypes.c_ulonglong)
		) -> bool:
	return _BNTypeParserPreprocessSource(parser, cstr(source), cstr(fileName), platform, existingTypes, existingTypeCount, options, optionCount, includeDirs, includeDirCount, output, errors, errorCount)


# -------------------------------------------------------
# _BNTypePrinterDefaultPrintAllTypes

_BNTypePrinterDefaultPrintAllTypes = core.BNTypePrinterDefaultPrintAllTypes
_BNTypePrinterDefaultPrintAllTypes.restype = ctypes.c_bool
_BNTypePrinterDefaultPrintAllTypes.argtypes = [
		ctypes.POINTER(BNTypePrinter),
		ctypes.POINTER(BNQualifiedName),
		ctypes.POINTER(ctypes.POINTER(BNType)),
		ctypes.c_ulonglong,
		ctypes.POINTER(BNBinaryView),
		ctypes.c_int,
		TokenEscapingTypeEnum,
		ctypes.POINTER(ctypes.c_char_p),
	]


# noinspection PyPep8Naming
def BNTypePrinterDefaultPrintAllTypes(
		printer: ctypes.POINTER(BNTypePrinter), 
		names: ctypes.POINTER(BNQualifiedName), 
		types: ctypes.POINTER(ctypes.POINTER(BNType)), 
		typeCount: int, 
		data: ctypes.POINTER(BNBinaryView), 
		lineWidth: int, 
		escaping: TokenEscapingType, 
		result: ctypes.POINTER(ctypes.c_char_p)
		) -> bool:
	return _BNTypePrinterDefaultPrintAllTypes(printer, names, types, typeCount, data, lineWidth, escaping, result)


# -------------------------------------------------------
# _BNTypePrinterPrintAllTypes

_BNTypePrinterPrintAllTypes = core.BNTypePrinterPrintAllTypes
_BNTypePrinterPrintAllTypes.restype = ctypes.c_bool
_BNTypePrinterPrintAllTypes.argtypes = [
		ctypes.POINTER(BNTypePrinter),
		ctypes.POINTER(BNQualifiedName),
		ctypes.POINTER(ctypes.POINTER(BNType)),
		ctypes.c_ulonglong,
		ctypes.POINTER(BNBinaryView),
		ctypes.c_int,
		TokenEscapingTypeEnum,
		ctypes.POINTER(ctypes.c_char_p),
	]


# noinspection PyPep8Naming
def BNTypePrinterPrintAllTypes(
		printer: ctypes.POINTER(BNTypePrinter), 
		names: ctypes.POINTER(BNQualifiedName), 
		types: ctypes.POINTER(ctypes.POINTER(BNType)), 
		typeCount: int, 
		data: ctypes.POINTER(BNBinaryView), 
		lineWidth: int, 
		escaping: TokenEscapingType, 
		result: ctypes.POINTER(ctypes.c_char_p)
		) -> bool:
	return _BNTypePrinterPrintAllTypes(printer, names, types, typeCount, data, lineWidth, escaping, result)


# -------------------------------------------------------
# _BNTypeWithReplacedEnumeration

_BNTypeWithReplacedEnumeration = core.BNTypeWithReplacedEnumeration
_BNTypeWithReplacedEnumeration.restype = ctypes.POINTER(BNType)
_BNTypeWithReplacedEnumeration.argtypes = [
		ctypes.POINTER(BNType),
		ctypes.POINTER(BNEnumeration),
		ctypes.POINTER(BNEnumeration),
	]


# noinspection PyPep8Naming
def BNTypeWithReplacedEnumeration(
		type: ctypes.POINTER(BNType), 
		from_: ctypes.POINTER(BNEnumeration), 
		to: ctypes.POINTER(BNEnumeration)
		) -> Optional[ctypes.POINTER(BNType)]:
	result = _BNTypeWithReplacedEnumeration(type, from_, to)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNTypeWithReplacedNamedTypeReference

_BNTypeWithReplacedNamedTypeReference = core.BNTypeWithReplacedNamedTypeReference
_BNTypeWithReplacedNamedTypeReference.restype = ctypes.POINTER(BNType)
_BNTypeWithReplacedNamedTypeReference.argtypes = [
		ctypes.POINTER(BNType),
		ctypes.POINTER(BNNamedTypeReference),
		ctypes.POINTER(BNNamedTypeReference),
	]


# noinspection PyPep8Naming
def BNTypeWithReplacedNamedTypeReference(
		type: ctypes.POINTER(BNType), 
		from_: ctypes.POINTER(BNNamedTypeReference), 
		to: ctypes.POINTER(BNNamedTypeReference)
		) -> Optional[ctypes.POINTER(BNType)]:
	result = _BNTypeWithReplacedNamedTypeReference(type, from_, to)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNTypeWithReplacedStructure

_BNTypeWithReplacedStructure = core.BNTypeWithReplacedStructure
_BNTypeWithReplacedStructure.restype = ctypes.POINTER(BNType)
_BNTypeWithReplacedStructure.argtypes = [
		ctypes.POINTER(BNType),
		ctypes.POINTER(BNStructure),
		ctypes.POINTER(BNStructure),
	]


# noinspection PyPep8Naming
def BNTypeWithReplacedStructure(
		type: ctypes.POINTER(BNType), 
		from_: ctypes.POINTER(BNStructure), 
		to: ctypes.POINTER(BNStructure)
		) -> Optional[ctypes.POINTER(BNType)]:
	result = _BNTypeWithReplacedStructure(type, from_, to)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNTypesEqual

_BNTypesEqual = core.BNTypesEqual
_BNTypesEqual.restype = ctypes.c_bool
_BNTypesEqual.argtypes = [
		ctypes.POINTER(BNType),
		ctypes.POINTER(BNType),
	]


# noinspection PyPep8Naming
def BNTypesEqual(
		a: ctypes.POINTER(BNType), 
		b: ctypes.POINTER(BNType)
		) -> bool:
	return _BNTypesEqual(a, b)


# -------------------------------------------------------
# _BNTypesNotEqual

_BNTypesNotEqual = core.BNTypesNotEqual
_BNTypesNotEqual.restype = ctypes.c_bool
_BNTypesNotEqual.argtypes = [
		ctypes.POINTER(BNType),
		ctypes.POINTER(BNType),
	]


# noinspection PyPep8Naming
def BNTypesNotEqual(
		a: ctypes.POINTER(BNType), 
		b: ctypes.POINTER(BNType)
		) -> bool:
	return _BNTypesNotEqual(a, b)


# -------------------------------------------------------
# _BNUndefineAnalysisType

_BNUndefineAnalysisType = core.BNUndefineAnalysisType
_BNUndefineAnalysisType.restype = None
_BNUndefineAnalysisType.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNUndefineAnalysisType(
		view: ctypes.POINTER(BNBinaryView), 
		id: Optional[str]
		) -> None:
	return _BNUndefineAnalysisType(view, cstr(id))


# -------------------------------------------------------
# _BNUndefineAutoSymbol

_BNUndefineAutoSymbol = core.BNUndefineAutoSymbol
_BNUndefineAutoSymbol.restype = None
_BNUndefineAutoSymbol.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNSymbol),
	]


# noinspection PyPep8Naming
def BNUndefineAutoSymbol(
		view: ctypes.POINTER(BNBinaryView), 
		sym: ctypes.POINTER(BNSymbol)
		) -> None:
	return _BNUndefineAutoSymbol(view, sym)


# -------------------------------------------------------
# _BNUndefineDataVariable

_BNUndefineDataVariable = core.BNUndefineDataVariable
_BNUndefineDataVariable.restype = None
_BNUndefineDataVariable.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNUndefineDataVariable(
		view: ctypes.POINTER(BNBinaryView), 
		addr: int
		) -> None:
	return _BNUndefineDataVariable(view, addr)


# -------------------------------------------------------
# _BNUndefineUserAnalysisType

_BNUndefineUserAnalysisType = core.BNUndefineUserAnalysisType
_BNUndefineUserAnalysisType.restype = None
_BNUndefineUserAnalysisType.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNQualifiedName),
	]


# noinspection PyPep8Naming
def BNUndefineUserAnalysisType(
		view: ctypes.POINTER(BNBinaryView), 
		name: ctypes.POINTER(BNQualifiedName)
		) -> None:
	return _BNUndefineUserAnalysisType(view, name)


# -------------------------------------------------------
# _BNUndefineUserDataVariable

_BNUndefineUserDataVariable = core.BNUndefineUserDataVariable
_BNUndefineUserDataVariable.restype = None
_BNUndefineUserDataVariable.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNUndefineUserDataVariable(
		view: ctypes.POINTER(BNBinaryView), 
		addr: int
		) -> None:
	return _BNUndefineUserDataVariable(view, addr)


# -------------------------------------------------------
# _BNUndefineUserSymbol

_BNUndefineUserSymbol = core.BNUndefineUserSymbol
_BNUndefineUserSymbol.restype = None
_BNUndefineUserSymbol.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNSymbol),
	]


# noinspection PyPep8Naming
def BNUndefineUserSymbol(
		view: ctypes.POINTER(BNBinaryView), 
		sym: ctypes.POINTER(BNSymbol)
		) -> None:
	return _BNUndefineUserSymbol(view, sym)


# -------------------------------------------------------
# _BNUndo

_BNUndo = core.BNUndo
_BNUndo.restype = ctypes.c_bool
_BNUndo.argtypes = [
		ctypes.POINTER(BNFileMetadata),
	]


# noinspection PyPep8Naming
def BNUndo(
		file: ctypes.POINTER(BNFileMetadata)
		) -> bool:
	return _BNUndo(file)


# -------------------------------------------------------
# _BNUnescapeTypeName

_BNUnescapeTypeName = core.BNUnescapeTypeName
_BNUnescapeTypeName.restype = ctypes.POINTER(ctypes.c_byte)
_BNUnescapeTypeName.argtypes = [
		ctypes.c_char_p,
		TokenEscapingTypeEnum,
	]


# noinspection PyPep8Naming
def BNUnescapeTypeName(
		name: Optional[str], 
		escaping: TokenEscapingType
		) -> Optional[Optional[str]]:
	result = _BNUnescapeTypeName(cstr(name), escaping)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNUnmergeVariables

_BNUnmergeVariables = core.BNUnmergeVariables
_BNUnmergeVariables.restype = None
_BNUnmergeVariables.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNVariable),
		ctypes.POINTER(BNVariable),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNUnmergeVariables(
		func: ctypes.POINTER(BNFunction), 
		target: ctypes.POINTER(BNVariable), 
		sources: ctypes.POINTER(BNVariable), 
		sourceCount: int
		) -> None:
	return _BNUnmergeVariables(func, target, sources, sourceCount)


# -------------------------------------------------------
# _BNUnregisterDataNotification

_BNUnregisterDataNotification = core.BNUnregisterDataNotification
_BNUnregisterDataNotification.restype = None
_BNUnregisterDataNotification.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNBinaryDataNotification),
	]


# noinspection PyPep8Naming
def BNUnregisterDataNotification(
		view: ctypes.POINTER(BNBinaryView), 
		notify: ctypes.POINTER(BNBinaryDataNotification)
		) -> None:
	return _BNUnregisterDataNotification(view, notify)


# -------------------------------------------------------
# _BNUnregisterDebugInfoParser

_BNUnregisterDebugInfoParser = core.BNUnregisterDebugInfoParser
_BNUnregisterDebugInfoParser.restype = None
_BNUnregisterDebugInfoParser.argtypes = [
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNUnregisterDebugInfoParser(
		rawName: Optional[str]
		) -> None:
	return _BNUnregisterDebugInfoParser(cstr(rawName))


# -------------------------------------------------------
# _BNUnregisterEnterpriseServerNotification

_BNUnregisterEnterpriseServerNotification = core.BNUnregisterEnterpriseServerNotification
_BNUnregisterEnterpriseServerNotification.restype = None
_BNUnregisterEnterpriseServerNotification.argtypes = [
		ctypes.POINTER(BNEnterpriseServerCallbacks),
	]


# noinspection PyPep8Naming
def BNUnregisterEnterpriseServerNotification(
		notify: ctypes.POINTER(BNEnterpriseServerCallbacks)
		) -> None:
	return _BNUnregisterEnterpriseServerNotification(notify)


# -------------------------------------------------------
# _BNUnregisterLogListener

_BNUnregisterLogListener = core.BNUnregisterLogListener
_BNUnregisterLogListener.restype = None
_BNUnregisterLogListener.argtypes = [
		ctypes.POINTER(BNLogListener),
	]


# noinspection PyPep8Naming
def BNUnregisterLogListener(
		listener: ctypes.POINTER(BNLogListener)
		) -> None:
	return _BNUnregisterLogListener(listener)


# -------------------------------------------------------
# _BNUnregisterObjectDestructionCallbacks

_BNUnregisterObjectDestructionCallbacks = core.BNUnregisterObjectDestructionCallbacks
_BNUnregisterObjectDestructionCallbacks.restype = None
_BNUnregisterObjectDestructionCallbacks.argtypes = [
		ctypes.POINTER(BNObjectDestructionCallbacks),
	]


# noinspection PyPep8Naming
def BNUnregisterObjectDestructionCallbacks(
		callbacks: ctypes.POINTER(BNObjectDestructionCallbacks)
		) -> None:
	return _BNUnregisterObjectDestructionCallbacks(callbacks)


# -------------------------------------------------------
# _BNUnregisterObjectRefDebugTrace

_BNUnregisterObjectRefDebugTrace = core.BNUnregisterObjectRefDebugTrace
_BNUnregisterObjectRefDebugTrace.restype = None
_BNUnregisterObjectRefDebugTrace.argtypes = [
		ctypes.c_char_p,
		ctypes.c_void_p,
	]


# noinspection PyPep8Naming
def BNUnregisterObjectRefDebugTrace(
		typeName: Optional[str], 
		trace: Optional[ctypes.c_void_p]
		) -> None:
	return _BNUnregisterObjectRefDebugTrace(cstr(typeName), trace)


# -------------------------------------------------------
# _BNUnregisterProjectNotification

_BNUnregisterProjectNotification = core.BNUnregisterProjectNotification
_BNUnregisterProjectNotification.restype = None
_BNUnregisterProjectNotification.argtypes = [
		ctypes.POINTER(BNProject),
		ctypes.POINTER(BNProjectNotification),
	]


# noinspection PyPep8Naming
def BNUnregisterProjectNotification(
		project: ctypes.POINTER(BNProject), 
		notify: ctypes.POINTER(BNProjectNotification)
		) -> None:
	return _BNUnregisterProjectNotification(project, notify)


# -------------------------------------------------------
# _BNUnregisterScriptingInstanceOutputListener

_BNUnregisterScriptingInstanceOutputListener = core.BNUnregisterScriptingInstanceOutputListener
_BNUnregisterScriptingInstanceOutputListener.restype = None
_BNUnregisterScriptingInstanceOutputListener.argtypes = [
		ctypes.POINTER(BNScriptingInstance),
		ctypes.POINTER(BNScriptingOutputListener),
	]


# noinspection PyPep8Naming
def BNUnregisterScriptingInstanceOutputListener(
		instance: ctypes.POINTER(BNScriptingInstance), 
		callbacks: ctypes.POINTER(BNScriptingOutputListener)
		) -> None:
	return _BNUnregisterScriptingInstanceOutputListener(instance, callbacks)


# -------------------------------------------------------
# _BNUnregisterTypeArchiveNotification

_BNUnregisterTypeArchiveNotification = core.BNUnregisterTypeArchiveNotification
_BNUnregisterTypeArchiveNotification.restype = None
_BNUnregisterTypeArchiveNotification.argtypes = [
		ctypes.POINTER(BNTypeArchive),
		ctypes.POINTER(BNTypeArchiveNotification),
	]


# noinspection PyPep8Naming
def BNUnregisterTypeArchiveNotification(
		archive: ctypes.POINTER(BNTypeArchive), 
		notification: ctypes.POINTER(BNTypeArchiveNotification)
		) -> None:
	return _BNUnregisterTypeArchiveNotification(archive, notification)


# -------------------------------------------------------
# _BNUnregisterViewOfType

_BNUnregisterViewOfType = core.BNUnregisterViewOfType
_BNUnregisterViewOfType.restype = None
_BNUnregisterViewOfType.argtypes = [
		ctypes.POINTER(BNFileMetadata),
		ctypes.c_char_p,
		ctypes.POINTER(BNBinaryView),
	]


# noinspection PyPep8Naming
def BNUnregisterViewOfType(
		file: ctypes.POINTER(BNFileMetadata), 
		type: Optional[str], 
		view: ctypes.POINTER(BNBinaryView)
		) -> None:
	return _BNUnregisterViewOfType(file, cstr(type), view)


# -------------------------------------------------------
# _BNUnsplitVariable

_BNUnsplitVariable = core.BNUnsplitVariable
_BNUnsplitVariable.restype = None
_BNUnsplitVariable.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNVariable),
	]


# noinspection PyPep8Naming
def BNUnsplitVariable(
		func: ctypes.POINTER(BNFunction), 
		var: ctypes.POINTER(BNVariable)
		) -> None:
	return _BNUnsplitVariable(func, var)


# -------------------------------------------------------
# _BNUpdateAnalysis

_BNUpdateAnalysis = core.BNUpdateAnalysis
_BNUpdateAnalysis.restype = None
_BNUpdateAnalysis.argtypes = [
		ctypes.POINTER(BNBinaryView),
	]


# noinspection PyPep8Naming
def BNUpdateAnalysis(
		view: ctypes.POINTER(BNBinaryView)
		) -> None:
	return _BNUpdateAnalysis(view)


# -------------------------------------------------------
# _BNUpdateAnalysisAndWait

_BNUpdateAnalysisAndWait = core.BNUpdateAnalysisAndWait
_BNUpdateAnalysisAndWait.restype = None
_BNUpdateAnalysisAndWait.argtypes = [
		ctypes.POINTER(BNBinaryView),
	]


# noinspection PyPep8Naming
def BNUpdateAnalysisAndWait(
		view: ctypes.POINTER(BNBinaryView)
		) -> None:
	return _BNUpdateAnalysisAndWait(view)


# -------------------------------------------------------
# _BNUpdateEnterpriseServerLicense

_BNUpdateEnterpriseServerLicense = core.BNUpdateEnterpriseServerLicense
_BNUpdateEnterpriseServerLicense.restype = ctypes.c_bool
_BNUpdateEnterpriseServerLicense.argtypes = [
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNUpdateEnterpriseServerLicense(
		timeout: int
		) -> bool:
	return _BNUpdateEnterpriseServerLicense(timeout)


# -------------------------------------------------------
# _BNUpdateFlowGraph

_BNUpdateFlowGraph = core.BNUpdateFlowGraph
_BNUpdateFlowGraph.restype = ctypes.POINTER(BNFlowGraph)
_BNUpdateFlowGraph.argtypes = [
		ctypes.POINTER(BNFlowGraph),
	]


# noinspection PyPep8Naming
def BNUpdateFlowGraph(
		graph: ctypes.POINTER(BNFlowGraph)
		) -> Optional[ctypes.POINTER(BNFlowGraph)]:
	result = _BNUpdateFlowGraph(graph)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNUpdateHighLevelILOperand

_BNUpdateHighLevelILOperand = core.BNUpdateHighLevelILOperand
_BNUpdateHighLevelILOperand.restype = None
_BNUpdateHighLevelILOperand.argtypes = [
		ctypes.POINTER(BNHighLevelILFunction),
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNUpdateHighLevelILOperand(
		func: ctypes.POINTER(BNHighLevelILFunction), 
		instr: int, 
		operandIndex: int, 
		value: int
		) -> None:
	return _BNUpdateHighLevelILOperand(func, instr, operandIndex, value)


# -------------------------------------------------------
# _BNUpdateLogListeners

_BNUpdateLogListeners = core.BNUpdateLogListeners
_BNUpdateLogListeners.restype = None
_BNUpdateLogListeners.argtypes = [
	]


# noinspection PyPep8Naming
def BNUpdateLogListeners(
		) -> None:
	return _BNUpdateLogListeners()


# -------------------------------------------------------
# _BNUpdateLowLevelILOperand

_BNUpdateLowLevelILOperand = core.BNUpdateLowLevelILOperand
_BNUpdateLowLevelILOperand.restype = None
_BNUpdateLowLevelILOperand.argtypes = [
		ctypes.POINTER(BNLowLevelILFunction),
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNUpdateLowLevelILOperand(
		func: ctypes.POINTER(BNLowLevelILFunction), 
		instr: int, 
		operandIndex: int, 
		value: int
		) -> None:
	return _BNUpdateLowLevelILOperand(func, instr, operandIndex, value)


# -------------------------------------------------------
# _BNUpdateMediumLevelILOperand

_BNUpdateMediumLevelILOperand = core.BNUpdateMediumLevelILOperand
_BNUpdateMediumLevelILOperand.restype = None
_BNUpdateMediumLevelILOperand.argtypes = [
		ctypes.POINTER(BNMediumLevelILFunction),
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNUpdateMediumLevelILOperand(
		func: ctypes.POINTER(BNMediumLevelILFunction), 
		instr: int, 
		operandIndex: int, 
		value: int
		) -> None:
	return _BNUpdateMediumLevelILOperand(func, instr, operandIndex, value)


# -------------------------------------------------------
# _BNUpdateReportFlowGraph

_BNUpdateReportFlowGraph = core.BNUpdateReportFlowGraph
_BNUpdateReportFlowGraph.restype = None
_BNUpdateReportFlowGraph.argtypes = [
		ctypes.POINTER(BNReportCollection),
		ctypes.c_ulonglong,
		ctypes.POINTER(BNFlowGraph),
	]


# noinspection PyPep8Naming
def BNUpdateReportFlowGraph(
		reports: ctypes.POINTER(BNReportCollection), 
		i: int, 
		graph: ctypes.POINTER(BNFlowGraph)
		) -> None:
	return _BNUpdateReportFlowGraph(reports, i, graph)


# -------------------------------------------------------
# _BNUpdateToLatestVersion

_BNUpdateToLatestVersion = core.BNUpdateToLatestVersion
_BNUpdateToLatestVersion.restype = UpdateResultEnum
_BNUpdateToLatestVersion.argtypes = [
		ctypes.c_char_p,
		ctypes.POINTER(ctypes.c_char_p),
		ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong),
		ctypes.c_void_p,
	]


# noinspection PyPep8Naming
def BNUpdateToLatestVersion(
		channel: Optional[str], 
		errors: ctypes.POINTER(ctypes.c_char_p), 
		progress: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong), 
		context: Optional[ctypes.c_void_p]
		) -> UpdateResult:
	return _BNUpdateToLatestVersion(cstr(channel), errors, progress, context)


# -------------------------------------------------------
# _BNUpdateToVersion

_BNUpdateToVersion = core.BNUpdateToVersion
_BNUpdateToVersion.restype = UpdateResultEnum
_BNUpdateToVersion.argtypes = [
		ctypes.c_char_p,
		ctypes.c_char_p,
		ctypes.POINTER(ctypes.c_char_p),
		ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong),
		ctypes.c_void_p,
	]


# noinspection PyPep8Naming
def BNUpdateToVersion(
		channel: Optional[str], 
		version: Optional[str], 
		errors: ctypes.POINTER(ctypes.c_char_p), 
		progress: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong), 
		context: Optional[ctypes.c_void_p]
		) -> UpdateResult:
	return _BNUpdateToVersion(cstr(channel), cstr(version), errors, progress, context)


# -------------------------------------------------------
# _BNUpdatesChecked

_BNUpdatesChecked = core.BNUpdatesChecked
_BNUpdatesChecked.restype = None
_BNUpdatesChecked.argtypes = [
	]


# noinspection PyPep8Naming
def BNUpdatesChecked(
		) -> None:
	return _BNUpdatesChecked()


# -------------------------------------------------------
# _BNWaitForMainThreadAction

_BNWaitForMainThreadAction = core.BNWaitForMainThreadAction
_BNWaitForMainThreadAction.restype = None
_BNWaitForMainThreadAction.argtypes = [
		ctypes.POINTER(BNMainThreadAction),
	]


# noinspection PyPep8Naming
def BNWaitForMainThreadAction(
		action: ctypes.POINTER(BNMainThreadAction)
		) -> None:
	return _BNWaitForMainThreadAction(action)


# -------------------------------------------------------
# _BNWasFunctionAutomaticallyDiscovered

_BNWasFunctionAutomaticallyDiscovered = core.BNWasFunctionAutomaticallyDiscovered
_BNWasFunctionAutomaticallyDiscovered.restype = ctypes.c_bool
_BNWasFunctionAutomaticallyDiscovered.argtypes = [
		ctypes.POINTER(BNFunction),
	]


# noinspection PyPep8Naming
def BNWasFunctionAutomaticallyDiscovered(
		func: ctypes.POINTER(BNFunction)
		) -> bool:
	return _BNWasFunctionAutomaticallyDiscovered(func)


# -------------------------------------------------------
# _BNWorkerEnqueue

_BNWorkerEnqueue = core.BNWorkerEnqueue
_BNWorkerEnqueue.restype = None
_BNWorkerEnqueue.argtypes = [
		ctypes.c_void_p,
		ctypes.CFUNCTYPE(None, ctypes.c_void_p),
	]


# noinspection PyPep8Naming
def BNWorkerEnqueue(
		ctxt: Optional[ctypes.c_void_p], 
		action: ctypes.CFUNCTYPE(None, ctypes.c_void_p)
		) -> None:
	return _BNWorkerEnqueue(ctxt, action)


# -------------------------------------------------------
# _BNWorkerEnqueueNamed

_BNWorkerEnqueueNamed = core.BNWorkerEnqueueNamed
_BNWorkerEnqueueNamed.restype = None
_BNWorkerEnqueueNamed.argtypes = [
		ctypes.c_void_p,
		ctypes.CFUNCTYPE(None, ctypes.c_void_p),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNWorkerEnqueueNamed(
		ctxt: Optional[ctypes.c_void_p], 
		action: ctypes.CFUNCTYPE(None, ctypes.c_void_p), 
		name: Optional[str]
		) -> None:
	return _BNWorkerEnqueueNamed(ctxt, action, cstr(name))


# -------------------------------------------------------
# _BNWorkerInteractiveEnqueue

_BNWorkerInteractiveEnqueue = core.BNWorkerInteractiveEnqueue
_BNWorkerInteractiveEnqueue.restype = None
_BNWorkerInteractiveEnqueue.argtypes = [
		ctypes.c_void_p,
		ctypes.CFUNCTYPE(None, ctypes.c_void_p),
	]


# noinspection PyPep8Naming
def BNWorkerInteractiveEnqueue(
		ctxt: Optional[ctypes.c_void_p], 
		action: ctypes.CFUNCTYPE(None, ctypes.c_void_p)
		) -> None:
	return _BNWorkerInteractiveEnqueue(ctxt, action)


# -------------------------------------------------------
# _BNWorkerInteractiveEnqueueNamed

_BNWorkerInteractiveEnqueueNamed = core.BNWorkerInteractiveEnqueueNamed
_BNWorkerInteractiveEnqueueNamed.restype = None
_BNWorkerInteractiveEnqueueNamed.argtypes = [
		ctypes.c_void_p,
		ctypes.CFUNCTYPE(None, ctypes.c_void_p),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNWorkerInteractiveEnqueueNamed(
		ctxt: Optional[ctypes.c_void_p], 
		action: ctypes.CFUNCTYPE(None, ctypes.c_void_p), 
		name: Optional[str]
		) -> None:
	return _BNWorkerInteractiveEnqueueNamed(ctxt, action, cstr(name))


# -------------------------------------------------------
# _BNWorkerPriorityEnqueue

_BNWorkerPriorityEnqueue = core.BNWorkerPriorityEnqueue
_BNWorkerPriorityEnqueue.restype = None
_BNWorkerPriorityEnqueue.argtypes = [
		ctypes.c_void_p,
		ctypes.CFUNCTYPE(None, ctypes.c_void_p),
	]


# noinspection PyPep8Naming
def BNWorkerPriorityEnqueue(
		ctxt: Optional[ctypes.c_void_p], 
		action: ctypes.CFUNCTYPE(None, ctypes.c_void_p)
		) -> None:
	return _BNWorkerPriorityEnqueue(ctxt, action)


# -------------------------------------------------------
# _BNWorkerPriorityEnqueueNamed

_BNWorkerPriorityEnqueueNamed = core.BNWorkerPriorityEnqueueNamed
_BNWorkerPriorityEnqueueNamed.restype = None
_BNWorkerPriorityEnqueueNamed.argtypes = [
		ctypes.c_void_p,
		ctypes.CFUNCTYPE(None, ctypes.c_void_p),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNWorkerPriorityEnqueueNamed(
		ctxt: Optional[ctypes.c_void_p], 
		action: ctypes.CFUNCTYPE(None, ctypes.c_void_p), 
		name: Optional[str]
		) -> None:
	return _BNWorkerPriorityEnqueueNamed(ctxt, action, cstr(name))


# -------------------------------------------------------
# _BNWorkflowAssignSubactivities

_BNWorkflowAssignSubactivities = core.BNWorkflowAssignSubactivities
_BNWorkflowAssignSubactivities.restype = ctypes.c_bool
_BNWorkflowAssignSubactivities.argtypes = [
		ctypes.POINTER(BNWorkflow),
		ctypes.c_char_p,
		ctypes.POINTER(ctypes.c_char_p),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNWorkflowAssignSubactivities(
		workflow: ctypes.POINTER(BNWorkflow), 
		activity: Optional[str], 
		activities: ctypes.POINTER(ctypes.c_char_p), 
		size: int
		) -> bool:
	return _BNWorkflowAssignSubactivities(workflow, cstr(activity), activities, size)


# -------------------------------------------------------
# _BNWorkflowClear

_BNWorkflowClear = core.BNWorkflowClear
_BNWorkflowClear.restype = ctypes.c_bool
_BNWorkflowClear.argtypes = [
		ctypes.POINTER(BNWorkflow),
	]


# noinspection PyPep8Naming
def BNWorkflowClear(
		workflow: ctypes.POINTER(BNWorkflow)
		) -> bool:
	return _BNWorkflowClear(workflow)


# -------------------------------------------------------
# _BNWorkflowClone

_BNWorkflowClone = core.BNWorkflowClone
_BNWorkflowClone.restype = ctypes.POINTER(BNWorkflow)
_BNWorkflowClone.argtypes = [
		ctypes.POINTER(BNWorkflow),
		ctypes.c_char_p,
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNWorkflowClone(
		workflow: ctypes.POINTER(BNWorkflow), 
		name: Optional[str], 
		activity: Optional[str]
		) -> Optional[ctypes.POINTER(BNWorkflow)]:
	result = _BNWorkflowClone(workflow, cstr(name), cstr(activity))
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNWorkflowContains

_BNWorkflowContains = core.BNWorkflowContains
_BNWorkflowContains.restype = ctypes.c_bool
_BNWorkflowContains.argtypes = [
		ctypes.POINTER(BNWorkflow),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNWorkflowContains(
		workflow: ctypes.POINTER(BNWorkflow), 
		activity: Optional[str]
		) -> bool:
	return _BNWorkflowContains(workflow, cstr(activity))


# -------------------------------------------------------
# _BNWorkflowGetActivity

_BNWorkflowGetActivity = core.BNWorkflowGetActivity
_BNWorkflowGetActivity.restype = ctypes.POINTER(BNActivity)
_BNWorkflowGetActivity.argtypes = [
		ctypes.POINTER(BNWorkflow),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNWorkflowGetActivity(
		workflow: ctypes.POINTER(BNWorkflow), 
		activity: Optional[str]
		) -> Optional[ctypes.POINTER(BNActivity)]:
	result = _BNWorkflowGetActivity(workflow, cstr(activity))
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNWorkflowGetActivityRoots

_BNWorkflowGetActivityRoots = core.BNWorkflowGetActivityRoots
_BNWorkflowGetActivityRoots.restype = ctypes.POINTER(ctypes.c_char_p)
_BNWorkflowGetActivityRoots.argtypes = [
		ctypes.POINTER(BNWorkflow),
		ctypes.c_char_p,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNWorkflowGetActivityRoots(
		workflow: ctypes.POINTER(BNWorkflow), 
		activity: Optional[str], 
		inoutSize: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_char_p)]:
	result = _BNWorkflowGetActivityRoots(workflow, cstr(activity), inoutSize)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNWorkflowGetConfiguration

_BNWorkflowGetConfiguration = core.BNWorkflowGetConfiguration
_BNWorkflowGetConfiguration.restype = ctypes.POINTER(ctypes.c_byte)
_BNWorkflowGetConfiguration.argtypes = [
		ctypes.POINTER(BNWorkflow),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNWorkflowGetConfiguration(
		workflow: ctypes.POINTER(BNWorkflow), 
		activity: Optional[str]
		) -> Optional[Optional[str]]:
	result = _BNWorkflowGetConfiguration(workflow, cstr(activity))
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNWorkflowGetGraph

_BNWorkflowGetGraph = core.BNWorkflowGetGraph
_BNWorkflowGetGraph.restype = ctypes.POINTER(BNFlowGraph)
_BNWorkflowGetGraph.argtypes = [
		ctypes.POINTER(BNWorkflow),
		ctypes.c_char_p,
		ctypes.c_bool,
	]


# noinspection PyPep8Naming
def BNWorkflowGetGraph(
		workflow: ctypes.POINTER(BNWorkflow), 
		activity: Optional[str], 
		sequential: bool
		) -> Optional[ctypes.POINTER(BNFlowGraph)]:
	result = _BNWorkflowGetGraph(workflow, cstr(activity), sequential)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNWorkflowGetSubactivities

_BNWorkflowGetSubactivities = core.BNWorkflowGetSubactivities
_BNWorkflowGetSubactivities.restype = ctypes.POINTER(ctypes.c_char_p)
_BNWorkflowGetSubactivities.argtypes = [
		ctypes.POINTER(BNWorkflow),
		ctypes.c_char_p,
		ctypes.c_bool,
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNWorkflowGetSubactivities(
		workflow: ctypes.POINTER(BNWorkflow), 
		activity: Optional[str], 
		immediate: bool, 
		inoutSize: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_char_p)]:
	result = _BNWorkflowGetSubactivities(workflow, cstr(activity), immediate, inoutSize)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNWorkflowInsert

_BNWorkflowInsert = core.BNWorkflowInsert
_BNWorkflowInsert.restype = ctypes.c_bool
_BNWorkflowInsert.argtypes = [
		ctypes.POINTER(BNWorkflow),
		ctypes.c_char_p,
		ctypes.POINTER(ctypes.c_char_p),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNWorkflowInsert(
		workflow: ctypes.POINTER(BNWorkflow), 
		activity: Optional[str], 
		activities: ctypes.POINTER(ctypes.c_char_p), 
		size: int
		) -> bool:
	return _BNWorkflowInsert(workflow, cstr(activity), activities, size)


# -------------------------------------------------------
# _BNWorkflowInstance

_BNWorkflowInstance = core.BNWorkflowInstance
_BNWorkflowInstance.restype = ctypes.POINTER(BNWorkflow)
_BNWorkflowInstance.argtypes = [
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNWorkflowInstance(
		name: Optional[str]
		) -> Optional[ctypes.POINTER(BNWorkflow)]:
	result = _BNWorkflowInstance(cstr(name))
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNWorkflowIsRegistered

_BNWorkflowIsRegistered = core.BNWorkflowIsRegistered
_BNWorkflowIsRegistered.restype = ctypes.c_bool
_BNWorkflowIsRegistered.argtypes = [
		ctypes.POINTER(BNWorkflow),
	]


# noinspection PyPep8Naming
def BNWorkflowIsRegistered(
		workflow: ctypes.POINTER(BNWorkflow)
		) -> bool:
	return _BNWorkflowIsRegistered(workflow)


# -------------------------------------------------------
# _BNWorkflowRegisterActivity

_BNWorkflowRegisterActivity = core.BNWorkflowRegisterActivity
_BNWorkflowRegisterActivity.restype = ctypes.POINTER(BNActivity)
_BNWorkflowRegisterActivity.argtypes = [
		ctypes.POINTER(BNWorkflow),
		ctypes.POINTER(BNActivity),
		ctypes.POINTER(ctypes.c_char_p),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNWorkflowRegisterActivity(
		workflow: ctypes.POINTER(BNWorkflow), 
		activity: ctypes.POINTER(BNActivity), 
		subactivities: ctypes.POINTER(ctypes.c_char_p), 
		size: int
		) -> Optional[ctypes.POINTER(BNActivity)]:
	result = _BNWorkflowRegisterActivity(workflow, activity, subactivities, size)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNWorkflowRemove

_BNWorkflowRemove = core.BNWorkflowRemove
_BNWorkflowRemove.restype = ctypes.c_bool
_BNWorkflowRemove.argtypes = [
		ctypes.POINTER(BNWorkflow),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNWorkflowRemove(
		workflow: ctypes.POINTER(BNWorkflow), 
		activity: Optional[str]
		) -> bool:
	return _BNWorkflowRemove(workflow, cstr(activity))


# -------------------------------------------------------
# _BNWorkflowReplace

_BNWorkflowReplace = core.BNWorkflowReplace
_BNWorkflowReplace.restype = ctypes.c_bool
_BNWorkflowReplace.argtypes = [
		ctypes.POINTER(BNWorkflow),
		ctypes.c_char_p,
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNWorkflowReplace(
		workflow: ctypes.POINTER(BNWorkflow), 
		activity: Optional[str], 
		newActivity: Optional[str]
		) -> bool:
	return _BNWorkflowReplace(workflow, cstr(activity), cstr(newActivity))


# -------------------------------------------------------
# _BNWorkflowShowReport

_BNWorkflowShowReport = core.BNWorkflowShowReport
_BNWorkflowShowReport.restype = None
_BNWorkflowShowReport.argtypes = [
		ctypes.POINTER(BNWorkflow),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNWorkflowShowReport(
		workflow: ctypes.POINTER(BNWorkflow), 
		name: Optional[str]
		) -> None:
	return _BNWorkflowShowReport(workflow, cstr(name))


# -------------------------------------------------------
# _BNWorkflowSize

_BNWorkflowSize = core.BNWorkflowSize
_BNWorkflowSize.restype = ctypes.c_ulonglong
_BNWorkflowSize.argtypes = [
		ctypes.POINTER(BNWorkflow),
	]


# noinspection PyPep8Naming
def BNWorkflowSize(
		workflow: ctypes.POINTER(BNWorkflow)
		) -> int:
	return _BNWorkflowSize(workflow)


# -------------------------------------------------------
# _BNWrite16

_BNWrite16 = core.BNWrite16
_BNWrite16.restype = ctypes.c_bool
_BNWrite16.argtypes = [
		ctypes.POINTER(BNBinaryWriter),
		ctypes.c_ushort,
	]


# noinspection PyPep8Naming
def BNWrite16(
		stream: ctypes.POINTER(BNBinaryWriter), 
		val: int
		) -> bool:
	return _BNWrite16(stream, val)


# -------------------------------------------------------
# _BNWrite32

_BNWrite32 = core.BNWrite32
_BNWrite32.restype = ctypes.c_bool
_BNWrite32.argtypes = [
		ctypes.POINTER(BNBinaryWriter),
		ctypes.c_uint,
	]


# noinspection PyPep8Naming
def BNWrite32(
		stream: ctypes.POINTER(BNBinaryWriter), 
		val: int
		) -> bool:
	return _BNWrite32(stream, val)


# -------------------------------------------------------
# _BNWrite64

_BNWrite64 = core.BNWrite64
_BNWrite64.restype = ctypes.c_bool
_BNWrite64.argtypes = [
		ctypes.POINTER(BNBinaryWriter),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNWrite64(
		stream: ctypes.POINTER(BNBinaryWriter), 
		val: int
		) -> bool:
	return _BNWrite64(stream, val)


# -------------------------------------------------------
# _BNWrite8

_BNWrite8 = core.BNWrite8
_BNWrite8.restype = ctypes.c_bool
_BNWrite8.argtypes = [
		ctypes.POINTER(BNBinaryWriter),
		ctypes.c_ubyte,
	]


# noinspection PyPep8Naming
def BNWrite8(
		stream: ctypes.POINTER(BNBinaryWriter), 
		val: int
		) -> bool:
	return _BNWrite8(stream, val)


# -------------------------------------------------------
# _BNWriteBE16

_BNWriteBE16 = core.BNWriteBE16
_BNWriteBE16.restype = ctypes.c_bool
_BNWriteBE16.argtypes = [
		ctypes.POINTER(BNBinaryWriter),
		ctypes.c_ushort,
	]


# noinspection PyPep8Naming
def BNWriteBE16(
		stream: ctypes.POINTER(BNBinaryWriter), 
		val: int
		) -> bool:
	return _BNWriteBE16(stream, val)


# -------------------------------------------------------
# _BNWriteBE32

_BNWriteBE32 = core.BNWriteBE32
_BNWriteBE32.restype = ctypes.c_bool
_BNWriteBE32.argtypes = [
		ctypes.POINTER(BNBinaryWriter),
		ctypes.c_uint,
	]


# noinspection PyPep8Naming
def BNWriteBE32(
		stream: ctypes.POINTER(BNBinaryWriter), 
		val: int
		) -> bool:
	return _BNWriteBE32(stream, val)


# -------------------------------------------------------
# _BNWriteBE64

_BNWriteBE64 = core.BNWriteBE64
_BNWriteBE64.restype = ctypes.c_bool
_BNWriteBE64.argtypes = [
		ctypes.POINTER(BNBinaryWriter),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNWriteBE64(
		stream: ctypes.POINTER(BNBinaryWriter), 
		val: int
		) -> bool:
	return _BNWriteBE64(stream, val)


# -------------------------------------------------------
# _BNWriteData

_BNWriteData = core.BNWriteData
_BNWriteData.restype = ctypes.c_bool
_BNWriteData.argtypes = [
		ctypes.POINTER(BNBinaryWriter),
		ctypes.c_void_p,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNWriteData(
		stream: ctypes.POINTER(BNBinaryWriter), 
		src: Optional[ctypes.c_void_p], 
		len: int
		) -> bool:
	return _BNWriteData(stream, src, len)


# -------------------------------------------------------
# _BNWriteDataForDownloadInstance

_BNWriteDataForDownloadInstance = core.BNWriteDataForDownloadInstance
_BNWriteDataForDownloadInstance.restype = ctypes.c_ulonglong
_BNWriteDataForDownloadInstance.argtypes = [
		ctypes.POINTER(BNDownloadInstance),
		ctypes.POINTER(ctypes.c_ubyte),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNWriteDataForDownloadInstance(
		instance: ctypes.POINTER(BNDownloadInstance), 
		data: ctypes.POINTER(ctypes.c_ubyte), 
		len: int
		) -> int:
	return _BNWriteDataForDownloadInstance(instance, data, len)


# -------------------------------------------------------
# _BNWriteDatabaseAnalysisCache

_BNWriteDatabaseAnalysisCache = core.BNWriteDatabaseAnalysisCache
_BNWriteDatabaseAnalysisCache.restype = ctypes.c_bool
_BNWriteDatabaseAnalysisCache.argtypes = [
		ctypes.POINTER(BNDatabase),
		ctypes.POINTER(BNKeyValueStore),
	]


# noinspection PyPep8Naming
def BNWriteDatabaseAnalysisCache(
		database: ctypes.POINTER(BNDatabase), 
		val: ctypes.POINTER(BNKeyValueStore)
		) -> bool:
	return _BNWriteDatabaseAnalysisCache(database, val)


# -------------------------------------------------------
# _BNWriteDatabaseGlobal

_BNWriteDatabaseGlobal = core.BNWriteDatabaseGlobal
_BNWriteDatabaseGlobal.restype = ctypes.c_bool
_BNWriteDatabaseGlobal.argtypes = [
		ctypes.POINTER(BNDatabase),
		ctypes.c_char_p,
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNWriteDatabaseGlobal(
		database: ctypes.POINTER(BNDatabase), 
		key: Optional[str], 
		val: Optional[str]
		) -> bool:
	return _BNWriteDatabaseGlobal(database, cstr(key), cstr(val))


# -------------------------------------------------------
# _BNWriteDatabaseGlobalData

_BNWriteDatabaseGlobalData = core.BNWriteDatabaseGlobalData
_BNWriteDatabaseGlobalData.restype = ctypes.c_bool
_BNWriteDatabaseGlobalData.argtypes = [
		ctypes.POINTER(BNDatabase),
		ctypes.c_char_p,
		ctypes.POINTER(BNDataBuffer),
	]


# noinspection PyPep8Naming
def BNWriteDatabaseGlobalData(
		database: ctypes.POINTER(BNDatabase), 
		key: Optional[str], 
		val: ctypes.POINTER(BNDataBuffer)
		) -> bool:
	return _BNWriteDatabaseGlobalData(database, cstr(key), val)


# -------------------------------------------------------
# _BNWriteDatabaseSnapshotData

_BNWriteDatabaseSnapshotData = core.BNWriteDatabaseSnapshotData
_BNWriteDatabaseSnapshotData.restype = ctypes.c_longlong
_BNWriteDatabaseSnapshotData.argtypes = [
		ctypes.POINTER(BNDatabase),
		ctypes.POINTER(ctypes.c_longlong),
		ctypes.c_ulonglong,
		ctypes.POINTER(BNBinaryView),
		ctypes.c_char_p,
		ctypes.POINTER(BNKeyValueStore),
		ctypes.c_bool,
		ctypes.c_void_p,
		ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNWriteDatabaseSnapshotData(
		database: ctypes.POINTER(BNDatabase), 
		parents: ctypes.POINTER(ctypes.c_longlong), 
		parentCount: int, 
		file: ctypes.POINTER(BNBinaryView), 
		name: Optional[str], 
		data: ctypes.POINTER(BNKeyValueStore), 
		autoSave: bool, 
		ctxt: Optional[ctypes.c_void_p], 
		progress: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong)
		) -> int:
	return _BNWriteDatabaseSnapshotData(database, parents, parentCount, file, cstr(name), data, autoSave, ctxt, progress)


# -------------------------------------------------------
# _BNWriteLE16

_BNWriteLE16 = core.BNWriteLE16
_BNWriteLE16.restype = ctypes.c_bool
_BNWriteLE16.argtypes = [
		ctypes.POINTER(BNBinaryWriter),
		ctypes.c_ushort,
	]


# noinspection PyPep8Naming
def BNWriteLE16(
		stream: ctypes.POINTER(BNBinaryWriter), 
		val: int
		) -> bool:
	return _BNWriteLE16(stream, val)


# -------------------------------------------------------
# _BNWriteLE32

_BNWriteLE32 = core.BNWriteLE32
_BNWriteLE32.restype = ctypes.c_bool
_BNWriteLE32.argtypes = [
		ctypes.POINTER(BNBinaryWriter),
		ctypes.c_uint,
	]


# noinspection PyPep8Naming
def BNWriteLE32(
		stream: ctypes.POINTER(BNBinaryWriter), 
		val: int
		) -> bool:
	return _BNWriteLE32(stream, val)


# -------------------------------------------------------
# _BNWriteLE64

_BNWriteLE64 = core.BNWriteLE64
_BNWriteLE64.restype = ctypes.c_bool
_BNWriteLE64.argtypes = [
		ctypes.POINTER(BNBinaryWriter),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNWriteLE64(
		stream: ctypes.POINTER(BNBinaryWriter), 
		val: int
		) -> bool:
	return _BNWriteLE64(stream, val)


# -------------------------------------------------------
# _BNWriteTypeLibraryToFile

_BNWriteTypeLibraryToFile = core.BNWriteTypeLibraryToFile
_BNWriteTypeLibraryToFile.restype = None
_BNWriteTypeLibraryToFile.argtypes = [
		ctypes.POINTER(BNTypeLibrary),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNWriteTypeLibraryToFile(
		lib: ctypes.POINTER(BNTypeLibrary), 
		path: Optional[str]
		) -> None:
	return _BNWriteTypeLibraryToFile(lib, cstr(path))


# -------------------------------------------------------
# _BNWriteViewBuffer

_BNWriteViewBuffer = core.BNWriteViewBuffer
_BNWriteViewBuffer.restype = ctypes.c_ulonglong
_BNWriteViewBuffer.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
		ctypes.POINTER(BNDataBuffer),
	]


# noinspection PyPep8Naming
def BNWriteViewBuffer(
		view: ctypes.POINTER(BNBinaryView), 
		offset: int, 
		data: ctypes.POINTER(BNDataBuffer)
		) -> int:
	return _BNWriteViewBuffer(view, offset, data)


# -------------------------------------------------------
# _BNWriteViewData

_BNWriteViewData = core.BNWriteViewData
_BNWriteViewData.restype = ctypes.c_ulonglong
_BNWriteViewData.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
		ctypes.c_void_p,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNWriteViewData(
		view: ctypes.POINTER(BNBinaryView), 
		offset: int, 
		data: Optional[ctypes.c_void_p], 
		len: int
		) -> int:
	return _BNWriteViewData(view, offset, data, len)


# -------------------------------------------------------
# _BNWriteWebsocketClientData

_BNWriteWebsocketClientData = core.BNWriteWebsocketClientData
_BNWriteWebsocketClientData.restype = ctypes.c_ulonglong
_BNWriteWebsocketClientData.argtypes = [
		ctypes.POINTER(BNWebsocketClient),
		ctypes.POINTER(ctypes.c_ubyte),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNWriteWebsocketClientData(
		client: ctypes.POINTER(BNWebsocketClient), 
		data: ctypes.POINTER(ctypes.c_ubyte), 
		len: int
		) -> int:
	return _BNWriteWebsocketClientData(client, data, len)


# -------------------------------------------------------
# _BNZlibCompress

_BNZlibCompress = core.BNZlibCompress
_BNZlibCompress.restype = ctypes.POINTER(BNDataBuffer)
_BNZlibCompress.argtypes = [
		ctypes.POINTER(BNDataBuffer),
	]


# noinspection PyPep8Naming
def BNZlibCompress(
		buf: ctypes.POINTER(BNDataBuffer)
		) -> Optional[ctypes.POINTER(BNDataBuffer)]:
	result = _BNZlibCompress(buf)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNZlibDecompress

_BNZlibDecompress = core.BNZlibDecompress
_BNZlibDecompress.restype = ctypes.POINTER(BNDataBuffer)
_BNZlibDecompress.argtypes = [
		ctypes.POINTER(BNDataBuffer),
	]


# noinspection PyPep8Naming
def BNZlibDecompress(
		buf: ctypes.POINTER(BNDataBuffer)
		) -> Optional[ctypes.POINTER(BNDataBuffer)]:
	result = _BNZlibDecompress(buf)
	if not result:
		return None
	return result


max_confidence = 255


# Helper functions
def handle_of_type(value, handle_type):
	if isinstance(value, ctypes.POINTER(handle_type)) or isinstance(value, ctypes.c_void_p):
		return ctypes.cast(value, ctypes.POINTER(handle_type))
	raise ValueError('expected pointer to %s' % str(handle_type))

# Set path for core plugins
BNSetBundledPluginDirectory(os.path.join(_base_path, "plugins"))